re PR c/13801 (Decls should regain old type at end of scope)

	PR c/13801
	* c-decl.c (struct c_binding): Add type and inner_comp fields.
	(bind): Set type and inner_comp fields.
	(pop_scope): Restore type of decl to the correct type from an
	outer scope.  Give error when popping file scope for incomplete
	arrays completed incompatibly with default initialization in an
	inner scope.
	(diagnose_mismatched_decls): Handle externs with initializers at
	block scope.
	(pushdecl): Set type of external declaration at block scope based
	only on the visible declarations.  Save type when changing the
	type of a declaration.  Merge an external declaration at block
	scope with a visible static declaration at file scope.
	(implicitly_declare): Give recycled old declaration the new type
	except for incompatible declarations of built-in functions, saving
	the old type.

testsuite:
	* gcc.dg/redecl-3.c, gcc.dg/redecl-4.c, gcc.dg/redecl-6.c,
	gcc.dg/redecl-7.c, gcc.dg/redecl-8.c, gcc.dg/redecl-9.c,
	gcc.dg/redecl-10.c, gcc.dg/debug/redecl-1.c,
	gcc.dg/debug/redecl-2.c, gcc.dg/debug/redecl-3.c,
	gcc.dg/debug/redecl-4.c, gcc.dg/debug/redecl-5.c: New tests.

From-SVN: r86636

1 files changed, 137 insertions, 14 deletions

diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 6630d9a..a8f2530 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -164,6 +164,16 @@ bool c_override_global_bindings_to_false;
    suppress further errors about that identifier in the current
    function.
 
+   The ->type field stores the type of the declaration in this scope;
+   if NULL, the type is the type of the ->decl field.  This is only of
+   relevance for objects with external or internal linkage which may
+   be redeclared in inner scopes, forming composite types that only
+   persist for the duration of those scopes.  In the external scope,
+   this stores the composite of all the types declared for this
+   object, visible or not.  The ->inner_comp field (used only at file
+   scope) stores whether an incomplete array type at file scope was
+   completed at an inner scope to an array size other than 1.
+
    The depth field is copied from the scope structure that holds this
    decl.  It is used to preserve the proper ordering of the ->shadowed
    field (see bind()) and also for a handful of special-case checks.
@@ -176,13 +186,15 @@ bool c_override_global_bindings_to_false;
 struct c_binding GTY((chain_next ("%h.prev")))
 {
   tree decl;			/* the decl bound */
+  tree type;			/* the type in this scope */
   tree id;			/* the identifier it's bound to */
   struct c_binding *prev;	/* the previous decl in this scope */
   struct c_binding *shadowed;	/* the innermost decl shadowed by this one */
   unsigned int depth : 28;      /* depth of this scope */
   BOOL_BITFIELD invisible : 1;  /* normal lookup should ignore this binding */
   BOOL_BITFIELD nested : 1;     /* do not set DECL_CONTEXT when popping */
-  /* two free bits */
+  BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
+  /* one free bit */
 };
 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
@@ -436,6 +448,9 @@ bind (tree name, tree decl, struct c_scope *scope, bool invisible, bool nested)
   b->depth = scope->depth;
   b->invisible = invisible;
   b->nested = nested;
+  b->inner_comp = 0;
+
+  b->type = 0;
 
   b->prev = scope->bindings;
   scope->bindings = b;
@@ -758,6 +773,12 @@ pop_scope (void)
 	      && scope != external_scope)
 	    warning ("%Junused variable `%D'", p, p);
 
+	  if (b->inner_comp)
+	    {
+	      error ("%Jtype of array %qD completed incompatibly with"
+		     " implicit initialization", p, p);
+	    }
+
 	  /* Fall through.  */
 	case TYPE_DECL:
 	case CONST_DECL:
@@ -797,6 +818,8 @@ pop_scope (void)
 	      if (I_SYMBOL_BINDING (b->id) != b) abort ();
 #endif
 	      I_SYMBOL_BINDING (b->id) = b->shadowed;
