1 files changed, 133 insertions, 150 deletions

diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 5285c02fa00..bdb68199351 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -52,7 +52,8 @@ along with GCC; see the file COPYING3.  If not see
 #include "c-pragma.h"
 #include "langhooks.h"
 #include "tree-mudflap.h"
-#include "tree-gimple.h"
+#include "gimple.h"
+#include "tree-iterator.h"
 #include "diagnostic.h"
 #include "tree-dump.h"
 #include "cgraph.h"
@@ -61,6 +62,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "except.h"
 #include "langhooks-def.h"
 #include "pointer-set.h"
+#include "gimple.h"
 
 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
 enum decl_context
@@ -248,7 +250,7 @@ extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
 
 union lang_tree_node
   GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
-       chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) GENERIC_NEXT (&%h.generic))")))
+       chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))")))
 {
   union tree_node GTY ((tag ("0"),
 			desc ("tree_node_structure (&%h)")))
@@ -786,7 +788,7 @@ pop_scope (void)
 		   && TREE_PUBLIC (p)
 		   && !DECL_INITIAL (p)
 		   && !flag_gnu89_inline)
-	    pedwarn ("inline function %q+D declared but never defined", p);
+	    pedwarn (0, "inline function %q+D declared but never defined", p);
 
 	  goto common_symbol;
 
@@ -1223,7 +1225,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
 	       && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
 	       && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
 	{
-	  pedwarn ("conflicting types for %q+D", newdecl);
+	  pedwarn (0, "conflicting types for %q+D", newdecl);
 	  /* Make sure we keep void as the return type.  */
 	  TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
 	  C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
@@ -1236,7 +1238,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
 	       && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
 	       && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
 	{
-	  pedwarn ("conflicting types for %q+D", newdecl);
+	  pedwarn (0, "conflicting types for %q+D", newdecl);
 	  /* Make sure we keep void as the return type.  */
 	  TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
 	  pedwarned = true;
@@ -1515,30 +1517,6 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
 		   "noinline follows inline declaration ", newdecl);
 	  warned = true;
 	}
