CbC/CbC_gcc: gcc/c-decl.c comparison

comparison gcc/c-decl.c @ 69:1b10fe6932e1

merge 69

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 07:53:12 +0900
parents	326d9e06c2e3 f6334be47118
children	b81903832de2

comparison

equal deleted inserted replaced

-:b362627d71ba
+:1b10fe6932e1
 /* Process declarations and variables for C compiler.
 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "input.h"
 #include "tm.h"
 #include "intl.h"
 #include "tree.h"
 #include "tree-inline.h"
-#include "rtl.h"
 #include "flags.h"
 #include "function.h"
 #include "output.h"
-#include "expr.h"
 #include "c-tree.h"
 #include "toplev.h"
-#include "ggc.h"
 #include "tm_p.h"
 #include "cpplib.h"
 #include "target.h"
 #include "debug.h"
 #include "opts.h"
 #include "timevar.h"
-#include "c-common.h"
+#include "c-family/c-common.h"
-#include "c-pragma.h"
+#include "c-family/c-objc.h"
+#include "c-family/c-pragma.h"
 #include "c-lang.h"
 #include "langhooks.h"
 #include "tree-mudflap.h"
-#include "gimple.h"
 #include "tree-iterator.h"
-#include "diagnostic.h"
+#include "diagnostic-core.h"
 #include "tree-dump.h"
 #include "cgraph.h"
 #include "hashtab.h"
-#include "libfuncs.h"
-#include "except.h"
 #include "langhooks-def.h"
 #include "pointer-set.h"
 #include "gimple.h"
 #ifndef noCbC
 #include "cbc-tree.h"
 tree cbc_env;
 tree cbc_return_f;
 location_t cbc_return;
 #endif
 #include "plugin.h"
+#include "c-family/c-ada-spec.h"
 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
 enum decl_context
 { NORMAL,           /* Ordinary declaration */
 FUNCDEF,          /* Function definition */
 static GTY(()) struct stmt_tree_s c_stmt_tree;
 /* State saving variables.  */
 tree c_break_label;
 tree c_cont_label;
-/* Linked list of TRANSLATION_UNIT_DECLS for the translation units
-included in this invocation.  Note that the current translation
-unit is not included in this list.  */
-static GTY(()) tree all_translation_units;
 /* A list of decls to be made automatically visible in each file scope.  */
 static GTY(()) tree visible_builtins;
 /* Set to 0 at beginning of a function definition, set to 1 if
 /* True if this scope has any label bindings.  This is used to speed
 up searching for labels when popping scopes, particularly since
 labels are normally only found at function scope.  */
 BOOL_BITFIELD has_label_bindings : 1;
+/* True if we should issue a warning if a goto statement crosses any
+of the bindings.  We still need to check the list of bindings to
+find the specific ones we need to warn about.  This is true if
+decl_jump_unsafe would return true for any of the bindings.  This
+is used to avoid looping over all the bindings unnecessarily.  */
+BOOL_BITFIELD has_jump_unsafe_decl : 1;
 };
 /* The scope currently in effect.  */
 static GTY(()) struct c_scope *current_scope;
 append_to_statement_list_force (t, &cur_stmt_list);
 return t;
 }
+/* Return true if we will want to say something if a goto statement
+crosses DECL.  */
+static bool
+decl_jump_unsafe (tree decl)
+{
+if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
+return false;
+/* Always warn about crossing variably modified types.  */
+if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
+&& variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
+return true;
+/* Otherwise, only warn if -Wgoto-misses-init and this is an
+initialized automatic decl.  */
+if (warn_jump_misses_init
+&& TREE_CODE (decl) == VAR_DECL
+&& !TREE_STATIC (decl)
+&& DECL_INITIAL (decl) != NULL_TREE)
+return true;
+return false;
+}
 void
 c_print_identifier (FILE *file, tree node, int indent)
 {
 print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
 {
 b = binding_freelist;
 binding_freelist = b->prev;
 }
 else
-b = GGC_NEW (struct c_binding);
+b = ggc_alloc_c_binding ();
 b->shadowed = 0;
 b->decl = decl;
 b->id = name;
 b->depth = scope->depth;
 b->u.type = NULL;
 b->prev = scope->bindings;
 scope->bindings = b;
+if (decl_jump_unsafe (decl))
+scope->has_jump_unsafe_decl = 1;
 if (!name)
 return;
 switch (TREE_CODE (decl))
 void
 record_inline_static (location_t loc, tree func, tree decl,
 enum c_inline_static_type type)
 {
-struct c_inline_static *csi = GGC_NEW (struct c_inline_static);
+struct c_inline_static *csi = ggc_alloc_c_inline_static ();
 csi->location = loc;
 csi->function = func;
 csi->static_decl = decl;
 csi->type = type;
 csi->next = c_inline_statics;
 }
 p->stmt_exprs = 0;
 p->left_stmt_expr = false;
 }
-/* Return true if we will want to say something if a goto statement
-crosses DECL.  */
-static bool
-decl_jump_unsafe (tree decl)
-{
-if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
-return false;
-/* Always warn about crossing variably modified types.  */
-if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
-&& variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
-return true;
-/* Otherwise, only warn if -Wgoto-misses-init and this is an
-initialized automatic decl.  */
-if (warn_jump_misses_init
-&& TREE_CODE (decl) == VAR_DECL
-&& !TREE_STATIC (decl)
-&& DECL_INITIAL (decl) != NULL_TREE)
-return true;
-return false;
-}
 /* Update spot bindings P as we pop out of SCOPE.  Return true if we
 should push decls for a label.  */
 static bool
 update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
 {
 scope = scope_freelist;
 scope_freelist = scope->outer;
 }
 else
