Allow inline and __attribute((noinline)) to be used together without warning in C++ [GH #183]

Author: mborland

src/attribute.c

@@ -6059,6 +6059,37 @@ that entity.
 
 #endif /* GNU_NAKED_ATTRIBUTE_ALLOWED || MICROSOFT_EXTENSIONS_ALLOWED */
 
+static a_boolean gnu_accepts_noinline_on_inline_routine(an_attribute_ptr  ap)
+/*
+ap is a GNU "noinline" attribute being applied to an inline routine.  Return
+TRUE if GCC accepts that combination silently in the context of ap. For
+example:
+
+  inline __attribute__((noinline)) int f() { return 0; }  // No warning.
+
+This idiom is used to ensure a noinline function in a header file does not
+cause linker errors.  GCC in C mode will warn on this while it does not in C++.
+*/
+{
+  a_boolean           result = FALSE;
+  a_decl_parse_state  *dps = (a_decl_parse_state*)ap->assoc_info;
+
+  if (!C_mode()) {
+    if (dps == NULL) {
+      /* The attribute is not being applied as part of a declaration, which
+         means it is being copied to a template instance. */
+      result = TRUE;
+    } else {
+      result = ap->on_primary_declaration &&
+               (dps->dso_flags &
+                     (DSO_INLINE | DSO_CONSTEXPR | DSO_CONSTEVAL)) != 0 &&
+               !dps->inline_on_earlier_decl;
+    }  /* if */
+  }  /* if */
+  return result;
+}  /* gnu_accepts_noinline_on_inline_routine */
+
+
 static char* apply_noinline_attr(an_attribute_ptr  ap,
                                  char              *entity,
                                  an_il_entry_kind  entity_kind)
@@ -6069,15 +6100,16 @@ and return the entity.
 {
   if (entity_kind == iek_routine) {
     a_routine_ptr  rp = (a_routine_ptr)entity;
+    a_boolean      has_always_inline = FALSE;
+#if GNU_EXTENSIONS_ALLOWED
+    has_always_inline = find_attribute(ak_always_inline,
+                                       rp->source_corresp.attributes) != NULL;
+#endif /* GNU_EXTENSIONS_ALLOWED */
     rp->never_inline = TRUE;
     if (rp->is_inline && is_gcc_attribute(ap) &&
         (!rp->source_corresp.is_class_member ||
-         rp->defined_outside_of_parent
-#if GNU_EXTENSIONS_ALLOWED
-         || find_attribute(ak_always_inline, rp->source_corresp.attributes)
-                                                                    != NULL
-#endif /* GNU_EXTENSIONS_ALLOWED */
-                                                                           )) {
+         rp->defined_outside_of_parent || has_always_inline) &&
+        (has_always_inline || !gnu_accepts_noinline_on_inline_routine(ap))) {
       pos_warning(ec_inline_gnu_noinline_conflict, &ap->position);
     }  /* if */
   } else {

src/decls.c

@@ -314,6 +314,7 @@ be restored).
   dps->has_direct_initializer = FALSE;
   dps->first_decl = FALSE;
   dps->first_decl_of_predeclared_entity = FALSE;
+  dps->inline_on_earlier_decl = FALSE;
   dps->override_okay = FALSE;
   dps->initializer_is_expr_list = FALSE;
   dps->no_special_cli_class_type_check = FALSE;
@@ -10374,6 +10375,9 @@ skip_overloading:;
       is_nothrow_type(rtp)) {
     routine_ptr->never_throws = TRUE;
   }  /* if */      
+  /* Record whether the routine was inline before this declaration (used when
+     applying the GNU "noinline" attribute). */
+  dps->inline_on_earlier_decl = routine_ptr->is_inline;
   if (func_info->is_inline) set_inline_flag(routine_ptr, TRUE);
   if (use_std_c99_inlining && !idlb.is_block_extern_decl) {
     /* In C99 mode the definition_for_inlining_only flag is set only if that is
@@ -11511,6 +11515,9 @@ definition of a member function of a class template.
         rout_ptr->is_constexpr = TRUE;
       }  /* if */
     }  /* if */