+	      if (b->shadowed && b->shadowed->type)
+		TREE_TYPE (b->shadowed->decl) = b->shadowed->type;
 	    }
 	  break;
 
@@ -1357,15 +1380,23 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
       else if (!DECL_FILE_SCOPE_P (newdecl))
 	{
 	  if (DECL_EXTERNAL (newdecl))
-	    abort ();
+	    {
+	      /* Extern with initializer at block scope, which will
+		 already have received an error.  */
+	    }
 	  else if (DECL_EXTERNAL (olddecl))
-	    error ("%Jdeclaration of '%D' with no linkage follows "
-		   "extern declaration", newdecl, newdecl);
+	    {
+	      error ("%Jdeclaration of '%D' with no linkage follows "
+		     "extern declaration", newdecl, newdecl);
+	      locate_old_decl (olddecl, error);
+	    }
 	  else
-	    error ("%Jredeclaration of '%D' with no linkage",
-		   newdecl, newdecl);
+	    {
+	      error ("%Jredeclaration of '%D' with no linkage",
+		     newdecl, newdecl);
+	      locate_old_decl (olddecl, error);
+	    }
 
-	  locate_old_decl (olddecl, error);
 	  return false;
 	}
     }
@@ -1895,6 +1926,9 @@ pushdecl (tree x)
   b = I_SYMBOL_BINDING (name);
   if (b && B_IN_SCOPE (b, scope))
     {
+      if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
+	  && COMPLETE_TYPE_P (TREE_TYPE (x)))
+	b->inner_comp = false;
       if (duplicate_decls (x, b->decl))
 	return b->decl;
       else