-scope = GGC_CNEW (struct c_scope);
+scope = ggc_alloc_cleared_c_scope ();
 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes.  */
 if (current_scope)
 scope->float_const_decimal64 = current_scope->float_const_decimal64;
 else
 s = scope;
 while (s != NULL)
 {
 if (s->has_label_bindings)
-{
+	{
-struct c_binding *b;
+	  struct c_binding *b;
-for (b = s->bindings; b != NULL; b = b->prev)
+	  for (b = s->bindings; b != NULL; b = b->prev)
-{
+	    {
-struct c_label_vars *label_vars;
+	      struct c_label_vars *label_vars;
-struct c_binding *b1;
+	      struct c_binding *b1;
-unsigned int ix;
+	      bool hjud;
-struct c_goto_bindings *g;
+	      unsigned int ix;
+	      struct c_goto_bindings *g;
-if (TREE_CODE (b->decl) != LABEL_DECL)
-continue;
+	      if (TREE_CODE (b->decl) != LABEL_DECL)
-label_vars = b->u.label;
+		continue;
+	      label_vars = b->u.label;
-b1 = label_vars->label_bindings.bindings_in_scope;
-if (update_spot_bindings (scope, &label_vars->label_bindings))
+	      b1 = label_vars->label_bindings.bindings_in_scope;
-{
+	      if (label_vars->label_bindings.scope == NULL)
-/* This label is defined in this scope.  */
+		hjud = false;
-for (; b1 != NULL;  b1 = b1->prev)
+	      else
-{
+		hjud = label_vars->label_bindings.scope->has_jump_unsafe_decl;
-/* A goto from later in the function to this
+	      if (update_spot_bindings (scope, &label_vars->label_bindings))
-label will never see the initialization of
+		{
-B1, if any.  Save it to issue a warning if
+		  /* This label is defined in this scope.  */
-needed.  */
+		  if (hjud)
-if (decl_jump_unsafe (b1->decl))
+		    {
-VEC_safe_push (tree, gc, label_vars->decls_in_scope,
+		      for (; b1 != NULL; b1 = b1->prev)
-b1->decl);
+			{
-}
+			  /* A goto from later in the function to this
-}
+			     label will never see the initialization
+			     of B1, if any.  Save it to issue a
-/* Update the bindings of any goto statements associated
+			     warning if needed.  */
-with this label.  */
+			  if (decl_jump_unsafe (b1->decl))
-for (ix = 0;
+			    VEC_safe_push (tree, gc,
-VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
+					   label_vars->decls_in_scope,
-++ix)
+					   b1->decl);
-update_spot_bindings (scope, &g->goto_bindings);
+			}
-}
+		    }
-}
+		}
+	      /* Update the bindings of any goto statements associated
+		 with this label.  */
+	      FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+		update_spot_bindings (scope, &g->goto_bindings);
+	    }
+	}
 /* Don't search beyond the current function.  */
 if (s == current_function_scope)
 break;
 "parameter list local" tagged types.  */
 if (scope->function_body)
 context = current_function_decl;
 else if (scope == file_scope)
 {
-tree file_decl = build_decl (UNKNOWN_LOCATION,
+tree file_decl = build_translation_unit_decl (NULL_TREE);
-TRANSLATION_UNIT_DECL, 0, 0);
-TREE_CHAIN (file_decl) = all_translation_units;
-all_translation_units = file_decl;
 context = file_decl;
 }
 else
 context = block;
 /* Clear all bindings in this scope.  */
 for (b = scope->bindings; b; b = free_binding_and_advance (b))
 {
 p = b->decl;
 switch (TREE_CODE (p))
-{
+	{
-case LABEL_DECL:
+	case LABEL_DECL:
-/* Warnings for unused labels, errors for undefined labels.  */
+	  /* Warnings for unused labels, errors for undefined labels.  */
-if (TREE_USED (p) && !DECL_INITIAL (p))
+	  if (TREE_USED (p) && !DECL_INITIAL (p))
-{
+	    {
-error ("label %q+D used but not defined", p);
+	      error ("label %q+D used but not defined", p);
-DECL_INITIAL (p) = error_mark_node;
+	      DECL_INITIAL (p) = error_mark_node;
-}
+	    }
-else
+	  else
-warn_for_unused_label (p);
+	    warn_for_unused_label (p);
+	  /* Labels go in BLOCK_VARS.  */
-/* Labels go in BLOCK_VARS.  */
+	  DECL_CHAIN (p) = BLOCK_VARS (block);
-TREE_CHAIN (p) = BLOCK_VARS (block);
+	  BLOCK_VARS (block) = p;
-BLOCK_VARS (block) = p;
+	  gcc_assert (I_LABEL_BINDING (b->id) == b);
-gcc_assert (I_LABEL_BINDING (b->id) == b);
+	  I_LABEL_BINDING (b->id) = b->shadowed;
-I_LABEL_BINDING (b->id) = b->shadowed;
+	  /* Also pop back to the shadowed label_vars.  */
-/* Also pop back to the shadowed label_vars.  */
+	  release_tree_vector (b->u.label->decls_in_scope);
-release_tree_vector (b->u.label->decls_in_scope);
+	  b->u.label = b->u.label->shadowed;
-b->u.label = b->u.label->shadowed;
+	  break;
-break;
+	case ENUMERAL_TYPE:
-case ENUMERAL_TYPE:
+	case UNION_TYPE:
-case UNION_TYPE:
+	case RECORD_TYPE:
-case RECORD_TYPE:
+	  set_type_context (p, context);
-set_type_context (p, context);
+	  /* Types may not have tag-names, in which case the type
-/* Types may not have tag-names, in which case the type
+	     appears in the bindings list with b->id NULL.  */
-appears in the bindings list with b->id NULL.  */
+	  if (b->id)
-if (b->id)
+	    {
-{
+	      gcc_assert (I_TAG_BINDING (b->id) == b);
-gcc_assert (I_TAG_BINDING (b->id) == b);
+	      I_TAG_BINDING (b->id) = b->shadowed;
-I_TAG_BINDING (b->id) = b->shadowed;
+	    }
-}
+	  break;
-break;
+	case FUNCTION_DECL:
-case FUNCTION_DECL:
+	  /* Propagate TREE_ADDRESSABLE from nested functions to their
-/* Propagate TREE_ADDRESSABLE from nested functions to their
+	     containing functions.  */
-containing functions.  */
+	  if (!TREE_ASM_WRITTEN (p)
-if (!TREE_ASM_WRITTEN (p)
+	      && DECL_INITIAL (p) != 0
-&& DECL_INITIAL (p) != 0
+	      && TREE_ADDRESSABLE (p)
-&& TREE_ADDRESSABLE (p)
+	      && DECL_ABSTRACT_ORIGIN (p) != 0
-&& DECL_ABSTRACT_ORIGIN (p) != 0
+	      && DECL_ABSTRACT_ORIGIN (p) != p)
-&& DECL_ABSTRACT_ORIGIN (p) != p)
+	    TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
-TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
+	  if (!DECL_EXTERNAL (p)
-if (!DECL_EXTERNAL (p)
+	      && !DECL_INITIAL (p)
-&& !DECL_INITIAL (p)
+	      && scope != file_scope
-&& scope != file_scope
+	      && scope != external_scope)
-&& scope != external_scope)
+	    {
-{
+	      error ("nested function %q+D declared but never defined", p);
-error ("nested function %q+D declared but never defined", p);
+	      undef_nested_function = true;
-undef_nested_function = true;
+	    }
-}
+	  else if (DECL_DECLARED_INLINE_P (p)
-else if (DECL_DECLARED_INLINE_P (p)
+		   && TREE_PUBLIC (p)
-&& TREE_PUBLIC (p)
+		   && !DECL_INITIAL (p))
-&& !DECL_INITIAL (p))
+	    {
-{
+	      /* C99 6.7.4p6: "a function with external linkage... declared
-/* C99 6.7.4p6: "a function with external linkage... declared
+		 with an inline function specifier ... shall also be defined
-with an inline function specifier ... shall also be defined
+		 in the same translation unit."  */
-in the same translation unit."  */
+	      if (!flag_gnu89_inline)
-if (!flag_gnu89_inline)
+		pedwarn (input_location, 0,
-pedwarn (input_location, 0,
+			 "inline function %q+D declared but never defined", p);
-"inline function %q+D declared but never defined", p);
+	      DECL_EXTERNAL (p) = 1;
-DECL_EXTERNAL (p) = 1;
+	    }
-}
+	  goto common_symbol;
-goto common_symbol;
+	case VAR_DECL:
-case VAR_DECL:
+	  /* Warnings for unused variables.  */
-/* Warnings for unused variables.  */
+	  if ((!TREE_USED (p) || !DECL_READ_P (p))
-if (!TREE_USED (p)
+	      && !TREE_NO_WARNING (p)
-&& !TREE_NO_WARNING (p)
+	      && !DECL_IN_SYSTEM_HEADER (p)
-&& !DECL_IN_SYSTEM_HEADER (p)
+	      && DECL_NAME (p)
-&& DECL_NAME (p)
+	      && !DECL_ARTIFICIAL (p)
-&& !DECL_ARTIFICIAL (p)
+	      && scope != file_scope
-&& scope != file_scope
+	      && scope != external_scope)
-&& scope != external_scope)
+	    {
-warning (OPT_Wunused_variable, "unused variable %q+D", p);
+	      if (!TREE_USED (p))
+		warning (OPT_Wunused_variable, "unused variable %q+D", p);
-if (b->inner_comp)
+	      else if (DECL_CONTEXT (p) == current_function_decl)
-{
+		warning_at (DECL_SOURCE_LOCATION (p),
-error ("type of array %q+D completed incompatibly with"
+			    OPT_Wunused_but_set_variable,
-" implicit initialization", p);
+			    "variable %qD set but not used", p);
-}
+	    }
-/* Fall through.  */
+	  if (b->inner_comp)
-case TYPE_DECL:
+	    {
-case CONST_DECL:
+	      error ("type of array %q+D completed incompatibly with"
-common_symbol:
+		     " implicit initialization", p);
-/* All of these go in BLOCK_VARS, but only if this is the
+	    }
-binding in the home scope.  */
-if (!b->nested)
+	  /* Fall through.  */
-{
+	case TYPE_DECL:
-TREE_CHAIN (p) = BLOCK_VARS (block);
+	case CONST_DECL:
-BLOCK_VARS (block) = p;
+	common_symbol:
-}
+	  /* All of these go in BLOCK_VARS, but only if this is the
-else if (VAR_OR_FUNCTION_DECL_P (p))
+	     binding in the home scope.  */
-{
+	  if (!b->nested)
-/* For block local externs add a special
+	    {
-DECL_EXTERNAL decl for debug info generation.  */
+	      DECL_CHAIN (p) = BLOCK_VARS (block);
-tree extp = copy_node (p);
+	      BLOCK_VARS (block) = p;
+	    }
-DECL_EXTERNAL (extp) = 1;
+	  else if (VAR_OR_FUNCTION_DECL_P (p))
-TREE_STATIC (extp) = 0;
+	    {
-TREE_PUBLIC (extp) = 1;
+	      /* For block local externs add a special
-DECL_INITIAL (extp) = NULL_TREE;
+		 DECL_EXTERNAL decl for debug info generation.  */
-DECL_LANG_SPECIFIC (extp) = NULL;
+	      tree extp = copy_node (p);
-DECL_CONTEXT (extp) = current_function_decl;
-if (TREE_CODE (p) == FUNCTION_DECL)
-{
+	      DECL_EXTERNAL (extp) = 1;
-DECL_RESULT (extp) = NULL_TREE;
+	      TREE_STATIC (extp) = 0;
-DECL_SAVED_TREE (extp) = NULL_TREE;
+	      TREE_PUBLIC (extp) = 1;
-DECL_STRUCT_FUNCTION (extp) = NULL;
+	      DECL_INITIAL (extp) = NULL_TREE;
-}
+	      DECL_LANG_SPECIFIC (extp) = NULL;
-if (b->locus != UNKNOWN_LOCATION)
+	      DECL_CONTEXT (extp) = current_function_decl;
-DECL_SOURCE_LOCATION (extp) = b->locus;
+	      if (TREE_CODE (p) == FUNCTION_DECL)
-TREE_CHAIN (extp) = BLOCK_VARS (block);
+		{
-BLOCK_VARS (block) = extp;
+		  DECL_RESULT (extp) = NULL_TREE;
-}
+		  DECL_SAVED_TREE (extp) = NULL_TREE;
-/* If this is the file scope, and we are processing more
+		  DECL_STRUCT_FUNCTION (extp) = NULL;
-than one translation unit in this compilation, set
+		}
-DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
+	      if (b->locus != UNKNOWN_LOCATION)
-This makes same_translation_unit_p work, and causes
+		DECL_SOURCE_LOCATION (extp) = b->locus;
-static declarations to be given disambiguating suffixes.  */
+	      DECL_CHAIN (extp) = BLOCK_VARS (block);
-if (scope == file_scope && num_in_fnames > 1)
+	      BLOCK_VARS (block) = extp;
-{
+	    }
-DECL_CONTEXT (p) = context;
+	  /* If this is the file scope set DECL_CONTEXT of each decl to
-if (TREE_CODE (p) == TYPE_DECL)
+	     the TRANSLATION_UNIT_DECL.  This makes same_translation_unit_p
-set_type_context (TREE_TYPE (p), context);
+	     work.  */
-}
+	  if (scope == file_scope)
+	    {
-/* Fall through.  */
+	      DECL_CONTEXT (p) = context;
-/* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
+	      if (TREE_CODE (p) == TYPE_DECL
-already been put there by store_parm_decls.  Unused-
+		  && TREE_TYPE (p) != error_mark_node)
-parameter warnings are handled by function.c.
+		set_type_context (TREE_TYPE (p), context);
-error_mark_node obviously does not go in BLOCK_VARS and
+	    }
-does not get unused-variable warnings.  */
-case PARM_DECL:
-case ERROR_MARK:
+	  /* Fall through.  */
-/* It is possible for a decl not to have a name.  We get
+	  /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
-here with b->id NULL in this case.  */
+	     already been put there by store_parm_decls.  Unused-
-if (b->id)
+	     parameter warnings are handled by function.c.
-{
+	     error_mark_node obviously does not go in BLOCK_VARS and
-gcc_assert (I_SYMBOL_BINDING (b->id) == b);
+	     does not get unused-variable warnings.  */
-I_SYMBOL_BINDING (b->id) = b->shadowed;
+	case PARM_DECL:
-if (b->shadowed && b->shadowed->u.type)
+	case ERROR_MARK:
-TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
+	  /* It is possible for a decl not to have a name.  We get
-}
+	     here with b->id NULL in this case.  */
-break;
+	  if (b->id)
+	    {
-default:
+	      gcc_assert (I_SYMBOL_BINDING (b->id) == b);
-gcc_unreachable ();
+	      I_SYMBOL_BINDING (b->id) = b->shadowed;
-}
+	      if (b->shadowed && b->shadowed->u.type)
+		TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
+	    }
+	  break;
+	default:
+	  gcc_unreachable ();
+	}
 }
 /* Dispose of the block that we just made inside some higher level.  */
 if ((scope->function_body || scope == file_scope) && context)
 push_scope ();
 file_scope = current_scope;
 start_fname_decls ();
-for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
+for (decl = visible_builtins; decl; decl = DECL_CHAIN (decl))
 bind (DECL_NAME (decl), decl, file_scope,
 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
 }
 void
 if (!scope->has_label_bindings)
 continue;
 for (b = scope->bindings; b != NULL; b = b->prev)
-{
+	{
-struct c_label_vars *label_vars;
+	  struct c_label_vars *label_vars;
-unsigned int ix;
+	  unsigned int ix;
-struct c_goto_bindings *g;
+	  struct c_goto_bindings *g;
-if (TREE_CODE (b->decl) != LABEL_DECL)
+	  if (TREE_CODE (b->decl) != LABEL_DECL)
-continue;
+	    continue;
-label_vars = b->u.label;
+	  label_vars = b->u.label;
-++label_vars->label_bindings.stmt_exprs;
+	  ++label_vars->label_bindings.stmt_exprs;
-for (ix = 0;
+	  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
-VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
+	    ++g->goto_bindings.stmt_exprs;
-++ix)
+	}
-++g->goto_bindings.stmt_exprs;
-}
 }
 if (switch_bindings != NULL)
 ++switch_bindings->stmt_exprs;
 }
 if (!scope->has_label_bindings)
 continue;
 for (b = scope->bindings; b != NULL; b = b->prev)
-{
+	{
-struct c_label_vars *label_vars;
+	  struct c_label_vars *label_vars;
-unsigned int ix;
+	  unsigned int ix;
-struct c_goto_bindings *g;
+	  struct c_goto_bindings *g;
-if (TREE_CODE (b->decl) != LABEL_DECL)
+	  if (TREE_CODE (b->decl) != LABEL_DECL)
-continue;
+	    continue;
-label_vars = b->u.label;
+	  label_vars = b->u.label;
---label_vars->label_bindings.stmt_exprs;
+	  --label_vars->label_bindings.stmt_exprs;
-if (label_vars->label_bindings.stmt_exprs < 0)
+	  if (label_vars->label_bindings.stmt_exprs < 0)
-{
+	    {
-label_vars->label_bindings.left_stmt_expr = true;
+	      label_vars->label_bindings.left_stmt_expr = true;
-label_vars->label_bindings.stmt_exprs = 0;
+	      label_vars->label_bindings.stmt_exprs = 0;
-}
+	    }
-for (ix = 0;
+	  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
-VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
+	    {
-++ix)
+	      --g->goto_bindings.stmt_exprs;
-{
+	      if (g->goto_bindings.stmt_exprs < 0)
---g->goto_bindings.stmt_exprs;
+		{
-if (g->goto_bindings.stmt_exprs < 0)
+		  g->goto_bindings.left_stmt_expr = true;
-{
+		  g->goto_bindings.stmt_exprs = 0;
-g->goto_bindings.left_stmt_expr = true;
+		}
-g->goto_bindings.stmt_exprs = 0;
+	    }
-}
+	}
-}
-}
 }
 if (switch_bindings != NULL)
 {
 --switch_bindings->stmt_exprs;
 {
 tree t;
 if (TREE_CODE (olddecl) != FUNCTION_DECL
 || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
-|| !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
+|| !((!prototype_p (oldtype) && DECL_INITIAL (olddecl) == 0)
-||
+	   || (!prototype_p (newtype) && DECL_INITIAL (newdecl) == 0)))
-(TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
 return;
 t = TYPE_ARG_TYPES (oldtype);
 if (t == 0)
 t = TYPE_ARG_TYPES (newtype);
 }
 }
 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
 but silently ignore the redeclaration if either is in a system
-header.  (Conflicting redeclarations were handled above.)  */
+header.  (Conflicting redeclarations were handled above.)  This
+is allowed for C1X if the types are the same, not just
+compatible.  */
 if (TREE_CODE (newdecl) == TYPE_DECL)
 {
+bool types_different = false;
+int comptypes_result;
+comptypes_result
+	= comptypes_check_different_types (oldtype, newtype, &types_different);
+if (comptypes_result != 1 || types_different)
+	{
+	  error ("redefinition of typedef %q+D with different type", newdecl);
+	  locate_old_decl (olddecl);
+	  return false;
+	}
 if (DECL_IN_SYSTEM_HEADER (newdecl)
 || DECL_IN_SYSTEM_HEADER (olddecl)
 || TREE_NO_WARNING (newdecl)
 || TREE_NO_WARNING (olddecl))
 return true;  /* Allow OLDDECL to continue in use.  */
-error ("redefinition of typedef %q+D", newdecl);
+if (pedantic && !flag_isoc1x)
-locate_old_decl (olddecl);
+	{
-return false;
+	  pedwarn (input_location, OPT_pedantic,
+		   "redefinition of typedef %q+D", newdecl);
+	  locate_old_decl (olddecl);
+	}
+else if (variably_modified_type_p (newtype, NULL))
+	{
+	  /* Whether there is a constraint violation for the types not
+	     being the same cannot be determined at compile time; a
+	     warning that there may be one at runtime is considered
+	     appropriate (WG14 reflector message 11743, 8 May 2009).  */
+	  warning (0, "redefinition of typedef %q+D may be a constraint "
+		   "violation at runtime", newdecl);
+	  locate_old_decl (olddecl);
+	}
+return true;
 }
 /* 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
 /* If you declare a built-in function name as static, or
 define the built-in with an old-style definition (so we
 can't validate the argument list) the built-in definition is
 overridden, but optionally warn this was a bad choice of name.  */
 if (DECL_BUILT_IN (olddecl)
-&& !C_DECL_DECLARED_BUILTIN (olddecl)
+	  && !C_DECL_DECLARED_BUILTIN (olddecl)
-&& (!TREE_PUBLIC (newdecl)
+	  && (!TREE_PUBLIC (newdecl)
-|| (DECL_INITIAL (newdecl)
+	      || (DECL_INITIAL (newdecl)
-&& !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
+		  && !prototype_p (TREE_TYPE (newdecl)))))
-{
+	{
-warning (OPT_Wshadow, "declaration of %q+D shadows "
+	  warning (OPT_Wshadow, "declaration of %q+D shadows "
-"a built-in function", newdecl);
+		   "a built-in function", newdecl);
-/* Discard the old built-in function.  */
+	  /* Discard the old built-in function.  */
-return false;
+	  return false;
-}
+	}
 if (DECL_INITIAL (newdecl))
 {
 if (DECL_INITIAL (olddecl))
 {
 }
 }
 /* If we have a prototype after an old-style function definition,
 the argument types must be checked specially.  */
 else if (DECL_INITIAL (olddecl)
-&& !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
+	       && !prototype_p (oldtype) && prototype_p (newtype)
-&& TYPE_ACTUAL_ARG_TYPES (oldtype)
+	       && TYPE_ACTUAL_ARG_TYPES (oldtype)
-&& !validate_proto_after_old_defn (newdecl, newtype, oldtype))
+	       && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
-{
+	{
-locate_old_decl (olddecl);
+	  locate_old_decl (olddecl);
-return false;
+	  return false;
-}
+	}
 /* A non-static declaration (even an "extern") followed by a
 static declaration is undefined behavior per C99 6.2.2p3-5,7.
 The same is true for a static forward declaration at block
 scope followed by a non-static declaration/definition at file
 scope.  Static followed by non-static at the same scope is
 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
 {
 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);
+			   && prototype_p (TREE_TYPE (newdecl)));
 bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
-&& TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
+			   && prototype_p (TREE_TYPE (olddecl)));
 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
 forward decl anymore).  */
 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
 /* Also preserve various other info from the definition.  */
 if (!new_is_definition)
-{
+	{
-tree t;
+	  tree t;
-DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
+	  DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
-DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
+	  DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
-DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
+	  DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
-DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
+	  DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
-gimple_set_body (newdecl, gimple_body (olddecl));
+	  DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
-DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
+	  for (t = DECL_ARGUMENTS (newdecl); t ; t = DECL_CHAIN (t))
-for (t = DECL_ARGUMENTS (newdecl); t ; t = TREE_CHAIN (t))
+	    DECL_CONTEXT (t) = newdecl;
-DECL_CONTEXT (t) = newdecl;
+	  /* See if we've got a function to instantiate from.  */
-/* See if we've got a function to instantiate from.  */
+	  if (DECL_SAVED_TREE (olddecl))
-if (DECL_SAVED_TREE (olddecl))
+	    DECL_ABSTRACT_ORIGIN (newdecl)
-DECL_ABSTRACT_ORIGIN (newdecl)
+	      = DECL_ABSTRACT_ORIGIN (olddecl);
-= DECL_ABSTRACT_ORIGIN (olddecl);
+	}
-}
 }
 extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
 /* Merge the USED information.  */
 if (TREE_USED (olddecl))
 TREE_USED (newdecl) = 1;
 else if (TREE_USED (newdecl))
 TREE_USED (olddecl) = 1;
+if (TREE_CODE (olddecl) == VAR_DECL || TREE_CODE (olddecl) == PARM_DECL)
+DECL_READ_P (newdecl) |= DECL_READ_P (olddecl);
+if (DECL_PRESERVE_P (olddecl))
+DECL_PRESERVE_P (newdecl) = 1;
+else if (DECL_PRESERVE_P (newdecl))
+DECL_PRESERVE_P (olddecl) = 1;
 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
 DECL_ARGUMENTS (if appropriate).  */
 {
 (char *) newdecl + sizeof (struct tree_common),
 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:
 case LABEL_DECL:
 case RESULT_DECL:
 error_at (loc, "%qE undeclared here (not in a function)", id);
 scope = current_scope;
 }
 else
 {
-error_at (loc, "%qE undeclared (first use in this function)", id);
+if (!objc_diagnose_private_ivar (id))
+error_at (loc, "%qE undeclared (first use in this function)", id);
 if (!already)
-{
+	{
-error_at (loc, "(Each undeclared identifier is reported only once");
+inform (loc, "each undeclared identifier is reported only"
-error_at (loc, "for each function it appears in.)");
+" once for each function it appears in");
-already = true;
+	  already = true;
-}
+	}
 /* If we are parsing old-style parameter decls, current_function_decl
 will be nonnull but current_function_scope will be null.  */
 scope = current_function_scope ? current_function_scope : current_scope;
 }
 struct c_label_vars *label_vars;
 DECL_CONTEXT (label) = current_function_decl;
 DECL_MODE (label) = VOIDmode;
-label_vars = GGC_NEW (struct c_label_vars);
+label_vars = ggc_alloc_c_label_vars ();
 label_vars->shadowed = NULL;
 set_spot_bindings (&label_vars->label_bindings, defining);
 label_vars->decls_in_scope = make_tree_vector ();
 label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
 *p_label_vars = label_vars;
 lookup_label (tree name)
 {
 tree label;
 struct c_label_vars *label_vars;
-if (current_function_decl == 0)
+if (current_function_scope == 0)
 {
 error ("label %qE referenced outside of any function", name);
 return 0;
 }
 list for possible later warnings.  */
 if (label_vars->label_bindings.scope == NULL)
 {
 struct c_goto_bindings *g;
-g = GGC_NEW (struct c_goto_bindings);
+g = ggc_alloc_c_goto_bindings ();
 g->loc = loc;
 set_spot_bindings (&g->goto_bindings, true);
 VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
 return label;
 }
 int i = 1;
 lab:
 ...
 goto lab;
 Issue a warning or error.  */
-for (ix = 0; VEC_iterate (tree, label_vars->decls_in_scope, ix, decl); ++ix)
+FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
 warn_about_goto (loc, label, decl);
 if (label_vars->label_bindings.left_stmt_expr)
 {
 error_at (loc, "jump into statement expression");
 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
 {
 unsigned int ix;
 struct c_goto_bindings *g;
-for (ix = 0;
+FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
-VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
-++ix)
 {
 struct c_binding *b;
 struct c_scope *scope;
 /* We have a goto to this label.  The goto is going forward.  In
-g->scope, the goto is going to skip any binding which was
+	 g->scope, the goto is going to skip any binding which was
-defined after g->bindings_in_scope.  */
+	 defined after g->bindings_in_scope.  */
-for (b = g->goto_bindings.scope->bindings;
+if (g->goto_bindings.scope->has_jump_unsafe_decl)
-b != g->goto_bindings.bindings_in_scope;
+	{
-b = b->prev)
+	  for (b = g->goto_bindings.scope->bindings;
-{
+	       b != g->goto_bindings.bindings_in_scope;
-if (decl_jump_unsafe (b->decl))
+	       b = b->prev)
-warn_about_goto (g->loc, label, b->decl);
+	    {
-}
+	      if (decl_jump_unsafe (b->decl))
+		warn_about_goto (g->loc, label, b->decl);
+	    }
+	}
 /* We also need to warn about decls defined in any scopes
 between the scope of the label and the scope of the goto.  */
 for (scope = label_vars->label_bindings.scope;
-scope != g->goto_bindings.scope;
+	   scope != g->goto_bindings.scope;
-scope = scope->outer)
+	   scope = scope->outer)
-{
+	{
-gcc_assert (scope != NULL);
+	  gcc_assert (scope != NULL);
-if (scope == label_vars->label_bindings.scope)
+	  if (scope->has_jump_unsafe_decl)
-b = label_vars->label_bindings.bindings_in_scope;
+	    {
-else
+	      if (scope == label_vars->label_bindings.scope)
-b = scope->bindings;
+		b = label_vars->label_bindings.bindings_in_scope;
-for (; b != NULL; b = b->prev)
+	      else
-{
+		b = scope->bindings;
-if (decl_jump_unsafe (b->decl))
+	      for (; b != NULL; b = b->prev)
-warn_about_goto (g->loc, label, b->decl);
+		{
-}
+		  if (decl_jump_unsafe (b->decl))
-}
+		    warn_about_goto (g->loc, label, b->decl);
+		}
+	    }
+	}
 if (g->goto_bindings.stmt_exprs > 0)
 {
 error_at (g->loc, "jump into statement expression");
 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
 scope = scope->outer)
 {
 struct c_binding *b;
 gcc_assert (scope != NULL);
+if (!scope->has_jump_unsafe_decl)
+	continue;
 for (b = scope->bindings; b != NULL; b = b->prev)
 {
 if (decl_jump_unsafe (b->decl))
 {
 if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
 /* Declarations from c_common_nodes_and_builtins must not be associated
 with this input file, lest we get differences between using and not
 using preprocessed headers.  */
 input_location = BUILTINS_LOCATION;
-build_common_tree_nodes (flag_signed_char, false);
+build_common_tree_nodes (flag_signed_char);
 c_common_nodes_and_builtins ();
 /* In C, comparisons and TRUTH_* expressions have type int.  */
 truthvalue_type_node = integer_type_node;
 /* For invalid programs like this:
 void foo()
 const char* p = __FUNCTION__;
-the __FUNCTION__ is believed to appear in K&R style function
+	 the __FUNCTION__ is believed to appear in K&R style function
-parameter declarator.  In that case we still don't have
+	 parameter declarator.  In that case we still don't have
-function_scope.  */
+	 function_scope.  */
-&& (!errorcount || current_function_scope))
+&& (!seen_error () || current_function_scope))
 {
 DECL_CONTEXT (decl) = current_function_decl;
 bind (id, decl, current_function_scope,
 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
 }
 {
 tree type = TREE_TYPE (decl);
 tree   id = DECL_NAME (decl);
 const char *name = IDENTIFIER_POINTER (id);
-C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
+C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
 /* Should never be called on a symbol with a preexisting meaning.  */
 gcc_assert (!I_SYMBOL_BINDING (id));
 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
 /* Builtins in the implementation namespace are made visible without
 needing to be explicitly declared.  See push_file_scope.  */
 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
 {
-TREE_CHAIN (decl) = visible_builtins;
+DECL_CHAIN (decl) = visible_builtins;
 visible_builtins = decl;
 }
 return decl;
 }
 {
 tree type = TREE_TYPE (decl);
 tree   id = DECL_NAME (decl);
 const char *name = IDENTIFIER_POINTER (id);
-C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
+C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
 /* Should never be called on a symbol with a preexisting meaning.  */
 gcc_assert (!I_SYMBOL_BINDING (id));
 bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
 /* Builtins in the implementation namespace are made visible without
 needing to be explicitly declared.  See push_file_scope.  */
 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
 {
-TREE_CHAIN (decl) = visible_builtins;
+DECL_CHAIN (decl) = visible_builtins;
 visible_builtins = decl;
 }
 return decl;
 }
 {
 tree value = declspecs->type;
 enum tree_code code = TREE_CODE (value);
 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
-/* Used to test also that TYPE_SIZE (value) != 0.
+	/* Used to test also that TYPE_SIZE (value) != 0.
-That caused warning for `struct foo;' at top level in the file.  */
+	   That caused warning for `struct foo;' at top level in the file.  */
-{
+	{
-tree name = TYPE_NAME (value);
+	  tree name = TYPE_NAME (value);
-tree t;
+	  tree t;
-found_tag = true;
+	  found_tag = true;
-if (declspecs->restrict_p)
+	  if (declspecs->restrict_p)
-{
+	    {
-error ("invalid use of %<restrict%>");
+	      error ("invalid use of %<restrict%>");
-warned = 1;
+	      warned = 1;
-}
+	    }
-if (name == 0)
+	  if (name == 0)
-{
+	    {
-if (warned != 1 && code != ENUMERAL_TYPE)
+	      if (warned != 1 && code != ENUMERAL_TYPE)
-/* Empty unnamed enum OK */
+		/* Empty unnamed enum OK */
-{
+		{
-pedwarn (input_location, 0,
+		  pedwarn (input_location, 0,
-"unnamed struct/union that defines no instances");
+			   "unnamed struct/union that defines no instances");
-warned = 1;
+		  warned = 1;
-}
+		}
-}
+	    }
-else if (!declspecs->tag_defined_p
+	  else if (declspecs->typespec_kind != ctsk_tagdef
-&& declspecs->storage_class != csc_none)
+&& declspecs->typespec_kind != ctsk_tagfirstref
-{
+		   && declspecs->storage_class != csc_none)
-if (warned != 1)
+	    {
-pedwarn (input_location, 0,
+	      if (warned != 1)
-"empty declaration with storage class specifier "
+		pedwarn (input_location, 0,
-"does not redeclare tag");
+			 "empty declaration with storage class specifier "
-warned = 1;
+			 "does not redeclare tag");
-pending_xref_error ();
+	      warned = 1;
-}
+	      pending_xref_error ();
-else if (!declspecs->tag_defined_p
+	    }
-&& (declspecs->const_p
+	  else if (declspecs->typespec_kind != ctsk_tagdef
-|| declspecs->volatile_p
+&& declspecs->typespec_kind != ctsk_tagfirstref
-|| declspecs->restrict_p
+		   && (declspecs->const_p
-|| declspecs->address_space))
+		       || declspecs->volatile_p
-{
+		       || declspecs->restrict_p
-if (warned != 1)
+		       || declspecs->address_space))
-pedwarn (input_location, 0,
+	    {
-"empty declaration with type qualifier "
+	      if (warned != 1)
-"does not redeclare tag");
+		pedwarn (input_location, 0,
-warned = 1;
+			 "empty declaration with type qualifier "
-pending_xref_error ();
+			  "does not redeclare tag");
-}
+	      warned = 1;
+	      pending_xref_error ();
+	    }
+	  else
+	    {
+	      pending_invalid_xref = 0;
+	      t = lookup_tag (code, name, 1, NULL);
+	      if (t == 0)
+		{
+		  t = make_node (code);
+		  pushtag (input_location, name, t);
+		}
+	    }
+	}
 else
 {
 pending_invalid_xref = 0;
 t = lookup_tag (code, name, 1, NULL);
 /* If this is a function declaration, write a record describing it to the
 prototypes file (if requested).  */
 if (TREE_CODE (decl) == FUNCTION_DECL)
-gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
+gen_aux_info_record (decl, 0, 0, prototype_p (TREE_TYPE (decl)));
 /* ANSI specifies that a tentative definition which is not merged with
 a non-tentative definition behaves exactly like a definition with an
 initializer equal to zero.  (Section 3.7.2)
 struct c_declarator *ce = declarator;
 if (ce->kind == cdk_pointer)
 ce = declarator->declarator;
 if (ce->kind == cdk_function)
-{
+	{
-tree args = ce->u.arg_info->parms;
+	  tree args = ce->u.arg_info->parms;
-for (; args; args = TREE_CHAIN (args))
+	  for (; args; args = DECL_CHAIN (args))
-{
+	    {
-tree type = TREE_TYPE (args);
+	      tree type = TREE_TYPE (args);
-if (type && INTEGRAL_TYPE_P (type)
+	      if (type && INTEGRAL_TYPE_P (type)
-&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
+		  && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
-DECL_ARG_TYPE (args) = integer_type_node;
+		DECL_ARG_TYPE (args) = integer_type_node;
-}
+	    }
-}
+	}
 }
 if (TREE_CODE (decl) == FUNCTION_DECL
 && DECL_DECLARED_INLINE_P (decl)
 && DECL_UNINLINABLE (decl)
 && DECL_DECLARED_INLINE_P (current_function_decl)
 && DECL_EXTERNAL (current_function_decl))
 record_inline_static (input_location, current_function_decl,
 decl, csi_modifiable);
+if (c_dialect_objc ()
+&& (TREE_CODE (decl) == VAR_DECL
+|| TREE_CODE (decl) == FUNCTION_DECL))
+objc_check_global_decl (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);
 if (initialized && DECL_EXTERNAL (tem))
 DECL_EXTERNAL (tem) = 0;
 TREE_STATIC (tem) = 1;
 }
 return tem;
+}
+/* Subroutine of finish_decl. TYPE is the type of an uninitialized object
+DECL or the non-array element type if DECL is an uninitialized array.
+If that type has a const member, diagnose this. */
+static void
+diagnose_uninitialized_cst_member (tree decl, tree type)
+{
+tree field;
+for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+{
+tree field_type;
+if (TREE_CODE (field) != FIELD_DECL)
+	continue;
+field_type = strip_array_types (TREE_TYPE (field));
+if (TYPE_QUALS (field_type) & TYPE_QUAL_CONST)
+	{
+	  warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
+	  	      "uninitialized const member in %qT is invalid in C++",
+		      strip_array_types (TREE_TYPE (decl)));
+	  inform (DECL_SOURCE_LOCATION (field), "%qD should be initialized", field);
+	}
+if (TREE_CODE (field_type) == RECORD_TYPE
+	  || TREE_CODE (field_type) == UNION_TYPE)
+	diagnose_uninitialized_cst_member (decl, field_type);
+}
 }
 /* Finish processing of a declaration;
 install its initial value.
 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
 TREE_TYPE (decl) = error_mark_node;
 }
 }
 if (TREE_USED (type))
-TREE_USED (decl) = 1;
+	{
+	  TREE_USED (decl) = 1;
+	  DECL_READ_P (decl) = 1;
+	}
 }
 /* If this is a function and an assembler name is specified, reset DECL_RTL
 so we can give it its new name.  Also, update built_in_decls if it
 was a normal built-in.  */
 /* Install a cleanup (aka destructor) if one was given.  */
 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
 {
 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
 if (attr)
-{
+	{
-tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
+	  tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
-tree cleanup_decl = lookup_name (cleanup_id);
+	  tree cleanup_decl = lookup_name (cleanup_id);
-tree cleanup;
+	  tree cleanup;
-VEC(tree,gc) *vec;
+	  VEC(tree,gc) *vec;
-/* Build "cleanup(&decl)" for the destructor.  */
+	  /* Build "cleanup(&decl)" for the destructor.  */
-cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
+	  cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
-vec = VEC_alloc (tree, gc, 1);
+	  vec = VEC_alloc (tree, gc, 1);
-VEC_quick_push (tree, vec, cleanup);
+	  VEC_quick_push (tree, vec, cleanup);
-cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
+	  cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
-cleanup_decl, vec, NULL);
+	      				     cleanup_decl, vec, NULL);
-VEC_free (tree, gc, vec);
+	  VEC_free (tree, gc, vec);
-/* Don't warn about decl unused; the cleanup uses it.  */
+	  /* Don't warn about decl unused; the cleanup uses it.  */
-TREE_USED (decl) = 1;
+	  TREE_USED (decl) = 1;
-TREE_USED (cleanup_decl) = 1;
+	  TREE_USED (cleanup_decl) = 1;
+	  DECL_READ_P (decl) = 1;
-push_cleanup (decl, cleanup, false);
-}
+	  push_cleanup (decl, cleanup, false);
+	}
 }
 if (warn_cxx_compat
 && TREE_CODE (decl) == VAR_DECL
-&& TREE_READONLY (decl)
 && !DECL_EXTERNAL (decl)
 && DECL_INITIAL (decl) == NULL_TREE)
-warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
+{
-"uninitialized const %qD is invalid in C++", decl);
+type = strip_array_types (type);
+if (TREE_READONLY (decl))
+	warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
+		    "uninitialized const %qD is invalid in C++", decl);
+else if ((TREE_CODE (type) == RECORD_TYPE
+	      	|| TREE_CODE (type) == UNION_TYPE)
+	       && C_TYPE_FIELDS_READONLY (type))
+	diagnose_uninitialized_cst_member (decl, type);
+}
 }
 /* Given a parsed parameter declaration, decode it into a PARM_DECL.  */
 tree
 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR.  */
 tree decl;
 tree complit;
 tree stmt;
-if (type == error_mark_node)
+if (type == error_mark_node
+|| init == error_mark_node)
 return error_mark_node;
 decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
 DECL_EXTERNAL (decl) = 0;
 TREE_PUBLIC (decl) = 0;
 TREE_STATIC (decl) = (current_scope == file_scope);
 DECL_CONTEXT (decl) = current_function_decl;
 TREE_USED (decl) = 1;
+DECL_READ_P (decl) = 1;
 TREE_TYPE (decl) = type;
 TREE_READONLY (decl) = TYPE_READONLY (type);
 store_init_value (loc, decl, init, NULL_TREE);
 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
 is valid for C++.  */
 void
 check_compound_literal_type (location_t loc, struct c_type_name *type_name)
 {
-if (warn_cxx_compat && type_name->specs->tag_defined_p)
+if (warn_cxx_compat
+&& (type_name->specs->typespec_kind == ctsk_tagdef
+|| type_name->specs->typespec_kind == ctsk_tagfirstref))
 warning_at (loc, OPT_Wc___compat,
 "defining a type in a compound literal is invalid in C++");
 }
 /* Determine whether TYPE is a structure with a flexible array member,
 switch (TREE_CODE (type))
 {
 case RECORD_TYPE:
 x = TYPE_FIELDS (type);
 if (x == NULL_TREE)
-return false;
+	return false;
-while (TREE_CHAIN (x) != NULL_TREE)
+while (DECL_CHAIN (x) != NULL_TREE)
-x = TREE_CHAIN (x);
+	x = DECL_CHAIN (x);
 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
 return true;
 return false;
 case UNION_TYPE:
-for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
+for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
-{
+	{
-if (flexible_array_type_p (TREE_TYPE (x)))
+	  if (flexible_array_type_p (TREE_TYPE (x)))
-return true;
+	    return true;
-}
+	}
 return false;
 default:
 return false;
 }
 }
 location_t loc = UNKNOWN_LOCATION;
 const char *errmsg;
 tree expr_dummy;
 bool expr_const_operands_dummy;
+if (TREE_CODE (type) == ERROR_MARK)
+return error_mark_node;
 if (expr == NULL)
 expr = &expr_dummy;
 if (expr_const_operands == NULL)
 expr_const_operands = &expr_const_operands_dummy;
 array_ptr_attrs = NULL_TREE;
 array_parm_static = 0;
 }
 switch (declarator->kind)
-{
+	{
-case cdk_attrs:
+	case cdk_attrs:
-{
+	  {
-/* A declarator with embedded attributes.  */
+	    /* A declarator with embedded attributes.  */
-tree attrs = declarator->u.attrs;
+	    tree attrs = declarator->u.attrs;
-const struct c_declarator *inner_decl;
+	    const struct c_declarator *inner_decl;
-int attr_flags = 0;
+	    int attr_flags = 0;
-declarator = declarator->declarator;
+	    declarator = declarator->declarator;
-inner_decl = declarator;
+	    inner_decl = declarator;
-while (inner_decl->kind == cdk_attrs)
+	    while (inner_decl->kind == cdk_attrs)
-inner_decl = inner_decl->declarator;
+	      inner_decl = inner_decl->declarator;
-if (inner_decl->kind == cdk_id)
+	    if (inner_decl->kind == cdk_id)
-attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
+	      attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
-else if (inner_decl->kind == cdk_function)
+	    else if (inner_decl->kind == cdk_function)
-attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
+	      attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
-else if (inner_decl->kind == cdk_array)
+	    else if (inner_decl->kind == cdk_array)
-attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
+	      attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
-returned_attrs = decl_attributes (&type,
+	    returned_attrs = decl_attributes (&type,
-chainon (returned_attrs, attrs),
+					      chainon (returned_attrs, attrs),
-attr_flags);
+					      attr_flags);
-break;
+	    break;
-}
+	  }
-case cdk_array:
+	case cdk_array:
-{
+	  {
-tree itype = NULL_TREE;
+	    tree itype = NULL_TREE;
-tree size = declarator->u.array.dimen;
+	    tree size = declarator->u.array.dimen;
-/* The index is a signed object `sizetype' bits wide.  */
+	    /* The index is a signed object `sizetype' bits wide.  */
-tree index_type = c_common_signed_type (sizetype);
+	    tree index_type = c_common_signed_type (sizetype);
-array_ptr_quals = declarator->u.array.quals;
+	    array_ptr_quals = declarator->u.array.quals;
-array_ptr_attrs = declarator->u.array.attrs;
+	    array_ptr_attrs = declarator->u.array.attrs;
-array_parm_static = declarator->u.array.static_p;
+	    array_parm_static = declarator->u.array.static_p;
-array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
+	    array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
-declarator = declarator->declarator;
+	    declarator = declarator->declarator;
-/* Check for some types that there cannot be arrays of.  */
+	    /* Check for some types that there cannot be arrays of.  */
-if (VOID_TYPE_P (type))
+	    if (VOID_TYPE_P (type))
-{
+	      {
-if (name)
+		if (name)
-error_at (loc, "declaration of %qE as array of voids", name);
+		  error_at (loc, "declaration of %qE as array of voids", name);
-else
+		else
-error_at (loc, "declaration of type name as array of voids");
+		  error_at (loc, "declaration of type name as array of voids");
-type = error_mark_node;
+		type = error_mark_node;
-}
+	      }
-if (TREE_CODE (type) == FUNCTION_TYPE)
+	    if (TREE_CODE (type) == FUNCTION_TYPE)
-{
+	      {
-if (name)
+		if (name)
-error_at (loc, "declaration of %qE as array of functions",
+		  error_at (loc, "declaration of %qE as array of functions",
-name);
+		      	    name);
-else
+		else
-error_at (loc, "declaration of type name as array of "
+		  error_at (loc, "declaration of type name as array of "
-"functions");
+		            "functions");
-type = error_mark_node;
+		type = error_mark_node;
-}
+	      }
+	    if (pedantic && !in_system_header && flexible_array_type_p (type))
-if (pedantic && !in_system_header && flexible_array_type_p (type))
+	      pedwarn (loc, OPT_pedantic,
-pedwarn (loc, OPT_pedantic,
+		       "invalid use of structure with flexible array member");
-"invalid use of structure with flexible array member");
+	    if (size == error_mark_node)
-if (size == error_mark_node)
+	      type = error_mark_node;
-type = error_mark_node;
+	    if (type == error_mark_node)
-if (type == error_mark_node)
+	      continue;
-continue;
+	    /* If size was specified, set ITYPE to a range-type for
-/* If size was specified, set ITYPE to a range-type for
+	       that size.  Otherwise, ITYPE remains null.  finish_decl
-that size.  Otherwise, ITYPE remains null.  finish_decl
+	       may figure it out from an initial value.  */
-may figure it out from an initial value.  */
+	    if (size)
-if (size)
+	      {
-{
+		bool size_maybe_const = true;
-bool size_maybe_const = true;
+		bool size_int_const = (TREE_CODE (size) == INTEGER_CST
-bool size_int_const = (TREE_CODE (size) == INTEGER_CST
+				       && !TREE_OVERFLOW (size));
-&& !TREE_OVERFLOW (size));
+		bool this_size_varies = false;
-bool this_size_varies = false;
+		/* Strip NON_LVALUE_EXPRs since we aren't using as an
-/* Strip NON_LVALUE_EXPRs since we aren't using as an
+		   lvalue.  */
-lvalue.  */
+		STRIP_TYPE_NOPS (size);
-STRIP_TYPE_NOPS (size);
+		if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
-if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
+		  {
-{
+		    if (name)
-if (name)
+		      error_at (loc, "size of array %qE has non-integer type",
-error_at (loc, "size of array %qE has non-integer type",
+			  	name);
-name);
+		    else
-else
+		      error_at (loc,
-error_at (loc,
+			  	"size of unnamed array has non-integer type");
-"size of unnamed array has non-integer type");
+		    size = integer_one_node;
-size = integer_one_node;
+		  }
-}
+		size = c_fully_fold (size, false, &size_maybe_const);
-size = c_fully_fold (size, false, &size_maybe_const);
+		if (pedantic && size_maybe_const && integer_zerop (size))
-if (pedantic && size_maybe_const && integer_zerop (size))
+		  {
-{
+		    if (name)
-if (name)
+		      pedwarn (loc, OPT_pedantic,
-pedwarn (loc, OPT_pedantic,
+			       "ISO C forbids zero-size array %qE", name);
-"ISO C forbids zero-size array %qE", name);
+		    else
-else
+		      pedwarn (loc, OPT_pedantic,
-pedwarn (loc, OPT_pedantic,
+			       "ISO C forbids zero-size array");
-"ISO C forbids zero-size array");
+		  }
-}
+		if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
-if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
+		  {
-{
+		    constant_expression_warning (size);
-constant_expression_warning (size);
+		    if (tree_int_cst_sgn (size) < 0)
-if (tree_int_cst_sgn (size) < 0)
+		      {
-{
+			if (name)
-if (name)
+			  error_at (loc, "size of array %qE is negative", name);
-error_at (loc, "size of array %qE is negative", name);
+			else
-else
+			  error_at (loc, "size of unnamed array is negative");
-error_at (loc, "size of unnamed array is negative");
+			size = integer_one_node;
-size = integer_one_node;
+		      }
-}
+		    /* Handle a size folded to an integer constant but
-/* Handle a size folded to an integer constant but
+		       not an integer constant expression.  */
-not an integer constant expression.  */
+		    if (!size_int_const)
-if (!size_int_const)
+		      {
-{
+			/* If this is a file scope declaration of an
-/* If this is a file scope declaration of an
+			   ordinary identifier, this is invalid code;
-ordinary identifier, this is invalid code;
+			   diagnosing it here and not subsequently
-diagnosing it here and not subsequently
+			   treating the type as variable-length avoids
-treating the type as variable-length avoids
+			   more confusing diagnostics later.  */
-more confusing diagnostics later.  */
+			if ((decl_context == NORMAL || decl_context == FIELD)
-if ((decl_context == NORMAL || decl_context == FIELD)
+			    && current_scope == file_scope)
-&& current_scope == file_scope)
+			  pedwarn (input_location, 0,
-pedwarn (input_location, 0,
+				   "variably modified %qE at file scope",
-"variably modified %qE at file scope",
+				   name);
-name);
+			else
-else
+			  this_size_varies = size_varies = true;
-this_size_varies = size_varies = true;
+			warn_variable_length_array (name, size);
-warn_variable_length_array (name, size);
+		      }
-}
+		  }
-}
+		else if ((decl_context == NORMAL || decl_context == FIELD)
-else if ((decl_context == NORMAL || decl_context == FIELD)
+			 && current_scope == file_scope)
-&& current_scope == file_scope)
+		  {
-{
+		    error_at (loc, "variably modified %qE at file scope", name);
-error_at (loc, "variably modified %qE at file scope", name);
+		    size = integer_one_node;
-size = integer_one_node;
+		  }
-}
+		else
-else
+		  {
-{
+		    /* Make sure the array size remains visibly
-/* Make sure the array size remains visibly
+		       nonconstant even if it is (eg) a const variable
-nonconstant even if it is (eg) a const variable
+		       with known value.  */
-with known value.  */
+		    this_size_varies = size_varies = true;
-this_size_varies = size_varies = true;
+		    warn_variable_length_array (name, size);
-warn_variable_length_array (name, size);
+		  }
-}
+		if (integer_zerop (size) && !this_size_varies)
-if (integer_zerop (size) && !this_size_varies)
+		  {
-{
+		    /* A zero-length array cannot be represented with
-/* A zero-length array cannot be represented with
+		       an unsigned index type, which is what we'll
-an unsigned index type, which is what we'll
+		       get with build_index_type.  Create an
-get with build_index_type.  Create an
+		       open-ended range instead.  */
-open-ended range instead.  */
+		    itype = build_range_type (sizetype, size, NULL_TREE);
-itype = build_range_type (sizetype, size, NULL_TREE);
+		  }
-}
+		else
-else
+		  {
-{
+		    /* Arrange for the SAVE_EXPR on the inside of the
-/* Arrange for the SAVE_EXPR on the inside of the
+		       MINUS_EXPR, which allows the -1 to get folded
-MINUS_EXPR, which allows the -1 to get folded
+		       with the +1 that happens when building TYPE_SIZE.  */
-with the +1 that happens when building TYPE_SIZE.  */
+		    if (size_varies)
-if (size_varies)
+		      size = c_variable_size (size);
-size = c_variable_size (size);
+		    if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
-if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
+		      size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
-size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
+				     integer_zero_node, size);
-integer_zero_node, size);
+		    /* Compute the maximum valid index, that is, size
-/* Compute the maximum valid index, that is, size
+		       - 1.  Do the calculation in index_type, so that
-- 1.  Do the calculation in index_type, so that
+		       if it is a variable the computations will be
-if it is a variable the computations will be
+		       done in the proper mode.  */
-done in the proper mode.  */
+		    itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
-itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
+					     convert (index_type, size),
-convert (index_type, size),
+					     convert (index_type,
-convert (index_type,
+						      size_one_node));
-size_one_node));
+		    /* If that overflowed, the array is too big.  ???
-/* If that overflowed, the array is too big.  ???
+		       While a size of INT_MAX+1 technically shouldn't
-While a size of INT_MAX+1 technically shouldn't
+		       cause an overflow (because we subtract 1), the
-cause an overflow (because we subtract 1), the
+		       overflow is recorded during the conversion to
-overflow is recorded during the conversion to
+		       index_type, before the subtraction.  Handling
-index_type, before the subtraction.  Handling
+		       this case seems like an unnecessary
-this case seems like an unnecessary
+		       complication.  */
-complication.  */
+		    if (TREE_CODE (itype) == INTEGER_CST
-if (TREE_CODE (itype) == INTEGER_CST
+			&& TREE_OVERFLOW (itype))
-&& TREE_OVERFLOW (itype))
+		      {
-{
+			if (name)
-if (name)
+			  error_at (loc, "size of array %qE is too large",
-error_at (loc, "size of array %qE is too large",
+			            name);
-name);
+			else
-else
+			  error_at (loc, "size of unnamed array is too large");
-error_at (loc, "size of unnamed array is too large");
+			type = error_mark_node;
-type = error_mark_node;
+			continue;
-continue;
+		      }
-}
+		    itype = build_index_type (itype);
-itype = build_index_type (itype);
+		  }
-}
+		if (this_size_varies)
-if (this_size_varies)
+		  {
-{
+		    if (*expr)
-if (*expr)
+		      *expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
-*expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
+				      *expr, size);
-*expr, size);
+		    else
-else
+		      *expr = size;
-*expr = size;
+		    *expr_const_operands &= size_maybe_const;
-*expr_const_operands &= size_maybe_const;
+		  }
-}
+	      }
-}
+	    else if (decl_context == FIELD)
-else if (decl_context == FIELD)
+	      {
-{
+		bool flexible_array_member = false;
-bool flexible_array_member = false;
+		if (array_parm_vla_unspec_p)
-if (array_parm_vla_unspec_p)
+		  /* Field names can in fact have function prototype
-/* Field names can in fact have function prototype
+		     scope so [*] is disallowed here through making
-scope so [*] is disallowed here through making
+		     the field variably modified, not through being
-the field variably modified, not through being
+		     something other than a declaration with function
-something other than a declaration with function
+		     prototype scope.  */
-prototype scope.  */
+		  size_varies = true;
-size_varies = true;
+		else
-else
+		  {
-{
+		    const struct c_declarator *t = declarator;
-const struct c_declarator *t = declarator;
+		    while (t->kind == cdk_attrs)
-while (t->kind == cdk_attrs)
+		      t = t->declarator;
-t = t->declarator;
+		    flexible_array_member = (t->kind == cdk_id);
-flexible_array_member = (t->kind == cdk_id);
+		  }
-}
+		if (flexible_array_member
-if (flexible_array_member
+		    && pedantic && !flag_isoc99 && !in_system_header)
-&& pedantic && !flag_isoc99 && !in_system_header)
+		  pedwarn (loc, OPT_pedantic,
-pedwarn (loc, OPT_pedantic,
+			   "ISO C90 does not support flexible array members");
-"ISO C90 does not support flexible array members");
+		/* ISO C99 Flexible array members are effectively
-/* ISO C99 Flexible array members are effectively
+		   identical to GCC's zero-length array extension.  */
-identical to GCC's zero-length array extension.  */
+		if (flexible_array_member || array_parm_vla_unspec_p)
-if (flexible_array_member || array_parm_vla_unspec_p)
+		  itype = build_range_type (sizetype, size_zero_node,
-itype = build_range_type (sizetype, size_zero_node,
+					    NULL_TREE);
-NULL_TREE);
+	      }
-}
+	    else if (decl_context == PARM)
-else if (decl_context == PARM)
+	      {
-{
+		if (array_parm_vla_unspec_p)
-if (array_parm_vla_unspec_p)
+		  {
-{
+		    itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
-itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
+		    size_varies = true;
-size_varies = true;
+		  }
-}
+	      }
-}
+	    else if (decl_context == TYPENAME)
-else if (decl_context == TYPENAME)
+	      {
-{
+		if (array_parm_vla_unspec_p)
-if (array_parm_vla_unspec_p)
+		  {
-{
+		    /* C99 6.7.5.2p4 */
-/* C99 6.7.5.2p4 */
+		    warning (0, "%<[*]%> not in a declaration");
-warning (0, "%<[*]%> not in a declaration");
+		    /* We use this to avoid messing up with incomplete
-/* We use this to avoid messing up with incomplete
+		       array types of the same type, that would
-array types of the same type, that would
+		       otherwise be modified below.  */
-otherwise be modified below.  */
+		    itype = build_range_type (sizetype, size_zero_node,
-itype = build_range_type (sizetype, size_zero_node,
+					      NULL_TREE);
-NULL_TREE);
+		    size_varies = true;
-size_varies = true;
+		  }
-}
+	      }
-}
+	     /* Complain about arrays of incomplete types.  */
-/* Complain about arrays of incomplete types.  */
+	    if (!COMPLETE_TYPE_P (type))
-if (!COMPLETE_TYPE_P (type))
+	      {
-{
+		error_at (loc, "array type has incomplete element type");
-error_at (loc, "array type has incomplete element type");
+		type = error_mark_node;
-type = error_mark_node;
+	      }
-}
+	    else
-else
+	    /* When itype is NULL, a shared incomplete array type is
-/* When itype is NULL, a shared incomplete array type is
+	       returned for all array of a given type.  Elsewhere we
-returned for all array of a given type.  Elsewhere we
+	       make sure we don't complete that type before copying
-make sure we don't complete that type before copying
+	       it, but here we want to make sure we don't ever
-it, but here we want to make sure we don't ever
+	       modify the shared type, so we gcc_assert (itype)
-modify the shared type, so we gcc_assert (itype)
+	       below.  */
-below.  */
+	      {
-{
+		addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals);
-addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals);
+		if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
-if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
+		  type = build_qualified_type (type,
-type = build_qualified_type (type,
+					       ENCODE_QUAL_ADDR_SPACE (as));
-ENCODE_QUAL_ADDR_SPACE (as));
+		type = build_array_type (type, itype);
-type = build_array_type (type, itype);
+	      }
-}
+	    if (type != error_mark_node)
-if (type != error_mark_node)
+	      {
-{
+		if (size_varies)
-if (size_varies)
+		  {
-{
+		    /* It is ok to modify type here even if itype is
-/* It is ok to modify type here even if itype is
+		       NULL: if size_varies, we're in a
-NULL: if size_varies, we're in a
+		       multi-dimensional array and the inner type has
-multi-dimensional array and the inner type has
+		       variable size, so the enclosing shared array type
-variable size, so the enclosing shared array type
+		       must too.  */
-must too.  */
+		    if (size && TREE_CODE (size) == INTEGER_CST)
-if (size && TREE_CODE (size) == INTEGER_CST)
+		      type
-type
+			= build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
-= build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
+		    C_TYPE_VARIABLE_SIZE (type) = 1;
-C_TYPE_VARIABLE_SIZE (type) = 1;
+		  }
-}
+		/* The GCC extension for zero-length arrays differs from
-/* The GCC extension for zero-length arrays differs from
+		   ISO flexible array members in that sizeof yields
-ISO flexible array members in that sizeof yields
+		   zero.  */
-zero.  */
+		if (size && integer_zerop (size))
-if (size && integer_zerop (size))
+		  {
-{
+		    gcc_assert (itype);
-gcc_assert (itype);
+		    type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
-TYPE_SIZE (type) = bitsize_zero_node;
+		    TYPE_SIZE (type) = bitsize_zero_node;
-TYPE_SIZE_UNIT (type) = size_zero_node;
+		    TYPE_SIZE_UNIT (type) = size_zero_node;
-}
+		    SET_TYPE_STRUCTURAL_EQUALITY (type);
-if (array_parm_vla_unspec_p)
+		  }
-{
+		if (array_parm_vla_unspec_p)
-gcc_assert (itype);
+		  {
-/* The type is complete.  C99 6.7.5.2p4  */
+		    gcc_assert (itype);
-TYPE_SIZE (type) = bitsize_zero_node;
+		    /* The type is complete.  C99 6.7.5.2p4  */
-TYPE_SIZE_UNIT (type) = size_zero_node;
+		    type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
-}
+		    TYPE_SIZE (type) = bitsize_zero_node;
-}
+		    TYPE_SIZE_UNIT (type) = size_zero_node;
+		    SET_TYPE_STRUCTURAL_EQUALITY (type);
-if (decl_context != PARM
+		  }
-&& (array_ptr_quals != TYPE_UNQUALIFIED
+	      }
-|| array_ptr_attrs != NULL_TREE
-|| array_parm_static))
+	    if (decl_context != PARM
-{
+		&& (array_ptr_quals != TYPE_UNQUALIFIED
-error_at (loc, "static or type qualifiers in non-parameter array declarator");
+		    || array_ptr_attrs != NULL_TREE
-array_ptr_quals = TYPE_UNQUALIFIED;
+		    || array_parm_static))
-array_ptr_attrs = NULL_TREE;
+	      {
-array_parm_static = 0;
+		error_at (loc, "static or type qualifiers in non-parameter array declarator");
-}
+		array_ptr_quals = TYPE_UNQUALIFIED;
-break;
+		array_ptr_attrs = NULL_TREE;
-}
+		array_parm_static = 0;
-case cdk_function:
+	      }
-{
+	    break;
-/* Say it's a definition only for the declarator closest
+	  }
-to the identifier, apart possibly from some
+	case cdk_function:
-attributes.  */
+	  {
-bool really_funcdef = false;
+	    /* Say it's a definition only for the declarator closest
-tree arg_types;
+	       to the identifier, apart possibly from some
-if (funcdef_flag)
+	       attributes.  */
-{
+	    bool really_funcdef = false;
-const struct c_declarator *t = declarator->declarator;
+	    tree arg_types;
-while (t->kind == cdk_attrs)
+	    if (funcdef_flag)
-t = t->declarator;
+	      {
-really_funcdef = (t->kind == cdk_id);
+		const struct c_declarator *t = declarator->declarator;
-}
+		while (t->kind == cdk_attrs)
+		  t = t->declarator;
-/* Declaring a function type.  Make sure we have a valid
+		really_funcdef = (t->kind == cdk_id);
-type for the function to return.  */
+	      }
-if (type == error_mark_node)
-continue;
+	    /* Declaring a function type.  Make sure we have a valid
-size_varies = false;
+	       type for the function to return.  */
+	    if (type == error_mark_node)
-/* Warn about some types functions can't return.  */
+	      continue;
-if (TREE_CODE (type) == FUNCTION_TYPE)
-{
+	    size_varies = false;
-if (name)
-error_at (loc, "%qE declared as function returning a "
+	    /* Warn about some types functions can't return.  */
-"function", name);
+	    if (TREE_CODE (type) == FUNCTION_TYPE)
-else
+	      {
-error_at (loc, "type name declared as function "
+		if (name)
-"returning a function");
+		  error_at (loc, "%qE declared as function returning a "
-type = integer_type_node;
+		      		 "function", name);
-}
+		else
-if (TREE_CODE (type) == ARRAY_TYPE)
+		  error_at (loc, "type name declared as function "
-{
+			    "returning a function");
-if (name)
+		type = integer_type_node;
-error_at (loc, "%qE declared as function returning an array",
+	      }
-name);
+	    if (TREE_CODE (type) == ARRAY_TYPE)
-else
+	      {
-error_at (loc, "type name declared as function returning "
+		if (name)
-"an array");
+		  error_at (loc, "%qE declared as function returning an array",
-type = integer_type_node;
+		      	    name);
-}
+		else
-errmsg = targetm.invalid_return_type (type);
+		  error_at (loc, "type name declared as function returning "
-if (errmsg)
+		      	    "an array");
-{
+		type = integer_type_node;
-error (errmsg);
+	      }
-type = integer_type_node;
+	    errmsg = targetm.invalid_return_type (type);
-}
+	    if (errmsg)
+	      {
-/* Construct the function type and go to the next
+		error (errmsg);
-inner layer of declarator.  */
+		type = integer_type_node;
-arg_info = declarator->u.arg_info;
+	      }
-arg_types = grokparms (arg_info, really_funcdef);
-if (really_funcdef)
+	    /* Construct the function type and go to the next
-put_pending_sizes (arg_info->pending_sizes);
+	       inner layer of declarator.  */
+	    arg_info = declarator->u.arg_info;
-/* Type qualifiers before the return type of the function
+	    arg_types = grokparms (arg_info, really_funcdef);
-qualify the return type, not the function type.  */
+	    if (really_funcdef)
-if (type_quals)
+	      put_pending_sizes (arg_info->pending_sizes);
-{
-/* Type qualifiers on a function return type are
+	    /* Type qualifiers before the return type of the function
-normally permitted by the standard but have no
+	       qualify the return type, not the function type.  */
-effect, so give a warning at -Wreturn-type.
+	    if (type_quals)
-Qualifiers on a void return type are banned on
+	      {
-function definitions in ISO C; GCC used to used
+		/* Type qualifiers on a function return type are
-them for noreturn functions.  */
+		   normally permitted by the standard but have no
-if (VOID_TYPE_P (type) && really_funcdef)
+		   effect, so give a warning at -Wreturn-type.
-pedwarn (loc, 0,
+		   Qualifiers on a void return type are banned on
-"function definition has qualified void return type");
+		   function definitions in ISO C; GCC used to used
-else
+		   them for noreturn functions.  */
-warning_at (loc, OPT_Wignored_qualifiers,
+		if (VOID_TYPE_P (type) && really_funcdef)
-"type qualifiers ignored on function return type");
+		  pedwarn (loc, 0,
+			   "function definition has qualified void return type");
-type = c_build_qualified_type (type, type_quals);
+		else
-}
+		  warning_at (loc, OPT_Wignored_qualifiers,
-type_quals = TYPE_UNQUALIFIED;
+			   "type qualifiers ignored on function return type");
+		type = c_build_qualified_type (type, type_quals);
+	      }
+	    type_quals = TYPE_UNQUALIFIED;
 #ifndef noCbC
 if ( declspecs->typespec_word == cts_CbC_code )
 {
 type = build_code_segment_type (type, arg_types);
 else
 #endif
 {
 type = build_function_type (type, arg_types);
 }
+	    declarator = declarator->declarator;
-declarator = declarator->declarator;
+	    /* Set the TYPE_CONTEXTs for each tagged type which is local to
-/* Set the TYPE_CONTEXTs for each tagged type which is local to
+	       the formal parameter list of this FUNCTION_TYPE to point to
-the formal parameter list of this FUNCTION_TYPE to point to
+	       the FUNCTION_TYPE node itself.  */
-the FUNCTION_TYPE node itself.  */
+	    {
-{
+	      c_arg_tag *tag;
-tree link;
+	      unsigned ix;
-for (link = arg_info->tags;
+	      FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
-link;
+		TYPE_CONTEXT (tag->type) = type;
-link = TREE_CHAIN (link))
+	    }
-TYPE_CONTEXT (TREE_VALUE (link)) = type;
+	    break;
-}
+	  }
-break;
+	case cdk_pointer:
-}
+	  {
-case cdk_pointer:
+	    /* Merge any constancy or volatility into the target type
-{
+	       for the pointer.  */
-/* Merge any constancy or volatility into the target type
+	    if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
-for the pointer.  */
+		&& type_quals)
+	      pedwarn (loc, OPT_pedantic,
-if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
+		       "ISO C forbids qualified function types");
-&& type_quals)
+	    if (type_quals)
-pedwarn (loc, OPT_pedantic,
+	      type = c_build_qualified_type (type, type_quals);
-"ISO C forbids qualified function types");
+	    size_varies = false;
-if (type_quals)
-type = c_build_qualified_type (type, type_quals);
+	    /* When the pointed-to type involves components of variable size,
-size_varies = false;
+	       care must be taken to ensure that the size evaluation code is
+	       emitted early enough to dominate all the possible later uses
-/* When the pointed-to type involves components of variable size,
+	       and late enough for the variables on which it depends to have
-care must be taken to ensure that the size evaluation code is
+	       been assigned.
-emitted early enough to dominate all the possible later uses
+	       This is expected to happen automatically when the pointed-to
-and late enough for the variables on which it depends to have
+	       type has a name/declaration of it's own, but special attention
-been assigned.
+	       is required if the type is anonymous.
+	       We handle the NORMAL and FIELD contexts here by attaching an
-This is expected to happen automatically when the pointed-to
+	       artificial TYPE_DECL to such pointed-to type.  This forces the
-type has a name/declaration of it's own, but special attention
+	       sizes evaluation at a safe point and ensures it is not deferred
-is required if the type is anonymous.
+	       until e.g. within a deeper conditional context.
+	       We expect nothing to be needed here for PARM or TYPENAME.
-We handle the NORMAL and FIELD contexts here by attaching an
+	       Pushing a TYPE_DECL at this point for TYPENAME would actually
-artificial TYPE_DECL to such pointed-to type.  This forces the
+	       be incorrect, as we might be in the middle of an expression
-sizes evaluation at a safe point and ensures it is not deferred
+	       with side effects on the pointed-to type size "arguments" prior
-until e.g. within a deeper conditional context.
+	       to the pointer declaration point and the fake TYPE_DECL in the
+	       enclosing context would force the size evaluation prior to the
-We expect nothing to be needed here for PARM or TYPENAME.
+	       side effects.  */
-Pushing a TYPE_DECL at this point for TYPENAME would actually
-be incorrect, as we might be in the middle of an expression
+	    if (!TYPE_NAME (type)
-with side effects on the pointed-to type size "arguments" prior
+		&& (decl_context == NORMAL || decl_context == FIELD)
-to the pointer declaration point and the fake TYPE_DECL in the
+		&& variably_modified_type_p (type, NULL_TREE))
-enclosing context would force the size evaluation prior to the
+	      {
-side effects.  */
+		tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
+		DECL_ARTIFICIAL (decl) = 1;
-if (!TYPE_NAME (type)
+		pushdecl (decl);
-&& (decl_context == NORMAL || decl_context == FIELD)
+		finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
-&& variably_modified_type_p (type, NULL_TREE))
+		TYPE_NAME (type) = decl;
-{
+	      }
-tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
-DECL_ARTIFICIAL (decl) = 1;
+	    type = build_pointer_type (type);
-pushdecl (decl);
-finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
+	    /* Process type qualifiers (such as const or volatile)
-TYPE_NAME (type) = decl;
+	       that were given inside the `*'.  */
-}
+	    type_quals = declarator->u.pointer_quals;
-type = build_pointer_type (type);
+	    declarator = declarator->declarator;
-/* Process type qualifiers (such as const or volatile)
+	    break;
-that were given inside the `*'.  */
+	  }
-type_quals = declarator->u.pointer_quals;
+	default:
+	  gcc_unreachable ();
-declarator = declarator->declarator;
+	}
-break;
-}
-default:
-gcc_unreachable ();
-}
 }
 *decl_attrs = chainon (returned_attrs, *decl_attrs);
 /* Now TYPE has the actual type, apart from any qualifiers in
 TYPE_QUALS.  */
 if (size_varies)
 C_DECL_VARIABLE_SIZE (decl) = 1;
 }
 else if (TREE_CODE (type) == FUNCTION_TYPE)
 {
-if (storage_class == csc_register || threadp)
+	if (storage_class == csc_register || threadp)
-{
+	  {
-error_at (loc, "invalid storage class for function %qE", name);
+	    error_at (loc, "invalid storage class for function %qE", name);
-}
+	   }
-else if (current_scope != file_scope)
+	else if (current_scope != file_scope)
-{
+	  {
-/* Function declaration not at file scope.  Storage
+	    /* Function declaration not at file scope.  Storage
-classes other than `extern' are not allowed, C99
+	       classes other than `extern' are not allowed, C99
-6.7.1p5, and `extern' makes no difference.  However,
+	       6.7.1p5, and `extern' makes no difference.  However,
-GCC allows 'auto', perhaps with 'inline', to support
+	       GCC allows 'auto', perhaps with 'inline', to support
-nested functions.  */
+	       nested functions.  */
-if (storage_class == csc_auto)
+	    if (storage_class == csc_auto)
-pedwarn (loc, OPT_pedantic,
+		pedwarn (loc, OPT_pedantic,
-"invalid storage class for function %qE", name);
+			 "invalid storage class for function %qE", name);
-else if (storage_class == csc_static)
+	    else if (storage_class == csc_static)
-{
+	      {
-error_at (loc, "invalid storage class for function %qE", name);
+		error_at (loc, "invalid storage class for function %qE", name);
-if (funcdef_flag)
+		if (funcdef_flag)
-storage_class = declspecs->storage_class = csc_none;
+		  storage_class = declspecs->storage_class = csc_none;
-else
+		else
-return 0;
+		  return 0;
-}
+	      }
-}
+	  }
-decl = build_decl (declarator->id_loc,
-FUNCTION_DECL, declarator->u.id, type);
+	decl = build_decl (declarator->id_loc,
-decl = build_decl_attribute_variant (decl, decl_attr);
+			   FUNCTION_DECL, declarator->u.id, type);
+	decl = build_decl_attribute_variant (decl, decl_attr);
-if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
-pedwarn (loc, OPT_pedantic,
+	if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
-"ISO C forbids qualified function types");
+	  pedwarn (loc, OPT_pedantic,
+		   "ISO C forbids qualified function types");
-/* GNU C interprets a volatile-qualified function type to indicate
-that the function does not return.  */
+	/* Every function declaration is an external reference
-if ((type_quals & TYPE_QUAL_VOLATILE)
+	   (DECL_EXTERNAL) except for those which are not at file
-&& !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
+	   scope and are explicitly declared "auto".  This is
-warning_at (loc, 0, "%<noreturn%> function returns non-void value");
+	   forbidden by standard C (C99 6.7.1p5) and is interpreted by
+	   GCC to signify a forward declaration of a nested function.  */
-/* Every function declaration is an external reference
+	if (storage_class == csc_auto && current_scope != file_scope)
-(DECL_EXTERNAL) except for those which are not at file
+	  DECL_EXTERNAL (decl) = 0;
-scope and are explicitly declared "auto".  This is
+	/* In C99, a function which is declared 'inline' with 'extern'
-forbidden by standard C (C99 6.7.1p5) and is interpreted by
+	   is not an external reference (which is confusing).  It
-GCC to signify a forward declaration of a nested function.  */
+	   means that the later definition of the function must be output
-if (storage_class == csc_auto && current_scope != file_scope)
+	   in this file, C99 6.7.4p6.  In GNU C89, a function declared
-DECL_EXTERNAL (decl) = 0;
+	   'extern inline' is an external reference.  */
-/* In C99, a function which is declared 'inline' with 'extern'
+	else if (declspecs->inline_p && storage_class != csc_static)
-is not an external reference (which is confusing).  It
+	  DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
-means that the later definition of the function must be output
+				  == flag_gnu89_inline);
-in this file, C99 6.7.4p6.  In GNU C89, a function declared
+	else
-'extern inline' is an external reference.  */
+	  DECL_EXTERNAL (decl) = !initialized;
-else if (declspecs->inline_p && storage_class != csc_static)
-DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
+	/* Record absence of global scope for `static' or `auto'.  */
-== flag_gnu89_inline);
+	TREE_PUBLIC (decl)
-else
+	  = !(storage_class == csc_static || storage_class == csc_auto);
-DECL_EXTERNAL (decl) = !initialized;
+	/* For a function definition, record the argument information
-/* Record absence of global scope for `static' or `auto'.  */
+	   block where store_parm_decls will look for it.  */
-TREE_PUBLIC (decl)
+	if (funcdef_flag)
-= !(storage_class == csc_static || storage_class == csc_auto);
+	  current_function_arg_info = arg_info;
-/* For a function definition, record the argument information
+	if (declspecs->default_int_p)
-block where store_parm_decls will look for it.  */
+	  C_FUNCTION_IMPLICIT_INT (decl) = 1;
-if (funcdef_flag)
-current_function_arg_info = arg_info;
+	/* Record presence of `inline', if it is reasonable.  */
+	if (flag_hosted && MAIN_NAME_P (declarator->u.id))
-if (declspecs->default_int_p)
+	  {
-C_FUNCTION_IMPLICIT_INT (decl) = 1;
+	    if (declspecs->inline_p)
+	      pedwarn (loc, 0, "cannot inline function %<main%>");
-/* Record presence of `inline', if it is reasonable.  */
+	  }
-if (flag_hosted && MAIN_NAME_P (declarator->u.id))
+	else if (declspecs->inline_p)
-{
+	  /* Record that the function is declared `inline'.  */
-if (declspecs->inline_p)
+	  DECL_DECLARED_INLINE_P (decl) = 1;
-pedwarn (loc, 0, "cannot inline function %<main%>");
-}
-else if (declspecs->inline_p)
-/* Record that the function is declared `inline'.  */
-DECL_DECLARED_INLINE_P (decl) = 1;
 }
 else
 {
 /* It's a variable.  */
 /* An uninitialized decl with `extern' is a reference.  */
 return 0;  /* don't set TYPE_ARG_TYPES in this case */
 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
 {
 if (!funcdef_flag)
-pedwarn (input_location, 0, "parameter names (without types) in function declaration");
+	{
+	  pedwarn (input_location, 0, "parameter names (without types) in function declaration");
-arg_info->parms = arg_info->types;
+	  arg_info->parms = NULL_TREE;
+	}
+else
+	arg_info->parms = arg_info->types;
 arg_info->types = 0;
 return 0;
 }
 else
 {
 already been given.  If a parameter has void type, then
 however the function cannot be defined or called, so
 warn.  */
 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
-parm;
+	   parm;
-parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
+	   parm = DECL_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
-{
+	{
-type = TREE_VALUE (typelt);
+	  type = TREE_VALUE (typelt);
-if (type == error_mark_node)
+	  if (type == error_mark_node)
-continue;
+	    continue;
-if (!COMPLETE_TYPE_P (type))
+	  if (!COMPLETE_TYPE_P (type))
-{
+	    {
-if (funcdef_flag)
+	      if (funcdef_flag)
-{
+		{
-if (DECL_NAME (parm))
+		  if (DECL_NAME (parm))
-error_at (input_location,
+		    error_at (input_location,
-"parameter %u (%q+D) has incomplete type",
+			      "parameter %u (%q+D) has incomplete type",
-parmno, parm);
+			      parmno, parm);
-else
+		  else
-error_at (DECL_SOURCE_LOCATION (parm),
+		    error_at (DECL_SOURCE_LOCATION (parm),
-"parameter %u has incomplete type",
+			      "parameter %u has incomplete type",
-parmno);
+			      parmno);
-TREE_VALUE (typelt) = error_mark_node;
+		  TREE_VALUE (typelt) = error_mark_node;
-TREE_TYPE (parm) = error_mark_node;
+		  TREE_TYPE (parm) = error_mark_node;
-}
+		  arg_types = NULL_TREE;
-else if (VOID_TYPE_P (type))
+		}
-{
+	      else if (VOID_TYPE_P (type))
-if (DECL_NAME (parm))
+		{
-warning_at (input_location, 0,
+		  if (DECL_NAME (parm))
-"parameter %u (%q+D) has void type",
+		    warning_at (input_location, 0,
-parmno, parm);
+				"parameter %u (%q+D) has void type",
-else
+				parmno, parm);
-warning_at (DECL_SOURCE_LOCATION (parm), 0,
+		  else
-"parameter %u has void type",
+		    warning_at (DECL_SOURCE_LOCATION (parm), 0,
-parmno);
+				"parameter %u has void type",
-}
+				parmno);
-}
+		}
+	    }
-errmsg = targetm.invalid_parameter_type (type);
-if (errmsg)
+	  errmsg = targetm.invalid_parameter_type (type);
-{
+	  if (errmsg)
-error (errmsg);
+	    {
-TREE_VALUE (typelt) = error_mark_node;
+	      error (errmsg);
-TREE_TYPE (parm) = error_mark_node;
+	      TREE_VALUE (typelt) = error_mark_node;
-}
+	      TREE_TYPE (parm) = error_mark_node;
+	      arg_types = NULL_TREE;
-if (DECL_NAME (parm) && TREE_USED (parm))
+	    }
-warn_if_shadowing (parm);
-}
+	  if (DECL_NAME (parm) && TREE_USED (parm))
+	    warn_if_shadowing (parm);
+	}
 return arg_types;
 }
+}
+/* Allocate and initialize a c_arg_info structure from the parser's
+obstack.  */
+struct c_arg_info *
+build_arg_info (void)
+{
+struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
+ret->parms = NULL_TREE;
+ret->tags = NULL;
+ret->types = NULL_TREE;
+ret->others = NULL_TREE;
+ret->pending_sizes = NULL;
+ret->had_vla_unspec = 0;
+return ret;
 }
 /* Take apart the current scope and return a c_arg_info structure with
 info on a parameter list just parsed.
 struct c_arg_info *
 get_parm_info (bool ellipsis)
 {
 struct c_binding *b = current_scope->bindings;
-struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
+struct c_arg_info *arg_info = build_arg_info ();
-struct c_arg_info);
 tree parms    = 0;
-tree tags     = 0;
+VEC(c_arg_tag,gc) *tags = NULL;
 tree types    = 0;
 tree others   = 0;
 static bool explained_incomplete_types = false;
 bool gave_void_only_once_err = false;
-arg_info->parms = 0;
-arg_info->tags = 0;
-arg_info->types = 0;
-arg_info->others = 0;
-arg_info->pending_sizes = 0;
 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
 /* The bindings in this scope must not get put into a block.
 We will take care of deleting the binding nodes.  */
 current_scope->bindings = 0;
 apply sanity checks; purge the name-to-decl bindings.  */
 while (b)
 {
 tree decl = b->decl;
 tree type = TREE_TYPE (decl);
+c_arg_tag *tag;
 const char *keyword;
 switch (TREE_CODE (decl))
-{
+	{
-case PARM_DECL:
+	case PARM_DECL:
-if (b->id)
+	  if (b->id)
-{
+	    {
-gcc_assert (I_SYMBOL_BINDING (b->id) == b);
+	      gcc_assert (I_SYMBOL_BINDING (b->id) == b);
-I_SYMBOL_BINDING (b->id) = b->shadowed;
+	      I_SYMBOL_BINDING (b->id) = b->shadowed;
-}
+	    }
-/* Check for forward decls that never got their actual decl.  */
+	  /* Check for forward decls that never got their actual decl.  */
-if (TREE_ASM_WRITTEN (decl))
+	  if (TREE_ASM_WRITTEN (decl))
-error ("parameter %q+D has just a forward declaration", decl);
+	    error ("parameter %q+D has just a forward declaration", decl);
-/* Check for (..., void, ...) and issue an error.  */
+	  /* Check for (..., void, ...) and issue an error.  */
-else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
+	  else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
-{
+	    {
-if (!gave_void_only_once_err)
+	      if (!gave_void_only_once_err)
-{
+		{
-error ("%<void%> must be the only parameter");
+		  error ("%<void%> must be the only parameter");
-gave_void_only_once_err = true;
+		  gave_void_only_once_err = true;
-}
+		}
-}
+	    }
-else
+	  else
-{
+	    {
-/* Valid parameter, add it to the list.  */
+	      /* Valid parameter, add it to the list.  */
-TREE_CHAIN (decl) = parms;
+	      DECL_CHAIN (decl) = parms;
-parms = decl;
+	      parms = decl;
-/* Since there is a prototype, args are passed in their
+	      /* Since there is a prototype, args are passed in their
-declared types.  The back end may override this later.  */
+		 declared types.  The back end may override this later.  */
-DECL_ARG_TYPE (decl) = type;
+	      DECL_ARG_TYPE (decl) = type;
-types = tree_cons (0, type, types);
+	      types = tree_cons (0, type, types);
-}
+	    }
-break;
+	  break;
-case ENUMERAL_TYPE: keyword = "enum"; goto tag;
+	case ENUMERAL_TYPE: keyword = "enum"; goto tag;
-case UNION_TYPE:    keyword = "union"; goto tag;
+	case UNION_TYPE:    keyword = "union"; goto tag;
-case RECORD_TYPE:   keyword = "struct"; goto tag;
+	case RECORD_TYPE:   keyword = "struct"; goto tag;
-tag:
+	tag:
-/* Types may not have tag-names, in which case the type
+	  /* Types may not have tag-names, in which case the type
-appears in the bindings list with b->id NULL.  */
+	     appears in the bindings list with b->id NULL.  */
-if (b->id)
+	  if (b->id)
-{
+	    {
-gcc_assert (I_TAG_BINDING (b->id) == b);
+	      gcc_assert (I_TAG_BINDING (b->id) == b);
-I_TAG_BINDING (b->id) = b->shadowed;
+	      I_TAG_BINDING (b->id) = b->shadowed;
-}
+	    }
-/* Warn about any struct, union or enum tags defined in a
+	  /* Warn about any struct, union or enum tags defined in a
-parameter list.  The scope of such types is limited to
+	     parameter list.  The scope of such types is limited to
-the parameter list, which is rarely if ever desirable
+	     the parameter list, which is rarely if ever desirable
-(it's impossible to call such a function with type-
+	     (it's impossible to call such a function with type-
-correct arguments).  An anonymous union parm type is
+	     correct arguments).  An anonymous union parm type is
-meaningful as a GNU extension, so don't warn for that.  */
+	     meaningful as a GNU extension, so don't warn for that.  */
-if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
+	  if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
-{
+	    {
-if (b->id)
+	      if (b->id)
-/* The %s will be one of 'struct', 'union', or 'enum'.  */
+		/* The %s will be one of 'struct', 'union', or 'enum'.  */
-warning (0, "%<%s %E%> declared inside parameter list",
+		warning (0, "%<%s %E%> declared inside parameter list",
-keyword, b->id);
+			 keyword, b->id);
-else
+	      else
-/* The %s will be one of 'struct', 'union', or 'enum'.  */
+		/* The %s will be one of 'struct', 'union', or 'enum'.  */
-warning (0, "anonymous %s declared inside parameter list",
+		warning (0, "anonymous %s declared inside parameter list",
-keyword);
+			 keyword);
-if (!explained_incomplete_types)
+	      if (!explained_incomplete_types)
-{
+		{
-warning (0, "its scope is only this definition or declaration,"
+		  warning (0, "its scope is only this definition or declaration,"
-" which is probably not what you want");
+			   " which is probably not what you want");
-explained_incomplete_types = true;
+		  explained_incomplete_types = true;
-}
+		}
-}
+	    }
-tags = tree_cons (b->id, decl, tags);
+	  tag = VEC_safe_push (c_arg_tag, gc, tags, NULL);
-break;
+	  tag->id = b->id;
+	  tag->type = decl;
-case CONST_DECL:
+	  break;
-case TYPE_DECL:
-case FUNCTION_DECL:
+	case CONST_DECL:
-/* CONST_DECLs appear here when we have an embedded enum,
+	case TYPE_DECL:
-and TYPE_DECLs appear here when we have an embedded struct
+	case FUNCTION_DECL:
-or union.  No warnings for this - we already warned about the
+	  /* CONST_DECLs appear here when we have an embedded enum,
-type itself.  FUNCTION_DECLs appear when there is an implicit
+	     and TYPE_DECLs appear here when we have an embedded struct
-function declaration in the parameter list.  */
+	     or union.  No warnings for this - we already warned about the
+	     type itself.  FUNCTION_DECLs appear when there is an implicit
-TREE_CHAIN (decl) = others;
+	     function declaration in the parameter list.  */
-others = decl;
-/* fall through */
+	  /* When we reinsert this decl in the function body, we need
+	     to reconstruct whether it was marked as nested.  */
-case ERROR_MARK:
+	  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
-/* error_mark_node appears here when we have an undeclared
+		      ? b->nested
-variable.  Just throw it away.  */
+		      : !b->nested);
-if (b->id)
+	  DECL_CHAIN (decl) = others;
-{
+	  others = decl;
-gcc_assert (I_SYMBOL_BINDING (b->id) == b);
+	  /* fall through */
-I_SYMBOL_BINDING (b->id) = b->shadowed;
-}
+	case ERROR_MARK:
-break;
+	  /* error_mark_node appears here when we have an undeclared
+	     variable.  Just throw it away.  */
-/* Other things that might be encountered.  */
+	  if (b->id)
-case LABEL_DECL:
+	    {
-case VAR_DECL:
+	      gcc_assert (I_SYMBOL_BINDING (b->id) == b);
-default:
+	      I_SYMBOL_BINDING (b->id) = b->shadowed;
-gcc_unreachable ();
+	    }
-}
+	  break;
+	  /* Other things that might be encountered.  */
+	case LABEL_DECL:
+	case VAR_DECL:
+	default:
+	  gcc_unreachable ();
+	}
 b = free_binding_and_advance (b);
 }
 arg_info->parms = parms;
 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
 && width == NULL_TREE)
 {
 /* This is an unnamed decl.
-If we have something of the form "union { list } ;" then this
+	 If we have something of the form "union { list } ;" then this
-is the anonymous union extension.  Similarly for struct.
+	 is the anonymous union extension.  Similarly for struct.
-If this is something of the form "struct foo;", then
+	 If this is something of the form "struct foo;", then
-If MS extensions are enabled, this is handled as an
+	   If MS or Plan 9 extensions are enabled, this is handled as
-anonymous struct.
+	     an anonymous struct.
-Otherwise this is a forward declaration of a structure tag.
+	   Otherwise this is a forward declaration of a structure tag.
-If this is something of the form "foo;" and foo is a TYPE_DECL, then
+	 If this is something of the form "foo;" and foo is a TYPE_DECL, then
-If MS extensions are enabled and foo names a structure, then
+	   If foo names a structure or union without a tag, then this
-again this is an anonymous struct.
+	     is an anonymous struct (this is permitted by C1X).
-Otherwise this is an error.
+	   If MS or Plan 9 extensions are enabled and foo names a
+	     structure, then again this is an anonymous struct.
-Oh what a horrid tangled web we weave.  I wonder if MS consciously
+	   Otherwise this is an error.
-took this from Plan 9 or if it was an accident of implementation
-that took root before someone noticed the bug...  */
+	 Oh what a horrid tangled web we weave.  I wonder if MS consciously
+	 took this from Plan 9 or if it was an accident of implementation
+	 that took root before someone noticed the bug...  */
 tree type = declspecs->type;
 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
 || TREE_CODE (type) == UNION_TYPE);
 bool ok = false;
