Date: Sat, 14 Mar 2009 19:36:13 +0000 (UTC) From: David Schultz <das@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r189824 - in head/contrib/gcc: . doc Message-ID: <200903141936.n2EJaDM5006130@svn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: das Date: Sat Mar 14 19:36:13 2009 New Revision: 189824 URL: http://svn.freebsd.org/changeset/base/189824 Log: Make gcc use C99 inline semantics in c99 and gnu99 mode. This was the original intent, but the functionality wasn't implemented until after gcc 4.2 was released. However, if you compiled a program that would behave differently before and after this change, gcc 4.2 would have warned you; hence, everything currently in the base system is unaffected by this change. This patch also adds additional warnings about certain inline function-related bogosity, e.g., using a static non-const local variable in an inline function. These changes were merged from a snapshot of gcc mainline from March 2007, prior to the GPLv3 switch. I then ran the regression test suite from a more recent gcc snapshot and fixed the important bugs it found. I also squelched the following warning unless -pedantic is specified: foo is static but used in inline function bar which is not static This is consistent with LLVM's behavior, but not consistent with gcc 4.3. Reviewed by: arch@ Modified: head/contrib/gcc/c-cppbuiltin.c head/contrib/gcc/c-decl.c head/contrib/gcc/c-opts.c head/contrib/gcc/c-tree.h head/contrib/gcc/c-typeck.c head/contrib/gcc/doc/extend.texi Modified: head/contrib/gcc/c-cppbuiltin.c ============================================================================== --- head/contrib/gcc/c-cppbuiltin.c Sat Mar 14 19:35:13 2009 (r189823) +++ head/contrib/gcc/c-cppbuiltin.c Sat Mar 14 19:36:13 2009 (r189824) @@ -1,5 +1,6 @@ /* Define builtin-in macros for the C family front ends. - Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 + Free Software Foundation, Inc. This file is part of GCC. @@ -484,7 +485,10 @@ c_cpp_builtins (cpp_reader *pfile) /* Misc. */ builtin_define_with_value ("__VERSION__", version_string, 1); - cpp_define (pfile, "__GNUC_GNU_INLINE__"); + if (flag_gnu89_inline) + cpp_define (pfile, "__GNUC_GNU_INLINE__"); + else + cpp_define (pfile, "__GNUC_STDC_INLINE__"); /* Definitions for LP64 model. */ if (TYPE_PRECISION (long_integer_type_node) == 64 Modified: head/contrib/gcc/c-decl.c ============================================================================== --- head/contrib/gcc/c-decl.c Sat Mar 14 19:35:13 2009 (r189823) +++ head/contrib/gcc/c-decl.c Sat Mar 14 19:36:13 2009 (r189824) @@ -1,6 +1,6 @@ /* Process declarations and variables for C compiler. Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of GCC. @@ -20,6 +20,9 @@ Software Foundation, 51 Franklin Street, 02110-1301, USA. */ /* $FreeBSD$ */ +/* Merged C99 inline changes from gcc trunk 122565 2007-03-05 */ +/* Fixed problems with compiling inline-25.c and inline-26.c */ +/* XXX still fails inline-29.c, inline-31.c, and inline-32.c */ /* Process declarations and symbol lookup for C front end. Also constructs types; the standard scalar types at initialization, @@ -156,10 +159,6 @@ int current_function_returns_abnormally; static int warn_about_return_type; -/* Nonzero when starting a function declared `extern inline'. */ - -static int current_extern_inline; - /* Nonzero when the current toplevel function contains a declaration of a nested function which is never defined. */ @@ -804,6 +803,15 @@ pop_scope (void) error ("nested function %q+D declared but never defined", p); undef_nested_function = true; } + /* C99 6.7.4p6: "a function with external linkage... declared + with an inline function specifier ... shall also be defined in the + same translation unit." */ + else if (DECL_DECLARED_INLINE_P (p) + && TREE_PUBLIC (p) + && !DECL_INITIAL (p) + && !flag_gnu89_inline) + pedwarn ("inline function %q+D declared but never defined", p); + goto common_symbol; case VAR_DECL: @@ -1294,10 +1302,11 @@ diagnose_mismatched_decls (tree newdecl, /* Function declarations can either be 'static' or 'extern' (no qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore - can never conflict with each other on account of linkage (6.2.2p4). - Multiple definitions are not allowed (6.9p3,5) but GCC permits - two definitions if one is 'extern inline' and one is not. The non- - extern-inline definition supersedes the extern-inline definition. */ + can never conflict with each other on account of linkage + (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but + gnu89 mode permits two definitions if one is 'extern inline' and + one is not. The non- extern-inline definition supersedes the + extern-inline definition. */ else if (TREE_CODE (newdecl) == FUNCTION_DECL) { @@ -1323,16 +1332,18 @@ diagnose_mismatched_decls (tree newdecl, { /* If both decls are in the same TU and the new declaration isn't overriding an extern inline reject the new decl. - When we handle c99 style inline rules we'll want to reject - the following: - - DECL_EXTERN_INLINE (olddecl) - && !DECL_EXTERN_INLINE (newdecl) - - if they're in the same translation unit. Until we implement - the full semantics we accept the construct. */ - if (!(DECL_EXTERN_INLINE (olddecl) - && !DECL_EXTERN_INLINE (newdecl)) + In c99, no overriding is allowed in the same translation + unit. */ + if ((!DECL_EXTERN_INLINE (olddecl) + || DECL_EXTERN_INLINE (newdecl) + || (!flag_gnu89_inline + && (!DECL_DECLARED_INLINE_P (olddecl) + || !lookup_attribute ("gnu_inline", + DECL_ATTRIBUTES (olddecl))) + && (!DECL_DECLARED_INLINE_P (newdecl) + || !lookup_attribute ("gnu_inline", + DECL_ATTRIBUTES (newdecl)))) + ) && same_translation_unit_p (newdecl, olddecl)) { error ("redefinition of %q+D", newdecl); @@ -1392,6 +1403,23 @@ diagnose_mismatched_decls (tree newdecl, warned = true; } } + + /* Make sure gnu_inline attribute is either not present, or + present on all inline decls. */ + if (DECL_DECLARED_INLINE_P (olddecl) + && DECL_DECLARED_INLINE_P (newdecl)) + { + bool newa = lookup_attribute ("gnu_inline", + DECL_ATTRIBUTES (newdecl)) != NULL; + bool olda = lookup_attribute ("gnu_inline", + DECL_ATTRIBUTES (olddecl)) != NULL; + if (newa != olda) + { + error ("%<gnu_inline%> attribute present on %q+D", + newa ? newdecl : olddecl); + error ("%Jbut not here", newa ? olddecl : newdecl); + } + } } else if (TREE_CODE (newdecl) == VAR_DECL) { @@ -1523,9 +1551,13 @@ diagnose_mismatched_decls (tree newdecl, ??? Should we still warn about this now we have unit-at-a-time mode and can get it right? Definitely don't complain if the decls are in different translation - units. */ + units. + C99 permits this, so don't warn in that case. (The function + may not be inlined everywhere in function-at-a-time mode, but + we still shouldn't warn.) */ if (DECL_DECLARED_INLINE_P (newdecl) && !DECL_DECLARED_INLINE_P (olddecl) - && same_translation_unit_p (olddecl, newdecl)) + && same_translation_unit_p (olddecl, newdecl) + && flag_gnu89_inline) { if (TREE_USED (olddecl)) { @@ -1602,12 +1634,13 @@ diagnose_mismatched_decls (tree newdecl, static void merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype) { - int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL - && DECL_INITIAL (newdecl) != 0); - int new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL - && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0); - int old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL - && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0); + bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL + && DECL_INITIAL (newdecl) != 0); + bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL + && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0); + bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL + && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0); + bool extern_changed = false; /* For real parm decl following a forward decl, rechain the old decl in its new location and clear TREE_ASM_WRITTEN (it's not a @@ -1750,6 +1783,20 @@ merge_decls (tree newdecl, tree olddecl, } } + /* In c99, 'extern' declaration before (or after) 'inline' means this + function is not DECL_EXTERNAL, unless 'gnu_inline' attribute + is present. */ + if (TREE_CODE (newdecl) == FUNCTION_DECL + && !flag_gnu89_inline + && (DECL_DECLARED_INLINE_P (newdecl) + || DECL_DECLARED_INLINE_P (olddecl)) + && (!DECL_DECLARED_INLINE_P (newdecl) + || !DECL_DECLARED_INLINE_P (olddecl) + || !DECL_EXTERNAL (olddecl)) + && DECL_EXTERNAL (newdecl) + && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))) + DECL_EXTERNAL (newdecl) = 0; + if (DECL_EXTERNAL (newdecl)) { TREE_STATIC (newdecl) = TREE_STATIC (olddecl); @@ -1842,6 +1889,8 @@ merge_decls (tree newdecl, tree olddecl, } } + extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl); + /* Copy most of the decl-specific fields of NEWDECL into OLDDECL. But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */ { @@ -1884,6 +1933,13 @@ merge_decls (tree newdecl, tree olddecl, || (TREE_CODE (olddecl) == VAR_DECL && TREE_STATIC (olddecl)))) make_decl_rtl (olddecl); + + /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL, + and the definition is coming from the old version, cgraph needs + to be called again. */ + if (extern_changed && !new_is_definition + && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl)) + cgraph_finalize_function (olddecl, false); } /* Handle when a new declaration NEWDECL has the same name as an old @@ -3274,6 +3330,18 @@ start_decl (struct c_declarator *declara /* Set attributes here so if duplicate decl, will have proper attributes. */ decl_attributes (&decl, attributes, 0); + /* Handle gnu_inline attribute. */ + if (declspecs->inline_p + && !flag_gnu89_inline + && TREE_CODE (decl) == FUNCTION_DECL + && lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))) + { + if (declspecs->storage_class == csc_auto && current_scope != file_scope) + ; + else if (declspecs->storage_class != csc_static) + DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl); + } + if (TREE_CODE (decl) == FUNCTION_DECL && targetm.calls.promote_prototypes (TREE_TYPE (decl))) { @@ -3301,6 +3369,18 @@ start_decl (struct c_declarator *declara warning (OPT_Wattributes, "inline function %q+D given attribute noinline", decl); + /* C99 6.7.4p3: An inline definition of a function with external + linkage shall not contain a definition of a modifiable object + with static storage duration... */ + if (TREE_CODE (decl) == VAR_DECL + && current_scope != file_scope + && TREE_STATIC (decl) + && !TREE_READONLY (decl) + && DECL_DECLARED_INLINE_P (current_function_decl) + && DECL_EXTERNAL (current_function_decl)) + pedwarn ("%q+D is static but declared in inline function %qD " + "which is not static", decl, current_function_decl); + /* Add this decl to the current scope. TEM may equal DECL or it may be a previous decl of the same name. */ tem = pushdecl (decl); @@ -4755,8 +4835,16 @@ grokdeclarator (const struct c_declarato GCC to signify a forward declaration of a nested function. */ if (storage_class == csc_auto && current_scope != file_scope) DECL_EXTERNAL (decl) = 0; + /* In C99, a function which is declared 'inline' with 'extern' + is not an external reference (which is confusing). It + means that the later definition of the function must be output + in this file, C99 6.7.4p6. In GNU C89, a function declared + 'extern inline' is an external reference. */ + else if (declspecs->inline_p && storage_class != csc_static) + DECL_EXTERNAL (decl) = ((storage_class == csc_extern) + == flag_gnu89_inline); else - DECL_EXTERNAL (decl) = 1; + DECL_EXTERNAL (decl) = !initialized; /* Record absence of global scope for `static' or `auto'. */ TREE_PUBLIC (decl) @@ -4786,11 +4874,7 @@ grokdeclarator (const struct c_declarato the abstract origin pointing between the declarations, which will confuse dwarf2out. */ if (initialized) - { - DECL_INLINE (decl) = 1; - if (storage_class == csc_extern) - current_extern_inline = 1; - } + DECL_INLINE (decl) = 1; } /* If -finline-functions, assume it can be inlined. This does two things: let the function be deferred until it is actually @@ -5288,12 +5372,15 @@ start_struct (enum tree_code code, tree error ("nested redefinition of %<union %E%>", name); else error ("nested redefinition of %<struct %E%>", name); + /* Don't create structures that contain themselves. */ + ref = NULL_TREE; } } - else - { - /* Otherwise create a forward-reference just so the tag is in scope. */ + /* Otherwise create a forward-reference just so the tag is in scope. */ + + if (ref == NULL_TREE || TREE_CODE (ref) != code) + { ref = make_node (code); pushtag (name, ref); } @@ -5985,7 +6072,6 @@ start_function (struct c_declspecs *decl current_function_returns_null = 0; current_function_returns_abnormally = 0; warn_about_return_type = 0; - current_extern_inline = 0; c_switch_stack = NULL; nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se); @@ -6025,6 +6111,16 @@ start_function (struct c_declspecs *decl warning (OPT_Wattributes, "inline function %q+D given attribute noinline", decl1); + /* Handle gnu_inline attribute. */ + if (declspecs->inline_p + && !flag_gnu89_inline + && TREE_CODE (decl1) == FUNCTION_DECL + && lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))) + { + if (declspecs->storage_class != csc_static) + DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1); + } + announce_function (decl1); if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1)))) @@ -6137,36 +6233,6 @@ start_function (struct c_declspecs *decl warning (OPT_Wmissing_declarations, "%q+D was used with no declaration before its definition", decl1); - /* This is a definition, not a reference. - So normally clear DECL_EXTERNAL. - However, `extern inline' acts like a declaration - except for defining how to inline. So set DECL_EXTERNAL in that case. */ - DECL_EXTERNAL (decl1) = current_extern_inline; - - /* C99 specified different behaviour for non-static inline - functions, compared with the traditional GNU behaviour. We don't - support the C99 behaviour, but we do warn about non-static inline - functions here. The warning can be disabled via an explicit use - of -fgnu89-inline, or by using the gnu_inline attribute. */ - if (DECL_DECLARED_INLINE_P (decl1) - && TREE_PUBLIC (decl1) - && flag_isoc99 - && flag_gnu89_inline != 1 - && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1)) - && diagnostic_report_warnings_p ()) - { - static bool info = false; - - warning (0, "C99 inline functions are not supported; using GNU89"); - if (!info) - { - warning (0, - "to disable this warning use -fgnu89-inline or " - "the gnu_inline function attribute"); - info = true; - } - } - /* This function exists in static storage. (This does not mean `static' in the C sense!) */ TREE_STATIC (decl1) = 1; @@ -6942,7 +7008,6 @@ c_push_function_context (struct function p->returns_null = current_function_returns_null; p->returns_abnormally = current_function_returns_abnormally; p->warn_about_return_type = warn_about_return_type; - p->extern_inline = current_extern_inline; } /* Restore the variables used during compilation of a C function. */ @@ -6971,7 +7036,6 @@ c_pop_function_context (struct function current_function_returns_null = p->returns_null; current_function_returns_abnormally = p->returns_abnormally; warn_about_return_type = p->warn_about_return_type; - current_extern_inline = p->extern_inline; f->language = NULL; } Modified: head/contrib/gcc/c-opts.c ============================================================================== --- head/contrib/gcc/c-opts.c Sat Mar 14 19:35:13 2009 (r189823) +++ head/contrib/gcc/c-opts.c Sat Mar 14 19:36:13 2009 (r189824) @@ -21,6 +21,7 @@ Software Foundation, 51 Franklin Street, 02110-1301, USA. */ /* $FreeBSD$ */ +/* Merged C99 inline changes from gcc trunk 122565 2007-03-05 */ #include "config.h" #include "system.h" @@ -1008,11 +1009,12 @@ c_common_post_options (const char **pfil if (flag_inline_functions) flag_inline_trees = 2; - /* We recognize -fgnu89-inline in preparation for 4.3 where the - option will be meaningful. Here we just reject - -fno-gnu89-inline, since we don't support it. */ - if (!flag_gnu89_inline) - error ("-fno-gnu89-inline is not supported"); + /* By default we use C99 inline semantics in GNU99 or C99 mode. C99 + inline semantics are not supported in GNU89 or C89 mode. */ + if (flag_gnu89_inline == -1) + flag_gnu89_inline = !flag_isoc99; + else if (!flag_gnu89_inline && !flag_isoc99) + error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode"); /* If we are given more than one input file, we must use unit-at-a-time mode. */ Modified: head/contrib/gcc/c-tree.h ============================================================================== --- head/contrib/gcc/c-tree.h Sat Mar 14 19:35:13 2009 (r189823) +++ head/contrib/gcc/c-tree.h Sat Mar 14 19:36:13 2009 (r189824) @@ -384,7 +384,6 @@ struct language_function GTY(()) int returns_null; int returns_abnormally; int warn_about_return_type; - int extern_inline; }; /* Save lists of labels used or defined in particular contexts. Modified: head/contrib/gcc/c-typeck.c ============================================================================== --- head/contrib/gcc/c-typeck.c Sat Mar 14 19:35:13 2009 (r189823) +++ head/contrib/gcc/c-typeck.c Sat Mar 14 19:36:13 2009 (r189824) @@ -2109,6 +2109,19 @@ build_external_ref (tree id, int fun, lo if (context != 0 && context != current_function_decl) DECL_NONLOCAL (ref) = 1; } + /* C99 6.7.4p3: An inline definition of a function with external + linkage ... shall not contain a reference to an identifier with + internal linkage. */ + else if (current_function_decl != 0 + && DECL_DECLARED_INLINE_P (current_function_decl) + && DECL_EXTERNAL (current_function_decl) + && VAR_OR_FUNCTION_DECL_P (ref) + && DECL_FILE_SCOPE_P (ref) + && pedantic + && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref)) + && ! TREE_PUBLIC (ref)) + pedwarn ("%H%qD is static but used in inline function %qD " + "which is not static", &loc, ref, current_function_decl); return ref; } Modified: head/contrib/gcc/doc/extend.texi ============================================================================== --- head/contrib/gcc/doc/extend.texi Sat Mar 14 19:35:13 2009 (r189823) +++ head/contrib/gcc/doc/extend.texi Sat Mar 14 19:36:13 2009 (r189824) @@ -3829,66 +3829,54 @@ These attributes mainly are intended to @cindex open coding @cindex macros, inline alternative -By declaring a function @code{inline}, you can direct GCC to +By declaring a function inline, you can direct GCC to make +calls to that function faster. One way GCC can achieve this is to integrate that function's code into the code for its callers. This makes execution faster by eliminating the function-call overhead; in -addition, if any of the actual argument values are constant, their known -values may permit simplifications at compile time so that not all of the -inline function's code needs to be included. The effect on code size is -less predictable; object code may be larger or smaller with function -inlining, depending on the particular case. Inlining of functions is an -optimization and it really ``works'' only in optimizing compilation. If -you don't use @option{-O}, no function is really inline. - -Inline functions are included in the ISO C99 standard, but there are -currently substantial differences between what GCC implements and what -the ISO C99 standard requires. GCC will fully support C99 inline -functions in version 4.3. The traditional GCC handling of inline -functions will still be available with @option{-std=gnu89}, -@option{-fgnu89-inline} or when @code{gnu_inline} attribute is present -on all inline declarations. The preprocessor macros -@code{__GNUC_GNU_INLINE__} and @code{__GNUC_STDC_INLINE__} may be used -to determine the handling of @code{inline} during a particular -compilation (@pxref{Common Predefined Macros,,,cpp,The C -Preprocessor}). +addition, if any of the actual argument values are constant, their +known values may permit simplifications at compile time so that not +all of the inline function's code needs to be included. The effect on +code size is less predictable; object code may be larger or smaller +with function inlining, depending on the particular case. You can +also direct GCC to try to integrate all ``simple enough'' functions +into their callers with the option @option{-finline-functions}. + +GCC implements three different semantics of declaring a function +inline. One is available with @option{-std=gnu89}, another when +@option{-std=c99} or @option{-std=gnu99}, and the third is used when +compiling C++. To declare a function inline, use the @code{inline} keyword in its declaration, like this: @smallexample -inline int +static inline int inc (int *a) @{ (*a)++; @} @end smallexample -(If you are writing a header file to be included in ISO C programs, write -@code{__inline__} instead of @code{inline}. @xref{Alternate Keywords}.) -You can also make all ``simple enough'' functions inline with the option -@option{-finline-functions}. - -@opindex Winline -Note that certain usages in a function definition can make it unsuitable -for inline substitution. Among these usages are: use of varargs, use of -alloca, use of variable sized data types (@pxref{Variable Length}), -use of computed goto (@pxref{Labels as Values}), use of nonlocal goto, -and nested functions (@pxref{Nested Functions}). Using @option{-Winline} -will warn when a function marked @code{inline} could not be substituted, -and will give the reason for the failure. +If you are writing a header file to be included in ISO C89 programs, write +@code{__inline__} instead of @code{inline}. @xref{Alternate Keywords}. -Note that in C and Objective-C, unlike C++, the @code{inline} keyword -does not affect the linkage of the function. +The three types of inlining behave similarly in two important cases: +when the @code{inline} keyword is used on a @code{static} function, +like the example above, and when a function is first declared without +using the @code{inline} keyword and then is defined with +@code{inline}, like this: -@cindex automatic @code{inline} for C++ member fns -@cindex @code{inline} automatic for C++ member fns -@cindex member fns, automatically @code{inline} -@cindex C++ member fns, automatically @code{inline} -@opindex fno-default-inline -GCC automatically inlines member functions defined within the class -body of C++ programs even if they are not explicitly declared -@code{inline}. (You can override this with @option{-fno-default-inline}; -@pxref{C++ Dialect Options,,Options Controlling C++ Dialect}.) +@smallexample +extern int inc (int *a); +inline int +inc (int *a) +@{ + (*a)++; +@} +@end smallexample + +In both of these common cases, the program behaves the same as if you +had not used the @code{inline} keyword, except for its speed. @cindex inline functions, omission of @opindex fkeep-inline-functions @@ -3904,6 +3892,27 @@ nonintegrated call, then the function is usual. The function must also be compiled as usual if the program refers to its address, because that can't be inlined. +@cindex automatic @code{inline} for C++ member fns +@cindex @code{inline} automatic for C++ member fns +@cindex member fns, automatically @code{inline} +@cindex C++ member fns, automatically @code{inline} +@opindex fno-default-inline +As required by ISO C++, GCC considers member functions defined within +the body of a class to be marked inline even if they are +not explicitly declared with the @code{inline} keyword. You can +override this with @option{-fno-default-inline}; @pxref{C++ Dialect +Options,,Options Controlling C++ Dialect}. + +GCC does not inline any functions when not optimizing unless you specify +the @samp{always_inline} attribute for the function, like this: + +@smallexample +/* @r{Prototype.} */ +inline void foo (const char) __attribute__((always_inline)); +@end smallexample + +The remainder of this section is specific to GNU C89 inlining. + @cindex non-static inline function When an inline function is not @code{static}, then the compiler must assume that there may be calls from other source files; since a global symbol can @@ -3926,24 +3935,6 @@ The definition in the header file will c to be inlined. If any uses of the function remain, they will refer to the single copy in the library. -Since GCC 4.3 will implement ISO C99 semantics for -inline functions, it is simplest to use @code{static inline} only -to guarantee compatibility. (The -existing semantics will remain available when @option{-std=gnu89} is -specified, but eventually the default will be @option{-std=gnu99}; -that will implement the C99 semantics, though it does not do so in -versions of GCC before 4.3. After the default changes, the existing -semantics will still be available via the @option{-fgnu89-inline} -option or the @code{gnu_inline} function attribute.) - -GCC does not inline any functions when not optimizing unless you specify -the @samp{always_inline} attribute for the function, like this: - -@smallexample -/* @r{Prototype.} */ -inline void foo (const char) __attribute__((always_inline)); -@end smallexample - @node Extended Asm @section Assembler Instructions with C Expression Operands @cindex extended @code{asm}
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200903141936.n2EJaDM5006130>