-
-      /* Inline declaration after use or definition.
-	 ??? 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.
-	 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)
-	  && flag_gnu89_inline)
-	{
-	  if (TREE_USED (olddecl))
-	    {
-	      warning (0, "%q+D declared inline after being called", olddecl);
-	      warned = true;
-	    }
-	  else if (DECL_INITIAL (olddecl))
-	    {
-	      warning (0, "%q+D declared inline after its definition", olddecl);
-	      warned = true;
-	    }
-	}
     }
   else /* PARM_DECL, VAR_DECL */
     {
@@ -1588,7 +1566,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
 
   /* Report location of previous decl/defn in a consistent manner.  */
   if (warned || pedwarned)
-    locate_old_decl (olddecl, pedwarned ? pedwarn : warning0);
+    locate_old_decl (olddecl, pedwarned ? pedwarn0 : warning0);
 
 #undef DECL_EXTERN_INLINE
 
@@ -1801,9 +1779,9 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
       if (new_is_definition && DECL_INITIAL (olddecl))
 	{
 	  if (TREE_USED (olddecl)
-	      /* In unit-at-a-time mode we never inline re-defined extern
-		 inline functions.  */
-	      && !flag_unit_at_a_time
+	      /* We never inline re-defined extern inline functions.
+		 FIXME: This would be better handled by keeping both functions
+		 as separate declarations.  */
 	      && cgraph_function_possibly_inlined_p (olddecl))
 	    (*debug_hooks->outlining_inline_function) (olddecl);
 
@@ -1842,6 +1820,17 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
 	      = C_DECL_BUILTIN_PROTOTYPE (olddecl);
 	}
 
+      /* Preserve function specific target and optimization options */
+      if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
+	  && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
+	DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
+	  = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
+
+      if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
+	  && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
+	DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
+	  = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
+
       /* Also preserve various other info from the definition.  */
       if (!new_is_definition)
 	{
@@ -1849,6 +1838,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
 	  DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
 	  DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
 	  DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
+	  gimple_set_body (newdecl, gimple_body (olddecl));
 	  DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
 
 	  /* Set DECL_INLINE on the declaration if we've got a body
@@ -1883,6 +1873,10 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
 	    sizeof (struct tree_decl_common) - sizeof (struct tree_common));
     switch (TREE_CODE (olddecl))
       {
+      case FUNCTION_DECL:
+	gimple_set_body (olddecl, gimple_body (newdecl));
+	/* fall through */
+
       case FIELD_DECL:
       case VAR_DECL:
       case PARM_DECL:
@@ -1890,7 +1884,6 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
       case RESULT_DECL:
       case CONST_DECL:
       case TYPE_DECL:
-      case FUNCTION_DECL:
 	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
 		(char *) newdecl + sizeof (struct tree_decl_common),
 		tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
@@ -2345,7 +2338,8 @@ implicit_decl_warning (tree id, tree olddecl)
   if (warn_implicit_function_declaration)
     {
       if (flag_isoc99)
-	pedwarn (G_("implicit declaration of function %qE"), id);
+	pedwarn (OPT_Wimplicit_function_declaration, 
+		 G_("implicit declaration of function %qE"), id);
       else 
 	warning (OPT_Wimplicit_function_declaration, 
 		 G_("implicit declaration of function %qE"), id);
@@ -2897,7 +2891,7 @@ shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
 	      if (warned != 1 && code != ENUMERAL_TYPE)
 		/* Empty unnamed enum OK */
 		{
-		  pedwarn ("unnamed struct/union that defines no instances");
+		  pedwarn (0, "unnamed struct/union that defines no instances");
 		  warned = 1;
 		}
 	    }
@@ -2905,8 +2899,8 @@ shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
 		   && declspecs->storage_class != csc_none)
 	    {
 	      if (warned != 1)
-		pedwarn ("empty declaration with storage class specifier "
-			 "does not redeclare tag");
+		pedwarn (0, "empty declaration with storage class specifier "
+			  "does not redeclare tag");
 	      warned = 1;
 	      pending_xref_error ();
 	    }
@@ -2916,8 +2910,8 @@ shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
 		       || declspecs->restrict_p))
 	    {
 	      if (warned != 1)
-		pedwarn ("empty declaration with type qualifier "
-			 "does not redeclare tag");
+		pedwarn (0, "empty declaration with type qualifier "
+			  "does not redeclare tag");
 	      warned = 1;
 	      pending_xref_error ();
 	    }
@@ -2937,14 +2931,14 @@ shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
 	{
 	  if (warned != 1 && !in_system_header)
 	    {
-	      pedwarn ("useless type name in empty declaration");
+	      pedwarn (0, "useless type name in empty declaration");
 	      warned = 1;
 	    }
 	}
     }
   else if (warned != 1 && !in_system_header && declspecs->typedef_p)
     {
-      pedwarn ("useless type name in empty declaration");
+      pedwarn (0, "useless type name in empty declaration");
       warned = 1;
     }
 
@@ -2991,7 +2985,7 @@ shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
   if (warned != 1)
     {
       if (!found_tag)
-	pedwarn ("empty declaration");
+	pedwarn (0, "empty declaration");
     }
 }
 
@@ -3054,13 +3048,13 @@ build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
     }
   declarator->u.array.static_p = static_p;
   declarator->u.array.vla_unspec_p = vla_unspec_p;
-  if (pedantic && !flag_isoc99)
+  if (!flag_isoc99)
     {
       if (static_p || quals != NULL)
-	pedwarn ("ISO C90 does not support %<static%> or type "
+	pedwarn (OPT_pedantic, "ISO C90 does not support %<static%> or type "
 		 "qualifiers in parameter array declarators");
       if (vla_unspec_p)
-	pedwarn ("ISO C90 does not support %<[*]%> array declarators");
+	pedwarn (OPT_pedantic, "ISO C90 does not support %<[*]%> array declarators");
     }
   if (vla_unspec_p)
     {
@@ -3316,8 +3310,8 @@ start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
       && !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);
+    pedwarn (0, "%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.  */
@@ -3606,10 +3600,6 @@ finish_decl (tree decl, tree init, tree asmspec_tree)
 	}
     }
 