-if (type_ok
+if (type_ok)
-&& (flag_ms_extensions || !declspecs->typedef_p))
+	{
-{
+	  if (flag_ms_extensions || flag_plan9_extensions)
-if (flag_ms_extensions)
+	    ok = true;
-ok = true;
+	  else if (TYPE_NAME (TYPE_MAIN_VARIANT (type)) == NULL)
-else if (flag_iso)
+	    ok = true;
-ok = false;
+	  else
-else if (TYPE_NAME (type) == NULL)
+	    ok = false;
-ok = true;
+	}
-else
-ok = false;
-}
 if (!ok)
-{
+	{
-pedwarn (loc, 0, "declaration does not declare anything");
+	  pedwarn (loc, 0, "declaration does not declare anything");
-return NULL_TREE;
+	  return NULL_TREE;
-}
+	}
-pedwarn (loc, OPT_pedantic, "ISO C doesn%'t support unnamed structs/unions");
+if (!flag_isoc1x)
+	{
+	  if (flag_isoc99)
+	    pedwarn (loc, OPT_pedantic,
+		     "ISO C99 doesn%'t support unnamed structs/unions");
+	  else
+	    pedwarn (loc, OPT_pedantic,
+		     "ISO C90 doesn%'t support unnamed structs/unions");
+	}
 }
 value = grokdeclarator (declarator, declspecs, FIELD, false,
 width ? &width : NULL, decl_attrs, NULL, NULL,
 DEPRECATED_NORMAL);
 }
 return value;
 }