@@ -1915,13 +1949,63 @@ pushdecl (tree x)
      have compatible type; otherwise, the behavior is undefined.)  */
   if (DECL_EXTERNAL (x) || scope == file_scope)
     {
+      tree type = TREE_TYPE (x);
+      tree vistype = 0;
+      tree visdecl = 0;
+      bool type_saved = false;
+      if (b && !B_IN_EXTERNAL_SCOPE (b)
+	  && (TREE_CODE (b->decl) == FUNCTION_DECL
+	      || TREE_CODE (b->decl) == VAR_DECL)
+	  && DECL_FILE_SCOPE_P (b->decl))
+	{
+	  visdecl = b->decl;
+	  vistype = TREE_TYPE (visdecl);
+	}
       if (warn_nested_externs
 	  && scope != file_scope
 	  && !DECL_IN_SYSTEM_HEADER (x))
 	warning ("nested extern declaration of '%D'", x);
 
       while (b && !B_IN_EXTERNAL_SCOPE (b))
-	b = b->shadowed;
+	{
+	  /* If this decl might be modified, save its type.  This is
+	     done here rather than when the decl is first bound
+	     because the type may change after first binding, through
+	     being completed or through attributes being added.  If we
+	     encounter multiple such decls, only the first should have
+	     its type saved; the others will already have had their
+	     proper types saved and the types will not have changed as
+	     their scopes will not have been re-entered.  */
+	  if (DECL_FILE_SCOPE_P (b->decl) && !type_saved)
+	    {
+	      b->type = TREE_TYPE (b->decl);
+	      type_saved = true;
+	    }
+	  if (B_IN_FILE_SCOPE (b)
+	      && TREE_CODE (b->decl) == VAR_DECL
+	      && TREE_STATIC (b->decl)
+	      && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
+	      && !TYPE_DOMAIN (TREE_TYPE (b->decl))
+	      && TREE_CODE (type) == ARRAY_TYPE
+	      && TYPE_DOMAIN (type)
+	      && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
+	      && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
+	    {
+	      /* Array type completed in inner scope, which should be
+		 diagnosed if the completion does not have size 1 and
+		 it does not get completed in the file scope.  */
+	      b->inner_comp = true;
+	    }
+	  b = b->shadowed;
+	}
+
+      /* If a matching external declaration has been found, set its
+	 type to the composite of all the types of that declaration.
+	 After the consistency checks, it will be reset to the
+	 composite of the visible types only.  */
+      if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
+	  && b->type)
+	TREE_TYPE (b->decl) = b->type;
 
       /* The point of the same_translation_unit_p check here is,
 	 we want to detect a duplicate decl for a construct like
@@ -1932,13 +2016,34 @@ pushdecl (tree x)
 	  && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
 	  && duplicate_decls (x, b->decl))
 	{
+	  tree thistype;
+	  thistype = (vistype ? composite_type (vistype, type) : type);
+	  b->type = TREE_TYPE (b->decl);
+	  if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
+	    thistype
+	      = build_type_attribute_variant (thistype,
+					      TYPE_ATTRIBUTES (b->type));
+	  TREE_TYPE (b->decl) = thistype;
 	  bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true);
 	  return b->decl;
 	}
       else if (TREE_PUBLIC (x))
 	{
-	  bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false);
-	  nested = true;
+	  if (visdecl && !b && duplicate_decls (x, visdecl))
+	    {
+	      /* An external declaration at block scope referring to a
+		 visible entity with internal linkage.  The composite
+		 type will already be correct for this scope, so we
+		 just need to fall through to make the declaration in
+		 this scope.  */
+	      nested = true;
+	    }
+	  else
+	    {
+	      bind (name, x, external_scope, /*invisible=*/true,
+		    /*nested=*/false);
+	      nested = true;
+	    }
 	}
     }
   /* Similarly, a declaration of a function with static linkage at
@@ -2056,7 +2161,16 @@ implicit_decl_warning (tree id, tree olddecl)
 tree
 implicitly_declare (tree functionid)
 {
-  tree decl = lookup_name_in_scope (functionid, external_scope);
+  struct c_binding *b;
+  tree decl = 0;
+  for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
+    {
+      if (B_IN_SCOPE (b, external_scope))
+	{
+	  decl = b->decl;
+	  break;
+	}
+    }
 
   if (decl)
     {
@@ -2073,10 +2187,13 @@ implicitly_declare (tree functionid)
 	}
       else
 	{
+	  tree newtype = default_function_type;
+	  if (b->type)
+	    TREE_TYPE (decl) = b->type;
 	  /* Implicit declaration of a function already declared
 	     (somehow) in a different scope, or as a built-in.
 	     If this is the first time this has happened, warn;
-	     then recycle the old declaration.  */
+	     then recycle the old declaration but with the new type.  */
 	  if (!C_DECL_IMPLICIT (decl))
 	    {
 	      implicit_decl_warning (functionid, decl);
@@ -2084,21 +2201,27 @@ implicitly_declare (tree functionid)
 	    }
 	  if (DECL_BUILT_IN (decl))
 	    {
-	      if (!comptypes (default_function_type, TREE_TYPE (decl)))
+	      newtype = build_type_attribute_variant (newtype,
+						      TYPE_ATTRIBUTES
+						      (TREE_TYPE (decl)));
+	      if (!comptypes (newtype, TREE_TYPE (decl)))
 		{
 		  warning ("incompatible implicit declaration of built-in"
 			   " function %qD", decl);
+		  newtype = TREE_TYPE (decl);
 		}
 	    }
 	  else
 	    {
-	      if (!comptypes (default_function_type, TREE_TYPE (decl)))
+	      if (!comptypes (newtype, TREE_TYPE (decl)))
 		{
 		  error ("incompatible implicit declaration of function %qD",
 			 decl);
 		  locate_old_decl (decl, error);
 		}
 	    }
+	  b->type = TREE_TYPE (decl);
+	  TREE_TYPE (decl) = newtype;
 	  bind (functionid, decl, current_scope,
 		/*invisible=*/false, /*nested=*/true);
 	  return decl;