-  /* If this was marked 'used', be sure it will be output.  */
-  if (!flag_unit_at_a_time && lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
-    mark_decl_referenced (decl);
-
   if (TREE_CODE (decl) == TYPE_DECL)
     {
       if (!DECL_FILE_SCOPE_P (decl)
@@ -3694,7 +3684,7 @@ mark_forward_parm_decls (void)
 
   if (pedantic && !current_scope->warned_forward_parm_decls)
     {
-      pedwarn ("ISO C forbids forward parameter declarations");
+      pedwarn (OPT_pedantic, "ISO C forbids forward parameter declarations");
       current_scope->warned_forward_parm_decls = true;
     }
 
@@ -3841,12 +3831,11 @@ check_bitfield_type_and_width (tree *type, tree *width, const char *orig_name)
     }
 
   type_mv = TYPE_MAIN_VARIANT (*type);
-  if (pedantic
-      && !in_system_header
+  if (!in_system_header
       && type_mv != integer_type_node
       && type_mv != unsigned_type_node
       && type_mv != boolean_type_node)
-    pedwarn ("type of bit-field %qs is a GCC extension", name);
+    pedwarn (OPT_pedantic, "type of bit-field %qs is a GCC extension", name);
 
   max_width = TYPE_PRECISION (*type);
 
@@ -3876,28 +3865,27 @@ check_bitfield_type_and_width (tree *type, tree *width, const char *orig_name)
 static void
 warn_variable_length_array (const char *name, tree size)
 {
-  int ped = !flag_isoc99 && pedantic && warn_vla != 0;
   int const_size = TREE_CONSTANT (size);
 
-  if (ped)
+  if (!flag_isoc99 && pedantic && warn_vla != 0)
     {
       if (const_size)
 	{
 	  if (name)
-	    pedwarn ("ISO C90 forbids array %qs whose size "
+	    pedwarn (OPT_Wvla, "ISO C90 forbids array %qs whose size "
 		     "can%'t be evaluated",
 		     name);
 	  else
-	    pedwarn ("ISO C90 forbids array whose size "
+	    pedwarn (OPT_Wvla, "ISO C90 forbids array whose size "
 		     "can%'t be evaluated");
 	}
       else
 	{
 	  if (name) 
-	    pedwarn ("ISO C90 forbids variable length array %qs",
+	    pedwarn (OPT_Wvla, "ISO C90 forbids variable length array %qs",
 		     name);
 	  else
-	    pedwarn ("ISO C90 forbids variable length array");
+	    pedwarn (OPT_Wvla, "ISO C90 forbids variable length array");
 	}
     }
   else if (warn_vla > 0)
@@ -4058,8 +4046,9 @@ grokdeclarator (const struct c_declarator *declarator,
       if ((warn_implicit_int || warn_return_type || flag_isoc99)
 	  && funcdef_flag)
 	warn_about_return_type = 1;
-      else if (warn_implicit_int || flag_isoc99)
-	pedwarn_c99 ("type defaults to %<int%> in declaration of %qs", name);
+      else 
+	pedwarn_c99 (flag_isoc99 ? 0 : OPT_Wimplicit_int, 
+		     "type defaults to %<int%> in declaration of %qs", name);
     }
 
   /* Adjust the type if a bit-field is being declared,
@@ -4067,7 +4056,7 @@ grokdeclarator (const struct c_declarator *declarator,
      "signed".  */
   if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
       && TREE_CODE (type) == INTEGER_TYPE)
-    type = c_common_unsigned_type (type);
+    type = unsigned_type_for (type);
 
   /* Figure out the type qualifiers for the declaration.  There are
      two ways a declaration can become qualified.  One is something
@@ -4087,11 +4076,11 @@ grokdeclarator (const struct c_declarator *declarator,
   if (pedantic && !flag_isoc99)
     {
       if (constp > 1)
-	pedwarn ("duplicate %<const%>");
+	pedwarn (OPT_pedantic, "duplicate %<const%>");
       if (restrictp > 1)
-	pedwarn ("duplicate %<restrict%>");
+	pedwarn (OPT_pedantic, "duplicate %<restrict%>");
       if (volatilep > 1)
-	pedwarn ("duplicate %<volatile%>");
+	pedwarn (OPT_pedantic, "duplicate %<volatile%>");
     }
   if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
     type = TYPE_MAIN_VARIANT (type);
@@ -4108,9 +4097,9 @@ grokdeclarator (const struct c_declarator *declarator,
 	  || storage_class == csc_register
 	  || storage_class == csc_typedef))
     {
-      if (storage_class == csc_auto
-	  && (pedantic || current_scope == file_scope))
-	pedwarn ("function definition declared %<auto%>");
+      if (storage_class == csc_auto)
+	pedwarn ((current_scope == file_scope) ? 0 : OPT_pedantic, 
+		 "function definition declared %<auto%>");
       if (storage_class == csc_register)
 	error ("function definition declared %<register%>");
       if (storage_class == csc_typedef)
@@ -4166,7 +4155,7 @@ grokdeclarator (const struct c_declarator *declarator,
       if (storage_class == csc_auto)
 	error ("file-scope declaration of %qs specifies %<auto%>", name);
       if (pedantic && storage_class == csc_register)
-	pedwarn ("file-scope declaration of %qs specifies %<register%>", name);
+	pedwarn (OPT_pedantic, "file-scope declaration of %qs specifies %<register%>", name);
     }
   else
     {
@@ -4279,7 +4268,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	      }
 
 	    if (pedantic && !in_system_header && flexible_array_type_p (type))
-	      pedwarn ("invalid use of structure with flexible array member");
+	      pedwarn (OPT_pedantic, "invalid use of structure with flexible array member");
 
 	    if (size == error_mark_node)
 	      type = error_mark_node;
@@ -4304,7 +4293,7 @@ grokdeclarator (const struct c_declarator *declarator,
 		  }
 
 		if (pedantic && integer_zerop (size))
-		  pedwarn ("ISO C forbids zero-size array %qs", name);
+		  pedwarn (OPT_pedantic, "ISO C forbids zero-size array %qs", name);
 
 		if (TREE_CODE (size) == INTEGER_CST)
 		  {
@@ -4376,7 +4365,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	    else if (decl_context == FIELD)
 	      {
 		if (pedantic && !flag_isoc99 && !in_system_header)
-		  pedwarn ("ISO C90 does not support flexible array members");
+		  pedwarn (OPT_pedantic, "ISO C90 does not support flexible array members");
 
 		/* ISO C99 Flexible array members are effectively
 		   identical to GCC's zero-length array extension.  */
@@ -4521,7 +4510,7 @@ grokdeclarator (const struct c_declarator *declarator,
 		   function definitions in ISO C; GCC used to used
 		   them for noreturn functions.  */
 		if (VOID_TYPE_P (type) && really_funcdef)
-		  pedwarn ("function definition has qualified void return type");
+		  pedwarn (0, "function definition has qualified void return type");
 		else
 		  warning (OPT_Wignored_qualifiers,
 			   "type qualifiers ignored on function return type");
@@ -4553,7 +4542,7 @@ grokdeclarator (const struct c_declarator *declarator,
 
 	    if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
 		&& type_quals)
-	      pedwarn ("ISO C forbids qualified function types");
+	      pedwarn (OPT_pedantic, "ISO C forbids qualified function types");
 	    if (type_quals)
 	      type = c_build_qualified_type (type, type_quals);
 	    size_varies = 0;
@@ -4634,7 +4623,7 @@ grokdeclarator (const struct c_declarator *declarator,
       tree decl;
       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
 	  && type_quals)
-	pedwarn ("ISO C forbids qualified function types");
+	pedwarn (OPT_pedantic, "ISO C forbids qualified function types");
       if (type_quals)
 	type = c_build_qualified_type (type, type_quals);
       decl = build_decl (TYPE_DECL, declarator->u.id, type);
@@ -4642,7 +4631,7 @@ grokdeclarator (const struct c_declarator *declarator,
       if (declspecs->explicit_signed_p)
 	C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
       if (declspecs->inline_p)
-	pedwarn ("typedef %q+D declared %<inline%>", decl);
+	pedwarn (0, "typedef %q+D declared %<inline%>", decl);
       return decl;
     }
 
@@ -4657,7 +4646,7 @@ grokdeclarator (const struct c_declarator *declarator,
 		  && !declspecs->inline_p);
       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
 	  && type_quals)
-	pedwarn ("ISO C forbids const or volatile function types");
+	pedwarn (OPT_pedantic, "ISO C forbids const or volatile function types");
       if (type_quals)
 	type = c_build_qualified_type (type, type_quals);
       return type;
@@ -4667,7 +4656,8 @@ grokdeclarator (const struct c_declarator *declarator,
       && variably_modified_type_p (type, NULL_TREE))
     {
       /* C99 6.7.2.1p8 */
-      pedwarn ("a member of a structure or union cannot have a variably modified type");
+      pedwarn (OPT_pedantic, 
+	       "a member of a structure or union cannot have a variably modified type");
     }
 
   /* Aside from typedefs and type names (handle above),
@@ -4720,8 +4710,8 @@ grokdeclarator (const struct c_declarator *declarator,
 	  }
 	else if (TREE_CODE (type) == FUNCTION_TYPE)
 	  {
-	    if (pedantic && type_quals)
-	      pedwarn ("ISO C forbids qualified function types");
+	    if (type_quals)
+	      pedwarn (OPT_pedantic, "ISO C forbids qualified function types");
 	    if (type_quals)
 	      type = c_build_qualified_type (type, type_quals);
 	    type = build_pointer_type (type);
@@ -4747,7 +4737,7 @@ grokdeclarator (const struct c_declarator *declarator,
 
 	DECL_ARG_TYPE (decl) = promoted_type;
 	if (declspecs->inline_p)
-	  pedwarn ("parameter %q+D declared %<inline%>", decl);
+	  pedwarn (0, "parameter %q+D declared %<inline%>", decl);
       }
     else if (decl_context == FIELD)
       {
@@ -4793,10 +4783,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	       GCC allows 'auto', perhaps with 'inline', to support
 	       nested functions.  */
 	    if (storage_class == csc_auto)
-	      {
-		if (pedantic)
-		  pedwarn ("invalid storage class for function %qs", name);
-	      }
+		pedwarn (OPT_pedantic, "invalid storage class for function %qs", name);
 	    else if (storage_class == csc_static)
 	      {
 		error ("invalid storage class for function %qs", name);
@@ -4812,7 +4799,8 @@ grokdeclarator (const struct c_declarator *declarator,
 	decl = build_decl_attribute_variant (decl, decl_attr);
 
 	if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
-	  pedwarn ("ISO C forbids qualified function types");
+	  pedwarn (OPT_pedantic,
+		   "ISO C forbids qualified function types");
 
 	/* GNU C interprets a volatile-qualified function type to indicate
 	   that the function does not return.  */
@@ -4854,7 +4842,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	if (flag_hosted && MAIN_NAME_P (declarator->u.id))
 	  {
 	    if (declspecs->inline_p)
-	      pedwarn ("cannot inline function %<main%>");
+	      pedwarn (0, "cannot inline function %<main%>");
 	  }
 	else if (declspecs->inline_p)
 	  {
@@ -4868,10 +4856,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	    if (initialized)
 	      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
-	   needed, and let dwarf2 know that the function is inlinable.  */
-	else if (flag_inline_trees == 2 && initialized)
+	else if (initialized)
 	  DECL_INLINE (decl) = 1;
       }
     else
@@ -4907,7 +4892,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	  C_DECL_VARIABLE_SIZE (decl) = 1;
 
 	if (declspecs->inline_p)
-	  pedwarn ("variable %q+D declared %<inline%>", decl);
+	  pedwarn (0, "variable %q+D declared %<inline%>", decl);
 
 	/* At file scope, an initialized extern declaration may follow
 	   a static declaration.  In that case, DECL_EXTERNAL will be
@@ -5015,7 +5000,7 @@ grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
   else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
     {
       if (!funcdef_flag)
-	pedwarn ("parameter names (without types) in function declaration");
+	pedwarn (0, "parameter names (without types) in function declaration");
 
       arg_info->parms = arg_info->types;
       arg_info->types = 0;
@@ -5429,11 +5414,10 @@ grokfield (struct c_declarator *declarator, struct c_declspecs *declspecs,
 	}
       if (!ok)
 	{
-	  pedwarn ("declaration does not declare anything");
+	  pedwarn (0, "declaration does not declare anything");
 	  return NULL_TREE;
 	}
-      if (pedantic)
-	pedwarn ("ISO C doesn%'t support unnamed structs/unions");
+      pedwarn (OPT_pedantic, "ISO C doesn%'t support unnamed structs/unions");
     }
 
   value = grokdeclarator (declarator, declspecs, FIELD, false,
@@ -5532,16 +5516,16 @@ finish_struct (tree t, tree fieldlist, tree attributes)
 	  if (TREE_CODE (t) == UNION_TYPE)
 	    {
 	      if (fieldlist)
-		pedwarn ("union has no named members");
+		pedwarn (OPT_pedantic, "union has no named members");
 	      else
-		pedwarn ("union has no members");
+		pedwarn (OPT_pedantic, "union has no members");
 	    }
 	  else
 	    {
 	      if (fieldlist)
-		pedwarn ("struct has no named members");
+		pedwarn (OPT_pedantic, "struct has no named members");
 	      else
-		pedwarn ("struct has no members");
+		pedwarn (OPT_pedantic, "struct has no members");
 	    }
 	}
     }
@@ -5620,7 +5604,8 @@ finish_struct (tree t, tree fieldlist, tree attributes)
 
       if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
 	  && flexible_array_type_p (TREE_TYPE (x)))
-	pedwarn ("%Jinvalid use of structure with flexible array member", x);
+	pedwarn (OPT_pedantic, 
+		 "%Jinvalid use of structure with flexible array member", x);
 
       if (DECL_NAME (x))
 	saw_named_field = 1;
@@ -6005,7 +5990,7 @@ build_enumerator (struct c_enum_contents *the_enum, tree name, tree value)
 
   if (pedantic && !int_fits_type_p (value, integer_type_node))
     {
-      pedwarn ("ISO C restricts enumerator values to range of %<int%>");
+      pedwarn (OPT_pedantic, "ISO C restricts enumerator values to range of %<int%>");
       /* XXX This causes -pedantic to change the meaning of the program.
 	 Remove?  -zw 2004-03-15  */
       value = convert (integer_type_node, value);
@@ -6121,7 +6106,9 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
     }
 
   if (warn_about_return_type)
-    pedwarn_c99 ("return type defaults to %<int%>");
+    pedwarn_c99 (flag_isoc99 ? 0 
+		 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
+		 "return type defaults to %<int%>");
 
   /* Make the init_value nonzero so pushdecl knows this is not tentative.
      error_mark_node is replaced below (in pop_scope) with the BLOCK.  */
@@ -6242,12 +6229,12 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
     {
       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
 	  != integer_type_node)
-	pedwarn ("return type of %q+D is not %<int%>", decl1);
+	pedwarn (OPT_Wmain, "return type of %q+D is not %<int%>", decl1);
 
       check_main_parameter_types(decl1);
 
       if (!TREE_PUBLIC (decl1))
-	pedwarn ("%q+D is normally a non-static function", decl1);
+	pedwarn (OPT_Wmain, "%q+D is normally a non-static function", decl1);
     }
 
   /* Record the decl so that the function name is defined.
@@ -6395,7 +6382,7 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
 	  warn_if_shadowing (decl);
 
 	  if (flag_isoc99)
-	    pedwarn ("type of %q+D defaults to %<int%>", decl);
+	    pedwarn (0, "type of %q+D defaults to %<int%>", decl);
 	  else 
 	    warning (OPT_Wmissing_parameter_type, "type of %q+D defaults to %<int%>", decl);
 	}
@@ -6506,22 +6493,19 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
 		      < TYPE_PRECISION (integer_type_node))
 		    DECL_ARG_TYPE (parm) = integer_type_node;
 
-		  if (pedantic)
+		  /* ??? Is it possible to get here with a
+		     built-in prototype or will it always have
+		     been diagnosed as conflicting with an
+		     old-style definition and discarded?  */
+		  if (current_function_prototype_built_in)
+		    warning (OPT_pedantic, "promoted argument %qD "
+			     "doesn%'t match built-in prototype", parm);
+		  else
 		    {
-		      /* ??? Is it possible to get here with a
-			 built-in prototype or will it always have
-			 been diagnosed as conflicting with an
-			 old-style definition and discarded?  */
-		      if (current_function_prototype_built_in)
-			warning (0, "promoted argument %qD "
-				 "doesn%'t match built-in prototype", parm);
-		      else
-			{
-			  pedwarn ("promoted argument %qD "
-				   "doesn%'t match prototype", parm);
-			  pedwarn ("%Hprototype declaration",
-				   &current_function_prototype_locus);
-			}
+		      pedwarn (OPT_pedantic, "promoted argument %qD "
+			       "doesn%'t match prototype", parm);
+		      pedwarn (OPT_pedantic, "%Hprototype declaration",
+			       &current_function_prototype_locus);
 		    }
 		}
 	      else
@@ -6656,9 +6640,10 @@ static void
 c_gimple_diagnostics_recursively (tree fndecl)
 {
   struct cgraph_node *cgn;
+  gimple_seq body = gimple_body (fndecl);
 
   /* Handle attribute((warn_unused_result)).  Relies on gimple input.  */
-  c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
+  c_warn_unused_result (body);
 
   /* Notice when OpenMP structured block constraints are violated.  */
   if (flag_openmp)
@@ -6713,7 +6698,7 @@ finish_function (void)
 	  /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
 	     If warn_main is -1 (-Wno-main) we don't want to be warned.  */
 	  if (!warn_main)
-	    pedwarn ("return type of %q+D is not %<int%>", fndecl);
+	    pedwarn (0, "return type of %q+D is not %<int%>", fndecl);
 	}
       else
 	{
@@ -6746,9 +6731,9 @@ finish_function (void)
       && !MAIN_NAME_P (DECL_NAME (fndecl))
       /* Or if they didn't actually specify a return type.  */
       && !C_FUNCTION_IMPLICIT_INT (fndecl)
-      /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
-	 inline function, as we might never be compiled separately.  */
-      && DECL_INLINE (fndecl))
+      /* Normally, with -Wreturn-type, flow will complain, but we might
+         optimize out static functions.  */
+      && !TREE_PUBLIC (fndecl))
     {
       warning (OPT_Wreturn_type,
 	       "no return statement in function returning non-void");
@@ -7164,8 +7149,8 @@ declspecs_add_qual (struct c_declspecs *specs, tree qual)
     default:
       gcc_unreachable ();
     }
-  if (dupe && pedantic && !flag_isoc99)
-    pedwarn ("duplicate %qE", qual);
+  if (dupe && !flag_isoc99)
+    pedwarn (OPT_pedantic, "duplicate %qE", qual);
   return specs;
 }
 
@@ -7213,9 +7198,8 @@ declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
 			     "declaration specifiers");
 		      break;
 		    }
-		  if (pedantic && !flag_isoc99 && !in_system_header
-		      && warn_long_long)
-		    pedwarn ("ISO C90 does not support %<long long%>");
+		  if (pedantic && !flag_isoc99 && !in_system_header)
+		    pedwarn (OPT_Wlong_long, "ISO C90 does not support %<long long%>");
 		  specs->long_long_p = 1;
 		  break;
 		}