+/* Subroutine of detect_field_duplicates: return whether X and Y,
+which are both fields in the same struct, have duplicate field
+names.  */
+static bool
+is_duplicate_field (tree x, tree y)
+{
+if (DECL_NAME (x) != NULL_TREE && DECL_NAME (x) == DECL_NAME (y))
+return true;
+/* When using -fplan9-extensions, an anonymous field whose name is a
+typedef can duplicate a field name.  */
+if (flag_plan9_extensions
+&& (DECL_NAME (x) == NULL_TREE || DECL_NAME (y) == NULL_TREE))
+{
+tree xt, xn, yt, yn;
+xt = TREE_TYPE (x);
+if (DECL_NAME (x) != NULL_TREE)
+	xn = DECL_NAME (x);
+else if ((TREE_CODE (xt) == RECORD_TYPE || TREE_CODE (xt) == UNION_TYPE)
+	       && TYPE_NAME (xt) != NULL_TREE
+	       && TREE_CODE (TYPE_NAME (xt)) == TYPE_DECL)
+	xn = DECL_NAME (TYPE_NAME (xt));
+else
+	xn = NULL_TREE;
+yt = TREE_TYPE (y);
+if (DECL_NAME (y) != NULL_TREE)
+	yn = DECL_NAME (y);
+else if ((TREE_CODE (yt) == RECORD_TYPE || TREE_CODE (yt) == UNION_TYPE)
+	       && TYPE_NAME (yt) != NULL_TREE
+	       && TREE_CODE (TYPE_NAME (yt)) == TYPE_DECL)
+	yn = DECL_NAME (TYPE_NAME (yt));
+else
+	yn = NULL_TREE;
+if (xn != NULL_TREE && xn == yn)
+	return true;
+}
+return false;
+}
+/* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
+to HTAB, giving errors for any duplicates.  */
+static void
+detect_field_duplicates_hash (tree fieldlist, htab_t htab)
+{
+tree x, y;
+void **slot;
+for (x = fieldlist; x ; x = DECL_CHAIN (x))
+if ((y = DECL_NAME (x)) != 0)
+{
+	slot = htab_find_slot (htab, y, INSERT);
+	if (*slot)
+	  {
+	    error ("duplicate member %q+D", x);
+	    DECL_NAME (x) = NULL_TREE;
+	  }
+	*slot = y;
+}
+else if (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
+	     || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
+{
+	detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x)), htab);
+	/* When using -fplan9-extensions, an anonymous field whose
+	   name is a typedef can duplicate a field name.  */
+	if (flag_plan9_extensions
+	    && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
+	    && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL)
+	  {
+	    tree xn = DECL_NAME (TYPE_NAME (TREE_TYPE (x)));
+	    slot = htab_find_slot (htab, xn, INSERT);
+	    if (*slot)
+	      error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x)));
+	    *slot = xn;
+	  }
+}
+}
 /* Generate an error for any duplicate field names in FIELDLIST.  Munge
 the list such that this does not present a problem later.  */
 static void
 detect_field_duplicates (tree fieldlist)
 {
 tree x, y;
 int timeout = 10;
+/* If the struct is the list of instance variables of an Objective-C
+class, then we need to add all the instance variables of
+superclasses before checking for duplicates (since you can't have
+an instance variable in a subclass with the same name as an
+instance variable in a superclass).  objc_get_interface_ivars()
+leaves fieldlist unchanged if we are not in this case, so in that
+case nothing changes compared to C.
+*/
+if (c_dialect_objc ())
+fieldlist = objc_get_interface_ivars (fieldlist);
 /* First, see if there are more than "a few" fields.
 This is trivially true if there are zero or one fields.  */
-if (!fieldlist)
+if (!fieldlist || !DECL_CHAIN (fieldlist))
 return;
-x = TREE_CHAIN (fieldlist);
+x = fieldlist;
-if (!x)
-return;
 do {
 timeout--;
-x = TREE_CHAIN (x);
+if (DECL_NAME (x) == NULL_TREE
+	&& (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
+	    || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
+timeout = 0;
+x = DECL_CHAIN (x);
 } while (timeout > 0 && x);
-/* If there were "few" fields, avoid the overhead of allocating
+/* If there were "few" fields and no anonymous structures or unions,
-a hash table.  Instead just do the nested traversal thing.  */
+avoid the overhead of allocating a hash table.  Instead just do
+the nested traversal thing.  */
 if (timeout > 0)
 {
-for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
+for (x = DECL_CHAIN (fieldlist); x; x = DECL_CHAIN (x))
-if (DECL_NAME (x))
+	/* When using -fplan9-extensions, we can have duplicates
-{
+	   between typedef names and fields.  */
-for (y = fieldlist; y != x; y = TREE_CHAIN (y))
+	if (DECL_NAME (x)
-if (DECL_NAME (y) == DECL_NAME (x))
+	    || (flag_plan9_extensions
-{
+		&& DECL_NAME (x) == NULL_TREE
-error ("duplicate member %q+D", x);
+		&& (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
-DECL_NAME (x) = NULL_TREE;
+		    || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
-}
+		&& TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
-}
+		&& TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL))
+	  {
+	    for (y = fieldlist; y != x; y = TREE_CHAIN (y))
+	      if (is_duplicate_field (y, x))
+		{
+		  error ("duplicate member %q+D", x);
+		  DECL_NAME (x) = NULL_TREE;
+		}
+	  }
 }
 else
 {
 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
-void **slot;
+detect_field_duplicates_hash (fieldlist, htab);
-for (x = fieldlist; x ; x = TREE_CHAIN (x))
-if ((y = DECL_NAME (x)) != 0)
-{
-slot = htab_find_slot (htab, y, INSERT);
-if (*slot)
-{
-error ("duplicate member %q+D", x);
-DECL_NAME (x) = NULL_TREE;
-}
-*slot = y;
-}
 htab_delete (htab);
 }
 }
 /* Finish up struct info used by -Wc++-compat.  */
 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
 the current struct.  We do this now at the end of the struct
 because the flag is used to issue visibility warnings, and we
 only want to issue those warnings if the type is referenced
 outside of the struct declaration.  */
-for (ix = 0; VEC_iterate (tree, struct_parse_info->struct_types, ix, x); ++ix)
+FOR_EACH_VEC_ELT (tree, struct_parse_info->struct_types, ix, x)
 C_TYPE_DEFINED_IN_STRUCT (x) = 1;
 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
 typedefs used when declaring fields in this struct.  If the name
 of any of the fields is also a typedef name then the struct would
 {
 /* Use a pointer_set using the name of the typedef.  We can use
 a pointer_set because identifiers are interned.  */
 struct pointer_set_t *tset = pointer_set_create ();
-for (ix = 0;
+FOR_EACH_VEC_ELT (tree, struct_parse_info->typedefs_seen, ix, x)
-VEC_iterate (tree, struct_parse_info->typedefs_seen, ix, x);
+	pointer_set_insert (tset, DECL_NAME (x));
-++ix)
-pointer_set_insert (tset, DECL_NAME (x));
+for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x))
+	{
-for (x = fieldlist; x != NULL_TREE; x = TREE_CHAIN (x))
+	  if (DECL_NAME (x) != NULL_TREE
-{
+	      && pointer_set_contains (tset, DECL_NAME (x)))
-if (pointer_set_contains (tset, DECL_NAME (x)))
+	    {
-{
+	      warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
-warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
+			  ("using %qD as both field and typedef name is "
-("using %qD as both field and typedef name is "
+			   "invalid in C++"),
-"invalid in C++"),
+			  x);
-x);
+	      /* FIXME: It would be nice to report the location where
-/* FIXME: It would be nice to report the location where
+		 the typedef name is used.  */
-the typedef name is used.  */
+	    }
-}
+	}
-}
 pointer_set_destroy (tset);
 }
 /* For each field which has a binding and which was not defined in
 an enclosing struct, clear the in_struct field.  */
