OSDN Git Service

* emit-rtl.c (add_insn_before): Fix comment typo.
[pf3gnuchains/gcc-fork.git] / gcc / c-decl.c
1 /* Process declarations and variables for C compiler.
2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 /* Process declarations and symbol lookup for C front end.
23    Also constructs types; the standard scalar types at initialization,
24    and structure, union, array and enum types when they are declared.  */
25
26 /* ??? not all decl nodes are given the most useful possible
27    line numbers.  For example, the CONST_DECLs for enum values.  */
28
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "input.h"
33 #include "tm.h"
34 #include "intl.h"
35 #include "tree.h"
36 #include "tree-inline.h"
37 #include "rtl.h"
38 #include "flags.h"
39 #include "function.h"
40 #include "output.h"
41 #include "expr.h"
42 #include "c-tree.h"
43 #include "toplev.h"
44 #include "ggc.h"
45 #include "tm_p.h"
46 #include "cpplib.h"
47 #include "target.h"
48 #include "debug.h"
49 #include "opts.h"
50 #include "timevar.h"
51 #include "c-common.h"
52 #include "c-pragma.h"
53 #include "langhooks.h"
54 #include "tree-mudflap.h"
55 #include "tree-gimple.h"
56 #include "diagnostic.h"
57 #include "tree-dump.h"
58 #include "cgraph.h"
59 #include "hashtab.h"
60 #include "libfuncs.h"
61 #include "except.h"
62 #include "langhooks-def.h"
63
64 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
65 enum decl_context
66 { NORMAL,                       /* Ordinary declaration */
67   FUNCDEF,                      /* Function definition */
68   PARM,                         /* Declaration of parm before function body */
69   FIELD,                        /* Declaration inside struct or union */
70   TYPENAME};                    /* Typename (inside cast or sizeof)  */
71
72 \f
73 /* Nonzero if we have seen an invalid cross reference
74    to a struct, union, or enum, but not yet printed the message.  */
75 tree pending_invalid_xref;
76
77 /* File and line to appear in the eventual error message.  */
78 location_t pending_invalid_xref_location;
79
80 /* True means we've initialized exception handling.  */
81 bool c_eh_initialized_p;
82
83 /* While defining an enum type, this is 1 plus the last enumerator
84    constant value.  Note that will do not have to save this or `enum_overflow'
85    around nested function definition since such a definition could only
86    occur in an enum value expression and we don't use these variables in
87    that case.  */
88
89 static tree enum_next_value;
90
91 /* Nonzero means that there was overflow computing enum_next_value.  */
92
93 static int enum_overflow;
94
95 /* The file and line that the prototype came from if this is an
96    old-style definition; used for diagnostics in
97    store_parm_decls_oldstyle.  */
98
99 static location_t current_function_prototype_locus;
100
101 /* The argument information structure for the function currently being
102    defined.  */
103
104 static struct c_arg_info *current_function_arg_info;
105
106 /* The obstack on which parser and related data structures, which are
107    not live beyond their top-level declaration or definition, are
108    allocated.  */
109 struct obstack parser_obstack;
110
111 /* The current statement tree.  */
112
113 static GTY(()) struct stmt_tree_s c_stmt_tree;
114
115 /* State saving variables.  */
116 tree c_break_label;
117 tree c_cont_label;
118
119 /* Linked list of TRANSLATION_UNIT_DECLS for the translation units
120    included in this invocation.  Note that the current translation
121    unit is not included in this list.  */
122
123 static GTY(()) tree all_translation_units;
124
125 /* A list of decls to be made automatically visible in each file scope.  */
126 static GTY(()) tree visible_builtins;
127
128 /* Set to 0 at beginning of a function definition, set to 1 if
129    a return statement that specifies a return value is seen.  */
130
131 int current_function_returns_value;
132
133 /* Set to 0 at beginning of a function definition, set to 1 if
134    a return statement with no argument is seen.  */
135
136 int current_function_returns_null;
137
138 /* Set to 0 at beginning of a function definition, set to 1 if
139    a call to a noreturn function is seen.  */
140
141 int current_function_returns_abnormally;
142
143 /* Set to nonzero by `grokdeclarator' for a function
144    whose return type is defaulted, if warnings for this are desired.  */
145
146 static int warn_about_return_type;
147
148 /* Nonzero when starting a function declared `extern inline'.  */
149
150 static int current_extern_inline;
151
152 /* True means global_bindings_p should return false even if the scope stack
153    says we are in file scope.  */
154 bool c_override_global_bindings_to_false;
155
156 \f
157 /* Each c_binding structure describes one binding of an identifier to
158    a decl.  All the decls in a scope - irrespective of namespace - are
159    chained together by the ->prev field, which (as the name implies)
160    runs in reverse order.  All the decls in a given namespace bound to
161    a given identifier are chained by the ->shadowed field, which runs
162    from inner to outer scopes.
163
164    The ->decl field usually points to a DECL node, but there are two
165    exceptions.  In the namespace of type tags, the bound entity is a
166    RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node.  If an undeclared
167    identifier is encountered, it is bound to error_mark_node to
168    suppress further errors about that identifier in the current
169    function.
170
171    The ->type field stores the type of the declaration in this scope;
172    if NULL, the type is the type of the ->decl field.  This is only of
173    relevance for objects with external or internal linkage which may
174    be redeclared in inner scopes, forming composite types that only
175    persist for the duration of those scopes.  In the external scope,
176    this stores the composite of all the types declared for this
177    object, visible or not.  The ->inner_comp field (used only at file
178    scope) stores whether an incomplete array type at file scope was
179    completed at an inner scope to an array size other than 1.
180
181    The depth field is copied from the scope structure that holds this
182    decl.  It is used to preserve the proper ordering of the ->shadowed
183    field (see bind()) and also for a handful of special-case checks.
184    Finally, the invisible bit is true for a decl which should be
185    ignored for purposes of normal name lookup, and the nested bit is
186    true for a decl that's been bound a second time in an inner scope;
187    in all such cases, the binding in the outer scope will have its
188    invisible bit true.  */
189
190 struct c_binding GTY((chain_next ("%h.prev")))
191 {
192   tree decl;                    /* the decl bound */
193   tree type;                    /* the type in this scope */
194   tree id;                      /* the identifier it's bound to */
195   struct c_binding *prev;       /* the previous decl in this scope */
196   struct c_binding *shadowed;   /* the innermost decl shadowed by this one */
197   unsigned int depth : 28;      /* depth of this scope */
198   BOOL_BITFIELD invisible : 1;  /* normal lookup should ignore this binding */
199   BOOL_BITFIELD nested : 1;     /* do not set DECL_CONTEXT when popping */
200   BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
201   /* one free bit */
202 };
203 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
204 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
205 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
206 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
207
208 #define I_SYMBOL_BINDING(node) \
209   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
210 #define I_SYMBOL_DECL(node) \
211  (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
212
213 #define I_TAG_BINDING(node) \
214   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
215 #define I_TAG_DECL(node) \
216  (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
217
218 #define I_LABEL_BINDING(node) \
219   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
220 #define I_LABEL_DECL(node) \
221  (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
222
223 /* Each C symbol points to three linked lists of c_binding structures.
224    These describe the values of the identifier in the three different
225    namespaces defined by the language.  */
226
227 struct lang_identifier GTY(())
228 {
229   struct c_common_identifier common_id;
230   struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
231   struct c_binding *tag_binding;    /* struct/union/enum tags */
232   struct c_binding *label_binding;  /* labels */
233 };
234
235 /* Validate c-lang.c's assumptions.  */
236 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
237 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
238
239 /* The resulting tree type.  */
240
241 union lang_tree_node
242   GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
243        chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : (union lang_tree_node *) TREE_CHAIN (&%h.generic)")))
244 {
245   union tree_node GTY ((tag ("0"),
246                         desc ("tree_node_structure (&%h)")))
247     generic;
248   struct lang_identifier GTY ((tag ("1"))) identifier;
249 };
250
251 /* Each c_scope structure describes the complete contents of one
252    scope.  Four scopes are distinguished specially: the innermost or
253    current scope, the innermost function scope, the file scope (always
254    the second to outermost) and the outermost or external scope.
255
256    Most declarations are recorded in the current scope.
257
258    All normal label declarations are recorded in the innermost
259    function scope, as are bindings of undeclared identifiers to
260    error_mark_node.  (GCC permits nested functions as an extension,
261    hence the 'innermost' qualifier.)  Explicitly declared labels
262    (using the __label__ extension) appear in the current scope.
263
264    Being in the file scope (current_scope == file_scope) causes
265    special behavior in several places below.  Also, under some
266    conditions the Objective-C front end records declarations in the
267    file scope even though that isn't the current scope.
268
269    All declarations with external linkage are recorded in the external
270    scope, even if they aren't visible there; this models the fact that
271    such declarations are visible to the entire program, and (with a
272    bit of cleverness, see pushdecl) allows diagnosis of some violations
273    of C99 6.2.2p7 and 6.2.7p2:
274
275      If, within the same translation unit, the same identifier appears
276      with both internal and external linkage, the behavior is
277      undefined.
278
279      All declarations that refer to the same object or function shall
280      have compatible type; otherwise, the behavior is undefined.
281
282    Initially only the built-in declarations, which describe compiler
283    intrinsic functions plus a subset of the standard library, are in
284    this scope.
285
286    The order of the blocks list matters, and it is frequently appended
287    to.  To avoid having to walk all the way to the end of the list on
288    each insertion, or reverse the list later, we maintain a pointer to
289    the last list entry.  (FIXME: It should be feasible to use a reversed
290    list here.)
291
292    The bindings list is strictly in reverse order of declarations;
293    pop_scope relies on this.  */
294
295
296 struct c_scope GTY((chain_next ("%h.outer")))
297 {
298   /* The scope containing this one.  */
299   struct c_scope *outer;
300
301   /* The next outermost function scope.  */
302   struct c_scope *outer_function;
303
304   /* All bindings in this scope.  */
305   struct c_binding *bindings;
306
307   /* For each scope (except the global one), a chain of BLOCK nodes
308      for all the scopes that were entered and exited one level down.  */
309   tree blocks;
310   tree blocks_last;
311
312   /* The depth of this scope.  Used to keep the ->shadowed chain of
313      bindings sorted innermost to outermost.  */
314   unsigned int depth : 28;
315
316   /* True if we are currently filling this scope with parameter
317      declarations.  */
318   BOOL_BITFIELD parm_flag : 1;
319
320   /* True if we already complained about forward parameter decls
321      in this scope.  This prevents double warnings on
322      foo (int a; int b; ...)  */
323   BOOL_BITFIELD warned_forward_parm_decls : 1;
324
325   /* True if this is the outermost block scope of a function body.
326      This scope contains the parameters, the local variables declared
327      in the outermost block, and all the labels (except those in
328      nested functions, or declared at block scope with __label__).  */
329   BOOL_BITFIELD function_body : 1;
330
331   /* True means make a BLOCK for this scope no matter what.  */
332   BOOL_BITFIELD keep : 1;
333 };
334
335 /* The scope currently in effect.  */
336
337 static GTY(()) struct c_scope *current_scope;
338
339 /* The innermost function scope.  Ordinary (not explicitly declared)
340    labels, bindings to error_mark_node, and the lazily-created
341    bindings of __func__ and its friends get this scope.  */
342
343 static GTY(()) struct c_scope *current_function_scope;
344
345 /* The C file scope.  This is reset for each input translation unit.  */
346
347 static GTY(()) struct c_scope *file_scope;
348
349 /* The outermost scope.  This is used for all declarations with
350    external linkage, and only these, hence the name.  */
351
352 static GTY(()) struct c_scope *external_scope;
353
354 /* A chain of c_scope structures awaiting reuse.  */
355
356 static GTY((deletable)) struct c_scope *scope_freelist;
357
358 /* A chain of c_binding structures awaiting reuse.  */
359
360 static GTY((deletable)) struct c_binding *binding_freelist;
361
362 /* Append VAR to LIST in scope SCOPE.  */
363 #define SCOPE_LIST_APPEND(scope, list, decl) do {       \
364   struct c_scope *s_ = (scope);                         \
365   tree d_ = (decl);                                     \
366   if (s_->list##_last)                                  \
367     TREE_CHAIN (s_->list##_last) = d_;                  \
368   else                                                  \
369     s_->list = d_;                                      \
370   s_->list##_last = d_;                                 \
371 } while (0)
372
373 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE.  */
374 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {        \
375   struct c_scope *t_ = (tscope);                                \
376   struct c_scope *f_ = (fscope);                                \
377   if (t_->to##_last)                                            \
378     TREE_CHAIN (t_->to##_last) = f_->from;                      \
379   else                                                          \
380     t_->to = f_->from;                                          \
381   t_->to##_last = f_->from##_last;                              \
382 } while (0)
383
384 /* True means unconditionally make a BLOCK for the next scope pushed.  */
385
386 static bool keep_next_level_flag;
387
388 /* True means the next call to push_scope will be the outermost scope
389    of a function body, so do not push a new scope, merely cease
390    expecting parameter decls.  */
391
392 static bool next_is_function_body;
393
394 /* Functions called automatically at the beginning and end of execution.  */
395
396 static GTY(()) tree static_ctors;
397 static GTY(()) tree static_dtors;
398
399 /* Forward declarations.  */
400 static tree lookup_name_in_scope (tree, struct c_scope *);
401 static tree c_make_fname_decl (tree, int);
402 static tree grokdeclarator (const struct c_declarator *,
403                             struct c_declspecs *,
404                             enum decl_context, bool, tree *);
405 static tree grokparms (struct c_arg_info *, bool);
406 static void layout_array_type (tree);
407 \f
408 /* States indicating how grokdeclarator() should handle declspecs marked
409    with __attribute__((deprecated)).  An object declared as
410    __attribute__((deprecated)) suppresses warnings of uses of other
411    deprecated items.  */
412
413 enum deprecated_states {
414   DEPRECATED_NORMAL,
415   DEPRECATED_SUPPRESS
416 };
417
418 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
419
420 void
421 c_print_identifier (FILE *file, tree node, int indent)
422 {
423   print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
424   print_node (file, "tag", I_TAG_DECL (node), indent + 4);
425   print_node (file, "label", I_LABEL_DECL (node), indent + 4);
426   if (C_IS_RESERVED_WORD (node))
427     {
428       tree rid = ridpointers[C_RID_CODE (node)];
429       indent_to (file, indent + 4);
430       fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
431                (void *) rid, IDENTIFIER_POINTER (rid));
432     }
433 }
434
435 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
436    which may be any of several kinds of DECL or TYPE or error_mark_node,
437    in the scope SCOPE.  */
438 static void
439 bind (tree name, tree decl, struct c_scope *scope, bool invisible, bool nested)
440 {
441   struct c_binding *b, **here;
442
443   if (binding_freelist)
444     {
445       b = binding_freelist;
446       binding_freelist = b->prev;
447     }
448   else
449     b = GGC_NEW (struct c_binding);
450
451   b->shadowed = 0;
452   b->decl = decl;
453   b->id = name;
454   b->depth = scope->depth;
455   b->invisible = invisible;
456   b->nested = nested;
457   b->inner_comp = 0;
458
459   b->type = 0;
460
461   b->prev = scope->bindings;
462   scope->bindings = b;
463
464   if (!name)
465     return;
466
467   switch (TREE_CODE (decl))
468     {
469     case LABEL_DECL:     here = &I_LABEL_BINDING (name);   break;
470     case ENUMERAL_TYPE:
471     case UNION_TYPE:
472     case RECORD_TYPE:    here = &I_TAG_BINDING (name);     break;
473     case VAR_DECL:
474     case FUNCTION_DECL:
475     case TYPE_DECL:
476     case CONST_DECL:
477     case PARM_DECL:
478     case ERROR_MARK:     here = &I_SYMBOL_BINDING (name);  break;
479
480     default:
481       gcc_unreachable ();
482     }
483
484   /* Locate the appropriate place in the chain of shadowed decls
485      to insert this binding.  Normally, scope == current_scope and
486      this does nothing.  */
487   while (*here && (*here)->depth > scope->depth)
488     here = &(*here)->shadowed;
489
490   b->shadowed = *here;
491   *here = b;
492 }
493
494 /* Clear the binding structure B, stick it on the binding_freelist,
495    and return the former value of b->prev.  This is used by pop_scope
496    and get_parm_info to iterate destructively over all the bindings
497    from a given scope.  */
498 static struct c_binding *
499 free_binding_and_advance (struct c_binding *b)
500 {
501   struct c_binding *prev = b->prev;
502
503   memset (b, 0, sizeof (struct c_binding));
504   b->prev = binding_freelist;
505   binding_freelist = b;
506
507   return prev;
508 }
509
510 \f
511 /* Hook called at end of compilation to assume 1 elt
512    for a file-scope tentative array defn that wasn't complete before.  */
513
514 void
515 c_finish_incomplete_decl (tree decl)
516 {
517   if (TREE_CODE (decl) == VAR_DECL)
518     {
519       tree type = TREE_TYPE (decl);
520       if (type != error_mark_node
521           && TREE_CODE (type) == ARRAY_TYPE
522           && !DECL_EXTERNAL (decl)
523           && TYPE_DOMAIN (type) == 0)
524         {
525           warning ("%Jarray %qD assumed to have one element", decl, decl);
526
527           complete_array_type (type, NULL_TREE, 1);
528
529           layout_decl (decl, 0);
530         }
531     }
532 }
533 \f
534 /* The Objective-C front-end often needs to determine the current scope.  */
535
536 void *
537 objc_get_current_scope (void)
538 {
539   return current_scope;
540 }
541
542 /* The following function is used only by Objective-C.  It needs to live here
543    because it accesses the innards of c_scope.  */
544
545 void
546 objc_mark_locals_volatile (void *enclosing_blk)
547 {
548   struct c_scope *scope;
549   struct c_binding *b;
550
551   for (scope = current_scope;
552        scope && scope != enclosing_blk;
553        scope = scope->outer)
554     {
555       for (b = scope->bindings; b; b = b->prev)
556         {
557           if (TREE_CODE (b->decl) == VAR_DECL
558               || TREE_CODE (b->decl) == PARM_DECL)
559             {
560               C_DECL_REGISTER (b->decl) = 0;
561               DECL_REGISTER (b->decl) = 0;
562               TREE_THIS_VOLATILE (b->decl) = 1;
563             }
564         }
565
566       /* Do not climb up past the current function.  */
567       if (scope->function_body)
568         break;
569     }
570 }
571
572 /* Nonzero if we are currently in file scope.  */
573
574 int
575 global_bindings_p (void)
576 {
577   return current_scope == file_scope && !c_override_global_bindings_to_false;
578 }
579
580 void
581 keep_next_level (void)
582 {
583   keep_next_level_flag = true;
584 }
585
586 /* Identify this scope as currently being filled with parameters.  */
587
588 void
589 declare_parm_level (void)
590 {
591   current_scope->parm_flag = true;
592 }
593
594 void
595 push_scope (void)
596 {
597   if (next_is_function_body)
598     {
599       /* This is the transition from the parameters to the top level
600          of the function body.  These are the same scope
601          (C99 6.2.1p4,6) so we do not push another scope structure.
602          next_is_function_body is set only by store_parm_decls, which
603          in turn is called when and only when we are about to
604          encounter the opening curly brace for the function body.
605
606          The outermost block of a function always gets a BLOCK node,
607          because the debugging output routines expect that each
608          function has at least one BLOCK.  */
609       current_scope->parm_flag         = false;
610       current_scope->function_body     = true;
611       current_scope->keep              = true;
612       current_scope->outer_function    = current_function_scope;
613       current_function_scope           = current_scope;
614
615       keep_next_level_flag = false;
616       next_is_function_body = false;
617     }
618   else
619     {
620       struct c_scope *scope;
621       if (scope_freelist)
622         {
623           scope = scope_freelist;
624           scope_freelist = scope->outer;
625         }
626       else
627         scope = GGC_CNEW (struct c_scope);
628
629       scope->keep          = keep_next_level_flag;
630       scope->outer         = current_scope;
631       scope->depth         = current_scope ? (current_scope->depth + 1) : 0;
632
633       /* Check for scope depth overflow.  Unlikely (2^28 == 268,435,456) but
634          possible.  */
635       if (current_scope && scope->depth == 0)
636         {
637           scope->depth--;
638           sorry ("GCC supports only %u nested scopes", scope->depth);
639         }
640
641       current_scope        = scope;
642       keep_next_level_flag = false;
643     }
644 }
645
646 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT.  */
647
648 static void
649 set_type_context (tree type, tree context)
650 {
651   for (type = TYPE_MAIN_VARIANT (type); type;
652        type = TYPE_NEXT_VARIANT (type))
653     TYPE_CONTEXT (type) = context;
654 }
655
656 /* Exit a scope.  Restore the state of the identifier-decl mappings
657    that were in effect when this scope was entered.  Return a BLOCK
658    node containing all the DECLs in this scope that are of interest
659    to debug info generation.  */
660
661 tree
662 pop_scope (void)
663 {
664   struct c_scope *scope = current_scope;
665   tree block, context, p;
666   struct c_binding *b;
667
668   bool functionbody = scope->function_body;
669   bool keep = functionbody || scope->keep || scope->bindings;
670
671   /* If appropriate, create a BLOCK to record the decls for the life
672      of this function.  */
673   block = 0;
674   if (keep)
675     {
676       block = make_node (BLOCK);
677       BLOCK_SUBBLOCKS (block) = scope->blocks;
678       TREE_USED (block) = 1;
679
680       /* In each subblock, record that this is its superior.  */
681       for (p = scope->blocks; p; p = TREE_CHAIN (p))
682         BLOCK_SUPERCONTEXT (p) = block;
683
684       BLOCK_VARS (block) = 0;
685     }
686
687   /* The TYPE_CONTEXTs for all of the tagged types belonging to this
688      scope must be set so that they point to the appropriate
689      construct, i.e.  either to the current FUNCTION_DECL node, or
690      else to the BLOCK node we just constructed.
691
692      Note that for tagged types whose scope is just the formal
693      parameter list for some function type specification, we can't
694      properly set their TYPE_CONTEXTs here, because we don't have a
695      pointer to the appropriate FUNCTION_TYPE node readily available
696      to us.  For those cases, the TYPE_CONTEXTs of the relevant tagged
697      type nodes get set in `grokdeclarator' as soon as we have created
698      the FUNCTION_TYPE node which will represent the "scope" for these
699      "parameter list local" tagged types.  */
700   if (scope->function_body)
701     context = current_function_decl;
702   else if (scope == file_scope)
703     {
704       tree file_decl = build_decl (TRANSLATION_UNIT_DECL, 0, 0);
705       TREE_CHAIN (file_decl) = all_translation_units;
706       all_translation_units = file_decl;
707       context = file_decl;
708     }
709   else
710     context = block;
711
712   /* Clear all bindings in this scope.  */
713   for (b = scope->bindings; b; b = free_binding_and_advance (b))
714     {
715       p = b->decl;
716       switch (TREE_CODE (p))
717         {
718         case LABEL_DECL:
719           /* Warnings for unused labels, errors for undefined labels.  */
720           if (TREE_USED (p) && !DECL_INITIAL (p))
721             {
722               error ("%Jlabel %qD used but not defined", p, p);
723               DECL_INITIAL (p) = error_mark_node;
724             }
725           else if (!TREE_USED (p) && warn_unused_label)
726             {
727               if (DECL_INITIAL (p))
728                 warning ("%Jlabel %qD defined but not used", p, p);
729               else
730                 warning ("%Jlabel %qD declared but not defined", p, p);
731             }
732           /* Labels go in BLOCK_VARS.  */
733           TREE_CHAIN (p) = BLOCK_VARS (block);
734           BLOCK_VARS (block) = p;
735           gcc_assert (I_LABEL_BINDING (b->id) == b);
736           I_LABEL_BINDING (b->id) = b->shadowed;
737           break;
738
739         case ENUMERAL_TYPE:
740         case UNION_TYPE:
741         case RECORD_TYPE:
742           set_type_context (p, context);
743
744           /* Types may not have tag-names, in which case the type
745              appears in the bindings list with b->id NULL.  */
746           if (b->id)
747             {
748               gcc_assert (I_TAG_BINDING (b->id) == b);
749               I_TAG_BINDING (b->id) = b->shadowed;
750             }
751           break;
752
753         case FUNCTION_DECL:
754           /* Propagate TREE_ADDRESSABLE from nested functions to their
755              containing functions.  */
756           if (!TREE_ASM_WRITTEN (p)
757               && DECL_INITIAL (p) != 0
758               && TREE_ADDRESSABLE (p)
759               && DECL_ABSTRACT_ORIGIN (p) != 0
760               && DECL_ABSTRACT_ORIGIN (p) != p)
761             TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
762           goto common_symbol;
763
764         case VAR_DECL:
765           /* Warnings for unused variables.  */
766           if (warn_unused_variable
767               && !TREE_USED (p)
768               && !DECL_IN_SYSTEM_HEADER (p)
769               && DECL_NAME (p)
770               && !DECL_ARTIFICIAL (p)
771               && scope != file_scope
772               && scope != external_scope) 
773             warning ("%Junused variable %qD", p, p);
774
775           if (b->inner_comp)
776             {
777               error ("%Jtype of array %qD completed incompatibly with"
778                      " implicit initialization", p, p);
779             }
780
781           /* Fall through.  */
782         case TYPE_DECL:
783         case CONST_DECL:
784         common_symbol:
785           /* All of these go in BLOCK_VARS, but only if this is the
786              binding in the home scope.  */
787           if (!b->nested)
788             {
789               TREE_CHAIN (p) = BLOCK_VARS (block);
790               BLOCK_VARS (block) = p;
791             }
792           /* If this is the file scope, and we are processing more
793              than one translation unit in this compilation, set
794              DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
795              This makes same_translation_unit_p work, and causes
796              static declarations to be given disambiguating suffixes.  */
797           if (scope == file_scope && num_in_fnames > 1)
798             {
799               DECL_CONTEXT (p) = context;
800               if (TREE_CODE (p) == TYPE_DECL)
801                 set_type_context (TREE_TYPE (p), context);
802             }
803
804           /* Fall through.  */
805           /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
806              already been put there by store_parm_decls.  Unused-
807              parameter warnings are handled by function.c.
808              error_mark_node obviously does not go in BLOCK_VARS and
809              does not get unused-variable warnings.  */
810         case PARM_DECL:
811         case ERROR_MARK:
812           /* It is possible for a decl not to have a name.  We get
813              here with b->id NULL in this case.  */
814           if (b->id)
815             {
816               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
817               I_SYMBOL_BINDING (b->id) = b->shadowed;
818               if (b->shadowed && b->shadowed->type)
819                 TREE_TYPE (b->shadowed->decl) = b->shadowed->type;
820             }
821           break;
822
823         default:
824           gcc_unreachable ();
825         }
826     }
827
828
829   /* Dispose of the block that we just made inside some higher level.  */
830   if ((scope->function_body || scope == file_scope) && context)
831     {
832       DECL_INITIAL (context) = block;
833       BLOCK_SUPERCONTEXT (block) = context;
834     }
835   else if (scope->outer)
836     {
837       if (block)
838         SCOPE_LIST_APPEND (scope->outer, blocks, block);
839       /* If we did not make a block for the scope just exited, any
840          blocks made for inner scopes must be carried forward so they
841          will later become subblocks of something else.  */
842       else if (scope->blocks)
843         SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
844     }
845
846   /* Pop the current scope, and free the structure for reuse.  */
847   current_scope = scope->outer;
848   if (scope->function_body)
849     current_function_scope = scope->outer_function;
850
851   memset (scope, 0, sizeof (struct c_scope));
852   scope->outer = scope_freelist;
853   scope_freelist = scope;
854
855   return block;
856 }
857
858 void
859 push_file_scope (void)
860 {
861   tree decl;
862
863   if (file_scope)
864     return;
865
866   push_scope ();
867   file_scope = current_scope;
868
869   start_fname_decls ();
870
871   for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
872     bind (DECL_NAME (decl), decl, file_scope,
873           /*invisible=*/false, /*nested=*/true);
874 }
875
876 void
877 pop_file_scope (void)
878 {
879   /* In case there were missing closebraces, get us back to the global
880      binding level.  */
881   while (current_scope != file_scope)
882     pop_scope ();
883
884   /* __FUNCTION__ is defined at file scope ("").  This
885      call may not be necessary as my tests indicate it
886      still works without it.  */
887   finish_fname_decls ();
888
889   /* This is the point to write out a PCH if we're doing that.
890      In that case we do not want to do anything else.  */
891   if (pch_file)
892     {
893       c_common_write_pch ();
894       return;
895     }
896
897   /* Pop off the file scope and close this translation unit.  */
898   pop_scope ();
899   file_scope = 0;
900   cgraph_finalize_compilation_unit ();
901 }
902
903 /* Insert BLOCK at the end of the list of subblocks of the current
904    scope.  This is used when a BIND_EXPR is expanded, to handle the
905    BLOCK node inside the BIND_EXPR.  */
906
907 void
908 insert_block (tree block)
909 {
910   TREE_USED (block) = 1;
911   SCOPE_LIST_APPEND (current_scope, blocks, block);
912 }
913 \f
914 /* Push a definition or a declaration of struct, union or enum tag "name".
915    "type" should be the type node.
916    We assume that the tag "name" is not already defined.
917
918    Note that the definition may really be just a forward reference.
919    In that case, the TYPE_SIZE will be zero.  */
920
921 static void
922 pushtag (tree name, tree type)
923 {
924   /* Record the identifier as the type's name if it has none.  */
925   if (name && !TYPE_NAME (type))
926     TYPE_NAME (type) = name;
927   bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false);
928
929   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
930      tagged type we just added to the current scope.  This fake
931      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
932      to output a representation of a tagged type, and it also gives
933      us a convenient place to record the "scope start" address for the
934      tagged type.  */
935
936   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
937
938   /* An approximation for now, so we can tell this is a function-scope tag.
939      This will be updated in pop_scope.  */
940   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
941 }
942 \f
943 /* Subroutine of compare_decls.  Allow harmless mismatches in return
944    and argument types provided that the type modes match.  This function
945    return a unified type given a suitable match, and 0 otherwise.  */
946
947 static tree
948 match_builtin_function_types (tree newtype, tree oldtype)
949 {
950   tree newrettype, oldrettype;
951   tree newargs, oldargs;
952   tree trytype, tryargs;
953
954   /* Accept the return type of the new declaration if same modes.  */
955   oldrettype = TREE_TYPE (oldtype);
956   newrettype = TREE_TYPE (newtype);
957
958   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
959     return 0;
960
961   oldargs = TYPE_ARG_TYPES (oldtype);
962   newargs = TYPE_ARG_TYPES (newtype);
963   tryargs = newargs;
964
965   while (oldargs || newargs)
966     {
967       if (!oldargs
968           || !newargs
969           || !TREE_VALUE (oldargs)
970           || !TREE_VALUE (newargs)
971           || TYPE_MODE (TREE_VALUE (oldargs))
972              != TYPE_MODE (TREE_VALUE (newargs)))
973         return 0;
974
975       oldargs = TREE_CHAIN (oldargs);
976       newargs = TREE_CHAIN (newargs);
977     }
978
979   trytype = build_function_type (newrettype, tryargs);
980   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
981 }
982
983 /* Subroutine of diagnose_mismatched_decls.  Check for function type
984    mismatch involving an empty arglist vs a nonempty one and give clearer
985    diagnostics.  */
986 static void
987 diagnose_arglist_conflict (tree newdecl, tree olddecl,
988                            tree newtype, tree oldtype)
989 {
990   tree t;
991
992   if (TREE_CODE (olddecl) != FUNCTION_DECL
993       || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
994       || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
995            ||
996            (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
997     return;
998
999   t = TYPE_ARG_TYPES (oldtype);
1000   if (t == 0)
1001     t = TYPE_ARG_TYPES (newtype);
1002   for (; t; t = TREE_CHAIN (t))
1003     {
1004       tree type = TREE_VALUE (t);
1005
1006       if (TREE_CHAIN (t) == 0
1007           && TYPE_MAIN_VARIANT (type) != void_type_node)
1008         {
1009           inform ("a parameter list with an ellipsis can%'t match "
1010                   "an empty parameter name list declaration");
1011           break;
1012         }
1013
1014       if (c_type_promotes_to (type) != type)
1015         {
1016           inform ("an argument type that has a default promotion can%'t match "
1017                   "an empty parameter name list declaration");
1018           break;
1019         }
1020     }
1021 }
1022
1023 /* Another subroutine of diagnose_mismatched_decls.  OLDDECL is an
1024    old-style function definition, NEWDECL is a prototype declaration.
1025    Diagnose inconsistencies in the argument list.  Returns TRUE if
1026    the prototype is compatible, FALSE if not.  */
1027 static bool
1028 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1029 {
1030   tree newargs, oldargs;
1031   int i;
1032
1033   /* ??? Elsewhere TYPE_MAIN_VARIANT is not used in this context.  */
1034 #define END_OF_ARGLIST(t) (TYPE_MAIN_VARIANT (t) == void_type_node)
1035
1036   oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1037   newargs = TYPE_ARG_TYPES (newtype);
1038   i = 1;
1039
1040   for (;;)
1041     {
1042       tree oldargtype = TREE_VALUE (oldargs);
1043       tree newargtype = TREE_VALUE (newargs);
1044
1045       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1046         break;
1047
1048       /* Reaching the end of just one list means the two decls don't
1049          agree on the number of arguments.  */
1050       if (END_OF_ARGLIST (oldargtype))
1051         {
1052           error ("%Jprototype for %qD declares more arguments "
1053                  "than previous old-style definition", newdecl, newdecl);
1054           return false;
1055         }
1056       else if (END_OF_ARGLIST (newargtype))
1057         {
1058           error ("%Jprototype for %qD declares fewer arguments "
1059                  "than previous old-style definition", newdecl, newdecl);
1060           return false;
1061         }
1062
1063       /* Type for passing arg must be consistent with that declared
1064          for the arg.  */
1065       else if (!comptypes (oldargtype, newargtype))
1066         {
1067           error ("%Jprototype for %qD declares argument %d"
1068                  " with incompatible type",
1069                  newdecl, newdecl, i);
1070           return false;
1071         }
1072
1073       oldargs = TREE_CHAIN (oldargs);
1074       newargs = TREE_CHAIN (newargs);
1075       i++;
1076     }
1077
1078   /* If we get here, no errors were found, but do issue a warning
1079      for this poor-style construct.  */
1080   warning ("%Jprototype for %qD follows non-prototype definition",
1081            newdecl, newdecl);
1082   return true;
1083 #undef END_OF_ARGLIST
1084 }
1085
1086 /* Subroutine of diagnose_mismatched_decls.  Report the location of DECL,
1087    first in a pair of mismatched declarations, using the diagnostic
1088    function DIAG.  */
1089 static void
1090 locate_old_decl (tree decl, void (*diag)(const char *, ...))
1091 {
1092   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1093     ;
1094   else if (DECL_INITIAL (decl))
1095     diag (N_("%Jprevious definition of %qD was here"), decl, decl);
1096   else if (C_DECL_IMPLICIT (decl))
1097     diag (N_("%Jprevious implicit declaration of %qD was here"), decl, decl);
1098   else
1099     diag (N_("%Jprevious declaration of %qD was here"), decl, decl);
1100 }
1101
1102 /* Subroutine of duplicate_decls.  Compare NEWDECL to OLDDECL.
1103    Returns true if the caller should proceed to merge the two, false
1104    if OLDDECL should simply be discarded.  As a side effect, issues
1105    all necessary diagnostics for invalid or poor-style combinations.
1106    If it returns true, writes the types of NEWDECL and OLDDECL to
1107    *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1108    TREE_TYPE (NEWDECL, OLDDECL) respectively.  */
1109
1110 static bool
1111 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1112                            tree *newtypep, tree *oldtypep)
1113 {
1114   tree newtype, oldtype;
1115   bool pedwarned = false;
1116   bool warned = false;
1117
1118   /* If we have error_mark_node for either decl or type, just discard
1119      the previous decl - we're in an error cascade already.  */
1120   if (olddecl == error_mark_node || newdecl == error_mark_node)
1121     return false;
1122   *oldtypep = oldtype = TREE_TYPE (olddecl);
1123   *newtypep = newtype = TREE_TYPE (newdecl);
1124   if (oldtype == error_mark_node || newtype == error_mark_node)
1125     return false;
1126
1127   /* Two different categories of symbol altogether.  This is an error
1128      unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
1129   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1130     {
1131       if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1132             && DECL_BUILT_IN (olddecl)
1133             && !C_DECL_DECLARED_BUILTIN (olddecl)))
1134         {
1135           error ("%J%qD redeclared as different kind of symbol",
1136                  newdecl, newdecl);
1137           locate_old_decl (olddecl, error);
1138         }
1139       else if (TREE_PUBLIC (newdecl))
1140         warning ("%Jbuilt-in function %qD declared as non-function",
1141                  newdecl, newdecl);
1142       else if (warn_shadow)
1143         warning ("%Jdeclaration of %qD shadows a built-in function",
1144                  newdecl, newdecl);
1145       return false;
1146     }
1147
1148   /* Enumerators have no linkage, so may only be declared once in a
1149      given scope.  */
1150   if (TREE_CODE (olddecl) == CONST_DECL)
1151     {
1152       error ("%Jredeclaration of enumerator %qD", newdecl, newdecl);
1153       locate_old_decl (olddecl, error);
1154       return false;
1155     }
1156
1157   if (!comptypes (oldtype, newtype))
1158     {
1159       if (TREE_CODE (olddecl) == FUNCTION_DECL
1160           && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1161         {
1162           /* Accept harmless mismatch in function types.
1163              This is for the ffs and fprintf builtins.  */
1164           tree trytype = match_builtin_function_types (newtype, oldtype);
1165
1166           if (trytype && comptypes (newtype, trytype))
1167             *oldtypep = oldtype = trytype;
1168           else
1169             {
1170               /* If types don't match for a built-in, throw away the
1171                  built-in.  No point in calling locate_old_decl here, it
1172                  won't print anything.  */
1173               warning ("%Jconflicting types for built-in function %qD",
1174                        newdecl, newdecl);
1175               return false;
1176             }
1177         }
1178       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1179                && DECL_IS_BUILTIN (olddecl))
1180         {
1181           /* A conflicting function declaration for a predeclared
1182              function that isn't actually built in.  Objective C uses
1183              these.  The new declaration silently overrides everything
1184              but the volatility (i.e. noreturn) indication.  See also
1185              below.  FIXME: Make Objective C use normal builtins.  */
1186           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1187           return false;
1188         }
1189       /* Permit void foo (...) to match int foo (...) if the latter is
1190          the definition and implicit int was used.  See
1191          c-torture/compile/920625-2.c.  */
1192       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1193                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1194                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1195                && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1196         {
1197           pedwarn ("%Jconflicting types for %qD", newdecl, newdecl);
1198           /* Make sure we keep void as the return type.  */
1199           TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1200           C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1201           pedwarned = true;
1202         }
1203       /* Permit void foo (...) to match an earlier call to foo (...) with
1204          no declared type (thus, implicitly int).  */
1205       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1206                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1207                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1208                && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1209         {
1210           pedwarn ("%Jconflicting types for %qD", newdecl, newdecl);
1211           /* Make sure we keep void as the return type.  */
1212           TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1213           pedwarned = true;
1214         }
1215       else
1216         {
1217           if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
1218             error ("%J conflicting type qualifiers for %qD", newdecl, newdecl);
1219           else
1220             error ("%Jconflicting types for %qD", newdecl, newdecl);
1221           diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1222           locate_old_decl (olddecl, error);
1223           return false;
1224         }
1225     }
1226
1227   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1228      but silently ignore the redeclaration if either is in a system
1229      header.  (Conflicting redeclarations were handled above.)  */
1230   if (TREE_CODE (newdecl) == TYPE_DECL)
1231     {
1232       if (DECL_IN_SYSTEM_HEADER (newdecl) || DECL_IN_SYSTEM_HEADER (olddecl))
1233         return true;  /* Allow OLDDECL to continue in use.  */
1234
1235       error ("%Jredefinition of typedef %qD", newdecl, newdecl);
1236       locate_old_decl (olddecl, error);
1237       return false;
1238     }
1239
1240   /* Function declarations can either be 'static' or 'extern' (no
1241      qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1242      can never conflict with each other on account of linkage (6.2.2p4).
1243      Multiple definitions are not allowed (6.9p3,5) but GCC permits
1244      two definitions if one is 'extern inline' and one is not.  The non-
1245      extern-inline definition supersedes the extern-inline definition.  */
1246   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1247     {
1248       /* If you declare a built-in function name as static, or
1249          define the built-in with an old-style definition (so we
1250          can't validate the argument list) the built-in definition is
1251          overridden, but optionally warn this was a bad choice of name.  */
1252       if (DECL_BUILT_IN (olddecl)
1253           && !C_DECL_DECLARED_BUILTIN (olddecl)
1254           && (!TREE_PUBLIC (newdecl)
1255               || (DECL_INITIAL (newdecl)
1256                   && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1257         {
1258           if (warn_shadow)
1259             warning ("%Jdeclaration of %qD shadows a built-in function",
1260                      newdecl, newdecl);
1261           /* Discard the old built-in function.  */
1262           return false;
1263         }
1264
1265       if (DECL_INITIAL (newdecl))
1266         {
1267           if (DECL_INITIAL (olddecl)
1268               && !(DECL_DECLARED_INLINE_P (olddecl)
1269                    && DECL_EXTERNAL (olddecl)
1270                    && !(DECL_DECLARED_INLINE_P (newdecl)
1271                         && DECL_EXTERNAL (newdecl)
1272                         && same_translation_unit_p (olddecl, newdecl))))
1273             {
1274               error ("%Jredefinition of %qD", newdecl, newdecl);
1275               locate_old_decl (olddecl, error);
1276               return false;
1277             }
1278         }
1279       /* If we have a prototype after an old-style function definition,
1280          the argument types must be checked specially.  */
1281       else if (DECL_INITIAL (olddecl)
1282                && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1283                && TYPE_ACTUAL_ARG_TYPES (oldtype)
1284                && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1285         {
1286           locate_old_decl (olddecl, error);
1287           return false;
1288         }
1289       /* A non-static declaration (even an "extern") followed by a
1290          static declaration is undefined behavior per C99 6.2.2p3-5,7.
1291          The same is true for a static forward declaration at block
1292          scope followed by a non-static declaration/definition at file
1293          scope.  Static followed by non-static at the same scope is
1294          not undefined behavior, and is the most convenient way to get
1295          some effects (see e.g.  what unwind-dw2-fde-glibc.c does to
1296          the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1297          we do diagnose it if -Wtraditional.  */
1298       if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1299         {
1300           /* Two exceptions to the rule.  If olddecl is an extern
1301              inline, or a predeclared function that isn't actually
1302              built in, newdecl silently overrides olddecl.  The latter
1303              occur only in Objective C; see also above.  (FIXME: Make
1304              Objective C use normal builtins.)  */
1305           if (!DECL_IS_BUILTIN (olddecl)
1306               && !(DECL_EXTERNAL (olddecl)
1307                    && DECL_DECLARED_INLINE_P (olddecl)))
1308             {
1309               error ("%Jstatic declaration of %qD follows "
1310                      "non-static declaration", newdecl, newdecl);
1311               locate_old_decl (olddecl, error);
1312             }
1313           return false;
1314         }
1315       else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1316         {
1317           if (DECL_CONTEXT (olddecl))
1318             {
1319               error ("%Jnon-static declaration of %qD follows "
1320                      "static declaration", newdecl, newdecl);
1321               locate_old_decl (olddecl, error);
1322               return false;
1323             }
1324           else if (warn_traditional)
1325             {
1326               warning ("%Jnon-static declaration of %qD follows "
1327                        "static declaration", newdecl, newdecl);
1328               warned = true;
1329             }
1330         }
1331     }
1332   else if (TREE_CODE (newdecl) == VAR_DECL)
1333     {
1334       /* Only variables can be thread-local, and all declarations must
1335          agree on this property.  */
1336       if (DECL_THREAD_LOCAL (newdecl) != DECL_THREAD_LOCAL (olddecl))
1337         {
1338           if (DECL_THREAD_LOCAL (newdecl))
1339             error ("%Jthread-local declaration of %qD follows "
1340                    "non-thread-local declaration", newdecl, newdecl);
1341           else
1342             error ("%Jnon-thread-local declaration of %qD follows "
1343                    "thread-local declaration", newdecl, newdecl);
1344
1345           locate_old_decl (olddecl, error);
1346           return false;
1347         }
1348
1349       /* Multiple initialized definitions are not allowed (6.9p3,5).  */
1350       if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1351         {
1352           error ("%Jredefinition of %qD", newdecl, newdecl);
1353           locate_old_decl (olddecl, error);
1354           return false;
1355         }
1356
1357       /* Objects declared at file scope: if the first declaration had
1358          external linkage (even if it was an external reference) the
1359          second must have external linkage as well, or the behavior is
1360          undefined.  If the first declaration had internal linkage, then
1361          the second must too, or else be an external reference (in which
1362          case the composite declaration still has internal linkage).
1363          As for function declarations, we warn about the static-then-
1364          extern case only for -Wtraditional.  See generally 6.2.2p3-5,7.  */
1365       if (DECL_FILE_SCOPE_P (newdecl)
1366           && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1367         {
1368           if (DECL_EXTERNAL (newdecl))
1369             {
1370               if (!DECL_FILE_SCOPE_P (olddecl))
1371                 {
1372                   error ("%Jextern declaration of %qD follows "
1373                          "declaration with no linkage", newdecl, newdecl);
1374                   locate_old_decl (olddecl, error);
1375                   return false;
1376                 }
1377               else if (warn_traditional)
1378                 {
1379                   warning ("%Jnon-static declaration of %qD follows "
1380                            "static declaration", newdecl, newdecl);
1381                   warned = true;
1382                 }
1383             }
1384           else
1385             {
1386               if (TREE_PUBLIC (newdecl))
1387                 error ("%Jnon-static declaration of %qD follows "
1388                        "static declaration", newdecl, newdecl);
1389               else
1390                 error ("%Jstatic declaration of %qD follows "
1391                        "non-static declaration", newdecl, newdecl);
1392
1393               locate_old_decl (olddecl, error);
1394               return false;
1395             }
1396         }
1397       /* Two objects with the same name declared at the same block
1398          scope must both be external references (6.7p3).  */
1399       else if (!DECL_FILE_SCOPE_P (newdecl))
1400         {
1401           if (DECL_EXTERNAL (newdecl))
1402             {
1403               /* Extern with initializer at block scope, which will
1404                  already have received an error.  */
1405             }
1406           else if (DECL_EXTERNAL (olddecl))
1407             {
1408               error ("%Jdeclaration of %qD with no linkage follows "
1409                      "extern declaration", newdecl, newdecl);
1410               locate_old_decl (olddecl, error);
1411             }
1412           else
1413             {
1414               error ("%Jredeclaration of %qD with no linkage",
1415                      newdecl, newdecl);
1416               locate_old_decl (olddecl, error);
1417             }
1418
1419           return false;
1420         }
1421     }
1422
1423   /* warnings */
1424   /* All decls must agree on a visibility.  */
1425   if (DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
1426       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1427     {
1428       warning ("%Jredeclaration of %qD with different visibility "
1429                "(old visibility preserved)", newdecl, newdecl);
1430       warned = true;
1431     }
1432
1433   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1434     {
1435       /* Diagnose inline __attribute__ ((noinline)) which is silly.  */
1436       if (DECL_DECLARED_INLINE_P (newdecl)
1437           && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1438         {
1439           warning ("%Jinline declaration of %qD follows "
1440                    "declaration with attribute noinline", newdecl, newdecl);
1441           warned = true;
1442         }
1443       else if (DECL_DECLARED_INLINE_P (olddecl)
1444                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1445         {
1446           warning ("%Jdeclaration of %qD with attribute noinline follows "
1447                    "inline declaration ", newdecl, newdecl);
1448           warned = true;
1449         }
1450
1451       /* Inline declaration after use or definition.
1452          ??? Should we still warn about this now we have unit-at-a-time
1453          mode and can get it right?
1454          Definitely don't complain if the decls are in different translation
1455          units.  */
1456       if (DECL_DECLARED_INLINE_P (newdecl) && !DECL_DECLARED_INLINE_P (olddecl)
1457           && same_translation_unit_p (olddecl, newdecl))
1458         {
1459           if (TREE_USED (olddecl))
1460             {
1461               warning ("%J%qD declared inline after being called",
1462                        olddecl, olddecl);
1463               warned = true;
1464             }
1465           else if (DECL_INITIAL (olddecl))
1466             {
1467               warning ("%J%qD declared inline after its definition",
1468                        olddecl, olddecl);
1469               warned = true;
1470             }
1471         }
1472     }
1473   else /* PARM_DECL, VAR_DECL */
1474     {
1475       /* Redeclaration of a parameter is a constraint violation (this is
1476          not explicitly stated, but follows from C99 6.7p3 [no more than
1477          one declaration of the same identifier with no linkage in the
1478          same scope, except type tags] and 6.2.2p6 [parameters have no
1479          linkage]).  We must check for a forward parameter declaration,
1480          indicated by TREE_ASM_WRITTEN on the old declaration - this is
1481          an extension, the mandatory diagnostic for which is handled by
1482          mark_forward_parm_decls.  */
1483
1484       if (TREE_CODE (newdecl) == PARM_DECL
1485           && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
1486         {
1487           error ("%Jredefinition of parameter %qD", newdecl, newdecl);
1488           locate_old_decl (olddecl, error);
1489           return false;
1490         }
1491     }
1492
1493   /* Optional warning for completely redundant decls.  */
1494   if (!warned && !pedwarned
1495       && warn_redundant_decls
1496       /* Don't warn about a function declaration followed by a
1497          definition.  */
1498       && !(TREE_CODE (newdecl) == FUNCTION_DECL
1499            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
1500       /* Don't warn about redundant redeclarations of builtins.  */
1501       && !(TREE_CODE (newdecl) == FUNCTION_DECL
1502            && !DECL_BUILT_IN (newdecl)
1503            && DECL_BUILT_IN (olddecl)
1504            && !C_DECL_DECLARED_BUILTIN (olddecl))
1505       /* Don't warn about an extern followed by a definition.  */
1506       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
1507       /* Don't warn about forward parameter decls.  */
1508       && !(TREE_CODE (newdecl) == PARM_DECL
1509            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)))
1510     {
1511       warning ("%Jredundant redeclaration of %qD", newdecl, newdecl);
1512       warned = true;
1513     }
1514
1515   /* Report location of previous decl/defn in a consistent manner.  */
1516   if (warned || pedwarned)
1517     locate_old_decl (olddecl, pedwarned ? pedwarn : warning);
1518
1519   return true;
1520 }
1521
1522 /* Subroutine of duplicate_decls.  NEWDECL has been found to be
1523    consistent with OLDDECL, but carries new information.  Merge the
1524    new information into OLDDECL.  This function issues no
1525    diagnostics.  */
1526
1527 static void
1528 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
1529 {
1530   int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1531                            && DECL_INITIAL (newdecl) != 0);
1532
1533   /* For real parm decl following a forward decl, rechain the old decl
1534      in its new location and clear TREE_ASM_WRITTEN (it's not a
1535      forward decl anymore).  */
1536   if (TREE_CODE (newdecl) == PARM_DECL
1537       && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1538     {
1539       struct c_binding *b, **here;
1540
1541       for (here = &current_scope->bindings; *here; here = &(*here)->prev)
1542         if ((*here)->decl == olddecl)
1543           goto found;
1544       gcc_unreachable ();
1545
1546     found:
1547       b = *here;
1548       *here = b->prev;
1549       b->prev = current_scope->bindings;
1550       current_scope->bindings = b;
1551
1552       TREE_ASM_WRITTEN (olddecl) = 0;
1553     }
1554
1555   DECL_ATTRIBUTES (newdecl)
1556     = targetm.merge_decl_attributes (olddecl, newdecl);
1557
1558   /* Merge the data types specified in the two decls.  */
1559   TREE_TYPE (newdecl)
1560     = TREE_TYPE (olddecl)
1561     = composite_type (newtype, oldtype);
1562
1563   /* Lay the type out, unless already done.  */
1564   if (!comptypes (oldtype, TREE_TYPE (newdecl)))
1565     {
1566       if (TREE_TYPE (newdecl) != error_mark_node)
1567         layout_type (TREE_TYPE (newdecl));
1568       if (TREE_CODE (newdecl) != FUNCTION_DECL
1569           && TREE_CODE (newdecl) != TYPE_DECL
1570           && TREE_CODE (newdecl) != CONST_DECL)
1571         layout_decl (newdecl, 0);
1572     }
1573   else
1574     {
1575       /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
1576       DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1577       DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1578       DECL_MODE (newdecl) = DECL_MODE (olddecl);
1579       if (TREE_CODE (olddecl) != FUNCTION_DECL)
1580         if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1581           {
1582             DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1583             DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1584           }
1585     }
1586
1587   /* Keep the old rtl since we can safely use it.  */
1588   COPY_DECL_RTL (olddecl, newdecl);
1589
1590   /* Merge the type qualifiers.  */
1591   if (TREE_READONLY (newdecl))
1592     TREE_READONLY (olddecl) = 1;
1593
1594   if (TREE_THIS_VOLATILE (newdecl))
1595     {
1596       TREE_THIS_VOLATILE (olddecl) = 1;
1597       if (TREE_CODE (newdecl) == VAR_DECL)
1598         make_var_volatile (newdecl);
1599     }
1600
1601   /* Merge deprecatedness.  */
1602   if (TREE_DEPRECATED (newdecl))
1603     TREE_DEPRECATED (olddecl) = 1;
1604
1605   /* Keep source location of definition rather than declaration.  */
1606   if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
1607     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1608
1609   /* Merge the unused-warning information.  */
1610   if (DECL_IN_SYSTEM_HEADER (olddecl))
1611     DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1612   else if (DECL_IN_SYSTEM_HEADER (newdecl))
1613     DECL_IN_SYSTEM_HEADER (olddecl) = 1;
1614
1615   /* Merge the initialization information.  */
1616    if (DECL_INITIAL (newdecl) == 0)
1617     DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1618
1619   /* Merge the section attribute.
1620      We want to issue an error if the sections conflict but that must be
1621      done later in decl_attributes since we are called before attributes
1622      are assigned.  */
1623   if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1624     DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1625
1626   /* Copy the assembler name.
1627      Currently, it can only be defined in the prototype.  */
1628   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1629
1630   /* Use visibility of whichever declaration had it specified */
1631   if (DECL_VISIBILITY_SPECIFIED (olddecl))
1632     {
1633       DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1634       DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1635     }
1636
1637   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1638     {
1639       DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1640       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1641       DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1642       DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1643         |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1644       TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1645       TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1646       DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1647       DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1648     }
1649
1650   /* Merge the storage class information.  */
1651   merge_weak (newdecl, olddecl);
1652
1653   /* For functions, static overrides non-static.  */
1654   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1655     {
1656       TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1657       /* This is since we don't automatically
1658          copy the attributes of NEWDECL into OLDDECL.  */
1659       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1660       /* If this clears `static', clear it in the identifier too.  */
1661       if (!TREE_PUBLIC (olddecl))
1662         TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1663     }
1664   if (DECL_EXTERNAL (newdecl))
1665     {
1666       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1667       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1668
1669       /* An extern decl does not override previous storage class.  */
1670       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1671       if (!DECL_EXTERNAL (newdecl))
1672         {
1673           DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1674           DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1675         }
1676     }
1677   else
1678     {
1679       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1680       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1681     }
1682
1683   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1684     {
1685       /* If we're redefining a function previously defined as extern
1686          inline, make sure we emit debug info for the inline before we
1687          throw it away, in case it was inlined into a function that hasn't
1688          been written out yet.  */
1689       if (new_is_definition && DECL_INITIAL (olddecl))
1690         {
1691           if (TREE_USED (olddecl)
1692               /* In unit-at-a-time mode we never inline re-defined extern
1693                  inline functions.  */
1694               && !flag_unit_at_a_time
1695               && cgraph_function_possibly_inlined_p (olddecl))
1696             (*debug_hooks->outlining_inline_function) (olddecl);
1697
1698           /* The new defn must not be inline.  */
1699           DECL_INLINE (newdecl) = 0;
1700           DECL_UNINLINABLE (newdecl) = 1;
1701         }
1702       else
1703         {
1704           /* If either decl says `inline', this fn is inline,
1705              unless its definition was passed already.  */
1706           if (DECL_DECLARED_INLINE_P (newdecl)
1707               || DECL_DECLARED_INLINE_P (olddecl))
1708             DECL_DECLARED_INLINE_P (newdecl) = 1;
1709
1710           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1711             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1712         }
1713
1714       if (DECL_BUILT_IN (olddecl))
1715         {
1716           /* If redeclaring a builtin function, it stays built in.
1717              But it gets tagged as having been declared.  */
1718           DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1719           DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1720           C_DECL_DECLARED_BUILTIN (newdecl) = 1;
1721         }
1722
1723       /* Also preserve various other info from the definition.  */
1724       if (!new_is_definition)
1725         {
1726           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1727           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1728           DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1729           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1730           DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1731
1732           /* Set DECL_INLINE on the declaration if we've got a body
1733              from which to instantiate.  */
1734           if (DECL_INLINE (olddecl) && !DECL_UNINLINABLE (newdecl))
1735             {
1736               DECL_INLINE (newdecl) = 1;
1737               DECL_ABSTRACT_ORIGIN (newdecl)
1738                 = DECL_ABSTRACT_ORIGIN (olddecl);
1739             }
1740         }
1741       else
1742         {
1743           /* If a previous declaration said inline, mark the
1744              definition as inlinable.  */
1745           if (DECL_DECLARED_INLINE_P (newdecl)
1746               && !DECL_UNINLINABLE (newdecl))
1747             DECL_INLINE (newdecl) = 1;
1748         }
1749     }
1750
1751   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1752      But preserve OLDDECL's DECL_UID and DECL_CONTEXT.  */
1753   {
1754     unsigned olddecl_uid = DECL_UID (olddecl);
1755     tree olddecl_context = DECL_CONTEXT (olddecl);
1756
1757     memcpy ((char *) olddecl + sizeof (struct tree_common),
1758             (char *) newdecl + sizeof (struct tree_common),
1759             sizeof (struct tree_decl) - sizeof (struct tree_common));
1760     DECL_UID (olddecl) = olddecl_uid;
1761     DECL_CONTEXT (olddecl) = olddecl_context;
1762   }
1763
1764   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1765      so that encode_section_info has a chance to look at the new decl
1766      flags and attributes.  */
1767   if (DECL_RTL_SET_P (olddecl)
1768       && (TREE_CODE (olddecl) == FUNCTION_DECL
1769           || (TREE_CODE (olddecl) == VAR_DECL
1770               && TREE_STATIC (olddecl))))
1771     make_decl_rtl (olddecl);
1772 }
1773
1774 /* Handle when a new declaration NEWDECL has the same name as an old
1775    one OLDDECL in the same binding contour.  Prints an error message
1776    if appropriate.
1777
1778    If safely possible, alter OLDDECL to look like NEWDECL, and return
1779    true.  Otherwise, return false.  */
1780
1781 static bool
1782 duplicate_decls (tree newdecl, tree olddecl)
1783 {
1784   tree newtype = NULL, oldtype = NULL;
1785
1786   if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
1787     return false;
1788
1789   merge_decls (newdecl, olddecl, newtype, oldtype);
1790   return true;
1791 }
1792
1793 \f
1794 /* Check whether decl-node NEW_DECL shadows an existing declaration.  */
1795 static void
1796 warn_if_shadowing (tree new_decl)
1797 {
1798   struct c_binding *b;
1799
1800   /* Shadow warnings wanted?  */
1801   if (!warn_shadow
1802       /* No shadow warnings for internally generated vars.  */
1803       || DECL_IS_BUILTIN (new_decl)
1804       /* No shadow warnings for vars made for inlining.  */
1805       || DECL_FROM_INLINE (new_decl)
1806       /* Don't warn about the parm names in function declarator
1807          within a function declarator.  It would be nice to avoid
1808          warning in any function declarator in a declaration, as
1809          opposed to a definition, but there is no way to tell
1810          it's not a definition at this point.  */
1811       || (TREE_CODE (new_decl) == PARM_DECL && current_scope->outer->parm_flag))
1812     return;
1813
1814   /* Is anything being shadowed?  Invisible decls do not count.  */
1815   for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
1816     if (b->decl && b->decl != new_decl && !b->invisible)
1817       {
1818         tree old_decl = b->decl;
1819
1820         if (TREE_CODE (old_decl) == PARM_DECL)
1821           warning ("%Jdeclaration of %qD shadows a parameter",
1822                    new_decl, new_decl);
1823         else if (DECL_FILE_SCOPE_P (old_decl))
1824           warning ("%Jdeclaration of %qD shadows a global declaration",
1825                    new_decl, new_decl);
1826         else if (TREE_CODE (old_decl) == FUNCTION_DECL
1827                  && DECL_BUILT_IN (old_decl))
1828           warning ("%Jdeclaration of %qD shadows a built-in function",
1829                    new_decl, new_decl);
1830         else
1831           warning ("%Jdeclaration of %qD shadows a previous local",
1832                    new_decl, new_decl);
1833
1834         if (TREE_CODE (old_decl) != FUNCTION_DECL
1835             || !DECL_BUILT_IN (old_decl))
1836           warning ("%Jshadowed declaration is here", old_decl);
1837
1838         break;
1839       }
1840 }
1841
1842
1843 /* Subroutine of pushdecl.
1844
1845    X is a TYPE_DECL for a typedef statement.  Create a brand new
1846    ..._TYPE node (which will be just a variant of the existing
1847    ..._TYPE node with identical properties) and then install X
1848    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1849
1850    The whole point here is to end up with a situation where each
1851    and every ..._TYPE node the compiler creates will be uniquely
1852    associated with AT MOST one node representing a typedef name.
1853    This way, even though the compiler substitutes corresponding
1854    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1855    early on, later parts of the compiler can always do the reverse
1856    translation and get back the corresponding typedef name.  For
1857    example, given:
1858
1859         typedef struct S MY_TYPE;
1860         MY_TYPE object;
1861
1862    Later parts of the compiler might only know that `object' was of
1863    type `struct S' if it were not for code just below.  With this
1864    code however, later parts of the compiler see something like:
1865
1866         struct S' == struct S
1867         typedef struct S' MY_TYPE;
1868         struct S' object;
1869
1870     And they can then deduce (from the node for type struct S') that
1871     the original object declaration was:
1872
1873                 MY_TYPE object;
1874
1875     Being able to do this is important for proper support of protoize,
1876     and also for generating precise symbolic debugging information
1877     which takes full account of the programmer's (typedef) vocabulary.
1878
1879     Obviously, we don't want to generate a duplicate ..._TYPE node if
1880     the TYPE_DECL node that we are now processing really represents a
1881     standard built-in type.
1882
1883     Since all standard types are effectively declared at line zero
1884     in the source file, we can easily check to see if we are working
1885     on a standard type by checking the current value of lineno.  */
1886
1887 static void
1888 clone_underlying_type (tree x)
1889 {
1890   if (DECL_IS_BUILTIN (x))
1891     {
1892       if (TYPE_NAME (TREE_TYPE (x)) == 0)
1893         TYPE_NAME (TREE_TYPE (x)) = x;
1894     }
1895   else if (TREE_TYPE (x) != error_mark_node
1896            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
1897     {
1898       tree tt = TREE_TYPE (x);
1899       DECL_ORIGINAL_TYPE (x) = tt;
1900       tt = build_variant_type_copy (tt);
1901       TYPE_NAME (tt) = x;
1902       TREE_USED (tt) = TREE_USED (x);
1903       TREE_TYPE (x) = tt;
1904     }
1905 }
1906
1907 /* Record a decl-node X as belonging to the current lexical scope.
1908    Check for errors (such as an incompatible declaration for the same
1909    name already seen in the same scope).
1910
1911    Returns either X or an old decl for the same name.
1912    If an old decl is returned, it may have been smashed
1913    to agree with what X says.  */
1914
1915 tree
1916 pushdecl (tree x)
1917 {
1918   tree name = DECL_NAME (x);
1919   struct c_scope *scope = current_scope;
1920   struct c_binding *b;
1921   bool nested = false;
1922
1923   /* Functions need the lang_decl data.  */
1924   if (TREE_CODE (x) == FUNCTION_DECL && !DECL_LANG_SPECIFIC (x))
1925     DECL_LANG_SPECIFIC (x) = GGC_CNEW (struct lang_decl);
1926
1927   /* Must set DECL_CONTEXT for everything not at file scope or
1928      DECL_FILE_SCOPE_P won't work.  Local externs don't count
1929      unless they have initializers (which generate code).  */
1930   if (current_function_decl
1931       && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
1932           || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
1933     DECL_CONTEXT (x) = current_function_decl;
1934
1935   /* Anonymous decls are just inserted in the scope.  */
1936   if (!name)
1937     {
1938       bind (name, x, scope, /*invisible=*/false, /*nested=*/false);
1939       return x;
1940     }
1941
1942   /* First, see if there is another declaration with the same name in
1943      the current scope.  If there is, duplicate_decls may do all the
1944      work for us.  If duplicate_decls returns false, that indicates
1945      two incompatible decls in the same scope; we are to silently
1946      replace the old one (duplicate_decls has issued all appropriate
1947      diagnostics).  In particular, we should not consider possible
1948      duplicates in the external scope, or shadowing.  */
1949   b = I_SYMBOL_BINDING (name);
1950   if (b && B_IN_SCOPE (b, scope))
1951     {
1952       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
1953           && COMPLETE_TYPE_P (TREE_TYPE (x)))
1954         b->inner_comp = false;
1955       if (duplicate_decls (x, b->decl))
1956         return b->decl;
1957       else
1958         goto skip_external_and_shadow_checks;
1959     }
1960
1961   /* All declarations with external linkage, and all external
1962      references, go in the external scope, no matter what scope is
1963      current.  However, the binding in that scope is ignored for
1964      purposes of normal name lookup.  A separate binding structure is
1965      created in the requested scope; this governs the normal
1966      visibility of the symbol.
1967
1968      The binding in the externals scope is used exclusively for
1969      detecting duplicate declarations of the same object, no matter
1970      what scope they are in; this is what we do here.  (C99 6.2.7p2:
1971      All declarations that refer to the same object or function shall
1972      have compatible type; otherwise, the behavior is undefined.)  */
1973   if (DECL_EXTERNAL (x) || scope == file_scope)
1974     {
1975       tree type = TREE_TYPE (x);
1976       tree vistype = 0;
1977       tree visdecl = 0;
1978       bool type_saved = false;
1979       if (b && !B_IN_EXTERNAL_SCOPE (b)
1980           && (TREE_CODE (b->decl) == FUNCTION_DECL
1981               || TREE_CODE (b->decl) == VAR_DECL)
1982           && DECL_FILE_SCOPE_P (b->decl))
1983         {
1984           visdecl = b->decl;
1985           vistype = TREE_TYPE (visdecl);
1986         }
1987       if (warn_nested_externs
1988           && scope != file_scope
1989           && !DECL_IN_SYSTEM_HEADER (x))
1990         warning ("nested extern declaration of %qD", x);
1991
1992       while (b && !B_IN_EXTERNAL_SCOPE (b))
1993         {
1994           /* If this decl might be modified, save its type.  This is
1995              done here rather than when the decl is first bound
1996              because the type may change after first binding, through
1997              being completed or through attributes being added.  If we
1998              encounter multiple such decls, only the first should have
1999              its type saved; the others will already have had their
2000              proper types saved and the types will not have changed as
2001              their scopes will not have been re-entered.  */
2002           if (DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2003             {
2004               b->type = TREE_TYPE (b->decl);
2005               type_saved = true;
2006             }
2007           if (B_IN_FILE_SCOPE (b)
2008               && TREE_CODE (b->decl) == VAR_DECL
2009               && TREE_STATIC (b->decl)
2010               && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2011               && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2012               && TREE_CODE (type) == ARRAY_TYPE
2013               && TYPE_DOMAIN (type)
2014               && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2015               && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2016             {
2017               /* Array type completed in inner scope, which should be
2018                  diagnosed if the completion does not have size 1 and
2019                  it does not get completed in the file scope.  */
2020               b->inner_comp = true;
2021             }
2022           b = b->shadowed;
2023         }
2024
2025       /* If a matching external declaration has been found, set its
2026          type to the composite of all the types of that declaration.
2027          After the consistency checks, it will be reset to the
2028          composite of the visible types only.  */
2029       if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2030           && b->type)
2031         TREE_TYPE (b->decl) = b->type;
2032
2033       /* The point of the same_translation_unit_p check here is,
2034          we want to detect a duplicate decl for a construct like
2035          foo() { extern bar(); } ... static bar();  but not if
2036          they are in different translation units.  In any case,
2037          the static does not go in the externals scope.  */
2038       if (b
2039           && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2040           && duplicate_decls (x, b->decl))
2041         {
2042           tree thistype;
2043           thistype = (vistype ? composite_type (vistype, type) : type);
2044           b->type = TREE_TYPE (b->decl);
2045           if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2046             thistype
2047               = build_type_attribute_variant (thistype,
2048                                               TYPE_ATTRIBUTES (b->type));
2049           TREE_TYPE (b->decl) = thistype;
2050           bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true);
2051           return b->decl;
2052         }
2053       else if (TREE_PUBLIC (x))
2054         {
2055           if (visdecl && !b && duplicate_decls (x, visdecl))
2056             {
2057               /* An external declaration at block scope referring to a
2058                  visible entity with internal linkage.  The composite
2059                  type will already be correct for this scope, so we
2060                  just need to fall through to make the declaration in
2061                  this scope.  */
2062               nested = true;
2063               x = visdecl;
2064             }
2065           else
2066             {
2067               bind (name, x, external_scope, /*invisible=*/true,
2068                     /*nested=*/false);
2069               nested = true;
2070             }
2071         }
2072     }
2073
2074   warn_if_shadowing (x);
2075
2076  skip_external_and_shadow_checks:
2077   if (TREE_CODE (x) == TYPE_DECL)
2078     clone_underlying_type (x);
2079
2080   bind (name, x, scope, /*invisible=*/false, nested);
2081
2082   /* If x's type is incomplete because it's based on a
2083      structure or union which has not yet been fully declared,
2084      attach it to that structure or union type, so we can go
2085      back and complete the variable declaration later, if the
2086      structure or union gets fully declared.
2087
2088      If the input is erroneous, we can have error_mark in the type
2089      slot (e.g. "f(void a, ...)") - that doesn't count as an
2090      incomplete type.  */
2091   if (TREE_TYPE (x) != error_mark_node
2092       && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2093     {
2094       tree element = TREE_TYPE (x);
2095
2096       while (TREE_CODE (element) == ARRAY_TYPE)
2097         element = TREE_TYPE (element);
2098       element = TYPE_MAIN_VARIANT (element);
2099
2100       if ((TREE_CODE (element) == RECORD_TYPE
2101            || TREE_CODE (element) == UNION_TYPE)
2102           && (TREE_CODE (x) != TYPE_DECL
2103               || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2104           && !COMPLETE_TYPE_P (element))
2105         C_TYPE_INCOMPLETE_VARS (element)
2106           = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2107     }
2108   return x;
2109 }
2110
2111 /* Record X as belonging to file scope.
2112    This is used only internally by the Objective-C front end,
2113    and is limited to its needs.  duplicate_decls is not called;
2114    if there is any preexisting decl for this identifier, it is an ICE.  */
2115
2116 tree
2117 pushdecl_top_level (tree x)
2118 {
2119   tree name;
2120   bool nested = false;
2121   gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2122
2123   name = DECL_NAME (x);
2124
2125  gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2126
2127   if (TREE_PUBLIC (x))
2128     {
2129       bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false);
2130       nested = true;
2131     }
2132   if (file_scope)
2133     bind (name, x, file_scope, /*invisible=*/false, nested);
2134
2135   return x;
2136 }
2137 \f
2138 static void
2139 implicit_decl_warning (tree id, tree olddecl)
2140 {
2141   void (*diag) (const char *, ...);
2142   switch (mesg_implicit_function_declaration)
2143     {
2144     case 0: return;
2145     case 1: diag = warning; break;
2146     case 2: diag = error;   break;
2147     default: gcc_unreachable ();
2148     }
2149
2150   diag (N_("implicit declaration of function %qE"), id);
2151   if (olddecl)
2152     locate_old_decl (olddecl, diag);
2153 }
2154
2155 /* Generate an implicit declaration for identifier FUNCTIONID as a
2156    function of type int ().  */
2157
2158 tree
2159 implicitly_declare (tree functionid)
2160 {
2161   struct c_binding *b;
2162   tree decl = 0;
2163   tree asmspec_tree;
2164
2165   for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2166     {
2167       if (B_IN_SCOPE (b, external_scope))
2168         {
2169           decl = b->decl;
2170           break;
2171         }
2172     }
2173
2174   if (decl)
2175     {
2176       /* FIXME: Objective-C has weird not-really-builtin functions
2177          which are supposed to be visible automatically.  They wind up
2178          in the external scope because they're pushed before the file
2179          scope gets created.  Catch this here and rebind them into the
2180          file scope.  */
2181       if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2182         {
2183           bind (functionid, decl, file_scope,
2184                 /*invisible=*/false, /*nested=*/true);
2185           return decl;
2186         }
2187       else
2188         {
2189           tree newtype = default_function_type;
2190           if (b->type)
2191             TREE_TYPE (decl) = b->type;
2192           /* Implicit declaration of a function already declared
2193              (somehow) in a different scope, or as a built-in.
2194              If this is the first time this has happened, warn;
2195              then recycle the old declaration but with the new type.  */
2196           if (!C_DECL_IMPLICIT (decl))
2197             {
2198               implicit_decl_warning (functionid, decl);
2199               C_DECL_IMPLICIT (decl) = 1;
2200             }
2201           if (DECL_BUILT_IN (decl))
2202             {
2203               newtype = build_type_attribute_variant (newtype,
2204                                                       TYPE_ATTRIBUTES
2205                                                       (TREE_TYPE (decl)));
2206               if (!comptypes (newtype, TREE_TYPE (decl)))
2207                 {
2208                   warning ("incompatible implicit declaration of built-in"
2209                            " function %qD", decl);
2210                   newtype = TREE_TYPE (decl);
2211                 }
2212             }
2213           else
2214             {
2215               if (!comptypes (newtype, TREE_TYPE (decl)))
2216                 {
2217                   error ("incompatible implicit declaration of function %qD",
2218                          decl);
2219                   locate_old_decl (decl, error);
2220                 }
2221             }
2222           b->type = TREE_TYPE (decl);
2223           TREE_TYPE (decl) = newtype;
2224           bind (functionid, decl, current_scope,
2225                 /*invisible=*/false, /*nested=*/true);
2226           return decl;
2227         }
2228     }
2229
2230   /* Not seen before.  */
2231   decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2232   DECL_EXTERNAL (decl) = 1;
2233   TREE_PUBLIC (decl) = 1;
2234   C_DECL_IMPLICIT (decl) = 1;
2235   implicit_decl_warning (functionid, 0);
2236   asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2237   if (asmspec_tree)
2238     set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2239
2240   /* C89 says implicit declarations are in the innermost block.
2241      So we record the decl in the standard fashion.  */
2242   decl = pushdecl (decl);
2243
2244   /* No need to call objc_check_decl here - it's a function type.  */
2245   rest_of_decl_compilation (decl, 0, 0);
2246
2247   /* Write a record describing this implicit function declaration
2248      to the prototypes file (if requested).  */
2249   gen_aux_info_record (decl, 0, 1, 0);
2250
2251   /* Possibly apply some default attributes to this implicit declaration.  */
2252   decl_attributes (&decl, NULL_TREE, 0);
2253
2254   return decl;
2255 }
2256
2257 /* Issue an error message for a reference to an undeclared variable
2258    ID, including a reference to a builtin outside of function-call
2259    context.  Establish a binding of the identifier to error_mark_node
2260    in an appropriate scope, which will suppress further errors for the
2261    same identifier.  */
2262 void
2263 undeclared_variable (tree id)
2264 {
2265   static bool already = false;
2266   struct c_scope *scope;
2267
2268   if (current_function_decl == 0)
2269     {
2270       error ("%qE undeclared here (not in a function)", id);
2271       scope = current_scope;
2272     }
2273   else
2274     {
2275       error ("%qE undeclared (first use in this function)", id);
2276
2277       if (!already)
2278         {
2279           error ("(Each undeclared identifier is reported only once");
2280           error ("for each function it appears in.)");
2281           already = true;
2282         }
2283
2284       /* If we are parsing old-style parameter decls, current_function_decl
2285          will be nonnull but current_function_scope will be null.  */
2286       scope = current_function_scope ? current_function_scope : current_scope;
2287     }
2288   bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false);
2289 }
2290 \f
2291 /* Subroutine of lookup_label, declare_label, define_label: construct a
2292    LABEL_DECL with all the proper frills.  */
2293
2294 static tree
2295 make_label (tree name, location_t location)
2296 {
2297   tree label = build_decl (LABEL_DECL, name, void_type_node);
2298
2299   DECL_CONTEXT (label) = current_function_decl;
2300   DECL_MODE (label) = VOIDmode;
2301   DECL_SOURCE_LOCATION (label) = location;
2302
2303   return label;
2304 }
2305
2306 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2307    Create one if none exists so far for the current function.
2308    This is called when a label is used in a goto expression or
2309    has its address taken.  */
2310
2311 tree
2312 lookup_label (tree name)
2313 {
2314   tree label;
2315
2316   if (current_function_decl == 0)
2317     {
2318       error ("label %qs referenced outside of any function",
2319              IDENTIFIER_POINTER (name));
2320       return 0;
2321     }
2322
2323   /* Use a label already defined or ref'd with this name, but not if
2324      it is inherited from a containing function and wasn't declared
2325      using __label__.  */
2326   label = I_LABEL_DECL (name);
2327   if (label && (DECL_CONTEXT (label) == current_function_decl
2328                 || C_DECLARED_LABEL_FLAG (label)))
2329     {
2330       /* If the label has only been declared, update its apparent
2331          location to point here, for better diagnostics if it
2332          turns out not to have been defined.  */
2333       if (!TREE_USED (label))
2334         DECL_SOURCE_LOCATION (label) = input_location;
2335       return label;
2336     }
2337
2338   /* No label binding for that identifier; make one.  */
2339   label = make_label (name, input_location);
2340
2341   /* Ordinary labels go in the current function scope.  */
2342   bind (name, label, current_function_scope,
2343         /*invisible=*/false, /*nested=*/false);
2344   return label;
2345 }
2346
2347 /* Make a label named NAME in the current function, shadowing silently
2348    any that may be inherited from containing functions or containing
2349    scopes.  This is called for __label__ declarations.  */
2350
2351 tree
2352 declare_label (tree name)
2353 {
2354   struct c_binding *b = I_LABEL_BINDING (name);
2355   tree label;
2356
2357   /* Check to make sure that the label hasn't already been declared
2358      at this scope */
2359   if (b && B_IN_CURRENT_SCOPE (b))
2360     {
2361       error ("duplicate label declaration %qs", IDENTIFIER_POINTER (name));
2362       locate_old_decl (b->decl, error);
2363
2364       /* Just use the previous declaration.  */
2365       return b->decl;
2366     }
2367
2368   label = make_label (name, input_location);
2369   C_DECLARED_LABEL_FLAG (label) = 1;
2370
2371   /* Declared labels go in the current scope.  */
2372   bind (name, label, current_scope,
2373         /*invisible=*/false, /*nested=*/false);
2374   return label;
2375 }
2376
2377 /* Define a label, specifying the location in the source file.
2378    Return the LABEL_DECL node for the label, if the definition is valid.
2379    Otherwise return 0.  */
2380
2381 tree
2382 define_label (location_t location, tree name)
2383 {
2384   /* Find any preexisting label with this name.  It is an error
2385      if that label has already been defined in this function, or
2386      if there is a containing function with a declared label with
2387      the same name.  */
2388   tree label = I_LABEL_DECL (name);
2389
2390   if (label
2391       && ((DECL_CONTEXT (label) == current_function_decl
2392            && DECL_INITIAL (label) != 0)
2393           || (DECL_CONTEXT (label) != current_function_decl
2394               && C_DECLARED_LABEL_FLAG (label))))
2395     {
2396       error ("%Hduplicate label %qD", &location, label);
2397       locate_old_decl (label, error);
2398       return 0;
2399     }
2400   else if (label && DECL_CONTEXT (label) == current_function_decl)
2401     {
2402       /* The label has been used or declared already in this function,
2403          but not defined.  Update its location to point to this
2404          definition.  */
2405       DECL_SOURCE_LOCATION (label) = location;
2406     }
2407   else
2408     {
2409       /* No label binding for that identifier; make one.  */
2410       label = make_label (name, location);
2411
2412       /* Ordinary labels go in the current function scope.  */
2413       bind (name, label, current_function_scope,
2414             /*invisible=*/false, /*nested=*/false);
2415     }
2416
2417   if (warn_traditional && !in_system_header && lookup_name (name))
2418     warning ("%Htraditional C lacks a separate namespace for labels, "
2419              "identifier %qs conflicts", &location,
2420              IDENTIFIER_POINTER (name));
2421
2422   /* Mark label as having been defined.  */
2423   DECL_INITIAL (label) = error_mark_node;
2424   return label;
2425 }
2426 \f
2427 /* Given NAME, an IDENTIFIER_NODE,
2428    return the structure (or union or enum) definition for that name.
2429    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
2430    CODE says which kind of type the caller wants;
2431    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2432    If the wrong kind of type is found, an error is reported.  */
2433
2434 static tree
2435 lookup_tag (enum tree_code code, tree name, int thislevel_only)
2436 {
2437   struct c_binding *b = I_TAG_BINDING (name);
2438   int thislevel = 0;
2439
2440   if (!b || !b->decl)
2441     return 0;
2442
2443   /* We only care about whether it's in this level if
2444      thislevel_only was set or it might be a type clash.  */
2445   if (thislevel_only || TREE_CODE (b->decl) != code)
2446     {
2447       /* For our purposes, a tag in the external scope is the same as
2448          a tag in the file scope.  (Primarily relevant to Objective-C
2449          and its builtin structure tags, which get pushed before the
2450          file scope is created.)  */
2451       if (B_IN_CURRENT_SCOPE (b)
2452           || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
2453         thislevel = 1;
2454     }
2455
2456   if (thislevel_only && !thislevel)
2457     return 0;
2458
2459   if (TREE_CODE (b->decl) != code)
2460     {
2461       /* Definition isn't the kind we were looking for.  */
2462       pending_invalid_xref = name;
2463       pending_invalid_xref_location = input_location;
2464
2465       /* If in the same binding level as a declaration as a tag
2466          of a different type, this must not be allowed to
2467          shadow that tag, so give the error immediately.
2468          (For example, "struct foo; union foo;" is invalid.)  */
2469       if (thislevel)
2470         pending_xref_error ();
2471     }
2472   return b->decl;
2473 }
2474
2475 /* Print an error message now
2476    for a recent invalid struct, union or enum cross reference.
2477    We don't print them immediately because they are not invalid
2478    when used in the `struct foo;' construct for shadowing.  */
2479
2480 void
2481 pending_xref_error (void)
2482 {
2483   if (pending_invalid_xref != 0)
2484     error ("%H%qs defined as wrong kind of tag",
2485            &pending_invalid_xref_location,
2486            IDENTIFIER_POINTER (pending_invalid_xref));
2487   pending_invalid_xref = 0;
2488 }
2489
2490 \f
2491 /* Look up NAME in the current scope and its superiors
2492    in the namespace of variables, functions and typedefs.
2493    Return a ..._DECL node of some kind representing its definition,
2494    or return 0 if it is undefined.  */
2495
2496 tree
2497 lookup_name (tree name)
2498 {
2499   struct c_binding *b = I_SYMBOL_BINDING (name);
2500   if (b && !b->invisible)
2501     return b->decl;
2502   return 0;
2503 }
2504
2505 /* Similar to `lookup_name' but look only at the indicated scope.  */
2506
2507 static tree
2508 lookup_name_in_scope (tree name, struct c_scope *scope)
2509 {
2510   struct c_binding *b;
2511
2512   for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
2513     if (B_IN_SCOPE (b, scope))
2514       return b->decl;
2515   return 0;
2516 }
2517 \f
2518 /* Create the predefined scalar types of C,
2519    and some nodes representing standard constants (0, 1, (void *) 0).
2520    Initialize the global scope.
2521    Make definitions for built-in primitive functions.  */
2522
2523 void
2524 c_init_decl_processing (void)
2525 {
2526   tree endlink;
2527   tree ptr_ftype_void, ptr_ftype_ptr;
2528   location_t save_loc = input_location;
2529
2530   /* Adds some ggc roots, and reserved words for c-parse.in.  */
2531   c_parse_init ();
2532
2533   current_function_decl = 0;
2534
2535   gcc_obstack_init (&parser_obstack);
2536
2537   /* Make the externals scope.  */
2538   push_scope ();
2539   external_scope = current_scope;
2540
2541   /* Declarations from c_common_nodes_and_builtins must not be associated
2542      with this input file, lest we get differences between using and not
2543      using preprocessed headers.  */
2544 #ifdef USE_MAPPED_LOCATION
2545   input_location = BUILTINS_LOCATION;
2546 #else
2547   input_location.file = "<built-in>";
2548   input_location.line = 0;
2549 #endif
2550
2551   build_common_tree_nodes (flag_signed_char, false);
2552
2553   c_common_nodes_and_builtins ();
2554
2555   /* In C, comparisons and TRUTH_* expressions have type int.  */
2556   truthvalue_type_node = integer_type_node;
2557   truthvalue_true_node = integer_one_node;
2558   truthvalue_false_node = integer_zero_node;
2559
2560   /* Even in C99, which has a real boolean type.  */
2561   pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2562                         boolean_type_node));
2563
2564   endlink = void_list_node;
2565   ptr_ftype_void = build_function_type (ptr_type_node, endlink);
2566   ptr_ftype_ptr
2567     = build_function_type (ptr_type_node,
2568                            tree_cons (NULL_TREE, ptr_type_node, endlink));
2569
2570   input_location = save_loc;
2571
2572   pedantic_lvalues = true;
2573
2574   make_fname_decl = c_make_fname_decl;
2575   start_fname_decls ();
2576 }
2577
2578 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2579    decl, NAME is the initialization string and TYPE_DEP indicates whether
2580    NAME depended on the type of the function.  As we don't yet implement
2581    delayed emission of static data, we mark the decl as emitted
2582    so it is not placed in the output.  Anything using it must therefore pull
2583    out the STRING_CST initializer directly.  FIXME.  */
2584
2585 static tree
2586 c_make_fname_decl (tree id, int type_dep)
2587 {
2588   const char *name = fname_as_string (type_dep);
2589   tree decl, type, init;
2590   size_t length = strlen (name);
2591
2592   type =  build_array_type
2593           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
2594            build_index_type (size_int (length)));
2595
2596   decl = build_decl (VAR_DECL, id, type);
2597
2598   TREE_STATIC (decl) = 1;
2599   TREE_READONLY (decl) = 1;
2600   DECL_ARTIFICIAL (decl) = 1;
2601
2602   init = build_string (length + 1, name);
2603   free ((char *) name);
2604   TREE_TYPE (init) = type;
2605   DECL_INITIAL (decl) = init;
2606
2607   TREE_USED (decl) = 1;
2608
2609   if (current_function_decl)
2610     {
2611       DECL_CONTEXT (decl) = current_function_decl;
2612       bind (id, decl, current_function_scope,
2613             /*invisible=*/false, /*nested=*/false);
2614     }
2615
2616   finish_decl (decl, init, NULL_TREE);
2617
2618   return decl;
2619 }
2620
2621 /* Return a definition for a builtin function named NAME and whose data type
2622    is TYPE.  TYPE should be a function type with argument types.
2623    FUNCTION_CODE tells later passes how to compile calls to this function.
2624    See tree.h for its possible values.
2625
2626    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2627    the name to be called if we can't opencode the function.  If
2628    ATTRS is nonzero, use that for the function's attribute list.  */
2629
2630 tree
2631 builtin_function (const char *name, tree type, int function_code,
2632                   enum built_in_class cl, const char *library_name,
2633                   tree attrs)
2634 {
2635   tree id = get_identifier (name);
2636   tree decl = build_decl (FUNCTION_DECL, id, type);
2637   TREE_PUBLIC (decl) = 1;
2638   DECL_EXTERNAL (decl) = 1;
2639   DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
2640   DECL_BUILT_IN_CLASS (decl) = cl;
2641   DECL_FUNCTION_CODE (decl) = function_code;
2642   if (library_name)
2643     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2644
2645   /* Should never be called on a symbol with a preexisting meaning.  */
2646   gcc_assert (!I_SYMBOL_BINDING (id));
2647
2648   bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false);
2649
2650   /* Builtins in the implementation namespace are made visible without
2651      needing to be explicitly declared.  See push_file_scope.  */
2652   if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
2653     {
2654       TREE_CHAIN (decl) = visible_builtins;
2655       visible_builtins = decl;
2656     }
2657
2658   /* Possibly apply some default attributes to this built-in function.  */
2659   if (attrs)
2660     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2661   else
2662     decl_attributes (&decl, NULL_TREE, 0);
2663
2664   return decl;
2665 }
2666 \f
2667 /* Called when a declaration is seen that contains no names to declare.
2668    If its type is a reference to a structure, union or enum inherited
2669    from a containing scope, shadow that tag name for the current scope
2670    with a forward reference.
2671    If its type defines a new named structure or union
2672    or defines an enum, it is valid but we need not do anything here.
2673    Otherwise, it is an error.  */
2674
2675 void
2676 shadow_tag (const struct c_declspecs *declspecs)
2677 {
2678   shadow_tag_warned (declspecs, 0);
2679 }
2680
2681 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
2682    but no pedwarn.  */
2683 void
2684 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
2685 {
2686   bool found_tag = false;
2687
2688   if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
2689     {
2690       tree value = declspecs->type;
2691       enum tree_code code = TREE_CODE (value);
2692
2693       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2694         /* Used to test also that TYPE_SIZE (value) != 0.
2695            That caused warning for `struct foo;' at top level in the file.  */
2696         {
2697           tree name = TYPE_NAME (value);
2698           tree t;
2699
2700           found_tag = true;
2701
2702           if (name == 0)
2703             {
2704               if (warned != 1 && code != ENUMERAL_TYPE)
2705                 /* Empty unnamed enum OK */
2706                 {
2707                   pedwarn ("unnamed struct/union that defines no instances");
2708                   warned = 1;
2709                 }
2710             }
2711           else if (!declspecs->tag_defined_p
2712                    && declspecs->storage_class != csc_none)
2713             {
2714               if (warned != 1)
2715                 pedwarn ("empty declaration with storage class specifier "
2716                          "does not redeclare tag");
2717               warned = 1;
2718               pending_xref_error ();
2719             }
2720           else if (!declspecs->tag_defined_p
2721                    && (declspecs->const_p
2722                        || declspecs->volatile_p
2723                        || declspecs->restrict_p))
2724             {
2725               if (warned != 1)
2726                 pedwarn ("empty declaration with type qualifier "
2727                          "does not redeclare tag");
2728               warned = 1;
2729               pending_xref_error ();
2730             }
2731           else
2732             {
2733               pending_invalid_xref = 0;
2734               t = lookup_tag (code, name, 1);
2735
2736               if (t == 0)
2737                 {
2738                   t = make_node (code);
2739                   pushtag (name, t);
2740                 }
2741             }
2742         }
2743       else
2744         {
2745           if (warned != 1 && !in_system_header)
2746             {
2747               pedwarn ("useless type name in empty declaration");
2748               warned = 1;
2749             }
2750         }
2751     }
2752   else if (warned != 1 && !in_system_header && declspecs->typedef_p)
2753     {
2754       pedwarn ("useless type name in empty declaration");
2755       warned = 1;
2756     }
2757
2758   pending_invalid_xref = 0;
2759
2760   if (declspecs->inline_p)
2761     {
2762       error ("%<inline%> in empty declaration");
2763       warned = 1;
2764     }
2765
2766   if (current_scope == file_scope && declspecs->storage_class == csc_auto)
2767     {
2768       error ("%<auto%> in file-scope empty declaration");
2769       warned = 1;
2770     }
2771
2772   if (current_scope == file_scope && declspecs->storage_class == csc_register)
2773     {
2774       error ("%<register%> in file-scope empty declaration");
2775       warned = 1;
2776     }
2777
2778   if (!warned && !in_system_header && declspecs->storage_class != csc_none)
2779     {
2780       warning ("useless storage class specifier in empty declaration");
2781       warned = 2;
2782     }
2783
2784   if (!warned && !in_system_header && declspecs->thread_p)
2785     {
2786       warning ("useless %<__thread%> in empty declaration");
2787       warned = 2;
2788     }
2789
2790   if (!warned && !in_system_header && (declspecs->const_p
2791                                        || declspecs->volatile_p
2792                                        || declspecs->restrict_p))
2793     {
2794       warning ("useless type qualifier in empty declaration");
2795       warned = 2;
2796     }
2797
2798   if (warned != 1)
2799     {
2800       if (!found_tag)
2801         pedwarn ("empty declaration");
2802     }
2803 }
2804 \f
2805
2806 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
2807    bits.  SPECS represents declaration specifiers that the grammar
2808    only permits to contain type qualifiers and attributes.  */
2809
2810 int
2811 quals_from_declspecs (const struct c_declspecs *specs)
2812 {
2813   int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
2814                | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
2815                | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
2816   gcc_assert (!specs->type
2817               && !specs->decl_attr
2818               && specs->typespec_word == cts_none
2819               && specs->storage_class == csc_none
2820               && !specs->typedef_p
2821               && !specs->explicit_signed_p
2822               && !specs->deprecated_p
2823               && !specs->long_p
2824               && !specs->long_long_p
2825               && !specs->short_p
2826               && !specs->signed_p
2827               && !specs->unsigned_p
2828               && !specs->complex_p
2829               && !specs->inline_p
2830               && !specs->thread_p);
2831   return quals;
2832 }
2833
2834 /* Construct an array declarator.  EXPR is the expression inside [], or
2835    NULL_TREE.  QUALS are the type qualifiers inside the [] (to be applied
2836    to the pointer to which a parameter array is converted).  STATIC_P is
2837    true if "static" is inside the [], false otherwise.  VLA_UNSPEC_P
2838    is true if the array is [*], a VLA of unspecified length which is
2839    nevertheless a complete type (not currently implemented by GCC),
2840    false otherwise.  The field for the contained declarator is left to be
2841    filled in by set_array_declarator_inner.  */
2842
2843 struct c_declarator *
2844 build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
2845                         bool vla_unspec_p)
2846 {
2847   struct c_declarator *declarator = XOBNEW (&parser_obstack,
2848                                             struct c_declarator);
2849   declarator->kind = cdk_array;
2850   declarator->declarator = 0;
2851   declarator->u.array.dimen = expr;
2852   if (quals)
2853     {
2854       declarator->u.array.attrs = quals->attrs;
2855       declarator->u.array.quals = quals_from_declspecs (quals);
2856     }
2857   else
2858     {
2859       declarator->u.array.attrs = NULL_TREE;
2860       declarator->u.array.quals = 0;
2861     }
2862   declarator->u.array.static_p = static_p;
2863   declarator->u.array.vla_unspec_p = vla_unspec_p;
2864   if (pedantic && !flag_isoc99)
2865     {
2866       if (static_p || quals != NULL)
2867         pedwarn ("ISO C90 does not support %<static%> or type "
2868                  "qualifiers in parameter array declarators");
2869       if (vla_unspec_p)
2870         pedwarn ("ISO C90 does not support %<[*]%> array declarators");
2871     }
2872   if (vla_unspec_p)
2873     warning ("GCC does not yet properly implement %<[*]%> array declarators");
2874   return declarator;
2875 }
2876
2877 /* Set the contained declarator of an array declarator.  DECL is the
2878    declarator, as constructed by build_array_declarator; INNER is what
2879    appears on the left of the [].  ABSTRACT_P is true if it is an
2880    abstract declarator, false otherwise; this is used to reject static
2881    and type qualifiers in abstract declarators, where they are not in
2882    the C99 grammar (subject to possible change in DR#289).  */
2883
2884 struct c_declarator *
2885 set_array_declarator_inner (struct c_declarator *decl,
2886                             struct c_declarator *inner, bool abstract_p)
2887 {
2888   decl->declarator = inner;
2889   if (abstract_p && (decl->u.array.quals != TYPE_UNQUALIFIED
2890                      || decl->u.array.attrs != NULL_TREE
2891                      || decl->u.array.static_p))
2892     error ("static or type qualifiers in abstract declarator");
2893   return decl;
2894 }
2895 \f
2896 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
2897
2898 tree
2899 groktypename (struct c_type_name *type_name)
2900 {
2901   tree type;
2902   tree attrs = type_name->specs->attrs;
2903
2904   type_name->specs->attrs = NULL_TREE;
2905
2906   type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
2907                          false, NULL);
2908
2909   /* Apply attributes.  */
2910   decl_attributes (&type, attrs, 0);
2911
2912   return type;
2913 }
2914
2915 /* Decode a declarator in an ordinary declaration or data definition.
2916    This is called as soon as the type information and variable name
2917    have been parsed, before parsing the initializer if any.
2918    Here we create the ..._DECL node, fill in its type,
2919    and put it on the list of decls for the current context.
2920    The ..._DECL node is returned as the value.
2921
2922    Exception: for arrays where the length is not specified,
2923    the type is left null, to be filled in by `finish_decl'.
2924
2925    Function definitions do not come here; they go to start_function
2926    instead.  However, external and forward declarations of functions
2927    do go through here.  Structure field declarations are done by
2928    grokfield and not through here.  */
2929
2930 tree
2931 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
2932             bool initialized, tree attributes)
2933 {
2934   tree decl;
2935   tree tem;
2936
2937   /* An object declared as __attribute__((deprecated)) suppresses
2938      warnings of uses of other deprecated items.  */
2939   if (lookup_attribute ("deprecated", attributes))
2940     deprecated_state = DEPRECATED_SUPPRESS;
2941
2942   decl = grokdeclarator (declarator, declspecs,
2943                          NORMAL, initialized, NULL);
2944   if (!decl)
2945     return 0;
2946
2947   deprecated_state = DEPRECATED_NORMAL;
2948
2949   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
2950       && MAIN_NAME_P (DECL_NAME (decl)))
2951     warning ("%J%qD is usually a function", decl, decl);
2952
2953   if (initialized)
2954     /* Is it valid for this decl to have an initializer at all?
2955        If not, set INITIALIZED to zero, which will indirectly
2956        tell 'finish_decl' to ignore the initializer once it is parsed.  */
2957     switch (TREE_CODE (decl))
2958       {
2959       case TYPE_DECL:
2960         error ("typedef %qD is initialized (use __typeof__ instead)", decl);
2961         initialized = 0;
2962         break;
2963
2964       case FUNCTION_DECL:
2965         error ("function %qD is initialized like a variable", decl);
2966         initialized = 0;
2967         break;
2968
2969       case PARM_DECL:
2970         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
2971         error ("parameter %qD is initialized", decl);
2972         initialized = 0;
2973         break;
2974
2975       default:
2976         /* Don't allow initializations for incomplete types except for
2977            arrays which might be completed by the initialization.  */
2978
2979         /* This can happen if the array size is an undefined macro.
2980            We already gave a warning, so we don't need another one.  */
2981         if (TREE_TYPE (decl) == error_mark_node)
2982           initialized = 0;
2983         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
2984           {
2985             /* A complete type is ok if size is fixed.  */
2986
2987             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
2988                 || C_DECL_VARIABLE_SIZE (decl))
2989               {
2990                 error ("variable-sized object may not be initialized");
2991                 initialized = 0;
2992               }
2993           }
2994         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
2995           {
2996             error ("variable %qD has initializer but incomplete type", decl);
2997             initialized = 0;
2998           }
2999         else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
3000           {
3001             error ("elements of array %qD have incomplete type", decl);
3002             initialized = 0;
3003           }
3004         else if (C_DECL_VARIABLE_SIZE (decl))
3005           {
3006             /* Although C99 is unclear about whether incomplete arrays
3007                of VLAs themselves count as VLAs, it does not make
3008                sense to permit them to be initialized given that
3009                ordinary VLAs may not be initialized.  */
3010             error ("variable-sized object may not be initialized");
3011             initialized = 0;
3012           }
3013       }
3014
3015   if (initialized)
3016     {
3017       if (current_scope == file_scope)
3018         TREE_STATIC (decl) = 1;
3019
3020       /* Tell 'pushdecl' this is an initialized decl
3021          even though we don't yet have the initializer expression.
3022          Also tell 'finish_decl' it may store the real initializer.  */
3023       DECL_INITIAL (decl) = error_mark_node;
3024     }
3025
3026   /* If this is a function declaration, write a record describing it to the
3027      prototypes file (if requested).  */
3028
3029   if (TREE_CODE (decl) == FUNCTION_DECL)
3030     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3031
3032   /* ANSI specifies that a tentative definition which is not merged with
3033      a non-tentative definition behaves exactly like a definition with an
3034      initializer equal to zero.  (Section 3.7.2)
3035
3036      -fno-common gives strict ANSI behavior, though this tends to break
3037      a large body of code that grew up without this rule.
3038
3039      Thread-local variables are never common, since there's no entrenched
3040      body of code to break, and it allows more efficient variable references
3041      in the presence of dynamic linking.  */
3042
3043   if (TREE_CODE (decl) == VAR_DECL
3044       && !initialized
3045       && TREE_PUBLIC (decl)
3046       && !DECL_THREAD_LOCAL (decl)
3047       && !flag_no_common)
3048     DECL_COMMON (decl) = 1;
3049
3050   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3051   decl_attributes (&decl, attributes, 0);
3052
3053   if (TREE_CODE (decl) == FUNCTION_DECL
3054       && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
3055     {
3056       struct c_declarator *ce = declarator;
3057
3058       if (ce->kind == cdk_pointer)
3059         ce = declarator->declarator;
3060       if (ce->kind == cdk_function)
3061         {
3062           tree args = ce->u.arg_info->parms;
3063           for (; args; args = TREE_CHAIN (args))
3064             {
3065               tree type = TREE_TYPE (args);
3066               if (type && INTEGRAL_TYPE_P (type)
3067                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
3068                 DECL_ARG_TYPE (args) = integer_type_node;
3069             }
3070         }
3071     }
3072
3073   if (TREE_CODE (decl) == FUNCTION_DECL
3074       && DECL_DECLARED_INLINE_P (decl)
3075       && DECL_UNINLINABLE (decl)
3076       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3077     warning ("%Jinline function %qD given attribute noinline", decl, decl);
3078
3079   /* Add this decl to the current scope.
3080      TEM may equal DECL or it may be a previous decl of the same name.  */
3081   tem = pushdecl (decl);
3082
3083   if (initialized && DECL_EXTERNAL (tem))
3084     {
3085       DECL_EXTERNAL (tem) = 0;
3086       TREE_STATIC (tem) = 1;
3087     }
3088
3089   return tem;
3090 }
3091
3092 /* Finish processing of a declaration;
3093    install its initial value.
3094    If the length of an array type is not known before,
3095    it must be determined now, from the initial value, or it is an error.  */
3096
3097 void
3098 finish_decl (tree decl, tree init, tree asmspec_tree)
3099 {
3100   tree type = TREE_TYPE (decl);
3101   int was_incomplete = (DECL_SIZE (decl) == 0);
3102   const char *asmspec = 0;
3103
3104   /* If a name was specified, get the string.  */
3105   if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
3106       && DECL_FILE_SCOPE_P (decl))
3107     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
3108   if (asmspec_tree)
3109     asmspec = TREE_STRING_POINTER (asmspec_tree);
3110
3111   /* If `start_decl' didn't like having an initialization, ignore it now.  */
3112   if (init != 0 && DECL_INITIAL (decl) == 0)
3113     init = 0;
3114
3115   /* Don't crash if parm is initialized.  */
3116   if (TREE_CODE (decl) == PARM_DECL)
3117     init = 0;
3118
3119   if (init)
3120     store_init_value (decl, init);
3121
3122   if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
3123                             || TREE_CODE (decl) == FUNCTION_DECL
3124                             || TREE_CODE (decl) == FIELD_DECL))
3125     objc_check_decl (decl);
3126
3127   /* Deduce size of array from initialization, if not already known.  */
3128   if (TREE_CODE (type) == ARRAY_TYPE
3129       && TYPE_DOMAIN (type) == 0
3130       && TREE_CODE (decl) != TYPE_DECL)
3131     {
3132       int do_default
3133         = (TREE_STATIC (decl)
3134            /* Even if pedantic, an external linkage array
3135               may have incomplete type at first.  */
3136            ? pedantic && !TREE_PUBLIC (decl)
3137            : !DECL_EXTERNAL (decl));
3138       int failure
3139         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3140
3141       /* Get the completed type made by complete_array_type.  */
3142       type = TREE_TYPE (decl);
3143
3144       if (failure == 1)
3145         error ("%Jinitializer fails to determine size of %qD", decl, decl);
3146
3147       else if (failure == 2)
3148         {
3149           if (do_default)
3150             error ("%Jarray size missing in %qD", decl, decl);
3151           /* If a `static' var's size isn't known,
3152              make it extern as well as static, so it does not get
3153              allocated.
3154              If it is not `static', then do not mark extern;
3155              finish_incomplete_decl will give it a default size
3156              and it will get allocated.  */
3157           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3158             DECL_EXTERNAL (decl) = 1;
3159         }
3160
3161       /* TYPE_MAX_VALUE is always one less than the number of elements
3162          in the array, because we start counting at zero.  Therefore,
3163          warn only if the value is less than zero.  */
3164       else if (pedantic && TYPE_DOMAIN (type) != 0
3165                && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3166         error ("%Jzero or negative size array %qD", decl, decl);
3167
3168       layout_decl (decl, 0);
3169     }
3170
3171   if (TREE_CODE (decl) == VAR_DECL)
3172     {
3173       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3174           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3175         layout_decl (decl, 0);
3176
3177       if (DECL_SIZE (decl) == 0
3178           /* Don't give an error if we already gave one earlier.  */
3179           && TREE_TYPE (decl) != error_mark_node
3180           && (TREE_STATIC (decl)
3181               /* A static variable with an incomplete type
3182                  is an error if it is initialized.
3183                  Also if it is not file scope.
3184                  Otherwise, let it through, but if it is not `extern'
3185                  then it may cause an error message later.  */
3186               ? (DECL_INITIAL (decl) != 0
3187                  || !DECL_FILE_SCOPE_P (decl))
3188               /* An automatic variable with an incomplete type
3189                  is an error.  */
3190               : !DECL_EXTERNAL (decl)))
3191          {
3192            error ("%Jstorage size of %qD isn%'t known", decl, decl);
3193            TREE_TYPE (decl) = error_mark_node;
3194          }
3195
3196       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3197           && DECL_SIZE (decl) != 0)
3198         {
3199           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3200             constant_expression_warning (DECL_SIZE (decl));
3201           else
3202             error ("%Jstorage size of %qD isn%'t constant", decl, decl);
3203         }
3204
3205       if (TREE_USED (type))
3206         TREE_USED (decl) = 1;
3207     }
3208
3209   /* If this is a function and an assembler name is specified, reset DECL_RTL
3210      so we can give it its new name.  Also, update built_in_decls if it
3211      was a normal built-in.  */
3212   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3213     {
3214       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
3215         set_builtin_user_assembler_name (decl, asmspec);
3216       set_user_assembler_name (decl, asmspec);
3217     }
3218
3219   /* If #pragma weak was used, mark the decl weak now.  */
3220   if (current_scope == file_scope)
3221     maybe_apply_pragma_weak (decl);
3222
3223   /* If this is a variable definition, determine its ELF visibility.  */
3224   if (TREE_CODE (decl) == VAR_DECL 
3225       && TREE_STATIC (decl) 
3226       && !DECL_EXTERNAL (decl))
3227     c_determine_visibility (decl);
3228
3229   /* Output the assembler code and/or RTL code for variables and functions,
3230      unless the type is an undefined structure or union.
3231      If not, it will get done when the type is completed.  */
3232
3233   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3234     {
3235       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
3236       if (c_dialect_objc ())
3237         objc_check_decl (decl);
3238
3239       if (asmspec) 
3240         {
3241           /* If this is not a static variable, issue a warning.
3242              It doesn't make any sense to give an ASMSPEC for an
3243              ordinary, non-register local variable.  Historically,
3244              GCC has accepted -- but ignored -- the ASMSPEC in
3245              this case.  */
3246           if (!DECL_FILE_SCOPE_P (decl)
3247               && TREE_CODE (decl) == VAR_DECL
3248               && !C_DECL_REGISTER (decl)
3249               && !TREE_STATIC (decl))
3250             warning ("%Jignoring asm-specifier for non-static local "
3251                      "variable %qD", decl, decl);
3252           else if (C_DECL_REGISTER (decl))
3253             change_decl_assembler_name (decl, get_identifier (asmspec));
3254           else
3255             set_user_assembler_name (decl, asmspec);
3256         }
3257       
3258       if (DECL_FILE_SCOPE_P (decl))
3259         {
3260           if (DECL_INITIAL (decl) == NULL_TREE
3261               || DECL_INITIAL (decl) == error_mark_node)
3262             /* Don't output anything
3263                when a tentative file-scope definition is seen.
3264                But at end of compilation, do output code for them.  */
3265             DECL_DEFER_OUTPUT (decl) = 1;
3266           rest_of_decl_compilation (decl, true, 0);
3267         }
3268       else
3269         {
3270           /* In conjunction with an ASMSPEC, the `register'
3271              keyword indicates that we should place the variable
3272              in a particular register.  */
3273           if (asmspec && C_DECL_REGISTER (decl))
3274             {
3275               DECL_HARD_REGISTER (decl) = 1;
3276               /* This cannot be done for a structure with volatile
3277                  fields, on which DECL_REGISTER will have been
3278                  reset.  */
3279               if (!DECL_REGISTER (decl))
3280                 error ("cannot put object with volatile field into register");
3281             }
3282
3283           if (TREE_CODE (decl) != FUNCTION_DECL)
3284             {
3285               /* If we're building a variable sized type, and we might be
3286                  reachable other than via the top of the current binding
3287                  level, then create a new BIND_EXPR so that we deallocate
3288                  the object at the right time.  */
3289               /* Note that DECL_SIZE can be null due to errors.  */
3290               if (DECL_SIZE (decl)
3291                   && !TREE_CONSTANT (DECL_SIZE (decl))
3292                   && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
3293                 {
3294                   tree bind;
3295                   bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
3296                   TREE_SIDE_EFFECTS (bind) = 1;
3297                   add_stmt (bind);
3298                   BIND_EXPR_BODY (bind) = push_stmt_list ();
3299                 }
3300               add_stmt (build_stmt (DECL_EXPR, decl));
3301             }
3302         }
3303   
3304
3305       if (!DECL_FILE_SCOPE_P (decl))
3306         {
3307           /* Recompute the RTL of a local array now
3308              if it used to be an incomplete type.  */
3309           if (was_incomplete
3310               && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
3311             {
3312               /* If we used it already as memory, it must stay in memory.  */
3313               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3314               /* If it's still incomplete now, no init will save it.  */
3315               if (DECL_SIZE (decl) == 0)
3316                 DECL_INITIAL (decl) = 0;
3317             }
3318         }
3319     }
3320
3321   /* If this was marked 'used', be sure it will be output.  */
3322   if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
3323     mark_decl_referenced (decl);
3324
3325   if (TREE_CODE (decl) == TYPE_DECL)
3326     {
3327       if (!DECL_FILE_SCOPE_P (decl)
3328           && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3329         add_stmt (build_stmt (DECL_EXPR, decl));
3330
3331       rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
3332     }
3333
3334   /* At the end of a declaration, throw away any variable type sizes
3335      of types defined inside that declaration.  There is no use
3336      computing them in the following function definition.  */
3337   if (current_scope == file_scope)
3338     get_pending_sizes ();
3339
3340   /* Install a cleanup (aka destructor) if one was given.  */
3341   if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
3342     {
3343       tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
3344       if (attr)
3345         {
3346           tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
3347           tree cleanup_decl = lookup_name (cleanup_id);
3348           tree cleanup;
3349
3350           /* Build "cleanup(&decl)" for the destructor.  */
3351           cleanup = build_unary_op (ADDR_EXPR, decl, 0);
3352           cleanup = build_tree_list (NULL_TREE, cleanup);
3353           cleanup = build_function_call (cleanup_decl, cleanup);
3354
3355           /* Don't warn about decl unused; the cleanup uses it.  */
3356           TREE_USED (decl) = 1;
3357           TREE_USED (cleanup_decl) = 1;
3358
3359           /* Initialize EH, if we've been told to do so.  */
3360           if (flag_exceptions && !c_eh_initialized_p)
3361             {
3362               c_eh_initialized_p = true;
3363               eh_personality_libfunc
3364                 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
3365                                     ? "__gcc_personality_sj0"
3366                                     : "__gcc_personality_v0");
3367               using_eh_for_cleanups ();
3368             }
3369
3370           push_cleanup (decl, cleanup, false);
3371         }
3372     }
3373 }
3374
3375 /* Given a parsed parameter declaration, decode it into a PARM_DECL.  */
3376
3377 tree
3378 grokparm (const struct c_parm *parm)
3379 {
3380   tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
3381                               NULL);
3382
3383   decl_attributes (&decl, parm->attrs, 0);
3384
3385   return decl;
3386 }
3387
3388 /* Given a parsed parameter declaration, decode it into a PARM_DECL
3389    and push that on the current scope.  */
3390
3391 void
3392 push_parm_decl (const struct c_parm *parm)
3393 {
3394   tree decl;
3395
3396   decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL);
3397   decl_attributes (&decl, parm->attrs, 0);
3398
3399   decl = pushdecl (decl);
3400
3401   finish_decl (decl, NULL_TREE, NULL_TREE);
3402 }
3403
3404 /* Mark all the parameter declarations to date as forward decls.
3405    Also diagnose use of this extension.  */
3406
3407 void
3408 mark_forward_parm_decls (void)
3409 {
3410   struct c_binding *b;
3411
3412   if (pedantic && !current_scope->warned_forward_parm_decls)
3413     {
3414       pedwarn ("ISO C forbids forward parameter declarations");
3415       current_scope->warned_forward_parm_decls = true;
3416     }
3417
3418   for (b = current_scope->bindings; b; b = b->prev)
3419     if (TREE_CODE (b->decl) == PARM_DECL)
3420       TREE_ASM_WRITTEN (b->decl) = 1;
3421 }
3422 \f
3423 static GTY(()) int compound_literal_number;
3424
3425 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
3426    literal, which may be an incomplete array type completed by the
3427    initializer; INIT is a CONSTRUCTOR that initializes the compound
3428    literal.  */
3429
3430 tree
3431 build_compound_literal (tree type, tree init)
3432 {
3433   /* We do not use start_decl here because we have a type, not a declarator;
3434      and do not use finish_decl because the decl should be stored inside
3435      the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR.  */
3436   tree decl;
3437   tree complit;
3438   tree stmt;
3439
3440   if (type == error_mark_node)
3441     return error_mark_node;
3442
3443   decl = build_decl (VAR_DECL, NULL_TREE, type);
3444   DECL_EXTERNAL (decl) = 0;
3445   TREE_PUBLIC (decl) = 0;
3446   TREE_STATIC (decl) = (current_scope == file_scope);
3447   DECL_CONTEXT (decl) = current_function_decl;
3448   TREE_USED (decl) = 1;
3449   TREE_TYPE (decl) = type;
3450   TREE_READONLY (decl) = TYPE_READONLY (type);
3451   store_init_value (decl, init);
3452
3453   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3454     {
3455       int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3456       
3457       gcc_assert (!failure);
3458     }
3459
3460   type = TREE_TYPE (decl);
3461   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3462     return error_mark_node;
3463
3464   stmt = build_stmt (DECL_EXPR, decl);
3465   complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3466   TREE_SIDE_EFFECTS (complit) = 1;
3467
3468   layout_decl (decl, 0);
3469
3470   if (TREE_STATIC (decl))
3471     {
3472       /* This decl needs a name for the assembler output.  We also need
3473          a unique suffix to be added to the name.  */
3474       char *name;
3475
3476       ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3477                                compound_literal_number);
3478       compound_literal_number++;
3479       DECL_NAME (decl) = get_identifier (name);
3480       DECL_DEFER_OUTPUT (decl) = 1;
3481       DECL_COMDAT (decl) = 1;
3482       DECL_ARTIFICIAL (decl) = 1;
3483       DECL_IGNORED_P (decl) = 1;
3484       pushdecl (decl);
3485       rest_of_decl_compilation (decl, 1, 0);
3486     }
3487
3488   return complit;
3489 }
3490 \f
3491 /* Make TYPE a complete type based on INITIAL_VALUE.
3492    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3493    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3494
3495 int
3496 complete_array_type (tree type, tree initial_value, int do_default)
3497 {
3498   tree maxindex = NULL_TREE;
3499   int value = 0;
3500
3501   if (initial_value)
3502     {
3503       /* Note MAXINDEX  is really the maximum index,
3504          one less than the size.  */
3505       if (TREE_CODE (initial_value) == STRING_CST)