+    /* Record whether the routine was inline before this declaration (used when
+       applying the GNU "noinline" attribute). */
+    dps->inline_on_earlier_decl = rout_ptr->is_inline;
     if (!rout_ptr->is_inline) {
       if (func_info->is_inline || rout_ptr->is_declared_constexpr) {
         set_inline_flag(rout_ptr, TRUE);

src/decls.h

@@ -1061,6 +1061,11 @@ typedef struct a_decl_parse_state {
 			/* TRUE if this is the first declaration of a variable
 			   or function that was predeclared by the front
 			   end. */
+  a_bit_field	inline_on_earlier_decl:1;
+			/* TRUE if this declaration redeclares a function that
+			   was already inline before this declaration (e.g.,
+			   because an earlier declaration specified
+			   "inline"). */
   a_bit_field	redeclares_tag:1;
 			/* TRUE if the specifiers include a tag name (like
 			   "struct S" or "enum E") that must match a prior

src/func_def.c

@@ -2531,6 +2531,9 @@ member declaration (allowed in some Microsoft modes only).
        specification, and issue one if needed. */
     issue_no_exception_support_diag_on_throw_spec(func_info);
   }  /* if */
+  /* Record whether the routine was inline before this declaration (used when
+     applying the GNU "noinline" attribute). */
+  dps->inline_on_earlier_decl = rp->is_inline;
   if (func_info->is_inline) {
     if (!rp->is_inline) {
       set_inline_flag(rp, TRUE);

src/il.c

@@ -3284,12 +3284,15 @@ set).
 #endif /* MICROSOFT_EXTENSIONS_ALLOWED */
 #if GNU_EXTENSIONS_ALLOWED
   } else if (rp->never_inline && gnu_mode &&
+             (!rp->is_template_function || rp->is_specialized ||
+              rp->is_prototype_instantiation) &&
              (!rp->source_corresp.is_class_member ||
               rp->defined_outside_of_parent ||
               find_attribute(ak_always_inline, rp->source_corresp.attributes)
                                                                     != NULL)) {
     /* Was explicitly marked "noinline" previously and is now explicitly
-       marked inline. */
+       marked inline.  (An instance generated from a template is not
+       checked: the declarations of the template itself were.) */
     pos_warning(ec_inline_gnu_noinline_conflict, &error_position);
 #endif /* GNU_EXTENSIONS_ALLOWED */
   }  /* if */

src/pending_changes/gh-183-inline-noinline.txt

@@ -0,0 +1,20 @@
+//allowed_words: NOINLINE
+[GH #183]
+GNU compatibility: "inline" combined with "noinline" on a definition
+
+In GNU and Clang C++ modes, the front end warned that a routine is both
+"inline" and "noinline" when a function definition was declared "inline" and
+had the GNU "noinline" attribute, but GCC accepts that combination silently
+(it is used, e.g., by Boost through "BOOST_NOINLINE inline").  For example:
+
+  inline __attribute__((noinline)) int f(int x) {  // No warning now.
+    return x;
+  }
+
+In C modes, where GCC and Clang warn about the combination in all of those
+cases, the behavior is unchanged.
+
+Also, instantiating a function template (or a member function of a class
+template) that is both "inline" and "noinline" no longer repeats the warning
+"At end of source" for each instance, only the template declarations are
+checked.

tests/expectations/edg_x86_32_cp/regressions.log

@@ -1,3 +1,4 @@
+gh-183-redecl.sft.cpp:fp:-DTEST_NUMBER=1 --c++17:REQUIREMENTS NOT MET:
 gh-309.sft.cpp:fp:-DTEST_NUMBER=1 --g++:REQUIREMENTS NOT MET:
 gh-309.sft.cpp:fp:-DTEST_NUMBER=2 --g++ --no_exceptions:REQUIREMENTS NOT MET:
 immediate-pragma-lost.sft.cpp:cppbe:-DTEST_NUMBER=1:PASS:

tests/expectations/edg_x86_64_cp/regressions.log

@@ -1,3 +1,4 @@
+gh-183-redecl.sft.cpp:fp:-DTEST_NUMBER=1 --c++17:REQUIREMENTS NOT MET:
 gh-309.sft.cpp:fp:-DTEST_NUMBER=1 --g++:REQUIREMENTS NOT MET:
 gh-309.sft.cpp:fp:-DTEST_NUMBER=2 --g++ --no_exceptions:REQUIREMENTS NOT MET:
 immediate-pragma-lost.sft.cpp:cppbe:-DTEST_NUMBER=1:PASS:

tests/tests/imported/gnu/cpp/.Wattributes-3.rto/default.1.1.txt

@@ -3,10 +3,6 @@ fe_only -DTEST_NUMBER=1 --gnu_version=999999 -tused -e 200 --no_wrap --no_wrap_d
   ATTR ((__always_inline__))
   ^
 
-"Test_name.c", line 53: warning: routine is both "inline" and "noinline"
-  inline ATTR ((__noinline__))
-         ^
-
 "Test_name.c", line 58: warning: the "always_inline" attribute is ignored on non-inline functions
   ATTR ((__always_inline__))
   ^

tests/tests/imported/gnu/cpp/ext/.attr-noinline-2.rto/default.1.1.txt

@@ -3,7 +3,3 @@ fe_only -DTEST_NUMBER=1 --gnu_version=999999 -tused -e 200 --no_wrap --no_wrap_d
   fnoinline_always_inline<Special>()    // { dg-bogus "follows declaration" }
   ^
 
-"Test_name.c", line 58: warning: routine is both "inline" and "noinline"
-  fnoinline_always_inline<Special>()    // { dg-bogus "follows declaration" }
-  ^
-