-for (ix = 0;
+FOR_EACH_VEC_ELT (c_binding_ptr, struct_parse_info->fields, ix, b)
-VEC_iterate (c_binding_ptr, struct_parse_info->fields, ix, b);
-++ix)
 b->in_struct = 0;
 }
 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
 if (pedantic)
 {
-for (x = fieldlist; x; x = TREE_CHAIN (x))
+for (x = fieldlist; x; x = DECL_CHAIN (x))
-if (DECL_NAME (x) != 0)
+	{
-break;
+	  if (DECL_NAME (x) != 0)
+	    break;
+	  if (flag_isoc1x
+	      && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
+		  || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
+	    break;
+	}
 if (x == 0)
 {
 if (TREE_CODE (t) == UNION_TYPE)
 {
 to its width, rather than the precision of the specified standard
 type.  (Correct layout requires the original type to have been preserved
 until now.)  */
 saw_named_field = 0;
-for (x = fieldlist; x; x = TREE_CHAIN (x))
+for (x = fieldlist; x; x = DECL_CHAIN (x))
 {
 if (TREE_TYPE (x) == error_mark_node)
 continue;
 DECL_CONTEXT (x) = t;
 /* If any field is const, the structure type is pseudo-const.  */
 if (TREE_READONLY (x))
 C_TYPE_FIELDS_READONLY (t) = 1;
 else
-{
+	{
-/* A field that is pseudo-const makes the structure likewise.  */
+	  /* A field that is pseudo-const makes the structure likewise.  */
-tree t1 = TREE_TYPE (x);
+	  tree t1 = strip_array_types (TREE_TYPE (x));
-while (TREE_CODE (t1) == ARRAY_TYPE)
+	  if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
-t1 = TREE_TYPE (t1);
+	      && C_TYPE_FIELDS_READONLY (t1))
-if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
+	    C_TYPE_FIELDS_READONLY (t) = 1;
-&& C_TYPE_FIELDS_READONLY (t1))
+	}
-C_TYPE_FIELDS_READONLY (t) = 1;
-}
 /* Any field that is volatile means variables of this type must be
 treated in some ways as volatile.  */
 if (TREE_THIS_VOLATILE (x))
 C_TYPE_FIELDS_VOLATILE (t) = 1;
 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
 DECL_PACKED (x) = 1;
 /* Detect flexible array member in an invalid context.  */
 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
-&& TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
+	  && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
-&& TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
+	  && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
-&& TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
+	  && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
-{
+	{
-if (TREE_CODE (t) == UNION_TYPE)
+	  if (TREE_CODE (t) == UNION_TYPE)
-{
+	    {
-error_at (DECL_SOURCE_LOCATION (x),
+	      error_at (DECL_SOURCE_LOCATION (x),
-"flexible array member in union");
+			"flexible array member in union");
-TREE_TYPE (x) = error_mark_node;
+	      TREE_TYPE (x) = error_mark_node;
-}
+	    }
-else if (TREE_CHAIN (x) != NULL_TREE)
+	  else if (DECL_CHAIN (x) != NULL_TREE)
-{
+	    {
-error_at (DECL_SOURCE_LOCATION (x),
+	      error_at (DECL_SOURCE_LOCATION (x),
-"flexible array member not at end of struct");
+			"flexible array member not at end of struct");
-TREE_TYPE (x) = error_mark_node;
+	      TREE_TYPE (x) = error_mark_node;
-}
+	    }
-else if (!saw_named_field)
+	  else if (!saw_named_field)
-{
+	    {
-error_at (DECL_SOURCE_LOCATION (x),
+	      error_at (DECL_SOURCE_LOCATION (x),
-"flexible array member in otherwise empty struct");
+			"flexible array member in otherwise empty struct");
-TREE_TYPE (x) = error_mark_node;
+	      TREE_TYPE (x) = error_mark_node;
-}
+	    }
-}
+	}
 if (pedantic && TREE_CODE (t) == RECORD_TYPE
 && flexible_array_type_p (TREE_TYPE (x)))
 pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
 "invalid use of structure with flexible array member");
-if (DECL_NAME (x))
+if (DECL_NAME (x)
-saw_named_field = 1;
+	  || TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
+	  || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
+	saw_named_field = 1;
 }
 detect_field_duplicates (fieldlist);
 /* Now we have the nearly final fieldlist.  Record it,
 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
 }
 DECL_INITIAL (*fieldlistp) = 0;
 }
 else
-fieldlistp = &TREE_CHAIN (*fieldlistp);
+	fieldlistp = &DECL_CHAIN (*fieldlistp);
 }
 /* Now we have the truly final field list.
 Store it in this type and in the variants.  */
 We arbitrarily consider 16 or more elts to be "a lot".  */
 {
 int len = 0;
-for (x = fieldlist; x; x = TREE_CHAIN (x))
+for (x = fieldlist; x; x = DECL_CHAIN (x))
 {
 if (len > 15 || DECL_NAME (x) == NULL)
 break;
 len += 1;
 }
 if (len > 15)
 {
-tree *field_array;
+	tree *field_array;
-struct lang_type *space;
+	struct lang_type *space;
-struct sorted_fields_type *space2;
+	struct sorted_fields_type *space2;
-len += list_length (x);
+	len += list_length (x);
-/* Use the same allocation policy here that make_node uses, to
+	/* Use the same allocation policy here that make_node uses, to
-ensure that this lives as long as the rest of the struct decl.
+	  ensure that this lives as long as the rest of the struct decl.
-All decls in an inline function need to be saved.  */
+	  All decls in an inline function need to be saved.  */
-space = GGC_CNEW (struct lang_type);
+	space = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
-space2 = GGC_NEWVAR (struct sorted_fields_type,
+	space2 = ggc_alloc_sorted_fields_type
-sizeof (struct sorted_fields_type) + len * sizeof (tree));
+	  (sizeof (struct sorted_fields_type) + len * sizeof (tree));
-len = 0;
+	len = 0;
-space->s = space2;
+	space->s = space2;
-field_array = &space2->elts[0];
+	field_array = &space2->elts[0];
-for (x = fieldlist; x; x = TREE_CHAIN (x))
+	for (x = fieldlist; x; x = DECL_CHAIN (x))
-{
+	  {
-field_array[len++] = x;
+	    field_array[len++] = x;
-/* If there is anonymous struct or union, break out of the loop.  */
+	    /* If there is anonymous struct or union, break out of the loop.  */
-if (DECL_NAME (x) == NULL)
+	    if (DECL_NAME (x) == NULL)
-break;
+	      break;
-}
+	  }
-/* Found no anonymous struct/union.  Add the TYPE_LANG_SPECIFIC.  */
+	/* Found no anonymous struct/union.  Add the TYPE_LANG_SPECIFIC.  */
-if (x == NULL)
+	if (x == NULL)
-{
+	  {
-TYPE_LANG_SPECIFIC (t) = space;
+	    TYPE_LANG_SPECIFIC (t) = space;
-TYPE_LANG_SPECIFIC (t)->s->len = len;
+	    TYPE_LANG_SPECIFIC (t)->s->len = len;
-field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
+	    field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
-qsort (field_array, len, sizeof (tree), field_decl_cmp);
+	    qsort (field_array, len, sizeof (tree), field_decl_cmp);
-}
+	  }
 }
 }
 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
 {
 }
 /* If this was supposed to be a transparent union, but we can't
 make it one, warn and turn off the flag.  */
 if (TREE_CODE (t) == UNION_TYPE
-&& TYPE_TRANSPARENT_UNION (t)
+&& TYPE_TRANSPARENT_AGGR (t)
 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
 {
-TYPE_TRANSPARENT_UNION (t) = 0;
+TYPE_TRANSPARENT_AGGR (t) = 0;
 warning_at (loc, 0, "union cannot be made transparent");
 }
 /* If this structure or union completes the type of any previous
 variable declaration, lay it out and output its rtl.  */
 TYPE_VALUES (enumtype) = values;
 }
 /* Record the min/max values so that we can warn about bit-field
 enumerations that are too small for the values.  */
-lt = GGC_CNEW (struct lang_type);
+lt = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
 lt->enum_min = minnode;
 lt->enum_max = maxnode;
 TYPE_LANG_SPECIFIC (enumtype) = lt;
 /* Fix up all variant types of this enum type.  */
 return enumtype;
 }
 /* Build and install a CONST_DECL for one value of the
 current enumeration type (one that was begun with start_enum).
-LOC is the location of the enumerator.
+DECL_LOC is the location of the enumerator.
+LOC is the location of the '=' operator if any, DECL_LOC otherwise.
 Return a tree-list containing the CONST_DECL and its value.
 Assignment of sequential values by default is handled here.  */
 tree
-build_enumerator (location_t loc,
+build_enumerator (location_t decl_loc, location_t loc,
-struct c_enum_contents *the_enum, tree name, tree value)
+		  struct c_enum_contents *the_enum, tree name, tree value)
 {
 tree decl, type;
 /* Validate and default VALUE.  */
 if (int_fits_type_p (value, integer_type_node))
 value = convert (integer_type_node, value);
 /* Set basis for default for next value.  */
 the_enum->enum_next_value
-= build_binary_op
+= build_binary_op (EXPR_LOC_OR_HERE (value),
-(EXPR_HAS_LOCATION (value) ? EXPR_LOCATION (value) : input_location,
+		       PLUS_EXPR, value, integer_one_node, 0);
-PLUS_EXPR, value, integer_one_node, 0);
 the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
 /* Now create a declaration for the enum value name.  */
 type = TREE_TYPE (value);
 TYPE_PRECISION (integer_type_node)),
 (TYPE_PRECISION (type)
 >= TYPE_PRECISION (integer_type_node)
 && TYPE_UNSIGNED (type)));