@@ -7338,8 +7322,8 @@ declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
 	      break;
 	    case RID_COMPLEX:
 	      dupe = specs->complex_p;
-	      if (pedantic && !flag_isoc99 && !in_system_header)
-		pedwarn ("ISO C90 does not support complex types");
+	      if (!flag_isoc99 && !in_system_header)
+		pedwarn (OPT_pedantic, "ISO C90 does not support complex types");
 	      if (specs->typespec_word == cts_void)
 		error ("both %<complex%> and %<void%> in "
 		       "declaration specifiers");
@@ -7369,8 +7353,7 @@ declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
 	      break;
 	    case RID_SAT:
 	      dupe = specs->saturating_p;
-	      if (pedantic)
-		pedwarn ("ISO C does not support saturating types");
+	      pedwarn (OPT_pedantic, "ISO C does not support saturating types");
 	      if (specs->typespec_word == cts_void)
 		error ("both %<_Sat%> and %<void%> in "
 		       "declaration specifiers");
@@ -7567,8 +7550,8 @@ declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
 	      }
 	      if (!targetm.decimal_float_supported_p ())
 		error ("decimal floating point not supported for this target");
-	      if (pedantic)
-		pedwarn ("ISO C does not support decimal floating point");
+	      pedwarn (OPT_pedantic, 
+		       "ISO C does not support decimal floating point");
 	      return specs;
 	    case RID_FRACT:
 	    case RID_ACCUM:
@@ -7588,8 +7571,8 @@ declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
 	      }
 	      if (!targetm.fixed_point_supported_p ())
 		error ("fixed-point types not supported for this target");
-	      if (pedantic)
-		pedwarn ("ISO C does not support fixed-point types");
+	      pedwarn (OPT_pedantic, 
+		       "ISO C does not support fixed-point types");
 	      return specs;
 	    default:
 	      /* ObjC reserved word "id", handled below.  */
@@ -7775,9 +7758,9 @@ finish_declspecs (struct c_declspecs *specs)
       else if (specs->complex_p)
 	{
 	  specs->typespec_word = cts_double;
-	  if (pedantic)
-	    pedwarn ("ISO C does not support plain %<complex%> meaning "
-		     "%<double complex%>");
+	  pedwarn (OPT_pedantic, 
+		   "ISO C does not support plain %<complex%> meaning "
+		   "%<double complex%>");
 	}
       else
 	{
@@ -7820,8 +7803,8 @@ finish_declspecs (struct c_declspecs *specs)
 	specs->type = char_type_node;
       if (specs->complex_p)
 	{
-	  if (pedantic)
-	    pedwarn ("ISO C does not support complex integer types");
+	  pedwarn (OPT_pedantic, 
+		   "ISO C does not support complex integer types");
 	  specs->type = build_complex_type (specs->type);
 	}
       break;
@@ -7846,8 +7829,8 @@ finish_declspecs (struct c_declspecs *specs)
 		       : integer_type_node);
       if (specs->complex_p)
 	{
-	  if (pedantic)
-	    pedwarn ("ISO C does not support complex integer types");
+	  pedwarn (OPT_pedantic, 
+		   "ISO C does not support complex integer types");
 	  specs->type = build_complex_type (specs->type);
 	}
       break;
@@ -7997,7 +7980,7 @@ c_write_global_declarations_1 (tree globals)
 	  && !TREE_PUBLIC (decl)
 	  && C_DECL_USED (decl))
 	{
-	  pedwarn ("%q+F used but never defined", decl);
+	  pedwarn (0, "%q+F used but never defined", decl);
 	  TREE_NO_WARNING (decl) = 1;
 	}