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, 2006, 2007 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, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, 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 #include "pointer-set.h"
  64
  65 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
  66 enum decl_context
  67 { NORMAL,                       /* Ordinary declaration */
  68   FUNCDEF,                      /* Function definition */
  69   PARM,                         /* Declaration of parm before function body */
  70   FIELD,                        /* Declaration inside struct or union */
  71   TYPENAME};                    /* Typename (inside cast or sizeof)  */
  72
  73 \f
  74 /* Nonzero if we have seen an invalid cross reference
  75    to a struct, union, or enum, but not yet printed the message.  */
  76 tree pending_invalid_xref;
  77
  78 /* File and line to appear in the eventual error message.  */
  79 location_t pending_invalid_xref_location;
  80
  81 /* True means we've initialized exception handling.  */
  82 bool c_eh_initialized_p;
  83
  84 /* While defining an enum type, this is 1 plus the last enumerator
  85    constant value.  Note that will do not have to save this or `enum_overflow'
  86    around nested function definition since such a definition could only
  87    occur in an enum value expression and we don't use these variables in
  88    that case.  */
  89
  90 static tree enum_next_value;
  91
  92 /* Nonzero means that there was overflow computing enum_next_value.  */
  93
  94 static int enum_overflow;
  95
  96 /* The file and line that the prototype came from if this is an
  97    old-style definition; used for diagnostics in
  98    store_parm_decls_oldstyle.  */
  99
 100 static location_t current_function_prototype_locus;
 101
 102 /* Whether this prototype was built-in.  */
 103
 104 static bool current_function_prototype_built_in;
 105
 106 /* The argument type information of this prototype.  */
 107
 108 static tree current_function_prototype_arg_types;
 109
 110 /* The argument information structure for the function currently being
 111    defined.  */
 112
 113 static struct c_arg_info *current_function_arg_info;
 114
 115 /* The obstack on which parser and related data structures, which are
 116    not live beyond their top-level declaration or definition, are
 117    allocated.  */
 118 struct obstack parser_obstack;
 119
 120 /* The current statement tree.  */
 121
 122 static GTY(()) struct stmt_tree_s c_stmt_tree;
 123
 124 /* State saving variables.  */
 125 tree c_break_label;
 126 tree c_cont_label;
 127
 128 /* Linked list of TRANSLATION_UNIT_DECLS for the translation units
 129    included in this invocation.  Note that the current translation
 130    unit is not included in this list.  */
 131
 132 static GTY(()) tree all_translation_units;
 133
 134 /* A list of decls to be made automatically visible in each file scope.  */
 135 static GTY(()) tree visible_builtins;
 136
 137 /* Set to 0 at beginning of a function definition, set to 1 if
 138    a return statement that specifies a return value is seen.  */
 139
 140 int current_function_returns_value;
 141
 142 /* Set to 0 at beginning of a function definition, set to 1 if
 143    a return statement with no argument is seen.  */
 144
 145 int current_function_returns_null;
 146
 147 /* Set to 0 at beginning of a function definition, set to 1 if
 148    a call to a noreturn function is seen.  */
 149
 150 int current_function_returns_abnormally;
 151
 152 /* Set to nonzero by `grokdeclarator' for a function
 153    whose return type is defaulted, if warnings for this are desired.  */
 154
 155 static int warn_about_return_type;
 156
 157 /* Nonzero when the current toplevel function contains a declaration
 158    of a nested function which is never defined.  */
 159
 160 static bool undef_nested_function;
 161
 162 /* True means global_bindings_p should return false even if the scope stack
 163    says we are in file scope.  */
 164 bool c_override_global_bindings_to_false;
 165
 166 \f
 167 /* Each c_binding structure describes one binding of an identifier to
 168    a decl.  All the decls in a scope - irrespective of namespace - are
 169    chained together by the ->prev field, which (as the name implies)
 170    runs in reverse order.  All the decls in a given namespace bound to
 171    a given identifier are chained by the ->shadowed field, which runs
 172    from inner to outer scopes.
 173
 174    The ->decl field usually points to a DECL node, but there are two
 175    exceptions.  In the namespace of type tags, the bound entity is a
 176    RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node.  If an undeclared
 177    identifier is encountered, it is bound to error_mark_node to
 178    suppress further errors about that identifier in the current
 179    function.
 180
 181    The ->type field stores the type of the declaration in this scope;
 182    if NULL, the type is the type of the ->decl field.  This is only of
 183    relevance for objects with external or internal linkage which may
 184    be redeclared in inner scopes, forming composite types that only
 185    persist for the duration of those scopes.  In the external scope,
 186    this stores the composite of all the types declared for this
 187    object, visible or not.  The ->inner_comp field (used only at file
 188    scope) stores whether an incomplete array type at file scope was
 189    completed at an inner scope to an array size other than 1.
 190
 191    The depth field is copied from the scope structure that holds this
 192    decl.  It is used to preserve the proper ordering of the ->shadowed
 193    field (see bind()) and also for a handful of special-case checks.
 194    Finally, the invisible bit is true for a decl which should be
 195    ignored for purposes of normal name lookup, and the nested bit is
 196    true for a decl that's been bound a second time in an inner scope;
 197    in all such cases, the binding in the outer scope will have its
 198    invisible bit true.  */
 199
 200 struct c_binding GTY((chain_next ("%h.prev")))
 201 {
 202   tree decl;                    /* the decl bound */
 203   tree type;                    /* the type in this scope */
 204   tree id;                      /* the identifier it's bound to */
 205   struct c_binding *prev;       /* the previous decl in this scope */
 206   struct c_binding *shadowed;   /* the innermost decl shadowed by this one */
 207   unsigned int depth : 28;      /* depth of this scope */
 208   BOOL_BITFIELD invisible : 1;  /* normal lookup should ignore this binding */
 209   BOOL_BITFIELD nested : 1;     /* do not set DECL_CONTEXT when popping */
 210   BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
 211   /* one free bit */
 212 };
 213 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
 214 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
 215 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
 216 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
 217
 218 #define I_SYMBOL_BINDING(node) \
 219   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
 220 #define I_SYMBOL_DECL(node) \
 221  (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
 222
 223 #define I_TAG_BINDING(node) \
 224   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
 225 #define I_TAG_DECL(node) \
 226  (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
 227
 228 #define I_LABEL_BINDING(node) \
 229   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
 230 #define I_LABEL_DECL(node) \
 231  (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
 232
 233 /* Each C symbol points to three linked lists of c_binding structures.
 234    These describe the values of the identifier in the three different
 235    namespaces defined by the language.  */
 236
 237 struct lang_identifier GTY(())
 238 {
 239   struct c_common_identifier common_id;
 240   struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
 241   struct c_binding *tag_binding;    /* struct/union/enum tags */
 242   struct c_binding *label_binding;  /* labels */
 243 };
 244
 245 /* Validate c-lang.c's assumptions.  */
 246 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
 247 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
 248
 249 /* The resulting tree type.  */
 250
 251 union lang_tree_node
 252   GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
 253        chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) GENERIC_NEXT (&%h.generic))")))
 254 {
 255   union tree_node GTY ((tag ("0"),
 256                         desc ("tree_node_structure (&%h)")))
 257     generic;
 258   struct lang_identifier GTY ((tag ("1"))) identifier;
 259 };
 260
 261 /* Each c_scope structure describes the complete contents of one
 262    scope.  Four scopes are distinguished specially: the innermost or
 263    current scope, the innermost function scope, the file scope (always
 264    the second to outermost) and the outermost or external scope.
 265
 266    Most declarations are recorded in the current scope.
 267
 268    All normal label declarations are recorded in the innermost
 269    function scope, as are bindings of undeclared identifiers to
 270    error_mark_node.  (GCC permits nested functions as an extension,
 271    hence the 'innermost' qualifier.)  Explicitly declared labels
 272    (using the __label__ extension) appear in the current scope.
 273
 274    Being in the file scope (current_scope == file_scope) causes
 275    special behavior in several places below.  Also, under some
 276    conditions the Objective-C front end records declarations in the
 277    file scope even though that isn't the current scope.
 278
 279    All declarations with external linkage are recorded in the external
 280    scope, even if they aren't visible there; this models the fact that
 281    such declarations are visible to the entire program, and (with a
 282    bit of cleverness, see pushdecl) allows diagnosis of some violations
 283    of C99 6.2.2p7 and 6.2.7p2:
 284
 285      If, within the same translation unit, the same identifier appears
 286      with both internal and external linkage, the behavior is
 287      undefined.
 288
 289      All declarations that refer to the same object or function shall
 290      have compatible type; otherwise, the behavior is undefined.
 291
 292    Initially only the built-in declarations, which describe compiler
 293    intrinsic functions plus a subset of the standard library, are in
 294    this scope.
 295
 296    The order of the blocks list matters, and it is frequently appended
 297    to.  To avoid having to walk all the way to the end of the list on
 298    each insertion, or reverse the list later, we maintain a pointer to
 299    the last list entry.  (FIXME: It should be feasible to use a reversed
 300    list here.)
 301
 302    The bindings list is strictly in reverse order of declarations;
 303    pop_scope relies on this.  */
 304
 305
 306 struct c_scope GTY((chain_next ("%h.outer")))
 307 {
 308   /* The scope containing this one.  */
 309   struct c_scope *outer;
 310
 311   /* The next outermost function scope.  */
 312   struct c_scope *outer_function;
 313
 314   /* All bindings in this scope.  */
 315   struct c_binding *bindings;
 316
 317   /* For each scope (except the global one), a chain of BLOCK nodes
 318      for all the scopes that were entered and exited one level down.  */
 319   tree blocks;
 320   tree blocks_last;
 321
 322   /* The depth of this scope.  Used to keep the ->shadowed chain of
 323      bindings sorted innermost to outermost.  */
 324   unsigned int depth : 28;
 325
 326   /* True if we are currently filling this scope with parameter
 327      declarations.  */
 328   BOOL_BITFIELD parm_flag : 1;
 329
 330   /* True if we saw [*] in this scope.  Used to give an error messages
 331      if these appears in a function definition.  */
 332   BOOL_BITFIELD had_vla_unspec : 1;
 333
 334   /* True if we already complained about forward parameter decls
 335      in this scope.  This prevents double warnings on
 336      foo (int a; int b; ...)  */
 337   BOOL_BITFIELD warned_forward_parm_decls : 1;
 338
 339   /* True if this is the outermost block scope of a function body.
 340      This scope contains the parameters, the local variables declared
 341      in the outermost block, and all the labels (except those in
 342      nested functions, or declared at block scope with __label__).  */
 343   BOOL_BITFIELD function_body : 1;
 344
 345   /* True means make a BLOCK for this scope no matter what.  */
 346   BOOL_BITFIELD keep : 1;
 347 };
 348
 349 /* The scope currently in effect.  */
 350
 351 static GTY(()) struct c_scope *current_scope;
 352
 353 /* The innermost function scope.  Ordinary (not explicitly declared)
 354    labels, bindings to error_mark_node, and the lazily-created
 355    bindings of __func__ and its friends get this scope.  */
 356
 357 static GTY(()) struct c_scope *current_function_scope;
 358
 359 /* The C file scope.  This is reset for each input translation unit.  */
 360
 361 static GTY(()) struct c_scope *file_scope;
 362
 363 /* The outermost scope.  This is used for all declarations with
 364    external linkage, and only these, hence the name.  */
 365
 366 static GTY(()) struct c_scope *external_scope;
 367
 368 /* A chain of c_scope structures awaiting reuse.  */
 369
 370 static GTY((deletable)) struct c_scope *scope_freelist;
 371
 372 /* A chain of c_binding structures awaiting reuse.  */
 373
 374 static GTY((deletable)) struct c_binding *binding_freelist;
 375
 376 /* Append VAR to LIST in scope SCOPE.  */
 377 #define SCOPE_LIST_APPEND(scope, list, decl) do {       \
 378   struct c_scope *s_ = (scope);                         \
 379   tree d_ = (decl);                                     \
 380   if (s_->list##_last)                                  \
 381     TREE_CHAIN (s_->list##_last) = d_;                  \
 382   else                                                  \
 383     s_->list = d_;                                      \
 384   s_->list##_last = d_;                                 \
 385 } while (0)
 386
 387 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE.  */
 388 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {        \
 389   struct c_scope *t_ = (tscope);                                \
 390   struct c_scope *f_ = (fscope);                                \
 391   if (t_->to##_last)                                            \
 392     TREE_CHAIN (t_->to##_last) = f_->from;                      \
 393   else                                                          \
 394     t_->to = f_->from;                                          \
 395   t_->to##_last = f_->from##_last;                              \
 396 } while (0)
 397
 398 /* True means unconditionally make a BLOCK for the next scope pushed.  */
 399
 400 static bool keep_next_level_flag;
 401
 402 /* True means the next call to push_scope will be the outermost scope
 403    of a function body, so do not push a new scope, merely cease
 404    expecting parameter decls.  */
 405
 406 static bool next_is_function_body;
 407
 408 /* Forward declarations.  */
 409 static tree lookup_name_in_scope (tree, struct c_scope *);
 410 static tree c_make_fname_decl (tree, int);
 411 static tree grokdeclarator (const struct c_declarator *,
 412                             struct c_declspecs *,
 413                             enum decl_context, bool, tree *);
 414 static tree grokparms (struct c_arg_info *, bool);
 415 static void layout_array_type (tree);
 416 \f
 417 /* T is a statement.  Add it to the statement-tree.  This is the
 418    C/ObjC version--C++ has a slightly different version of this
 419    function.  */
 420
 421 tree
 422 add_stmt (tree t)
 423 {
 424   enum tree_code code = TREE_CODE (t);
 425
 426   if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
 427     {
 428       if (!EXPR_HAS_LOCATION (t))
 429         SET_EXPR_LOCATION (t, input_location);
 430     }
 431
 432   if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
 433     STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
 434
 435   /* Add T to the statement-tree.  Non-side-effect statements need to be
 436      recorded during statement expressions.  */
 437   append_to_statement_list_force (t, &cur_stmt_list);
 438
 439   return t;
 440 }
 441 \f
 442 /* States indicating how grokdeclarator() should handle declspecs marked
 443    with __attribute__((deprecated)).  An object declared as
 444    __attribute__((deprecated)) suppresses warnings of uses of other
 445    deprecated items.  */
 446
 447 enum deprecated_states {
 448   DEPRECATED_NORMAL,
 449   DEPRECATED_SUPPRESS
 450 };
 451
 452 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 453
 454 void
 455 c_print_identifier (FILE *file, tree node, int indent)
 456 {
 457   print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
 458   print_node (file, "tag", I_TAG_DECL (node), indent + 4);
 459   print_node (file, "label", I_LABEL_DECL (node), indent + 4);
 460   if (C_IS_RESERVED_WORD (node))
 461     {
 462       tree rid = ridpointers[C_RID_CODE (node)];
 463       indent_to (file, indent + 4);
 464       fprintf (file, "rid %p \"%s\"",
 465                (void *) rid, IDENTIFIER_POINTER (rid));
 466     }
 467 }
 468
 469 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
 470    which may be any of several kinds of DECL or TYPE or error_mark_node,
 471    in the scope SCOPE.  */
 472 static void
 473 bind (tree name, tree decl, struct c_scope *scope, bool invisible, bool nested)
 474 {
 475   struct c_binding *b, **here;
 476
 477   if (binding_freelist)
 478     {
 479       b = binding_freelist;
 480       binding_freelist = b->prev;
 481     }
 482   else
 483     b = GGC_NEW (struct c_binding);
 484
 485   b->shadowed = 0;
 486   b->decl = decl;
 487   b->id = name;
 488   b->depth = scope->depth;
 489   b->invisible = invisible;
 490   b->nested = nested;
 491   b->inner_comp = 0;
 492
 493   b->type = 0;
 494
 495   b->prev = scope->bindings;
 496   scope->bindings = b;
 497
 498   if (!name)
 499     return;
 500
 501   switch (TREE_CODE (decl))
 502     {
 503     case LABEL_DECL:     here = &I_LABEL_BINDING (name);   break;
 504     case ENUMERAL_TYPE:
 505     case UNION_TYPE:
 506     case RECORD_TYPE:    here = &I_TAG_BINDING (name);     break;
 507     case VAR_DECL:
 508     case FUNCTION_DECL:
 509     case TYPE_DECL:
 510     case CONST_DECL:
 511     case PARM_DECL:
 512     case ERROR_MARK:     here = &I_SYMBOL_BINDING (name);  break;
 513
 514     default:
 515       gcc_unreachable ();
 516     }
 517
 518   /* Locate the appropriate place in the chain of shadowed decls
 519      to insert this binding.  Normally, scope == current_scope and
 520      this does nothing.  */
 521   while (*here && (*here)->depth > scope->depth)
 522     here = &(*here)->shadowed;
 523
 524   b->shadowed = *here;
 525   *here = b;
 526 }
 527
 528 /* Clear the binding structure B, stick it on the binding_freelist,
 529    and return the former value of b->prev.  This is used by pop_scope
 530    and get_parm_info to iterate destructively over all the bindings
 531    from a given scope.  */
 532 static struct c_binding *
 533 free_binding_and_advance (struct c_binding *b)
 534 {
 535   struct c_binding *prev = b->prev;
 536
 537   memset (b, 0, sizeof (struct c_binding));
 538   b->prev = binding_freelist;
 539   binding_freelist = b;
 540
 541   return prev;
 542 }
 543
 544 \f
 545 /* Hook called at end of compilation to assume 1 elt
 546    for a file-scope tentative array defn that wasn't complete before.  */
 547
 548 void
 549 c_finish_incomplete_decl (tree decl)
 550 {
 551   if (TREE_CODE (decl) == VAR_DECL)
 552     {
 553       tree type = TREE_TYPE (decl);
 554       if (type != error_mark_node
 555           && TREE_CODE (type) == ARRAY_TYPE
 556           && !DECL_EXTERNAL (decl)
 557           && TYPE_DOMAIN (type) == 0)
 558         {
 559           warning (0, "array %q+D assumed to have one element", decl);
 560
 561           complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
 562
 563           layout_decl (decl, 0);
 564         }
 565     }
 566 }
 567 \f
 568 /* The Objective-C front-end often needs to determine the current scope.  */
 569
 570 void *
 571 objc_get_current_scope (void)
 572 {
 573   return current_scope;
 574 }
 575
 576 /* The following function is used only by Objective-C.  It needs to live here
 577    because it accesses the innards of c_scope.  */
 578
 579 void
 580 objc_mark_locals_volatile (void *enclosing_blk)
 581 {
 582   struct c_scope *scope;
 583   struct c_binding *b;
 584
 585   for (scope = current_scope;
 586        scope && scope != enclosing_blk;
 587        scope = scope->outer)
 588     {
 589       for (b = scope->bindings; b; b = b->prev)
 590         objc_volatilize_decl (b->decl);
 591
 592       /* Do not climb up past the current function.  */
 593       if (scope->function_body)
 594         break;
 595     }
 596 }
 597
 598 /* Nonzero if we are currently in file scope.  */
 599
 600 int
 601 global_bindings_p (void)
 602 {
 603   return current_scope == file_scope && !c_override_global_bindings_to_false;
 604 }
 605
 606 void
 607 keep_next_level (void)
 608 {
 609   keep_next_level_flag = true;
 610 }
 611
 612 /* Identify this scope as currently being filled with parameters.  */
 613
 614 void
 615 declare_parm_level (void)
 616 {
 617   current_scope->parm_flag = true;
 618 }
 619
 620 void
 621 push_scope (void)
 622 {
 623   if (next_is_function_body)
 624     {
 625       /* This is the transition from the parameters to the top level
 626          of the function body.  These are the same scope
 627          (C99 6.2.1p4,6) so we do not push another scope structure.
 628          next_is_function_body is set only by store_parm_decls, which
 629          in turn is called when and only when we are about to
 630          encounter the opening curly brace for the function body.
 631
 632          The outermost block of a function always gets a BLOCK node,
 633          because the debugging output routines expect that each
 634          function has at least one BLOCK.  */
 635       current_scope->parm_flag         = false;
 636       current_scope->function_body     = true;
 637       current_scope->keep              = true;
 638       current_scope->outer_function    = current_function_scope;
 639       current_function_scope           = current_scope;
 640
 641       keep_next_level_flag = false;
 642       next_is_function_body = false;
 643     }
 644   else
 645     {
 646       struct c_scope *scope;
 647       if (scope_freelist)
 648         {
 649           scope = scope_freelist;
 650           scope_freelist = scope->outer;
 651         }
 652       else
 653         scope = GGC_CNEW (struct c_scope);
 654
 655       scope->keep          = keep_next_level_flag;
 656       scope->outer         = current_scope;
 657       scope->depth         = current_scope ? (current_scope->depth + 1) : 0;
 658
 659       /* Check for scope depth overflow.  Unlikely (2^28 == 268,435,456) but
 660          possible.  */
 661       if (current_scope && scope->depth == 0)
 662         {
 663           scope->depth--;
 664           sorry ("GCC supports only %u nested scopes", scope->depth);
 665         }
 666
 667       current_scope        = scope;
 668       keep_next_level_flag = false;
 669     }
 670 }
 671
 672 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT.  */
 673
 674 static void
 675 set_type_context (tree type, tree context)
 676 {
 677   for (type = TYPE_MAIN_VARIANT (type); type;
 678        type = TYPE_NEXT_VARIANT (type))
 679     TYPE_CONTEXT (type) = context;
 680 }
 681
 682 /* Exit a scope.  Restore the state of the identifier-decl mappings
 683    that were in effect when this scope was entered.  Return a BLOCK
 684    node containing all the DECLs in this scope that are of interest
 685    to debug info generation.  */
 686
 687 tree
 688 pop_scope (void)
 689 {
 690   struct c_scope *scope = current_scope;
 691   tree block, context, p;
 692   struct c_binding *b;
 693
 694   bool functionbody = scope->function_body;
 695   bool keep = functionbody || scope->keep || scope->bindings;
 696
 697   c_end_vm_scope (scope->depth);
 698
 699   /* If appropriate, create a BLOCK to record the decls for the life
 700      of this function.  */
 701   block = 0;
 702   if (keep)
 703     {
 704       block = make_node (BLOCK);
 705       BLOCK_SUBBLOCKS (block) = scope->blocks;
 706       TREE_USED (block) = 1;
 707
 708       /* In each subblock, record that this is its superior.  */
 709       for (p = scope->blocks; p; p = TREE_CHAIN (p))
 710         BLOCK_SUPERCONTEXT (p) = block;
 711
 712       BLOCK_VARS (block) = 0;
 713     }
 714
 715   /* The TYPE_CONTEXTs for all of the tagged types belonging to this
 716      scope must be set so that they point to the appropriate
 717      construct, i.e.  either to the current FUNCTION_DECL node, or
 718      else to the BLOCK node we just constructed.
 719
 720      Note that for tagged types whose scope is just the formal
 721      parameter list for some function type specification, we can't
 722      properly set their TYPE_CONTEXTs here, because we don't have a
 723      pointer to the appropriate FUNCTION_TYPE node readily available
 724      to us.  For those cases, the TYPE_CONTEXTs of the relevant tagged
 725      type nodes get set in `grokdeclarator' as soon as we have created
 726      the FUNCTION_TYPE node which will represent the "scope" for these
 727      "parameter list local" tagged types.  */
 728   if (scope->function_body)
 729     context = current_function_decl;
 730   else if (scope == file_scope)
 731     {
 732       tree file_decl = build_decl (TRANSLATION_UNIT_DECL, 0, 0);
 733       TREE_CHAIN (file_decl) = all_translation_units;
 734       all_translation_units = file_decl;
 735       context = file_decl;
 736     }
 737   else
 738     context = block;
 739
 740   /* Clear all bindings in this scope.  */
 741   for (b = scope->bindings; b; b = free_binding_and_advance (b))
 742     {
 743       p = b->decl;
 744       switch (TREE_CODE (p))
 745         {
 746         case LABEL_DECL:
 747           /* Warnings for unused labels, errors for undefined labels.  */
 748           if (TREE_USED (p) && !DECL_INITIAL (p))
 749             {
 750               error ("label %q+D used but not defined", p);
 751               DECL_INITIAL (p) = error_mark_node;
 752             }
 753           else
 754             warn_for_unused_label (p);
 755
 756           /* Labels go in BLOCK_VARS.  */
 757           TREE_CHAIN (p) = BLOCK_VARS (block);
 758           BLOCK_VARS (block) = p;
 759           gcc_assert (I_LABEL_BINDING (b->id) == b);
 760           I_LABEL_BINDING (b->id) = b->shadowed;
 761           break;
 762
 763         case ENUMERAL_TYPE:
 764         case UNION_TYPE:
 765         case RECORD_TYPE:
 766           set_type_context (p, context);
 767
 768           /* Types may not have tag-names, in which case the type
 769              appears in the bindings list with b->id NULL.  */
 770           if (b->id)
 771             {
 772               gcc_assert (I_TAG_BINDING (b->id) == b);
 773               I_TAG_BINDING (b->id) = b->shadowed;
 774             }
 775           break;
 776
 777         case FUNCTION_DECL:
 778           /* Propagate TREE_ADDRESSABLE from nested functions to their
 779              containing functions.  */
 780           if (!TREE_ASM_WRITTEN (p)
 781               && DECL_INITIAL (p) != 0
 782               && TREE_ADDRESSABLE (p)
 783               && DECL_ABSTRACT_ORIGIN (p) != 0
 784               && DECL_ABSTRACT_ORIGIN (p) != p)
 785             TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
 786           if (!DECL_EXTERNAL (p)
 787               && !DECL_INITIAL (p)
 788               && scope != file_scope
 789               && scope != external_scope)
 790             {
 791               error ("nested function %q+D declared but never defined", p);
 792               undef_nested_function = true;
 793             }
 794           /* C99 6.7.4p6: "a function with external linkage... declared
 795              with an inline function specifier ... shall also be defined in the
 796              same translation unit."  */
 797           else if (DECL_DECLARED_INLINE_P (p)
 798                    && TREE_PUBLIC (p)
 799                    && !DECL_INITIAL (p)
 800                    && !flag_gnu89_inline)
 801             pedwarn ("inline function %q+D declared but never defined", p);
 802
 803           goto common_symbol;
 804
 805         case VAR_DECL:
 806           /* Warnings for unused variables.  */
 807           if (!TREE_USED (p)
 808               && !TREE_NO_WARNING (p)
 809               && !DECL_IN_SYSTEM_HEADER (p)
 810               && DECL_NAME (p)
 811               && !DECL_ARTIFICIAL (p)
 812               && scope != file_scope
 813               && scope != external_scope)
 814             warning (OPT_Wunused_variable, "unused variable %q+D", p);
 815
 816           if (b->inner_comp)
 817             {
 818               error ("type of array %q+D completed incompatibly with"
 819                      " implicit initialization", p);
 820             }
 821
 822           /* Fall through.  */
 823         case TYPE_DECL:
 824         case CONST_DECL:
 825         common_symbol:
 826           /* All of these go in BLOCK_VARS, but only if this is the
 827              binding in the home scope.  */
 828           if (!b->nested)
 829             {
 830               TREE_CHAIN (p) = BLOCK_VARS (block);
 831               BLOCK_VARS (block) = p;
 832             }
 833           /* If this is the file scope, and we are processing more
 834              than one translation unit in this compilation, set
 835              DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
 836              This makes same_translation_unit_p work, and causes
 837              static declarations to be given disambiguating suffixes.  */
 838           if (scope == file_scope && num_in_fnames > 1)
 839             {
 840               DECL_CONTEXT (p) = context;
 841               if (TREE_CODE (p) == TYPE_DECL)
 842                 set_type_context (TREE_TYPE (p), context);
 843             }
 844
 845           /* Fall through.  */
 846           /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
 847              already been put there by store_parm_decls.  Unused-
 848              parameter warnings are handled by function.c.
 849              error_mark_node obviously does not go in BLOCK_VARS and
 850              does not get unused-variable warnings.  */
 851         case PARM_DECL:
 852         case ERROR_MARK:
 853           /* It is possible for a decl not to have a name.  We get
 854              here with b->id NULL in this case.  */
 855           if (b->id)
 856             {
 857               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
 858               I_SYMBOL_BINDING (b->id) = b->shadowed;
 859               if (b->shadowed && b->shadowed->type)
 860                 TREE_TYPE (b->shadowed->decl) = b->shadowed->type;
 861             }
 862           break;
 863
 864         default:
 865           gcc_unreachable ();
 866         }
 867     }
 868
 869
 870   /* Dispose of the block that we just made inside some higher level.  */
 871   if ((scope->function_body || scope == file_scope) && context)
 872     {
 873       DECL_INITIAL (context) = block;
 874       BLOCK_SUPERCONTEXT (block) = context;
 875     }
 876   else if (scope->outer)
 877     {
 878       if (block)
 879         SCOPE_LIST_APPEND (scope->outer, blocks, block);
 880       /* If we did not make a block for the scope just exited, any
 881          blocks made for inner scopes must be carried forward so they
 882          will later become subblocks of something else.  */
 883       else if (scope->blocks)
 884         SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
 885     }
 886
 887   /* Pop the current scope, and free the structure for reuse.  */
 888   current_scope = scope->outer;
 889   if (scope->function_body)
 890     current_function_scope = scope->outer_function;
 891
 892   memset (scope, 0, sizeof (struct c_scope));
 893   scope->outer = scope_freelist;
 894   scope_freelist = scope;
 895
 896   return block;
 897 }
 898
 899 void
 900 push_file_scope (void)
 901 {
 902   tree decl;
 903
 904   if (file_scope)
 905     return;
 906
 907   push_scope ();
 908   file_scope = current_scope;
 909
 910   start_fname_decls ();
 911
 912   for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
 913     bind (DECL_NAME (decl), decl, file_scope,
 914           /*invisible=*/false, /*nested=*/true);
 915 }
 916
 917 void
 918 pop_file_scope (void)
 919 {
 920   /* In case there were missing closebraces, get us back to the global
 921      binding level.  */
 922   while (current_scope != file_scope)
 923     pop_scope ();
 924
 925   /* __FUNCTION__ is defined at file scope ("").  This
 926      call may not be necessary as my tests indicate it
 927      still works without it.  */
 928   finish_fname_decls ();
 929
 930   /* This is the point to write out a PCH if we're doing that.
 931      In that case we do not want to do anything else.  */
 932   if (pch_file)
 933     {
 934       c_common_write_pch ();
 935       return;
 936     }
 937
 938   /* Pop off the file scope and close this translation unit.  */
 939   pop_scope ();
 940   file_scope = 0;
 941
 942   maybe_apply_pending_pragma_weaks ();
 943   cgraph_finalize_compilation_unit ();
 944 }
 945
 946 /* Insert BLOCK at the end of the list of subblocks of the current
 947    scope.  This is used when a BIND_EXPR is expanded, to handle the
 948    BLOCK node inside the BIND_EXPR.  */
 949
 950 void
 951 insert_block (tree block)
 952 {
 953   TREE_USED (block) = 1;
 954   SCOPE_LIST_APPEND (current_scope, blocks, block);
 955 }
 956 \f
 957 /* Push a definition or a declaration of struct, union or enum tag "name".
 958    "type" should be the type node.
 959    We assume that the tag "name" is not already defined.
 960
 961    Note that the definition may really be just a forward reference.
 962    In that case, the TYPE_SIZE will be zero.  */
 963
 964 static void
 965 pushtag (tree name, tree type)
 966 {
 967   /* Record the identifier as the type's name if it has none.  */
 968   if (name && !TYPE_NAME (type))
 969     TYPE_NAME (type) = name;
 970   bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false);
 971
 972   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
 973      tagged type we just added to the current scope.  This fake
 974      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
 975      to output a representation of a tagged type, and it also gives
 976      us a convenient place to record the "scope start" address for the
 977      tagged type.  */
 978
 979   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
 980
 981   /* An approximation for now, so we can tell this is a function-scope tag.
 982      This will be updated in pop_scope.  */
 983   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
 984 }
 985 \f
 986 /* Subroutine of compare_decls.  Allow harmless mismatches in return
 987    and argument types provided that the type modes match.  This function
 988    return a unified type given a suitable match, and 0 otherwise.  */
 989
 990 static tree
 991 match_builtin_function_types (tree newtype, tree oldtype)
 992 {
 993   tree newrettype, oldrettype;
 994   tree newargs, oldargs;
 995   tree trytype, tryargs;
 996
 997   /* Accept the return type of the new declaration if same modes.  */
 998   oldrettype = TREE_TYPE (oldtype);
 999   newrettype = TREE_TYPE (newtype);
1000
1001   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1002     return 0;
1003
1004   oldargs = TYPE_ARG_TYPES (oldtype);
1005   newargs = TYPE_ARG_TYPES (newtype);
1006   tryargs = newargs;
1007
1008   while (oldargs || newargs)
1009     {
1010       if (!oldargs
1011           || !newargs
1012           || !TREE_VALUE (oldargs)
1013           || !TREE_VALUE (newargs)
1014           || TYPE_MODE (TREE_VALUE (oldargs))
1015              != TYPE_MODE (TREE_VALUE (newargs)))
1016         return 0;
1017
1018       oldargs = TREE_CHAIN (oldargs);
1019       newargs = TREE_CHAIN (newargs);
1020     }
1021
1022   trytype = build_function_type (newrettype, tryargs);
1023   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1024 }
1025
1026 /* Subroutine of diagnose_mismatched_decls.  Check for function type
1027    mismatch involving an empty arglist vs a nonempty one and give clearer
1028    diagnostics.  */
1029 static void
1030 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1031                            tree newtype, tree oldtype)
1032 {
1033   tree t;
1034
1035   if (TREE_CODE (olddecl) != FUNCTION_DECL
1036       || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1037       || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1038            ||
1039            (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1040     return;
1041
1042   t = TYPE_ARG_TYPES (oldtype);
1043   if (t == 0)
1044     t = TYPE_ARG_TYPES (newtype);
1045   for (; t; t = TREE_CHAIN (t))
1046     {
1047       tree type = TREE_VALUE (t);
1048
1049       if (TREE_CHAIN (t) == 0
1050           && TYPE_MAIN_VARIANT (type) != void_type_node)
1051         {
1052           inform ("a parameter list with an ellipsis can%'t match "
1053                   "an empty parameter name list declaration");
1054           break;
1055         }
1056
1057       if (c_type_promotes_to (type) != type)
1058         {
1059           inform ("an argument type that has a default promotion can%'t match "
1060                   "an empty parameter name list declaration");
1061           break;
1062         }
1063     }
1064 }
1065
1066 /* Another subroutine of diagnose_mismatched_decls.  OLDDECL is an
1067    old-style function definition, NEWDECL is a prototype declaration.
1068    Diagnose inconsistencies in the argument list.  Returns TRUE if
1069    the prototype is compatible, FALSE if not.  */
1070 static bool
1071 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1072 {
1073   tree newargs, oldargs;
1074   int i;
1075
1076 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1077
1078   oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1079   newargs = TYPE_ARG_TYPES (newtype);
1080   i = 1;
1081
1082   for (;;)
1083     {
1084       tree oldargtype = TREE_VALUE (oldargs);
1085       tree newargtype = TREE_VALUE (newargs);
1086
1087       if (oldargtype == error_mark_node || newargtype == error_mark_node)
1088         return false;
1089
1090       oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1091       newargtype = TYPE_MAIN_VARIANT (newargtype);
1092
1093       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1094         break;
1095
1096       /* Reaching the end of just one list means the two decls don't
1097          agree on the number of arguments.  */
1098       if (END_OF_ARGLIST (oldargtype))
1099         {
1100           error ("prototype for %q+D declares more arguments "
1101                  "than previous old-style definition", newdecl);
1102           return false;
1103         }
1104       else if (END_OF_ARGLIST (newargtype))
1105         {
1106           error ("prototype for %q+D declares fewer arguments "
1107                  "than previous old-style definition", newdecl);
1108           return false;
1109         }
1110
1111       /* Type for passing arg must be consistent with that declared
1112          for the arg.  */
1113       else if (!comptypes (oldargtype, newargtype))
1114         {
1115           error ("prototype for %q+D declares argument %d"
1116                  " with incompatible type",
1117                  newdecl, i);
1118           return false;
1119         }
1120
1121       oldargs = TREE_CHAIN (oldargs);
1122       newargs = TREE_CHAIN (newargs);
1123       i++;
1124     }
1125
1126   /* If we get here, no errors were found, but do issue a warning
1127      for this poor-style construct.  */
1128   warning (0, "prototype for %q+D follows non-prototype definition",
1129            newdecl);
1130   return true;
1131 #undef END_OF_ARGLIST
1132 }
1133
1134 /* Subroutine of diagnose_mismatched_decls.  Report the location of DECL,
1135    first in a pair of mismatched declarations, using the diagnostic
1136    function DIAG.  */
1137 static void
1138 locate_old_decl (tree decl, void (*diag)(const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2))
1139 {
1140   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1141     ;
1142   else if (DECL_INITIAL (decl))
1143     diag (G_("previous definition of %q+D was here"), decl);
1144   else if (C_DECL_IMPLICIT (decl))
1145     diag (G_("previous implicit declaration of %q+D was here"), decl);
1146   else
1147     diag (G_("previous declaration of %q+D was here"), decl);
1148 }
1149
1150 /* Subroutine of duplicate_decls.  Compare NEWDECL to OLDDECL.
1151    Returns true if the caller should proceed to merge the two, false
1152    if OLDDECL should simply be discarded.  As a side effect, issues
1153    all necessary diagnostics for invalid or poor-style combinations.
1154    If it returns true, writes the types of NEWDECL and OLDDECL to
1155    *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1156    TREE_TYPE (NEWDECL, OLDDECL) respectively.  */
1157
1158 static bool
1159 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1160                            tree *newtypep, tree *oldtypep)
1161 {
1162   tree newtype, oldtype;
1163   bool pedwarned = false;
1164   bool warned = false;
1165   bool retval = true;
1166
1167 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL)  \
1168                                   && DECL_EXTERNAL (DECL))
1169
1170   /* If we have error_mark_node for either decl or type, just discard
1171      the previous decl - we're in an error cascade already.  */
1172   if (olddecl == error_mark_node || newdecl == error_mark_node)
1173     return false;
1174   *oldtypep = oldtype = TREE_TYPE (olddecl);
1175   *newtypep = newtype = TREE_TYPE (newdecl);
1176   if (oldtype == error_mark_node || newtype == error_mark_node)
1177     return false;
1178
1179   /* Two different categories of symbol altogether.  This is an error
1180      unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
1181   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1182     {
1183       if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1184             && DECL_BUILT_IN (olddecl)
1185             && !C_DECL_DECLARED_BUILTIN (olddecl)))
1186         {
1187           error ("%q+D redeclared as different kind of symbol", newdecl);
1188           locate_old_decl (olddecl, error);
1189         }
1190       else if (TREE_PUBLIC (newdecl))
1191         warning (0, "built-in function %q+D declared as non-function",
1192                  newdecl);
1193       else
1194         warning (OPT_Wshadow, "declaration of %q+D shadows "
1195                  "a built-in function", newdecl);
1196       return false;
1197     }
1198
1199   /* Enumerators have no linkage, so may only be declared once in a
1200      given scope.  */
1201   if (TREE_CODE (olddecl) == CONST_DECL)
1202     {
1203       error ("redeclaration of enumerator %q+D", newdecl);
1204       locate_old_decl (olddecl, error);
1205       return false;
1206     }
1207
1208   if (!comptypes (oldtype, newtype))
1209     {
1210       if (TREE_CODE (olddecl) == FUNCTION_DECL
1211           && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1212         {
1213           /* Accept harmless mismatch in function types.
1214              This is for the ffs and fprintf builtins.  */
1215           tree trytype = match_builtin_function_types (newtype, oldtype);
1216
1217           if (trytype && comptypes (newtype, trytype))
1218             *oldtypep = oldtype = trytype;
1219           else
1220             {
1221               /* If types don't match for a built-in, throw away the
1222                  built-in.  No point in calling locate_old_decl here, it
1223                  won't print anything.  */
1224               warning (0, "conflicting types for built-in function %q+D",
1225                        newdecl);
1226               return false;
1227             }
1228         }
1229       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1230                && DECL_IS_BUILTIN (olddecl))
1231         {
1232           /* A conflicting function declaration for a predeclared
1233              function that isn't actually built in.  Objective C uses
1234              these.  The new declaration silently overrides everything
1235              but the volatility (i.e. noreturn) indication.  See also
1236              below.  FIXME: Make Objective C use normal builtins.  */
1237           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1238           return false;
1239         }
1240       /* Permit void foo (...) to match int foo (...) if the latter is
1241          the definition and implicit int was used.  See
1242          c-torture/compile/920625-2.c.  */
1243       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1244                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1245                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1246                && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1247         {
1248           pedwarn ("conflicting types for %q+D", newdecl);
1249           /* Make sure we keep void as the return type.  */
1250           TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1251           C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1252           pedwarned = true;
1253         }
1254       /* Permit void foo (...) to match an earlier call to foo (...) with
1255          no declared type (thus, implicitly int).  */
1256       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1257                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1258                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1259                && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1260         {
1261           pedwarn ("conflicting types for %q+D", newdecl);
1262           /* Make sure we keep void as the return type.  */
1263           TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1264           pedwarned = true;
1265         }
1266       else
1267         {
1268           if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
1269             error ("conflicting type qualifiers for %q+D", newdecl);
1270           else
1271             error ("conflicting types for %q+D", newdecl);
1272           diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1273           locate_old_decl (olddecl, error);
1274           return false;
1275         }
1276     }
1277
1278   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1279      but silently ignore the redeclaration if either is in a system
1280      header.  (Conflicting redeclarations were handled above.)  */
1281   if (TREE_CODE (newdecl) == TYPE_DECL)
1282     {
1283       if (DECL_IN_SYSTEM_HEADER (newdecl) || DECL_IN_SYSTEM_HEADER (olddecl))
1284         return true;  /* Allow OLDDECL to continue in use.  */
1285
1286       error ("redefinition of typedef %q+D", newdecl);
1287       locate_old_decl (olddecl, error);
1288       return false;
1289     }
1290
1291   /* Function declarations can either be 'static' or 'extern' (no
1292      qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1293      can never conflict with each other on account of linkage
1294      (6.2.2p4).  Multiple definitions are not allowed (6.9p3,5) but
1295      gnu89 mode permits two definitions if one is 'extern inline' and
1296      one is not.  The non- extern-inline definition supersedes the
1297      extern-inline definition.  */
1298
1299   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1300     {
1301       /* If you declare a built-in function name as static, or
1302          define the built-in with an old-style definition (so we
1303          can't validate the argument list) the built-in definition is
1304          overridden, but optionally warn this was a bad choice of name.  */
1305       if (DECL_BUILT_IN (olddecl)
1306           && !C_DECL_DECLARED_BUILTIN (olddecl)
1307           && (!TREE_PUBLIC (newdecl)
1308               || (DECL_INITIAL (newdecl)
1309                   && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1310         {
1311           warning (OPT_Wshadow, "declaration of %q+D shadows "
1312                    "a built-in function", newdecl);
1313           /* Discard the old built-in function.  */
1314           return false;
1315         }
1316
1317       if (DECL_INITIAL (newdecl))
1318         {
1319           if (DECL_INITIAL (olddecl))
1320             {
1321               /* If both decls are in the same TU and the new declaration
1322                  isn't overriding an extern inline reject the new decl.
1323                  In c99, no overriding is allowed in the same translation
1324                  unit.  */
1325               if ((!DECL_EXTERN_INLINE (olddecl)
1326                    || DECL_EXTERN_INLINE (newdecl)
1327                    || (!flag_gnu89_inline
1328                        && (!DECL_DECLARED_INLINE_P (olddecl)
1329                            || !lookup_attribute ("gnu_inline",
1330                                                  DECL_ATTRIBUTES (olddecl)))
1331                        && (!DECL_DECLARED_INLINE_P (newdecl)
1332                            || !lookup_attribute ("gnu_inline",
1333                                                  DECL_ATTRIBUTES (newdecl))))
1334                   )
1335                   && same_translation_unit_p (newdecl, olddecl))
1336                 {
1337                   error ("redefinition of %q+D", newdecl);
1338                   locate_old_decl (olddecl, error);
1339                   return false;
1340                 }
1341             }
1342         }
1343       /* If we have a prototype after an old-style function definition,
1344          the argument types must be checked specially.  */
1345       else if (DECL_INITIAL (olddecl)
1346                && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1347                && TYPE_ACTUAL_ARG_TYPES (oldtype)
1348                && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1349         {
1350           locate_old_decl (olddecl, error);
1351           return false;
1352         }
1353       /* A non-static declaration (even an "extern") followed by a
1354          static declaration is undefined behavior per C99 6.2.2p3-5,7.
1355          The same is true for a static forward declaration at block
1356          scope followed by a non-static declaration/definition at file
1357          scope.  Static followed by non-static at the same scope is
1358          not undefined behavior, and is the most convenient way to get
1359          some effects (see e.g.  what unwind-dw2-fde-glibc.c does to
1360          the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1361          we do diagnose it if -Wtraditional.  */
1362       if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1363         {
1364           /* Two exceptions to the rule.  If olddecl is an extern
1365              inline, or a predeclared function that isn't actually
1366              built in, newdecl silently overrides olddecl.  The latter
1367              occur only in Objective C; see also above.  (FIXME: Make
1368              Objective C use normal builtins.)  */
1369           if (!DECL_IS_BUILTIN (olddecl)
1370               && !DECL_EXTERN_INLINE (olddecl))
1371             {
1372               error ("static declaration of %q+D follows "
1373                      "non-static declaration", newdecl);
1374               locate_old_decl (olddecl, error);
1375             }
1376           return false;
1377         }
1378       else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1379         {
1380           if (DECL_CONTEXT (olddecl))
1381             {
1382               error ("non-static declaration of %q+D follows "
1383                      "static declaration", newdecl);
1384               locate_old_decl (olddecl, error);
1385               return false;
1386             }
1387           else if (warn_traditional)
1388             {
1389               warning (OPT_Wtraditional, "non-static declaration of %q+D "
1390                        "follows static declaration", newdecl);
1391               warned = true;
1392             }
1393         }
1394
1395       /* Make sure gnu_inline attribute is either not present, or
1396          present on all inline decls.  */
1397       if (DECL_DECLARED_INLINE_P (olddecl)
1398           && DECL_DECLARED_INLINE_P (newdecl))
1399         {
1400           bool newa = lookup_attribute ("gnu_inline",
1401                                         DECL_ATTRIBUTES (newdecl)) != NULL;
1402           bool olda = lookup_attribute ("gnu_inline",
1403                                         DECL_ATTRIBUTES (olddecl)) != NULL;
1404           if (newa != olda)
1405             {
1406               error ("%<gnu_inline%> attribute present on %q+D",
1407                      newa ? newdecl : olddecl);
1408               error ("%Jbut not here", newa ? olddecl : newdecl);
1409             }
1410         }
1411     }
1412   else if (TREE_CODE (newdecl) == VAR_DECL)
1413     {
1414       /* Only variables can be thread-local, and all declarations must
1415          agree on this property.  */
1416       if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
1417         {
1418           /* Nothing to check.  Since OLDDECL is marked threadprivate
1419              and NEWDECL does not have a thread-local attribute, we
1420              will merge the threadprivate attribute into NEWDECL.  */
1421           ;
1422         }
1423       else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1424         {
1425           if (DECL_THREAD_LOCAL_P (newdecl))
1426             error ("thread-local declaration of %q+D follows "
1427                    "non-thread-local declaration", newdecl);
1428           else
1429             error ("non-thread-local declaration of %q+D follows "
1430                    "thread-local declaration", newdecl);
1431
1432           locate_old_decl (olddecl, error);
1433           return false;
1434         }
1435
1436       /* Multiple initialized definitions are not allowed (6.9p3,5).  */
1437       if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1438         {
1439           error ("redefinition of %q+D", newdecl);
1440           locate_old_decl (olddecl, error);
1441           return false;
1442         }
1443
1444       /* Objects declared at file scope: if the first declaration had
1445          external linkage (even if it was an external reference) the
1446          second must have external linkage as well, or the behavior is
1447          undefined.  If the first declaration had internal linkage, then
1448          the second must too, or else be an external reference (in which
1449          case the composite declaration still has internal linkage).
1450          As for function declarations, we warn about the static-then-
1451          extern case only for -Wtraditional.  See generally 6.2.2p3-5,7.  */
1452       if (DECL_FILE_SCOPE_P (newdecl)
1453           && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1454         {
1455           if (DECL_EXTERNAL (newdecl))
1456             {
1457               if (!DECL_FILE_SCOPE_P (olddecl))
1458                 {
1459                   error ("extern declaration of %q+D follows "
1460                          "declaration with no linkage", newdecl);
1461                   locate_old_decl (olddecl, error);
1462                   return false;
1463                 }
1464               else if (warn_traditional)
1465                 {
1466                   warning (OPT_Wtraditional, "non-static declaration of %q+D "
1467                            "follows static declaration", newdecl);
1468                   warned = true;
1469                 }
1470             }
1471           else
1472             {
1473               if (TREE_PUBLIC (newdecl))
1474                 error ("non-static declaration of %q+D follows "
1475                        "static declaration", newdecl);
1476               else
1477                 error ("static declaration of %q+D follows "
1478                        "non-static declaration", newdecl);
1479
1480               locate_old_decl (olddecl, error);
1481               return false;
1482             }
1483         }
1484       /* Two objects with the same name declared at the same block
1485          scope must both be external references (6.7p3).  */
1486       else if (!DECL_FILE_SCOPE_P (newdecl))
1487         {
1488           if (DECL_EXTERNAL (newdecl))
1489             {
1490               /* Extern with initializer at block scope, which will
1491                  already have received an error.  */
1492             }
1493           else if (DECL_EXTERNAL (olddecl))
1494             {
1495               error ("declaration of %q+D with no linkage follows "
1496                      "extern declaration", newdecl);
1497               locate_old_decl (olddecl, error);
1498             }
1499           else
1500             {
1501               error ("redeclaration of %q+D with no linkage", newdecl);
1502               locate_old_decl (olddecl, error);
1503             }
1504
1505           return false;
1506         }
1507     }
1508
1509   /* warnings */
1510   /* All decls must agree on a visibility.  */
1511   if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
1512       && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
1513       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1514     {
1515       warning (0, "redeclaration of %q+D with different visibility "
1516                "(old visibility preserved)", newdecl);
1517       warned = true;
1518     }
1519
1520   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1521     {
1522       /* Diagnose inline __attribute__ ((noinline)) which is silly.  */
1523       if (DECL_DECLARED_INLINE_P (newdecl)
1524           && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1525         {
1526           warning (OPT_Wattributes, "inline declaration of %qD follows "
1527                    "declaration with attribute noinline", newdecl);
1528           warned = true;
1529         }
1530       else if (DECL_DECLARED_INLINE_P (olddecl)
1531                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1532         {
1533           warning (OPT_Wattributes, "declaration of %q+D with attribute "
1534                    "noinline follows inline declaration ", newdecl);
1535           warned = true;
1536         }
1537
1538       /* Inline declaration after use or definition.
1539          ??? Should we still warn about this now we have unit-at-a-time
1540          mode and can get it right?
1541          Definitely don't complain if the decls are in different translation
1542          units.
1543          C99 permits this, so don't warn in that case.  (The function
1544          may not be inlined everywhere in function-at-a-time mode, but
1545          we still shouldn't warn.)  */
1546       if (DECL_DECLARED_INLINE_P (newdecl) && !DECL_DECLARED_INLINE_P (olddecl)
1547           && same_translation_unit_p (olddecl, newdecl)
1548           && flag_gnu89_inline)
1549         {
1550           if (TREE_USED (olddecl))
1551             {
1552               warning (0, "%q+D declared inline after being called", olddecl);
1553               warned = true;
1554             }
1555           else if (DECL_INITIAL (olddecl))
1556             {
1557               warning (0, "%q+D declared inline after its definition", olddecl);
1558               warned = true;
1559             }
1560         }
1561     }
1562   else /* PARM_DECL, VAR_DECL */
1563     {
1564       /* Redeclaration of a parameter is a constraint violation (this is
1565          not explicitly stated, but follows from C99 6.7p3 [no more than
1566          one declaration of the same identifier with no linkage in the
1567          same scope, except type tags] and 6.2.2p6 [parameters have no
1568          linkage]).  We must check for a forward parameter declaration,
1569          indicated by TREE_ASM_WRITTEN on the old declaration - this is
1570          an extension, the mandatory diagnostic for which is handled by
1571          mark_forward_parm_decls.  */
1572
1573       if (TREE_CODE (newdecl) == PARM_DECL
1574           && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
1575         {
1576           error ("redefinition of parameter %q+D", newdecl);
1577           locate_old_decl (olddecl, error);
1578           return false;
1579         }
1580     }
1581
1582   /* Optional warning for completely redundant decls.  */
1583   if (!warned && !pedwarned
1584       && warn_redundant_decls
1585       /* Don't warn about a function declaration followed by a
1586          definition.  */
1587       && !(TREE_CODE (newdecl) == FUNCTION_DECL
1588            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
1589       /* Don't warn about redundant redeclarations of builtins.  */
1590       && !(TREE_CODE (newdecl) == FUNCTION_DECL
1591            && !DECL_BUILT_IN (newdecl)
1592            && DECL_BUILT_IN (olddecl)
1593            && !C_DECL_DECLARED_BUILTIN (olddecl))
1594       /* Don't warn about an extern followed by a definition.  */
1595       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
1596       /* Don't warn about forward parameter decls.  */
1597       && !(TREE_CODE (newdecl) == PARM_DECL
1598            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1599       /* Don't warn about a variable definition following a declaration.  */
1600       && !(TREE_CODE (newdecl) == VAR_DECL
1601            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
1602     {
1603       warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
1604                newdecl);
1605       warned = true;
1606     }
1607
1608   /* Report location of previous decl/defn in a consistent manner.  */
1609   if (warned || pedwarned)
1610     locate_old_decl (olddecl, pedwarned ? pedwarn : warning0);
1611
1612 #undef DECL_EXTERN_INLINE
1613
1614   return retval;
1615 }
1616
1617 /* Subroutine of duplicate_decls.  NEWDECL has been found to be
1618    consistent with OLDDECL, but carries new information.  Merge the
1619    new information into OLDDECL.  This function issues no
1620    diagnostics.  */
1621
1622 static void
1623 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
1624 {
1625   bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1626                             && DECL_INITIAL (newdecl) != 0);
1627   bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
1628                            && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
1629   bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
1630                            && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
1631   bool extern_changed = false;
1632
1633   /* For real parm decl following a forward decl, rechain the old decl
1634      in its new location and clear TREE_ASM_WRITTEN (it's not a
1635      forward decl anymore).  */
1636   if (TREE_CODE (newdecl) == PARM_DECL
1637       && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1638     {
1639       struct c_binding *b, **here;
1640
1641       for (here = &current_scope->bindings; *here; here = &(*here)->prev)
1642         if ((*here)->decl == olddecl)
1643           goto found;
1644       gcc_unreachable ();
1645
1646     found:
1647       b = *here;
1648       *here = b->prev;
1649       b->prev = current_scope->bindings;
1650       current_scope->bindings = b;
1651
1652       TREE_ASM_WRITTEN (olddecl) = 0;
1653     }
1654
1655   DECL_ATTRIBUTES (newdecl)
1656     = targetm.merge_decl_attributes (olddecl, newdecl);
1657
1658   /* Merge the data types specified in the two decls.  */
1659   TREE_TYPE (newdecl)
1660     = TREE_TYPE (olddecl)
1661     = composite_type (newtype, oldtype);
1662
1663   /* Lay the type out, unless already done.  */
1664   if (!comptypes (oldtype, TREE_TYPE (newdecl)))
1665     {
1666       if (TREE_TYPE (newdecl) != error_mark_node)
1667         layout_type (TREE_TYPE (newdecl));
1668       if (TREE_CODE (newdecl) != FUNCTION_DECL
1669           && TREE_CODE (newdecl) != TYPE_DECL
1670           && TREE_CODE (newdecl) != CONST_DECL)
1671         layout_decl (newdecl, 0);
1672     }
1673   else
1674     {
1675       /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
1676       DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1677       DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1678       DECL_MODE (newdecl) = DECL_MODE (olddecl);
1679       if (TREE_CODE (olddecl) != FUNCTION_DECL)
1680         if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1681           {
1682             DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1683             DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1684           }
1685     }
1686
1687
1688   /* Merge the type qualifiers.  */
1689   if (TREE_READONLY (newdecl))
1690     TREE_READONLY (olddecl) = 1;
1691
1692   if (TREE_THIS_VOLATILE (newdecl))
1693     TREE_THIS_VOLATILE (olddecl) = 1;
1694
1695   /* Merge deprecatedness.  */
1696   if (TREE_DEPRECATED (newdecl))
1697     TREE_DEPRECATED (olddecl) = 1;
1698
1699   /* Keep source location of definition rather than declaration and of
1700      prototype rather than non-prototype unless that prototype is
1701      built-in.  */
1702   if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
1703       || (old_is_prototype && !new_is_prototype
1704           && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
1705     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1706
1707   /* Merge the initialization information.  */
1708    if (DECL_INITIAL (newdecl) == 0)
1709     DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1710
1711   /* Merge the threadprivate attribute.  */
1712   if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
1713     {
1714       DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1715       C_DECL_THREADPRIVATE_P (newdecl) = 1;
1716     }
1717
1718   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
1719     {
1720       /* Merge the unused-warning information.  */
1721       if (DECL_IN_SYSTEM_HEADER (olddecl))
1722         DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1723       else if (DECL_IN_SYSTEM_HEADER (newdecl))
1724         DECL_IN_SYSTEM_HEADER (olddecl) = 1;
1725
1726       /* Merge the section attribute.
1727          We want to issue an error if the sections conflict but that
1728          must be done later in decl_attributes since we are called
1729          before attributes are assigned.  */
1730       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1731         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1732
1733       /* Copy the assembler name.
1734          Currently, it can only be defined in the prototype.  */
1735       COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1736
1737       /* Use visibility of whichever declaration had it specified */
1738       if (DECL_VISIBILITY_SPECIFIED (olddecl))
1739         {
1740           DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1741           DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1742         }
1743
1744       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1745         {
1746           DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1747           DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1748           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1749           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1750             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1751           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1752           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1753           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1754           DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1755           DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
1756         }
1757
1758       /* Merge the storage class information.  */
1759       merge_weak (newdecl, olddecl);
1760
1761       /* For functions, static overrides non-static.  */
1762       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1763         {
1764           TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1765           /* This is since we don't automatically
1766              copy the attributes of NEWDECL into OLDDECL.  */
1767           TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1768           /* If this clears `static', clear it in the identifier too.  */
1769           if (!TREE_PUBLIC (olddecl))
1770             TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1771         }
1772     }
1773
1774   /* In c99, 'extern' declaration before (or after) 'inline' means this
1775      function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
1776      is present.  */
1777   if (TREE_CODE (newdecl) == FUNCTION_DECL
1778       && !flag_gnu89_inline
1779       && (DECL_DECLARED_INLINE_P (newdecl)
1780           || DECL_DECLARED_INLINE_P (olddecl))
1781       && (!DECL_DECLARED_INLINE_P (newdecl)
1782           || !DECL_DECLARED_INLINE_P (olddecl)
1783           || !DECL_EXTERNAL (olddecl))
1784       && DECL_EXTERNAL (newdecl)
1785       && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl)))
1786     DECL_EXTERNAL (newdecl) = 0;
1787
1788   if (DECL_EXTERNAL (newdecl))
1789     {
1790       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1791       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1792
1793       /* An extern decl does not override previous storage class.  */
1794       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1795       if (!DECL_EXTERNAL (newdecl))
1796         {
1797           DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1798           DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1799         }
1800     }
1801   else
1802     {
1803       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1804       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1805     }
1806
1807   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1808     {
1809       /* If we're redefining a function previously defined as extern
1810          inline, make sure we emit debug info for the inline before we
1811          throw it away, in case it was inlined into a function that
1812          hasn't been written out yet.  */
1813       if (new_is_definition && DECL_INITIAL (olddecl))
1814         {
1815           if (TREE_USED (olddecl)
1816               /* In unit-at-a-time mode we never inline re-defined extern
1817                  inline functions.  */
1818               && !flag_unit_at_a_time
1819               && cgraph_function_possibly_inlined_p (olddecl))
1820             (*debug_hooks->outlining_inline_function) (olddecl);
1821
1822           /* The new defn must not be inline.  */
1823           DECL_INLINE (newdecl) = 0;
1824           DECL_UNINLINABLE (newdecl) = 1;
1825         }
1826       else
1827         {
1828           /* If either decl says `inline', this fn is inline, unless
1829              its definition was passed already.  */
1830           if (DECL_DECLARED_INLINE_P (newdecl)
1831               || DECL_DECLARED_INLINE_P (olddecl))
1832             DECL_DECLARED_INLINE_P (newdecl) = 1;
1833
1834           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1835             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1836         }
1837
1838       if (DECL_BUILT_IN (olddecl))
1839         {
1840           /* If redeclaring a builtin function, it stays built in.
1841              But it gets tagged as having been declared.  */
1842           DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1843           DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1844           C_DECL_DECLARED_BUILTIN (newdecl) = 1;
1845           if (new_is_prototype)
1846             C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
1847           else
1848             C_DECL_BUILTIN_PROTOTYPE (newdecl)
1849               = C_DECL_BUILTIN_PROTOTYPE (olddecl);
1850         }
1851
1852       /* Also preserve various other info from the definition.  */
1853       if (!new_is_definition)
1854         {
1855           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1856           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1857           DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1858           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1859           DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1860
1861           /* Set DECL_INLINE on the declaration if we've got a body
1862              from which to instantiate.  */
1863           if (DECL_INLINE (olddecl) && !DECL_UNINLINABLE (newdecl))
1864             {
1865               DECL_INLINE (newdecl) = 1;
1866               DECL_ABSTRACT_ORIGIN (newdecl)
1867                 = DECL_ABSTRACT_ORIGIN (olddecl);
1868             }
1869         }
1870       else
1871         {
1872           /* If a previous declaration said inline, mark the
1873              definition as inlinable.  */
1874           if (DECL_DECLARED_INLINE_P (newdecl)
1875               && !DECL_UNINLINABLE (newdecl))
1876             DECL_INLINE (newdecl) = 1;
1877         }
1878     }
1879
1880    extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
1881
1882   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1883      But preserve OLDDECL's DECL_UID and DECL_CONTEXT.  */
1884   {
1885     unsigned olddecl_uid = DECL_UID (olddecl);
1886     tree olddecl_context = DECL_CONTEXT (olddecl);
1887
1888     memcpy ((char *) olddecl + sizeof (struct tree_common),
1889             (char *) newdecl + sizeof (struct tree_common),
1890             sizeof (struct tree_decl_common) - sizeof (struct tree_common));
1891     switch (TREE_CODE (olddecl))
1892       {
1893       case FIELD_DECL:
1894       case VAR_DECL:
1895       case PARM_DECL:
1896       case LABEL_DECL:
1897       case RESULT_DECL:
1898       case CONST_DECL:
1899       case TYPE_DECL:
1900       case FUNCTION_DECL:
1901         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1902                 (char *) newdecl + sizeof (struct tree_decl_common),
1903                 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
1904         break;
1905
1906       default:
1907
1908         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1909                 (char *) newdecl + sizeof (struct tree_decl_common),
1910                 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
1911       }
1912     DECL_UID (olddecl) = olddecl_uid;
1913     DECL_CONTEXT (olddecl) = olddecl_context;
1914   }
1915
1916   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1917      so that encode_section_info has a chance to look at the new decl
1918      flags and attributes.  */
1919   if (DECL_RTL_SET_P (olddecl)
1920       && (TREE_CODE (olddecl) == FUNCTION_DECL
1921           || (TREE_CODE (olddecl) == VAR_DECL
1922               && TREE_STATIC (olddecl))))
1923     make_decl_rtl (olddecl);
1924
1925   /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
1926      and the definition is coming from the old version, cgraph needs
1927      to be called again.  */
1928   if (extern_changed && !new_is_definition
1929       && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
1930     cgraph_finalize_function (olddecl, false);
1931 }
1932
1933 /* Handle when a new declaration NEWDECL has the same name as an old
1934    one OLDDECL in the same binding contour.  Prints an error message
1935    if appropriate.
1936
1937    If safely possible, alter OLDDECL to look like NEWDECL, and return
1938    true.  Otherwise, return false.  */
1939
1940 static bool
1941 duplicate_decls (tree newdecl, tree olddecl)
1942 {
1943   tree newtype = NULL, oldtype = NULL;
1944
1945   if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
1946     {
1947       /* Avoid `unused variable' and other warnings warnings for OLDDECL.  */
1948       TREE_NO_WARNING (olddecl) = 1;
1949       return false;
1950     }
1951
1952   merge_decls (newdecl, olddecl, newtype, oldtype);
1953   return true;
1954 }
1955
1956 \f
1957 /* Check whether decl-node NEW_DECL shadows an existing declaration.  */
1958 static void
1959 warn_if_shadowing (tree new_decl)
1960 {
1961   struct c_binding *b;
1962
1963   /* Shadow warnings wanted?  */
1964   if (!warn_shadow
1965       /* No shadow warnings for internally generated vars.  */
1966       || DECL_IS_BUILTIN (new_decl)
1967       /* No shadow warnings for vars made for inlining.  */
1968       || DECL_FROM_INLINE (new_decl))
1969     return;
1970
1971   /* Is anything being shadowed?  Invisible decls do not count.  */
1972   for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
1973     if (b->decl && b->decl != new_decl && !b->invisible)
1974       {
1975         tree old_decl = b->decl;
1976
1977         if (old_decl == error_mark_node)
1978           {
1979             warning (OPT_Wshadow, "declaration of %q+D shadows previous "
1980                      "non-variable", new_decl);
1981             break;
1982           }
1983         else if (TREE_CODE (old_decl) == PARM_DECL)
1984           warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
1985                    new_decl);
1986         else if (DECL_FILE_SCOPE_P (old_decl))
1987           warning (OPT_Wshadow, "declaration of %q+D shadows a global "
1988                    "declaration", new_decl);
1989         else if (TREE_CODE (old_decl) == FUNCTION_DECL
1990                  && DECL_BUILT_IN (old_decl))
1991           {
1992             warning (OPT_Wshadow, "declaration of %q+D shadows "
1993                      "a built-in function", new_decl);
1994             break;
1995           }
1996         else
1997           warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
1998                    new_decl);
1999
2000         warning (OPT_Wshadow, "%Jshadowed declaration is here", old_decl);
2001
2002         break;
2003       }
2004 }
2005
2006
2007 /* Subroutine of pushdecl.
2008
2009    X is a TYPE_DECL for a typedef statement.  Create a brand new
2010    ..._TYPE node (which will be just a variant of the existing
2011    ..._TYPE node with identical properties) and then install X
2012    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
2013
2014    The whole point here is to end up with a situation where each
2015    and every ..._TYPE node the compiler creates will be uniquely
2016    associated with AT MOST one node representing a typedef name.
2017    This way, even though the compiler substitutes corresponding
2018    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
2019    early on, later parts of the compiler can always do the reverse
2020    translation and get back the corresponding typedef name.  For
2021    example, given:
2022
2023         typedef struct S MY_TYPE;
2024         MY_TYPE object;
2025
2026    Later parts of the compiler might only know that `object' was of
2027    type `struct S' if it were not for code just below.  With this
2028    code however, later parts of the compiler see something like:
2029
2030         struct S' == struct S
2031         typedef struct S' MY_TYPE;
2032         struct S' object;
2033
2034     And they can then deduce (from the node for type struct S') that
2035     the original object declaration was:
2036
2037                 MY_TYPE object;
2038
2039     Being able to do this is important for proper support of protoize,
2040     and also for generating precise symbolic debugging information
2041     which takes full account of the programmer's (typedef) vocabulary.
2042
2043     Obviously, we don't want to generate a duplicate ..._TYPE node if
2044     the TYPE_DECL node that we are now processing really represents a
2045     standard built-in type.
2046
2047     Since all standard types are effectively declared at line zero
2048     in the source file, we can easily check to see if we are working
2049     on a standard type by checking the current value of lineno.  */
2050
2051 static void
2052 clone_underlying_type (tree x)
2053 {
2054   if (DECL_IS_BUILTIN (x))
2055     {
2056       if (TYPE_NAME (TREE_TYPE (x)) == 0)
2057         TYPE_NAME (TREE_TYPE (x)) = x;
2058     }
2059   else if (TREE_TYPE (x) != error_mark_node
2060            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
2061     {
2062       tree tt = TREE_TYPE (x);
2063       DECL_ORIGINAL_TYPE (x) = tt;
2064       tt = build_variant_type_copy (tt);
2065       TYPE_NAME (tt) = x;
2066       TREE_USED (tt) = TREE_USED (x);
2067       TREE_TYPE (x) = tt;
2068     }
2069 }
2070
2071 /* Record a decl-node X as belonging to the current lexical scope.
2072    Check for errors (such as an incompatible declaration for the same
2073    name already seen in the same scope).
2074
2075    Returns either X or an old decl for the same name.
2076    If an old decl is returned, it may have been smashed
2077    to agree with what X says.  */
2078
2079 tree
2080 pushdecl (tree x)
2081 {
2082   tree name = DECL_NAME (x);
2083   struct c_scope *scope = current_scope;
2084   struct c_binding *b;
2085   bool nested = false;
2086
2087   /* Functions need the lang_decl data.  */
2088   if (TREE_CODE (x) == FUNCTION_DECL && !DECL_LANG_SPECIFIC (x))
2089     DECL_LANG_SPECIFIC (x) = GGC_CNEW (struct lang_decl);
2090
2091   /* Must set DECL_CONTEXT for everything not at file scope or
2092      DECL_FILE_SCOPE_P won't work.  Local externs don't count
2093      unless they have initializers (which generate code).  */
2094   if (current_function_decl
2095       && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2096           || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2097     DECL_CONTEXT (x) = current_function_decl;
2098
2099   /* If this is of variably modified type, prevent jumping into its
2100      scope.  */
2101   if ((TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == TYPE_DECL)
2102       && variably_modified_type_p (TREE_TYPE (x), NULL_TREE))
2103     c_begin_vm_scope (scope->depth);
2104
2105   /* Anonymous decls are just inserted in the scope.  */
2106   if (!name)
2107     {
2108       bind (name, x, scope, /*invisible=*/false, /*nested=*/false);
2109       return x;
2110     }
2111
2112   /* First, see if there is another declaration with the same name in
2113      the current scope.  If there is, duplicate_decls may do all the
2114      work for us.  If duplicate_decls returns false, that indicates
2115      two incompatible decls in the same scope; we are to silently
2116      replace the old one (duplicate_decls has issued all appropriate
2117      diagnostics).  In particular, we should not consider possible
2118      duplicates in the external scope, or shadowing.  */
2119   b = I_SYMBOL_BINDING (name);
2120   if (b && B_IN_SCOPE (b, scope))
2121     {
2122       struct c_binding *b_ext, *b_use;
2123       tree type = TREE_TYPE (x);
2124       tree visdecl = b->decl;
2125       tree vistype = TREE_TYPE (visdecl);
2126       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2127           && COMPLETE_TYPE_P (TREE_TYPE (x)))
2128         b->inner_comp = false;
2129       b_use = b;
2130       b_ext = b;
2131       /* If this is an external linkage declaration, we should check
2132          for compatibility with the type in the external scope before
2133          setting the type at this scope based on the visible
2134          information only.  */
2135       if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2136         {
2137           while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2138             b_ext = b_ext->shadowed;
2139           if (b_ext)
2140             {
2141               b_use = b_ext;
2142               if (b_use->type)
2143                 TREE_TYPE (b_use->decl) = b_use->type;
2144             }
2145         }
2146       if (duplicate_decls (x, b_use->decl))
2147         {
2148           if (b_use != b)
2149             {
2150               /* Save the updated type in the external scope and
2151                  restore the proper type for this scope.  */
2152               tree thistype;
2153               if (comptypes (vistype, type))
2154                 thistype = composite_type (vistype, type);
2155               else
2156                 thistype = TREE_TYPE (b_use->decl);
2157               b_use->type = TREE_TYPE (b_use->decl);
2158               if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2159                   && DECL_BUILT_IN (b_use->decl))
2160                 thistype
2161                   = build_type_attribute_variant (thistype,
2162                                                   TYPE_ATTRIBUTES
2163                                                   (b_use->type));
2164               TREE_TYPE (b_use->decl) = thistype;
2165             }
2166           return b_use->decl;
2167         }
2168       else
2169         goto skip_external_and_shadow_checks;
2170     }
2171
2172   /* All declarations with external linkage, and all external
2173      references, go in the external scope, no matter what scope is
2174      current.  However, the binding in that scope is ignored for
2175      purposes of normal name lookup.  A separate binding structure is
2176      created in the requested scope; this governs the normal
2177      visibility of the symbol.
2178
2179      The binding in the externals scope is used exclusively for
2180      detecting duplicate declarations of the same object, no matter
2181      what scope they are in; this is what we do here.  (C99 6.2.7p2:
2182      All declarations that refer to the same object or function shall
2183      have compatible type; otherwise, the behavior is undefined.)  */
2184   if (DECL_EXTERNAL (x) || scope == file_scope)
2185     {
2186       tree type = TREE_TYPE (x);
2187       tree vistype = 0;
2188       tree visdecl = 0;
2189       bool type_saved = false;
2190       if (b && !B_IN_EXTERNAL_SCOPE (b)
2191           && (TREE_CODE (b->decl) == FUNCTION_DECL
2192               || TREE_CODE (b->decl) == VAR_DECL)
2193           && DECL_FILE_SCOPE_P (b->decl))
2194         {
2195           visdecl = b->decl;
2196           vistype = TREE_TYPE (visdecl);
2197         }
2198       if (scope != file_scope
2199           && !DECL_IN_SYSTEM_HEADER (x))
2200         warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2201
2202       while (b && !B_IN_EXTERNAL_SCOPE (b))
2203         {
2204           /* If this decl might be modified, save its type.  This is
2205              done here rather than when the decl is first bound
2206              because the type may change after first binding, through
2207              being completed or through attributes being added.  If we
2208              encounter multiple such decls, only the first should have
2209              its type saved; the others will already have had their
2210              proper types saved and the types will not have changed as
2211              their scopes will not have been re-entered.  */
2212           if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2213             {
2214               b->type = TREE_TYPE (b->decl);
2215               type_saved = true;
2216             }
2217           if (B_IN_FILE_SCOPE (b)
2218               && TREE_CODE (b->decl) == VAR_DECL
2219               && TREE_STATIC (b->decl)
2220               && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2221               && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2222               && TREE_CODE (type) == ARRAY_TYPE
2223               && TYPE_DOMAIN (type)
2224               && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2225               && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2226             {
2227               /* Array type completed in inner scope, which should be
2228                  diagnosed if the completion does not have size 1 and
2229                  it does not get completed in the file scope.  */
2230               b->inner_comp = true;
2231             }
2232           b = b->shadowed;
2233         }
2234
2235       /* If a matching external declaration has been found, set its
2236          type to the composite of all the types of that declaration.
2237          After the consistency checks, it will be reset to the
2238          composite of the visible types only.  */
2239       if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2240           && b->type)
2241         TREE_TYPE (b->decl) = b->type;
2242
2243       /* The point of the same_translation_unit_p check here is,
2244          we want to detect a duplicate decl for a construct like
2245          foo() { extern bar(); } ... static bar();  but not if
2246          they are in different translation units.  In any case,
2247          the static does not go in the externals scope.  */
2248       if (b
2249           && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2250           && duplicate_decls (x, b->decl))
2251         {
2252           tree thistype;
2253           if (vistype)
2254             {
2255               if (comptypes (vistype, type))
2256                 thistype = composite_type (vistype, type);
2257               else
2258                 thistype = TREE_TYPE (b->decl);
2259             }
2260           else
2261             thistype = type;
2262           b->type = TREE_TYPE (b->decl);
2263           if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2264             thistype
2265               = build_type_attribute_variant (thistype,
2266                                               TYPE_ATTRIBUTES (b->type));
2267           TREE_TYPE (b->decl) = thistype;
2268           bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true);
2269           return b->decl;
2270         }
2271       else if (TREE_PUBLIC (x))
2272         {
2273           if (visdecl && !b && duplicate_decls (x, visdecl))
2274             {
2275               /* An external declaration at block scope referring to a
2276                  visible entity with internal linkage.  The composite
2277                  type will already be correct for this scope, so we
2278                  just need to fall through to make the declaration in
2279                  this scope.  */
2280               nested = true;
2281               x = visdecl;
2282             }
2283           else
2284             {
2285               bind (name, x, external_scope, /*invisible=*/true,
2286                     /*nested=*/false);
2287               nested = true;
2288             }
2289         }
2290     }
2291
2292   if (TREE_CODE (x) != PARM_DECL)
2293     warn_if_shadowing (x);
2294
2295  skip_external_and_shadow_checks:
2296   if (TREE_CODE (x) == TYPE_DECL)
2297     clone_underlying_type (x);
2298
2299   bind (name, x, scope, /*invisible=*/false, nested);
2300
2301   /* If x's type is incomplete because it's based on a
2302      structure or union which has not yet been fully declared,
2303      attach it to that structure or union type, so we can go
2304      back and complete the variable declaration later, if the
2305      structure or union gets fully declared.
2306
2307      If the input is erroneous, we can have error_mark in the type
2308      slot (e.g. "f(void a, ...)") - that doesn't count as an
2309      incomplete type.  */
2310   if (TREE_TYPE (x) != error_mark_node
2311       && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2312     {
2313       tree element = TREE_TYPE (x);
2314
2315       while (TREE_CODE (element) == ARRAY_TYPE)
2316         element = TREE_TYPE (element);
2317       element = TYPE_MAIN_VARIANT (element);
2318
2319       if ((TREE_CODE (element) == RECORD_TYPE
2320            || TREE_CODE (element) == UNION_TYPE)
2321           && (TREE_CODE (x) != TYPE_DECL
2322               || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2323           && !COMPLETE_TYPE_P (element))
2324         C_TYPE_INCOMPLETE_VARS (element)
2325           = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2326     }
2327   return x;
2328 }
2329
2330 /* Record X as belonging to file scope.
2331    This is used only internally by the Objective-C front end,
2332    and is limited to its needs.  duplicate_decls is not called;
2333    if there is any preexisting decl for this identifier, it is an ICE.  */
2334
2335 tree
2336 pushdecl_top_level (tree x)
2337 {
2338   tree name;
2339   bool nested = false;
2340   gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2341
2342   name = DECL_NAME (x);
2343
2344  gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2345
2346   if (TREE_PUBLIC (x))
2347     {
2348       bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false);
2349       nested = true;
2350     }
2351   if (file_scope)
2352     bind (name, x, file_scope, /*invisible=*/false, nested);
2353
2354   return x;
2355 }
2356 \f
2357 static void
2358 implicit_decl_warning (tree id, tree olddecl)
2359 {
2360   if (warn_implicit_function_declaration)
2361     {
2362       if (flag_isoc99)
2363         pedwarn (G_("implicit declaration of function %qE"), id);
2364       else
2365         warning (OPT_Wimplicit_function_declaration,
2366                  G_("implicit declaration of function %qE"), id);
2367       if (olddecl)
2368         locate_old_decl (olddecl, inform);
2369     }
2370 }
2371
2372 /* Generate an implicit declaration for identifier FUNCTIONID as a
2373    function of type int ().  */
2374
2375 tree
2376 implicitly_declare (tree functionid)
2377 {
2378   struct c_binding *b;
2379   tree decl = 0;
2380   tree asmspec_tree;
2381
2382   for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2383     {
2384       if (B_IN_SCOPE (b, external_scope))
2385         {
2386           decl = b->decl;
2387           break;
2388         }
2389     }
2390
2391   if (decl)
2392     {
2393       if (decl == error_mark_node)
2394         return decl;
2395
2396       /* FIXME: Objective-C has weird not-really-builtin functions
2397          which are supposed to be visible automatically.  They wind up
2398          in the external scope because they're pushed before the file
2399          scope gets created.  Catch this here and rebind them into the
2400          file scope.  */
2401       if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2402         {
2403           bind (functionid, decl, file_scope,
2404                 /*invisible=*/false, /*nested=*/true);
2405           return decl;
2406         }
2407       else
2408         {
2409           tree newtype = default_function_type;
2410           if (b->type)
2411             TREE_TYPE (decl) = b->type;
2412           /* Implicit declaration of a function already declared
2413              (somehow) in a different scope, or as a built-in.
2414              If this is the first time this has happened, warn;
2415              then recycle the old declaration but with the new type.  */
2416           if (!C_DECL_IMPLICIT (decl))
2417             {
2418               implicit_decl_warning (functionid, decl);
2419               C_DECL_IMPLICIT (decl) = 1;
2420             }
2421           if (DECL_BUILT_IN (decl))
2422             {
2423               newtype = build_type_attribute_variant (newtype,
2424                                                       TYPE_ATTRIBUTES
2425                                                       (TREE_TYPE (decl)));
2426               if (!comptypes (newtype, TREE_TYPE (decl)))
2427                 {
2428                   warning (0, "incompatible implicit declaration of built-in"
2429                            " function %qD", decl);
2430                   newtype = TREE_TYPE (decl);
2431                 }
2432             }
2433           else
2434             {
2435               if (!comptypes (newtype, TREE_TYPE (decl)))
2436                 {
2437                   error ("incompatible implicit declaration of function %qD",
2438                          decl);
2439                   locate_old_decl (decl, error);
2440                 }
2441             }
2442           b->type = TREE_TYPE (decl);
2443           TREE_TYPE (decl) = newtype;
2444           bind (functionid, decl, current_scope,
2445                 /*invisible=*/false, /*nested=*/true);
2446           return decl;
2447         }
2448     }
2449
2450   /* Not seen before.  */
2451   decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2452   DECL_EXTERNAL (decl) = 1;
2453   TREE_PUBLIC (decl) = 1;
2454   C_DECL_IMPLICIT (decl) = 1;
2455   implicit_decl_warning (functionid, 0);
2456   asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2457   if (asmspec_tree)
2458     set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2459
2460   /* C89 says implicit declarations are in the innermost block.
2461      So we record the decl in the standard fashion.  */
2462   decl = pushdecl (decl);
2463
2464   /* No need to call objc_check_decl here - it's a function type.  */
2465   rest_of_decl_compilation (decl, 0, 0);
2466
2467   /* Write a record describing this implicit function declaration
2468      to the prototypes file (if requested).  */
2469   gen_aux_info_record (decl, 0, 1, 0);
2470
2471   /* Possibly apply some default attributes to this implicit declaration.  */
2472   decl_attributes (&decl, NULL_TREE, 0);
2473
2474   return decl;
2475 }
2476
2477 /* Issue an error message for a reference to an undeclared variable
2478    ID, including a reference to a builtin outside of function-call
2479    context.  Establish a binding of the identifier to error_mark_node
2480    in an appropriate scope, which will suppress further errors for the
2481    same identifier.  The error message should be given location LOC.  */
2482 void
2483 undeclared_variable (tree id, location_t loc)
2484 {
2485   static bool already = false;
2486   struct c_scope *scope;
2487
2488   if (current_function_decl == 0)
2489     {
2490       error ("%H%qE undeclared here (not in a function)", &loc, id);
2491       scope = current_scope;
2492     }
2493   else
2494     {
2495       error ("%H%qE undeclared (first use in this function)", &loc, id);
2496
2497       if (!already)
2498         {
2499           error ("%H(Each undeclared identifier is reported only once", &loc);
2500           error ("%Hfor each function it appears in.)", &loc);
2501           already = true;
2502         }
2503
2504       /* If we are parsing old-style parameter decls, current_function_decl
2505          will be nonnull but current_function_scope will be null.  */
2506       scope = current_function_scope ? current_function_scope : current_scope;
2507     }
2508   bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false);
2509 }
2510 \f
2511 /* Subroutine of lookup_label, declare_label, define_label: construct a
2512    LABEL_DECL with all the proper frills.  */
2513
2514 static tree
2515 make_label (tree name, location_t location)
2516 {
2517   tree label = build_decl (LABEL_DECL, name, void_type_node);
2518
2519   DECL_CONTEXT (label) = current_function_decl;
2520   DECL_MODE (label) = VOIDmode;
2521   DECL_SOURCE_LOCATION (label) = location;
2522
2523   return label;
2524 }
2525
2526 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2527    Create one if none exists so far for the current function.
2528    This is called when a label is used in a goto expression or
2529    has its address taken.  */
2530
2531 tree
2532 lookup_label (tree name)
2533 {
2534   tree label;
2535
2536   if (current_function_decl == 0)
2537     {
2538       error ("label %qE referenced outside of any function", name);
2539       return 0;
2540     }
2541
2542   /* Use a label already defined or ref'd with this name, but not if
2543      it is inherited from a containing function and wasn't declared
2544      using __label__.  */
2545   label = I_LABEL_DECL (name);
2546   if (label && (DECL_CONTEXT (label) == current_function_decl
2547                 || C_DECLARED_LABEL_FLAG (label)))
2548     {
2549       /* If the label has only been declared, update its apparent
2550          location to point here, for better diagnostics if it
2551          turns out not to have been defined.  */
2552       if (!TREE_USED (label))
2553         DECL_SOURCE_LOCATION (label) = input_location;
2554       return label;
2555     }
2556
2557   /* No label binding for that identifier; make one.  */
2558   label = make_label (name, input_location);
2559
2560   /* Ordinary labels go in the current function scope.  */
2561   bind (name, label, current_function_scope,
2562         /*invisible=*/false, /*nested=*/false);
2563   return label;
2564 }
2565
2566 /* Make a label named NAME in the current function, shadowing silently
2567    any that may be inherited from containing functions or containing
2568    scopes.  This is called for __label__ declarations.  */
2569
2570 tree
2571 declare_label (tree name)
2572 {
2573   struct c_binding *b = I_LABEL_BINDING (name);
2574   tree label;
2575
2576   /* Check to make sure that the label hasn't already been declared
2577      at this scope */
2578   if (b && B_IN_CURRENT_SCOPE (b))
2579     {
2580       error ("duplicate label declaration %qE", name);
2581       locate_old_decl (b->decl, error);
2582
2583       /* Just use the previous declaration.  */
2584       return b->decl;
2585     }
2586
2587   label = make_label (name, input_location);
2588   C_DECLARED_LABEL_FLAG (label) = 1;
2589
2590   /* Declared labels go in the current scope.  */
2591   bind (name, label, current_scope,
2592         /*invisible=*/false, /*nested=*/false);
2593   return label;
2594 }
2595
2596 /* Define a label, specifying the location in the source file.
2597    Return the LABEL_DECL node for the label, if the definition is valid.
2598    Otherwise return 0.  */
2599
2600 tree
2601 define_label (location_t location, tree name)
2602 {
2603   /* Find any preexisting label with this name.  It is an error
2604      if that label has already been defined in this function, or
2605      if there is a containing function with a declared label with
2606      the same name.  */
2607   tree label = I_LABEL_DECL (name);
2608   struct c_label_list *nlist_se, *nlist_vm;
2609
2610   if (label
2611       && ((DECL_CONTEXT (label) == current_function_decl
2612            && DECL_INITIAL (label) != 0)
2613           || (DECL_CONTEXT (label) != current_function_decl
2614               && C_DECLARED_LABEL_FLAG (label))))
2615     {
2616       error ("%Hduplicate label %qD", &location, label);
2617       locate_old_decl (label, error);
2618       return 0;
2619     }
2620   else if (label && DECL_CONTEXT (label) == current_function_decl)
2621     {
2622       /* The label has been used or declared already in this function,
2623          but not defined.  Update its location to point to this
2624          definition.  */
2625       if (C_DECL_UNDEFINABLE_STMT_EXPR (label))
2626         error ("%Jjump into statement expression", label);
2627       if (C_DECL_UNDEFINABLE_VM (label))
2628         error ("%Jjump into scope of identifier with variably modified type",
2629                label);
2630       DECL_SOURCE_LOCATION (label) = location;
2631     }
2632   else
2633     {
2634       /* No label binding for that identifier; make one.  */
2635       label = make_label (name, location);
2636
2637       /* Ordinary labels go in the current function scope.  */
2638       bind (name, label, current_function_scope,
2639             /*invisible=*/false, /*nested=*/false);
2640     }
2641
2642   if (!in_system_header && lookup_name (name))
2643     warning (OPT_Wtraditional, "%Htraditional C lacks a separate namespace "
2644              "for labels, identifier %qE conflicts", &location, name);
2645
2646   nlist_se = XOBNEW (&parser_obstack, struct c_label_list);
2647   nlist_se->next = label_context_stack_se->labels_def;
2648   nlist_se->label = label;
2649   label_context_stack_se->labels_def = nlist_se;
2650
2651   nlist_vm = XOBNEW (&parser_obstack, struct c_label_list);
2652   nlist_vm->next = label_context_stack_vm->labels_def;
2653   nlist_vm->label = label;
2654   label_context_stack_vm->labels_def = nlist_vm;
2655
2656   /* Mark label as having been defined.  */
2657   DECL_INITIAL (label) = error_mark_node;
2658   return label;
2659 }
2660 \f
2661 /* Given NAME, an IDENTIFIER_NODE,
2662    return the structure (or union or enum) definition for that name.
2663    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
2664    CODE says which kind of type the caller wants;
2665    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2666    If the wrong kind of type is found, an error is reported.  */
2667
2668 static tree
2669 lookup_tag (enum tree_code code, tree name, int thislevel_only)
2670 {
2671   struct c_binding *b = I_TAG_BINDING (name);
2672   int thislevel = 0;
2673
2674   if (!b || !b->decl)
2675     return 0;
2676
2677   /* We only care about whether it's in this level if
2678      thislevel_only was set or it might be a type clash.  */
2679   if (thislevel_only || TREE_CODE (b->decl) != code)
2680     {
2681       /* For our purposes, a tag in the external scope is the same as
2682          a tag in the file scope.  (Primarily relevant to Objective-C
2683          and its builtin structure tags, which get pushed before the
2684          file scope is created.)  */
2685       if (B_IN_CURRENT_SCOPE (b)
2686           || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
2687         thislevel = 1;
2688     }
2689
2690   if (thislevel_only && !thislevel)
2691     return 0;
2692
2693   if (TREE_CODE (b->decl) != code)
2694     {
2695       /* Definition isn't the kind we were looking for.  */
2696       pending_invalid_xref = name;
2697       pending_invalid_xref_location = input_location;
2698
2699       /* If in the same binding level as a declaration as a tag
2700          of a different type, this must not be allowed to
2701          shadow that tag, so give the error immediately.
2702          (For example, "struct foo; union foo;" is invalid.)  */
2703       if (thislevel)
2704         pending_xref_error ();
2705     }
2706   return b->decl;
2707 }
2708
2709 /* Print an error message now
2710    for a recent invalid struct, union or enum cross reference.
2711    We don't print them immediately because they are not invalid
2712    when used in the `struct foo;' construct for shadowing.  */
2713
2714 void
2715 pending_xref_error (void)
2716 {
2717   if (pending_invalid_xref != 0)
2718     error ("%H%qE defined as wrong kind of tag",
2719            &pending_invalid_xref_location, pending_invalid_xref);
2720   pending_invalid_xref = 0;
2721 }
2722
2723 \f
2724 /* Look up NAME in the current scope and its superiors
2725    in the namespace of variables, functions and typedefs.
2726    Return a ..._DECL node of some kind representing its definition,
2727    or return 0 if it is undefined.  */
2728
2729 tree
2730 lookup_name (tree name)
2731 {
2732   struct c_binding *b = I_SYMBOL_BINDING (name);
2733   if (b && !b->invisible)
2734     return b->decl;
2735   return 0;
2736 }
2737
2738 /* Similar to `lookup_name' but look only at the indicated scope.  */
2739
2740 static tree
2741 lookup_name_in_scope (tree name, struct c_scope *scope)
2742 {
2743   struct c_binding *b;
2744
2745   for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
2746     if (B_IN_SCOPE (b, scope))
2747       return b->decl;
2748   return 0;
2749 }
2750 \f
2751 /* Create the predefined scalar types of C,
2752    and some nodes representing standard constants (0, 1, (void *) 0).
2753    Initialize the global scope.
2754    Make definitions for built-in primitive functions.  */
2755
2756 void
2757 c_init_decl_processing (void)
2758 {
2759   location_t save_loc = input_location;
2760
2761   /* Initialize reserved words for parser.  */
2762   c_parse_init ();
2763
2764   current_function_decl = 0;
2765
2766   gcc_obstack_init (&parser_obstack);
2767
2768   /* Make the externals scope.  */
2769   push_scope ();
2770   external_scope = current_scope;
2771
2772   /* Declarations from c_common_nodes_and_builtins must not be associated
2773      with this input file, lest we get differences between using and not
2774      using preprocessed headers.  */
2775 #ifdef USE_MAPPED_LOCATION
2776   input_location = BUILTINS_LOCATION;
2777 #else
2778   input_location.file = "<built-in>";
2779   input_location.line = 0;
2780 #endif
2781
2782   build_common_tree_nodes (flag_signed_char, false);
2783
2784   c_common_nodes_and_builtins ();
2785
2786   /* In C, comparisons and TRUTH_* expressions have type int.  */
2787   truthvalue_type_node = integer_type_node;
2788   truthvalue_true_node = integer_one_node;
2789   truthvalue_false_node = integer_zero_node;
2790
2791   /* Even in C99, which has a real boolean type.  */
2792   pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2793                         boolean_type_node));
2794
2795   input_location = save_loc;
2796
2797   pedantic_lvalues = true;
2798
2799   make_fname_decl = c_make_fname_decl;
2800   start_fname_decls ();
2801 }
2802
2803 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2804    decl, NAME is the initialization string and TYPE_DEP indicates whether
2805    NAME depended on the type of the function.  As we don't yet implement
2806    delayed emission of static data, we mark the decl as emitted
2807    so it is not placed in the output.  Anything using it must therefore pull
2808    out the STRING_CST initializer directly.  FIXME.  */
2809
2810 static tree
2811 c_make_fname_decl (tree id, int type_dep)
2812 {
2813   const char *name = fname_as_string (type_dep);
2814   tree decl, type, init;
2815   size_t length = strlen (name);
2816
2817   type = build_array_type (char_type_node,
2818                            build_index_type (size_int (length)));
2819   type = c_build_qualified_type (type, TYPE_QUAL_CONST);
2820
2821   decl = build_decl (VAR_DECL, id, type);
2822
2823   TREE_STATIC (decl) = 1;
2824   TREE_READONLY (decl) = 1;
2825   DECL_ARTIFICIAL (decl) = 1;
2826
2827   init = build_string (length + 1, name);
2828   free ((char *) name);
2829   TREE_TYPE (init) = type;
2830   DECL_INITIAL (decl) = init;
2831
2832   TREE_USED (decl) = 1;
2833
2834   if (current_function_decl
2835       /* For invalid programs like this:
2836
2837          void foo()
2838          const char* p = __FUNCTION__;
2839
2840          the __FUNCTION__ is believed to appear in K&R style function
2841          parameter declarator.  In that case we still don't have
2842          function_scope.  */
2843       && (!errorcount || current_function_scope))
2844     {
2845       DECL_CONTEXT (decl) = current_function_decl;
2846       bind (id, decl, current_function_scope,
2847             /*invisible=*/false, /*nested=*/false);
2848     }
2849
2850   finish_decl (decl, init, NULL_TREE);
2851
2852   return decl;
2853 }
2854
2855 tree
2856 c_builtin_function (tree decl)
2857 {
2858   tree type = TREE_TYPE (decl);
2859   tree   id = DECL_NAME (decl);
2860
2861   const char *name = IDENTIFIER_POINTER (id);
2862   DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
2863   C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
2864
2865   /* Should never be called on a symbol with a preexisting meaning.  */
2866   gcc_assert (!I_SYMBOL_BINDING (id));
2867
2868   bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false);
2869
2870   /* Builtins in the implementation namespace are made visible without
2871      needing to be explicitly declared.  See push_file_scope.  */
2872   if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
2873     {
2874       TREE_CHAIN (decl) = visible_builtins;
2875       visible_builtins = decl;
2876     }
2877
2878   return decl;
2879 }
2880 \f
2881 /* Called when a declaration is seen that contains no names to declare.
2882    If its type is a reference to a structure, union or enum inherited
2883    from a containing scope, shadow that tag name for the current scope
2884    with a forward reference.
2885    If its type defines a new named structure or union
2886    or defines an enum, it is valid but we need not do anything here.
2887    Otherwise, it is an error.  */
2888
2889 void
2890 shadow_tag (const struct c_declspecs *declspecs)
2891 {
2892   shadow_tag_warned (declspecs, 0);
2893 }
2894
2895 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
2896    but no pedwarn.  */
2897 void
2898 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
2899 {
2900   bool found_tag = false;
2901
2902   if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
2903     {
2904       tree value = declspecs->type;
2905       enum tree_code code = TREE_CODE (value);
2906
2907       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2908         /* Used to test also that TYPE_SIZE (value) != 0.
2909            That caused warning for `struct foo;' at top level in the file.  */
2910         {
2911           tree name = TYPE_NAME (value);
2912           tree t;
2913
2914           found_tag = true;
2915
2916           if (name == 0)
2917             {
2918               if (warned != 1 && code != ENUMERAL_TYPE)
2919                 /* Empty unnamed enum OK */
2920                 {
2921                   pedwarn ("unnamed struct/union that defines no instances");
2922                   warned = 1;
2923                 }
2924             }
2925           else if (!declspecs->tag_defined_p
2926                    && declspecs->storage_class != csc_none)
2927             {
2928               if (warned != 1)
2929                 pedwarn ("empty declaration with storage class specifier "
2930                          "does not redeclare tag");
2931               warned = 1;
2932               pending_xref_error ();
2933             }
2934           else if (!declspecs->tag_defined_p
2935                    && (declspecs->const_p
2936                        || declspecs->volatile_p
2937                        || declspecs->restrict_p))
2938             {
2939               if (warned != 1)
2940                 pedwarn ("empty declaration with type qualifier "
2941                          "does not redeclare tag");
2942               warned = 1;
2943               pending_xref_error ();
2944             }
2945           else
2946             {
2947               pending_invalid_xref = 0;
2948               t = lookup_tag (code, name, 1);
2949
2950               if (t == 0)
2951                 {
2952                   t = make_node (code);
2953                   pushtag (name, t);
2954                 }
2955             }
2956         }
2957       else
2958         {
2959           if (warned != 1 && !in_system_header)
2960             {
2961               pedwarn ("useless type name in empty declaration");
2962               warned = 1;
2963             }
2964         }
2965     }
2966   else if (warned != 1 && !in_system_header && declspecs->typedef_p)
2967     {
2968       pedwarn ("useless type name in empty declaration");
2969       warned = 1;
2970     }
2971
2972   pending_invalid_xref = 0;
2973
2974   if (declspecs->inline_p)
2975     {
2976       error ("%<inline%> in empty declaration");
2977       warned = 1;
2978     }
2979
2980   if (current_scope == file_scope && declspecs->storage_class == csc_auto)
2981     {
2982       error ("%<auto%> in file-scope empty declaration");
2983       warned = 1;
2984     }
2985
2986   if (current_scope == file_scope && declspecs->storage_class == csc_register)
2987     {
2988       error ("%<register%> in file-scope empty declaration");
2989       warned = 1;
2990     }
2991
2992   if (!warned && !in_system_header && declspecs->storage_class != csc_none)
2993     {
2994       warning (0, "useless storage class specifier in empty declaration");
2995       warned = 2;
2996     }
2997
2998   if (!warned && !in_system_header && declspecs->thread_p)
2999     {
3000       warning (0, "useless %<__thread%> in empty declaration");
3001       warned = 2;
3002     }
3003
3004   if (!warned && !in_system_header && (declspecs->const_p
3005                                        || declspecs->volatile_p
3006                                        || declspecs->restrict_p))
3007     {
3008       warning (0, "useless type qualifier in empty declaration");
3009       warned = 2;
3010     }
3011
3012   if (warned != 1)
3013     {
3014       if (!found_tag)
3015         pedwarn ("empty declaration");
3016     }
3017 }
3018 \f
3019
3020 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3021    bits.  SPECS represents declaration specifiers that the grammar
3022    only permits to contain type qualifiers and attributes.  */
3023
3024 int
3025 quals_from_declspecs (const struct c_declspecs *specs)
3026 {
3027   int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3028                | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3029                | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
3030   gcc_assert (!specs->type
3031               && !specs->decl_attr
3032               && specs->typespec_word == cts_none
3033               && specs->storage_class == csc_none
3034               && !specs->typedef_p
3035               && !specs->explicit_signed_p
3036               && !specs->deprecated_p
3037               && !specs->long_p
3038               && !specs->long_long_p
3039               && !specs->short_p
3040               && !specs->signed_p
3041               && !specs->unsigned_p
3042               && !specs->complex_p
3043               && !specs->inline_p
3044               && !specs->thread_p);
3045   return quals;
3046 }
3047
3048 /* Construct an array declarator.  EXPR is the expression inside [],
3049    or NULL_TREE.  QUALS are the type qualifiers inside the [] (to be
3050    applied to the pointer to which a parameter array is converted).
3051    STATIC_P is true if "static" is inside the [], false otherwise.
3052    VLA_UNSPEC_P is true if the array is [*], a VLA of unspecified
3053    length which is nevertheless a complete type, false otherwise.  The
3054    field for the contained declarator is left to be filled in by
3055    set_array_declarator_inner.  */
3056
3057 struct c_declarator *
3058 build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
3059                         bool vla_unspec_p)
3060 {
3061   struct c_declarator *declarator = XOBNEW (&parser_obstack,
3062                                             struct c_declarator);
3063   declarator->kind = cdk_array;
3064   declarator->declarator = 0;
3065   declarator->u.array.dimen = expr;
3066   if (quals)
3067     {
3068       declarator->u.array.attrs = quals->attrs;
3069       declarator->u.array.quals = quals_from_declspecs (quals);
3070     }
3071   else
3072     {
3073       declarator->u.array.attrs = NULL_TREE;
3074       declarator->u.array.quals = 0;
3075     }
3076   declarator->u.array.static_p = static_p;
3077   declarator->u.array.vla_unspec_p = vla_unspec_p;
3078   if (pedantic && !flag_isoc99)
3079     {
3080       if (static_p || quals != NULL)
3081         pedwarn ("ISO C90 does not support %<static%> or type "
3082                  "qualifiers in parameter array declarators");
3083       if (vla_unspec_p)
3084         pedwarn ("ISO C90 does not support %<[*]%> array declarators");
3085     }
3086   if (vla_unspec_p)
3087     {
3088       if (!current_scope->parm_flag)
3089         {
3090           /* C99 6.7.5.2p4 */
3091           error ("%<[*]%> not allowed in other than function prototype scope");
3092           declarator->u.array.vla_unspec_p = false;
3093           return NULL;
3094         }
3095       current_scope->had_vla_unspec = true;
3096     }
3097   return declarator;
3098 }
3099
3100 /* Set the contained declarator of an array declarator.  DECL is the
3101    declarator, as constructed by build_array_declarator; INNER is what
3102    appears on the left of the [].  ABSTRACT_P is true if it is an
3103    abstract declarator, false otherwise; this is used to reject static
3104    and type qualifiers in abstract declarators, where they are not in
3105    the C99 grammar (subject to possible change in DR#289).  */
3106
3107 struct c_declarator *
3108 set_array_declarator_inner (struct c_declarator *decl,
3109                             struct c_declarator *inner, bool abstract_p)
3110 {
3111   decl->declarator = inner;
3112   if (abstract_p && (decl->u.array.quals != TYPE_UNQUALIFIED
3113                      || decl->u.array.attrs != NULL_TREE
3114                      || decl->u.array.static_p))
3115     error ("static or type qualifiers in abstract declarator");
3116   return decl;
3117 }
3118
3119 /* INIT is a constructor that forms DECL's initializer.  If the final
3120    element initializes a flexible array field, add the size of that
3121    initializer to DECL's size.  */
3122
3123 static void
3124 add_flexible_array_elts_to_size (tree decl, tree init)
3125 {
3126   tree elt, type;
3127
3128   if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3129     return;
3130
3131   elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3132   type = TREE_TYPE (elt);
3133   if (TREE_CODE (type) == ARRAY_TYPE
3134       && TYPE_SIZE (type) == NULL_TREE
3135       && TYPE_DOMAIN (type) != NULL_TREE
3136       && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3137     {
3138       complete_array_type (&type, elt, false);
3139       DECL_SIZE (decl)
3140         = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3141       DECL_SIZE_UNIT (decl)
3142         = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3143     }
3144 }
3145 \f
3146 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3147
3148 tree
3149 groktypename (struct c_type_name *type_name)
3150 {
3151   tree type;
3152   tree attrs = type_name->specs->attrs;
3153
3154   type_name->specs->attrs = NULL_TREE;
3155
3156   type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3157                          false, NULL);
3158
3159   /* Apply attributes.  */
3160   decl_attributes (&type, attrs, 0);
3161
3162   return type;
3163 }
3164
3165 /* Decode a declarator in an ordinary declaration or data definition.
3166    This is called as soon as the type information and variable name
3167    have been parsed, before parsing the initializer if any.
3168    Here we create the ..._DECL node, fill in its type,
3169    and put it on the list of decls for the current context.
3170    The ..._DECL node is returned as the value.
3171
3172    Exception: for arrays where the length is not specified,
3173    the type is left null, to be filled in by `finish_decl'.
3174
3175    Function definitions do not come here; they go to start_function
3176    instead.  However, external and forward declarations of functions
3177    do go through here.  Structure field declarations are done by
3178    grokfield and not through here.  */
3179
3180 tree
3181 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3182             bool initialized, tree attributes)
3183 {
3184   tree decl;
3185   tree tem;
3186
3187   /* An object declared as __attribute__((deprecated)) suppresses
3188      warnings of uses of other deprecated items.  */
3189   if (lookup_attribute ("deprecated", attributes))
3190     deprecated_state = DEPRECATED_SUPPRESS;
3191
3192   decl = grokdeclarator (declarator, declspecs,
3193                          NORMAL, initialized, NULL);
3194   if (!decl)
3195     return 0;
3196
3197   deprecated_state = DEPRECATED_NORMAL;
3198
3199   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3200       && MAIN_NAME_P (DECL_NAME (decl)))
3201     warning (OPT_Wmain, "%q+D is usually a function", decl);
3202
3203   if (initialized)
3204     /* Is it valid for this decl to have an initializer at all?
3205        If not, set INITIALIZED to zero, which will indirectly
3206        tell 'finish_decl' to ignore the initializer once it is parsed.  */
3207     switch (TREE_CODE (decl))
3208       {
3209       case TYPE_DECL:
3210         error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3211         initialized = 0;
3212         break;
3213
3214       case FUNCTION_DECL:
3215         error ("function %qD is initialized like a variable", decl);
3216         initialized = 0;
3217         break;
3218
3219       case PARM_DECL:
3220         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
3221         error ("parameter %qD is initialized", decl);
3222         initialized = 0;
3223         break;
3224
3225       default:
3226         /* Don't allow initializations for incomplete types except for
3227            arrays which might be completed by the initialization.  */
3228
3229         /* This can happen if the array size is an undefined macro.
3230            We already gave a warning, so we don't need another one.  */
3231         if (TREE_TYPE (decl) == error_mark_node)
3232           initialized = 0;
3233         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3234           {
3235             /* A complete type is ok if size is fixed.  */
3236
3237             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3238                 || C_DECL_VARIABLE_SIZE (decl))
3239               {
3240                 error ("variable-sized object may not be initialized");
3241                 initialized = 0;
3242               }
3243           }
3244         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3245           {
3246             error ("variable %qD has initializer but incomplete type", decl);
3247             initialized = 0;
3248           }
3249         else if (C_DECL_VARIABLE_SIZE (decl))
3250           {
3251             /* Although C99 is unclear about whether incomplete arrays
3252                of VLAs themselves count as VLAs, it does not make
3253                sense to permit them to be initialized given that
3254                ordinary VLAs may not be initialized.  */
3255             error ("variable-sized object may not be initialized");
3256             initialized = 0;
3257           }
3258       }
3259
3260   if (initialized)
3261     {
3262       if (current_scope == file_scope)
3263         TREE_STATIC (decl) = 1;
3264
3265       /* Tell 'pushdecl' this is an initialized decl
3266          even though we don't yet have the initializer expression.
3267          Also tell 'finish_decl' it may store the real initializer.  */
3268       DECL_INITIAL (decl) = error_mark_node;
3269     }
3270
3271   /* If this is a function declaration, write a record describing it to the
3272      prototypes file (if requested).  */
3273
3274   if (TREE_CODE (decl) == FUNCTION_DECL)
3275     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3276
3277   /* ANSI specifies that a tentative definition which is not merged with
3278      a non-tentative definition behaves exactly like a definition with an
3279      initializer equal to zero.  (Section 3.7.2)
3280
3281      -fno-common gives strict ANSI behavior, though this tends to break
3282      a large body of code that grew up without this rule.
3283
3284      Thread-local variables are never common, since there's no entrenched
3285      body of code to break, and it allows more efficient variable references
3286      in the presence of dynamic linking.  */
3287
3288   if (TREE_CODE (decl) == VAR_DECL
3289       && !initialized
3290       && TREE_PUBLIC (decl)
3291       && !DECL_THREAD_LOCAL_P (decl)
3292       && !flag_no_common)
3293     DECL_COMMON (decl) = 1;
3294
3295   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3296   decl_attributes (&decl, attributes, 0);
3297
3298   /* Handle gnu_inline attribute.  */
3299   if (declspecs->inline_p
3300       && !flag_gnu89_inline
3301       && TREE_CODE (decl) == FUNCTION_DECL
3302       && lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl)))
3303     {
3304       if (declspecs->storage_class == csc_auto && current_scope != file_scope)
3305         ;
3306       else if (declspecs->storage_class != csc_static)
3307         DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
3308     }
3309
3310   if (TREE_CODE (decl) == FUNCTION_DECL
3311       && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
3312     {
3313       struct c_declarator *ce = declarator;
3314
3315       if (ce->kind == cdk_pointer)
3316         ce = declarator->declarator;
3317       if (ce->kind == cdk_function)
3318         {
3319           tree args = ce->u.arg_info->parms;
3320           for (; args; args = TREE_CHAIN (args))
3321             {
3322               tree type = TREE_TYPE (args);
3323               if (type && INTEGRAL_TYPE_P (type)
3324                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
3325                 DECL_ARG_TYPE (args) = integer_type_node;
3326             }
3327         }
3328     }
3329
3330   if (TREE_CODE (decl) == FUNCTION_DECL
3331       && DECL_DECLARED_INLINE_P (decl)
3332       && DECL_UNINLINABLE (decl)
3333       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3334     warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
3335              decl);
3336
3337   /* C99 6.7.4p3: An inline definition of a function with external
3338      linkage shall not contain a definition of a modifiable object
3339      with static storage duration...  */
3340   if (TREE_CODE (decl) == VAR_DECL
3341       && current_scope != file_scope
3342       && TREE_STATIC (decl)
3343       && DECL_DECLARED_INLINE_P (current_function_decl)
3344       && DECL_EXTERNAL (current_function_decl))
3345     pedwarn ("%q+D is static but declared in inline function %qD "
3346              "which is not static", decl, current_function_decl);
3347
3348   /* Add this decl to the current scope.
3349      TEM may equal DECL or it may be a previous decl of the same name.  */
3350   tem = pushdecl (decl);
3351
3352   if (initialized && DECL_EXTERNAL (tem))
3353     {
3354       DECL_EXTERNAL (tem) = 0;
3355       TREE_STATIC (tem) = 1;
3356     }
3357
3358   return tem;
3359 }
3360
3361 /* Initialize EH if not initialized yet and exceptions are enabled.  */
3362
3363 void
3364 c_maybe_initialize_eh (void)
3365 {
3366   if (!flag_exceptions || c_eh_initialized_p)
3367     return;
3368
3369   c_eh_initialized_p = true;
3370   eh_personality_libfunc
3371     = init_one_libfunc (USING_SJLJ_EXCEPTIONS
3372                         ? "__gcc_personality_sj0"
3373                         : "__gcc_personality_v0");
3374   default_init_unwind_resume_libfunc ();
3375   using_eh_for_cleanups ();
3376 }
3377
3378 /* Finish processing of a declaration;
3379    install its initial value.
3380    If the length of an array type is not known before,
3381    it must be determined now, from the initial value, or it is an error.  */
3382
3383 void
3384 finish_decl (tree decl, tree init, tree asmspec_tree)
3385 {
3386   tree type;
3387   int was_incomplete = (DECL_SIZE (decl) == 0);
3388   const char *asmspec = 0;
3389
3390   /* If a name was specified, get the string.  */
3391   if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
3392       && DECL_FILE_SCOPE_P (decl))
3393     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
3394   if (asmspec_tree)
3395     asmspec = TREE_STRING_POINTER (asmspec_tree);
3396
3397   /* If `start_decl' didn't like having an initialization, ignore it now.  */
3398   if (init != 0 && DECL_INITIAL (decl) == 0)
3399     init = 0;
3400
3401   /* Don't crash if parm is initialized.  */
3402   if (TREE_CODE (decl) == PARM_DECL)
3403     init = 0;
3404
3405   if (init)
3406     store_init_value (decl, init);
3407
3408   if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
3409                             || TREE_CODE (decl) == FUNCTION_DECL
3410                             || TREE_CODE (decl) == FIELD_DECL))
3411     objc_check_decl (decl);
3412
3413   type = TREE_TYPE (decl);
3414
3415   /* Deduce size of array from initialization, if not already known.  */
3416   if (TREE_CODE (type) == ARRAY_TYPE
3417       && TYPE_DOMAIN (type) == 0
3418       && TREE_CODE (decl) != TYPE_DECL)
3419     {
3420       bool do_default
3421         = (TREE_STATIC (decl)
3422            /* Even if pedantic, an external linkage array
3423               may have incomplete type at first.  */
3424            ? pedantic && !TREE_PUBLIC (decl)
3425            : !DECL_EXTERNAL (decl));
3426       int failure
3427         = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
3428                                do_default);
3429
3430       /* Get the completed type made by complete_array_type.  */
3431       type = TREE_TYPE (decl);
3432
3433       switch (failure)
3434         {
3435         case 1:
3436           error ("initializer fails to determine size of %q+D", decl);
3437           break;
3438
3439         case 2:
3440           if (do_default)
3441             error ("array size missing in %q+D", decl);
3442           /* If a `static' var's size isn't known,
3443              make it extern as well as static, so it does not get
3444              allocated.
3445              If it is not `static', then do not mark extern;
3446              finish_incomplete_decl will give it a default size
3447              and it will get allocated.  */
3448           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3449             DECL_EXTERNAL (decl) = 1;
3450           break;
3451
3452         case 3:
3453           error ("zero or negative size array %q+D", decl);
3454           break;
3455
3456         case 0:
3457           /* For global variables, update the copy of the type that
3458              exists in the binding.  */
3459           if (TREE_PUBLIC (decl))
3460             {
3461               struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
3462               while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
3463                 b_ext = b_ext->shadowed;
3464               if (b_ext)
3465                 {
3466                   if (b_ext->type)
3467                     b_ext->type = composite_type (b_ext->type, type);
3468                   else
3469                     b_ext->type = type;
3470                 }
3471             }
3472           break;
3473
3474         default:
3475           gcc_unreachable ();
3476         }
3477
3478       if (DECL_INITIAL (decl))
3479         TREE_TYPE (DECL_INITIAL (decl)) = type;
3480
3481       layout_decl (decl, 0);
3482     }
3483
3484   if (TREE_CODE (decl) == VAR_DECL)
3485     {
3486       if (init && TREE_CODE (init) == CONSTRUCTOR)
3487         add_flexible_array_elts_to_size (decl, init);
3488
3489       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3490           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3491         layout_decl (decl, 0);
3492
3493       if (DECL_SIZE (decl) == 0
3494           /* Don't give an error if we already gave one earlier.  */
3495           && TREE_TYPE (decl) != error_mark_node
3496           && (TREE_STATIC (decl)
3497               /* A static variable with an incomplete type
3498                  is an error if it is initialized.
3499                  Also if it is not file scope.
3500                  Otherwise, let it through, but if it is not `extern'
3501                  then it may cause an error message later.  */
3502               ? (DECL_INITIAL (decl) != 0
3503                  || !DECL_FILE_SCOPE_P (decl))
3504               /* An automatic variable with an incomplete type
3505                  is an error.  */
3506               : !DECL_EXTERNAL (decl)))
3507          {
3508            error ("storage size of %q+D isn%'t known", decl);
3509            TREE_TYPE (decl) = error_mark_node;
3510          }
3511
3512       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3513           && DECL_SIZE (decl) != 0)
3514         {
3515           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3516             constant_expression_warning (DECL_SIZE (decl));
3517           else
3518             error ("storage size of %q+D isn%'t constant", decl);
3519         }
3520
3521       if (TREE_USED (type))
3522         TREE_USED (decl) = 1;
3523     }
3524
3525   /* If this is a function and an assembler name is specified, reset DECL_RTL
3526      so we can give it its new name.  Also, update built_in_decls if it
3527      was a normal built-in.  */
3528   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3529     {
3530       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
3531         set_builtin_user_assembler_name (decl, asmspec);
3532       set_user_assembler_name (decl, asmspec);
3533     }
3534
3535   /* If #pragma weak was used, mark the decl weak now.  */
3536   maybe_apply_pragma_weak (decl);
3537
3538   /* Output the assembler code and/or RTL code for variables and functions,
3539      unless the type is an undefined structure or union.
3540      If not, it will get done when the type is completed.  */
3541
3542   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3543     {
3544       /* Determine the ELF visibility.  */
3545       if (TREE_PUBLIC (decl))
3546         c_determine_visibility (decl);
3547
3548       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
3549       if (c_dialect_objc ())
3550         objc_check_decl (decl);
3551
3552       if (asmspec)
3553         {
3554           /* If this is not a static variable, issue a warning.
3555              It doesn't make any sense to give an ASMSPEC for an
3556              ordinary, non-register local variable.  Historically,
3557              GCC has accepted -- but ignored -- the ASMSPEC in
3558              this case.  */
3559           if (!DECL_FILE_SCOPE_P (decl)
3560               && TREE_CODE (decl) == VAR_DECL
3561               && !C_DECL_REGISTER (decl)
3562               && !TREE_STATIC (decl))
3563             warning (0, "ignoring asm-specifier for non-static local "
3564                      "variable %q+D", decl);
3565           else
3566             set_user_assembler_name (decl, asmspec);
3567         }
3568
3569       if (DECL_FILE_SCOPE_P (decl))
3570         {
3571           if (DECL_INITIAL (decl) == NULL_TREE
3572               || DECL_INITIAL (decl) == error_mark_node)
3573             /* Don't output anything
3574                when a tentative file-scope definition is seen.
3575                But at end of compilation, do output code for them.  */
3576             DECL_DEFER_OUTPUT (decl) = 1;
3577           rest_of_decl_compilation (decl, true, 0);
3578         }
3579       else
3580         {
3581           /* In conjunction with an ASMSPEC, the `register'
3582              keyword indicates that we should place the variable
3583              in a particular register.  */
3584           if (asmspec && C_DECL_REGISTER (decl))
3585             {
3586               DECL_HARD_REGISTER (decl) = 1;
3587               /* This cannot be done for a structure with volatile
3588                  fields, on which DECL_REGISTER will have been
3589                  reset.  */
3590               if (!DECL_REGISTER (decl))
3591                 error ("cannot put object with volatile field into register");
3592             }
3593
3594           if (TREE_CODE (decl) != FUNCTION_DECL)
3595             {
3596               /* If we're building a variable sized type, and we might be
3597                  reachable other than via the top of the current binding
3598                  level, then create a new BIND_EXPR so that we deallocate
3599                  the object at the right time.  */
3600               /* Note that DECL_SIZE can be null due to errors.  */
3601               if (DECL_SIZE (decl)
3602                   && !TREE_CONSTANT (DECL_SIZE (decl))
3603                   && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
3604                 {
3605                   tree bind;
3606                   bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
3607                   TREE_SIDE_EFFECTS (bind) = 1;
3608                   add_stmt (bind);
3609                   BIND_EXPR_BODY (bind) = push_stmt_list ();
3610                 }
3611               add_stmt (build_stmt (DECL_EXPR, decl));
3612             }
3613         }
3614
3615
3616       if (!DECL_FILE_SCOPE_P (decl))
3617         {
3618           /* Recompute the RTL of a local array now
3619              if it used to be an incomplete type.  */
3620           if (was_incomplete
3621               && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
3622             {
3623               /* If we used it already as memory, it must stay in memory.  */
3624               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3625               /* If it's still incomplete now, no init will save it.  */
3626               if (DECL_SIZE (decl) == 0)
3627                 DECL_INITIAL (decl) = 0;
3628             }
3629         }
3630     }
3631
3632   /* If this was marked 'used', be sure it will be output.  */
3633   if (!flag_unit_at_a_time && lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
3634     mark_decl_referenced (decl);
3635
3636   if (TREE_CODE (decl) == TYPE_DECL)
3637     {
3638       if (!DECL_FILE_SCOPE_P (decl)
3639           && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3640         add_stmt (build_stmt (DECL_EXPR, decl));
3641
3642       rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
3643     }
3644
3645   /* At the end of a declaration, throw away any variable type sizes
3646      of types defined inside that declaration.  There is no use
3647      computing them in the following function definition.  */
3648   if (current_scope == file_scope)
3649     get_pending_sizes ();
3650
3651   /* Install a cleanup (aka destructor) if one was given.  */
3652   if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
3653     {
3654       tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
3655       if (attr)
3656         {
3657           tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
3658           tree cleanup_decl = lookup_name (cleanup_id);
3659           tree cleanup;
3660
3661           /* Build "cleanup(&decl)" for the destructor.  */
3662           cleanup = build_unary_op (ADDR_EXPR, decl, 0);
3663           cleanup = build_tree_list (NULL_TREE, cleanup);
3664           cleanup = build_function_call (cleanup_decl, cleanup);
3665
3666           /* Don't warn about decl unused; the cleanup uses it.  */
3667           TREE_USED (decl) = 1;
3668           TREE_USED (cleanup_decl) = 1;
3669
3670           /* Initialize EH, if we've been told to do so.  */
3671           c_maybe_initialize_eh ();
3672
3673           push_cleanup (decl, cleanup, false);
3674         }
3675     }
3676 }
3677
3678 /* Given a parsed parameter declaration, decode it into a PARM_DECL.  */
3679
3680 tree
3681 grokparm (const struct c_parm *parm)
3682 {
3683   tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
3684                               NULL);
3685
3686   decl_attributes (&decl, parm->attrs, 0);
3687
3688   return decl;
3689 }
3690
3691 /* Given a parsed parameter declaration, decode it into a PARM_DECL
3692    and push that on the current scope.  */
3693
3694 void
3695 push_parm_decl (const struct c_parm *parm)
3696 {
3697   tree decl;
3698
3699   decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL);
3700   decl_attributes (&decl, parm->attrs, 0);
3701
3702   decl = pushdecl (decl);
3703
3704   finish_decl (decl, NULL_TREE, NULL_TREE);
3705 }
3706
3707 /* Mark all the parameter declarations to date as forward decls.
3708    Also diagnose use of this extension.  */
3709
3710 void
3711 mark_forward_parm_decls (void)
3712 {
3713   struct c_binding *b;
3714
3715   if (pedantic && !current_scope->warned_forward_parm_decls)
3716     {
3717       pedwarn ("ISO C forbids forward parameter declarations");
3718       current_scope->warned_forward_parm_decls = true;
3719     }
3720
3721   for (b = current_scope->bindings; b; b = b->prev)
3722     if (TREE_CODE (b->decl) == PARM_DECL)
3723       TREE_ASM_WRITTEN (b->decl) = 1;
3724 }
3725 \f
3726 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
3727    literal, which may be an incomplete array type completed by the
3728    initializer; INIT is a CONSTRUCTOR that initializes the compound
3729    literal.  */
3730
3731 tree
3732 build_compound_literal (tree type, tree init)
3733 {
3734   /* We do not use start_decl here because we have a type, not a declarator;
3735      and do not use finish_decl because the decl should be stored inside
3736      the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR.  */
3737   tree decl;
3738   tree complit;
3739   tree stmt;
3740
3741   if (type == error_mark_node)
3742     return error_mark_node;
3743
3744   decl = build_decl (VAR_DECL, NULL_TREE, type);
3745   DECL_EXTERNAL (decl) = 0;
3746   TREE_PUBLIC (decl) = 0;
3747   TREE_STATIC (decl) = (current_scope == file_scope);
3748   DECL_CONTEXT (decl) = current_function_decl;
3749   TREE_USED (decl) = 1;
3750   TREE_TYPE (decl) = type;
3751   TREE_READONLY (decl) = TYPE_READONLY (type);
3752   store_init_value (decl, init);
3753
3754   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3755     {
3756       int failure = complete_array_type (&TREE_TYPE (decl),
3757                                          DECL_INITIAL (decl), true);
3758       gcc_assert (!failure);
3759
3760       type = TREE_TYPE (decl);
3761       TREE_TYPE (DECL_INITIAL (decl)) = type;
3762     }
3763
3764   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3765     return error_mark_node;
3766
3767   stmt = build_stmt (DECL_EXPR, decl);
3768   complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
3769   TREE_SIDE_EFFECTS (complit) = 1;
3770
3771   layout_decl (decl, 0);
3772
3773   if (TREE_STATIC (decl))
3774     {
3775       /* This decl needs a name for the assembler output.  */
3776       set_compound_literal_name (decl);
3777       DECL_DEFER_OUTPUT (decl) = 1;
3778       DECL_COMDAT (decl) = 1;
3779       DECL_ARTIFICIAL (decl) = 1;
3780       DECL_IGNORED_P (decl) = 1;
3781       pushdecl (decl);
3782       rest_of_decl_compilation (decl, 1, 0);
3783     }
3784
3785   return complit;
3786 }
3787 \f
3788 /* Determine whether TYPE is a structure with a flexible array member,
3789    or a union containing such a structure (possibly recursively).  */
3790
3791 static bool
3792 flexible_array_type_p (tree type)
3793 {
3794   tree x;
3795   switch (TREE_CODE (type))
3796     {
3797     case RECORD_TYPE:
3798       x = TYPE_FIELDS (type);
3799       if (x == NULL_TREE)
3800         return false;
3801       while (TREE_CHAIN (x) != NULL_TREE)
3802         x = TREE_CHAIN (x);
3803       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3804           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3805           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3806           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3807         return true;
3808       return false;
3809     case UNION_TYPE:
3810       for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3811         {
3812           if (flexible_array_type_p (TREE_TYPE (x)))
3813             return true;
3814         }
3815       return false;
3816     default:
3817     return false;
3818   }
3819 }
3820 \f
3821 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
3822    replacing with appropriate values if they are invalid.  */
3823 static void
3824 check_bitfield_type_and_width (tree *type, tree *width, const char *orig_name)
3825 {
3826   tree type_mv;
3827   unsigned int max_width;
3828   unsigned HOST_WIDE_INT w;
3829   const char *name = orig_name ? orig_name: _("<anonymous>");
3830
3831   /* Detect and ignore out of range field width and process valid
3832      field widths.  */
3833   if (!INTEGRAL_TYPE_P (TREE_TYPE (*width))
3834       || TREE_CODE (*width) != INTEGER_CST)
3835     {
3836       error ("bit-field %qs width not an integer constant", name);
3837       *width = integer_one_node;
3838     }
3839   else
3840     {
3841       constant_expression_warning (*width);
3842       if (tree_int_cst_sgn (*width) < 0)
3843         {
3844           error ("negative width in bit-field %qs", name);
3845           *width = integer_one_node;
3846         }
3847       else if (integer_zerop (*width) && orig_name)
3848         {
3849           error ("zero width for bit-field %qs", name);
3850           *width = integer_one_node;
3851         }
3852     }
3853
3854   /* Detect invalid bit-field type.  */
3855   if (TREE_CODE (*type) != INTEGER_TYPE
3856       && TREE_CODE (*type) != BOOLEAN_TYPE
3857       && TREE_CODE (*type) != ENUMERAL_TYPE)
3858     {
3859       error ("bit-field %qs has invalid type", name);
3860       *type = unsigned_type_node;
3861     }
3862
3863   type_mv = TYPE_MAIN_VARIANT (*type);
3864   if (pedantic
3865       && !in_system_header
3866       && type_mv != integer_type_node
3867       && type_mv != unsigned_type_node
3868       && type_mv != boolean_type_node)
3869     pedwarn ("type of bit-field %qs is a GCC extension", name);
3870
3871   if (type_mv == boolean_type_node)
3872     max_width = CHAR_TYPE_SIZE;
3873   else
3874     max_width = TYPE_PRECISION (*type);
3875
3876   if (0 < compare_tree_int (*width, max_width))
3877     {
3878       error ("width of %qs exceeds its type", name);
3879       w = max_width;
3880       *width = build_int_cst (NULL_TREE, w);
3881     }
3882   else
3883     w = tree_low_cst (*width, 1);
3884
3885   if (TREE_CODE (*type) == ENUMERAL_TYPE)
3886     {
3887       struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
3888       if (!lt
3889           || w < min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
3890           || w < min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
3891         warning (0, "%qs is narrower than values of its type", name);
3892     }
3893 }
3894
3895 \f
3896
3897 /* Print warning about variable length array if necessary.  */
3898
3899 static void
3900 warn_variable_length_array (const char *name, tree size)
3901 {
3902   int ped = !flag_isoc99 && pedantic && warn_vla != 0;
3903   int const_size = TREE_CONSTANT (size);
3904
3905   if (ped)
3906     {
3907       if (const_size)
3908         {
3909           if (name)
3910             pedwarn ("ISO C90 forbids array %qs whose size "
3911                      "can%'t be evaluated",
3912                      name);
3913           else
3914             pedwarn ("ISO C90 forbids array whose size "
3915                      "can%'t be evaluated");
3916         }
3917       else
3918         {
3919           if (name)
3920             pedwarn ("ISO C90 forbids variable length array %qs",
3921                      name);
3922           else
3923             pedwarn ("ISO C90 forbids variable length array");
3924         }
3925     }
3926   else if (warn_vla > 0)
3927     {
3928       if (const_size)
3929         {
3930           if (name)
3931             warning (OPT_Wvla,
3932                      "the size of array %qs can"
3933                      "%'t be evaluated", name);
3934           else
3935             warning (OPT_Wvla,
3936                      "the size of array can %'t be evaluated");
3937         }
3938       else
3939         {
3940           if (name)
3941             warning (OPT_Wvla,
3942                      "variable length array %qs is used",
3943                      name);
3944           else
3945             warning (OPT_Wvla,
3946                      "variable length array is used");
3947         }
3948     }
3949 }
3950
3951 /* Given declspecs and a declarator,
3952    determine the name and type of the object declared
3953    and construct a ..._DECL node for it.
3954    (In one case we can return a ..._TYPE node instead.
3955     For invalid input we sometimes return 0.)
3956
3957    DECLSPECS is a c_declspecs structure for the declaration specifiers.
3958
3959    DECL_CONTEXT says which syntactic context this declaration is in:
3960      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3961      FUNCDEF for a function definition.  Like NORMAL but a few different
3962       error messages in each case.  Return value may be zero meaning
3963       this definition is too screwy to try to parse.
3964      PARM for a parameter declaration (either within a function prototype
3965       or before a function body).  Make a PARM_DECL, or return void_type_node.
3966      TYPENAME if for a typename (in a cast or sizeof).
3967       Don't make a DECL node; just return the ..._TYPE node.
3968      FIELD for a struct or union field; make a FIELD_DECL.
3969    INITIALIZED is true if the decl has an initializer.
3970    WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
3971    representing the width of the bit-field.
3972
3973    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3974    It may also be so in the PARM case, for a prototype where the
3975    argument type is specified but not the name.
3976
3977    This function is where the complicated C meanings of `static'
3978    and `extern' are interpreted.  */
3979
3980 static tree
3981 grokdeclarator (const struct c_declarator *declarator,
3982                 struct c_declspecs *declspecs,
3983                 enum decl_context decl_context, bool initialized, tree *width)
3984 {
3985   tree type = declspecs->type;
3986   bool threadp = declspecs->thread_p;
3987   enum c_storage_class storage_class = declspecs->storage_class;
3988   int constp;
3989   int restrictp;
3990   int volatilep;
3991   int type_quals = TYPE_UNQUALIFIED;
3992   const char *name, *orig_name;
3993   tree typedef_type = 0;
3994   bool funcdef_flag = false;
3995   bool funcdef_syntax = false;
3996   int size_varies = 0;
3997   tree decl_attr = declspecs->decl_attr;
3998   int array_ptr_quals = TYPE_UNQUALIFIED;
3999   tree array_ptr_attrs = NULL_TREE;
4000   int array_parm_static = 0;
4001   bool array_parm_vla_unspec_p = false;
4002   tree returned_attrs = NULL_TREE;
4003   bool bitfield = width != NULL;
4004   tree element_type;
4005   struct c_arg_info *arg_info = 0;
4006
4007   if (decl_context == FUNCDEF)
4008     funcdef_flag = true, decl_context = NORMAL;
4009
4010   /* Look inside a declarator for the name being declared
4011      and get it as a string, for an error message.  */
4012   {
4013     const struct c_declarator *decl = declarator;
4014     name = 0;
4015
4016     while (decl)
4017       switch (decl->kind)
4018         {
4019         case cdk_function:
4020         case cdk_array:
4021         case cdk_pointer:
4022           funcdef_syntax = (decl->kind == cdk_function);
4023           decl = decl->declarator;
4024           break;
4025
4026         case cdk_attrs:
4027           decl = decl->declarator;
4028           break;
4029
4030         case cdk_id:
4031           if (decl->u.id)
4032             name = IDENTIFIER_POINTER (decl->u.id);
4033           decl = 0;
4034           break;
4035
4036         default:
4037           gcc_unreachable ();
4038         }
4039     orig_name = name;
4040     if (name == 0)
4041       name = "type name";
4042   }
4043
4044   /* A function definition's declarator must have the form of
4045      a function declarator.  */
4046
4047   if (funcdef_flag && !funcdef_syntax)
4048     return 0;
4049
4050   /* If this looks like a function definition, make it one,
4051      even if it occurs where parms are expected.
4052      Then store_parm_decls will reject it and not use it as a parm.  */
4053   if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
4054     decl_context = PARM;
4055
4056   if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
4057     warn_deprecated_use (declspecs->type);
4058
4059   if ((decl_context == NORMAL || decl_context == FIELD)
4060       && current_scope == file_scope
4061       && variably_modified_type_p (type, NULL_TREE))
4062     {
4063       error ("variably modified %qs at file scope", name);
4064       type = integer_type_node;
4065     }
4066
4067   typedef_type = type;
4068   size_varies = C_TYPE_VARIABLE_SIZE (type);
4069
4070   /* Diagnose defaulting to "int".  */
4071
4072   if (declspecs->default_int_p && !in_system_header)
4073     {
4074       /* Issue a warning if this is an ISO C 99 program or if
4075          -Wreturn-type and this is a function, or if -Wimplicit;
4076          prefer the former warning since it is more explicit.  */
4077       if ((warn_implicit_int || warn_return_type || flag_isoc99)
4078           && funcdef_flag)
4079         warn_about_return_type = 1;
4080       else if (warn_implicit_int || flag_isoc99)
4081         pedwarn_c99 ("type defaults to %<int%> in declaration of %qs", name);
4082     }
4083
4084   /* Adjust the type if a bit-field is being declared,
4085      -funsigned-bitfields applied and the type is not explicitly
4086      "signed".  */
4087   if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
4088       && TREE_CODE (type) == INTEGER_TYPE)
4089     type = c_common_unsigned_type (type);
4090
4091   /* Figure out the type qualifiers for the declaration.  There are
4092      two ways a declaration can become qualified.  One is something
4093      like `const int i' where the `const' is explicit.  Another is
4094      something like `typedef const int CI; CI i' where the type of the
4095      declaration contains the `const'.  A third possibility is that
4096      there is a type qualifier on the element type of a typedefed
4097      array type, in which case we should extract that qualifier so
4098      that c_apply_type_quals_to_decls receives the full list of
4099      qualifiers to work with (C90 is not entirely clear about whether
4100      duplicate qualifiers should be diagnosed in this case, but it
4101      seems most appropriate to do so).  */
4102   element_type = strip_array_types (type);
4103   constp = declspecs->const_p + TYPE_READONLY (element_type);
4104   restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
4105   volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
4106   if (pedantic && !flag_isoc99)
4107     {
4108       if (constp > 1)
4109         pedwarn ("duplicate %<const%>");
4110       if (restrictp > 1)
4111         pedwarn ("duplicate %<restrict%>");
4112       if (volatilep > 1)
4113         pedwarn ("duplicate %<volatile%>");
4114     }
4115   if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
4116     type = TYPE_MAIN_VARIANT (type);
4117   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4118                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4119                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4120
4121   /* Warn about storage classes that are invalid for certain
4122      kinds of declarations (parameters, typenames, etc.).  */
4123
4124   if (funcdef_flag
4125       && (threadp
4126           || storage_class == csc_auto
4127           || storage_class == csc_register
4128           || storage_class == csc_typedef))
4129     {
4130       if (storage_class == csc_auto
4131           && (pedantic || current_scope == file_scope))
4132         pedwarn ("function definition declared %<auto%>");
4133       if (storage_class == csc_register)
4134         error ("function definition declared %<register%>");
4135       if (storage_class == csc_typedef)
4136         error ("function definition declared %<typedef%>");
4137       if (threadp)
4138         error ("function definition declared %<__thread%>");
4139       threadp = false;
4140       if (storage_class == csc_auto
4141           || storage_class == csc_register
4142           || storage_class == csc_typedef)
4143         storage_class = csc_none;
4144     }
4145   else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
4146     {
4147       if (decl_context == PARM && storage_class == csc_register)
4148         ;
4149       else
4150         {
4151           switch (decl_context)
4152             {
4153             case FIELD:
4154               error ("storage class specified for structure field %qs",
4155                      name);
4156               break;
4157             case PARM:
4158               error ("storage class specified for parameter %qs", name);
4159               break;
4160             default:
4161               error ("storage class specified for typename");
4162               break;
4163             }
4164           storage_class = csc_none;
4165           threadp = false;
4166         }
4167     }
4168   else if (storage_class == csc_extern
4169            && initialized
4170            && !funcdef_flag)
4171     {
4172       /* 'extern' with initialization is invalid if not at file scope.  */
4173        if (current_scope == file_scope)
4174          {
4175            /* It is fine to have 'extern const' when compiling at C
4176               and C++ intersection.  */
4177            if (!(warn_cxx_compat && constp))
4178              warning (0, "%qs initialized and declared %<extern%>", name);
4179          }
4180       else
4181         error ("%qs has both %<extern%> and initializer", name);
4182     }
4183   else if (current_scope == file_scope)
4184     {
4185       if (storage_class == csc_auto)
4186         error ("file-scope declaration of %qs specifies %<auto%>", name);
4187       if (pedantic && storage_class == csc_register)
4188         pedwarn ("file-scope declaration of %qs specifies %<register%>", name);
4189     }
4190   else
4191     {
4192       if (storage_class == csc_extern && funcdef_flag)
4193         error ("nested function %qs declared %<extern%>", name);
4194       else if (threadp && storage_class == csc_none)
4195         {
4196           error ("function-scope %qs implicitly auto and declared "
4197                  "%<__thread%>",
4198                  name);
4199           threadp = false;
4200         }
4201     }
4202
4203   /* Now figure out the structure of the declarator proper.
4204      Descend through it, creating more complex types, until we reach
4205      the declared identifier (or NULL_TREE, in an absolute declarator).
4206      At each stage we maintain an unqualified version of the type
4207      together with any qualifiers that should be applied to it with
4208      c_build_qualified_type; this way, array types including
4209      multidimensional array types are first built up in unqualified
4210      form and then the qualified form is created with
4211      TYPE_MAIN_VARIANT pointing to the unqualified form.  */
4212
4213   while (declarator && declarator->kind != cdk_id)
4214     {
4215       if (type == error_mark_node)
4216         {
4217           declarator = declarator->declarator;
4218           continue;
4219         }
4220
4221       /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
4222          a cdk_pointer (for *...),
4223          a cdk_function (for ...(...)),
4224          a cdk_attrs (for nested attributes),
4225          or a cdk_id (for the name being declared
4226          or the place in an absolute declarator
4227          where the name was omitted).
4228          For the last case, we have just exited the loop.
4229
4230          At this point, TYPE is the type of elements of an array,
4231          or for a function to return, or for a pointer to point to.
4232          After this sequence of ifs, TYPE is the type of the
4233          array or function or pointer, and DECLARATOR has had its
4234          outermost layer removed.  */
4235
4236       if (array_ptr_quals != TYPE_UNQUALIFIED
4237           || array_ptr_attrs != NULL_TREE
4238           || array_parm_static)
4239         {
4240           /* Only the innermost declarator (making a parameter be of
4241              array type which is converted to pointer type)
4242              may have static or type qualifiers.  */
4243           error ("static or type qualifiers in non-parameter array declarator");
4244           array_ptr_quals = TYPE_UNQUALIFIED;
4245           array_ptr_attrs = NULL_TREE;
4246           array_parm_static = 0;
4247         }
4248
4249       switch (declarator->kind)
4250         {
4251         case cdk_attrs:
4252           {
4253             /* A declarator with embedded attributes.  */
4254             tree attrs = declarator->u.attrs;
4255             const struct c_declarator *inner_decl;
4256             int attr_flags = 0;
4257             declarator = declarator->declarator;
4258             inner_decl = declarator;
4259             while (inner_decl->kind == cdk_attrs)
4260               inner_decl = inner_decl->declarator;
4261             if (inner_decl->kind == cdk_id)
4262               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
4263             else if (inner_decl->kind == cdk_function)
4264               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
4265             else if (inner_decl->kind == cdk_array)
4266               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
4267             returned_attrs = decl_attributes (&type,
4268                                               chainon (returned_attrs, attrs),
4269                                               attr_flags);
4270             break;
4271           }
4272         case cdk_array:
4273           {
4274             tree itype = NULL_TREE;
4275             tree size = declarator->u.array.dimen;
4276             /* The index is a signed object `sizetype' bits wide.  */
4277             tree index_type = c_common_signed_type (sizetype);
4278
4279             array_ptr_quals = declarator->u.array.quals;
4280             array_ptr_attrs = declarator->u.array.attrs;
4281             array_parm_static = declarator->u.array.static_p;
4282             array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
4283
4284             declarator = declarator->declarator;
4285
4286             /* Check for some types that there cannot be arrays of.  */
4287
4288             if (VOID_TYPE_P (type))
4289               {
4290                 error ("declaration of %qs as array of voids", name);
4291                 type = error_mark_node;
4292               }
4293
4294             if (TREE_CODE (type) == FUNCTION_TYPE)
4295               {
4296                 error ("declaration of %qs as array of functions", name);
4297                 type = error_mark_node;
4298               }
4299
4300             if (pedantic && !in_system_header && flexible_array_type_p (type))
4301               pedwarn ("invalid use of structure with flexible array member");
4302
4303             if (size == error_mark_node)
4304               type = error_mark_node;
4305
4306             if (type == error_mark_node)
4307               continue;
4308
4309             /* If size was specified, set ITYPE to a range-type for
4310                that size.  Otherwise, ITYPE remains null.  finish_decl
4311                may figure it out from an initial value.  */
4312
4313             if (size)
4314               {
4315                 /* Strip NON_LVALUE_EXPRs since we aren't using as an
4316                    lvalue.  */
4317                 STRIP_TYPE_NOPS (size);
4318
4319                 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
4320                   {
4321                     error ("size of array %qs has non-integer type", name);
4322                     size = integer_one_node;
4323                   }
4324
4325                 if (pedantic && integer_zerop (size))
4326                   pedwarn ("ISO C forbids zero-size array %qs", name);
4327
4328                 if (TREE_CODE (size) == INTEGER_CST)
4329                   {
4330                     constant_expression_warning (size);
4331                     if (tree_int_cst_sgn (size) < 0)
4332                       {
4333                         error ("size of array %qs is negative", name);
4334                         size = integer_one_node;
4335                       }
4336                   }
4337                 else if ((decl_context == NORMAL || decl_context == FIELD)
4338                          && current_scope == file_scope)
4339                   {
4340                     error ("variably modified %qs at file scope", name);
4341                     size = integer_one_node;
4342                   }
4343                 else
4344                   {
4345                     /* Make sure the array size remains visibly
4346                        nonconstant even if it is (eg) a const variable
4347                        with known value.  */
4348                     size_varies = 1;
4349                     warn_variable_length_array (orig_name, size);
4350                   }
4351
4352                 if (integer_zerop (size))
4353                   {
4354                     /* A zero-length array cannot be represented with
4355                        an unsigned index type, which is what we'll
4356                        get with build_index_type.  Create an
4357                        open-ended range instead.  */
4358                     itype = build_range_type (sizetype, size, NULL_TREE);
4359                   }
4360                 else
4361                   {
4362                     /* Arrange for the SAVE_EXPR on the inside of the
4363                        MINUS_EXPR, which allows the -1 to get folded
4364                        with the +1 that happens when building TYPE_SIZE.  */
4365                     if (size_varies)
4366                       size = variable_size (size);
4367
4368                     /* Compute the maximum valid index, that is, size
4369                        - 1.  Do the calculation in index_type, so that
4370                        if it is a variable the computations will be
4371                        done in the proper mode.  */
4372                     itype = fold_build2 (MINUS_EXPR, index_type,
4373                                          convert (index_type, size),
4374                                          convert (index_type,
4375                                                   size_one_node));
4376
4377                     /* If that overflowed, the array is too big.  ???
4378                        While a size of INT_MAX+1 technically shouldn't
4379                        cause an overflow (because we subtract 1), the
4380                        overflow is recorded during the conversion to
4381                        index_type, before the subtraction.  Handling
4382                        this case seems like an unnecessary
4383                        complication.  */
4384                     if (TREE_CODE (itype) == INTEGER_CST
4385                         && TREE_OVERFLOW (itype))
4386                       {
4387                         error ("size of array %qs is too large", name);
4388                         type = error_mark_node;
4389                         continue;
4390                       }
4391
4392                     itype = build_index_type (itype);
4393                   }
4394               }
4395             else if (decl_context == FIELD)
4396               {
4397                 if (pedantic && !flag_isoc99 && !in_system_header)
4398                   pedwarn ("ISO C90 does not support flexible array members");
4399
4400                 /* ISO C99 Flexible array members are effectively
4401                    identical to GCC's zero-length array extension.  */
4402                 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4403               }
4404             else if (decl_context == PARM)
4405               {
4406                 if (array_parm_vla_unspec_p)
4407                   {
4408                     if (! orig_name)
4409                       {
4410                         /* C99 6.7.5.2p4 */
4411                         error ("%<[*]%> not allowed in other than a declaration");
4412                       }
4413
4414                     itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4415                     size_varies = 1;
4416                   }
4417               }
4418             else if (decl_context == TYPENAME)
4419               {
4420                 if (array_parm_vla_unspec_p)
4421                   {
4422                     /* The error is printed elsewhere.  We use this to
4423                        avoid messing up with incomplete array types of
4424                        the same type, that would otherwise be modified
4425                        below.  */
4426                     itype = build_range_type (sizetype, size_zero_node,
4427                                               NULL_TREE);
4428                   }
4429               }
4430
4431              /* Complain about arrays of incomplete types.  */
4432             if (!COMPLETE_TYPE_P (type))
4433               {
4434                 error ("array type has incomplete element type");
4435                 type = error_mark_node;
4436               }
4437             else
4438             /* When itype is NULL, a shared incomplete array type is
4439                returned for all array of a given type.  Elsewhere we
4440                make sure we don't complete that type before copying
4441                it, but here we want to make sure we don't ever
4442                modify the shared type, so we gcc_assert (itype)
4443                below.  */
4444               type = build_array_type (type, itype);
4445
4446             if (type != error_mark_node)
4447               {
4448                 if (size_varies)
4449                   {
4450                     /* It is ok to modify type here even if itype is
4451                        NULL: if size_varies, we're in a
4452                        multi-dimensional array and the inner type has
4453                        variable size, so the enclosing shared array type
4454                        must too.  */
4455                     if (size && TREE_CODE (size) == INTEGER_CST)
4456                       type
4457                         = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
4458                     C_TYPE_VARIABLE_SIZE (type) = 1;
4459                   }
4460
4461                 /* The GCC extension for zero-length arrays differs from
4462                    ISO flexible array members in that sizeof yields
4463                    zero.  */
4464                 if (size && integer_zerop (size))
4465                   {
4466                     gcc_assert (itype);
4467                     TYPE_SIZE (type) = bitsize_zero_node;
4468                     TYPE_SIZE_UNIT (type) = size_zero_node;
4469                   }
4470                 if (array_parm_vla_unspec_p)
4471                   {
4472                     gcc_assert (itype);
4473                     /* The type is complete.  C99 6.7.5.2p4  */
4474                     TYPE_SIZE (type) = bitsize_zero_node;
4475                     TYPE_SIZE_UNIT (type) = size_zero_node;
4476                   }
4477               }
4478
4479             if (decl_context != PARM
4480                 && (array_ptr_quals != TYPE_UNQUALIFIED
4481                     || array_ptr_attrs != NULL_TREE
4482                     || array_parm_static))
4483               {
4484                 error ("static or type qualifiers in non-parameter array declarator");
4485                 array_ptr_quals = TYPE_UNQUALIFIED;
4486                 array_ptr_attrs = NULL_TREE;
4487                 array_parm_static = 0;
4488               }
4489             break;
4490           }
4491         case cdk_function:
4492           {
4493             /* Say it's a definition only for the declarator closest
4494                to the identifier, apart possibly from some
4495                attributes.  */
4496             bool really_funcdef = false;
4497             tree arg_types;
4498             if (funcdef_flag)
4499               {
4500                 const struct c_declarator *t = declarator->declarator;
4501                 while (t->kind == cdk_attrs)
4502                   t = t->declarator;
4503                 really_funcdef = (t->kind == cdk_id);
4504               }
4505
4506             /* Declaring a function type.  Make sure we have a valid
4507                type for the function to return.  */
4508             if (type == error_mark_node)
4509               continue;
4510
4511             size_varies = 0;
4512
4513             /* Warn about some types functions can't return.  */
4514             if (TREE_CODE (type) == FUNCTION_TYPE)
4515               {
4516                 error ("%qs declared as function returning a function", name);
4517                 type = integer_type_node;
4518               }
4519             if (TREE_CODE (type) == ARRAY_TYPE)
4520               {
4521                 error ("%qs declared as function returning an array", name);
4522                 type = integer_type_node;
4523               }
4524
4525             /* Construct the function type and go to the next
4526                inner layer of declarator.  */
4527             arg_info = declarator->u.arg_info;
4528             arg_types = grokparms (arg_info, really_funcdef);
4529             if (really_funcdef)
4530               put_pending_sizes (arg_info->pending_sizes);
4531
4532             /* Type qualifiers before the return type of the function
4533                qualify the return type, not the function type.  */
4534             if (type_quals)
4535               {
4536                 /* Type qualifiers on a function return type are
4537                    normally permitted by the standard but have no
4538                    effect, so give a warning at -Wreturn-type.
4539                    Qualifiers on a void return type are banned on
4540                    function definitions in ISO C; GCC used to used
4541                    them for noreturn functions.  */
4542                 if (VOID_TYPE_P (type) && really_funcdef)
4543                   pedwarn ("function definition has qualified void return type");
4544                 else
4545                   warning (OPT_Wreturn_type,
4546                            "type qualifiers ignored on function return type");
4547
4548                 type = c_build_qualified_type (type, type_quals);
4549               }
4550             type_quals = TYPE_UNQUALIFIED;
4551
4552             type = build_function_type (type, arg_types);
4553             declarator = declarator->declarator;
4554
4555             /* Set the TYPE_CONTEXTs for each tagged type which is local to
4556                the formal parameter list of this FUNCTION_TYPE to point to
4557                the FUNCTION_TYPE node itself.  */
4558             {
4559               tree link;
4560
4561               for (link = arg_info->tags;
4562                    link;
4563                    link = TREE_CHAIN (link))
4564                 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4565             }
4566             break;
4567           }
4568         case cdk_pointer:
4569           {
4570             /* Merge any constancy or volatility into the target type
4571                for the pointer.  */
4572
4573             if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4574                 && type_quals)
4575               pedwarn ("ISO C forbids qualified function types");
4576             if (type_quals)
4577               type = c_build_qualified_type (type, type_quals);
4578             size_varies = 0;
4579
4580             /* When the pointed-to type involves components of variable size,
4581                care must be taken to ensure that the size evaluation code is
4582                emitted early enough to dominate all the possible later uses
4583                and late enough for the variables on which it depends to have
4584                been assigned.
4585
4586                This is expected to happen automatically when the pointed-to
4587                type has a name/declaration of it's own, but special attention
4588                is required if the type is anonymous.
4589
4590                We handle the NORMAL and FIELD contexts here by attaching an
4591                artificial TYPE_DECL to such pointed-to type.  This forces the
4592                sizes evaluation at a safe point and ensures it is not deferred
4593                until e.g. within a deeper conditional context.
4594
4595                We expect nothing to be needed here for PARM or TYPENAME.
4596                Pushing a TYPE_DECL at this point for TYPENAME would actually
4597                be incorrect, as we might be in the middle of an expression
4598                with side effects on the pointed-to type size "arguments" prior
4599                to the pointer declaration point and the fake TYPE_DECL in the
4600                enclosing context would force the size evaluation prior to the
4601                side effects.  */
4602
4603             if (!TYPE_NAME (type)
4604                 && (decl_context == NORMAL || decl_context == FIELD)
4605                 && variably_modified_type_p (type, NULL_TREE))
4606               {
4607                 tree decl = build_decl (TYPE_DECL, NULL_TREE, type);
4608                 DECL_ARTIFICIAL (decl) = 1;
4609                 pushdecl (decl);
4610                 finish_decl (decl, NULL_TREE, NULL_TREE);
4611                 TYPE_NAME (type) = decl;
4612               }
4613
4614             type = build_pointer_type (type);
4615
4616             /* Process type qualifiers (such as const or volatile)
4617                that were given inside the `*'.  */
4618             type_quals = declarator->u.pointer_quals;
4619
4620             declarator = declarator->declarator;
4621             break;
4622           }
4623         default:
4624           gcc_unreachable ();
4625         }
4626     }
4627
4628   /* Now TYPE has the actual type, apart from any qualifiers in
4629      TYPE_QUALS.  */
4630
4631   /* Check the type and width of a bit-field.  */
4632   if (bitfield)
4633     check_bitfield_type_and_width (&type, width, orig_name);
4634
4635   /* Did array size calculations overflow?  */
4636
4637   if (TREE_CODE (type) == ARRAY_TYPE
4638       && COMPLETE_TYPE_P (type)
4639       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
4640       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
4641     {
4642       error ("size of array %qs is too large", name);
4643       /* If we proceed with the array type as it is, we'll eventually
4644          crash in tree_low_cst().  */
4645       type = error_mark_node;
4646     }
4647
4648   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4649
4650   if (storage_class == csc_typedef)
4651     {
4652       tree decl;
4653       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4654           && type_quals)
4655         pedwarn ("ISO C forbids qualified function types");
4656       if (type_quals)
4657         type = c_build_qualified_type (type, type_quals);
4658       decl = build_decl (TYPE_DECL, declarator->u.id, type);
4659       if (declspecs->explicit_signed_p)
4660         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4661       decl_attributes (&decl, returned_attrs, 0);
4662       if (declspecs->inline_p)
4663         pedwarn ("typedef %q+D declared %<inline%>", decl);
4664       return decl;
4665     }
4666
4667   /* If this is a type name (such as, in a cast or sizeof),
4668      compute the type and return it now.  */
4669
4670   if (decl_context == TYPENAME)
4671     {
4672       /* Note that the grammar rejects storage classes in typenames
4673          and fields.  */
4674       gcc_assert (storage_class == csc_none && !threadp
4675                   && !declspecs->inline_p);
4676       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4677           && type_quals)
4678         pedwarn ("ISO C forbids const or volatile function types");
4679       if (type_quals)
4680         type = c_build_qualified_type (type, type_quals);
4681       decl_attributes (&type, returned_attrs, 0);
4682       return type;
4683     }
4684
4685   if (pedantic && decl_context == FIELD
4686       && variably_modified_type_p (type, NULL_TREE))
4687     {
4688       /* C99 6.7.2.1p8 */
4689       pedwarn ("a member of a structure or union cannot have a variably modified type");
4690     }
4691
4692   /* Aside from typedefs and type names (handle above),
4693      `void' at top level (not within pointer)
4694      is allowed only in public variables.
4695      We don't complain about parms either, but that is because
4696      a better error message can be made later.  */
4697
4698   if (VOID_TYPE_P (type) && decl_context != PARM
4699       && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4700             && (storage_class == csc_extern
4701                 || (current_scope == file_scope
4702                     && !(storage_class == csc_static
4703                          || storage_class == csc_register)))))
4704     {
4705       error ("variable or field %qs declared void", name);
4706       type = integer_type_node;
4707     }
4708
4709   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4710      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4711
4712   {
4713     tree decl;
4714
4715     if (decl_context == PARM)
4716       {
4717         tree type_as_written;
4718         tree promoted_type;
4719
4720         /* A parameter declared as an array of T is really a pointer to T.
4721            One declared as a function is really a pointer to a function.  */
4722
4723         if (TREE_CODE (type) == ARRAY_TYPE)
4724           {
4725             /* Transfer const-ness of array into that of type pointed to.  */
4726             type = TREE_TYPE (type);
4727             if (type_quals)
4728               type = c_build_qualified_type (type, type_quals);
4729             type = build_pointer_type (type);
4730             type_quals = array_ptr_quals;
4731
4732             /* We don't yet implement attributes in this context.  */
4733             if (array_ptr_attrs != NULL_TREE)
4734               warning (OPT_Wattributes,
4735                        "attributes in parameter array declarator ignored");
4736
4737             size_varies = 0;
4738           }
4739         else if (TREE_CODE (type) == FUNCTION_TYPE)
4740           {
4741             if (pedantic && type_quals)
4742               pedwarn ("ISO C forbids qualified function types");
4743             if (type_quals)
4744               type = c_build_qualified_type (type, type_quals);
4745             type = build_pointer_type (type);
4746             type_quals = TYPE_UNQUALIFIED;
4747           }
4748         else if (type_quals)
4749           type = c_build_qualified_type (type, type_quals);
4750
4751         type_as_written = type;
4752
4753         decl = build_decl (PARM_DECL, declarator->u.id, type);
4754         if (size_varies)
4755           C_DECL_VARIABLE_SIZE (decl) = 1;
4756
4757         /* Compute the type actually passed in the parmlist,
4758            for the case where there is no prototype.
4759            (For example, shorts and chars are passed as ints.)
4760            When there is a prototype, this is overridden later.  */
4761
4762         if (type == error_mark_node)
4763           promoted_type = type;
4764         else
4765           promoted_type = c_type_promotes_to (type);
4766
4767         DECL_ARG_TYPE (decl) = promoted_type;
4768         if (declspecs->inline_p)
4769           pedwarn ("parameter %q+D declared %<inline%>", decl);
4770       }
4771     else if (decl_context == FIELD)
4772       {
4773         /* Note that the grammar rejects storage classes in typenames
4774            and fields.  */
4775         gcc_assert (storage_class == csc_none && !threadp
4776                     && !declspecs->inline_p);
4777
4778         /* Structure field.  It may not be a function.  */
4779
4780         if (TREE_CODE (type) == FUNCTION_TYPE)
4781           {
4782             error ("field %qs declared as a function", name);
4783             type = build_pointer_type (type);
4784           }
4785         else if (TREE_CODE (type) != ERROR_MARK
4786                  && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4787           {
4788             error ("field %qs has incomplete type", name);
4789             type = error_mark_node;
4790           }
4791         type = c_build_qualified_type (type, type_quals);
4792         decl = build_decl (FIELD_DECL, declarator->u.id, type);
4793         DECL_NONADDRESSABLE_P (decl) = bitfield;
4794         if (bitfield && !declarator->u.id)
4795           TREE_NO_WARNING (decl) = 1;
4796
4797         if (size_varies)
4798           C_DECL_VARIABLE_SIZE (decl) = 1;
4799       }
4800     else if (TREE_CODE (type) == FUNCTION_TYPE)
4801       {
4802         if (storage_class == csc_register || threadp)
4803           {
4804             error ("invalid storage class for function %qs", name);
4805            }
4806         else if (current_scope != file_scope)
4807           {
4808             /* Function declaration not at file scope.  Storage
4809                classes other than `extern' are not allowed, C99
4810                6.7.1p5, and `extern' makes no difference.  However,
4811                GCC allows 'auto', perhaps with 'inline', to support
4812                nested functions.  */
4813             if (storage_class == csc_auto)
4814               {
4815                 if (pedantic)
4816                   pedwarn ("invalid storage class for function %qs", name);
4817               }
4818             else if (storage_class == csc_static)
4819               {
4820                 error ("invalid storage class for function %qs", name);
4821                 if (funcdef_flag)
4822                   storage_class = declspecs->storage_class = csc_none;
4823                 else
4824                   return 0;
4825               }
4826           }
4827
4828         decl = build_decl (FUNCTION_DECL, declarator->u.id, type);
4829         decl = build_decl_attribute_variant (decl, decl_attr);
4830
4831         DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
4832
4833         if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
4834           pedwarn ("ISO C forbids qualified function types");
4835
4836         /* GNU C interprets a volatile-qualified function type to indicate
4837            that the function does not return.  */
4838         if ((type_quals & TYPE_QUAL_VOLATILE)
4839             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4840           warning (0, "%<noreturn%> function returns non-void value");
4841
4842         /* Every function declaration is an external reference
4843            (DECL_EXTERNAL) except for those which are not at file
4844            scope and are explicitly declared "auto".  This is
4845            forbidden by standard C (C99 6.7.1p5) and is interpreted by
4846            GCC to signify a forward declaration of a nested function.  */
4847         if (storage_class == csc_auto && current_scope != file_scope)
4848           DECL_EXTERNAL (decl) = 0;
4849         /* In C99, a function which is declared 'inline' with 'extern'
4850            is not an external reference (which is confusing).  It
4851            means that the later definition of the function must be output
4852            in this file, C99 6.7.4p6.  In GNU C89, a function declared
4853            'extern inline' is an external reference.  */
4854         else if (declspecs->inline_p && storage_class != csc_static)
4855           DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
4856                                   == flag_gnu89_inline);
4857         else
4858           DECL_EXTERNAL (decl) = !initialized;
4859
4860         /* Record absence of global scope for `static' or `auto'.  */
4861         TREE_PUBLIC (decl)
4862           = !(storage_class == csc_static || storage_class == csc_auto);
4863
4864         /* For a function definition, record the argument information
4865            block where store_parm_decls will look for it.  */
4866         if (funcdef_flag)
4867           current_function_arg_info = arg_info;
4868
4869         if (declspecs->default_int_p)
4870           C_FUNCTION_IMPLICIT_INT (decl) = 1;
4871
4872         /* Record presence of `inline', if it is reasonable.  */
4873         if (flag_hosted && MAIN_NAME_P (declarator->u.id))
4874           {
4875             if (declspecs->inline_p)
4876               pedwarn ("cannot inline function %<main%>");
4877           }
4878         else if (declspecs->inline_p)
4879           {
4880             /* Record that the function is declared `inline'.  */
4881             DECL_DECLARED_INLINE_P (decl) = 1;
4882
4883             /* Do not mark bare declarations as DECL_INLINE.  Doing so
4884                in the presence of multiple declarations can result in
4885                the abstract origin pointing between the declarations,
4886                which will confuse dwarf2out.  */
4887             if (initialized)
4888               DECL_INLINE (decl) = 1;
4889           }
4890         /* If -finline-functions, assume it can be inlined.  This does
4891            two things: let the function be deferred until it is actually
4892            needed, and let dwarf2 know that the function is inlinable.  */
4893         else if (flag_inline_trees == 2 && initialized)
4894           DECL_INLINE (decl) = 1;
4895       }
4896     else
4897       {
4898         /* It's a variable.  */
4899         /* An uninitialized decl with `extern' is a reference.  */
4900         int extern_ref = !initialized && storage_class == csc_extern;
4901
4902         type = c_build_qualified_type (type, type_quals);
4903
4904         /* C99 6.2.2p7: It is invalid (compile-time undefined
4905            behavior) to create an 'extern' declaration for a
4906            variable if there is a global declaration that is
4907            'static' and the global declaration is not visible.
4908            (If the static declaration _is_ currently visible,
4909            the 'extern' declaration is taken to refer to that decl.) */
4910         if (extern_ref && current_scope != file_scope)
4911           {
4912             tree global_decl  = identifier_global_value (declarator->u.id);
4913             tree visible_decl = lookup_name (declarator->u.id);
4914
4915             if (global_decl
4916                 && global_decl != visible_decl
4917                 && TREE_CODE (global_decl) == VAR_DECL
4918                 && !TREE_PUBLIC (global_decl))
4919               error ("variable previously declared %<static%> redeclared "
4920                      "%<extern%>");
4921           }
4922
4923         decl = build_decl (VAR_DECL, declarator->u.id, type);
4924         DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
4925         if (size_varies)
4926           C_DECL_VARIABLE_SIZE (decl) = 1;
4927
4928         if (declspecs->inline_p)
4929           pedwarn ("variable %q+D declared %<inline%>", decl);
4930
4931         /* At file scope, an initialized extern declaration may follow
4932            a static declaration.  In that case, DECL_EXTERNAL will be
4933            reset later in start_decl.  */
4934         DECL_EXTERNAL (decl) = (storage_class == csc_extern);
4935
4936         /* At file scope, the presence of a `static' or `register' storage
4937            class specifier, or the absence of all storage class specifiers
4938            makes this declaration a definition (perhaps tentative).  Also,
4939            the absence of `static' makes it public.  */
4940         if (current_scope == file_scope)
4941           {
4942             TREE_PUBLIC (decl) = storage_class != csc_static;
4943             TREE_STATIC (decl) = !extern_ref;
4944           }
4945         /* Not at file scope, only `static' makes a static definition.  */
4946         else
4947           {
4948             TREE_STATIC (decl) = (storage_class == csc_static);
4949             TREE_PUBLIC (decl) = extern_ref;
4950           }
4951
4952         if (threadp)
4953           DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
4954       }
4955
4956     if (storage_class == csc_extern
4957         && variably_modified_type_p (type, NULL_TREE))
4958       {
4959         /* C99 6.7.5.2p2 */
4960         error ("object with variably modified type must have no linkage");
4961       }
4962
4963     /* Record `register' declaration for warnings on &
4964        and in case doing stupid register allocation.  */
4965
4966     if (storage_class == csc_register)
4967       {
4968         C_DECL_REGISTER (decl) = 1;
4969         DECL_REGISTER (decl) = 1;
4970       }
4971
4972     /* Record constancy and volatility.  */
4973     c_apply_type_quals_to_decl (type_quals, decl);
4974
4975     /* If a type has volatile components, it should be stored in memory.
4976        Otherwise, the fact that those components are volatile
4977        will be ignored, and would even crash the compiler.
4978        Of course, this only makes sense on  VAR,PARM, and RESULT decl's.   */
4979     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
4980         && (TREE_CODE (decl) == VAR_DECL ||  TREE_CODE (decl) == PARM_DECL
4981           || TREE_CODE (decl) == RESULT_DECL))
4982       {
4983         /* It is not an error for a structure with volatile fields to
4984            be declared register, but reset DECL_REGISTER since it
4985            cannot actually go in a register.  */
4986         int was_reg = C_DECL_REGISTER (decl);
4987         C_DECL_REGISTER (decl) = 0;
4988         DECL_REGISTER (decl) = 0;
4989         c_mark_addressable (decl);
4990         C_DECL_REGISTER (decl) = was_reg;
4991       }
4992
4993   /* This is the earliest point at which we might know the assembler
4994      name of a variable.  Thus, if it's known before this, die horribly.  */
4995     gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
4996
4997     decl_attributes (&decl, returned_attrs, 0);
4998
4999     return decl;
5000   }
5001 }
5002 \f
5003 /* Decode the parameter-list info for a function type or function definition.
5004    The argument is the value returned by `get_parm_info' (or made in c-parse.c
5005    if there is an identifier list instead of a parameter decl list).
5006    These two functions are separate because when a function returns
5007    or receives functions then each is called multiple times but the order
5008    of calls is different.  The last call to `grokparms' is always the one
5009    that contains the formal parameter names of a function definition.
5010
5011    Return a list of arg types to use in the FUNCTION_TYPE for this function.
5012
5013    FUNCDEF_FLAG is true for a function definition, false for
5014    a mere declaration.  A nonempty identifier-list gets an error message
5015    when FUNCDEF_FLAG is false.  */
5016
5017 static tree
5018 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
5019 {
5020   tree arg_types = arg_info->types;
5021
5022   if (funcdef_flag && arg_info->had_vla_unspec)
5023     {
5024       /* A function definition isn't function prototype scope C99 6.2.1p4.  */
5025       /* C99 6.7.5.2p4 */
5026       error ("%<[*]%> not allowed in other than function prototype scope");
5027     }
5028
5029   if (arg_types == 0 && !funcdef_flag && !in_system_header)
5030     warning (OPT_Wstrict_prototypes,
5031              "function declaration isn%'t a prototype");
5032
5033   if (arg_types == error_mark_node)
5034     return 0;  /* don't set TYPE_ARG_TYPES in this case */
5035
5036   else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
5037     {
5038       if (!funcdef_flag)
5039         pedwarn ("parameter names (without types) in function declaration");
5040
5041       arg_info->parms = arg_info->types;
5042       arg_info->types = 0;
5043       return 0;
5044     }
5045   else
5046     {
5047       tree parm, type, typelt;
5048       unsigned int parmno;
5049
5050       /* If there is a parameter of incomplete type in a definition,
5051          this is an error.  In a declaration this is valid, and a
5052          struct or union type may be completed later, before any calls
5053          or definition of the function.  In the case where the tag was
5054          first declared within the parameter list, a warning has
5055          already been given.  If a parameter has void type, then
5056          however the function cannot be defined or called, so
5057          warn.  */
5058
5059       for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
5060            parm;
5061            parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
5062         {
5063           type = TREE_VALUE (typelt);
5064           if (type == error_mark_node)
5065             continue;
5066
5067           if (!COMPLETE_TYPE_P (type))
5068             {
5069               if (funcdef_flag)
5070                 {
5071                   if (DECL_NAME (parm))
5072                     error ("parameter %u (%q+D) has incomplete type",
5073                            parmno, parm);
5074                   else
5075                     error ("%Jparameter %u has incomplete type",
5076                            parm, parmno);
5077
5078                   TREE_VALUE (typelt) = error_mark_node;
5079                   TREE_TYPE (parm) = error_mark_node;
5080                 }
5081               else if (VOID_TYPE_P (type))
5082                 {
5083                   if (DECL_NAME (parm))
5084                     warning (0, "parameter %u (%q+D) has void type",
5085                              parmno, parm);
5086                   else
5087                     warning (0, "%Jparameter %u has void type",
5088                              parm, parmno);
5089                 }
5090             }
5091
5092           if (DECL_NAME (parm) && TREE_USED (parm))
5093             warn_if_shadowing (parm);
5094         }
5095       return arg_types;
5096     }
5097 }
5098
5099 /* Take apart the current scope and return a c_arg_info structure with
5100    info on a parameter list just parsed.
5101
5102    This structure is later fed to 'grokparms' and 'store_parm_decls'.
5103
5104    ELLIPSIS being true means the argument list ended in '...' so don't
5105    append a sentinel (void_list_node) to the end of the type-list.  */
5106
5107 struct c_arg_info *
5108 get_parm_info (bool ellipsis)
5109 {
5110   struct c_binding *b = current_scope->bindings;
5111   struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
5112                                         struct c_arg_info);
5113   tree parms    = 0;
5114   tree tags     = 0;
5115   tree types    = 0;
5116   tree others   = 0;
5117
5118   static bool explained_incomplete_types = false;
5119   bool gave_void_only_once_err = false;
5120
5121   arg_info->parms = 0;
5122   arg_info->tags = 0;
5123   arg_info->types = 0;
5124   arg_info->others = 0;
5125   arg_info->pending_sizes = 0;
5126   arg_info->had_vla_unspec = current_scope->had_vla_unspec;
5127
5128   /* The bindings in this scope must not get put into a block.
5129      We will take care of deleting the binding nodes.  */
5130   current_scope->bindings = 0;
5131
5132   /* This function is only called if there was *something* on the
5133      parameter list.  */
5134   gcc_assert (b);
5135
5136   /* A parameter list consisting solely of 'void' indicates that the
5137      function takes no arguments.  But if the 'void' is qualified
5138      (by 'const' or 'volatile'), or has a storage class specifier
5139      ('register'), then the behavior is undefined; issue an error.
5140      Typedefs for 'void' are OK (see DR#157).  */
5141   if (b->prev == 0                          /* one binding */
5142       && TREE_CODE (b->decl) == PARM_DECL   /* which is a parameter */
5143       && !DECL_NAME (b->decl)               /* anonymous */
5144       && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
5145     {
5146       if (TREE_THIS_VOLATILE (b->decl)
5147           || TREE_READONLY (b->decl)
5148           || C_DECL_REGISTER (b->decl))
5149         error ("%<void%> as only parameter may not be qualified");
5150
5151       /* There cannot be an ellipsis.  */
5152       if (ellipsis)
5153         error ("%<void%> must be the only parameter");
5154
5155       arg_info->types = void_list_node;
5156       return arg_info;
5157     }
5158
5159   if (!ellipsis)
5160     types = void_list_node;
5161
5162   /* Break up the bindings list into parms, tags, types, and others;
5163      apply sanity checks; purge the name-to-decl bindings.  */
5164   while (b)
5165     {
5166       tree decl = b->decl;
5167       tree type = TREE_TYPE (decl);
5168       const char *keyword;
5169
5170       switch (TREE_CODE (decl))
5171         {
5172         case PARM_DECL:
5173           if (b->id)
5174             {
5175               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5176               I_SYMBOL_BINDING (b->id) = b->shadowed;
5177             }
5178
5179           /* Check for forward decls that never got their actual decl.  */
5180           if (TREE_ASM_WRITTEN (decl))
5181             error ("parameter %q+D has just a forward declaration", decl);
5182           /* Check for (..., void, ...) and issue an error.  */
5183           else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
5184             {
5185               if (!gave_void_only_once_err)
5186                 {
5187                   error ("%<void%> must be the only parameter");
5188                   gave_void_only_once_err = true;
5189                 }
5190             }
5191           else
5192             {
5193               /* Valid parameter, add it to the list.  */
5194               TREE_CHAIN (decl) = parms;
5195               parms = decl;
5196
5197               /* Since there is a prototype, args are passed in their
5198                  declared types.  The back end may override this later.  */
5199               DECL_ARG_TYPE (decl) = type;
5200               types = tree_cons (0, type, types);
5201             }
5202           break;
5203
5204         case ENUMERAL_TYPE: keyword = "enum"; goto tag;
5205         case UNION_TYPE:    keyword = "union"; goto tag;
5206         case RECORD_TYPE:   keyword = "struct"; goto tag;
5207         tag:
5208           /* Types may not have tag-names, in which case the type
5209              appears in the bindings list with b->id NULL.  */
5210           if (b->id)
5211             {
5212               gcc_assert (I_TAG_BINDING (b->id) == b);
5213               I_TAG_BINDING (b->id) = b->shadowed;
5214             }
5215
5216           /* Warn about any struct, union or enum tags defined in a
5217              parameter list.  The scope of such types is limited to
5218              the parameter list, which is rarely if ever desirable
5219              (it's impossible to call such a function with type-
5220              correct arguments).  An anonymous union parm type is
5221              meaningful as a GNU extension, so don't warn for that.  */
5222           if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
5223             {
5224               if (b->id)
5225                 /* The %s will be one of 'struct', 'union', or 'enum'.  */
5226                 warning (0, "%<%s %E%> declared inside parameter list",
5227                          keyword, b->id);
5228               else
5229                 /* The %s will be one of 'struct', 'union', or 'enum'.  */
5230                 warning (0, "anonymous %s declared inside parameter list",
5231                          keyword);
5232
5233               if (!explained_incomplete_types)
5234                 {
5235                   warning (0, "its scope is only this definition or declaration,"
5236                            " which is probably not what you want");
5237                   explained_incomplete_types = true;
5238                 }
5239             }
5240
5241           tags = tree_cons (b->id, decl, tags);
5242           break;
5243
5244         case CONST_DECL:
5245         case TYPE_DECL:
5246         case FUNCTION_DECL:
5247           /* CONST_DECLs appear here when we have an embedded enum,
5248              and TYPE_DECLs appear here when we have an embedded struct
5249              or union.  No warnings for this - we already warned about the
5250              type itself.  FUNCTION_DECLs appear when there is an implicit
5251              function declaration in the parameter list.  */
5252
5253           TREE_CHAIN (decl) = others;
5254           others = decl;
5255           /* fall through */
5256
5257         case ERROR_MARK:
5258           /* error_mark_node appears here when we have an undeclared
5259              variable.  Just throw it away.  */
5260           if (b->id)
5261             {
5262               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5263               I_SYMBOL_BINDING (b->id) = b->shadowed;
5264             }
5265           break;
5266
5267           /* Other things that might be encountered.  */
5268         case LABEL_DECL:
5269         case VAR_DECL:
5270         default:
5271           gcc_unreachable ();
5272         }
5273
5274       b = free_binding_and_advance (b);
5275     }
5276
5277   arg_info->parms = parms;
5278   arg_info->tags = tags;
5279   arg_info->types = types;
5280   arg_info->others = others;
5281   arg_info->pending_sizes = get_pending_sizes ();
5282   return arg_info;
5283 }
5284 \f
5285 /* Get the struct, enum or union (CODE says which) with tag NAME.
5286    Define the tag as a forward-reference if it is not defined.
5287    Return a c_typespec structure for the type specifier.  */
5288
5289 struct c_typespec
5290 parser_xref_tag (enum tree_code code, tree name)
5291 {
5292   struct c_typespec ret;
5293   /* If a cross reference is requested, look up the type
5294      already defined for this tag and return it.  */
5295
5296   tree ref = lookup_tag (code, name, 0);
5297   /* If this is the right type of tag, return what we found.
5298      (This reference will be shadowed by shadow_tag later if appropriate.)
5299      If this is the wrong type of tag, do not return it.  If it was the
5300      wrong type in the same scope, we will have had an error
5301      message already; if in a different scope and declaring
5302      a name, pending_xref_error will give an error message; but if in a
5303      different scope and not declaring a name, this tag should
5304      shadow the previous declaration of a different type of tag, and
5305      this would not work properly if we return the reference found.
5306      (For example, with "struct foo" in an outer scope, "union foo;"
5307      must shadow that tag with a new one of union type.)  */
5308   ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
5309   if (ref && TREE_CODE (ref) == code)
5310     {
5311       ret.spec = ref;
5312       return ret;
5313     }
5314
5315   /* If no such tag is yet defined, create a forward-reference node
5316      and record it as the "definition".
5317      When a real declaration of this type is found,
5318      the forward-reference will be altered into a real type.  */
5319
5320   ref = make_node (code);
5321   if (code == ENUMERAL_TYPE)
5322     {
5323       /* Give the type a default layout like unsigned int
5324          to avoid crashing if it does not get defined.  */
5325       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5326       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5327       TYPE_USER_ALIGN (ref) = 0;
5328       TYPE_UNSIGNED (ref) = 1;
5329       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5330       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5331       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5332     }
5333
5334   pushtag (name, ref);
5335
5336   ret.spec = ref;
5337   return ret;
5338 }
5339
5340 /* Get the struct, enum or union (CODE says which) with tag NAME.
5341    Define the tag as a forward-reference if it is not defined.
5342    Return a tree for the type.  */
5343
5344 tree
5345 xref_tag (enum tree_code code, tree name)
5346 {
5347   return parser_xref_tag (code, name).spec;
5348 }
5349 \f
5350 /* Make sure that the tag NAME is defined *in the current scope*
5351    at least as a forward reference.
5352    CODE says which kind of tag NAME ought to be.  */
5353
5354 tree
5355 start_struct (enum tree_code code, tree name)
5356 {
5357   /* If there is already a tag defined at this scope
5358      (as a forward reference), just return it.  */
5359
5360   tree ref = 0;
5361
5362   if (name != 0)
5363     ref = lookup_tag (code, name, 1);
5364   if (ref && TREE_CODE (ref) == code)
5365     {
5366       if (TYPE_SIZE (ref))
5367         {
5368           if (code == UNION_TYPE)
5369             error ("redefinition of %<union %E%>", name);
5370           else
5371             error ("redefinition of %<struct %E%>", name);
5372         }
5373       else if (C_TYPE_BEING_DEFINED (ref))
5374         {
5375           if (code == UNION_TYPE)
5376             error ("nested redefinition of %<union %E%>", name);
5377           else
5378             error ("nested redefinition of %<struct %E%>", name);
5379           /* Don't create structures that contain themselves.  */
5380           ref = NULL_TREE;
5381         }
5382     }
5383
5384   /* Otherwise create a forward-reference just so the tag is in scope.  */
5385
5386   if (ref == NULL_TREE || TREE_CODE (ref) != code)
5387     {
5388       ref = make_node (code);
5389       pushtag (name, ref);
5390     }
5391
5392   C_TYPE_BEING_DEFINED (ref) = 1;
5393   TYPE_PACKED (ref) = flag_pack_struct;
5394   return ref;
5395 }
5396
5397 /* Process the specs, declarator and width (NULL if omitted)
5398    of a structure component, returning a FIELD_DECL node.
5399    WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
5400
5401    This is done during the parsing of the struct declaration.
5402    The FIELD_DECL nodes are chained together and the lot of them
5403    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5404
5405 tree
5406 grokfield (struct c_declarator *declarator, struct c_declspecs *declspecs,
5407            tree width)
5408 {
5409   tree value;
5410
5411   if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
5412       && width == NULL_TREE)
5413     {
5414       /* This is an unnamed decl.
5415
5416          If we have something of the form "union { list } ;" then this
5417          is the anonymous union extension.  Similarly for struct.
5418
5419          If this is something of the form "struct foo;", then
5420            If MS extensions are enabled, this is handled as an
5421              anonymous struct.
5422            Otherwise this is a forward declaration of a structure tag.
5423
5424          If this is something of the form "foo;" and foo is a TYPE_DECL, then
5425            If MS extensions are enabled and foo names a structure, then
5426              again this is an anonymous struct.
5427            Otherwise this is an error.
5428
5429          Oh what a horrid tangled web we weave.  I wonder if MS consciously
5430          took this from Plan 9 or if it was an accident of implementation
5431          that took root before someone noticed the bug...  */
5432
5433       tree type = declspecs->type;
5434       bool type_ok = (TREE_CODE (type) == RECORD_TYPE
5435                       || TREE_CODE (type) == UNION_TYPE);
5436       bool ok = false;
5437
5438       if (type_ok
5439           && (flag_ms_extensions || !declspecs->typedef_p))
5440         {
5441           if (flag_ms_extensions)
5442             ok = true;
5443           else if (flag_iso)
5444             ok = false;
5445           else if (TYPE_NAME (type) == NULL)
5446             ok = true;
5447           else
5448             ok = false;
5449         }
5450       if (!ok)
5451         {
5452           pedwarn ("declaration does not declare anything");
5453           return NULL_TREE;
5454         }
5455       if (pedantic)
5456         pedwarn ("ISO C doesn%'t support unnamed structs/unions");
5457     }
5458
5459   value = grokdeclarator (declarator, declspecs, FIELD, false,
5460                           width ? &width : NULL);
5461
5462   finish_decl (value, NULL_TREE, NULL_TREE);
5463   DECL_INITIAL (value) = width;
5464
5465   return value;
5466 }
5467 \f
5468 /* Generate an error for any duplicate field names in FIELDLIST.  Munge
5469    the list such that this does not present a problem later.  */
5470
5471 static void
5472 detect_field_duplicates (tree fieldlist)
5473 {
5474   tree x, y;
5475   int timeout = 10;
5476
5477   /* First, see if there are more than "a few" fields.
5478      This is trivially true if there are zero or one fields.  */
5479   if (!fieldlist)
5480     return;
5481   x = TREE_CHAIN (fieldlist);
5482   if (!x)
5483     return;
5484   do {
5485     timeout--;
5486     x = TREE_CHAIN (x);
5487   } while (timeout > 0 && x);
5488
5489   /* If there were "few" fields, avoid the overhead of allocating
5490      a hash table.  Instead just do the nested traversal thing.  */
5491   if (timeout > 0)
5492     {
5493       for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
5494         if (DECL_NAME (x))
5495           {
5496             for (y = fieldlist; y != x; y = TREE_CHAIN (y))
5497               if (DECL_NAME (y) == DECL_NAME (x))
5498                 {
5499                   error ("duplicate member %q+D", x);
5500                   DECL_NAME (x) = NULL_TREE;
5501                 }
5502           }
5503     }
5504   else
5505     {
5506       htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
5507       void **slot;
5508
5509       for (x = fieldlist; x ; x = TREE_CHAIN (x))
5510         if ((y = DECL_NAME (x)) != 0)
5511           {
5512             slot = htab_find_slot (htab, y, INSERT);
5513             if (*slot)
5514               {
5515                 error ("duplicate member %q+D", x);
5516                 DECL_NAME (x) = NULL_TREE;
5517               }
5518             *slot = y;
5519           }
5520
5521       htab_delete (htab);
5522     }
5523 }
5524
5525 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5526    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5527    ATTRIBUTES are attributes to be applied to the structure.  */
5528
5529 tree
5530 finish_struct (tree t, tree fieldlist, tree attributes)
5531 {
5532   tree x;
5533   bool toplevel = file_scope == current_scope;
5534   int saw_named_field;
5535
5536   /* If this type was previously laid out as a forward reference,
5537      make sure we lay it out again.  */
5538
5539   TYPE_SIZE (t) = 0;
5540
5541   decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5542
5543   if (pedantic)
5544     {
5545       for (x = fieldlist; x; x = TREE_CHAIN (x))
5546         if (DECL_NAME (x) != 0)
5547           break;
5548
5549       if (x == 0)
5550         {
5551           if (TREE_CODE (t) == UNION_TYPE)
5552             {
5553               if (fieldlist)
5554                 pedwarn ("union has no named members");
5555               else
5556                 pedwarn ("union has no members");
5557             }
5558           else
5559             {
5560               if (fieldlist)
5561                 pedwarn ("struct has no named members");
5562               else
5563                 pedwarn ("struct has no members");
5564             }
5565         }
5566     }
5567
5568   /* Install struct as DECL_CONTEXT of each field decl.
5569      Also process specified field sizes, found in the DECL_INITIAL,
5570      storing 0 there after the type has been changed to precision equal
5571      to its width, rather than the precision of the specified standard
5572      type.  (Correct layout requires the original type to have been preserved
5573      until now.)  */
5574
5575   saw_named_field = 0;
5576   for (x = fieldlist; x; x = TREE_CHAIN (x))
5577     {
5578       if (TREE_TYPE (x) == error_mark_node)
5579         continue;
5580
5581       DECL_CONTEXT (x) = t;
5582
5583       if (TYPE_PACKED (t) && TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
5584         DECL_PACKED (x) = 1;
5585
5586       /* If any field is const, the structure type is pseudo-const.  */
5587       if (TREE_READONLY (x))
5588         C_TYPE_FIELDS_READONLY (t) = 1;
5589       else
5590         {
5591           /* A field that is pseudo-const makes the structure likewise.  */
5592           tree t1 = TREE_TYPE (x);
5593           while (TREE_CODE (t1) == ARRAY_TYPE)
5594             t1 = TREE_TYPE (t1);
5595           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5596               && C_TYPE_FIELDS_READONLY (t1))
5597             C_TYPE_FIELDS_READONLY (t) = 1;
5598         }
5599
5600       /* Any field that is volatile means variables of this type must be
5601          treated in some ways as volatile.  */
5602       if (TREE_THIS_VOLATILE (x))
5603         C_TYPE_FIELDS_VOLATILE (t) = 1;
5604
5605       /* Any field of nominal variable size implies structure is too.  */
5606       if (C_DECL_VARIABLE_SIZE (x))
5607         C_TYPE_VARIABLE_SIZE (t) = 1;
5608
5609       if (DECL_INITIAL (x))
5610         {
5611           unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
5612           DECL_SIZE (x) = bitsize_int (width);
5613           DECL_BIT_FIELD (x) = 1;
5614           SET_DECL_C_BIT_FIELD (x);
5615         }
5616
5617       /* Detect flexible array member in an invalid context.  */
5618       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5619           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5620           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5621           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5622         {
5623           if (TREE_CODE (t) == UNION_TYPE)
5624             {
5625               error ("%Jflexible array member in union", x);
5626               TREE_TYPE (x) = error_mark_node;
5627             }
5628           else if (TREE_CHAIN (x) != NULL_TREE)
5629             {
5630               error ("%Jflexible array member not at end of struct", x);
5631               TREE_TYPE (x) = error_mark_node;
5632             }
5633           else if (!saw_named_field)
5634             {
5635               error ("%Jflexible array member in otherwise empty struct", x);
5636               TREE_TYPE (x) = error_mark_node;
5637             }
5638         }
5639
5640       if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
5641           && flexible_array_type_p (TREE_TYPE (x)))
5642         pedwarn ("%Jinvalid use of structure with flexible array member", x);
5643
5644       if (DECL_NAME (x))
5645         saw_named_field = 1;
5646     }
5647
5648   detect_field_duplicates (fieldlist);
5649
5650   /* Now we have the nearly final fieldlist.  Record it,
5651      then lay out the structure or union (including the fields).  */
5652
5653   TYPE_FIELDS (t) = fieldlist;
5654
5655   layout_type (t);
5656
5657   /* Give bit-fields their proper types.  */
5658   {
5659     tree *fieldlistp = &fieldlist;
5660     while (*fieldlistp)
5661       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
5662           && TREE_TYPE (*fieldlistp) != error_mark_node)
5663         {
5664           unsigned HOST_WIDE_INT width
5665             = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
5666           tree type = TREE_TYPE (*fieldlistp);
5667           if (width != TYPE_PRECISION (type))
5668             {
5669               TREE_TYPE (*fieldlistp)
5670                 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
5671               DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
5672             }
5673           DECL_INITIAL (*fieldlistp) = 0;
5674         }
5675       else
5676         fieldlistp = &TREE_CHAIN (*fieldlistp);
5677   }
5678
5679   /* Now we have the truly final field list.
5680      Store it in this type and in the variants.  */
5681
5682   TYPE_FIELDS (t) = fieldlist;
5683
5684   /* If there are lots of fields, sort so we can look through them fast.
5685      We arbitrarily consider 16 or more elts to be "a lot".  */
5686
5687   {
5688     int len = 0;
5689
5690     for (x = fieldlist; x; x = TREE_CHAIN (x))
5691       {
5692         if (len > 15 || DECL_NAME (x) == NULL)
5693           break;
5694         len += 1;
5695       }
5696
5697     if (len > 15)
5698       {
5699         tree *field_array;
5700         struct lang_type *space;
5701         struct sorted_fields_type *space2;
5702
5703         len += list_length (x);
5704
5705         /* Use the same allocation policy here that make_node uses, to
5706           ensure that this lives as long as the rest of the struct decl.
5707           All decls in an inline function need to be saved.  */
5708
5709         space = GGC_CNEW (struct lang_type);
5710         space2 = GGC_NEWVAR (struct sorted_fields_type,
5711                              sizeof (struct sorted_fields_type) + len * sizeof (tree));
5712
5713         len = 0;
5714         space->s = space2;
5715         field_array = &space2->elts[0];
5716         for (x = fieldlist; x; x = TREE_CHAIN (x))
5717           {
5718             field_array[len++] = x;
5719
5720             /* If there is anonymous struct or union, break out of the loop.  */
5721             if (DECL_NAME (x) == NULL)
5722               break;
5723           }
5724         /* Found no anonymous struct/union.  Add the TYPE_LANG_SPECIFIC.  */
5725         if (x == NULL)
5726           {
5727             TYPE_LANG_SPECIFIC (t) = space;
5728             TYPE_LANG_SPECIFIC (t)->s->len = len;
5729             field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
5730             qsort (field_array, len, sizeof (tree), field_decl_cmp);
5731           }
5732       }
5733   }
5734
5735   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5736     {
5737       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5738       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5739       C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
5740       C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
5741       C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
5742     }
5743
5744   /* If this was supposed to be a transparent union, but we can't
5745      make it one, warn and turn off the flag.  */
5746   if (TREE_CODE (t) == UNION_TYPE
5747       && TYPE_TRANSPARENT_UNION (t)
5748       && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
5749     {
5750       TYPE_TRANSPARENT_UNION (t) = 0;
5751       warning (0, "union cannot be made transparent");
5752     }
5753
5754   /* If this structure or union completes the type of any previous
5755      variable declaration, lay it out and output its rtl.  */
5756   for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
5757        x;
5758        x = TREE_CHAIN (x))
5759     {
5760       tree decl = TREE_VALUE (x);
5761       if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5762         layout_array_type (TREE_TYPE (decl));
5763       if (TREE_CODE (decl) != TYPE_DECL)
5764         {
5765           layout_decl (decl, 0);
5766           if (c_dialect_objc ())
5767             objc_check_decl (decl);
5768           rest_of_decl_compilation (decl, toplevel, 0);
5769           if (!toplevel)
5770             expand_decl (decl);
5771         }
5772     }
5773   C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
5774
5775   /* Finish debugging output for this type.  */
5776   rest_of_type_compilation (t, toplevel);
5777
5778   /* If we're inside a function proper, i.e. not file-scope and not still
5779      parsing parameters, then arrange for the size of a variable sized type
5780      to be bound now.  */
5781   if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
5782     add_stmt (build_stmt (DECL_EXPR, build_decl (TYPE_DECL, NULL, t)));
5783
5784   return t;
5785 }
5786
5787 /* Lay out the type T, and its element type, and so on.  */
5788
5789 static void
5790 layout_array_type (tree t)
5791 {
5792   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5793     layout_array_type (TREE_TYPE (t));
5794   layout_type (t);
5795 }
5796 \f
5797 /* Begin compiling the definition of an enumeration type.
5798    NAME is its name (or null if anonymous).
5799    Returns the type object, as yet incomplete.
5800    Also records info about it so that build_enumerator
5801    may be used to declare the individual values as they are read.  */
5802
5803 tree
5804 start_enum (tree name)
5805 {
5806   tree enumtype = 0;
5807
5808   /* If this is the real definition for a previous forward reference,
5809      fill in the contents in the same object that used to be the
5810      forward reference.  */
5811
5812   if (name != 0)
5813     enumtype = lookup_tag (ENUMERAL_TYPE, name, 1);
5814
5815   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5816     {
5817       enumtype = make_node (ENUMERAL_TYPE);
5818       pushtag (name, enumtype);
5819     }
5820
5821   if (C_TYPE_BEING_DEFINED (enumtype))
5822     error ("nested redefinition of %<enum %E%>", name);
5823
5824   C_TYPE_BEING_DEFINED (enumtype) = 1;
5825
5826   if (TYPE_VALUES (enumtype) != 0)
5827     {
5828       /* This enum is a named one that has been declared already.  */
5829       error ("redeclaration of %<enum %E%>", name);
5830
5831       /* Completely replace its old definition.
5832          The old enumerators remain defined, however.  */
5833       TYPE_VALUES (enumtype) = 0;
5834     }
5835
5836   enum_next_value = integer_zero_node;
5837   enum_overflow = 0;
5838
5839   if (flag_short_enums)
5840     TYPE_PACKED (enumtype) = 1;
5841
5842   return enumtype;
5843 }
5844
5845 /* After processing and defining all the values of an enumeration type,
5846    install their decls in the enumeration type and finish it off.
5847    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5848    and ATTRIBUTES are the specified attributes.
5849    Returns ENUMTYPE.  */
5850
5851 tree
5852 finish_enum (tree enumtype, tree values, tree attributes)
5853 {
5854   tree pair, tem;
5855   tree minnode = 0, maxnode = 0;
5856   int precision, unsign;
5857   bool toplevel = (file_scope == current_scope);
5858   struct lang_type *lt;
5859
5860   decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5861
5862   /* Calculate the maximum value of any enumerator in this type.  */
5863
5864   if (values == error_mark_node)
5865     minnode = maxnode = integer_zero_node;
5866   else
5867     {
5868       minnode = maxnode = TREE_VALUE (values);
5869       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5870         {
5871           tree value = TREE_VALUE (pair);
5872           if (tree_int_cst_lt (maxnode, value))
5873             maxnode = value;
5874           if (tree_int_cst_lt (value, minnode))
5875             minnode = value;
5876         }
5877     }
5878
5879   /* Construct the final type of this enumeration.  It is the same
5880      as one of the integral types - the narrowest one that fits, except
5881      that normally we only go as narrow as int - and signed iff any of
5882      the values are negative.  */
5883   unsign = (tree_int_cst_sgn (minnode) >= 0);
5884   precision = MAX (min_precision (minnode, unsign),
5885                    min_precision (maxnode, unsign));
5886
5887   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5888     {
5889       tem = c_common_type_for_size (precision, unsign);
5890       if (tem == NULL)
5891         {
5892           warning (0, "enumeration values exceed range of largest integer");
5893           tem = long_long_integer_type_node;
5894         }
5895     }
5896   else
5897     tem = unsign ? unsigned_type_node : integer_type_node;
5898
5899   TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
5900   TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
5901   TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
5902   TYPE_SIZE (enumtype) = 0;
5903
5904   /* If the precision of the type was specific with an attribute and it
5905      was too small, give an error.  Otherwise, use it.  */
5906   if (TYPE_PRECISION (enumtype))
5907     {
5908       if (precision > TYPE_PRECISION (enumtype))
5909         error ("specified mode too small for enumeral values");
5910     }
5911   else
5912     TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
5913
5914   layout_type (enumtype);
5915
5916   if (values != error_mark_node)
5917     {
5918       /* Change the type of the enumerators to be the enum type.  We
5919          need to do this irrespective of the size of the enum, for
5920          proper type checking.  Replace the DECL_INITIALs of the
5921          enumerators, and the value slots of the list, with copies
5922          that have the enum type; they cannot be modified in place
5923          because they may be shared (e.g.  integer_zero_node) Finally,
5924          change the purpose slots to point to the names of the decls.  */
5925       for (pair = values; pair; pair = TREE_CHAIN (pair))
5926         {
5927           tree enu = TREE_PURPOSE (pair);
5928           tree ini = DECL_INITIAL (enu);
5929
5930           TREE_TYPE (enu) = enumtype;
5931
5932           /* The ISO C Standard mandates enumerators to have type int,
5933              even though the underlying type of an enum type is
5934              unspecified.  Here we convert any enumerators that fit in
5935              an int to type int, to avoid promotions to unsigned types
5936              when comparing integers with enumerators that fit in the
5937              int range.  When -pedantic is given, build_enumerator()
5938              would have already taken care of those that don't fit.  */
5939           if (int_fits_type_p (ini, integer_type_node))
5940             tem = integer_type_node;
5941           else
5942             tem = enumtype;
5943           ini = convert (tem, ini);
5944
5945           DECL_INITIAL (enu) = ini;
5946           TREE_PURPOSE (pair) = DECL_NAME (enu);
5947           TREE_VALUE (pair) = ini;
5948         }
5949
5950       TYPE_VALUES (enumtype) = values;
5951     }
5952
5953   /* Record the min/max values so that we can warn about bit-field
5954      enumerations that are too small for the values.  */
5955   lt = GGC_CNEW (struct lang_type);
5956   lt->enum_min = minnode;
5957   lt->enum_max = maxnode;
5958   TYPE_LANG_SPECIFIC (enumtype) = lt;
5959
5960   /* Fix up all variant types of this enum type.  */
5961   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5962     {
5963       if (tem == enumtype)
5964         continue;
5965       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5966       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5967       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5968       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5969       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5970       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5971       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5972       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5973       TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5974       TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
5975       TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
5976     }
5977
5978   /* Finish debugging output for this type.  */
5979   rest_of_type_compilation (enumtype, toplevel);
5980
5981   return enumtype;
5982 }
5983
5984 /* Build and install a CONST_DECL for one value of the
5985    current enumeration type (one that was begun with start_enum).
5986    Return a tree-list containing the CONST_DECL and its value.
5987    Assignment of sequential values by default is handled here.  */
5988
5989 tree
5990 build_enumerator (tree name, tree value)
5991 {
5992   tree decl, type;
5993
5994   /* Validate and default VALUE.  */
5995
5996   if (value != 0)
5997     {
5998       /* Don't issue more errors for error_mark_node (i.e. an
5999          undeclared identifier) - just ignore the value expression.  */
6000       if (value == error_mark_node)
6001         value = 0;
6002       else if (!INTEGRAL_TYPE_P (TREE_TYPE (value))
6003                || TREE_CODE (value) != INTEGER_CST)
6004         {
6005           error ("enumerator value for %qE is not an integer constant", name);
6006           value = 0;
6007         }
6008       else
6009         {
6010           value = default_conversion (value);
6011           constant_expression_warning (value);
6012         }
6013     }
6014
6015   /* Default based on previous value.  */
6016   /* It should no longer be possible to have NON_LVALUE_EXPR
6017      in the default.  */
6018   if (value == 0)
6019     {
6020       value = enum_next_value;
6021       if (enum_overflow)
6022         error ("overflow in enumeration values");
6023     }
6024
6025   if (pedantic && !int_fits_type_p (value, integer_type_node))
6026     {
6027       pedwarn ("ISO C restricts enumerator values to range of %<int%>");
6028       /* XXX This causes -pedantic to change the meaning of the program.
6029          Remove?  -zw 2004-03-15  */
6030       value = convert (integer_type_node, value);
6031     }
6032
6033   /* Set basis for default for next value.  */
6034   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
6035   enum_overflow = tree_int_cst_lt (enum_next_value, value);
6036
6037   /* Now create a declaration for the enum value name.  */
6038
6039   type = TREE_TYPE (value);
6040   type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
6041                                       TYPE_PRECISION (integer_type_node)),
6042                                  (TYPE_PRECISION (type)
6043                                   >= TYPE_PRECISION (integer_type_node)
6044                                   && TYPE_UNSIGNED (type)));
6045
6046   decl = build_decl (CONST_DECL, name, type);
6047   DECL_INITIAL (decl) = convert (type, value);
6048   pushdecl (decl);
6049
6050   return tree_cons (decl, value, NULL_TREE);
6051 }
6052
6053 \f
6054 /* Create the FUNCTION_DECL for a function definition.
6055    DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
6056    the declaration; they describe the function's name and the type it returns,
6057    but twisted together in a fashion that parallels the syntax of C.
6058
6059    This function creates a binding context for the function body
6060    as well as setting up the FUNCTION_DECL in current_function_decl.
6061
6062    Returns 1 on success.  If the DECLARATOR is not suitable for a function
6063    (it defines a datum instead), we return 0, which tells
6064    yyparse to report a parse error.  */
6065
6066 int
6067 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
6068                 tree attributes)
6069 {
6070   tree decl1, old_decl;
6071   tree restype, resdecl;
6072   struct c_label_context_se *nstack_se;
6073   struct c_label_context_vm *nstack_vm;
6074
6075   current_function_returns_value = 0;  /* Assume, until we see it does.  */
6076   current_function_returns_null = 0;
6077   current_function_returns_abnormally = 0;
6078   warn_about_return_type = 0;
6079   c_switch_stack = NULL;
6080
6081   nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se);
6082   nstack_se->labels_def = NULL;
6083   nstack_se->labels_used = NULL;
6084   nstack_se->next = label_context_stack_se;
6085   label_context_stack_se = nstack_se;
6086
6087   nstack_vm = XOBNEW (&parser_obstack, struct c_label_context_vm);
6088   nstack_vm->labels_def = NULL;
6089   nstack_vm->labels_used = NULL;
6090   nstack_vm->scope = 0;
6091   nstack_vm->next = label_context_stack_vm;
6092   label_context_stack_vm = nstack_vm;
6093
6094   /* Indicate no valid break/continue context by setting these variables
6095      to some non-null, non-label value.  We'll notice and emit the proper
6096      error message in c_finish_bc_stmt.  */
6097   c_break_label = c_cont_label = size_zero_node;
6098
6099   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL);
6100
6101   /* If the declarator is not suitable for a function definition,
6102      cause a syntax error.  */
6103   if (decl1 == 0)
6104     {
6105       label_context_stack_se = label_context_stack_se->next;
6106       label_context_stack_vm = label_context_stack_vm->next;
6107       return 0;
6108     }
6109
6110   decl_attributes (&decl1, attributes, 0);
6111
6112   if (DECL_DECLARED_INLINE_P (decl1)
6113       && DECL_UNINLINABLE (decl1)
6114       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
6115     warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
6116              decl1);
6117
6118   /* Handle gnu_inline attribute.  */
6119   if (declspecs->inline_p
6120       && !flag_gnu89_inline
6121       && TREE_CODE (decl1) == FUNCTION_DECL
6122       && lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1)))
6123     {
6124       if (declspecs->storage_class != csc_static)
6125         DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
6126     }
6127
6128   announce_function (decl1);
6129
6130   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
6131     {
6132       error ("return type is an incomplete type");
6133       /* Make it return void instead.  */
6134       TREE_TYPE (decl1)
6135         = build_function_type (void_type_node,
6136                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6137     }
6138
6139   if (warn_about_return_type)
6140     pedwarn_c99 ("return type defaults to %<int%>");
6141
6142   /* Make the init_value nonzero so pushdecl knows this is not tentative.
6143      error_mark_node is replaced below (in pop_scope) with the BLOCK.  */
6144   DECL_INITIAL (decl1) = error_mark_node;
6145
6146   /* If this definition isn't a prototype and we had a prototype declaration
6147      before, copy the arg type info from that prototype.  */
6148   old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
6149   if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
6150     old_decl = 0;
6151   current_function_prototype_locus = UNKNOWN_LOCATION;
6152   current_function_prototype_built_in = false;
6153   current_function_prototype_arg_types = NULL_TREE;
6154   if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6155     {
6156       if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6157           && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6158                         TREE_TYPE (TREE_TYPE (old_decl))))
6159         {
6160           TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
6161                                               TREE_TYPE (decl1));
6162           current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
6163           current_function_prototype_built_in
6164             = C_DECL_BUILTIN_PROTOTYPE (old_decl);
6165           current_function_prototype_arg_types
6166             = TYPE_ARG_TYPES (TREE_TYPE (decl1));
6167         }
6168       if (TREE_PUBLIC (decl1))
6169         {
6170           /* If there is an external prototype declaration of this
6171              function, record its location but do not copy information
6172              to this decl.  This may be an invisible declaration
6173              (built-in or in a scope which has finished) or simply
6174              have more refined argument types than any declaration
6175              found above.  */
6176           struct c_binding *b;
6177           for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
6178             if (B_IN_SCOPE (b, external_scope))
6179               break;
6180           if (b)
6181             {
6182               tree ext_decl, ext_type;
6183               ext_decl = b->decl;
6184               ext_type = b->type ? b->type : TREE_TYPE (ext_decl);
6185               if (TREE_CODE (ext_type) == FUNCTION_TYPE
6186                   && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6187                                 TREE_TYPE (ext_type)))
6188                 {
6189                   current_function_prototype_locus
6190                     = DECL_SOURCE_LOCATION (ext_decl);
6191                   current_function_prototype_built_in
6192                     = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
6193                   current_function_prototype_arg_types
6194                     = TYPE_ARG_TYPES (ext_type);
6195                 }
6196             }
6197         }
6198     }
6199
6200   /* Optionally warn of old-fashioned def with no previous prototype.  */
6201   if (warn_strict_prototypes
6202       && old_decl != error_mark_node
6203       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6204       && C_DECL_ISNT_PROTOTYPE (old_decl))
6205     warning (OPT_Wstrict_prototypes,
6206              "function declaration isn%'t a prototype");
6207   /* Optionally warn of any global def with no previous prototype.  */
6208   else if (warn_missing_prototypes
6209            && old_decl != error_mark_node
6210            && TREE_PUBLIC (decl1)
6211            && !MAIN_NAME_P (DECL_NAME (decl1))
6212            && C_DECL_ISNT_PROTOTYPE (old_decl))
6213     warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl1);
6214   /* Optionally warn of any def with no previous prototype
6215      if the function has already been used.  */
6216   else if (warn_missing_prototypes
6217            && old_decl != 0
6218            && old_decl != error_mark_node
6219            && TREE_USED (old_decl)
6220            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6221     warning (OPT_Wmissing_prototypes,
6222              "%q+D was used with no prototype before its definition", decl1);
6223   /* Optionally warn of any global def with no previous declaration.  */
6224   else if (warn_missing_declarations
6225            && TREE_PUBLIC (decl1)
6226            && old_decl == 0
6227            && !MAIN_NAME_P (DECL_NAME (decl1)))
6228     warning (OPT_Wmissing_declarations, "no previous declaration for %q+D",
6229              decl1);
6230   /* Optionally warn of any def with no previous declaration
6231      if the function has already been used.  */
6232   else if (warn_missing_declarations
6233            && old_decl != 0
6234            && old_decl != error_mark_node
6235            && TREE_USED (old_decl)
6236            && C_DECL_IMPLICIT (old_decl))
6237     warning (OPT_Wmissing_declarations,
6238              "%q+D was used with no declaration before its definition", decl1);
6239
6240   /* This function exists in static storage.
6241      (This does not mean `static' in the C sense!)  */
6242   TREE_STATIC (decl1) = 1;
6243
6244   /* A nested function is not global.  */
6245   if (current_function_decl != 0)
6246     TREE_PUBLIC (decl1) = 0;
6247
6248   /* This is the earliest point at which we might know the assembler
6249      name of the function.  Thus, if it's set before this, die horribly.  */
6250   gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
6251
6252   /* If #pragma weak was used, mark the decl weak now.  */
6253   if (current_scope == file_scope)
6254     maybe_apply_pragma_weak (decl1);
6255
6256   /* Warn for unlikely, improbable, or stupid declarations of `main'.  */
6257   if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
6258     {
6259       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6260           != integer_type_node)
6261         pedwarn ("return type of %q+D is not %<int%>", decl1);
6262
6263       check_main_parameter_types(decl1);
6264
6265       if (!TREE_PUBLIC (decl1))
6266         pedwarn ("%q+D is normally a non-static function", decl1);
6267     }
6268
6269   /* Record the decl so that the function name is defined.
6270      If we already have a decl for this name, and it is a FUNCTION_DECL,
6271      use the old decl.  */
6272
6273   current_function_decl = pushdecl (decl1);
6274
6275   push_scope ();
6276   declare_parm_level ();
6277
6278   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6279   /* Promote the value to int before returning it.  */
6280   if (c_promoting_integer_type_p (restype))
6281     {
6282       /* It retains unsignedness if not really getting wider.  */
6283       if (TYPE_UNSIGNED (restype)
6284           && (TYPE_PRECISION (restype)
6285                   == TYPE_PRECISION (integer_type_node)))
6286         restype = unsigned_type_node;
6287       else
6288         restype = integer_type_node;
6289     }
6290
6291   resdecl = build_decl (RESULT_DECL, NULL_TREE, restype);
6292   DECL_ARTIFICIAL (resdecl) = 1;
6293   DECL_IGNORED_P (resdecl) = 1;
6294   DECL_RESULT (current_function_decl) = resdecl;
6295
6296   start_fname_decls ();
6297
6298   return 1;
6299 }
6300 \f
6301 /* Subroutine of store_parm_decls which handles new-style function
6302    definitions (prototype format). The parms already have decls, so we
6303    need only record them as in effect and complain if any redundant
6304    old-style parm decls were written.  */
6305 static void
6306 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
6307 {
6308   tree decl;
6309
6310   if (current_scope->bindings)
6311     {
6312       error ("%Jold-style parameter declarations in prototyped "
6313              "function definition", fndecl);
6314
6315       /* Get rid of the old-style declarations.  */
6316       pop_scope ();
6317       push_scope ();
6318     }
6319   /* Don't issue this warning for nested functions, and don't issue this
6320      warning if we got here because ARG_INFO_TYPES was error_mark_node
6321      (this happens when a function definition has just an ellipsis in
6322      its parameter list).  */
6323   else if (!in_system_header && !current_function_scope
6324            && arg_info->types != error_mark_node)
6325     warning (OPT_Wtraditional,
6326              "%Jtraditional C rejects ISO C style function definitions",
6327              fndecl);
6328
6329   /* Now make all the parameter declarations visible in the function body.
6330      We can bypass most of the grunt work of pushdecl.  */
6331   for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
6332     {
6333       DECL_CONTEXT (decl) = current_function_decl;
6334       if (DECL_NAME (decl))
6335         {
6336           bind (DECL_NAME (decl), decl, current_scope,
6337                 /*invisible=*/false, /*nested=*/false);
6338           if (!TREE_USED (decl))
6339             warn_if_shadowing (decl);
6340         }
6341       else
6342         error ("%Jparameter name omitted", decl);
6343     }
6344
6345   /* Record the parameter list in the function declaration.  */
6346   DECL_ARGUMENTS (fndecl) = arg_info->parms;
6347
6348   /* Now make all the ancillary declarations visible, likewise.  */
6349   for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
6350     {
6351       DECL_CONTEXT (decl) = current_function_decl;
6352       if (DECL_NAME (decl))
6353         bind (DECL_NAME (decl), decl, current_scope,
6354               /*invisible=*/false, /*nested=*/false);
6355     }
6356
6357   /* And all the tag declarations.  */
6358   for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
6359     if (TREE_PURPOSE (decl))
6360       bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
6361             /*invisible=*/false, /*nested=*/false);
6362 }
6363
6364 /* Subroutine of store_parm_decls which handles old-style function
6365    definitions (separate parameter list and declarations).  */
6366
6367 static void
6368 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
6369 {
6370   struct c_binding *b;
6371   tree parm, decl, last;
6372   tree parmids = arg_info->parms;
6373   struct pointer_set_t *seen_args = pointer_set_create ();
6374
6375   if (!in_system_header)
6376     warning (OPT_Wold_style_definition, "%Jold-style function definition",
6377              fndecl);
6378
6379   /* Match each formal parameter name with its declaration.  Save each
6380      decl in the appropriate TREE_PURPOSE slot of the parmids chain.  */
6381   for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6382     {
6383       if (TREE_VALUE (parm) == 0)
6384         {
6385           error ("%Jparameter name missing from parameter list", fndecl);
6386           TREE_PURPOSE (parm) = 0;
6387           continue;
6388         }
6389
6390       b = I_SYMBOL_BINDING (TREE_VALUE (parm));
6391       if (b && B_IN_CURRENT_SCOPE (b))
6392         {
6393           decl = b->decl;
6394           /* If we got something other than a PARM_DECL it is an error.  */
6395           if (TREE_CODE (decl) != PARM_DECL)
6396             error ("%q+D declared as a non-parameter", decl);
6397           /* If the declaration is already marked, we have a duplicate
6398              name.  Complain and ignore the duplicate.  */
6399           else if (pointer_set_contains (seen_args, decl))
6400             {
6401               error ("multiple parameters named %q+D", decl);
6402               TREE_PURPOSE (parm) = 0;
6403               continue;
6404             }
6405           /* If the declaration says "void", complain and turn it into
6406              an int.  */
6407           else if (VOID_TYPE_P (TREE_TYPE (decl)))
6408             {
6409               error ("parameter %q+D declared with void type", decl);
6410               TREE_TYPE (decl) = integer_type_node;
6411               DECL_ARG_TYPE (decl) = integer_type_node;
6412               layout_decl (decl, 0);
6413             }
6414           warn_if_shadowing (decl);
6415         }
6416       /* If no declaration found, default to int.  */
6417       else
6418         {
6419           decl = build_decl (PARM_DECL, TREE_VALUE (parm), integer_type_node);
6420           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
6421           DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (fndecl);
6422           pushdecl (decl);
6423           warn_if_shadowing (decl);
6424
6425           if (flag_isoc99)
6426             pedwarn ("type of %q+D defaults to %<int%>", decl);
6427           else
6428             warning (OPT_Wmissing_parameter_type, "type of %q+D defaults to %<int%>", decl);
6429         }
6430
6431       TREE_PURPOSE (parm) = decl;
6432       pointer_set_insert (seen_args, decl);
6433     }
6434
6435   /* Now examine the parms chain for incomplete declarations
6436      and declarations with no corresponding names.  */
6437
6438   for (b = current_scope->bindings; b; b = b->prev)
6439     {
6440       parm = b->decl;
6441       if (TREE_CODE (parm) != PARM_DECL)
6442         continue;
6443
6444       if (TREE_TYPE (parm) != error_mark_node
6445           && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
6446         {
6447           error ("parameter %q+D has incomplete type", parm);
6448           TREE_TYPE (parm) = error_mark_node;
6449         }
6450
6451       if (!pointer_set_contains (seen_args, parm))
6452         {
6453           error ("declaration for parameter %q+D but no such parameter", parm);
6454
6455           /* Pretend the parameter was not missing.
6456              This gets us to a standard state and minimizes
6457              further error messages.  */
6458           parmids = chainon (parmids, tree_cons (parm, 0, 0));
6459         }
6460     }
6461
6462   /* Chain the declarations together in the order of the list of
6463      names.  Store that chain in the function decl, replacing the
6464      list of names.  Update the current scope to match.  */
6465   DECL_ARGUMENTS (fndecl) = 0;
6466
6467   for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6468     if (TREE_PURPOSE (parm))
6469       break;
6470   if (parm && TREE_PURPOSE (parm))
6471     {
6472       last = TREE_PURPOSE (parm);
6473       DECL_ARGUMENTS (fndecl) = last;
6474
6475       for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
6476         if (TREE_PURPOSE (parm))
6477           {
6478             TREE_CHAIN (last) = TREE_PURPOSE (parm);
6479             last = TREE_PURPOSE (parm);
6480           }
6481       TREE_CHAIN (last) = 0;
6482     }
6483
6484   pointer_set_destroy (seen_args);
6485
6486   /* If there was a previous prototype,
6487      set the DECL_ARG_TYPE of each argument according to
6488      the type previously specified, and report any mismatches.  */
6489
6490   if (current_function_prototype_arg_types)
6491     {
6492       tree type;
6493       for (parm = DECL_ARGUMENTS (fndecl),
6494              type = current_function_prototype_arg_types;
6495            parm || (type && TREE_VALUE (type) != error_mark_node
6496                    && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
6497            parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6498         {
6499           if (parm == 0 || type == 0
6500               || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6501             {
6502               if (current_function_prototype_built_in)
6503                 warning (0, "number of arguments doesn%'t match "
6504                          "built-in prototype");
6505               else
6506                 {
6507                   error ("number of arguments doesn%'t match prototype");
6508                   error ("%Hprototype declaration",
6509                          &current_function_prototype_locus);
6510                 }
6511               break;
6512             }
6513           /* Type for passing arg must be consistent with that
6514              declared for the arg.  ISO C says we take the unqualified
6515              type for parameters declared with qualified type.  */
6516           if (!comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6517                           TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6518             {
6519               if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6520                   == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6521                 {
6522                   /* Adjust argument to match prototype.  E.g. a previous
6523                      `int foo(float);' prototype causes
6524                      `int foo(x) float x; {...}' to be treated like
6525                      `int foo(float x) {...}'.  This is particularly
6526                      useful for argument types like uid_t.  */
6527                   DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6528
6529                   if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
6530                       && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6531                       && TYPE_PRECISION (TREE_TYPE (parm))
6532                       < TYPE_PRECISION (integer_type_node))
6533                     DECL_ARG_TYPE (parm) = integer_type_node;
6534
6535                   if (pedantic)
6536                     {
6537                       /* ??? Is it possible to get here with a
6538                          built-in prototype or will it always have
6539                          been diagnosed as conflicting with an
6540                          old-style definition and discarded?  */
6541                       if (current_function_prototype_built_in)
6542                         warning (0, "promoted argument %qD "
6543                                  "doesn%'t match built-in prototype", parm);
6544                       else
6545                         {
6546                           pedwarn ("promoted argument %qD "
6547                                    "doesn%'t match prototype", parm);
6548                           pedwarn ("%Hprototype declaration",
6549                                    &current_function_prototype_locus);
6550                         }
6551                     }
6552                 }
6553               else
6554                 {
6555                   if (current_function_prototype_built_in)
6556                     warning (0, "argument %qD doesn%'t match "
6557                              "built-in prototype", parm);
6558                   else
6559                     {
6560                       error ("argument %qD doesn%'t match prototype", parm);
6561                       error ("%Hprototype declaration",
6562                              &current_function_prototype_locus);
6563                     }
6564                 }
6565             }
6566         }
6567       TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6568     }
6569
6570   /* Otherwise, create a prototype that would match.  */
6571
6572   else
6573     {
6574       tree actual = 0, last = 0, type;
6575
6576       for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6577         {
6578           type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6579           if (last)
6580             TREE_CHAIN (last) = type;
6581           else
6582             actual = type;
6583           last = type;
6584         }
6585       type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6586       if (last)
6587         TREE_CHAIN (last) = type;
6588       else
6589         actual = type;
6590
6591       /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6592          of the type of this function, but we need to avoid having this
6593          affect the types of other similarly-typed functions, so we must
6594          first force the generation of an identical (but separate) type
6595          node for the relevant function type.  The new node we create
6596          will be a variant of the main variant of the original function
6597          type.  */
6598
6599       TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
6600
6601       TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6602     }
6603 }
6604
6605 /* Store parameter declarations passed in ARG_INFO into the current
6606    function declaration.  */
6607
6608 void
6609 store_parm_decls_from (struct c_arg_info *arg_info)
6610 {
6611   current_function_arg_info = arg_info;
6612   store_parm_decls ();
6613 }
6614
6615 /* Store the parameter declarations into the current function declaration.
6616    This is called after parsing the parameter declarations, before
6617    digesting the body of the function.
6618
6619    For an old-style definition, construct a prototype out of the old-style
6620    parameter declarations and inject it into the function's type.  */
6621
6622 void
6623 store_parm_decls (void)
6624 {
6625   tree fndecl = current_function_decl;
6626   bool proto;
6627
6628   /* The argument information block for FNDECL.  */
6629   struct c_arg_info *arg_info = current_function_arg_info;
6630   current_function_arg_info = 0;
6631
6632   /* True if this definition is written with a prototype.  Note:
6633      despite C99 6.7.5.3p14, we can *not* treat an empty argument
6634      list in a function definition as equivalent to (void) -- an
6635      empty argument list specifies the function has no parameters,
6636      but only (void) sets up a prototype for future calls.  */
6637   proto = arg_info->types != 0;
6638
6639   if (proto)
6640     store_parm_decls_newstyle (fndecl, arg_info);
6641   else
6642     store_parm_decls_oldstyle (fndecl, arg_info);
6643
6644   /* The next call to push_scope will be a function body.  */
6645
6646   next_is_function_body = true;
6647
6648   /* Write a record describing this function definition to the prototypes
6649      file (if requested).  */
6650
6651   gen_aux_info_record (fndecl, 1, 0, proto);
6652
6653   /* Initialize the RTL code for the function.  */
6654   allocate_struct_function (fndecl);
6655
6656   /* Begin the statement tree for this function.  */
6657   DECL_SAVED_TREE (fndecl) = push_stmt_list ();
6658
6659   /* ??? Insert the contents of the pending sizes list into the function
6660      to be evaluated.  The only reason left to have this is
6661         void foo(int n, int array[n++])
6662      because we throw away the array type in favor of a pointer type, and
6663      thus won't naturally see the SAVE_EXPR containing the increment.  All
6664      other pending sizes would be handled by gimplify_parameters.  */
6665   {
6666     tree t;
6667     for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
6668       add_stmt (TREE_VALUE (t));
6669   }
6670
6671   /* Even though we're inside a function body, we still don't want to
6672      call expand_expr to calculate the size of a variable-sized array.
6673      We haven't necessarily assigned RTL to all variables yet, so it's
6674      not safe to try to expand expressions involving them.  */
6675   cfun->x_dont_save_pending_sizes_p = 1;
6676 }
6677 \f
6678 /* Emit diagnostics that require gimple input for detection.  Operate on
6679    FNDECL and all its nested functions.  */
6680
6681 static void
6682 c_gimple_diagnostics_recursively (tree fndecl)
6683 {
6684   struct cgraph_node *cgn;
6685
6686   /* Handle attribute((warn_unused_result)).  Relies on gimple input.  */
6687   c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
6688
6689   /* Notice when OpenMP structured block constraints are violated.  */
6690   if (flag_openmp)
6691     diagnose_omp_structured_block_errors (fndecl);
6692
6693   /* Finalize all nested functions now.  */
6694   cgn = cgraph_node (fndecl);
6695   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
6696     c_gimple_diagnostics_recursively (cgn->decl);
6697 }
6698
6699 /* Finish up a function declaration and compile that function
6700    all the way to assembler language output.  The free the storage
6701    for the function definition.
6702
6703    This is called after parsing the body of the function definition.  */
6704
6705 void
6706 finish_function (void)
6707 {
6708   tree fndecl = current_function_decl;
6709
6710   label_context_stack_se = label_context_stack_se->next;
6711   label_context_stack_vm = label_context_stack_vm->next;
6712
6713   if (TREE_CODE (fndecl) == FUNCTION_DECL
6714       && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
6715     {
6716       tree args = DECL_ARGUMENTS (fndecl);
6717       for (; args; args = TREE_CHAIN (args))
6718         {
6719           tree type = TREE_TYPE (args);
6720           if (INTEGRAL_TYPE_P (type)
6721               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
6722             DECL_ARG_TYPE (args) = integer_type_node;
6723         }
6724     }
6725
6726   if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
6727     BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6728
6729   /* Must mark the RESULT_DECL as being in this function.  */
6730
6731   if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
6732     DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6733
6734   if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6735     {
6736       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6737           != integer_type_node)
6738         {
6739           /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6740              If warn_main is -1 (-Wno-main) we don't want to be warned.  */
6741           if (!warn_main)
6742             pedwarn ("return type of %q+D is not %<int%>", fndecl);
6743         }
6744       else
6745         {
6746           if (flag_isoc99)
6747             {
6748               tree stmt = c_finish_return (integer_zero_node);
6749 #ifdef USE_MAPPED_LOCATION
6750               /* Hack.  We don't want the middle-end to warn that this return
6751                  is unreachable, so we mark its location as special.  Using
6752                  UNKNOWN_LOCATION has the problem that it gets clobbered in
6753                  annotate_one_with_locus.  A cleaner solution might be to
6754                  ensure ! should_carry_locus_p (stmt), but that needs a flag.
6755               */
6756               SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION);
6757 #else
6758               /* Hack.  We don't want the middle-end to warn that this
6759                  return is unreachable, so put the statement on the
6760                  special line 0.  */
6761               annotate_with_file_line (stmt, input_filename, 0);
6762 #endif
6763             }
6764         }
6765     }
6766
6767   /* Tie off the statement tree for this function.  */
6768   DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
6769
6770   finish_fname_decls ();
6771
6772   /* Complain if there's just no return statement.  */
6773   if (warn_return_type
6774       && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6775       && !current_function_returns_value && !current_function_returns_null
6776       /* Don't complain if we are no-return.  */
6777       && !current_function_returns_abnormally
6778       /* Don't warn for main().  */
6779       && !MAIN_NAME_P (DECL_NAME (fndecl))
6780       /* Or if they didn't actually specify a return type.  */
6781       && !C_FUNCTION_IMPLICIT_INT (fndecl)
6782       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
6783          inline function, as we might never be compiled separately.  */
6784       && DECL_INLINE (fndecl))
6785     {
6786       warning (OPT_Wreturn_type,
6787                "no return statement in function returning non-void");
6788       TREE_NO_WARNING (fndecl) = 1;
6789     }
6790
6791   /* With just -Wextra, complain only if function returns both with
6792      and without a value.  */
6793   if (extra_warnings
6794       && current_function_returns_value
6795       && current_function_returns_null)
6796     warning (OPT_Wextra, "this function may return with or without a value");
6797
6798   /* Store the end of the function, so that we get good line number
6799      info for the epilogue.  */
6800   cfun->function_end_locus = input_location;
6801
6802   /* Keep track of functions declared with the "constructor" and
6803      "destructor" attribute.  */
6804   c_record_cdtor_fn (fndecl);
6805
6806   /* Finalize the ELF visibility for the function.  */
6807   c_determine_visibility (fndecl);
6808
6809   /* Genericize before inlining.  Delay genericizing nested functions
6810      until their parent function is genericized.  Since finalizing
6811      requires GENERIC, delay that as well.  */
6812
6813   if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
6814       && !undef_nested_function)
6815     {
6816       if (!decl_function_context (fndecl))
6817         {
6818           c_genericize (fndecl);
6819           c_gimple_diagnostics_recursively (fndecl);
6820
6821           /* ??? Objc emits functions after finalizing the compilation unit.
6822              This should be cleaned up later and this conditional removed.  */
6823           if (cgraph_global_info_ready)
6824             {
6825               c_expand_body (fndecl);
6826               return;
6827             }
6828
6829           cgraph_finalize_function (fndecl, false);
6830         }
6831       else
6832         {
6833           /* Register this function with cgraph just far enough to get it
6834             added to our parent's nested function list.  Handy, since the
6835             C front end doesn't have such a list.  */
6836           (void) cgraph_node (fndecl);
6837         }
6838     }
6839
6840   if (!decl_function_context (fndecl))
6841     undef_nested_function = false;
6842
6843   /* We're leaving the context of this function, so zap cfun.
6844      It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
6845      tree_rest_of_compilation.  */
6846   cfun = NULL;
6847   current_function_decl = NULL;
6848 }
6849 \f
6850 /* Check the declarations given in a for-loop for satisfying the C99
6851    constraints.  If exactly one such decl is found, return it.  */
6852
6853 tree
6854 check_for_loop_decls (void)
6855 {
6856   struct c_binding *b;
6857   tree one_decl = NULL_TREE;
6858   int n_decls = 0;
6859
6860
6861   if (!flag_isoc99)
6862     {
6863       /* If we get here, declarations have been used in a for loop without
6864          the C99 for loop scope.  This doesn't make much sense, so don't
6865          allow it.  */
6866       error ("%<for%> loop initial declaration used outside C99 mode");
6867       return NULL_TREE;
6868     }
6869   /* C99 subclause 6.8.5 paragraph 3:
6870
6871        [#3]  The  declaration  part  of  a for statement shall only
6872        declare identifiers for objects having storage class auto or
6873        register.
6874
6875      It isn't clear whether, in this sentence, "identifiers" binds to
6876      "shall only declare" or to "objects" - that is, whether all identifiers
6877      declared must be identifiers for objects, or whether the restriction
6878      only applies to those that are.  (A question on this in comp.std.c
6879      in November 2000 received no answer.)  We implement the strictest
6880      interpretation, to avoid creating an extension which later causes
6881      problems.  */
6882
6883   for (b = current_scope->bindings; b; b = b->prev)
6884     {
6885       tree id = b->id;
6886       tree decl = b->decl;
6887
6888       if (!id)
6889         continue;
6890
6891       switch (TREE_CODE (decl))
6892         {
6893         case VAR_DECL:
6894           if (TREE_STATIC (decl))
6895             error ("declaration of static variable %q+D in %<for%> loop "
6896                    "initial declaration", decl);
6897           else if (DECL_EXTERNAL (decl))
6898             error ("declaration of %<extern%> variable %q+D in %<for%> loop "
6899                    "initial declaration", decl);
6900           break;
6901
6902         case RECORD_TYPE:
6903           error ("%<struct %E%> declared in %<for%> loop initial declaration",
6904                  id);
6905           break;
6906         case UNION_TYPE:
6907           error ("%<union %E%> declared in %<for%> loop initial declaration",
6908                  id);
6909           break;
6910         case ENUMERAL_TYPE:
6911           error ("%<enum %E%> declared in %<for%> loop initial declaration",
6912                  id);
6913           break;
6914         default:
6915           error ("declaration of non-variable %q+D in %<for%> loop "
6916                  "initial declaration", decl);
6917         }
6918
6919       n_decls++;
6920       one_decl = decl;
6921     }
6922
6923   return n_decls == 1 ? one_decl : NULL_TREE;
6924 }
6925 \f
6926 /* Save and reinitialize the variables
6927    used during compilation of a C function.  */
6928
6929 void
6930 c_push_function_context (struct function *f)
6931 {
6932   struct language_function *p;
6933   p = GGC_NEW (struct language_function);
6934   f->language = p;
6935
6936   p->base.x_stmt_tree = c_stmt_tree;
6937   p->x_break_label = c_break_label;
6938   p->x_cont_label = c_cont_label;
6939   p->x_switch_stack = c_switch_stack;
6940   p->arg_info = current_function_arg_info;
6941   p->returns_value = current_function_returns_value;
6942   p->returns_null = current_function_returns_null;
6943   p->returns_abnormally = current_function_returns_abnormally;
6944   p->warn_about_return_type = warn_about_return_type;
6945 }
6946
6947 /* Restore the variables used during compilation of a C function.  */
6948
6949 void
6950 c_pop_function_context (struct function *f)
6951 {
6952   struct language_function *p = f->language;
6953
6954   if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
6955       && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6956     {
6957       /* Stop pointing to the local nodes about to be freed.  */
6958       /* But DECL_INITIAL must remain nonzero so we know this
6959          was an actual function definition.  */
6960       DECL_INITIAL (current_function_decl) = error_mark_node;
6961       DECL_ARGUMENTS (current_function_decl) = 0;
6962     }
6963
6964   c_stmt_tree = p->base.x_stmt_tree;
6965   c_break_label = p->x_break_label;
6966   c_cont_label = p->x_cont_label;
6967   c_switch_stack = p->x_switch_stack;
6968   current_function_arg_info = p->arg_info;
6969   current_function_returns_value = p->returns_value;
6970   current_function_returns_null = p->returns_null;
6971   current_function_returns_abnormally = p->returns_abnormally;
6972   warn_about_return_type = p->warn_about_return_type;
6973
6974   f->language = NULL;
6975 }
6976
6977 /* Copy the DECL_LANG_SPECIFIC data associated with DECL.  */
6978
6979 void
6980 c_dup_lang_specific_decl (tree decl)
6981 {
6982   struct lang_decl *ld;
6983
6984   if (!DECL_LANG_SPECIFIC (decl))
6985     return;
6986
6987   ld = GGC_NEW (struct lang_decl);
6988   memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
6989   DECL_LANG_SPECIFIC (decl) = ld;
6990 }
6991
6992 /* The functions below are required for functionality of doing
6993    function at once processing in the C front end. Currently these
6994    functions are not called from anywhere in the C front end, but as
6995    these changes continue, that will change.  */
6996
6997 /* Returns the stmt_tree (if any) to which statements are currently
6998    being added.  If there is no active statement-tree, NULL is
6999    returned.  */
7000
7001 stmt_tree
7002 current_stmt_tree (void)
7003 {
7004   return &c_stmt_tree;
7005 }
7006
7007 /* Nonzero if TYPE is an anonymous union or struct type.  Always 0 in
7008    C.  */
7009
7010 int
7011 anon_aggr_type_p (tree ARG_UNUSED (node))
7012 {
7013   return 0;
7014 }
7015
7016 /* Return the global value of T as a symbol.  */
7017
7018 tree
7019 identifier_global_value (tree t)
7020 {
7021   struct c_binding *b;
7022
7023   for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
7024     if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
7025       return b->decl;
7026
7027   return 0;
7028 }
7029
7030 /* Record a builtin type for C.  If NAME is non-NULL, it is the name used;
7031    otherwise the name is found in ridpointers from RID_INDEX.  */
7032
7033 void
7034 record_builtin_type (enum rid rid_index, const char *name, tree type)
7035 {
7036   tree id, decl;
7037   if (name == 0)
7038     id = ridpointers[(int) rid_index];
7039   else
7040     id = get_identifier (name);
7041   decl = build_decl (TYPE_DECL, id, type);
7042   pushdecl (decl);
7043   if (debug_hooks->type_decl)
7044     debug_hooks->type_decl (decl, false);
7045 }
7046
7047 /* Build the void_list_node (void_type_node having been created).  */
7048 tree
7049 build_void_list_node (void)
7050 {
7051   tree t = build_tree_list (NULL_TREE, void_type_node);
7052   return t;
7053 }
7054
7055 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR.  */
7056
7057 struct c_parm *
7058 build_c_parm (struct c_declspecs *specs, tree attrs,
7059               struct c_declarator *declarator)
7060 {
7061   struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
7062   ret->specs = specs;
7063   ret->attrs = attrs;
7064   ret->declarator = declarator;
7065   return ret;
7066 }
7067
7068 /* Return a declarator with nested attributes.  TARGET is the inner
7069    declarator to which these attributes apply.  ATTRS are the
7070    attributes.  */
7071
7072 struct c_declarator *
7073 build_attrs_declarator (tree attrs, struct c_declarator *target)
7074 {
7075   struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7076   ret->kind = cdk_attrs;
7077   ret->declarator = target;
7078   ret->u.attrs = attrs;
7079   return ret;
7080 }
7081
7082 /* Return a declarator for a function with arguments specified by ARGS
7083    and return type specified by TARGET.  */
7084
7085 struct c_declarator *
7086 build_function_declarator (struct c_arg_info *args,
7087                            struct c_declarator *target)
7088 {
7089   struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7090   ret->kind = cdk_function;
7091   ret->declarator = target;
7092   ret->u.arg_info = args;
7093   return ret;
7094 }
7095
7096 /* Return a declarator for the identifier IDENT (which may be
7097    NULL_TREE for an abstract declarator).  */
7098
7099 struct c_declarator *
7100 build_id_declarator (tree ident)
7101 {
7102   struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7103   ret->kind = cdk_id;
7104   ret->declarator = 0;
7105   ret->u.id = ident;
7106   /* Default value - may get reset to a more precise location. */
7107   ret->id_loc = input_location;
7108   return ret;
7109 }
7110
7111 /* Return something to represent absolute declarators containing a *.
7112    TARGET is the absolute declarator that the * contains.
7113    TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
7114    to apply to the pointer type.  */
7115
7116 struct c_declarator *
7117 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
7118                          struct c_declarator *target)
7119 {
7120   tree attrs;
7121   int quals = 0;
7122   struct c_declarator *itarget = target;
7123   struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7124   if (type_quals_attrs)
7125     {
7126       attrs = type_quals_attrs->attrs;
7127       quals = quals_from_declspecs (type_quals_attrs);
7128       if (attrs != NULL_TREE)
7129         itarget = build_attrs_declarator (attrs, target);
7130     }
7131   ret->kind = cdk_pointer;
7132   ret->declarator = itarget;
7133   ret->u.pointer_quals = quals;
7134   return ret;
7135 }
7136
7137 /* Return a pointer to a structure for an empty list of declaration
7138    specifiers.  */
7139
7140 struct c_declspecs *
7141 build_null_declspecs (void)
7142 {
7143   struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
7144   ret->type = 0;
7145   ret->decl_attr = 0;
7146   ret->attrs = 0;
7147   ret->typespec_word = cts_none;
7148   ret->storage_class = csc_none;
7149   ret->declspecs_seen_p = false;
7150   ret->type_seen_p = false;
7151   ret->non_sc_seen_p = false;
7152   ret->typedef_p = false;
7153   ret->tag_defined_p = false;
7154   ret->explicit_signed_p = false;
7155   ret->deprecated_p = false;
7156   ret->default_int_p = false;
7157   ret->long_p = false;
7158   ret->long_long_p = false;
7159   ret->short_p = false;
7160   ret->signed_p = false;
7161   ret->unsigned_p = false;
7162   ret->complex_p = false;
7163   ret->inline_p = false;
7164   ret->thread_p = false;
7165   ret->const_p = false;
7166   ret->volatile_p = false;
7167   ret->restrict_p = false;
7168   return ret;
7169 }
7170
7171 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
7172    returning SPECS.  */
7173
7174 struct c_declspecs *
7175 declspecs_add_qual (struct c_declspecs *specs, tree qual)
7176 {
7177   enum rid i;
7178   bool dupe = false;
7179   specs->non_sc_seen_p = true;
7180   specs->declspecs_seen_p = true;
7181   gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
7182               && C_IS_RESERVED_WORD (qual));
7183   i = C_RID_CODE (qual);
7184   switch (i)
7185     {
7186     case RID_CONST:
7187       dupe = specs->const_p;
7188       specs->const_p = true;
7189       break;
7190     case RID_VOLATILE:
7191       dupe = specs->volatile_p;
7192       specs->volatile_p = true;
7193       break;
7194     case RID_RESTRICT:
7195       dupe = specs->restrict_p;
7196       specs->restrict_p = true;
7197       break;
7198     default:
7199       gcc_unreachable ();
7200     }
7201   if (dupe && pedantic && !flag_isoc99)
7202     pedwarn ("duplicate %qE", qual);
7203   return specs;
7204 }
7205
7206 /* Add the type specifier TYPE to the declaration specifiers SPECS,
7207    returning SPECS.  */
7208
7209 struct c_declspecs *
7210 declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
7211 {
7212   tree type = spec.spec;
7213   specs->non_sc_seen_p = true;
7214   specs->declspecs_seen_p = true;
7215   specs->type_seen_p = true;
7216   if (TREE_DEPRECATED (type))
7217     specs->deprecated_p = true;
7218
7219   /* Handle type specifier keywords.  */
7220   if (TREE_CODE (type) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (type))
7221     {
7222       enum rid i = C_RID_CODE (type);
7223       if (specs->type)
7224         {
7225           error ("two or more data types in declaration specifiers");
7226           return specs;
7227         }
7228       if ((int) i <= (int) RID_LAST_MODIFIER)
7229         {
7230           /* "long", "short", "signed", "unsigned" or "_Complex".  */
7231           bool dupe = false;
7232           switch (i)
7233             {
7234             case RID_LONG:
7235               if (specs->long_long_p)
7236                 {
7237                   error ("%<long long long%> is too long for GCC");
7238                   break;
7239                 }
7240               if (specs->long_p)
7241                 {
7242                   if (specs->typespec_word == cts_double)
7243                     {
7244                       error ("both %<long long%> and %<double%> in "
7245                              "declaration specifiers");
7246                       break;
7247                     }
7248                   if (pedantic && !flag_isoc99 && !in_system_header
7249                       && warn_long_long)
7250                     pedwarn ("ISO C90 does not support %<long long%>");
7251                   specs->long_long_p = 1;
7252                   break;
7253                 }
7254               if (specs->short_p)
7255                 error ("both %<long%> and %<short%> in "
7256                        "declaration specifiers");
7257               else if (specs->typespec_word == cts_void)
7258                 error ("both %<long%> and %<void%> in "
7259                        "declaration specifiers");
7260               else if (specs->typespec_word == cts_bool)
7261                 error ("both %<long%> and %<_Bool%> in "
7262                        "declaration specifiers");
7263               else if (specs->typespec_word == cts_char)
7264                 error ("both %<long%> and %<char%> in "
7265                        "declaration specifiers");
7266               else if (specs->typespec_word == cts_float)
7267                 error ("both %<long%> and %<float%> in "
7268                        "declaration specifiers");
7269               else if (specs->typespec_word == cts_dfloat32)
7270                 error ("both %<long%> and %<_Decimal32%> in "
7271                        "declaration specifiers");
7272               else if (specs->typespec_word == cts_dfloat64)
7273                 error ("both %<long%> and %<_Decimal64%> in "
7274                        "declaration specifiers");
7275               else if (specs->typespec_word == cts_dfloat128)
7276                 error ("both %<long%> and %<_Decimal128%> in "
7277                        "declaration specifiers");
7278               else
7279                 specs->long_p = true;
7280               break;
7281             case RID_SHORT:
7282               dupe = specs->short_p;
7283               if (specs->long_p)
7284                 error ("both %<long%> and %<short%> in "
7285                        "declaration specifiers");
7286               else if (specs->typespec_word == cts_void)
7287                 error ("both %<short%> and %<void%> in "
7288                        "declaration specifiers");
7289               else if (specs->typespec_word == cts_bool)
7290                 error ("both %<short%> and %<_Bool%> in "
7291                        "declaration specifiers");
7292               else if (specs->typespec_word == cts_char)
7293                 error ("both %<short%> and %<char%> in "
7294                        "declaration specifiers");
7295               else if (specs->typespec_word == cts_float)
7296                 error ("both %<short%> and %<float%> in "
7297                        "declaration specifiers");
7298               else if (specs->typespec_word == cts_double)
7299                 error ("both %<short%> and %<double%> in "
7300                        "declaration specifiers");
7301               else if (specs->typespec_word == cts_dfloat32)
7302                 error ("both %<short%> and %<_Decimal32%> in "
7303                        "declaration specifiers");
7304               else if (specs->typespec_word == cts_dfloat64)
7305                 error ("both %<short%> and %<_Decimal64%> in "
7306                                         "declaration specifiers");
7307               else if (specs->typespec_word == cts_dfloat128)
7308                 error ("both %<short%> and %<_Decimal128%> in "
7309                        "declaration specifiers");
7310               else
7311                 specs->short_p = true;
7312               break;
7313             case RID_SIGNED:
7314               dupe = specs->signed_p;
7315               if (specs->unsigned_p)
7316                 error ("both %<signed%> and %<unsigned%> in "
7317                        "declaration specifiers");
7318               else if (specs->typespec_word == cts_void)
7319                 error ("both %<signed%> and %<void%> in "
7320                        "declaration specifiers");
7321               else if (specs->typespec_word == cts_bool)
7322                 error ("both %<signed%> and %<_Bool%> in "
7323                        "declaration specifiers");
7324               else if (specs->typespec_word == cts_float)
7325                 error ("both %<signed%> and %<float%> in "
7326                        "declaration specifiers");
7327               else if (specs->typespec_word == cts_double)
7328                 error ("both %<signed%> and %<double%> in "
7329                        "declaration specifiers");
7330               else if (specs->typespec_word == cts_dfloat32)
7331                 error ("both %<signed%> and %<_Decimal32%> in "
7332                        "declaration specifiers");
7333               else if (specs->typespec_word == cts_dfloat64)
7334                 error ("both %<signed%> and %<_Decimal64%> in "
7335                        "declaration specifiers");
7336               else if (specs->typespec_word == cts_dfloat128)
7337                 error ("both %<signed%> and %<_Decimal128%> in "
7338                        "declaration specifiers");
7339               else
7340                 specs->signed_p = true;
7341               break;
7342             case RID_UNSIGNED:
7343               dupe = specs->unsigned_p;
7344               if (specs->signed_p)
7345                 error ("both %<signed%> and %<unsigned%> in "
7346                        "declaration specifiers");
7347               else if (specs->typespec_word == cts_void)
7348                 error ("both %<unsigned%> and %<void%> in "
7349                        "declaration specifiers");
7350               else if (specs->typespec_word == cts_bool)
7351                 error ("both %<unsigned%> and %<_Bool%> in "
7352                        "declaration specifiers");
7353               else if (specs->typespec_word == cts_float)
7354                 error ("both %<unsigned%> and %<float%> in "
7355                        "declaration specifiers");
7356               else if (specs->typespec_word == cts_double)
7357                 error ("both %<unsigned%> and %<double%> in "
7358                        "declaration specifiers");
7359               else if (specs->typespec_word == cts_dfloat32)
7360                 error ("both %<unsigned%> and %<_Decimal32%> in "
7361                        "declaration specifiers");
7362               else if (specs->typespec_word == cts_dfloat64)
7363                 error ("both %<unsigned%> and %<_Decimal64%> in "
7364                        "declaration specifiers");
7365               else if (specs->typespec_word == cts_dfloat128)
7366                 error ("both %<unsigned%> and %<_Decimal128%> in "
7367                        "declaration specifiers");
7368               else
7369                 specs->unsigned_p = true;
7370               break;
7371             case RID_COMPLEX:
7372               dupe = specs->complex_p;
7373               if (pedantic && !flag_isoc99 && !in_system_header)
7374                 pedwarn ("ISO C90 does not support complex types");
7375               if (specs->typespec_word == cts_void)
7376                 error ("both %<complex%> and %<void%> in "
7377                        "declaration specifiers");
7378               else if (specs->typespec_word == cts_bool)
7379                 error ("both %<complex%> and %<_Bool%> in "
7380                        "declaration specifiers");
7381               else if (specs->typespec_word == cts_dfloat32)
7382                 error ("both %<complex%> and %<_Decimal32%> in "
7383                        "declaration specifiers");
7384               else if (specs->typespec_word == cts_dfloat64)
7385                 error ("both %<complex%> and %<_Decimal64%> in "
7386                        "declaration specifiers");
7387               else if (specs->typespec_word == cts_dfloat128)
7388                 error ("both %<complex%> and %<_Decimal128%> in "
7389                        "declaration specifiers");
7390               else
7391                 specs->complex_p = true;
7392               break;
7393             default:
7394               gcc_unreachable ();
7395             }
7396
7397           if (dupe)
7398             error ("duplicate %qE", type);
7399
7400           return specs;
7401         }
7402       else
7403         {
7404           /* "void", "_Bool", "char", "int", "float" or "double".  */
7405           if (specs->typespec_word != cts_none)
7406             {
7407               error ("two or more data types in declaration specifiers");
7408               return specs;
7409             }
7410           switch (i)
7411             {
7412             case RID_VOID:
7413               if (specs->long_p)
7414                 error ("both %<long%> and %<void%> in "
7415                        "declaration specifiers");
7416               else if (specs->short_p)
7417                 error ("both %<short%> and %<void%> in "
7418                        "declaration specifiers");
7419               else if (specs->signed_p)
7420                 error ("both %<signed%> and %<void%> in "
7421                        "declaration specifiers");
7422               else if (specs->unsigned_p)
7423                 error ("both %<unsigned%> and %<void%> in "
7424                        "declaration specifiers");
7425               else if (specs->complex_p)
7426                 error ("both %<complex%> and %<void%> in "
7427                        "declaration specifiers");
7428               else
7429                 specs->typespec_word = cts_void;
7430               return specs;
7431             case RID_BOOL:
7432               if (specs->long_p)
7433                 error ("both %<long%> and %<_Bool%> in "
7434                        "declaration specifiers");
7435               else if (specs->short_p)
7436                 error ("both %<short%> and %<_Bool%> in "
7437                        "declaration specifiers");
7438               else if (specs->signed_p)
7439                 error ("both %<signed%> and %<_Bool%> in "
7440                        "declaration specifiers");
7441               else if (specs->unsigned_p)
7442                 error ("both %<unsigned%> and %<_Bool%> in "
7443                        "declaration specifiers");
7444               else if (specs->complex_p)
7445                 error ("both %<complex%> and %<_Bool%> in "
7446                        "declaration specifiers");
7447               else
7448                 specs->typespec_word = cts_bool;
7449               return specs;
7450             case RID_CHAR:
7451               if (specs->long_p)
7452                 error ("both %<long%> and %<char%> in "
7453                        "declaration specifiers");
7454               else if (specs->short_p)
7455                 error ("both %<short%> and %<char%> in "
7456                        "declaration specifiers");
7457               else
7458                 specs->typespec_word = cts_char;
7459               return specs;
7460             case RID_INT:
7461               specs->typespec_word = cts_int;
7462               return specs;
7463             case RID_FLOAT:
7464               if (specs->long_p)
7465                 error ("both %<long%> and %<float%> in "
7466                        "declaration specifiers");
7467               else if (specs->short_p)
7468                 error ("both %<short%> and %<float%> in "
7469                        "declaration specifiers");
7470               else if (specs->signed_p)
7471                 error ("both %<signed%> and %<float%> in "
7472                        "declaration specifiers");
7473               else if (specs->unsigned_p)
7474                 error ("both %<unsigned%> and %<float%> in "
7475                        "declaration specifiers");
7476               else
7477                 specs->typespec_word = cts_float;
7478               return specs;
7479             case RID_DOUBLE:
7480               if (specs->long_long_p)
7481                 error ("both %<long long%> and %<double%> in "
7482                        "declaration specifiers");
7483               else if (specs->short_p)
7484                 error ("both %<short%> and %<double%> in "
7485                        "declaration specifiers");
7486               else if (specs->signed_p)
7487                 error ("both %<signed%> and %<double%> in "
7488                        "declaration specifiers");
7489               else if (specs->unsigned_p)
7490                 error ("both %<unsigned%> and %<double%> in "
7491                        "declaration specifiers");
7492               else
7493                 specs->typespec_word = cts_double;
7494               return specs;
7495             case RID_DFLOAT32:
7496             case RID_DFLOAT64:
7497             case RID_DFLOAT128:
7498               {
7499                 const char *str;
7500                 if (i == RID_DFLOAT32)
7501                   str = "_Decimal32";
7502                 else if (i == RID_DFLOAT64)
7503                   str = "_Decimal64";
7504                 else
7505                   str = "_Decimal128";
7506                 if (specs->long_long_p)
7507                   error ("both %<long long%> and %<%s%> in "
7508                          "declaration specifiers", str);
7509                 if (specs->long_p)
7510                   error ("both %<long%> and %<%s%> in "
7511                          "declaration specifiers", str);
7512                 else if (specs->short_p)
7513                   error ("both %<short%> and %<%s%> in "
7514                          "declaration specifiers", str);
7515                 else if (specs->signed_p)
7516                   error ("both %<signed%> and %<%s%> in "
7517                          "declaration specifiers", str);
7518                 else if (specs->unsigned_p)
7519                   error ("both %<unsigned%> and %<%s%> in "
7520                          "declaration specifiers", str);
7521                 else if (specs->complex_p)
7522                   error ("both %<complex%> and %<%s%> in "
7523                          "declaration specifiers", str);
7524                 else if (i == RID_DFLOAT32)
7525                   specs->typespec_word = cts_dfloat32;
7526                 else if (i == RID_DFLOAT64)
7527                   specs->typespec_word = cts_dfloat64;
7528                 else
7529                   specs->typespec_word = cts_dfloat128;
7530               }
7531               if (!targetm.decimal_float_supported_p ())
7532                 error ("decimal floating point not supported for this target");
7533               if (pedantic)
7534                 pedwarn ("ISO C does not support decimal floating point");
7535               return specs;
7536             default:
7537               /* ObjC reserved word "id", handled below.  */
7538               break;
7539             }
7540         }
7541     }
7542
7543   /* Now we have a typedef (a TYPE_DECL node), an identifier (some
7544      form of ObjC type, cases such as "int" and "long" being handled
7545      above), a TYPE (struct, union, enum and typeof specifiers) or an
7546      ERROR_MARK.  In none of these cases may there have previously
7547      been any type specifiers.  */
7548   if (specs->type || specs->typespec_word != cts_none
7549       || specs->long_p || specs->short_p || specs->signed_p
7550       || specs->unsigned_p || specs->complex_p)
7551     error ("two or more data types in declaration specifiers");
7552   else if (TREE_CODE (type) == TYPE_DECL)
7553     {
7554       if (TREE_TYPE (type) == error_mark_node)
7555         ; /* Allow the type to default to int to avoid cascading errors.  */
7556       else
7557         {
7558           specs->type = TREE_TYPE (type);
7559           specs->decl_attr = DECL_ATTRIBUTES (type);
7560           specs->typedef_p = true;
7561           specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
7562         }
7563     }
7564   else if (TREE_CODE (type) == IDENTIFIER_NODE)
7565     {
7566       tree t = lookup_name (type);
7567       if (!t || TREE_CODE (t) != TYPE_DECL)
7568         error ("%qE fails to be a typedef or built in type", type);
7569       else if (TREE_TYPE (t) == error_mark_node)
7570         ;
7571       else
7572         specs->type = TREE_TYPE (t);
7573     }
7574   else if (TREE_CODE (type) != ERROR_MARK)
7575     {
7576       if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
7577         specs->tag_defined_p = true;
7578       if (spec.kind == ctsk_typeof)
7579         specs->typedef_p = true;
7580       specs->type = type;
7581     }
7582
7583   return specs;
7584 }
7585
7586 /* Add the storage class specifier or function specifier SCSPEC to the
7587    declaration specifiers SPECS, returning SPECS.  */
7588
7589 struct c_declspecs *
7590 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
7591 {
7592   enum rid i;
7593   enum c_storage_class n = csc_none;
7594   bool dupe = false;
7595   specs->declspecs_seen_p = true;
7596   gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
7597               && C_IS_RESERVED_WORD (scspec));
7598   i = C_RID_CODE (scspec);
7599   if (specs->non_sc_seen_p)
7600     warning (OPT_Wold_style_declaration,
7601              "%qE is not at beginning of declaration", scspec);
7602   switch (i)
7603     {
7604     case RID_INLINE:
7605       /* C99 permits duplicate inline.  Although of doubtful utility,
7606          it seems simplest to permit it in gnu89 mode as well, as
7607          there is also little utility in maintaining this as a
7608          difference between gnu89 and C99 inline.  */
7609       dupe = false;
7610       specs->inline_p = true;
7611       break;
7612     case RID_THREAD:
7613       dupe = specs->thread_p;
7614       if (specs->storage_class == csc_auto)
7615         error ("%<__thread%> used with %<auto%>");
7616       else if (specs->storage_class == csc_register)
7617         error ("%<__thread%> used with %<register%>");
7618       else if (specs->storage_class == csc_typedef)
7619         error ("%<__thread%> used with %<typedef%>");
7620       else
7621         specs->thread_p = true;
7622       break;
7623     case RID_AUTO:
7624       n = csc_auto;
7625       break;
7626     case RID_EXTERN:
7627       n = csc_extern;
7628       /* Diagnose "__thread extern".  */
7629       if (specs->thread_p)
7630         error ("%<__thread%> before %<extern%>");
7631       break;
7632     case RID_REGISTER:
7633       n = csc_register;
7634       break;
7635     case RID_STATIC:
7636       n = csc_static;
7637       /* Diagnose "__thread static".  */
7638       if (specs->thread_p)
7639         error ("%<__thread%> before %<static%>");
7640       break;
7641     case RID_TYPEDEF:
7642       n = csc_typedef;
7643       break;
7644     default:
7645       gcc_unreachable ();
7646     }
7647   if (n != csc_none && n == specs->storage_class)
7648     dupe = true;
7649   if (dupe)
7650     error ("duplicate %qE", scspec);
7651   if (n != csc_none)
7652     {
7653       if (specs->storage_class != csc_none && n != specs->storage_class)
7654         {
7655           error ("multiple storage classes in declaration specifiers");
7656         }
7657       else
7658         {
7659           specs->storage_class = n;
7660           if (n != csc_extern && n != csc_static && specs->thread_p)
7661             {
7662               error ("%<__thread%> used with %qE", scspec);
7663               specs->thread_p = false;
7664             }
7665         }
7666     }
7667   return specs;
7668 }
7669
7670 /* Add the attributes ATTRS to the declaration specifiers SPECS,
7671    returning SPECS.  */
7672
7673 struct c_declspecs *
7674 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
7675 {
7676   specs->attrs = chainon (attrs, specs->attrs);
7677   specs->declspecs_seen_p = true;
7678   return specs;
7679 }
7680
7681 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
7682    specifiers with any other type specifier to determine the resulting
7683    type.  This is where ISO C checks on complex types are made, since
7684    "_Complex long" is a prefix of the valid ISO C type "_Complex long
7685    double".  */
7686
7687 struct c_declspecs *
7688 finish_declspecs (struct c_declspecs *specs)
7689 {
7690   /* If a type was specified as a whole, we have no modifiers and are
7691      done.  */
7692   if (specs->type != NULL_TREE)
7693     {
7694       gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
7695                   && !specs->signed_p && !specs->unsigned_p
7696                   && !specs->complex_p);
7697       return specs;
7698     }
7699
7700   /* If none of "void", "_Bool", "char", "int", "float" or "double"
7701      has been specified, treat it as "int" unless "_Complex" is
7702      present and there are no other specifiers.  If we just have
7703      "_Complex", it is equivalent to "_Complex double", but e.g.
7704      "_Complex short" is equivalent to "_Complex short int".  */
7705   if (specs->typespec_word == cts_none)
7706     {
7707       if (specs->long_p || specs->short_p
7708           || specs->signed_p || specs->unsigned_p)
7709         {
7710           specs->typespec_word = cts_int;
7711         }
7712       else if (specs->complex_p)
7713         {
7714           specs->typespec_word = cts_double;
7715           if (pedantic)
7716             pedwarn ("ISO C does not support plain %<complex%> meaning "
7717                      "%<double complex%>");
7718         }
7719       else
7720         {
7721           specs->typespec_word = cts_int;
7722           specs->default_int_p = true;
7723           /* We don't diagnose this here because grokdeclarator will
7724              give more specific diagnostics according to whether it is
7725              a function definition.  */
7726         }
7727     }
7728
7729   /* If "signed" was specified, record this to distinguish "int" and
7730      "signed int" in the case of a bit-field with
7731      -funsigned-bitfields.  */
7732   specs->explicit_signed_p = specs->signed_p;
7733
7734   /* Now compute the actual type.  */
7735   switch (specs->typespec_word)
7736     {
7737     case cts_void:
7738       gcc_assert (!specs->long_p && !specs->short_p
7739                   && !specs->signed_p && !specs->unsigned_p
7740                   && !specs->complex_p);
7741       specs->type = void_type_node;
7742       break;
7743     case cts_bool:
7744       gcc_assert (!specs->long_p && !specs->short_p
7745                   && !specs->signed_p && !specs->unsigned_p
7746                   && !specs->complex_p);
7747       specs->type = boolean_type_node;
7748       break;
7749     case cts_char:
7750       gcc_assert (!specs->long_p && !specs->short_p);
7751       gcc_assert (!(specs->signed_p && specs->unsigned_p));
7752       if (specs->signed_p)
7753         specs->type = signed_char_type_node;
7754       else if (specs->unsigned_p)
7755         specs->type = unsigned_char_type_node;
7756       else
7757         specs->type = char_type_node;
7758       if (specs->complex_p)
7759         {
7760           if (pedantic)
7761             pedwarn ("ISO C does not support complex integer types");
7762           specs->type = build_complex_type (specs->type);
7763         }
7764       break;
7765     case cts_int:
7766       gcc_assert (!(specs->long_p && specs->short_p));
7767       gcc_assert (!(specs->signed_p && specs->unsigned_p));
7768       if (specs->long_long_p)
7769         specs->type = (specs->unsigned_p
7770                        ? long_long_unsigned_type_node
7771                        : long_long_integer_type_node);
7772       else if (specs->long_p)
7773         specs->type = (specs->unsigned_p
7774                        ? long_unsigned_type_node
7775                        : long_integer_type_node);
7776       else if (specs->short_p)
7777         specs->type = (specs->unsigned_p
7778                        ? short_unsigned_type_node
7779                        : short_integer_type_node);
7780       else
7781         specs->type = (specs->unsigned_p
7782                        ? unsigned_type_node
7783                        : integer_type_node);
7784       if (specs->complex_p)
7785         {
7786           if (pedantic)
7787             pedwarn ("ISO C does not support complex integer types");
7788           specs->type = build_complex_type (specs->type);
7789         }
7790       break;
7791     case cts_float:
7792       gcc_assert (!specs->long_p && !specs->short_p
7793                   && !specs->signed_p && !specs->unsigned_p);
7794       specs->type = (specs->complex_p
7795                      ? complex_float_type_node
7796                      : float_type_node);
7797       break;
7798     case cts_double:
7799       gcc_assert (!specs->long_long_p && !specs->short_p
7800                   && !specs->signed_p && !specs->unsigned_p);
7801       if (specs->long_p)
7802         {
7803           specs->type = (specs->complex_p
7804                          ? complex_long_double_type_node
7805                          : long_double_type_node);
7806         }
7807       else
7808         {
7809           specs->type = (specs->complex_p
7810                          ? complex_double_type_node
7811                          : double_type_node);
7812         }
7813       break;
7814     case cts_dfloat32:
7815     case cts_dfloat64:
7816     case cts_dfloat128:
7817       gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
7818                   && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
7819       if (specs->typespec_word == cts_dfloat32)
7820         specs->type = dfloat32_type_node;
7821       else if (specs->typespec_word == cts_dfloat64)
7822         specs->type = dfloat64_type_node;
7823       else
7824         specs->type = dfloat128_type_node;
7825       break;
7826     default:
7827       gcc_unreachable ();
7828     }
7829
7830   return specs;
7831 }
7832
7833 /* A subroutine of c_write_global_declarations.  Perform final processing
7834    on one file scope's declarations (or the external scope's declarations),
7835    GLOBALS.  */
7836
7837 static void
7838 c_write_global_declarations_1 (tree globals)
7839 {
7840   tree decl;
7841   bool reconsider;
7842
7843   /* Process the decls in the order they were written.  */
7844   for (decl = globals; decl; decl = TREE_CHAIN (decl))
7845     {
7846       /* Check for used but undefined static functions using the C
7847          standard's definition of "used", and set TREE_NO_WARNING so
7848          that check_global_declarations doesn't repeat the check.  */
7849       if (TREE_CODE (decl) == FUNCTION_DECL
7850           && DECL_INITIAL (decl) == 0
7851           && DECL_EXTERNAL (decl)
7852           && !TREE_PUBLIC (decl)
7853           && C_DECL_USED (decl))
7854         {
7855           pedwarn ("%q+F used but never defined", decl);
7856           TREE_NO_WARNING (decl) = 1;
7857         }
7858
7859       wrapup_global_declaration_1 (decl);
7860     }
7861
7862   do
7863     {
7864       reconsider = false;
7865       for (decl = globals; decl; decl = TREE_CHAIN (decl))
7866         reconsider |= wrapup_global_declaration_2 (decl);
7867     }
7868   while (reconsider);
7869
7870   for (decl = globals; decl; decl = TREE_CHAIN (decl))
7871     check_global_declaration_1 (decl);
7872 }
7873
7874 /* A subroutine of c_write_global_declarations Emit debug information for each
7875    of the declarations in GLOBALS.  */
7876
7877 static void
7878 c_write_global_declarations_2 (tree globals)
7879 {
7880   tree decl;
7881
7882   for (decl = globals; decl ; decl = TREE_CHAIN (decl))
7883     debug_hooks->global_decl (decl);
7884 }
7885
7886 /* Preserve the external declarations scope across a garbage collect.  */
7887 static GTY(()) tree ext_block;
7888
7889 void
7890 c_write_global_declarations (void)
7891 {
7892   tree t;
7893
7894   /* We don't want to do this if generating a PCH.  */
7895   if (pch_file)
7896     return;
7897
7898   /* Don't waste time on further processing if -fsyntax-only or we've
7899      encountered errors.  */
7900   if (flag_syntax_only || errorcount || sorrycount || cpp_errors (parse_in))
7901     return;
7902
7903   /* Close the external scope.  */
7904   ext_block = pop_scope ();
7905   external_scope = 0;
7906   gcc_assert (!current_scope);
7907
7908   if (ext_block)
7909     {
7910       tree tmp = BLOCK_VARS (ext_block);
7911       int flags;
7912       FILE * stream = dump_begin (TDI_tu, &flags);
7913       if (stream && tmp)
7914         {
7915           dump_node (tmp, flags & ~TDF_SLIM, stream);
7916           dump_end (TDI_tu, stream);
7917         }
7918     }
7919
7920   /* Process all file scopes in this compilation, and the external_scope,
7921      through wrapup_global_declarations and check_global_declarations.  */
7922   for (t = all_translation_units; t; t = TREE_CHAIN (t))
7923     c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
7924   c_write_global_declarations_1 (BLOCK_VARS (ext_block));
7925
7926   /* Call functions declared with the "constructor" or "destructor"
7927      attribute.  */
7928   c_build_cdtor_fns ();
7929
7930   /* We're done parsing; proceed to optimize and emit assembly.
7931      FIXME: shouldn't be the front end's responsibility to call this.  */
7932   cgraph_optimize ();
7933
7934   /* After cgraph has had a chance to emit everything that's going to
7935      be emitted, output debug information for globals.  */
7936   if (errorcount == 0 && sorrycount == 0)
7937     {
7938       timevar_push (TV_SYMOUT);
7939       for (t = all_translation_units; t; t = TREE_CHAIN (t))
7940         c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
7941       c_write_global_declarations_2 (BLOCK_VARS (ext_block));
7942       timevar_pop (TV_SYMOUT);
7943     }
7944
7945   ext_block = NULL;
7946 }
7947
7948 #include "gt-c-decl.h"