-decl = build_decl (loc, CONST_DECL, name, type);
+decl = build_decl (decl_loc, CONST_DECL, name, type);
 DECL_INITIAL (decl) = convert (type, value);
 pushdecl (decl);
 return tree_cons (decl, value, NULL_TREE);
 }
 /* Make the init_value nonzero so pushdecl knows this is not tentative.
 error_mark_node is replaced below (in pop_scope) with the BLOCK.  */
 DECL_INITIAL (decl1) = error_mark_node;
+/* A nested function is not global.  */
+if (current_function_decl != 0)
+TREE_PUBLIC (decl1) = 0;
 /* If this definition isn't a prototype and we had a prototype declaration
 before, copy the arg type info from that prototype.  */
 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
 old_decl = 0;
 current_function_prototype_locus = UNKNOWN_LOCATION;
 current_function_prototype_built_in = false;
 current_function_prototype_arg_types = NULL_TREE;
-if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
+if (!prototype_p (TREE_TYPE (decl1)))
 {
 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
 TREE_TYPE (TREE_TYPE (old_decl))))
 {
 }
 /* Optionally warn of old-fashioned def with no previous prototype.  */
 if (warn_strict_prototypes
 && old_decl != error_mark_node
-&& TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
+&& !prototype_p (TREE_TYPE (decl1))
 && C_DECL_ISNT_PROTOTYPE (old_decl))
 warning_at (loc, OPT_Wstrict_prototypes,
 "function declaration isn%'t a prototype");
 /* Optionally warn of any global def with no previous prototype.  */
 else if (warn_missing_prototypes
 warning_at (loc, OPT_Wmissing_prototypes,
 "no previous prototype for %qD", decl1);
 /* Optionally warn of any def with no previous prototype
 if the function has already been used.  */
 else if (warn_missing_prototypes
-&& old_decl != 0
+	   && old_decl != 0
-&& old_decl != error_mark_node
+	   && old_decl != error_mark_node
-&& TREE_USED (old_decl)
+	   && TREE_USED (old_decl)
-&& TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
+	   && !prototype_p (TREE_TYPE (old_decl)))
 warning_at (loc, OPT_Wmissing_prototypes,
 "%qD was used with no prototype before its definition", decl1);
 /* Optionally warn of any global def with no previous declaration.  */
 else if (warn_missing_declarations
 && TREE_PUBLIC (decl1)
 /* This function exists in static storage.
 (This does not mean `static' in the C sense!)  */
 TREE_STATIC (decl1) = 1;
-/* A nested function is not global.  */
-if (current_function_decl != 0)
-TREE_PUBLIC (decl1) = 0;
 /* This is the earliest point at which we might know the assembler
 name of the function.  Thus, if it's set before this, die horribly.  */
 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
 /* If #pragma weak was used, mark the decl weak now.  */
 old-style parm decls were written.  */
 static void
 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
 {
 tree decl;
+c_arg_tag *tag;
+unsigned ix;
 if (current_scope->bindings)
 {
 error_at (DECL_SOURCE_LOCATION (fndecl),
 "old-style parameter declarations in prototyped "
 warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
 "traditional C rejects ISO C style function definitions");
 /* Now make all the parameter declarations visible in the function body.
 We can bypass most of the grunt work of pushdecl.  */
-for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
+for (decl = arg_info->parms; decl; decl = DECL_CHAIN (decl))
 {
 DECL_CONTEXT (decl) = current_function_decl;
 if (DECL_NAME (decl))
 {
 bind (DECL_NAME (decl), decl, current_scope,
 /* Record the parameter list in the function declaration.  */
 DECL_ARGUMENTS (fndecl) = arg_info->parms;
 /* Now make all the ancillary declarations visible, likewise.  */
-for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
+for (decl = arg_info->others; decl; decl = DECL_CHAIN (decl))
 {
 DECL_CONTEXT (decl) = current_function_decl;
 if (DECL_NAME (decl))
-bind (DECL_NAME (decl), decl, current_scope,
+	bind (DECL_NAME (decl), decl, current_scope,
-/*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
+	      /*invisible=*/false,
+	      /*nested=*/(TREE_CODE (decl) == FUNCTION_DECL),
+	      UNKNOWN_LOCATION);
 }
 /* And all the tag declarations.  */
-for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
+FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
-if (TREE_PURPOSE (decl))
+if (tag->id)
-bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
+bind (tag->id, tag->type, current_scope,
-/*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
+	    /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
 }
 /* Subroutine of store_parm_decls which handles old-style function
 definitions (separate parameter list and declarations).  */
 continue;
 }
 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
 if (b && B_IN_CURRENT_SCOPE (b))
-{
+	{
-decl = b->decl;
+	  decl = b->decl;
-/* If we got something other than a PARM_DECL it is an error.  */
+	  /* Skip erroneous parameters.  */
-if (TREE_CODE (decl) != PARM_DECL)
+	  if (decl == error_mark_node)
-error_at (DECL_SOURCE_LOCATION (decl),
+	    continue;
-"%qD declared as a non-parameter", decl);
+	  /* If we got something other than a PARM_DECL it is an error.  */
-/* If the declaration is already marked, we have a duplicate
+	  if (TREE_CODE (decl) != PARM_DECL)
-name.  Complain and ignore the duplicate.  */
+	    error_at (DECL_SOURCE_LOCATION (decl),
-else if (pointer_set_contains (seen_args, decl))
+		      "%qD declared as a non-parameter", decl);
-{
+	  /* If the declaration is already marked, we have a duplicate
-error_at (DECL_SOURCE_LOCATION (decl),
+	     name.  Complain and ignore the duplicate.  */
-"multiple parameters named %qD", decl);
+	  else if (pointer_set_contains (seen_args, decl))
-TREE_PURPOSE (parm) = 0;
+	    {
-continue;
+	      error_at (DECL_SOURCE_LOCATION (decl),
-}
+			"multiple parameters named %qD", decl);
-/* If the declaration says "void", complain and turn it into
+	      TREE_PURPOSE (parm) = 0;
-an int.  */
+	      continue;
-else if (VOID_TYPE_P (TREE_TYPE (decl)))
+	    }
-{
+	  /* If the declaration says "void", complain and turn it into
-error_at (DECL_SOURCE_LOCATION (decl),
+	     an int.  */
-"parameter %qD declared with void type", decl);
+	  else if (VOID_TYPE_P (TREE_TYPE (decl)))
-TREE_TYPE (decl) = integer_type_node;
+	    {
-DECL_ARG_TYPE (decl) = integer_type_node;
+	      error_at (DECL_SOURCE_LOCATION (decl),
-layout_decl (decl, 0);
+			"parameter %qD declared with void type", decl);
-}
+	      TREE_TYPE (decl) = integer_type_node;
-warn_if_shadowing (decl);
+	      DECL_ARG_TYPE (decl) = integer_type_node;
-}
+	      layout_decl (decl, 0);
+	    }
+	  warn_if_shadowing (decl);
+	}
 /* If no declaration found, default to int.  */
 else
 {
 /* FIXME diagnostics: This should be the location of the argument,
 not the FNDECL.  E.g., for an old-style declaration
 {
 last = TREE_PURPOSE (parm);
 DECL_ARGUMENTS (fndecl) = last;
 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
-if (TREE_PURPOSE (parm))
+	if (TREE_PURPOSE (parm))
-{
+	  {
-TREE_CHAIN (last) = TREE_PURPOSE (parm);
+	    DECL_CHAIN (last) = TREE_PURPOSE (parm);
-last = TREE_PURPOSE (parm);
+	    last = TREE_PURPOSE (parm);
-}
+	  }
-TREE_CHAIN (last) = 0;
+DECL_CHAIN (last) = 0;
 }
 pointer_set_destroy (seen_args);
 /* If there was a previous prototype,
 tree type;
 for (parm = DECL_ARGUMENTS (fndecl),
 type = current_function_prototype_arg_types;
 parm || (type && TREE_VALUE (type) != error_mark_node
 && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
-parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
+	   parm = DECL_CHAIN (parm), type = TREE_CHAIN (type))
-{
+	{
-if (parm == 0 || type == 0
+	  if (parm == 0 || type == 0
-|| TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
+	      || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
-{
+	    {
-if (current_function_prototype_built_in)
+	      if (current_function_prototype_built_in)
-warning_at (DECL_SOURCE_LOCATION (fndecl),
+		warning_at (DECL_SOURCE_LOCATION (fndecl),
-0, "number of arguments doesn%'t match "
+			    0, "number of arguments doesn%'t match "
-"built-in prototype");
+			    "built-in prototype");
-else
+	      else
-{
+		{
-/* FIXME diagnostics: This should be the location of
+		  /* FIXME diagnostics: This should be the location of
-FNDECL, but there is bug when a prototype is
+		     FNDECL, but there is bug when a prototype is
-declared inside function context, but defined
+		     declared inside function context, but defined
-outside of it (e.g., gcc.dg/pr15698-2.c).  In
+		     outside of it (e.g., gcc.dg/pr15698-2.c).  In
-which case FNDECL gets the location of the
+		     which case FNDECL gets the location of the
-prototype, not the definition.  */
+		     prototype, not the definition.  */
-error_at (input_location,
+		  error_at (input_location,
-"number of arguments doesn%'t match prototype");
+			    "number of arguments doesn%'t match prototype");
-error_at (current_function_prototype_locus,
+		  error_at (current_function_prototype_locus,
-"prototype declaration");
+			    "prototype declaration");
-}
+		}
-break;
+	      break;
-}
+	    }
-/* Type for passing arg must be consistent with that
+	  /* Type for passing arg must be consistent with that
-declared for the arg.  ISO C says we take the unqualified
+	     declared for the arg.  ISO C says we take the unqualified
-type for parameters declared with qualified type.  */
+	     type for parameters declared with qualified type.  */
-if (TREE_TYPE (parm) != error_mark_node
+	  if (TREE_TYPE (parm) != error_mark_node
-&& TREE_TYPE (type) != error_mark_node
+	      && TREE_TYPE (type) != error_mark_node
-&& !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
+	      && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
-TYPE_MAIN_VARIANT (TREE_VALUE (type))))
+			     TYPE_MAIN_VARIANT (TREE_VALUE (type))))
-{
+	    {
-if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
+	      if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
-== TYPE_MAIN_VARIANT (TREE_VALUE (type)))
+		  == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
-{
+		{
-/* Adjust argument to match prototype.  E.g. a previous
+		  /* Adjust argument to match prototype.  E.g. a previous
-`int foo(float);' prototype causes
+		     `int foo(float);' prototype causes
-`int foo(x) float x; {...}' to be treated like
+		     `int foo(x) float x; {...}' to be treated like
-`int foo(float x) {...}'.  This is particularly
+		     `int foo(float x) {...}'.  This is particularly
-useful for argument types like uid_t.  */
+		     useful for argument types like uid_t.  */
-DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
+		  DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
-if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
+		  if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
-&& INTEGRAL_TYPE_P (TREE_TYPE (parm))
+		      && INTEGRAL_TYPE_P (TREE_TYPE (parm))
-&& TYPE_PRECISION (TREE_TYPE (parm))
+		      && TYPE_PRECISION (TREE_TYPE (parm))
-< TYPE_PRECISION (integer_type_node))
+		      < TYPE_PRECISION (integer_type_node))
-DECL_ARG_TYPE (parm) = integer_type_node;
+		    DECL_ARG_TYPE (parm) = integer_type_node;
-/* ??? Is it possible to get here with a
+		  /* ??? Is it possible to get here with a
-built-in prototype or will it always have
+		     built-in prototype or will it always have
-been diagnosed as conflicting with an
+		     been diagnosed as conflicting with an
-old-style definition and discarded?  */
+		     old-style definition and discarded?  */
-if (current_function_prototype_built_in)
+		  if (current_function_prototype_built_in)
-warning_at (DECL_SOURCE_LOCATION (parm),
+		    warning_at (DECL_SOURCE_LOCATION (parm),
-OPT_pedantic, "promoted argument %qD "
+				OPT_pedantic, "promoted argument %qD "
-"doesn%'t match built-in prototype", parm);
+				"doesn%'t match built-in prototype", parm);
-else
+		  else
-{
+		    {
-pedwarn (DECL_SOURCE_LOCATION (parm),
+		      pedwarn (DECL_SOURCE_LOCATION (parm),
-OPT_pedantic, "promoted argument %qD "
+			       OPT_pedantic, "promoted argument %qD "
-"doesn%'t match prototype", parm);
+			       "doesn%'t match prototype", parm);
-pedwarn (current_function_prototype_locus, OPT_pedantic,
+		      pedwarn (current_function_prototype_locus, OPT_pedantic,
-"prototype declaration");
+			       "prototype declaration");
-}
+		    }
-}
+		}
-else
+	      else
-{
+		{
-if (current_function_prototype_built_in)
+		  if (current_function_prototype_built_in)
-warning_at (DECL_SOURCE_LOCATION (parm),
+		    warning_at (DECL_SOURCE_LOCATION (parm),
-0, "argument %qD doesn%'t match "
+				0, "argument %qD doesn%'t match "
-"built-in prototype", parm);
+				"built-in prototype", parm);
-else
+		  else
-{
+		    {
-error_at (DECL_SOURCE_LOCATION (parm),
+		      error_at (DECL_SOURCE_LOCATION (parm),
-"argument %qD doesn%'t match prototype", parm);
+				"argument %qD doesn%'t match prototype", parm);
-error_at (current_function_prototype_locus,
+		      error_at (current_function_prototype_locus,
-"prototype declaration");
+				"prototype declaration");
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
 }
 /* Otherwise, create a prototype that would match.  */
 else
 {
 tree actual = 0, last = 0, type;
-for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
+for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
-{
+	{
-type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
+	  type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
-if (last)
+	  if (last)
-TREE_CHAIN (last) = type;
+	    TREE_CHAIN (last) = type;
-else
+	  else
-actual = type;
+	    actual = type;
-last = type;
+	  last = type;
-}
+	}
 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
 if (last)
 TREE_CHAIN (last) = type;
 else
 actual = type;
 void foo(int n, int array[n++])
 because we throw away the array type in favor of a pointer type, and
 thus won't naturally see the SAVE_EXPR containing the increment.  All
 other pending sizes would be handled by gimplify_parameters.  */
 {
+VEC(tree,gc) *pending_sizes = get_pending_sizes ();
 tree t;
-for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
+int i;
-add_stmt (TREE_VALUE (t));
+FOR_EACH_VEC_ELT (tree, pending_sizes, i, t)
+add_stmt (t);
 }
 /* Even though we're inside a function body, we still don't want to
 call expand_expr to calculate the size of a variable-sized array.
 We haven't necessarily assigned RTL to all variables yet, so it's
 cfun->dont_save_pending_sizes_p = 1;
 }
 /* Finish up a function declaration and compile that function
-all the way to assembler language output.  The free the storage
+all the way to assembler language output.  Then free the storage
 for the function definition.
 This is called after parsing the body of the function definition.  */
 void
 finish_function (void)
 {
 tree fndecl = current_function_decl;
+if (c_dialect_objc ())
+objc_finish_function ();
 if (TREE_CODE (fndecl) == FUNCTION_DECL
 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
 {
 tree args = DECL_ARGUMENTS (fndecl);
-for (; args; args = TREE_CHAIN (args))
+for (; args; args = DECL_CHAIN (args))
-{
+	{
-tree type = TREE_TYPE (args);
+	  tree type = TREE_TYPE (args);
-if (INTEGRAL_TYPE_P (type)
+	  if (INTEGRAL_TYPE_P (type)
-&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
+	      && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
-DECL_ARG_TYPE (args) = integer_type_node;
+	    DECL_ARG_TYPE (args) = integer_type_node;
-}
+	}
 }
 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
 if (warn_return_type
 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
 && !current_function_returns_value && !current_function_returns_null
 /* Don't complain if we are no-return.  */
 && !current_function_returns_abnormally
+/* Don't complain if we are declared noreturn.  */
+&& !TREE_THIS_VOLATILE (fndecl)
 /* Don't warn for main().  */
 && !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, but we might
 && !TREE_PUBLIC (fndecl))
 {
 warning (OPT_Wreturn_type,
 "no return statement in function returning non-void");
 TREE_NO_WARNING (fndecl) = 1;
+}
+/* Complain about parameters that are only set, but never otherwise used.  */
+if (warn_unused_but_set_parameter)
+{
+tree decl;
+for (decl = DECL_ARGUMENTS (fndecl);
+	   decl;
+	   decl = DECL_CHAIN (decl))
+	if (TREE_USED (decl)
+	    && TREE_CODE (decl) == PARM_DECL
+	    && !DECL_READ_P (decl)
+	    && DECL_NAME (decl)
+	    && !DECL_ARTIFICIAL (decl)
+	    && !TREE_NO_WARNING (decl))
+	  warning_at (DECL_SOURCE_LOCATION (decl),
+		      OPT_Wunused_but_set_parameter,
+		      "parameter %qD set but not used", decl);
 }
 /* Store the end of the function, so that we get good line number
 info for the epilogue.  */
 cfun->function_end_locus = input_location;
 current_function_decl = NULL;
 }
 /* Check the declarations given in a for-loop for satisfying the C99
 constraints.  If exactly one such decl is found, return it.  LOC is
-the location of the opening parenthesis of the for loop.  */
+the location of the opening parenthesis of the for loop.  The last
+parameter allows you to control the "for loop initial declarations
+are only allowed in C99 mode".  Normally, you should pass
+flag_isoc99 as that parameter.  But in some cases (Objective-C
+foreach loop, for example) we want to run the checks in this
+function even if not in C99 mode, so we allow the caller to turn
+off the error about not being in C99 mode.
+*/
 tree
-check_for_loop_decls (location_t loc)
+check_for_loop_decls (location_t loc, bool turn_off_iso_c99_error)
 {
 struct c_binding *b;
 tree one_decl = NULL_TREE;
 int n_decls = 0;
-if (!flag_isoc99)
+if (!turn_off_iso_c99_error)
 {
 static bool hint = true;
 /* If we get here, declarations have been used in a for loop without
 the C99 for loop scope.  This doesn't make much sense, so don't
 allow it.  */
 void
 c_push_function_context (void)
 {
 struct language_function *p;
-p = GGC_NEW (struct language_function);
+p = ggc_alloc_language_function ();
 cfun->language = p;
 p->base.x_stmt_tree = c_stmt_tree;
 p->x_break_label = c_break_label;
 p->x_cont_label = c_cont_label;
 ret->attrs = 0;
 ret->typespec_word = cts_none;
 ret->storage_class = csc_none;
 ret->expr_const_operands = true;
 ret->declspecs_seen_p = false;
-ret->type_seen_p = false;
+ret->typespec_kind = ctsk_none;
 ret->non_sc_seen_p = false;
 ret->typedef_p = false;
-ret->tag_defined_p = false;
 ret->explicit_signed_p = false;
 ret->deprecated_p = false;
 ret->default_int_p = false;
 ret->long_p = false;
 ret->long_long_p = false;
 struct c_typespec spec)
 {
 tree type = spec.spec;
 specs->non_sc_seen_p = true;
 specs->declspecs_seen_p = true;
-specs->type_seen_p = true;
+specs->typespec_kind = spec.kind;
 if (TREE_DEPRECATED (type))
 specs->deprecated_p = true;
 /* Handle type specifier keywords.  */
 if (TREE_CODE (type) == IDENTIFIER_NODE
 {
 error_at (loc, "two or more data types in declaration specifiers");
 return specs;
 }
 if ((int) i <= (int) RID_LAST_MODIFIER)
-{
+	{
-/* "long", "short", "signed", "unsigned", "_Complex" or "_Sat".  */
+	  /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat".  */
-bool dupe = false;
+	  bool dupe = false;
-switch (i)
+	  switch (i)
-{
+	    {
-case RID_LONG:
+	    case RID_LONG:
-if (specs->long_long_p)
+	      if (specs->long_long_p)
-{
+		{
-error_at (loc, "%<long long long%> is too long for GCC");
+		  error_at (loc, "%<long long long%> is too long for GCC");
-break;
+		  break;
-}
+		}
-if (specs->long_p)
+	      if (specs->long_p)
-{
+		{
-if (specs->typespec_word == cts_double)
+		  if (specs->typespec_word == cts_double)
-{
+		    {
-error_at (loc,
+		      error_at (loc,
-("both %<long long%> and %<double%> in "
+				("both %<long long%> and %<double%> in "
-"declaration specifiers"));
+				 "declaration specifiers"));
-break;
+		      break;
-}
+		    }
-pedwarn_c90 (loc, OPT_Wlong_long,
+		  pedwarn_c90 (loc, OPT_Wlong_long,
-"ISO C90 does not support %<long long%>");
+			       "ISO C90 does not support %<long long%>");
-specs->long_long_p = 1;
+		  specs->long_long_p = 1;
-break;
+		  break;
-}
+		}
-if (specs->short_p)
+	      if (specs->short_p)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<short%> in "
+			  ("both %<long%> and %<short%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_void)
+	      else if (specs->typespec_word == cts_void)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<void%> in "
+			  ("both %<long%> and %<void%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
 #ifndef noCbC
-else if (specs->typespec_word == cts_CbC_code)
+	      else if (specs->typespec_word == cts_CbC_code)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<void%> in "
+			  ("both %<long%> and %<void%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
 #endif
-else if (specs->typespec_word == cts_bool)
+	      else if (specs->typespec_word == cts_int128)
-error_at (loc,
+		  error_at (loc,
-("both %<long%> and %<_Bool%> in "
+			    ("both %<long%> and %<__int128%> in "
-"declaration specifiers"));
+			     "declaration specifiers"));
-else if (specs->typespec_word == cts_char)
+	      else if (specs->typespec_word == cts_bool)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<char%> in "
+			  ("both %<long%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_float)
+	      else if (specs->typespec_word == cts_char)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<float%> in "
+			  ("both %<long%> and %<char%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_dfloat32)
+	      else if (specs->typespec_word == cts_float)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<_Decimal32%> in "
+			  ("both %<long%> and %<float%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_dfloat64)
+	      else if (specs->typespec_word == cts_dfloat32)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<_Decimal64%> in "
+			  ("both %<long%> and %<_Decimal32%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_dfloat128)
+	      else if (specs->typespec_word == cts_dfloat64)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<_Decimal128%> in "
+			  ("both %<long%> and %<_Decimal64%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else
+	      else if (specs->typespec_word == cts_dfloat128)
-specs->long_p = true;
+		error_at (loc,
-break;
+			  ("both %<long%> and %<_Decimal128%> in "
-case RID_SHORT:
+			   "declaration specifiers"));
-dupe = specs->short_p;
+	      else
-if (specs->long_p)
+		specs->long_p = true;
-error_at (loc,
+	      break;
-("both %<long%> and %<short%> in "
+	    case RID_SHORT:
-"declaration specifiers"));
+	      dupe = specs->short_p;
-else if (specs->typespec_word == cts_void)
+	      if (specs->long_p)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<void%> in "
+			  ("both %<long%> and %<short%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_void)
+		error_at (loc,
+			  ("both %<short%> and %<void%> in "
+			   "declaration specifiers"));
 #ifndef noCbC
-else if (specs->typespec_word == cts_CbC_code)
+	      else if (specs->typespec_word == cts_CbC_code)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<void%> in "
+			  ("both %<short%> and %<void%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
 #endif
-else if (specs->typespec_word == cts_bool)
+	      else if (specs->typespec_word == cts_int128)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<_Bool%> in "
+			  ("both %<short%> and %<__int128%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_char)
+	      else if (specs->typespec_word == cts_bool)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<char%> in "
+			  ("both %<short%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_float)
+	      else if (specs->typespec_word == cts_char)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<float%> in "
+			  ("both %<short%> and %<char%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_double)
+	      else if (specs->typespec_word == cts_float)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<double%> in "
+			  ("both %<short%> and %<float%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_dfloat32)
+	      else if (specs->typespec_word == cts_double)
+		error_at (loc,
+			  ("both %<short%> and %<double%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat32)
+>>>>>>> other
 error_at (loc,
 ("both %<short%> and %<_Decimal32%> in "
 "declaration specifiers"));
 else if (specs->typespec_word == cts_dfloat64)
 error_at (loc,
 else if (specs->typespec_word == cts_bool)
 error_at (loc,
 ("both %<complex%> and %<_Bool%> in "
 "declaration specifiers"));
 else if (specs->typespec_word == cts_dfloat32)
-error_at (loc,
+		error_at (loc,
-("both %<complex%> and %<_Decimal32%> in "
+			  ("both %<complex%> and %<_Decimal32%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_dfloat64)
+	      else if (specs->typespec_word == cts_dfloat64)
-error_at (loc,
+		error_at (loc,
-("both %<complex%> and %<_Decimal64%> in "
+			  ("both %<complex%> and %<_Decimal64%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_dfloat128)
+	      else if (specs->typespec_word == cts_dfloat128)
-error_at (loc,
+		error_at (loc,
-("both %<complex%> and %<_Decimal128%> in "
+			  ("both %<complex%> and %<_Decimal128%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_fract)
+	      else if (specs->typespec_word == cts_fract)
-error_at (loc,
+		error_at (loc,
-("both %<complex%> and %<_Fract%> in "
+			  ("both %<complex%> and %<_Fract%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->typespec_word == cts_accum)
+	      else if (specs->typespec_word == cts_accum)
-error_at (loc,
+		error_at (loc,
-("both %<complex%> and %<_Accum%> in "
+			  ("both %<complex%> and %<_Accum%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->saturating_p)
+	      else if (specs->saturating_p)
-error_at (loc,
+		error_at (loc,
-("both %<complex%> and %<_Sat%> in "
+			  ("both %<complex%> and %<_Sat%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else
+	      else
-specs->complex_p = true;
+		specs->complex_p = true;
-break;
+	      break;
-case RID_SAT:
+	    case RID_SAT:
-dupe = specs->saturating_p;
+	      dupe = specs->saturating_p;
-pedwarn (loc, OPT_pedantic,
+	      pedwarn (loc, OPT_pedantic,
-"ISO C does not support saturating types");
+		       "ISO C does not support saturating types");
-if (specs->typespec_word == cts_void)
+	      if (specs->typespec_word == cts_int128)
-error_at (loc,
+	        {
-("both %<_Sat%> and %<void%> in "
+		  error_at (loc,
-"declaration specifiers"));
+			    ("both %<_Sat%> and %<__int128%> in "
-else if (specs->typespec_word == cts_bool)
+			     "declaration specifiers"));
-error_at (loc,
+	        }
-("both %<_Sat%> and %<_Bool%> in "
+	      else if (specs->typespec_word == cts_void)
-"declaration specifiers"));
+		error_at (loc,
-else if (specs->typespec_word == cts_char)
+			  ("both %<_Sat%> and %<void%> in "
-error_at (loc,
+			   "declaration specifiers"));
-("both %<_Sat%> and %<char%> in "
+	      else if (specs->typespec_word == cts_bool)
-"declaration specifiers"));
+		error_at (loc,
-else if (specs->typespec_word == cts_int)
+			  ("both %<_Sat%> and %<_Bool%> in "
-error_at (loc,
+			   "declaration specifiers"));
-("both %<_Sat%> and %<int%> in "
+	      else if (specs->typespec_word == cts_char)
-"declaration specifiers"));
+		error_at (loc,
-else if (specs->typespec_word == cts_float)
+			  ("both %<_Sat%> and %<char%> in "
-error_at (loc,
+			   "declaration specifiers"));
-("both %<_Sat%> and %<float%> in "
+	      else if (specs->typespec_word == cts_int)
-"declaration specifiers"));
+		error_at (loc,
-else if (specs->typespec_word == cts_double)
+			  ("both %<_Sat%> and %<int%> in "
-error_at (loc,
+			   "declaration specifiers"));
-("both %<_Sat%> and %<double%> in "
+	      else if (specs->typespec_word == cts_float)
-"declaration specifiers"));
+		error_at (loc,
+			  ("both %<_Sat%> and %<float%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_double)
+		error_at (loc,
+			  ("both %<_Sat%> and %<double%> in "
+			   "declaration specifiers"));
 else if (specs->typespec_word == cts_dfloat32)
 error_at (loc,
 ("both %<_Sat%> and %<_Decimal32%> in "
 "declaration specifiers"));
 else if (specs->typespec_word == cts_dfloat64)
 error_at (loc, "duplicate %qE", type);
 return specs;
 }
 else
-{
+	{
-/* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
+	  /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
-"_Decimal64", "_Decimal128", "_Fract" or "_Accum".  */
+	     "__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum".  */
-if (specs->typespec_word != cts_none)
+	  if (specs->typespec_word != cts_none)
-{
+	    {
-error_at (loc,
+	      error_at (loc,
-"two or more data types in declaration specifiers");
+			"two or more data types in declaration specifiers");
-return specs;
+	      return specs;
-}
+	    }
-switch (i)
+	  switch (i)
-{
+	    {
-case RID_VOID:
+	    case RID_INT128:
-if (specs->long_p)
+	      if (int128_integer_type_node == NULL_TREE)
-error_at (loc,
+		{
-("both %<long%> and %<void%> in "
+		  error_at (loc, "%<__int128%> is not supported for this target");
-"declaration specifiers"));
+		  return specs;
-else if (specs->short_p)
+		}
-error_at (loc,
+	      if (!in_system_header)
-("both %<short%> and %<void%> in "
+		pedwarn (loc, OPT_pedantic,
-"declaration specifiers"));
+			 "ISO C does not support %<__int128%> type");
-else if (specs->signed_p)
-error_at (loc,
+	      if (specs->long_p)
-("both %<signed%> and %<void%> in "
+		error_at (loc,
-"declaration specifiers"));
+			  ("both %<__int128%> and %<long%> in "
-else if (specs->unsigned_p)
+			   "declaration specifiers"));
-error_at (loc,
+	      else if (specs->saturating_p)
-("both %<unsigned%> and %<void%> in "
+		error_at (loc,
-"declaration specifiers"));
+			  ("both %<_Sat%> and %<__int128%> in "
-else if (specs->complex_p)
+			   "declaration specifiers"));
-error_at (loc,
+	      else if (specs->short_p)
-("both %<complex%> and %<void%> in "
+		error_at (loc,
-"declaration specifiers"));
+			  ("both %<__int128%> and %<short%> in "
-else if (specs->saturating_p)
+			   "declaration specifiers"));
-error_at (loc,
+	      else
-("both %<_Sat%> and %<void%> in "
+		specs->typespec_word = cts_int128;
-"declaration specifiers"));
+	      return specs;
-else
+	    case RID_VOID:
-specs->typespec_word = cts_void;
+	      if (specs->long_p)
-return specs;
+		error_at (loc,
+			  ("both %<long%> and %<void%> in "
+			   "declaration specifiers"));
+	      else if (specs->short_p)
+		error_at (loc,
+			  ("both %<short%> and %<void%> in "
+			   "declaration specifiers"));
+	      else if (specs->signed_p)
+		error_at (loc,
+			  ("both %<signed%> and %<void%> in "
+			   "declaration specifiers"));
+	      else if (specs->unsigned_p)
+		error_at (loc,
+			  ("both %<unsigned%> and %<void%> in "
+			   "declaration specifiers"));
+	      else if (specs->complex_p)
+		error_at (loc,
+			  ("both %<complex%> and %<void%> in "
+			   "declaration specifiers"));
+	      else if (specs->saturating_p)
+		error_at (loc,
+			  ("both %<_Sat%> and %<void%> in "
+			   "declaration specifiers"));
+	      else
+		specs->typespec_word = cts_void;
+	      return specs;
 #ifndef noCbC
-case RID_CbC_CODE:
+	    case RID_CbC_CODE:
-if (specs->long_p)
+	    if (specs->long_p)
-error ("both %<long%> and %<void%> in "
+	      error ("both %<long%> and %<void%> in "
-"declaration specifiers");
+		     "declaration specifiers");
-else if (specs->short_p)
+	    else if (specs->short_p)
-error ("both %<short%> and %<void%> in "
+	      error ("both %<short%> and %<void%> in "
-"declaration specifiers");
+		     "declaration specifiers");
-else if (specs->signed_p)
+	    else if (specs->signed_p)
-error ("both %<signed%> and %<void%> in "
+	      error ("both %<signed%> and %<void%> in "
-"declaration specifiers");
+		     "declaration specifiers");
-else if (specs->unsigned_p)
+	    else if (specs->unsigned_p)
-error ("both %<unsigned%> and %<void%> in "
+	      error ("both %<unsigned%> and %<void%> in "
-"declaration specifiers");
+		     "declaration specifiers");
-else if (specs->complex_p)
+	    else if (specs->complex_p)
-error ("both %<complex%> and %<void%> in "
+	      error ("both %<complex%> and %<void%> in "
-"declaration specifiers");
+		     "declaration specifiers");
-else
+	    else
-specs->typespec_word = cts_CbC_code;
+	      specs->typespec_word = cts_CbC_code;
-return specs;
+	    return specs;
 #endif
-case RID_BOOL:
+	    case RID_BOOL:
-if (specs->long_p)
+	      if (specs->long_p)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<_Bool%> in "
+			  ("both %<long%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->short_p)
+	      else if (specs->short_p)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<_Bool%> in "
+			  ("both %<short%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->signed_p)
+	      else if (specs->signed_p)
-error_at (loc,
+		error_at (loc,
-("both %<signed%> and %<_Bool%> in "
+			  ("both %<signed%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->unsigned_p)
+	      else if (specs->unsigned_p)
-error_at (loc,
+		error_at (loc,
-("both %<unsigned%> and %<_Bool%> in "
+			  ("both %<unsigned%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->complex_p)
+	      else if (specs->complex_p)
-error_at (loc,
+		error_at (loc,
-("both %<complex%> and %<_Bool%> in "
+			  ("both %<complex%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->saturating_p)
+	      else if (specs->saturating_p)
-error_at (loc,
+		error_at (loc,
-("both %<_Sat%> and %<_Bool%> in "
+			  ("both %<_Sat%> and %<_Bool%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else
+	      else
-specs->typespec_word = cts_bool;
+		specs->typespec_word = cts_bool;
-return specs;
+	      return specs;
-case RID_CHAR:
+	    case RID_CHAR:
-if (specs->long_p)
+	      if (specs->long_p)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<char%> in "
+			  ("both %<long%> and %<char%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->short_p)
+	      else if (specs->short_p)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<char%> in "
+			  ("both %<short%> and %<char%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->saturating_p)
+	      else if (specs->saturating_p)
-error_at (loc,
+		error_at (loc,
-("both %<_Sat%> and %<char%> in "
+			  ("both %<_Sat%> and %<char%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else
+	      else
-specs->typespec_word = cts_char;
+		specs->typespec_word = cts_char;
-return specs;
+	      return specs;
-case RID_INT:
+	    case RID_INT:
-if (specs->saturating_p)
+	      if (specs->saturating_p)
-error_at (loc,
+		error_at (loc,
-("both %<_Sat%> and %<int%> in "
+			  ("both %<_Sat%> and %<int%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else
+	      else
-specs->typespec_word = cts_int;
+		specs->typespec_word = cts_int;
-return specs;
+	      return specs;
-case RID_FLOAT:
+	    case RID_FLOAT:
-if (specs->long_p)
+	      if (specs->long_p)
-error_at (loc,
+		error_at (loc,
-("both %<long%> and %<float%> in "
+			  ("both %<long%> and %<float%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->short_p)
+	      else if (specs->short_p)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<float%> in "
+			  ("both %<short%> and %<float%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->signed_p)
+	      else if (specs->signed_p)
-error_at (loc,
+		error_at (loc,
-("both %<signed%> and %<float%> in "
+			  ("both %<signed%> and %<float%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->unsigned_p)
+	      else if (specs->unsigned_p)
-error_at (loc,
+		error_at (loc,
-("both %<unsigned%> and %<float%> in "
+			  ("both %<unsigned%> and %<float%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->saturating_p)
+	      else if (specs->saturating_p)
-error_at (loc,
+		error_at (loc,
-("both %<_Sat%> and %<float%> in "
+			  ("both %<_Sat%> and %<float%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else
+	      else
-specs->typespec_word = cts_float;
+		specs->typespec_word = cts_float;
-return specs;
+	      return specs;
-case RID_DOUBLE:
+	    case RID_DOUBLE:
-if (specs->long_long_p)
+	      if (specs->long_long_p)
-error_at (loc,
+		error_at (loc,
-("both %<long long%> and %<double%> in "
+			  ("both %<long long%> and %<double%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->short_p)
+	      else if (specs->short_p)
-error_at (loc,
+		error_at (loc,
-("both %<short%> and %<double%> in "
+			  ("both %<short%> and %<double%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->signed_p)
+	      else if (specs->signed_p)
-error_at (loc,
+		error_at (loc,
-("both %<signed%> and %<double%> in "
+			  ("both %<signed%> and %<double%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->unsigned_p)
+	      else if (specs->unsigned_p)
-error_at (loc,
+		error_at (loc,
-("both %<unsigned%> and %<double%> in "
+			  ("both %<unsigned%> and %<double%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else if (specs->saturating_p)
+	      else if (specs->saturating_p)
-error_at (loc,
+		error_at (loc,
-("both %<_Sat%> and %<double%> in "
+			  ("both %<_Sat%> and %<double%> in "
-"declaration specifiers"));
+			   "declaration specifiers"));
-else
+	      else
-specs->typespec_word = cts_double;
+		specs->typespec_word = cts_double;
-return specs;
+	      return specs;
-case RID_DFLOAT32:
+	    case RID_DFLOAT32:
-case RID_DFLOAT64:
+	    case RID_DFLOAT64:
-case RID_DFLOAT128:
+	    case RID_DFLOAT128:
-{
+	      {
-const char *str;
+		const char *str;
-if (i == RID_DFLOAT32)
+		if (i == RID_DFLOAT32)
-str = "_Decimal32";
+		  str = "_Decimal32";
-else if (i == RID_DFLOAT64)
+		else if (i == RID_DFLOAT64)
-str = "_Decimal64";
+		  str = "_Decimal64";
-else
+		else
-str = "_Decimal128";
+		  str = "_Decimal128";
-if (specs->long_long_p)
+		if (specs->long_long_p)
-error_at (loc,
+		  error_at (loc,
-("both %<long long%> and %<%s%> in "
+			    ("both %<long long%> and %<%s%> in "
-"declaration specifiers"),
+			     "declaration specifiers"),
-str);
+			    str);
-if (specs->long_p)
+		if (specs->long_p)
-error_at (loc,
+		  error_at (loc,
-("both %<long%> and %<%s%> in "
+			    ("both %<long%> and %<%s%> in "
-"declaration specifiers"),
+			     "declaration specifiers"),
-str);
+			    str);
-else if (specs->short_p)
+		else if (specs->short_p)
-error_at (loc,
+		  error_at (loc,
-("both %<short%> and %<%s%> in "
+			    ("both %<short%> and %<%s%> in "
-"declaration specifiers"),
+			     "declaration specifiers"),
-str);
+			    str);
-else if (specs->signed_p)
+		else if (specs->signed_p)
-error_at (loc,
+		  error_at (loc,
-("both %<signed%> and %<%s%> in "
+			    ("both %<signed%> and %<%s%> in "
-"declaration specifiers"),
+			     "declaration specifiers"),
-str);
+			    str);
-else if (specs->unsigned_p)
+		else if (specs->unsigned_p)
-error_at (loc,
+		  error_at (loc,
-("both %<unsigned%> and %<%s%> in "
+			    ("both %<unsigned%> and %<%s%> in "
-"declaration specifiers"),
+			     "declaration specifiers"),
-str);
+			    str);
 else if (specs->complex_p)
 error_at (loc,
 ("both %<complex%> and %<%s%> in "
 "declaration specifiers"),
 str);
 else if (TREE_TYPE (t) == error_mark_node)
 ;
 else
 specs->type = TREE_TYPE (t);
 }
-else if (TREE_CODE (type) != ERROR_MARK)
+else
 {
-if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
+if (TREE_CODE (type) != ERROR_MARK && spec.kind == ctsk_typeof)
-specs->tag_defined_p = true;
+	{
-if (spec.kind == ctsk_typeof)
+	  specs->typedef_p = true;
-{
+	  if (spec.expr)
-specs->typedef_p = true;
+	    {
-if (spec.expr)
+	      if (specs->expr)
-{
+		specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
-if (specs->expr)
+				      specs->expr, spec.expr);
-specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
+	      else
-specs->expr, spec.expr);
+		specs->expr = spec.expr;
-else
+	      specs->expr_const_operands &= spec.expr_const_operands;
-specs->expr = spec.expr;
+	    }
-specs->expr_const_operands &= spec.expr_const_operands;
+	}
-}
-}
 specs->type = type;
 }
 return specs;
 }
 /* If a type was specified as a whole, we have no modifiers and are
 done.  */
 if (specs->type != NULL_TREE)
 {
 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
-&& !specs->signed_p && !specs->unsigned_p
+		  && !specs->signed_p && !specs->unsigned_p
-&& !specs->complex_p);
+		  && !specs->complex_p);
+/* Set a dummy type.  */
+if (TREE_CODE (specs->type) == ERROR_MARK)
+specs->type = integer_type_node;
 return specs;
 }
 /* If none of "void", "_Bool", "char", "int", "float" or "double"
 has been specified, treat it as "int" unless "_Complex" is
 pedwarn (input_location, OPT_pedantic,
 "ISO C does not support complex integer types");
 specs->type = build_complex_type (specs->type);
 }
 break;
+case cts_int128:
+gcc_assert (!specs->long_p && !specs->short_p && !specs->long_long_p);
+gcc_assert (!(specs->signed_p && specs->unsigned_p));
+specs->type = (specs->unsigned_p
+		     ? int128_unsigned_type_node
+		     : int128_integer_type_node);
+if (specs->complex_p)
+	{
+	  pedwarn (input_location, OPT_pedantic,
+		   "ISO C does not support complex integer types");
+	  specs->type = build_complex_type (specs->type);
+	}
+break;
 case cts_int:
 gcc_assert (!(specs->long_p && specs->short_p));
 gcc_assert (!(specs->signed_p && specs->unsigned_p));
 if (specs->long_long_p)
 specs->type = (specs->unsigned_p
 {
 tree decl;
 bool reconsider;
 /* Process the decls in the order they were written.  */
-for (decl = globals; decl; decl = TREE_CHAIN (decl))
+for (decl = globals; decl; decl = DECL_CHAIN (decl))
 {
 /* Check for used but undefined static functions using the C
 standard's definition of "used", and set TREE_NO_WARNING so
 that check_global_declarations doesn't repeat the check.  */
 if (TREE_CODE (decl) == FUNCTION_DECL
 }
 do
 {
 reconsider = false;
-for (decl = globals; decl; decl = TREE_CHAIN (decl))
+for (decl = globals; decl; decl = DECL_CHAIN (decl))
-reconsider |= wrapup_global_declaration_2 (decl);
+	reconsider |= wrapup_global_declaration_2 (decl);
 }
 while (reconsider);
-for (decl = globals; decl; decl = TREE_CHAIN (decl))
+for (decl = globals; decl; decl = DECL_CHAIN (decl))
 check_global_declaration_1 (decl);
 }
 /* A subroutine of c_write_global_declarations Emit debug information for each
 of the declarations in GLOBALS.  */
 static void
 c_write_global_declarations_2 (tree globals)
 {
 tree decl;
-for (decl = globals; decl ; decl = TREE_CHAIN (decl))
+for (decl = globals; decl ; decl = DECL_CHAIN (decl))
 debug_hooks->global_decl (decl);
+}
+/* Callback to collect a source_ref from a DECL.  */
+static void
+collect_source_ref_cb (tree decl)
+{
+if (!DECL_IS_BUILTIN (decl))
+collect_source_ref (LOCATION_FILE (decl_sloc (decl, false)));
+}
+/* Collect all references relevant to SOURCE_FILE.  */
+static void
+collect_all_refs (const char *source_file)
+{
+tree t;
+unsigned i;
+FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file);
+}
+/* Iterate over all global declarations and call CALLBACK.  */
+static void
+for_each_global_decl (void (*callback) (tree decl))
+{
+tree t;
+tree decls;
+tree decl;
+unsigned i;
+FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+{
+decls = DECL_INITIAL (t);
+for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl))
+	callback (decl);
+}
 }
 /* Preserve the external declarations scope across a garbage collect.  */
 static GTY(()) tree ext_block;
 void
 c_write_global_declarations (void)
 {
 tree t;
+unsigned i;
 /* We don't want to do this if generating a PCH.  */
 if (pch_file)
 return;
-/* Don't waste time on further processing if -fsyntax-only.
+/* Do the Objective-C stuff.  This is where all the Objective-C
-Continue for warning and errors issued during lowering though.  */
+module stuff gets generated (symtab, class/protocol/selector
-if (flag_syntax_only)
+lists etc).  */
-return;
+if (c_dialect_objc ())
+objc_write_global_declarations ();
 /* Close the external scope.  */
 ext_block = pop_scope ();
 external_scope = 0;
 gcc_assert (!current_scope);
+/* Handle -fdump-ada-spec[-slim]. */
+if (dump_enabled_p (TDI_ada))
+{
+/* Build a table of files to generate specs for */
+if (get_dump_file_info (TDI_ada)->flags & TDF_SLIM)
+	collect_source_ref (main_input_filename);
+else
+	for_each_global_decl (collect_source_ref_cb);
+dump_ada_specs (collect_all_refs, NULL);
+}
 if (ext_block)
 {
 tree tmp = BLOCK_VARS (ext_block);
 int flags;
 FILE * stream = dump_begin (TDI_tu, &flags);
 }
 }
 /* Process all file scopes in this compilation, and the external_scope,
 through wrapup_global_declarations and check_global_declarations.  */
-for (t = all_translation_units; t; t = TREE_CHAIN (t))
+FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
 /* We're done parsing; proceed to optimize and emit assembly.
 FIXME: shouldn't be the front end's responsibility to call this.  */
 cgraph_finalize_compilation_unit ();
 /* After cgraph has had a chance to emit everything that's going to
 be emitted, output debug information for globals.  */
-if (errorcount == 0 && sorrycount == 0)
+if (!seen_error ())
 {
 timevar_push (TV_SYMOUT);
-for (t = all_translation_units; t; t = TREE_CHAIN (t))
+FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
-c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
+	c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
 timevar_pop (TV_SYMOUT);
 }
 ext_block = NULL;
 }
+/* Register reserved keyword WORD as qualifier for address space AS.  */
+void
+c_register_addr_space (const char *word, addr_space_t as)
+{
+int rid = RID_FIRST_ADDR_SPACE + as;
+tree id;
+/* Address space qualifiers are only supported
+in C with GNU extensions enabled.  */
+if (c_dialect_objc () || flag_no_asm)
+return;
+id = get_identifier (word);
+C_SET_RID_CODE (id, rid);
+C_IS_RESERVED_WORD (id) = 1;
+ridpointers [rid] = id;
+}
 #include "gt-c-decl.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-decl.c @ 69:1b10fe6932e1