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 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /* Process declarations and symbol lookup for C front end.
  23    Also constructs types; the standard scalar types at initialization,
  24    and structure, union, array and enum types when they are declared.  */
  25
  26 /* ??? not all decl nodes are given the most useful possible
  27    line numbers.  For example, the CONST_DECLs for enum values.  */
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include "intl.h"
  34 #include "tree.h"
  35 #include "tree-inline.h"
  36 #include "rtl.h"
  37 #include "flags.h"
  38 #include "function.h"
  39 #include "output.h"
  40 #include "expr.h"
  41 #include "c-tree.h"
  42 #include "toplev.h"
  43 #include "ggc.h"
  44 #include "tm_p.h"
  45 #include "cpplib.h"
  46 #include "target.h"
  47 #include "debug.h"
  48 #include "timevar.h"
  49 #include "c-common.h"
  50 #include "c-pragma.h"
  51 #include "cgraph.h"
  52 #include "hashtab.h"
  53 #include "libfuncs.h"
  54 #include "except.h"
  55 #include "langhooks-def.h"
  56
  57 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
  58 enum decl_context
  59 { NORMAL,                       /* Ordinary declaration */
  60   FUNCDEF,                      /* Function definition */
  61   PARM,                         /* Declaration of parm before function body */
  62   FIELD,                        /* Declaration inside struct or union */
  63   BITFIELD,                     /* Likewise but with specified width */
  64   TYPENAME};                    /* Typename (inside cast or sizeof)  */
  65
  66 \f
  67 /* Nonzero if we have seen an invalid cross reference
  68    to a struct, union, or enum, but not yet printed the message.  */
  69
  70 tree pending_invalid_xref;
  71 /* File and line to appear in the eventual error message.  */
  72 location_t pending_invalid_xref_location;
  73
  74 /* While defining an enum type, this is 1 plus the last enumerator
  75    constant value.  Note that will do not have to save this or `enum_overflow'
  76    around nested function definition since such a definition could only
  77    occur in an enum value expression and we don't use these variables in
  78    that case.  */
  79
  80 static tree enum_next_value;
  81
  82 /* Nonzero means that there was overflow computing enum_next_value.  */
  83
  84 static int enum_overflow;
  85
  86 /* Parsing a function declarator leaves a list of parameter names
  87    or a chain of parameter decls here.  */
  88
  89 static tree last_function_parms;
  90
  91 /* Parsing a function declarator leaves a chain of structure
  92    and enum types declared in the parmlist here.  */
  93
  94 static tree last_function_parm_tags;
  95
  96 /* After parsing the declarator that starts a function definition,
  97    `start_function' puts the list of parameter names or chain of decls here
  98    for `store_parm_decls' to find.  */
  99
 100 static tree current_function_parms;
 101
 102 /* Similar, for last_function_parm_tags.  */
 103
 104 static tree current_function_parm_tags;
 105
 106 /* Similar, for the file and line that the prototype came from if this is
 107    an old-style definition.  */
 108
 109 static location_t current_function_prototype_locus;
 110
 111 /* The current statement tree.  */
 112
 113 static GTY(()) struct stmt_tree_s c_stmt_tree;
 114
 115 /* The current scope statement stack.  */
 116
 117 static GTY(()) tree c_scope_stmt_stack;
 118
 119 /* A list of external DECLs that appeared at block scope when there was
 120    some other global meaning for that identifier.  */
 121 static GTY(()) tree truly_local_externals;
 122
 123 /* A list of the builtin file-scope DECLs.  */
 124
 125 static GTY(()) tree builtin_decls;
 126
 127 /* A DECL for the current file-scope context.  */
 128
 129 static GTY(()) tree current_file_decl;
 130
 131 /* Set to 0 at beginning of a function definition, set to 1 if
 132    a return statement that specifies a return value is seen.  */
 133
 134 int current_function_returns_value;
 135
 136 /* Set to 0 at beginning of a function definition, set to 1 if
 137    a return statement with no argument is seen.  */
 138
 139 int current_function_returns_null;
 140
 141 /* Set to 0 at beginning of a function definition, set to 1 if
 142    a call to a noreturn function is seen.  */
 143
 144 int current_function_returns_abnormally;
 145
 146 /* Set to nonzero by `grokdeclarator' for a function
 147    whose return type is defaulted, if warnings for this are desired.  */
 148
 149 static int warn_about_return_type;
 150
 151 /* Nonzero when starting a function declared `extern inline'.  */
 152
 153 static int current_extern_inline;
 154 \f
 155 /* For each binding contour we allocate a c_scope structure
 156  * which records the names defined in that contour.
 157  * Contours include:
 158  *  0) the global one
 159  *  1) one for each function definition,
 160  *     where internal declarations of the parameters appear.
 161  *  2) one for each compound statement,
 162  *     to record its declarations.
 163  *
 164  * The current meaning of a name can be found by searching the nested
 165  * scopes from the current one out to the global one.
 166  */
 167
 168 struct c_scope GTY(())
 169   {
 170     /* A chain of _DECL nodes for all variables, constants, functions,
 171        and typedef types.  These are in the reverse of the order supplied.
 172      */
 173     tree names;
 174
 175     /* A list of structure, union and enum definitions,
 176      * for looking up tag names.
 177      * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 178      * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 179      * or ENUMERAL_TYPE node.
 180      */
 181     tree tags;
 182
 183     /* For each scope, a list of shadowed outer-scope definitions
 184        to be restored when this scope is popped.
 185        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 186        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
 187     tree shadowed;
 188
 189     /* For each scope, a list of shadowed outer-scope tag definitions
 190        to be restored when this scope is popped.
 191        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 192        whose TREE_VALUE is its old definition (a kind of ..._TYPE node).  */
 193     tree shadowed_tags;
 194
 195     /* For each scope (except not the global one),
 196        a chain of BLOCK nodes for all the scopes
 197        that were entered and exited one level down.  */
 198     tree blocks;
 199
 200     /* The scope containing this one.  */
 201     struct c_scope *outer;
 202
 203     /* The next outermost function scope.  */
 204     struct c_scope *outer_function;
 205
 206     /* True if we are currently filling this scope with parameter
 207        declarations.  */
 208     bool parm_flag : 1;
 209
 210     /* True if this is the outermost block scope of a function body.
 211        This scope contains both the parameters and the local variables
 212        declared in the outermost block.  */
 213     bool function_body : 1;
 214
 215     /* True means make a BLOCK for this scope regardless of all else.  */
 216     bool keep : 1;
 217
 218     /* True means make a BLOCK if this scope has any subblocks.  */
 219     bool keep_if_subblocks : 1;
 220
 221     /* List of decls in `names' that have incomplete structure or
 222        union types.  */
 223     tree incomplete_list;
 224
 225     /* A list of decls giving the (reversed) specified order of parms,
 226        not including any forward-decls in the parmlist.
 227        This is so we can put the parms in proper order for assign_parms.  */
 228     tree parm_order;
 229   };
 230
 231 /* The scope currently in effect.  */
 232
 233 static GTY(()) struct c_scope *current_scope;
 234
 235 /* A chain of c_scope structures awaiting reuse.  */
 236
 237 static GTY((deletable (""))) struct c_scope *scope_freelist;
 238
 239 /* The innermost function scope.  Ordinary (not explicitly declared)
 240    labels, bindings to error_mark_node, and the lazily-created
 241    bindings of __func__ and its friends get this scope.  */
 242 static GTY(()) struct c_scope *current_function_scope;
 243
 244 /* The outermost scope, corresponding to the C "file scope".  This is
 245    created when the compiler is started and exists through the entire run.  */
 246
 247 static GTY(()) struct c_scope *global_scope;
 248
 249 /* True means unconditionally make a BLOCK for the next scope pushed.  */
 250
 251 static bool keep_next_level_flag;
 252
 253 /* True means make a BLOCK for the next scope pushed if it has subblocks.  */
 254
 255 static bool keep_next_if_subblocks;
 256
 257 /* Functions called automatically at the beginning and end of execution.  */
 258
 259 tree static_ctors, static_dtors;
 260
 261 /* Forward declarations.  */
 262
 263 static struct c_scope *make_scope (void);
 264 static void pop_scope (void);
 265 static tree match_builtin_function_types (tree, tree);
 266 static int duplicate_decls (tree, tree, int, int);
 267 static int redeclaration_error_message (tree, tree);
 268 static tree make_label (tree, location_t);
 269 static void bind_label (tree, tree, struct c_scope *);
 270 static void implicit_decl_warning (tree);
 271 static void storedecls (tree);
 272 static void storetags (tree);
 273 static tree lookup_tag (enum tree_code, tree, int);
 274 static tree lookup_name_current_level (tree);
 275 static tree grokdeclarator (tree, tree, enum decl_context, int);
 276 static tree grokparms (tree, int);
 277 static void layout_array_type (tree);
 278 static tree c_make_fname_decl (tree, int);
 279 static void c_expand_body_1 (tree, int);
 280 static tree any_external_decl (tree);
 281 static void record_external_decl (tree);
 282 static void warn_if_shadowing (tree, tree);
 283 static void clone_underlying_type (tree);
 284 static void pushdecl_function_level (tree, tree);
 285 static bool flexible_array_type_p (tree);
 286 static hashval_t link_hash_hash (const void *);
 287 static int link_hash_eq (const void *, const void *);
 288 \f
 289 /* States indicating how grokdeclarator() should handle declspecs marked
 290    with __attribute__((deprecated)).  An object declared as
 291    __attribute__((deprecated)) suppresses warnings of uses of other
 292    deprecated items.  */
 293
 294 enum deprecated_states {
 295   DEPRECATED_NORMAL,
 296   DEPRECATED_SUPPRESS
 297 };
 298
 299 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 300
 301 void
 302 c_print_identifier (FILE *file, tree node, int indent)
 303 {
 304   print_node (file, "symbol", IDENTIFIER_SYMBOL_VALUE (node), indent + 4);
 305   print_node (file, "tag", IDENTIFIER_TAG_VALUE (node), indent + 4);
 306   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
 307   if (C_IS_RESERVED_WORD (node))
 308     {
 309       tree rid = ridpointers[C_RID_CODE (node)];
 310       indent_to (file, indent + 4);
 311       fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
 312                (void *) rid, IDENTIFIER_POINTER (rid));
 313     }
 314 }
 315 \f
 316 /* Hook called at end of compilation to assume 1 elt
 317    for a file-scope tentative array defn that wasn't complete before.  */
 318
 319 void
 320 c_finish_incomplete_decl (tree decl)
 321 {
 322   if (TREE_CODE (decl) == VAR_DECL)
 323     {
 324       tree type = TREE_TYPE (decl);
 325       if (type != error_mark_node
 326           && TREE_CODE (type) == ARRAY_TYPE
 327           && ! DECL_EXTERNAL (decl)
 328           && TYPE_DOMAIN (type) == 0)
 329         {
 330           warning ("%Harray '%D' assumed to have one element",
 331                    &DECL_SOURCE_LOCATION (decl), decl);
 332
 333           complete_array_type (type, NULL_TREE, 1);
 334
 335           layout_decl (decl, 0);
 336         }
 337     }
 338 }
 339 \f
 340 /* Reuse or create a struct for this scope.  */
 341
 342 static struct c_scope *
 343 make_scope (void)
 344 {
 345   struct c_scope *result;
 346   if (scope_freelist)
 347     {
 348       result = scope_freelist;
 349       scope_freelist = result->outer;
 350     }
 351   else
 352     result = ggc_alloc_cleared (sizeof (struct c_scope));
 353
 354   return result;
 355 }
 356
 357 /* Remove the topmost scope from the stack and add it to the
 358    free list, updating current_function_scope if necessary.  */
 359
 360 static void
 361 pop_scope (void)
 362 {
 363   struct c_scope *scope = current_scope;
 364
 365   current_scope = scope->outer;
 366   if (scope->function_body)
 367     current_function_scope = scope->outer_function;
 368
 369   memset (scope, 0, sizeof (struct c_scope));
 370   scope->outer = scope_freelist;
 371   scope_freelist = scope;
 372 }
 373
 374 /* Nonzero if we are currently in the global scope.  */
 375
 376 int
 377 global_bindings_p (void)
 378 {
 379   return current_scope == global_scope;
 380 }
 381
 382 void
 383 keep_next_level (void)
 384 {
 385   keep_next_level_flag = true;
 386 }
 387
 388 /* Identify this scope as currently being filled with parameters.  */
 389
 390 void
 391 declare_parm_level (void)
 392 {
 393   current_scope->parm_flag = true;
 394 }
 395
 396 /* Nonzero if currently making parm declarations.  */
 397
 398 int
 399 in_parm_level_p (void)
 400 {
 401   return current_scope->parm_flag;
 402 }
 403
 404 /* Enter a new scope.  */
 405
 406 void
 407 pushlevel (int dummy ATTRIBUTE_UNUSED)
 408 {
 409   if (keep_next_if_subblocks)
 410     {
 411       /* This is the transition from the parameters to the top level
 412          of the function body.  These are the same scope
 413          (C99 6.2.1p4,6) so we do not push another scope structure.
 414
 415          XXX Note kludge - keep_next_if_subblocks is set only by
 416          store_parm_decls, which in turn is called when and only
 417          when we are about to encounter the opening curly brace for
 418          the function body.  */
 419       current_scope->parm_flag         = false;
 420       current_scope->function_body     = true;
 421       current_scope->keep             |= keep_next_level_flag;
 422       current_scope->keep_if_subblocks = true;
 423       current_scope->outer_function    = current_function_scope;
 424       current_function_scope           = current_scope;
 425
 426       keep_next_level_flag = false;
 427       keep_next_if_subblocks = false;
 428     }
 429   else
 430     {
 431       struct c_scope *scope = make_scope ();
 432
 433       scope->keep          = keep_next_level_flag;
 434       scope->outer         = current_scope;
 435       current_scope        = scope;
 436       keep_next_level_flag = false;
 437     }
 438 }
 439
 440 /* Exit a scope.  Restore the state of the identifier-decl mappings
 441    that were in effect when this scope was entered.
 442
 443    If KEEP is KEEP_YES (1), this scope had explicit declarations, so
 444    create a BLOCK node to record its declarations and subblocks for
 445    debugging output.  If KEEP is KEEP_MAYBE, do so only if the names
 446    or tags lists are nonempty.
 447
 448    If FUNCTIONBODY is nonzero, this level is the body of a function,
 449    so create a block as if KEEP were set and also clear out all
 450    label names.
 451
 452    If REVERSE is nonzero, reverse the order of decls before putting
 453    them into the BLOCK.  */
 454
 455 tree
 456 poplevel (int keep, int reverse, int functionbody)
 457 {
 458   tree link;
 459   tree block;
 460   tree decl;
 461   tree decls = current_scope->names;
 462   tree tags = current_scope->tags;
 463   tree subblocks = current_scope->blocks;
 464
 465   functionbody |= current_scope->function_body;
 466
 467   if (keep == KEEP_MAYBE)
 468     keep = (current_scope->names || current_scope->tags);
 469
 470   keep |= (current_scope->keep || functionbody
 471            || (subblocks && current_scope->keep_if_subblocks));
 472
 473   /* We used to warn about unused variables in expand_end_bindings,
 474      i.e. while generating RTL.  But in function-at-a-time mode we may
 475      choose to never expand a function at all (e.g. auto inlining), so
 476      we do this explicitly now.
 477      No warnings when the global scope is popped because the global
 478      scope isn't popped for the last translation unit, so the warnings
 479      are done in c_write_global_declaration.  */
 480   if (current_scope != global_scope)
 481     warn_about_unused_variables (decls);
 482
 483   /* Clear out the name-meanings declared in this scope.
 484      Propagate TREE_ADDRESSABLE from nested functions to their
 485      containing functions.  */
 486   for (link = decls; link; link = TREE_CHAIN (link))
 487     {
 488       if (TREE_CODE (link) == LABEL_DECL)
 489         {
 490           if (TREE_USED (link) && DECL_INITIAL (link) == 0)
 491             {
 492               error ("%Hlabel `%D' used but not defined",
 493                      &DECL_SOURCE_LOCATION (link), link);
 494               /* Avoid crashing later.  */
 495               DECL_INITIAL (link) = error_mark_node;
 496             }
 497           else if (!TREE_USED (link) && warn_unused_label)
 498             {
 499               if (DECL_INITIAL (link) != 0)
 500                 warning ("%Hlabel `%D' defined but not used",
 501                          &DECL_SOURCE_LOCATION (link), link);
 502               else
 503                 warning ("%Hlabel `%D' declared but not defined",
 504                          &DECL_SOURCE_LOCATION (link), link);
 505             }
 506           IDENTIFIER_LABEL_VALUE (DECL_NAME (link)) = 0;
 507         }
 508       else if (DECL_NAME (link) != 0)
 509         {
 510           if (DECL_EXTERNAL (link)
 511               && current_scope != global_scope)
 512             /* External decls stay in the symbol-value slot but are
 513                inaccessible.  */
 514             C_DECL_INVISIBLE (link) = 1;
 515           else
 516             IDENTIFIER_SYMBOL_VALUE (DECL_NAME (link)) = 0;
 517         }
 518
 519       if (TREE_CODE (link) == FUNCTION_DECL
 520           && ! TREE_ASM_WRITTEN (link)
 521           && DECL_INITIAL (link) != 0
 522           && TREE_ADDRESSABLE (link)
 523           && DECL_ABSTRACT_ORIGIN (link) != 0
 524           && DECL_ABSTRACT_ORIGIN (link) != link)
 525         TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (link)) = 1;
 526     }
 527
 528   /* Clear out the tag-meanings declared in this scope.  */
 529   for (link = tags; link; link = TREE_CHAIN (link))
 530     if (TREE_PURPOSE (link))
 531       IDENTIFIER_TAG_VALUE (TREE_PURPOSE (link)) = 0;
 532
 533   /* Restore all name- and label-meanings from outer scopes that were
 534      shadowed by this scope.  */
 535
 536   for (link = current_scope->shadowed; link; link = TREE_CHAIN (link))
 537     if (TREE_VALUE (link) && TREE_CODE (TREE_VALUE (link)) == LABEL_DECL)
 538       IDENTIFIER_LABEL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
 539     else
 540       IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
 541
 542   /* Restore all tag-meanings from outer scopes that were shadowed by
 543      this scope.  */
 544
 545   for (link = current_scope->shadowed_tags; link;
 546        link = TREE_CHAIN (link))
 547     IDENTIFIER_TAG_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
 548
 549   /* If this is the outermost block of a function, remove all
 550      PARM_DECLs from current_scope->names; they are already
 551      stored in DECL_ARGUMENTS of cfun->decl in proper order, should
 552      not be put in BLOCK_VARS, and furthermore reversing them will
 553      cause trouble later.  They are all together at the end of the
 554      list.  */
 555   if (functionbody && decls)
 556     {
 557       if (TREE_CODE (decls) == PARM_DECL)
 558         decls = 0;
 559       else
 560         {
 561           link = decls;
 562           while (TREE_CHAIN (link)
 563                  && TREE_CODE (TREE_CHAIN (link)) != PARM_DECL)
 564             link = TREE_CHAIN (link);
 565
 566           TREE_CHAIN (link) = 0;
 567         }
 568     }
 569
 570   /* Get the decls in the order they were written.
 571      Usually current_scope->names is in reverse order.
 572      But parameter decls were previously put in forward order.  */
 573
 574   if (reverse)
 575     decls = nreverse (decls);
 576
 577   /* If appropriate, create a BLOCK to record the decls for the life
 578      of this function.  */
 579
 580   block = 0;
 581   if (keep)
 582     {
 583       block = make_node (BLOCK);
 584       BLOCK_VARS (block) = decls;
 585       BLOCK_SUBBLOCKS (block) = subblocks;
 586       TREE_USED (block) = 1;
 587     }
 588
 589   /* In each subblock, record that this is its superior.  */
 590
 591   for (link = subblocks; link; link = TREE_CHAIN (link))
 592     BLOCK_SUPERCONTEXT (link) = block;
 593
 594   /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
 595      binding contour so that they point to the appropriate construct, i.e.
 596      either to the current FUNCTION_DECL node, or else to the BLOCK node
 597      we just constructed.
 598
 599      Note that for tagged types whose scope is just the formal parameter
 600      list for some function type specification, we can't properly set
 601      their TYPE_CONTEXTs here, because we don't have a pointer to the
 602      appropriate FUNCTION_TYPE node readily available to us.  For those
 603      cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
 604      in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
 605      node which will represent the "scope" for these "parameter list local"
 606      tagged types.  */
 607
 608   decl = functionbody ? current_function_decl : block;
 609   if (decl)
 610     for (link = tags; link; link = TREE_CHAIN (link))
 611       TYPE_CONTEXT (TREE_VALUE (link)) = decl;
 612
 613   /* Pop the current scope, and free the structure for reuse.  */
 614   pop_scope ();
 615
 616   /* Dispose of the block that we just made inside some higher level.  */
 617   if (functionbody)
 618     DECL_INITIAL (current_function_decl) = block;
 619   else if (block && current_scope)
 620     current_scope->blocks
 621       = chainon (current_scope->blocks, block);
 622   /* If we did not make a block for the scope just exited, any blocks
 623      made for inner scopes (since they cannot be recorded as subblocks
 624      here) must be carried forward so they will later become subblocks
 625      of something else.  */
 626   else if (! block && subblocks)
 627     current_scope->blocks
 628       = chainon (current_scope->blocks, subblocks);
 629
 630   return block;
 631 }
 632
 633 /* Insert BLOCK at the end of the list of subblocks of the current
 634    scope.  This is used when a BIND_EXPR is expanded, to handle the
 635    BLOCK node inside the BIND_EXPR.  */
 636
 637 void
 638 insert_block (tree block)
 639 {
 640   TREE_USED (block) = 1;
 641   current_scope->blocks
 642     = chainon (current_scope->blocks, block);
 643 }
 644
 645 /* Set the BLOCK node for the innermost scope (the one we are
 646    currently in).  The RTL expansion machinery requires us to provide
 647    this hook, but it is not useful in function-at-a-time mode.  */
 648
 649 void
 650 set_block (tree block ATTRIBUTE_UNUSED)
 651 {
 652 }
 653 \f
 654 /* Push a definition or a declaration of struct, union or enum tag "name".
 655    "type" should be the type node.
 656    We assume that the tag "name" is not already defined.
 657
 658    Note that the definition may really be just a forward reference.
 659    In that case, the TYPE_SIZE will be zero.  */
 660
 661 void
 662 pushtag (tree name, tree type)
 663 {
 664   struct c_scope *b = current_scope;
 665
 666   if (name)
 667     {
 668       /* Record the identifier as the type's name if it has none.  */
 669
 670       if (TYPE_NAME (type) == 0)
 671         TYPE_NAME (type) = name;
 672
 673       if (IDENTIFIER_TAG_VALUE (name))
 674         b->shadowed_tags = tree_cons (name, IDENTIFIER_TAG_VALUE (name),
 675                                       b->shadowed_tags);
 676       IDENTIFIER_TAG_VALUE (name) = type;
 677     }
 678
 679   b->tags = tree_cons (name, type, b->tags);
 680
 681   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
 682      tagged type we just added to the current scope.  This fake
 683      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
 684      to output a representation of a tagged type, and it also gives
 685      us a convenient place to record the "scope start" address for the
 686      tagged type.  */
 687
 688   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
 689
 690   /* An approximation for now, so we can tell this is a function-scope tag.
 691      This will be updated in poplevel.  */
 692   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
 693 }
 694 \f
 695 /* Subroutine of duplicate_decls.  Allow harmless mismatches in return
 696    and argument types provided that the type modes match.  This function
 697    return a unified type given a suitable match, and 0 otherwise.  */
 698
 699 static tree
 700 match_builtin_function_types (tree oldtype, tree newtype)
 701 {
 702   tree newrettype, oldrettype;
 703   tree newargs, oldargs;
 704   tree trytype, tryargs;
 705
 706   /* Accept the return type of the new declaration if same modes.  */
 707   oldrettype = TREE_TYPE (oldtype);
 708   newrettype = TREE_TYPE (newtype);
 709
 710   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
 711     return 0;
 712
 713   oldargs = TYPE_ARG_TYPES (oldtype);
 714   newargs = TYPE_ARG_TYPES (newtype);
 715   tryargs = newargs;
 716
 717   while (oldargs || newargs)
 718     {
 719       if (! oldargs
 720           || ! newargs
 721           || ! TREE_VALUE (oldargs)
 722           || ! TREE_VALUE (newargs)
 723           || TYPE_MODE (TREE_VALUE (oldargs))
 724              != TYPE_MODE (TREE_VALUE (newargs)))
 725         return 0;
 726
 727       oldargs = TREE_CHAIN (oldargs);
 728       newargs = TREE_CHAIN (newargs);
 729     }
 730
 731   trytype = build_function_type (newrettype, tryargs);
 732   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
 733 }
 734
 735 /* Handle when a new declaration NEWDECL
 736    has the same name as an old one OLDDECL
 737    in the same binding contour.
 738    Prints an error message if appropriate.
 739
 740    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
 741    Otherwise, return 0.
 742
 743    When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
 744    and OLDDECL is in an outer scope and should thus not be changed.  */
 745
 746 static int
 747 duplicate_decls (tree newdecl, tree olddecl, int different_binding_level,
 748                  int different_tu)
 749 {
 750   int comptype_flags = (different_tu ? COMPARE_DIFFERENT_TU
 751                         : COMPARE_STRICT);
 752   int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl),
 753                                comptype_flags);
 754   int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
 755                            && DECL_INITIAL (newdecl) != 0);
 756   tree oldtype = TREE_TYPE (olddecl);
 757   tree newtype = TREE_TYPE (newdecl);
 758   int errmsg = 0;
 759
 760   if (DECL_P (olddecl))
 761     {
 762       if (TREE_CODE (newdecl) == FUNCTION_DECL
 763           && TREE_CODE (olddecl) == FUNCTION_DECL
 764           && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
 765         {
 766           if (DECL_DECLARED_INLINE_P (newdecl)
 767               && DECL_UNINLINABLE (newdecl)
 768               && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
 769             /* Already warned elsewhere.  */;
 770           else if (DECL_DECLARED_INLINE_P (olddecl)
 771                    && DECL_UNINLINABLE (olddecl)
 772                    && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
 773             /* Already warned.  */;
 774           else if (DECL_DECLARED_INLINE_P (newdecl)
 775                    && ! DECL_DECLARED_INLINE_P (olddecl)
 776                    && DECL_UNINLINABLE (olddecl)
 777                    && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
 778             {
 779               warning ("%Hfunction '%D' redeclared as inline",
 780                        &DECL_SOURCE_LOCATION (newdecl), newdecl);
 781               warning ("%Hprevious declaration of function '%D' "
 782                        "with attribute noinline",
 783                        &DECL_SOURCE_LOCATION (olddecl), olddecl);
 784             }
 785           else if (DECL_DECLARED_INLINE_P (olddecl)
 786                    && DECL_UNINLINABLE (newdecl)
 787                    && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
 788             {
 789               warning ("%Hfunction '%D' redeclared with attribute noinline",
 790                        &DECL_SOURCE_LOCATION (newdecl), newdecl);
 791               warning ("%Hprevious declaration of function '%D' was inline",
 792                        &DECL_SOURCE_LOCATION (olddecl), olddecl);
 793             }
 794         }
 795
 796       DECL_ATTRIBUTES (newdecl)
 797         = (*targetm.merge_decl_attributes) (olddecl, newdecl);
 798     }
 799
 800   if (TREE_CODE (newtype) == ERROR_MARK
 801       || TREE_CODE (oldtype) == ERROR_MARK)
 802     types_match = 0;
 803
 804   /* New decl is completely inconsistent with the old one =>
 805      tell caller to replace the old one.
 806      This is always an error except in the case of shadowing a builtin.  */
 807   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
 808     {
 809       if (TREE_CODE (olddecl) == FUNCTION_DECL
 810           && DECL_BUILT_IN (olddecl))
 811         {
 812           /* If you declare a built-in or predefined function name as static,
 813              the old definition is overridden,
 814              but optionally warn this was a bad choice of name.  */
 815           if (!TREE_PUBLIC (newdecl))
 816             {
 817               if (warn_shadow)
 818                 warning ("%Hshadowing built-in function '%D'",
 819                          &DECL_SOURCE_LOCATION (newdecl), newdecl);
 820             }
 821           else
 822             warning ("%Hbuilt-in function '%D' declared as non-function",
 823                      &DECL_SOURCE_LOCATION (newdecl), newdecl);
 824         }
 825       else
 826         {
 827           error ("%H'%D' redeclared as different kind of symbol",
 828                  &DECL_SOURCE_LOCATION (newdecl), newdecl);
 829           error ("%Hprevious declaration of '%D'",
 830                  &DECL_SOURCE_LOCATION (olddecl), olddecl);
 831         }
 832
 833       return 0;
 834     }
 835
 836   /* For real parm decl following a forward decl, return 1 so old decl
 837      will be reused.  Only allow this to happen once.  */
 838   if (types_match && TREE_CODE (newdecl) == PARM_DECL
 839       && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
 840     {
 841       TREE_ASM_WRITTEN (olddecl) = 0;
 842       return 1;
 843     }
 844
 845   /* The new declaration is the same kind of object as the old one.
 846      The declarations may partially match.  Print warnings if they don't
 847      match enough.  Ultimately, copy most of the information from the new
 848      decl to the old one, and keep using the old one.  */
 849
 850   if (TREE_CODE (olddecl) == FUNCTION_DECL && DECL_BUILT_IN (olddecl))
 851     {
 852       /* A function declaration for a built-in function.  */
 853       if (!TREE_PUBLIC (newdecl))
 854         {
 855           /* If you declare a built-in function name as static, the
 856              built-in definition is overridden,
 857              but optionally warn this was a bad choice of name.  */
 858           if (warn_shadow)
 859             warning ("%Hshadowing built-in function '%D'",
 860                      &DECL_SOURCE_LOCATION (newdecl), newdecl);
 861           /* Discard the old built-in function.  */
 862           return 0;
 863         }
 864       else if (!types_match)
 865         {
 866           /* Accept harmless mismatch in function types.
 867              This is for the ffs and fprintf builtins.  */
 868           tree trytype = match_builtin_function_types (oldtype, newtype);
 869
 870           if (trytype)
 871             {
 872               types_match = comptypes (newtype, trytype, comptype_flags);
 873               if (types_match)
 874                 oldtype = trytype;
 875               if (! different_binding_level)
 876                 TREE_TYPE (olddecl) = oldtype;
 877             }
 878         }
 879       else if (TYPE_ARG_TYPES (oldtype) == NULL
 880                && TYPE_ARG_TYPES (newtype) != NULL)
 881         {
 882           /* For bcmp, bzero, fputs the builtin type has arguments not
 883              specified.  Use the ones from the prototype so that type checking
 884              is done for them.  */
 885           tree trytype
 886             = build_function_type (TREE_TYPE (oldtype),
 887                                    TYPE_ARG_TYPES (newtype));
 888           trytype = build_type_attribute_variant (trytype,
 889                                                   TYPE_ATTRIBUTES (oldtype));
 890
 891           oldtype = trytype;
 892           if (! different_binding_level)
 893             TREE_TYPE (olddecl) = oldtype;
 894         }
 895       if (!types_match)
 896         {
 897           /* If types don't match for a built-in, throw away the built-in.  */
 898           warning ("%Hconflicting types for built-in function '%D'",
 899                    &DECL_SOURCE_LOCATION (newdecl), newdecl);
 900           return 0;
 901         }
 902     }
 903   else if (TREE_CODE (olddecl) == FUNCTION_DECL
 904            && DECL_SOURCE_LINE (olddecl) == 0)
 905     {
 906       /* A function declaration for a predeclared function
 907          that isn't actually built in.  */
 908       if (!TREE_PUBLIC (newdecl))
 909         {
 910           /* If you declare it as static, the
 911              default definition is overridden.  */
 912           return 0;
 913         }
 914       else if (!types_match)
 915         {
 916           /* If the types don't match, preserve volatility indication.
 917              Later on, we will discard everything else about the
 918              default declaration.  */
 919           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
 920         }
 921     }
 922   /* Permit char *foo () to match void *foo (...) if not pedantic,
 923      if one of them came from a system header file.  */
 924   else if (!types_match
 925            && TREE_CODE (olddecl) == FUNCTION_DECL
 926            && TREE_CODE (newdecl) == FUNCTION_DECL
 927            && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
 928            && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
 929            && (DECL_IN_SYSTEM_HEADER (olddecl)
 930                || DECL_IN_SYSTEM_HEADER (newdecl))
 931            && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
 932                 && TYPE_ARG_TYPES (oldtype) == 0
 933                 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
 934                 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
 935                ||
 936                (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
 937                 && TYPE_ARG_TYPES (newtype) == 0
 938                 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
 939                 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
 940     {
 941       if (pedantic)
 942         pedwarn ("%Hconflicting types for '%D'",
 943                  &DECL_SOURCE_LOCATION (newdecl), newdecl);
 944       /* Make sure we keep void * as ret type, not char *.  */
 945       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
 946         TREE_TYPE (newdecl) = newtype = oldtype;
 947
 948       /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
 949          we will come back here again.  */
 950       DECL_IN_SYSTEM_HEADER (newdecl) = 1;
 951     }
 952   /* Permit void foo (...) to match int foo (...) if the latter is the
 953      definition and implicit int was used.  See c-torture/compile/920625-2.c.  */
 954   else if (!types_match && new_is_definition
 955            && TREE_CODE (olddecl) == FUNCTION_DECL
 956            && TREE_CODE (newdecl) == FUNCTION_DECL
 957            && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
 958            && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
 959            && C_FUNCTION_IMPLICIT_INT (newdecl))
 960     {
 961       pedwarn ("%Hconflicting types for '%D'",
 962                &DECL_SOURCE_LOCATION (newdecl), newdecl);
 963       /* Make sure we keep void as the return type.  */
 964       TREE_TYPE (newdecl) = newtype = oldtype;
 965       C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
 966     }
 967   else if (!types_match
 968            /* Permit char *foo (int, ...); followed by char *foo ();
 969               if not pedantic.  */
 970            && ! (TREE_CODE (olddecl) == FUNCTION_DECL
 971                  && ! pedantic
 972                  /* Return types must still match.  */
 973                  && comptypes (TREE_TYPE (oldtype),
 974                                TREE_TYPE (newtype), comptype_flags)
 975                  && TYPE_ARG_TYPES (newtype) == 0))
 976     {
 977       error ("%Hconflicting types for '%D'",
 978              &DECL_SOURCE_LOCATION (newdecl), newdecl);
 979       /* Check for function type mismatch
 980          involving an empty arglist vs a nonempty one.  */
 981       if (TREE_CODE (olddecl) == FUNCTION_DECL
 982           && comptypes (TREE_TYPE (oldtype),
 983                         TREE_TYPE (newtype), comptype_flags)
 984           && ((TYPE_ARG_TYPES (oldtype) == 0
 985                && DECL_INITIAL (olddecl) == 0)
 986               ||
 987               (TYPE_ARG_TYPES (newtype) == 0
 988                && DECL_INITIAL (newdecl) == 0)))
 989         {
 990           /* Classify the problem further.  */
 991           tree t = TYPE_ARG_TYPES (oldtype);
 992           if (t == 0)
 993             t = TYPE_ARG_TYPES (newtype);
 994           for (; t; t = TREE_CHAIN (t))
 995             {
 996               tree type = TREE_VALUE (t);
 997
 998               if (TREE_CHAIN (t) == 0
 999                   && TYPE_MAIN_VARIANT (type) != void_type_node)
1000                 {
1001                   error ("a parameter list with an ellipsis can't match an empty parameter name list declaration");
1002                   break;
1003                 }
1004
1005               if (c_type_promotes_to (type) != type)
1006                 {
1007                   error ("an argument type that has a default promotion can't match an empty parameter name list declaration");
1008                   break;
1009                 }
1010             }
1011         }
1012       if (C_DECL_IMPLICIT (olddecl))
1013         error ("%Hprevious implicit declaration of '%D'",
1014                &DECL_SOURCE_LOCATION (olddecl), olddecl);
1015       else
1016         error ("%Hprevious declaration of '%D'",
1017                &DECL_SOURCE_LOCATION (olddecl), olddecl);
1018
1019       /* This is safer because the initializer might contain references
1020          to variables that were declared between olddecl and newdecl. This
1021          will make the initializer invalid for olddecl in case it gets
1022          assigned to olddecl below.  */
1023       if (TREE_CODE (newdecl) == VAR_DECL)
1024         DECL_INITIAL (newdecl) = 0;
1025     }
1026   /* TLS cannot follow non-TLS declaration.  */
1027   else if (TREE_CODE (olddecl) == VAR_DECL && TREE_CODE (newdecl) == VAR_DECL
1028            && !DECL_THREAD_LOCAL (olddecl) && DECL_THREAD_LOCAL (newdecl))
1029     {
1030       error ("%Hthread-local declaration of '%D' follows non thread-local "
1031              "declaration", &DECL_SOURCE_LOCATION (newdecl), newdecl);
1032       error ("%Hprevious declaration of '%D'",
1033              &DECL_SOURCE_LOCATION (olddecl), olddecl);
1034     }
1035   /* non-TLS declaration cannot follow TLS declaration.  */
1036   else if (TREE_CODE (olddecl) == VAR_DECL && TREE_CODE (newdecl) == VAR_DECL
1037            && DECL_THREAD_LOCAL (olddecl) && !DECL_THREAD_LOCAL (newdecl))
1038     {
1039       error ("%Hnon thread-local declaration of '%D' follows "
1040              "thread-local declaration",
1041              &DECL_SOURCE_LOCATION (newdecl), newdecl);
1042       error ("%Hprevious declaration of '%D'",
1043              &DECL_SOURCE_LOCATION (olddecl), olddecl);
1044     }
1045   else
1046     {
1047       errmsg = redeclaration_error_message (newdecl, olddecl);
1048       if (errmsg)
1049         {
1050           const location_t *locus = &DECL_SOURCE_LOCATION (newdecl);
1051           switch (errmsg)
1052             {
1053             case 1:
1054               error ("%Hredefinition of '%D'", locus, newdecl);
1055               break;
1056             case 2:
1057               error ("%Hredeclaration of '%D'", locus, newdecl);
1058               break;
1059             case 3:
1060               error ("%Hconflicting declarations of '%D'", locus, newdecl);
1061               break;
1062             default:
1063               abort ();
1064             }
1065
1066           locus = &DECL_SOURCE_LOCATION (olddecl);
1067           if (DECL_INITIAL (olddecl)
1068               && current_scope == global_scope)
1069             error ("%H'%D' previously defined here", locus, olddecl);
1070           else
1071             error ("%H'%D' previously declared here", locus, olddecl);
1072           return 0;
1073         }
1074       else if (TREE_CODE (newdecl) == TYPE_DECL
1075                && (DECL_IN_SYSTEM_HEADER (olddecl)
1076                    || DECL_IN_SYSTEM_HEADER (newdecl)))
1077         {
1078           const location_t *locus = &DECL_SOURCE_LOCATION (newdecl);
1079           warning ("%Hredefinition of '%D'", locus, newdecl);
1080           locus = &DECL_SOURCE_LOCATION (olddecl);
1081           if (DECL_INITIAL (olddecl)
1082               && current_scope == global_scope)
1083             warning ("%H'%D' previously defined here", locus, olddecl);
1084           else
1085             warning ("%H'%D' previously declared here", locus, olddecl);
1086         }
1087       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1088                && DECL_INITIAL (olddecl) != 0
1089                && TYPE_ARG_TYPES (oldtype) == 0
1090                && TYPE_ARG_TYPES (newtype) != 0
1091                && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1092         {
1093           tree type, parm;
1094           int nargs;
1095           /* Prototype decl follows defn w/o prototype.  */
1096
1097           for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1098                type = TYPE_ARG_TYPES (newtype),
1099                nargs = 1;
1100                ;
1101                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1102             {
1103               if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1104                   && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1105                 {
1106                   const location_t *locus = &DECL_SOURCE_LOCATION (newdecl);
1107                   warning ("%Hprototype for '%D' follows", locus, newdecl);
1108                   locus = &DECL_SOURCE_LOCATION (olddecl);
1109                   warning ("%Hnon-prototype definition here", locus);
1110                   break;
1111                 }
1112               if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1113                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1114                 {
1115                   const location_t *locus = &DECL_SOURCE_LOCATION (newdecl);
1116                   error ("%Hprototype for '%D' follows and number of "
1117                          "arguments doesn't match", locus, newdecl);
1118                   locus = &DECL_SOURCE_LOCATION (olddecl);
1119                   error ("%Hnon-prototype definition here", locus);
1120                   errmsg = 1;
1121                   break;
1122                 }
1123               /* Type for passing arg must be consistent
1124                  with that declared for the arg.  */
1125               if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type),
1126                                comptype_flags))
1127                 {
1128                   const location_t *locus = &DECL_SOURCE_LOCATION (newdecl);
1129                   error ("%Hprototype for '%D' follows and argument %d "
1130                          "doesn't match", locus, newdecl, nargs);
1131                   locus = &DECL_SOURCE_LOCATION (olddecl);
1132                   error ("%Hnon-prototype definition here", locus);
1133                   errmsg = 1;
1134                   break;
1135                 }
1136             }
1137         }
1138       /* Warn about mismatches in various flags.  */
1139       else
1140         {
1141           /* Warn if function is now inline
1142              but was previously declared not inline and has been called.  */
1143           if (TREE_CODE (olddecl) == FUNCTION_DECL
1144               && ! DECL_DECLARED_INLINE_P (olddecl)
1145               && DECL_DECLARED_INLINE_P (newdecl)
1146               && TREE_USED (olddecl))
1147             warning ("%H'%D' declared inline after being called",
1148                      &DECL_SOURCE_LOCATION (newdecl), newdecl);
1149           if (TREE_CODE (olddecl) == FUNCTION_DECL
1150               && ! DECL_DECLARED_INLINE_P (olddecl)
1151               && DECL_DECLARED_INLINE_P (newdecl)
1152               && DECL_INITIAL (olddecl) != 0)
1153             warning ("%H'%D' declared inline after its definition",
1154                      &DECL_SOURCE_LOCATION (newdecl), newdecl);
1155
1156           /* If pedantic, warn when static declaration follows a non-static
1157              declaration.  Otherwise, do so only for functions.  */
1158           if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1159               && TREE_PUBLIC (olddecl)
1160               && !TREE_PUBLIC (newdecl))
1161             warning ("%Hstatic declaration for '%D' follows non-static",
1162                      &DECL_SOURCE_LOCATION (newdecl), newdecl);
1163
1164           /* If warn_traditional, warn when a non-static function
1165              declaration follows a static one.  */
1166           if (warn_traditional && !in_system_header
1167               && TREE_CODE (olddecl) == FUNCTION_DECL
1168               && !TREE_PUBLIC (olddecl)
1169               && TREE_PUBLIC (newdecl))
1170             warning ("%Hnon-static declaration for '%D' follows static",
1171                      &DECL_SOURCE_LOCATION (newdecl), newdecl);
1172
1173           /* Warn when const declaration follows a non-const
1174              declaration, but not for functions.  */
1175           if (TREE_CODE (olddecl) != FUNCTION_DECL
1176               && !TREE_READONLY (olddecl)
1177               && TREE_READONLY (newdecl))
1178             warning ("%Hconst declaration for '%D' follows non-const",
1179                      &DECL_SOURCE_LOCATION (newdecl), newdecl);
1180           /* These bits are logically part of the type, for variables.
1181              But not for functions
1182              (where qualifiers are not valid ANSI anyway).  */
1183           else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1184               && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1185                   || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1186             pedwarn ("%Htype qualifiers for '%D' conflict with previous "
1187                      "declaration", &DECL_SOURCE_LOCATION (newdecl), newdecl);
1188         }
1189     }
1190
1191   /* Optionally warn about more than one declaration for the same name.  */
1192   if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1193       /* Don't warn about a function declaration
1194          followed by a definition.  */
1195       && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1196            && DECL_INITIAL (olddecl) == 0)
1197       /* Don't warn about extern decl followed by (tentative) definition.  */
1198       && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1199     {
1200       warning ("%Hredundant redeclaration of '%D' in same scope",
1201                &DECL_SOURCE_LOCATION (newdecl), newdecl);
1202       warning ("%Hprevious declaration of '%D'",
1203                &DECL_SOURCE_LOCATION (olddecl), olddecl);
1204     }
1205
1206   /* Copy all the DECL_... slots specified in the new decl
1207      except for any that we copy here from the old type.
1208
1209      Past this point, we don't change OLDTYPE and NEWTYPE
1210      even if we change the types of NEWDECL and OLDDECL.  */
1211
1212   if (types_match)
1213     {
1214       /* When copying info to olddecl, we store into write_olddecl
1215          instead.  This allows us to avoid modifying olddecl when
1216          different_binding_level is true.  */
1217       tree write_olddecl = different_binding_level ? newdecl : olddecl;
1218
1219       /* Merge the data types specified in the two decls.  */
1220       if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1221         {
1222           if (different_binding_level)
1223             {
1224               if (TYPE_ARG_TYPES (oldtype) != 0
1225                   && TYPE_ARG_TYPES (newtype) == 0)
1226                 TREE_TYPE (newdecl) = common_type (newtype, oldtype);
1227               else
1228                 TREE_TYPE (newdecl)
1229                   = build_type_attribute_variant
1230                     (newtype,
1231                      merge_attributes (TYPE_ATTRIBUTES (newtype),
1232                                        TYPE_ATTRIBUTES (oldtype)));
1233             }
1234           else
1235             TREE_TYPE (newdecl)
1236               = TREE_TYPE (olddecl)
1237                 = common_type (newtype, oldtype);
1238         }
1239
1240       /* Lay the type out, unless already done.  */
1241       if (oldtype != TREE_TYPE (newdecl))
1242         {
1243           if (TREE_TYPE (newdecl) != error_mark_node)
1244             layout_type (TREE_TYPE (newdecl));
1245           if (TREE_CODE (newdecl) != FUNCTION_DECL
1246               && TREE_CODE (newdecl) != TYPE_DECL
1247               && TREE_CODE (newdecl) != CONST_DECL)
1248             layout_decl (newdecl, 0);
1249         }
1250       else
1251         {
1252           /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
1253           DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1254           DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1255           DECL_MODE (newdecl) = DECL_MODE (olddecl);
1256           if (TREE_CODE (olddecl) != FUNCTION_DECL)
1257             if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1258               {
1259                 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1260                 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1261               }
1262         }
1263
1264       /* Keep the old rtl since we can safely use it.  */
1265       COPY_DECL_RTL (olddecl, newdecl);
1266
1267       /* Merge the type qualifiers.  */
1268       if (TREE_READONLY (newdecl))
1269         TREE_READONLY (write_olddecl) = 1;
1270
1271       if (TREE_THIS_VOLATILE (newdecl))
1272         {
1273           TREE_THIS_VOLATILE (write_olddecl) = 1;
1274           if (TREE_CODE (newdecl) == VAR_DECL
1275               /* If an automatic variable is re-declared in the same
1276                  function scope, but the old declaration was not
1277                  volatile, make_var_volatile() would crash because the
1278                  variable would have been assigned to a pseudo, not a
1279                  MEM.  Since this duplicate declaration is invalid
1280                  anyway, we just skip the call.  */
1281               && errmsg == 0)
1282             make_var_volatile (newdecl);
1283         }
1284
1285       /* Keep source location of definition rather than declaration.  */
1286       /* When called with different_binding_level set, keep the old
1287          information so that meaningful diagnostics can be given.  */
1288       if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1289           && ! different_binding_level)
1290         {
1291           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1292           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1293         }
1294
1295       /* Merge the unused-warning information.  */
1296       if (DECL_IN_SYSTEM_HEADER (olddecl))
1297         DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1298       else if (DECL_IN_SYSTEM_HEADER (newdecl))
1299         DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1300
1301       /* Merge the initialization information.  */
1302       /* When called with different_binding_level set, don't copy over
1303          DECL_INITIAL, so that we don't accidentally change function
1304          declarations into function definitions.  */
1305       if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1306         DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1307
1308       /* Merge the section attribute.
1309          We want to issue an error if the sections conflict but that must be
1310          done later in decl_attributes since we are called before attributes
1311          are assigned.  */
1312       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1313         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1314
1315       /* Copy the assembler name.
1316          Currently, it can only be defined in the prototype.  */
1317       COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1318
1319       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1320         {
1321           DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1322           DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1323           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1324           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1325             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1326           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1327           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1328           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1329           DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1330         }
1331     }
1332   /* If cannot merge, then use the new type and qualifiers,
1333      and don't preserve the old rtl.  */
1334   else if (! different_binding_level)
1335     {
1336       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1337       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1338       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1339       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1340     }
1341
1342   /* Merge the storage class information.  */
1343   merge_weak (newdecl, olddecl);
1344
1345   /* For functions, static overrides non-static.  */
1346   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1347     {
1348       TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1349       /* This is since we don't automatically
1350          copy the attributes of NEWDECL into OLDDECL.  */
1351       /* No need to worry about different_binding_level here because
1352          then TREE_PUBLIC (newdecl) was true.  */
1353       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1354       /* If this clears `static', clear it in the identifier too.  */
1355       if (! TREE_PUBLIC (olddecl))
1356         TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1357     }
1358   if (DECL_EXTERNAL (newdecl))
1359     {
1360       if (! different_binding_level || different_tu)
1361         {
1362           /* Don't mess with these flags on local externs; they remain
1363              external even if there's a declaration at file scope which
1364              isn't.  */
1365           TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1366           DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1367         }
1368       /* An extern decl does not override previous storage class.  */
1369       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1370       if (! DECL_EXTERNAL (newdecl))
1371         {
1372           DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1373           /* If we have two non-EXTERNAL file-scope decls that are
1374              the same, only one of them should be written out.  */
1375           if (different_tu)
1376             TREE_ASM_WRITTEN (newdecl) = 1;
1377         }
1378     }
1379   else
1380     {
1381       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1382       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1383     }
1384
1385   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1386     {
1387       /* If we're redefining a function previously defined as extern
1388          inline, make sure we emit debug info for the inline before we
1389          throw it away, in case it was inlined into a function that hasn't
1390          been written out yet.  */
1391       if (new_is_definition && DECL_INITIAL (olddecl))
1392         {
1393           if (TREE_USED (olddecl))
1394             (*debug_hooks->outlining_inline_function) (olddecl);
1395
1396           /* The new defn must not be inline.  */
1397           DECL_INLINE (newdecl) = 0;
1398           DECL_UNINLINABLE (newdecl) = 1;
1399         }
1400       else
1401         {
1402           /* If either decl says `inline', this fn is inline,
1403              unless its definition was passed already.  */
1404           if (DECL_DECLARED_INLINE_P (newdecl)
1405               || DECL_DECLARED_INLINE_P (olddecl))
1406             DECL_DECLARED_INLINE_P (newdecl) = 1;
1407
1408           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1409             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1410         }
1411
1412       if (DECL_BUILT_IN (olddecl))
1413         {
1414           /* Get rid of any built-in function if new arg types don't match it
1415              or if we have a function definition.  */
1416           if (! types_match || new_is_definition)
1417             {
1418               if (! different_binding_level)
1419                 {
1420                   TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1421                   DECL_BUILT_IN_CLASS (olddecl) = NOT_BUILT_IN;
1422                 }
1423             }
1424           else
1425             {
1426               /* If redeclaring a builtin function, and not a definition,
1427                  it stays built in.  */
1428               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1429               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1430             }
1431         }
1432
1433       /* Also preserve various other info from the definition.  */
1434       if (! new_is_definition)
1435         {
1436           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1437           /* When called with different_binding_level set, don't copy over
1438              DECL_INITIAL, so that we don't accidentally change function
1439              declarations into function definitions.  */
1440           if (! different_binding_level)
1441             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1442           DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1443           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1444           DECL_ESTIMATED_INSNS (newdecl) = DECL_ESTIMATED_INSNS (olddecl);
1445           DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1446
1447           /* Set DECL_INLINE on the declaration if we've got a body
1448              from which to instantiate.  */
1449           if (DECL_INLINE (olddecl) && ! DECL_UNINLINABLE (newdecl))
1450             {
1451               DECL_INLINE (newdecl) = 1;
1452               DECL_ABSTRACT_ORIGIN (newdecl)
1453                 = (different_binding_level
1454                    ? DECL_ORIGIN (olddecl)
1455                    : DECL_ABSTRACT_ORIGIN (olddecl));
1456             }
1457         }
1458       else
1459         {
1460           /* If a previous declaration said inline, mark the
1461              definition as inlinable.  */
1462           if (DECL_DECLARED_INLINE_P (newdecl)
1463               && ! DECL_UNINLINABLE (newdecl))
1464             DECL_INLINE (newdecl) = 1;
1465         }
1466     }
1467   if (different_binding_level)
1468     return 0;
1469
1470   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1471      But preserve OLDDECL's DECL_UID.  */
1472   {
1473     unsigned olddecl_uid = DECL_UID (olddecl);
1474
1475     memcpy ((char *) olddecl + sizeof (struct tree_common),
1476             (char *) newdecl + sizeof (struct tree_common),
1477             sizeof (struct tree_decl) - sizeof (struct tree_common));
1478     DECL_UID (olddecl) = olddecl_uid;
1479   }
1480
1481   /* NEWDECL contains the merged attribute lists.
1482      Update OLDDECL to be the same.  */
1483   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1484
1485   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1486      so that encode_section_info has a chance to look at the new decl
1487      flags and attributes.  */
1488   if (DECL_RTL_SET_P (olddecl)
1489       && (TREE_CODE (olddecl) == FUNCTION_DECL
1490           || (TREE_CODE (olddecl) == VAR_DECL
1491               && TREE_STATIC (olddecl))))
1492     make_decl_rtl (olddecl, NULL);
1493
1494   return 1;
1495 }
1496
1497 /* Return any external DECL associated with ID, whether or not it is
1498    currently in scope.  */
1499
1500 static tree
1501 any_external_decl (tree id)
1502 {
1503   tree decl = IDENTIFIER_SYMBOL_VALUE (id);
1504   tree t;
1505
1506   if (decl == 0 || TREE_CODE (decl) == ERROR_MARK)
1507     return 0;
1508   else if (TREE_CODE (decl) != TYPE_DECL && DECL_EXTERNAL (decl))
1509     return decl;
1510
1511   t = purpose_member (id, truly_local_externals);
1512   if (t)
1513     return TREE_VALUE (t);
1514
1515   return 0;
1516 }
1517
1518 /* Record an external decl DECL.  This only does something if a
1519    shadowing decl already exists.  */
1520 static void
1521 record_external_decl (tree decl)
1522 {
1523   tree name = DECL_NAME (decl);
1524   if (!IDENTIFIER_SYMBOL_VALUE (name))
1525     return;
1526
1527   truly_local_externals = tree_cons (name, decl, truly_local_externals);
1528 }
1529
1530 /* Check whether decl-node X shadows an existing declaration.
1531    OLD is the old IDENTIFIER_SYMBOL_VALUE of the DECL_NAME of X,
1532    which might be a NULL_TREE.  */
1533 static void
1534 warn_if_shadowing (tree x, tree old)
1535 {
1536   const char *name;
1537
1538   /* Nothing to shadow?  */
1539   if (old == 0
1540       /* Shadow warnings not wanted?  */
1541       || !warn_shadow
1542       /* No shadow warnings for internally generated vars.  */
1543       || DECL_SOURCE_LINE (x) == 0
1544       /* No shadow warnings for vars made for inlining.  */
1545       || DECL_FROM_INLINE (x)
1546       /* Don't warn about the parm names in function declarator
1547          within a function declarator.
1548          It would be nice to avoid warning in any function
1549          declarator in a declaration, as opposed to a definition,
1550          but there is no way to tell it's not a definition.  */
1551       || (TREE_CODE (x) == PARM_DECL
1552           && current_scope->outer->parm_flag))
1553     return;
1554
1555   name = IDENTIFIER_POINTER (DECL_NAME (x));
1556
1557   if (TREE_CODE (old) == PARM_DECL)
1558     shadow_warning (SW_PARAM, name, old);
1559   else if (C_DECL_FILE_SCOPE (old))
1560     shadow_warning (SW_GLOBAL, name, old);
1561   else
1562     shadow_warning (SW_LOCAL, name, old);
1563 }
1564
1565
1566 /* Subroutine of pushdecl.
1567
1568    X is a TYPE_DECL for a typedef statement.  Create a brand new
1569    ..._TYPE node (which will be just a variant of the existing
1570    ..._TYPE node with identical properties) and then install X
1571    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1572
1573    The whole point here is to end up with a situation where each
1574    and every ..._TYPE node the compiler creates will be uniquely
1575    associated with AT MOST one node representing a typedef name.
1576    This way, even though the compiler substitutes corresponding
1577    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1578    early on, later parts of the compiler can always do the reverse
1579    translation and get back the corresponding typedef name.  For
1580    example, given:
1581
1582         typedef struct S MY_TYPE;
1583         MY_TYPE object;
1584
1585    Later parts of the compiler might only know that `object' was of
1586    type `struct S' if it were not for code just below.  With this
1587    code however, later parts of the compiler see something like:
1588
1589         struct S' == struct S
1590         typedef struct S' MY_TYPE;
1591         struct S' object;
1592
1593     And they can then deduce (from the node for type struct S') that
1594     the original object declaration was:
1595
1596                 MY_TYPE object;
1597
1598     Being able to do this is important for proper support of protoize,
1599     and also for generating precise symbolic debugging information
1600     which takes full account of the programmer's (typedef) vocabulary.
1601
1602     Obviously, we don't want to generate a duplicate ..._TYPE node if
1603     the TYPE_DECL node that we are now processing really represents a
1604     standard built-in type.
1605
1606     Since all standard types are effectively declared at line zero
1607     in the source file, we can easily check to see if we are working
1608     on a standard type by checking the current value of lineno.  */
1609
1610 static void
1611 clone_underlying_type (tree x)
1612 {
1613   if (DECL_SOURCE_LINE (x) == 0)
1614     {
1615       if (TYPE_NAME (TREE_TYPE (x)) == 0)
1616         TYPE_NAME (TREE_TYPE (x)) = x;
1617     }
1618   else if (TREE_TYPE (x) != error_mark_node
1619            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
1620     {
1621       tree tt = TREE_TYPE (x);
1622       DECL_ORIGINAL_TYPE (x) = tt;
1623       tt = build_type_copy (tt);
1624       TYPE_NAME (tt) = x;
1625       TREE_USED (tt) = TREE_USED (x);
1626       TREE_TYPE (x) = tt;
1627     }
1628 }
1629
1630 /* Record a decl-node X as belonging to the current lexical scope.
1631    Check for errors (such as an incompatible declaration for the same
1632    name already seen in the same scope).
1633
1634    Returns either X or an old decl for the same name.
1635    If an old decl is returned, it may have been smashed
1636    to agree with what X says.  */
1637
1638 tree
1639 pushdecl (tree x)
1640 {
1641   tree name = DECL_NAME (x);
1642   struct c_scope *scope = current_scope;
1643
1644 #ifdef ENABLE_CHECKING
1645   if (error_mark_node == 0)
1646     /* Called too early.  */
1647     abort ();
1648 #endif
1649
1650   /* Functions need the lang_decl data.  */
1651   if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
1652     DECL_LANG_SPECIFIC (x) = ggc_alloc_cleared (sizeof (struct lang_decl));
1653
1654   /* A local extern declaration for a function doesn't constitute nesting.
1655      A local auto declaration does, since it's a forward decl
1656      for a nested function coming later.  */
1657   if (current_function_decl == NULL
1658       || ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
1659           && DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x)))
1660     DECL_CONTEXT (x) = current_file_decl;
1661   else
1662     DECL_CONTEXT (x) = current_function_decl;
1663
1664   if (name)
1665     {
1666       tree old;
1667
1668       if (warn_nested_externs
1669           && scope != global_scope
1670           && DECL_EXTERNAL (x)
1671           && !DECL_IN_SYSTEM_HEADER (x))
1672         warning ("nested extern declaration of `%s'",
1673                  IDENTIFIER_POINTER (name));
1674
1675       old = lookup_name_current_level (name);
1676       if (old && duplicate_decls (x, old, 0, false))
1677         return old;
1678       if (DECL_EXTERNAL (x) || scope == global_scope)
1679         {
1680           /* Find and check against a previous, not-in-scope, external
1681              decl for this identifier.  (C99 s???: If two declarations
1682              with external linkage, referring to the same object, have
1683              incompatible types, the behavior is undefined).  */
1684           tree ext = any_external_decl (name);
1685           if (ext)
1686             {
1687               if (duplicate_decls (x, ext, scope != global_scope,
1688                                    false))
1689                 x = copy_node (ext);
1690             }
1691           else
1692             record_external_decl (x);
1693         }
1694
1695       if (TREE_CODE (x) == TYPE_DECL)
1696         clone_underlying_type (x);
1697
1698       /* If storing a local value, there may already be one
1699          (inherited).  If so, record it for restoration when this
1700          scope ends.  Take care not to do this if we are replacing an
1701          older decl in the same scope (i.e.  duplicate_decls returned
1702          false, above).  */
1703       if (scope != global_scope
1704           && IDENTIFIER_SYMBOL_VALUE (name)
1705           && IDENTIFIER_SYMBOL_VALUE (name) != old)
1706         {
1707           warn_if_shadowing (x, IDENTIFIER_SYMBOL_VALUE (name));
1708           scope->shadowed = tree_cons (name, IDENTIFIER_SYMBOL_VALUE (name),
1709                                        scope->shadowed);
1710         }
1711
1712       /* Install the new declaration in the requested scope.  */
1713       IDENTIFIER_SYMBOL_VALUE (name) = x;
1714       C_DECL_INVISIBLE (x) = 0;
1715
1716       /* Keep list of variables in this scope with incomplete type.
1717          If the input is erroneous, we can have error_mark in the type
1718          slot (e.g. "f(void a, ...)") - that doesn't count as an
1719          incomplete type.  */
1720       if (TREE_TYPE (x) != error_mark_node
1721           && !COMPLETE_TYPE_P (TREE_TYPE (x)))
1722         {
1723           tree element = TREE_TYPE (x);
1724
1725           while (TREE_CODE (element) == ARRAY_TYPE)
1726             element = TREE_TYPE (element);
1727           if (TREE_CODE (element) == RECORD_TYPE
1728               || TREE_CODE (element) == UNION_TYPE)
1729             scope->incomplete_list = tree_cons (NULL_TREE, x,
1730                                                 scope->incomplete_list);
1731         }
1732     }
1733
1734   /* Put decls on list in reverse order.
1735      We will reverse them later if necessary.  */
1736   TREE_CHAIN (x) = scope->names;
1737   scope->names = x;
1738
1739   return x;
1740 }
1741
1742 /* Record X as belonging to the global scope (C99 "file scope").
1743    This is used only internally by the Objective-C front end,
1744    and is limited to its needs.  It will hork if there is _any_
1745    visible binding for X (not just a global one).  */
1746 tree
1747 pushdecl_top_level (tree x)
1748 {
1749   tree name, old;
1750
1751   if (TREE_CODE (x) != VAR_DECL)
1752     abort ();
1753
1754   name = DECL_NAME (x);
1755   old = IDENTIFIER_SYMBOL_VALUE (name);
1756
1757   if (old)
1758     {
1759       if (DECL_CONTEXT (old))
1760         abort ();
1761
1762       if (!duplicate_decls (x, old, 0, false))
1763         abort ();
1764
1765       return old;
1766     }
1767
1768   DECL_CONTEXT (x) = current_file_decl;
1769   IDENTIFIER_SYMBOL_VALUE (name) = x;
1770   TREE_CHAIN (x) = global_scope->names;
1771   global_scope->names = x;
1772   return x;
1773 }
1774
1775 /* Record X as belonging to the outermost scope of the current
1776    function.  This is used only internally, by c_make_fname_decl and
1777    undeclared_variable, and is limited to their needs.  The NAME is
1778    provided as a separate argument because undeclared_variable wants to
1779    use error_mark_node for X.  For VAR_DECLs, duplicate_decls is not
1780    called; if there is any preexisting decl for this identifier, it is
1781    an ICE.  */
1782 static void
1783 pushdecl_function_level (tree x, tree name)
1784 {
1785   struct c_scope *scope = current_function_scope;
1786
1787   if (x == error_mark_node)
1788     scope->shadowed = tree_cons (name, IDENTIFIER_SYMBOL_VALUE (name),
1789                                  scope->shadowed);
1790   else if (TREE_CODE (x) == VAR_DECL)
1791     {
1792       if (name != DECL_NAME (x))
1793         abort ();
1794       if (IDENTIFIER_SYMBOL_VALUE (name))
1795         abort ();
1796
1797       DECL_CONTEXT (x) = current_function_decl;
1798       TREE_CHAIN (x) = scope->names;
1799       scope->names = x;
1800     }
1801
1802   IDENTIFIER_SYMBOL_VALUE (name) = x;
1803 }
1804 \f
1805 /* Generate an implicit declaration for identifier FUNCTIONID as a
1806    function of type int ().  */
1807
1808 tree
1809 implicitly_declare (tree functionid)
1810 {
1811   tree decl = any_external_decl (functionid);
1812
1813   if (decl && decl != error_mark_node)
1814     {
1815       /* Implicit declaration of a function already declared
1816          (somehow) in a different scope, or as a built-in.
1817          If this is the first time this has happened, warn;
1818          then recycle the old declaration.  */
1819       if (!C_DECL_IMPLICIT (decl))
1820         {
1821           implicit_decl_warning (DECL_NAME (decl));
1822           if (! C_DECL_FILE_SCOPE (decl))
1823             warning ("%Hprevious declaration of '%D'",
1824                      &DECL_SOURCE_LOCATION (decl), decl);
1825           C_DECL_IMPLICIT (decl) = 1;
1826         }
1827       /* If this function is global, then it must already be in the
1828          global scope, so there's no need to push it again.  */
1829       if (current_scope == global_scope)
1830         return decl;
1831       /* If this is a local declaration, make a copy; we can't have
1832          the same DECL listed in two different scopes.  */
1833       return pushdecl (copy_node (decl));
1834     }
1835
1836   /* Not seen before.  */
1837   decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
1838   DECL_EXTERNAL (decl) = 1;
1839   TREE_PUBLIC (decl) = 1;
1840   C_DECL_IMPLICIT (decl) = 1;
1841   implicit_decl_warning (functionid);
1842
1843   /* ANSI standard says implicit declarations are in the innermost block.
1844      So we record the decl in the standard fashion.  */
1845   decl = pushdecl (decl);
1846
1847   /* No need to call objc_check_decl here - it's a function type.  */
1848   rest_of_decl_compilation (decl, NULL, 0, 0);
1849
1850   /* Write a record describing this implicit function declaration to the
1851      prototypes file (if requested).  */
1852
1853   gen_aux_info_record (decl, 0, 1, 0);
1854
1855   /* Possibly apply some default attributes to this implicit declaration.  */
1856   decl_attributes (&decl, NULL_TREE, 0);
1857
1858   return decl;
1859 }
1860
1861 static void
1862 implicit_decl_warning (tree id)
1863 {
1864   const char *name = IDENTIFIER_POINTER (id);
1865   if (mesg_implicit_function_declaration == 2)
1866     error ("implicit declaration of function `%s'", name);
1867   else if (mesg_implicit_function_declaration == 1)
1868     warning ("implicit declaration of function `%s'", name);
1869 }
1870
1871 /* Return zero if the declaration NEWDECL is valid
1872    when the declaration OLDDECL (assumed to be for the same name)
1873    has already been seen.
1874    Otherwise return 1 if NEWDECL is a redefinition, 2 if it is a redeclaration,
1875    and 3 if it is a conflicting declaration.  */
1876
1877 static int
1878 redeclaration_error_message (tree newdecl, tree olddecl)
1879 {
1880   if (TREE_CODE (newdecl) == TYPE_DECL)
1881     {
1882       /* Do not complain about type redeclarations where at least one
1883          declaration was in a system header.  */
1884       if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
1885         return 0;
1886       return 1;
1887     }
1888   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1889     {
1890       /* Declarations of functions can insist on internal linkage
1891          but they can't be inconsistent with internal linkage,
1892          so there can be no error on that account.
1893          However defining the same name twice is no good.  */
1894       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
1895           /* However, defining once as extern inline and a second
1896              time in another way is ok.  */
1897           && ! (DECL_DECLARED_INLINE_P (olddecl) && DECL_EXTERNAL (olddecl)
1898                && ! (DECL_DECLARED_INLINE_P (newdecl)
1899                      && DECL_EXTERNAL (newdecl))))
1900         return 1;
1901       return 0;
1902     }
1903   else if (C_DECL_FILE_SCOPE (newdecl))
1904     {
1905       /* Objects declared at file scope:  */
1906       /* If at least one is a reference, it's ok.  */
1907       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
1908         return 0;
1909       /* Reject two definitions.  */
1910       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
1911         return 1;
1912       /* Now we have two tentative defs, or one tentative and one real def.  */
1913       /* Insist that the linkage match.  */
1914       if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
1915         return 3;
1916       return 0;
1917     }
1918   else if (current_scope->parm_flag
1919            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1920     return 0;
1921   else
1922     {
1923       /* Newdecl has block scope.  If olddecl has block scope also, then
1924          reject two definitions, and reject a definition together with an
1925          external reference.  Otherwise, it is OK, because newdecl must
1926          be an extern reference to olddecl.  */
1927       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
1928           && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
1929         return 2;
1930       return 0;
1931     }
1932 }
1933
1934 /* Issue an error message for a reference to an undeclared variable
1935    ID, including a reference to a builtin outside of function-call
1936    context.  Establish a binding of the identifier to error_mark_node
1937    in an appropriate scope, which will suppress further errors for the
1938    same identifier.  */
1939 void
1940 undeclared_variable (tree id)
1941 {
1942   static bool already = false;
1943
1944   if (current_function_decl == 0)
1945     {
1946       error ("`%s' undeclared here (not in a function)",
1947              IDENTIFIER_POINTER (id));
1948       IDENTIFIER_SYMBOL_VALUE (id) = error_mark_node;
1949     }
1950   else
1951     {
1952       error ("`%s' undeclared (first use in this function)",
1953              IDENTIFIER_POINTER (id));
1954
1955       if (! already)
1956         {
1957           error ("(Each undeclared identifier is reported only once");
1958           error ("for each function it appears in.)");
1959           already = true;
1960         }
1961
1962       pushdecl_function_level (error_mark_node, id);
1963     }
1964 }
1965 \f
1966 /* Subroutine of lookup_label, declare_label, define_label: construct a
1967    LABEL_DECL with all the proper frills.  */
1968
1969 static tree
1970 make_label (tree name, location_t location)
1971 {
1972   tree label = build_decl (LABEL_DECL, name, void_type_node);
1973
1974   DECL_CONTEXT (label) = current_function_decl;
1975   DECL_MODE (label) = VOIDmode;
1976   DECL_SOURCE_LOCATION (label) = location;
1977
1978   return label;
1979 }
1980
1981 /* Another subroutine of lookup_label, declare_label, define_label:
1982    set up the binding of name to LABEL_DECL in the given SCOPE.  */
1983
1984 static void
1985 bind_label (tree name, tree label, struct c_scope *scope)
1986 {
1987   if (IDENTIFIER_LABEL_VALUE (name))
1988     scope->shadowed = tree_cons (name, IDENTIFIER_LABEL_VALUE (name),
1989                                  scope->shadowed);
1990   IDENTIFIER_LABEL_VALUE (name) = label;
1991
1992   TREE_CHAIN (label) = scope->names;
1993   scope->names = label;
1994 }
1995
1996 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
1997    Create one if none exists so far for the current function.
1998    This is called when a label is used in a goto expression or
1999    has its address taken.  */
2000
2001 tree
2002 lookup_label (tree name)
2003 {
2004   tree label;
2005
2006   if (current_function_decl == 0)
2007     {
2008       error ("label %s referenced outside of any function",
2009              IDENTIFIER_POINTER (name));
2010       return 0;
2011     }
2012
2013   /* Use a label already defined or ref'd with this name, but not if
2014      it is inherited from a containing function and wasn't declared
2015      using __label__.  */
2016   label = IDENTIFIER_LABEL_VALUE (name);
2017   if (label && (DECL_CONTEXT (label) == current_function_decl
2018                 || C_DECLARED_LABEL_FLAG (label)))
2019     {
2020       /* If the label has only been declared, update its apparent
2021          location to point here, for better diagnostics if it
2022          turns out not to have been defined.  */
2023       if (!TREE_USED (label))
2024         DECL_SOURCE_LOCATION (label) = input_location;
2025       return label;
2026     }
2027
2028   /* No label binding for that identifier; make one.  */
2029   label = make_label (name, input_location);
2030
2031   /* Ordinary labels go in the current function scope, which is
2032      not necessarily the current label scope.  */
2033   bind_label (name, label, current_function_scope);
2034   return label;
2035 }
2036
2037 /* Make a label named NAME in the current function, shadowing silently
2038    any that may be inherited from containing functions or containing
2039    scopes.  This is called for __label__ declarations.  */
2040
2041 /* Note that valid use, if the label being shadowed comes from another
2042    scope in the same function, requires calling declare_nonlocal_label
2043    right away.  (Is this still true?  -zw 2003-07-17)  */
2044
2045 tree
2046 declare_label (tree name)
2047 {
2048   tree label = IDENTIFIER_LABEL_VALUE (name);
2049   tree dup;
2050
2051   /* Check to make sure that the label hasn't already been declared
2052      at this scope */
2053   for (dup = current_scope->names; dup; dup = TREE_CHAIN (dup))
2054     if (dup == label)
2055       {
2056         error ("duplicate label declaration `%s'", IDENTIFIER_POINTER (name));
2057         error ("%Hthis is a previous declaration",
2058                &DECL_SOURCE_LOCATION (dup));
2059
2060         /* Just use the previous declaration.  */
2061         return dup;
2062       }
2063
2064   label = make_label (name, input_location);
2065   C_DECLARED_LABEL_FLAG (label) = 1;
2066
2067   /* Declared labels go in the current scope.  */
2068   bind_label (name, label, current_scope);
2069   return label;
2070 }
2071
2072 /* Define a label, specifying the location in the source file.
2073    Return the LABEL_DECL node for the label, if the definition is valid.
2074    Otherwise return 0.  */
2075
2076 tree
2077 define_label (location_t location, tree name)
2078 {
2079   tree label;
2080
2081   /* Find any preexisting label with this name.  It is an error
2082      if that label has already been defined in this function, or
2083      if there is a containing function with a declared label with
2084      the same name.  */
2085   label = IDENTIFIER_LABEL_VALUE (name);
2086
2087   if (label
2088       && ((DECL_CONTEXT (label) == current_function_decl
2089            && DECL_INITIAL (label) != 0)
2090           || (DECL_CONTEXT (label) != current_function_decl
2091               && C_DECLARED_LABEL_FLAG (label))))
2092     {
2093       error ("%Hduplicate label `%D'", &location, label);
2094       if (DECL_INITIAL (label))
2095         error ("%H`%D' previously defined here",
2096                &DECL_SOURCE_LOCATION (label), label);
2097       else
2098         error ("%H`%D' previously declared here",
2099                &DECL_SOURCE_LOCATION (label), label);
2100       return 0;
2101     }
2102   else if (label && DECL_CONTEXT (label) == current_function_decl)
2103     {
2104       /* The label has been used or declared already in this function,
2105          but not defined.  Update its location to point to this
2106          definition.  */
2107       DECL_SOURCE_LOCATION (label) = location;
2108     }
2109   else
2110     {
2111       /* No label binding for that identifier; make one.  */
2112       label = make_label (name, location);
2113
2114       /* Ordinary labels go in the current function scope, which is
2115          not necessarily the current label scope.  */
2116       bind_label (name, label, current_function_scope);
2117     }
2118
2119   if (warn_traditional && !in_system_header && lookup_name (name))
2120     warning ("%Htraditional C lacks a separate namespace for labels, "
2121              "identifier `%s' conflicts", &location,
2122              IDENTIFIER_POINTER (name));
2123
2124   /* Mark label as having been defined.  */
2125   DECL_INITIAL (label) = error_mark_node;
2126   return label;
2127 }
2128 \f
2129 /* Return the list of declarations of the current scope.
2130    Note that this list is in reverse order unless/until
2131    you nreverse it; and when you do nreverse it, you must
2132    store the result back using `storedecls' or you will lose.  */
2133
2134 tree
2135 getdecls (void)
2136 {
2137   return current_scope->names;
2138 }
2139
2140 /* Return the list of type-tags (for structs, etc) of the current scope.  */
2141
2142 tree
2143 gettags (void)
2144 {
2145   return current_scope->tags;
2146 }
2147
2148 /* Store the list of declarations of the current scope.
2149    This is done for the parameter declarations of a function being defined,
2150    after they are modified in the light of any missing parameters.  */
2151
2152 static void
2153 storedecls (tree decls)
2154 {
2155   current_scope->names = decls;
2156 }
2157
2158 /* Similarly, store the list of tags of the current scope.  */
2159
2160 static void
2161 storetags (tree tags)
2162 {
2163   current_scope->tags = tags;
2164 }
2165 \f
2166 /* Given NAME, an IDENTIFIER_NODE,
2167    return the structure (or union or enum) definition for that name.
2168    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
2169    CODE says which kind of type the caller wants;
2170    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2171    If the wrong kind of type is found, an error is reported.  */
2172
2173 static tree
2174 lookup_tag (enum tree_code code, tree name, int thislevel_only)
2175 {
2176   tree tag = IDENTIFIER_TAG_VALUE (name);
2177   int thislevel = 0;
2178
2179   if (!tag)
2180     return 0;
2181
2182   /* We only care about whether it's in this level if
2183      thislevel_only was set or it might be a type clash.  */
2184   if (thislevel_only || TREE_CODE (tag) != code)
2185     {
2186       if (current_scope == global_scope
2187           || purpose_member (name, current_scope->tags))
2188         thislevel = 1;
2189     }
2190
2191   if (thislevel_only && !thislevel)
2192     return 0;
2193
2194   if (TREE_CODE (tag) != code)
2195     {
2196       /* Definition isn't the kind we were looking for.  */
2197       pending_invalid_xref = name;
2198       pending_invalid_xref_location = input_location;
2199
2200       /* If in the same binding level as a declaration as a tag
2201          of a different type, this must not be allowed to
2202          shadow that tag, so give the error immediately.
2203          (For example, "struct foo; union foo;" is invalid.)  */
2204       if (thislevel)
2205         pending_xref_error ();
2206     }
2207   return tag;
2208 }
2209
2210 /* Print an error message now
2211    for a recent invalid struct, union or enum cross reference.
2212    We don't print them immediately because they are not invalid
2213    when used in the `struct foo;' construct for shadowing.  */
2214
2215 void
2216 pending_xref_error (void)
2217 {
2218   if (pending_invalid_xref != 0)
2219     error ("%H`%s' defined as wrong kind of tag",
2220            &pending_invalid_xref_location,
2221            IDENTIFIER_POINTER (pending_invalid_xref));
2222   pending_invalid_xref = 0;
2223 }
2224
2225 \f
2226 /* Look up NAME in the current scope and its superiors
2227    in the namespace of variables, functions and typedefs.
2228    Return a ..._DECL node of some kind representing its definition,
2229    or return 0 if it is undefined.  */
2230
2231 tree
2232 lookup_name (tree name)
2233 {
2234   tree decl = IDENTIFIER_SYMBOL_VALUE (name);
2235   if (decl == 0 || decl == error_mark_node)
2236     return decl;
2237   if (C_DECL_INVISIBLE (decl))
2238     return 0;
2239   return decl;
2240 }
2241
2242 /* Similar to `lookup_name' but look only at the current scope.  */
2243
2244 static tree
2245 lookup_name_current_level (tree name)
2246 {
2247   tree decl = IDENTIFIER_SYMBOL_VALUE (name);
2248
2249   if (decl == 0 || decl == error_mark_node || C_DECL_INVISIBLE (decl))
2250     return 0;
2251
2252   if (current_scope == global_scope)
2253     return decl;
2254
2255   /* Scan the current scope for a decl with name NAME.  */
2256   if (chain_member (decl, current_scope->names))
2257     return decl;
2258
2259   return 0;
2260 }
2261 \f
2262 /* Create the predefined scalar types of C,
2263    and some nodes representing standard constants (0, 1, (void *) 0).
2264    Initialize the global scope.
2265    Make definitions for built-in primitive functions.  */
2266
2267 void
2268 c_init_decl_processing (void)
2269 {
2270   tree endlink;
2271   tree ptr_ftype_void, ptr_ftype_ptr;
2272   location_t save_loc = input_location;
2273
2274   /* Adds some ggc roots, and reserved words for c-parse.in.  */
2275   c_parse_init ();
2276
2277   current_function_decl = NULL;
2278   current_scope = NULL;
2279   current_function_scope = NULL;
2280   scope_freelist = NULL;
2281
2282   /* Make the c_scope structure for global names.  */
2283   pushlevel (0);
2284   global_scope = current_scope;
2285   /* Declarations from c_common_nodes_and_builtins must not be associated
2286      with this input file, lest we get differences between using and not
2287      using preprocessed headers.  */
2288   input_location.file = "<internal>";
2289   input_location.line = 0;
2290
2291   /* Make the DECL for the toplevel file scope.  */
2292   current_file_decl = build_decl (TRANSLATION_UNIT_DECL, NULL, NULL);
2293
2294   build_common_tree_nodes (flag_signed_char);
2295
2296   c_common_nodes_and_builtins ();
2297
2298   /* In C, comparisons and TRUTH_* expressions have type int.  */
2299   truthvalue_type_node = integer_type_node;
2300   truthvalue_true_node = integer_one_node;
2301   truthvalue_false_node = integer_zero_node;
2302
2303   /* Even in C99, which has a real boolean type.  */
2304   pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2305                         boolean_type_node));
2306
2307   endlink = void_list_node;
2308   ptr_ftype_void = build_function_type (ptr_type_node, endlink);
2309   ptr_ftype_ptr
2310     = build_function_type (ptr_type_node,
2311                            tree_cons (NULL_TREE, ptr_type_node, endlink));
2312
2313   input_location = save_loc;
2314
2315   pedantic_lvalues = pedantic;
2316
2317   make_fname_decl = c_make_fname_decl;
2318   start_fname_decls ();
2319
2320   builtin_decls = global_scope->names;
2321 }
2322
2323 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2324    decl, NAME is the initialization string and TYPE_DEP indicates whether
2325    NAME depended on the type of the function.  As we don't yet implement
2326    delayed emission of static data, we mark the decl as emitted
2327    so it is not placed in the output.  Anything using it must therefore pull
2328    out the STRING_CST initializer directly.  This does mean that these names
2329    are string merging candidates, which is wrong for C99's __func__.  FIXME.  */
2330
2331 static tree
2332 c_make_fname_decl (tree id, int type_dep)
2333 {
2334   const char *name = fname_as_string (type_dep);
2335   tree decl, type, init;
2336   size_t length = strlen (name);
2337
2338   type =  build_array_type
2339           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
2340            build_index_type (size_int (length)));
2341
2342   decl = build_decl (VAR_DECL, id, type);
2343
2344   TREE_STATIC (decl) = 1;
2345   TREE_READONLY (decl) = 1;
2346   DECL_ARTIFICIAL (decl) = 1;
2347
2348   init = build_string (length + 1, name);
2349   TREE_TYPE (init) = type;
2350   DECL_INITIAL (decl) = init;
2351
2352   TREE_USED (decl) = 1;
2353
2354   if (current_function_decl)
2355     pushdecl_function_level (decl, DECL_NAME (decl));
2356
2357   finish_decl (decl, init, NULL_TREE);
2358
2359   return decl;
2360 }
2361
2362 /* Return a definition for a builtin function named NAME and whose data type
2363    is TYPE.  TYPE should be a function type with argument types.
2364    FUNCTION_CODE tells later passes how to compile calls to this function.
2365    See tree.h for its possible values.
2366
2367    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2368    the name to be called if we can't opencode the function.  If
2369    ATTRS is nonzero, use that for the function's attribute list.  */
2370
2371 tree
2372 builtin_function (const char *name, tree type, int function_code,
2373                   enum built_in_class class, const char *library_name,
2374                   tree attrs)
2375 {
2376   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
2377   DECL_EXTERNAL (decl) = 1;
2378   TREE_PUBLIC (decl) = 1;
2379   if (library_name)
2380     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2381   make_decl_rtl (decl, NULL);
2382   pushdecl (decl);
2383   DECL_BUILT_IN_CLASS (decl) = class;
2384   DECL_FUNCTION_CODE (decl) = function_code;
2385
2386   /* Warn if a function in the namespace for users
2387      is used without an occasion to consider it declared.  */
2388   if (name[0] != '_' || name[1] != '_')
2389     C_DECL_INVISIBLE (decl) = 1;
2390
2391   /* Possibly apply some default attributes to this built-in function.  */
2392   if (attrs)
2393     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2394   else
2395     decl_attributes (&decl, NULL_TREE, 0);
2396
2397   return decl;
2398 }
2399
2400 /* Apply default attributes to a function, if a system function with default
2401    attributes.  */
2402
2403 void
2404 c_insert_default_attributes (tree decl)
2405 {
2406   if (!TREE_PUBLIC (decl))
2407     return;
2408   c_common_insert_default_attributes (decl);
2409 }
2410 \f
2411 /* Called when a declaration is seen that contains no names to declare.
2412    If its type is a reference to a structure, union or enum inherited
2413    from a containing scope, shadow that tag name for the current scope
2414    with a forward reference.
2415    If its type defines a new named structure or union
2416    or defines an enum, it is valid but we need not do anything here.
2417    Otherwise, it is an error.  */
2418
2419 void
2420 shadow_tag (tree declspecs)
2421 {
2422   shadow_tag_warned (declspecs, 0);
2423 }
2424
2425 void
2426 shadow_tag_warned (tree declspecs, int warned)
2427
2428
2429      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
2430         no pedwarn.  */
2431 {
2432   int found_tag = 0;
2433   tree link;
2434   tree specs, attrs;
2435
2436   pending_invalid_xref = 0;
2437
2438   /* Remove the attributes from declspecs, since they will confuse the
2439      following code.  */
2440   split_specs_attrs (declspecs, &specs, &attrs);
2441
2442   for (link = specs; link; link = TREE_CHAIN (link))
2443     {
2444       tree value = TREE_VALUE (link);
2445       enum tree_code code = TREE_CODE (value);
2446
2447       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2448         /* Used to test also that TYPE_SIZE (value) != 0.
2449            That caused warning for `struct foo;' at top level in the file.  */
2450         {
2451           tree name = TYPE_NAME (value);
2452           tree t;
2453
2454           found_tag++;
2455
2456           if (name == 0)
2457             {
2458               if (warned != 1 && code != ENUMERAL_TYPE)
2459                 /* Empty unnamed enum OK */
2460                 {
2461                   pedwarn ("unnamed struct/union that defines no instances");
2462                   warned = 1;
2463                 }
2464             }
2465           else
2466             {
2467               t = lookup_tag (code, name, 1);
2468
2469               if (t == 0)
2470                 {
2471                   t = make_node (code);
2472                   pushtag (name, t);
2473                 }
2474             }
2475         }
2476       else
2477         {
2478           if (!warned && ! in_system_header)
2479             {
2480               warning ("useless keyword or type name in empty declaration");
2481               warned = 2;
2482             }
2483         }
2484     }
2485
2486   if (found_tag > 1)
2487     error ("two types specified in one empty declaration");
2488
2489   if (warned != 1)
2490     {
2491       if (found_tag == 0)
2492         pedwarn ("empty declaration");
2493     }
2494 }
2495 \f
2496 /* Construct an array declarator.  EXPR is the expression inside [], or
2497    NULL_TREE.  QUALS are the type qualifiers inside the [] (to be applied
2498    to the pointer to which a parameter array is converted).  STATIC_P is
2499    nonzero if "static" is inside the [], zero otherwise.  VLA_UNSPEC_P
2500    is nonzero is the array is [*], a VLA of unspecified length which is
2501    nevertheless a complete type (not currently implemented by GCC),
2502    zero otherwise.  The declarator is constructed as an ARRAY_REF
2503    (to be decoded by grokdeclarator), whose operand 0 is what's on the
2504    left of the [] (filled by in set_array_declarator_type) and operand 1
2505    is the expression inside; whose TREE_TYPE is the type qualifiers and
2506    which has TREE_STATIC set if "static" is used.  */
2507
2508 tree
2509 build_array_declarator (tree expr, tree quals, int static_p, int vla_unspec_p)
2510 {
2511   tree decl;
2512   decl = build_nt (ARRAY_REF, NULL_TREE, expr);
2513   TREE_TYPE (decl) = quals;
2514   TREE_STATIC (decl) = (static_p ? 1 : 0);
2515   if (pedantic && !flag_isoc99)
2516     {
2517       if (static_p || quals != NULL_TREE)
2518         pedwarn ("ISO C90 does not support `static' or type qualifiers in parameter array declarators");
2519       if (vla_unspec_p)
2520         pedwarn ("ISO C90 does not support `[*]' array declarators");
2521     }
2522   if (vla_unspec_p)
2523     warning ("GCC does not yet properly implement `[*]' array declarators");
2524   return decl;
2525 }
2526
2527 /* Set the type of an array declarator.  DECL is the declarator, as
2528    constructed by build_array_declarator; TYPE is what appears on the left
2529    of the [] and goes in operand 0.  ABSTRACT_P is nonzero if it is an
2530    abstract declarator, zero otherwise; this is used to reject static and
2531    type qualifiers in abstract declarators, where they are not in the
2532    C99 grammar.  */
2533
2534 tree
2535 set_array_declarator_type (tree decl, tree type, int abstract_p)
2536 {
2537   TREE_OPERAND (decl, 0) = type;
2538   if (abstract_p && (TREE_TYPE (decl) != NULL_TREE || TREE_STATIC (decl)))
2539     error ("static or type qualifiers in abstract declarator");
2540   return decl;
2541 }
2542 \f
2543 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
2544
2545 tree
2546 groktypename (tree typename)
2547 {
2548   tree specs, attrs;
2549
2550   if (TREE_CODE (typename) != TREE_LIST)
2551     return typename;
2552
2553   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
2554
2555   typename = grokdeclarator (TREE_VALUE (typename), specs, TYPENAME, 0);
2556
2557   /* Apply attributes.  */
2558   decl_attributes (&typename, attrs, 0);
2559
2560   return typename;
2561 }
2562
2563 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
2564
2565 tree
2566 groktypename_in_parm_context (tree typename)
2567 {
2568   if (TREE_CODE (typename) != TREE_LIST)
2569     return typename;
2570   return grokdeclarator (TREE_VALUE (typename),
2571                          TREE_PURPOSE (typename),
2572                          PARM, 0);
2573 }
2574
2575 /* Decode a declarator in an ordinary declaration or data definition.
2576    This is called as soon as the type information and variable name
2577    have been parsed, before parsing the initializer if any.
2578    Here we create the ..._DECL node, fill in its type,
2579    and put it on the list of decls for the current context.
2580    The ..._DECL node is returned as the value.
2581
2582    Exception: for arrays where the length is not specified,
2583    the type is left null, to be filled in by `finish_decl'.
2584
2585    Function definitions do not come here; they go to start_function
2586    instead.  However, external and forward declarations of functions
2587    do go through here.  Structure field declarations are done by
2588    grokfield and not through here.  */
2589
2590 tree
2591 start_decl (tree declarator, tree declspecs, int initialized, tree attributes)
2592 {
2593   tree decl;
2594   tree tem;
2595
2596   /* An object declared as __attribute__((deprecated)) suppresses
2597      warnings of uses of other deprecated items.  */
2598   if (lookup_attribute ("deprecated", attributes))
2599     deprecated_state = DEPRECATED_SUPPRESS;
2600
2601   decl = grokdeclarator (declarator, declspecs,
2602                          NORMAL, initialized);
2603
2604   deprecated_state = DEPRECATED_NORMAL;
2605
2606   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
2607       && MAIN_NAME_P (DECL_NAME (decl)))
2608     warning ("%H'%D' is usually a function",
2609              &DECL_SOURCE_LOCATION (decl), decl);
2610
2611   if (initialized)
2612     /* Is it valid for this decl to have an initializer at all?
2613        If not, set INITIALIZED to zero, which will indirectly
2614        tell `finish_decl' to ignore the initializer once it is parsed.  */
2615     switch (TREE_CODE (decl))
2616       {
2617       case TYPE_DECL:
2618         error ("typedef `%s' is initialized (use __typeof__ instead)",
2619                IDENTIFIER_POINTER (DECL_NAME (decl)));
2620         initialized = 0;
2621         break;
2622
2623       case FUNCTION_DECL:
2624         error ("function `%s' is initialized like a variable",
2625                IDENTIFIER_POINTER (DECL_NAME (decl)));
2626         initialized = 0;
2627         break;
2628
2629       case PARM_DECL:
2630         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
2631         error ("parameter `%s' is initialized",
2632                IDENTIFIER_POINTER (DECL_NAME (decl)));
2633         initialized = 0;
2634         break;
2635
2636       default:
2637         /* Don't allow initializations for incomplete types
2638            except for arrays which might be completed by the initialization.  */
2639
2640         /* This can happen if the array size is an undefined macro.  We already
2641            gave a warning, so we don't need another one.  */
2642         if (TREE_TYPE (decl) == error_mark_node)
2643           initialized = 0;
2644         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
2645           {
2646             /* A complete type is ok if size is fixed.  */
2647
2648             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
2649                 || C_DECL_VARIABLE_SIZE (decl))
2650               {
2651                 error ("variable-sized object may not be initialized");
2652                 initialized = 0;
2653               }
2654           }
2655         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
2656           {
2657             error ("variable `%s' has initializer but incomplete type",
2658                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2659             initialized = 0;
2660           }
2661         else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
2662           {
2663             error ("elements of array `%s' have incomplete type",
2664                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2665             initialized = 0;
2666           }
2667       }
2668
2669   if (initialized)
2670     {
2671       DECL_EXTERNAL (decl) = 0;
2672       if (current_scope == global_scope)
2673         TREE_STATIC (decl) = 1;
2674
2675       /* Tell `pushdecl' this is an initialized decl
2676          even though we don't yet have the initializer expression.
2677          Also tell `finish_decl' it may store the real initializer.  */
2678       DECL_INITIAL (decl) = error_mark_node;
2679     }
2680
2681   /* If this is a function declaration, write a record describing it to the
2682      prototypes file (if requested).  */
2683
2684   if (TREE_CODE (decl) == FUNCTION_DECL)
2685     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
2686
2687   /* ANSI specifies that a tentative definition which is not merged with
2688      a non-tentative definition behaves exactly like a definition with an
2689      initializer equal to zero.  (Section 3.7.2)
2690
2691      -fno-common gives strict ANSI behavior, though this tends to break
2692      a large body of code that grew up without this rule.
2693
2694      Thread-local variables are never common, since there's no entrenched
2695      body of code to break, and it allows more efficient variable references
2696      in the presence of dynamic linking.  */
2697
2698   if (TREE_CODE (decl) == VAR_DECL
2699       && !initialized
2700       && TREE_PUBLIC (decl)
2701       && !DECL_THREAD_LOCAL (decl)
2702       && !flag_no_common)
2703     DECL_COMMON (decl) = 1;
2704
2705   /* Set attributes here so if duplicate decl, will have proper attributes.  */
2706   decl_attributes (&decl, attributes, 0);
2707
2708   if (TREE_CODE (decl) == FUNCTION_DECL
2709       && DECL_DECLARED_INLINE_P (decl)
2710       && DECL_UNINLINABLE (decl)
2711       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
2712     warning ("%Hinline function '%D' given attribute noinline",
2713              &DECL_SOURCE_LOCATION (decl), decl);
2714
2715   /* Add this decl to the current scope.
2716      TEM may equal DECL or it may be a previous decl of the same name.  */
2717   tem = pushdecl (decl);
2718
2719   /* For a local variable, define the RTL now.  */
2720   if (current_scope != global_scope
2721       /* But not if this is a duplicate decl
2722          and we preserved the rtl from the previous one
2723          (which may or may not happen).  */
2724       && !DECL_RTL_SET_P (tem)
2725       && C_DECL_FILE_SCOPE (tem))
2726     {
2727       if (TREE_TYPE (tem) != error_mark_node
2728           && COMPLETE_TYPE_P (TREE_TYPE (tem)))
2729         expand_decl (tem);
2730       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
2731                && DECL_INITIAL (tem) != 0)
2732         expand_decl (tem);
2733     }
2734
2735   return tem;
2736 }
2737
2738 /* Finish processing of a declaration;
2739    install its initial value.
2740    If the length of an array type is not known before,
2741    it must be determined now, from the initial value, or it is an error.  */
2742
2743 void
2744 finish_decl (tree decl, tree init, tree asmspec_tree)
2745 {
2746   tree type = TREE_TYPE (decl);
2747   int was_incomplete = (DECL_SIZE (decl) == 0);
2748   const char *asmspec = 0;
2749
2750   /* If a name was specified, get the string.  */
2751   if (current_scope == global_scope)
2752     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
2753   if (asmspec_tree)
2754     asmspec = TREE_STRING_POINTER (asmspec_tree);
2755
2756   /* If `start_decl' didn't like having an initialization, ignore it now.  */
2757   if (init != 0 && DECL_INITIAL (decl) == 0)
2758     init = 0;
2759
2760   /* Don't crash if parm is initialized.  */
2761   if (TREE_CODE (decl) == PARM_DECL)
2762     init = 0;
2763
2764   if (init)
2765     store_init_value (decl, init);
2766
2767   /* Deduce size of array from initialization, if not already known */
2768   if (TREE_CODE (type) == ARRAY_TYPE
2769       && TYPE_DOMAIN (type) == 0
2770       && TREE_CODE (decl) != TYPE_DECL)
2771     {
2772       int do_default
2773         = (TREE_STATIC (decl)
2774            /* Even if pedantic, an external linkage array
2775               may have incomplete type at first.  */
2776            ? pedantic && !TREE_PUBLIC (decl)
2777            : !DECL_EXTERNAL (decl));
2778       int failure
2779         = complete_array_type (type, DECL_INITIAL (decl), do_default);
2780
2781       /* Get the completed type made by complete_array_type.  */
2782       type = TREE_TYPE (decl);
2783
2784       if (failure == 1)
2785         error ("%Hinitializer fails to determine size of '%D'",
2786                &DECL_SOURCE_LOCATION (decl), decl);
2787
2788       else if (failure == 2)
2789         {
2790           if (do_default)
2791             error ("%Harray size missing in '%D'",
2792                    &DECL_SOURCE_LOCATION (decl), decl);
2793           /* If a `static' var's size isn't known,
2794              make it extern as well as static, so it does not get
2795              allocated.
2796              If it is not `static', then do not mark extern;
2797              finish_incomplete_decl will give it a default size
2798              and it will get allocated.  */
2799           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
2800             DECL_EXTERNAL (decl) = 1;
2801         }
2802
2803       /* TYPE_MAX_VALUE is always one less than the number of elements
2804          in the array, because we start counting at zero.  Therefore,
2805          warn only if the value is less than zero.  */
2806       else if (pedantic && TYPE_DOMAIN (type) != 0
2807               && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
2808         error ("%Hzero or negative size array '%D'",
2809                &DECL_SOURCE_LOCATION (decl), decl);
2810
2811       layout_decl (decl, 0);
2812     }
2813
2814   if (TREE_CODE (decl) == VAR_DECL)
2815     {
2816       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
2817           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
2818         layout_decl (decl, 0);
2819
2820       if (DECL_SIZE (decl) == 0
2821           /* Don't give an error if we already gave one earlier.  */
2822           && TREE_TYPE (decl) != error_mark_node
2823           && (TREE_STATIC (decl)
2824               ?
2825                 /* A static variable with an incomplete type
2826                    is an error if it is initialized.
2827                    Also if it is not file scope.
2828                    Otherwise, let it through, but if it is not `extern'
2829                    then it may cause an error message later.  */
2830                 (DECL_INITIAL (decl) != 0
2831                  || !C_DECL_FILE_SCOPE (decl))
2832               :
2833                 /* An automatic variable with an incomplete type
2834                    is an error.  */
2835                 !DECL_EXTERNAL (decl)))
2836         {
2837           error ("%Hstorage size of '%D' isn't known",
2838                  &DECL_SOURCE_LOCATION (decl), decl);
2839           TREE_TYPE (decl) = error_mark_node;
2840         }
2841
2842       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
2843           && DECL_SIZE (decl) != 0)
2844         {
2845           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
2846             constant_expression_warning (DECL_SIZE (decl));
2847           else
2848             error ("%Hstorage size of '%D' isn't constant",
2849                    &DECL_SOURCE_LOCATION (decl), decl);
2850         }
2851
2852       if (TREE_USED (type))
2853         TREE_USED (decl) = 1;
2854     }
2855
2856   /* If this is a function and an assembler name is specified, reset DECL_RTL
2857      so we can give it its new name.  Also, update built_in_decls if it
2858      was a normal built-in.  */
2859   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
2860     {
2861       /* ASMSPEC is given, and not the name of a register.  Mark the
2862       name with a star so assemble_name won't munge it.  */
2863       char *starred = alloca (strlen (asmspec) + 2);
2864       starred[0] = '*';
2865       strcpy (starred + 1, asmspec);
2866
2867       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2868         {
2869           tree builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
2870           SET_DECL_RTL (builtin, NULL_RTX);
2871           SET_DECL_ASSEMBLER_NAME (builtin, get_identifier (starred));
2872 #ifdef TARGET_MEM_FUNCTIONS
2873           if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
2874             init_block_move_fn (starred);
2875           else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
2876             init_block_clear_fn (starred);
2877 #else
2878           if (DECL_FUNCTION_CODE (decl) == BUILT_IN_BCOPY)
2879             init_block_move_fn (starred);
2880           else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_BZERO)
2881             init_block_clear_fn (starred);
2882 #endif
2883         }
2884       SET_DECL_RTL (decl, NULL_RTX);
2885       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (starred));
2886     }
2887
2888   /* If #pragma weak was used, mark the decl weak now.  */
2889   if (current_scope == global_scope)
2890     maybe_apply_pragma_weak (decl);
2891
2892   /* Output the assembler code and/or RTL code for variables and functions,
2893      unless the type is an undefined structure or union.
2894      If not, it will get done when the type is completed.  */
2895
2896   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2897     {
2898       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
2899       if (c_dialect_objc ())
2900         objc_check_decl (decl);
2901
2902       if (C_DECL_FILE_SCOPE (decl))
2903         {
2904           if (DECL_INITIAL (decl) == NULL_TREE
2905               || DECL_INITIAL (decl) == error_mark_node)
2906             /* Don't output anything
2907                when a tentative file-scope definition is seen.
2908                But at end of compilation, do output code for them.  */
2909             DECL_DEFER_OUTPUT (decl) = 1;
2910           rest_of_decl_compilation (decl, asmspec, true, 0);
2911         }
2912       else
2913         {
2914           /* This is a local variable.  If there is an ASMSPEC, the
2915              user has requested that we handle it specially.  */
2916           if (asmspec)
2917             {
2918               /* In conjunction with an ASMSPEC, the `register'
2919                  keyword indicates that we should place the variable
2920                  in a particular register.  */
2921               if (DECL_REGISTER (decl))
2922                 DECL_C_HARD_REGISTER (decl) = 1;
2923
2924               /* If this is not a static variable, issue a warning.
2925                  It doesn't make any sense to give an ASMSPEC for an
2926                  ordinary, non-register local variable.  Historically,
2927                  GCC has accepted -- but ignored -- the ASMSPEC in
2928                  this case.  */
2929               if (TREE_CODE (decl) == VAR_DECL
2930                   && !DECL_REGISTER (decl)
2931                   && !TREE_STATIC (decl))
2932                 warning ("%Hignoring asm-specifier for non-static local "
2933                          "variable '%D'", &DECL_SOURCE_LOCATION (decl), decl);
2934               else
2935                 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
2936             }
2937
2938           if (TREE_CODE (decl) != FUNCTION_DECL)
2939             add_decl_stmt (decl);
2940         }
2941
2942       if (!C_DECL_FILE_SCOPE (decl))
2943         {
2944           /* Recompute the RTL of a local array now
2945              if it used to be an incomplete type.  */
2946           if (was_incomplete
2947               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
2948             {
2949               /* If we used it already as memory, it must stay in memory.  */
2950               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
2951               /* If it's still incomplete now, no init will save it.  */
2952               if (DECL_SIZE (decl) == 0)
2953                 DECL_INITIAL (decl) = 0;
2954             }
2955         }
2956     }
2957
2958   /* If this was marked 'used', be sure it will be output.  */
2959   if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
2960     mark_referenced (DECL_ASSEMBLER_NAME (decl));
2961
2962   if (TREE_CODE (decl) == TYPE_DECL)
2963     {
2964       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
2965       if (c_dialect_objc ())
2966         objc_check_decl (decl);
2967       rest_of_decl_compilation (decl, NULL, C_DECL_FILE_SCOPE (decl), 0);
2968     }
2969
2970   /* At the end of a declaration, throw away any variable type sizes
2971      of types defined inside that declaration.  There is no use
2972      computing them in the following function definition.  */
2973   if (current_scope == global_scope)
2974     get_pending_sizes ();
2975
2976   /* Install a cleanup (aka destructor) if one was given.  */
2977   if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
2978     {
2979       tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
2980       if (attr)
2981         {
2982           static bool eh_initialized_p;
2983
2984           tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
2985           tree cleanup_decl = lookup_name (cleanup_id);
2986           tree cleanup;
2987
2988           /* Build "cleanup(&decl)" for the destructor.  */
2989           cleanup = build_unary_op (ADDR_EXPR, decl, 0);
2990           cleanup = build_tree_list (NULL_TREE, cleanup);
2991           cleanup = build_function_call (cleanup_decl, cleanup);
2992
2993           /* Don't warn about decl unused; the cleanup uses it.  */
2994           TREE_USED (decl) = 1;
2995
2996           /* Initialize EH, if we've been told to do so.  */
2997           if (flag_exceptions && !eh_initialized_p)
2998             {
2999               eh_initialized_p = true;
3000               eh_personality_libfunc
3001                 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
3002                                     ? "__gcc_personality_sj0"
3003                                     : "__gcc_personality_v0");
3004               using_eh_for_cleanups ();
3005             }
3006
3007           add_stmt (build_stmt (CLEANUP_STMT, decl, cleanup));
3008         }
3009     }
3010 }
3011
3012 /* Given a parsed parameter declaration,
3013    decode it into a PARM_DECL and push that on the current scope.
3014    Also, for the sake of forward parm decls,
3015    record the given order of parms in `parm_order'.  */
3016
3017 void
3018 push_parm_decl (tree parm)
3019 {
3020   tree decl;
3021   int old_immediate_size_expand = immediate_size_expand;
3022   /* Don't try computing parm sizes now -- wait till fn is called.  */
3023   immediate_size_expand = 0;
3024
3025   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3026                          TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3027   decl_attributes (&decl, TREE_VALUE (parm), 0);
3028
3029   decl = pushdecl (decl);
3030
3031   immediate_size_expand = old_immediate_size_expand;
3032
3033   current_scope->parm_order
3034     = tree_cons (NULL_TREE, decl, current_scope->parm_order);
3035
3036   /* Add this decl to the current scope.  */
3037   finish_decl (decl, NULL_TREE, NULL_TREE);
3038 }
3039
3040 /* Clear the given order of parms in `parm_order'.
3041    Used at start of parm list,
3042    and also at semicolon terminating forward decls.  */
3043
3044 void
3045 clear_parm_order (void)
3046 {
3047   current_scope->parm_order = NULL_TREE;
3048 }
3049 \f
3050 static GTY(()) int compound_literal_number;
3051
3052 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
3053    literal, which may be an incomplete array type completed by the
3054    initializer; INIT is a CONSTRUCTOR that initializes the compound
3055    literal.  */
3056
3057 tree
3058 build_compound_literal (tree type, tree init)
3059 {
3060   /* We do not use start_decl here because we have a type, not a declarator;
3061      and do not use finish_decl because the decl should be stored inside
3062      the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT.  */
3063   tree decl = build_decl (VAR_DECL, NULL_TREE, type);
3064   tree complit;
3065   tree stmt;
3066   DECL_EXTERNAL (decl) = 0;
3067   TREE_PUBLIC (decl) = 0;
3068   TREE_STATIC (decl) = (current_scope == global_scope);
3069   DECL_CONTEXT (decl) = current_function_decl;
3070   TREE_USED (decl) = 1;
3071   TREE_TYPE (decl) = type;
3072   TREE_READONLY (decl) = TREE_READONLY (type);
3073   store_init_value (decl, init);
3074
3075   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3076     {
3077       int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3078       if (failure)
3079         abort ();
3080     }
3081
3082   type = TREE_TYPE (decl);
3083   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3084     return error_mark_node;
3085
3086   stmt = build_stmt (DECL_STMT, decl);
3087   complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3088   TREE_SIDE_EFFECTS (complit) = 1;
3089
3090   layout_decl (decl, 0);
3091
3092   if (TREE_STATIC (decl))
3093     {
3094       /* This decl needs a name for the assembler output.  We also need
3095          a unique suffix to be added to the name.  */
3096       char *name;
3097
3098       ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3099                                compound_literal_number);
3100       compound_literal_number++;
3101       DECL_NAME (decl) = get_identifier (name);
3102       DECL_DEFER_OUTPUT (decl) = 1;
3103       DECL_COMDAT (decl) = 1;
3104       DECL_ARTIFICIAL (decl) = 1;
3105       pushdecl (decl);
3106       rest_of_decl_compilation (decl, NULL, 1, 0);
3107     }
3108
3109   return complit;
3110 }
3111 \f
3112 /* Make TYPE a complete type based on INITIAL_VALUE.
3113    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3114    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3115
3116 int
3117 complete_array_type (tree type, tree initial_value, int do_default)
3118 {
3119   tree maxindex = NULL_TREE;
3120   int value = 0;
3121
3122   if (initial_value)
3123     {
3124       /* Note MAXINDEX  is really the maximum index,
3125          one less than the size.  */
3126       if (TREE_CODE (initial_value) == STRING_CST)
3127         {
3128           int eltsize
3129             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3130           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3131                                    / eltsize) - 1, 0);
3132         }
3133       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3134         {
3135           tree elts = CONSTRUCTOR_ELTS (initial_value);
3136           maxindex = build_int_2 (-1, -1);
3137           for (; elts; elts = TREE_CHAIN (elts))
3138             {
3139               if (TREE_PURPOSE (elts))
3140                 maxindex = TREE_PURPOSE (elts);
3141               else
3142                 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3143                                         maxindex, integer_one_node));
3144             }
3145           maxindex = copy_node (maxindex);
3146         }
3147       else
3148         {
3149           /* Make an error message unless that happened already.  */
3150           if (initial_value != error_mark_node)
3151             value = 1;
3152
3153           /* Prevent further error messages.  */
3154           maxindex = build_int_2 (0, 0);
3155         }
3156     }
3157
3158   if (!maxindex)
3159     {
3160       if (do_default)
3161         maxindex = build_int_2 (0, 0);
3162       value = 2;
3163     }
3164
3165   if (maxindex)
3166     {
3167       TYPE_DOMAIN (type) = build_index_type (maxindex);
3168       if (!TREE_TYPE (maxindex))
3169         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3170     }
3171
3172   /* Lay out the type now that we can get the real answer.  */
3173
3174   layout_type (type);
3175
3176   return value;
3177 }
3178 \f
3179 /* Determine whether TYPE is a structure with a flexible array member,
3180    or a union containing such a structure (possibly recursively).  */
3181
3182 static bool
3183 flexible_array_type_p (tree type)
3184 {
3185   tree x;
3186   switch (TREE_CODE (type))
3187     {
3188     case RECORD_TYPE:
3189       x = TYPE_FIELDS (type);
3190       if (x == NULL_TREE)
3191         return false;
3192       while (TREE_CHAIN (x) != NULL_TREE)
3193         x = TREE_CHAIN (x);
3194       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3195           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3196           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3197           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3198         return true;
3199       return false;
3200     case UNION_TYPE:
3201       for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3202         {
3203           if (flexible_array_type_p (TREE_TYPE (x)))
3204             return true;
3205         }
3206       return false;
3207     default:
3208     return false;
3209   }
3210 }
3211 \f
3212 /* Given declspecs and a declarator,
3213    determine the name and type of the object declared
3214    and construct a ..._DECL node for it.
3215    (In one case we can return a ..._TYPE node instead.
3216     For invalid input we sometimes return 0.)
3217
3218    DECLSPECS is a chain of tree_list nodes whose value fields
3219     are the storage classes and type specifiers.
3220
3221    DECL_CONTEXT says which syntactic context this declaration is in:
3222      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3223      FUNCDEF for a function definition.  Like NORMAL but a few different
3224       error messages in each case.  Return value may be zero meaning
3225       this definition is too screwy to try to parse.
3226      PARM for a parameter declaration (either within a function prototype
3227       or before a function body).  Make a PARM_DECL, or return void_type_node.
3228      TYPENAME if for a typename (in a cast or sizeof).
3229       Don't make a DECL node; just return the ..._TYPE node.
3230      FIELD for a struct or union field; make a FIELD_DECL.
3231      BITFIELD for a field with specified width.
3232    INITIALIZED is 1 if the decl has an initializer.
3233
3234    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3235    It may also be so in the PARM case, for a prototype where the
3236    argument type is specified but not the name.
3237
3238    This function is where the complicated C meanings of `static'
3239    and `extern' are interpreted.  */
3240
3241 static tree
3242 grokdeclarator (tree declarator, tree declspecs,
3243                 enum decl_context decl_context, int initialized)
3244 {
3245   int specbits = 0;
3246   tree spec;
3247   tree type = NULL_TREE;
3248   int longlong = 0;
3249   int constp;
3250   int restrictp;
3251   int volatilep;
3252   int type_quals = TYPE_UNQUALIFIED;
3253   int inlinep;
3254   int explicit_int = 0;
3255   int explicit_char = 0;
3256   int defaulted_int = 0;
3257   tree typedef_decl = 0;
3258   const char *name;
3259   tree typedef_type = 0;
3260   int funcdef_flag = 0;
3261   enum tree_code innermost_code = ERROR_MARK;
3262   int bitfield = 0;
3263   int size_varies = 0;
3264   tree decl_attr = NULL_TREE;
3265   tree array_ptr_quals = NULL_TREE;
3266   int array_parm_static = 0;
3267   tree returned_attrs = NULL_TREE;
3268
3269   if (decl_context == BITFIELD)
3270     bitfield = 1, decl_context = FIELD;
3271
3272   if (decl_context == FUNCDEF)
3273     funcdef_flag = 1, decl_context = NORMAL;
3274
3275   /* Look inside a declarator for the name being declared
3276      and get it as a string, for an error message.  */
3277   {
3278     tree decl = declarator;
3279     name = 0;
3280
3281     while (decl)
3282       switch (TREE_CODE (decl))
3283         {
3284         case ARRAY_REF:
3285         case INDIRECT_REF:
3286         case CALL_EXPR:
3287           innermost_code = TREE_CODE (decl);
3288           decl = TREE_OPERAND (decl, 0);
3289           break;
3290
3291         case TREE_LIST:
3292           decl = TREE_VALUE (decl);
3293           break;
3294
3295         case IDENTIFIER_NODE:
3296           name = IDENTIFIER_POINTER (decl);
3297           decl = 0;
3298           break;
3299
3300         default:
3301           abort ();
3302         }
3303     if (name == 0)
3304       name = "type name";
3305   }
3306
3307   /* A function definition's declarator must have the form of
3308      a function declarator.  */
3309
3310   if (funcdef_flag && innermost_code != CALL_EXPR)
3311     return 0;
3312
3313   /* If this looks like a function definition, make it one,
3314      even if it occurs where parms are expected.
3315      Then store_parm_decls will reject it and not use it as a parm.  */
3316   if (decl_context == NORMAL && !funcdef_flag
3317       && current_scope->parm_flag)
3318     decl_context = PARM;
3319
3320   /* Look through the decl specs and record which ones appear.
3321      Some typespecs are defined as built-in typenames.
3322      Others, the ones that are modifiers of other types,
3323      are represented by bits in SPECBITS: set the bits for
3324      the modifiers that appear.  Storage class keywords are also in SPECBITS.
3325
3326      If there is a typedef name or a type, store the type in TYPE.
3327      This includes builtin typedefs such as `int'.
3328
3329      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3330      and did not come from a user typedef.
3331
3332      Set LONGLONG if `long' is mentioned twice.  */
3333
3334   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3335     {
3336       tree id = TREE_VALUE (spec);
3337
3338       /* If the entire declaration is itself tagged as deprecated then
3339          suppress reports of deprecated items.  */
3340       if (id && TREE_DEPRECATED (id))
3341         {
3342           if (deprecated_state != DEPRECATED_SUPPRESS)
3343             warn_deprecated_use (id);
3344         }
3345
3346       if (id == ridpointers[(int) RID_INT])
3347         explicit_int = 1;
3348       if (id == ridpointers[(int) RID_CHAR])
3349         explicit_char = 1;
3350
3351       if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3352         {
3353           enum rid i = C_RID_CODE (id);
3354           if ((int) i <= (int) RID_LAST_MODIFIER)
3355             {
3356               if (i == RID_LONG && (specbits & (1 << (int) RID_LONG)))
3357                 {
3358                   if (longlong)
3359                     error ("`long long long' is too long for GCC");
3360                   else
3361                     {
3362                       if (pedantic && !flag_isoc99 && ! in_system_header
3363                           && warn_long_long)
3364                         pedwarn ("ISO C90 does not support `long long'");
3365                       longlong = 1;
3366                     }
3367                 }
3368               else if (specbits & (1 << (int) i))
3369                 {
3370                   if (i == RID_CONST || i == RID_VOLATILE || i == RID_RESTRICT)
3371                     {
3372                       if (!flag_isoc99)
3373                         pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3374                     }
3375                   else
3376                     error ("duplicate `%s'", IDENTIFIER_POINTER (id));
3377                 }
3378
3379               /* Diagnose "__thread extern".  Recall that this list
3380                  is in the reverse order seen in the text.  */
3381               if (i == RID_THREAD
3382                   && (specbits & (1 << (int) RID_EXTERN
3383                                   | 1 << (int) RID_STATIC)))
3384                 {
3385                   if (specbits & 1 << (int) RID_EXTERN)
3386                     error ("`__thread' before `extern'");
3387                   else
3388                     error ("`__thread' before `static'");
3389                 }
3390
3391               specbits |= 1 << (int) i;
3392               goto found;
3393             }
3394         }
3395       if (type)
3396         error ("two or more data types in declaration of `%s'", name);
3397       /* Actual typedefs come to us as TYPE_DECL nodes.  */
3398       else if (TREE_CODE (id) == TYPE_DECL)
3399         {
3400           if (TREE_TYPE (id) == error_mark_node)
3401             ; /* Allow the type to default to int to avoid cascading errors.  */
3402           else
3403             {
3404               type = TREE_TYPE (id);
3405               decl_attr = DECL_ATTRIBUTES (id);
3406               typedef_decl = id;
3407             }
3408         }
3409       /* Built-in types come as identifiers.  */
3410       else if (TREE_CODE (id) == IDENTIFIER_NODE)
3411         {
3412           tree t = lookup_name (id);
3413           if (TREE_TYPE (t) == error_mark_node)
3414             ;
3415           else if (!t || TREE_CODE (t) != TYPE_DECL)
3416             error ("`%s' fails to be a typedef or built in type",
3417                    IDENTIFIER_POINTER (id));
3418           else
3419             {
3420               type = TREE_TYPE (t);
3421               typedef_decl = t;
3422             }
3423         }
3424       else if (TREE_CODE (id) != ERROR_MARK)
3425         type = id;
3426
3427     found:
3428       ;
3429     }
3430
3431   typedef_type = type;
3432   if (type)
3433     size_varies = C_TYPE_VARIABLE_SIZE (type);
3434
3435   /* No type at all: default to `int', and set DEFAULTED_INT
3436      because it was not a user-defined typedef.  */
3437
3438   if (type == 0)
3439     {
3440       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3441                           | (1 << (int) RID_SIGNED)
3442                           | (1 << (int) RID_UNSIGNED)
3443                           | (1 << (int) RID_COMPLEX))))
3444           /* Don't warn about typedef foo = bar.  */
3445           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3446           && ! in_system_header)
3447         {
3448           /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3449              and this is a function, or if -Wimplicit; prefer the former
3450              warning since it is more explicit.  */
3451           if ((warn_implicit_int || warn_return_type || flag_isoc99)
3452               && funcdef_flag)
3453             warn_about_return_type = 1;
3454           else if (warn_implicit_int || flag_isoc99)
3455             pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
3456                          name);
3457         }
3458
3459       defaulted_int = 1;
3460       type = integer_type_node;
3461     }
3462
3463   /* Now process the modifiers that were specified
3464      and check for invalid combinations.  */
3465
3466   /* Long double is a special combination.  */
3467
3468   if ((specbits & 1 << (int) RID_LONG) && ! longlong
3469       && TYPE_MAIN_VARIANT (type) == double_type_node)
3470     {
3471       specbits &= ~(1 << (int) RID_LONG);
3472       type = long_double_type_node;
3473     }
3474
3475   /* Check all other uses of type modifiers.  */
3476
3477   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3478                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3479     {
3480       int ok = 0;
3481
3482       if ((specbits & 1 << (int) RID_LONG)
3483           && (specbits & 1 << (int) RID_SHORT))
3484         error ("both long and short specified for `%s'", name);
3485       else if (((specbits & 1 << (int) RID_LONG)
3486                 || (specbits & 1 << (int) RID_SHORT))
3487                && explicit_char)
3488         error ("long or short specified with char for `%s'", name);
3489       else if (((specbits & 1 << (int) RID_LONG)
3490                 || (specbits & 1 << (int) RID_SHORT))
3491                && TREE_CODE (type) == REAL_TYPE)
3492         {
3493           static int already = 0;
3494
3495           error ("long or short specified with floating type for `%s'", name);
3496           if (! already && ! pedantic)
3497             {
3498               error ("the only valid combination is `long double'");
3499               already = 1;
3500             }
3501         }
3502       else if ((specbits & 1 << (int) RID_SIGNED)
3503                && (specbits & 1 << (int) RID_UNSIGNED))
3504         error ("both signed and unsigned specified for `%s'", name);
3505       else if (TREE_CODE (type) != INTEGER_TYPE)
3506         error ("long, short, signed or unsigned invalid for `%s'", name);
3507       else
3508         {
3509           ok = 1;
3510           if (!explicit_int && !defaulted_int && !explicit_char)
3511             {
3512               error ("long, short, signed or unsigned used invalidly for `%s'",
3513                      name);
3514               ok = 0;
3515             }
3516         }
3517
3518       /* Discard the type modifiers if they are invalid.  */
3519       if (! ok)
3520         {
3521           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3522                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3523           longlong = 0;
3524         }
3525     }
3526
3527   if ((specbits & (1 << (int) RID_COMPLEX))
3528       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
3529     {
3530       error ("complex invalid for `%s'", name);
3531       specbits &= ~(1 << (int) RID_COMPLEX);
3532     }
3533
3534   /* Decide whether an integer type is signed or not.
3535      Optionally treat bitfields as signed by default.  */
3536   if (specbits & 1 << (int) RID_UNSIGNED
3537       || (bitfield && ! flag_signed_bitfields
3538           && (explicit_int || defaulted_int || explicit_char
3539               /* A typedef for plain `int' without `signed'
3540                  can be controlled just like plain `int'.  */
3541               || ! (typedef_decl != 0
3542                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3543           && TREE_CODE (type) != ENUMERAL_TYPE
3544           && !(specbits & 1 << (int) RID_SIGNED)))
3545     {
3546       if (longlong)
3547         type = long_long_unsigned_type_node;
3548       else if (specbits & 1 << (int) RID_LONG)
3549         type = long_unsigned_type_node;
3550       else if (specbits & 1 << (int) RID_SHORT)
3551         type = short_unsigned_type_node;
3552       else if (type == char_type_node)
3553         type = unsigned_char_type_node;
3554       else if (typedef_decl)
3555         type = c_common_unsigned_type (type);
3556       else
3557         type = unsigned_type_node;
3558     }
3559   else if ((specbits & 1 << (int) RID_SIGNED)
3560            && type == char_type_node)
3561     type = signed_char_type_node;
3562   else if (longlong)
3563     type = long_long_integer_type_node;
3564   else if (specbits & 1 << (int) RID_LONG)
3565     type = long_integer_type_node;
3566   else if (specbits & 1 << (int) RID_SHORT)
3567     type = short_integer_type_node;
3568
3569   if (specbits & 1 << (int) RID_COMPLEX)
3570     {
3571       if (pedantic && !flag_isoc99)
3572         pedwarn ("ISO C90 does not support complex types");
3573       /* If we just have "complex", it is equivalent to
3574          "complex double", but if any modifiers at all are specified it is
3575          the complex form of TYPE.  E.g, "complex short" is
3576          "complex short int".  */
3577
3578       if (defaulted_int && ! longlong
3579           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3580                             | (1 << (int) RID_SIGNED)
3581                             | (1 << (int) RID_UNSIGNED))))
3582         {
3583           if (pedantic)
3584             pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
3585           type = complex_double_type_node;
3586         }
3587       else if (type == integer_type_node)
3588         {
3589           if (pedantic)
3590             pedwarn ("ISO C does not support complex integer types");
3591           type = complex_integer_type_node;
3592         }
3593       else if (type == float_type_node)
3594         type = complex_float_type_node;
3595       else if (type == double_type_node)
3596         type = complex_double_type_node;
3597       else if (type == long_double_type_node)
3598         type = complex_long_double_type_node;
3599       else
3600         {
3601           if (pedantic)
3602             pedwarn ("ISO C does not support complex integer types");
3603           type = build_complex_type (type);
3604         }
3605     }
3606
3607   /* Figure out the type qualifiers for the declaration.  There are
3608      two ways a declaration can become qualified.  One is something
3609      like `const int i' where the `const' is explicit.  Another is
3610      something like `typedef const int CI; CI i' where the type of the
3611      declaration contains the `const'.  */
3612   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
3613   restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
3614   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
3615   inlinep = !! (specbits & (1 << (int) RID_INLINE));
3616   if (constp > 1 && ! flag_isoc99)
3617     pedwarn ("duplicate `const'");
3618   if (restrictp > 1 && ! flag_isoc99)
3619     pedwarn ("duplicate `restrict'");
3620   if (volatilep > 1 && ! flag_isoc99)
3621     pedwarn ("duplicate `volatile'");
3622   if (! flag_gen_aux_info && (TYPE_QUALS (type)))
3623     type = TYPE_MAIN_VARIANT (type);
3624   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
3625                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
3626                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
3627
3628   /* Warn if two storage classes are given. Default to `auto'.  */
3629
3630   {
3631     int nclasses = 0;
3632
3633     if (specbits & 1 << (int) RID_AUTO) nclasses++;
3634     if (specbits & 1 << (int) RID_STATIC) nclasses++;
3635     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
3636     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
3637     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
3638
3639     /* "static __thread" and "extern __thread" are allowed.  */
3640     if ((specbits & (1 << (int) RID_THREAD
3641                      | 1 << (int) RID_STATIC
3642                      | 1 << (int) RID_EXTERN)) == (1 << (int) RID_THREAD))
3643       nclasses++;
3644
3645     /* Warn about storage classes that are invalid for certain
3646        kinds of declarations (parameters, typenames, etc.).  */
3647
3648     if (nclasses > 1)
3649       error ("multiple storage classes in declaration of `%s'", name);
3650     else if (funcdef_flag
3651              && (specbits
3652                  & ((1 << (int) RID_REGISTER)
3653                     | (1 << (int) RID_AUTO)
3654                     | (1 << (int) RID_TYPEDEF)
3655                     | (1 << (int) RID_THREAD))))
3656       {
3657         if (specbits & 1 << (int) RID_AUTO
3658             && (pedantic || current_scope == global_scope))
3659           pedwarn ("function definition declared `auto'");
3660         if (specbits & 1 << (int) RID_REGISTER)
3661           error ("function definition declared `register'");
3662         if (specbits & 1 << (int) RID_TYPEDEF)
3663           error ("function definition declared `typedef'");
3664         if (specbits & 1 << (int) RID_THREAD)
3665           error ("function definition declared `__thread'");
3666         specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3667                       | (1 << (int) RID_AUTO) | (1 << (int) RID_THREAD));
3668       }
3669     else if (decl_context != NORMAL && nclasses > 0)
3670       {
3671         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
3672           ;
3673         else
3674           {
3675             switch (decl_context)
3676               {
3677               case FIELD:
3678                 error ("storage class specified for structure field `%s'",
3679                        name);
3680                 break;
3681               case PARM:
3682                 error ("storage class specified for parameter `%s'", name);
3683                 break;
3684               default:
3685                 error ("storage class specified for typename");
3686                 break;
3687               }
3688             specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3689                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
3690                           | (1 << (int) RID_EXTERN) | (1 << (int) RID_THREAD));
3691           }
3692       }
3693     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
3694       {
3695         /* `extern' with initialization is invalid if not at file scope.  */
3696         if (current_scope == global_scope)
3697           warning ("`%s' initialized and declared `extern'", name);
3698         else
3699           error ("`%s' has both `extern' and initializer", name);
3700       }
3701     else if (current_scope == global_scope)
3702       {
3703         if (specbits & 1 << (int) RID_AUTO)
3704           error ("file-scope declaration of `%s' specifies `auto'", name);
3705       }
3706     else
3707       {
3708         if (specbits & 1 << (int) RID_EXTERN && funcdef_flag)
3709           error ("nested function `%s' declared `extern'", name);
3710         else if ((specbits & (1 << (int) RID_THREAD
3711                                | 1 << (int) RID_EXTERN
3712                                | 1 << (int) RID_STATIC))
3713                  == (1 << (int) RID_THREAD))
3714           {
3715             error ("function-scope `%s' implicitly auto and declared `__thread'",
3716                    name);
3717             specbits &= ~(1 << (int) RID_THREAD);
3718           }
3719       }
3720   }
3721
3722   /* Now figure out the structure of the declarator proper.
3723      Descend through it, creating more complex types, until we reach
3724      the declared identifier (or NULL_TREE, in an absolute declarator).  */
3725
3726   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
3727     {
3728       if (type == error_mark_node)
3729         {
3730           declarator = TREE_OPERAND (declarator, 0);
3731           continue;
3732         }
3733
3734       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3735          an INDIRECT_REF (for *...),
3736          a CALL_EXPR (for ...(...)),
3737          a TREE_LIST (for nested attributes),
3738          an identifier (for the name being declared)
3739          or a null pointer (for the place in an absolute declarator
3740          where the name was omitted).
3741          For the last two cases, we have just exited the loop.
3742
3743          At this point, TYPE is the type of elements of an array,
3744          or for a function to return, or for a pointer to point to.
3745          After this sequence of ifs, TYPE is the type of the
3746          array or function or pointer, and DECLARATOR has had its
3747          outermost layer removed.  */
3748
3749       if (array_ptr_quals != NULL_TREE || array_parm_static)
3750         {
3751           /* Only the innermost declarator (making a parameter be of
3752              array type which is converted to pointer type)
3753              may have static or type qualifiers.  */
3754           error ("static or type qualifiers in non-parameter array declarator");
3755           array_ptr_quals = NULL_TREE;
3756           array_parm_static = 0;
3757         }
3758
3759       if (TREE_CODE (declarator) == TREE_LIST)
3760         {
3761           /* We encode a declarator with embedded attributes using
3762              a TREE_LIST.  */
3763           tree attrs = TREE_PURPOSE (declarator);
3764           tree inner_decl;
3765           int attr_flags = 0;
3766           declarator = TREE_VALUE (declarator);
3767           inner_decl = declarator;
3768           while (inner_decl != NULL_TREE
3769                  && TREE_CODE (inner_decl) == TREE_LIST)
3770             inner_decl = TREE_VALUE (inner_decl);
3771           if (inner_decl == NULL_TREE
3772               || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
3773             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
3774           else if (TREE_CODE (inner_decl) == CALL_EXPR)
3775             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
3776           else if (TREE_CODE (inner_decl) == ARRAY_REF)
3777             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
3778           returned_attrs = decl_attributes (&type,
3779                                             chainon (returned_attrs, attrs),
3780                                             attr_flags);
3781         }
3782       else if (TREE_CODE (declarator) == ARRAY_REF)
3783         {
3784           tree itype = NULL_TREE;
3785           tree size = TREE_OPERAND (declarator, 1);
3786           /* The index is a signed object `sizetype' bits wide.  */
3787           tree index_type = c_common_signed_type (sizetype);
3788
3789           array_ptr_quals = TREE_TYPE (declarator);
3790           array_parm_static = TREE_STATIC (declarator);
3791
3792           declarator = TREE_OPERAND (declarator, 0);
3793
3794           /* Check for some types that there cannot be arrays of.  */
3795
3796           if (VOID_TYPE_P (type))
3797             {
3798               error ("declaration of `%s' as array of voids", name);
3799               type = error_mark_node;
3800             }
3801
3802           if (TREE_CODE (type) == FUNCTION_TYPE)
3803             {
3804               error ("declaration of `%s' as array of functions", name);
3805               type = error_mark_node;
3806             }
3807
3808           if (pedantic && flexible_array_type_p (type))
3809             pedwarn ("invalid use of structure with flexible array member");
3810
3811           if (size == error_mark_node)
3812             type = error_mark_node;
3813
3814           if (type == error_mark_node)
3815             continue;
3816
3817           /* If size was specified, set ITYPE to a range-type for that size.
3818              Otherwise, ITYPE remains null.  finish_decl may figure it out
3819              from an initial value.  */
3820
3821           if (size)
3822             {
3823               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3824               STRIP_TYPE_NOPS (size);
3825
3826               if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
3827                 {
3828                   error ("size of array `%s' has non-integer type", name);
3829                   size = integer_one_node;
3830                 }
3831
3832               if (pedantic && integer_zerop (size))
3833                 pedwarn ("ISO C forbids zero-size array `%s'", name);
3834
3835               if (TREE_CODE (size) == INTEGER_CST)
3836                 {
3837                   constant_expression_warning (size);
3838                   if (tree_int_cst_sgn (size) < 0)
3839                     {
3840                       error ("size of array `%s' is negative", name);
3841                       size = integer_one_node;
3842                     }
3843                 }
3844               else
3845                 {
3846                   /* Make sure the array size remains visibly nonconstant
3847                      even if it is (eg) a const variable with known value.  */
3848                   size_varies = 1;
3849
3850                   if (!flag_isoc99 && pedantic)
3851                     {
3852                       if (TREE_CONSTANT (size))
3853                         pedwarn ("ISO C90 forbids array `%s' whose size can't be evaluated",
3854                                  name);
3855                       else
3856                         pedwarn ("ISO C90 forbids variable-size array `%s'",
3857                                  name);
3858                     }
3859                 }
3860
3861               if (integer_zerop (size))
3862                 {
3863                   /* A zero-length array cannot be represented with an
3864                      unsigned index type, which is what we'll get with
3865                      build_index_type.  Create an open-ended range instead.  */
3866                   itype = build_range_type (sizetype, size, NULL_TREE);
3867                 }
3868               else
3869                 {
3870                   /* Compute the maximum valid index, that is, size - 1.
3871                      Do the calculation in index_type, so that if it is
3872                      a variable the computations will be done in the
3873                      proper mode.  */
3874                   itype = fold (build (MINUS_EXPR, index_type,
3875                                        convert (index_type, size),
3876                                        convert (index_type, size_one_node)));
3877
3878                   /* If that overflowed, the array is too big.
3879                      ??? While a size of INT_MAX+1 technically shouldn't
3880                      cause an overflow (because we subtract 1), the overflow
3881                      is recorded during the conversion to index_type, before
3882                      the subtraction.  Handling this case seems like an
3883                      unnecessary complication.  */
3884                   if (TREE_OVERFLOW (itype))
3885                     {
3886                       error ("size of array `%s' is too large", name);
3887                       type = error_mark_node;
3888                       continue;
3889                     }
3890
3891                   if (size_varies)
3892                     {
3893                       /* We must be able to distinguish the
3894                          SAVE_EXPR_CONTEXT for the variably-sized type
3895                          so that we can set it correctly in
3896                          set_save_expr_context.  The convention is
3897                          that all SAVE_EXPRs that need to be reset
3898                          have NULL_TREE for their SAVE_EXPR_CONTEXT.  */
3899                       tree cfd = current_function_decl;
3900                       if (decl_context == PARM)
3901                         current_function_decl = NULL_TREE;
3902                       itype = variable_size (itype);
3903                       if (decl_context == PARM)
3904                         current_function_decl = cfd;
3905                     }
3906                   itype = build_index_type (itype);
3907                 }
3908             }
3909           else if (decl_context == FIELD)
3910             {
3911               if (pedantic && !flag_isoc99 && !in_system_header)
3912                 pedwarn ("ISO C90 does not support flexible array members");
3913
3914               /* ISO C99 Flexible array members are effectively identical
3915                  to GCC's zero-length array extension.  */
3916               itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
3917             }
3918
3919           /* If pedantic, complain about arrays of incomplete types.  */
3920
3921           if (pedantic && !COMPLETE_TYPE_P (type))
3922             pedwarn ("array type has incomplete element type");
3923
3924           /* Build the array type itself, then merge any constancy or
3925              volatility into the target type.  We must do it in this order
3926              to ensure that the TYPE_MAIN_VARIANT field of the array type
3927              is set correctly.  */
3928
3929           type = build_array_type (type, itype);
3930           if (type_quals)
3931             type = c_build_qualified_type (type, type_quals);
3932
3933           if (size_varies)
3934             C_TYPE_VARIABLE_SIZE (type) = 1;
3935
3936           /* The GCC extension for zero-length arrays differs from
3937              ISO flexible array members in that sizeof yields zero.  */
3938           if (size && integer_zerop (size))
3939             {
3940               layout_type (type);
3941               TYPE_SIZE (type) = bitsize_zero_node;
3942               TYPE_SIZE_UNIT (type) = size_zero_node;
3943             }
3944           if (decl_context != PARM
3945               && (array_ptr_quals != NULL_TREE || array_parm_static))
3946             {
3947               error ("static or type qualifiers in non-parameter array declarator");
3948               array_ptr_quals = NULL_TREE;
3949               array_parm_static = 0;
3950             }
3951         }
3952       else if (TREE_CODE (declarator) == CALL_EXPR)
3953         {
3954           tree arg_types;
3955
3956           /* Declaring a function type.
3957              Make sure we have a valid type for the function to return.  */
3958           if (type == error_mark_node)
3959             continue;
3960
3961           size_varies = 0;
3962
3963           /* Warn about some types functions can't return.  */
3964
3965           if (TREE_CODE (type) == FUNCTION_TYPE)
3966             {
3967               error ("`%s' declared as function returning a function", name);
3968               type = integer_type_node;
3969             }
3970           if (TREE_CODE (type) == ARRAY_TYPE)
3971             {
3972               error ("`%s' declared as function returning an array", name);
3973               type = integer_type_node;
3974             }
3975
3976           /* Construct the function type and go to the next
3977              inner layer of declarator.  */
3978
3979           arg_types = grokparms (TREE_OPERAND (declarator, 1),
3980                                  funcdef_flag
3981                                  /* Say it's a definition
3982                                     only for the CALL_EXPR
3983                                     closest to the identifier.  */
3984                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
3985           /* Type qualifiers before the return type of the function
3986              qualify the return type, not the function type.  */
3987           if (type_quals)
3988             {
3989               /* Type qualifiers on a function return type are normally
3990                  permitted by the standard but have no effect, so give a
3991                  warning at -Wextra.  Qualifiers on a void return type have
3992                  meaning as a GNU extension, and are banned on function
3993                  definitions in ISO C.  FIXME: strictly we shouldn't
3994                  pedwarn for qualified void return types except on function
3995                  definitions, but not doing so could lead to the undesirable
3996                  state of a "volatile void" function return type not being
3997                  warned about, and a use of the function being compiled
3998                  with GNU semantics, with no diagnostics under -pedantic.  */
3999               if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4000                 pedwarn ("ISO C forbids qualified void function return type");
4001               else if (extra_warnings
4002                        && !(VOID_TYPE_P (type)
4003                             && type_quals == TYPE_QUAL_VOLATILE))
4004                 warning ("type qualifiers ignored on function return type");
4005
4006               type = c_build_qualified_type (type, type_quals);
4007             }
4008           type_quals = TYPE_UNQUALIFIED;
4009
4010           type = build_function_type (type, arg_types);
4011           declarator = TREE_OPERAND (declarator, 0);
4012
4013           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4014              the formal parameter list of this FUNCTION_TYPE to point to
4015              the FUNCTION_TYPE node itself.  */
4016
4017           {
4018             tree link;
4019
4020             for (link = last_function_parm_tags;
4021                  link;
4022                  link = TREE_CHAIN (link))
4023               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4024           }
4025         }
4026       else if (TREE_CODE (declarator) == INDIRECT_REF)
4027         {
4028           /* Merge any constancy or volatility into the target type
4029              for the pointer.  */
4030
4031           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4032               && type_quals)
4033             pedwarn ("ISO C forbids qualified function types");
4034           if (type_quals)
4035             type = c_build_qualified_type (type, type_quals);
4036           type_quals = TYPE_UNQUALIFIED;
4037           size_varies = 0;
4038
4039           type = build_pointer_type (type);
4040
4041           /* Process a list of type modifier keywords
4042              (such as const or volatile) that were given inside the `*'.  */
4043
4044           if (TREE_TYPE (declarator))
4045             {
4046               tree typemodlist;
4047               int erred = 0;
4048
4049               constp = 0;
4050               volatilep = 0;
4051               restrictp = 0;
4052               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4053                    typemodlist = TREE_CHAIN (typemodlist))
4054                 {
4055                   tree qualifier = TREE_VALUE (typemodlist);
4056
4057                   if (C_IS_RESERVED_WORD (qualifier))
4058                     {
4059                       if (C_RID_CODE (qualifier) == RID_CONST)
4060                         constp++;
4061                       else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4062                         volatilep++;
4063                       else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4064                         restrictp++;
4065                       else
4066                         erred++;
4067                     }
4068                   else
4069                     erred++;
4070                 }
4071
4072               if (erred)
4073                 error ("invalid type modifier within pointer declarator");
4074               if (constp > 1 && ! flag_isoc99)
4075                 pedwarn ("duplicate `const'");
4076               if (volatilep > 1 && ! flag_isoc99)
4077                 pedwarn ("duplicate `volatile'");
4078               if (restrictp > 1 && ! flag_isoc99)
4079                 pedwarn ("duplicate `restrict'");
4080
4081               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4082                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4083                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4084             }
4085
4086           declarator = TREE_OPERAND (declarator, 0);
4087         }
4088       else
4089         abort ();
4090
4091     }
4092
4093   /* Now TYPE has the actual type.  */
4094
4095   /* Did array size calculations overflow?  */
4096
4097   if (TREE_CODE (type) == ARRAY_TYPE
4098       && COMPLETE_TYPE_P (type)
4099       && TREE_OVERFLOW (TYPE_SIZE (type)))
4100     {
4101       error ("size of array `%s' is too large", name);
4102       /* If we proceed with the array type as it is, we'll eventually
4103          crash in tree_low_cst().  */
4104       type = error_mark_node;
4105     }
4106
4107   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4108
4109   if (specbits & (1 << (int) RID_TYPEDEF))
4110     {
4111       tree decl;
4112       /* Note that the grammar rejects storage classes
4113          in typenames, fields or parameters */
4114       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4115           && type_quals)
4116         pedwarn ("ISO C forbids qualified function types");
4117       if (type_quals)
4118         type = c_build_qualified_type (type, type_quals);
4119       decl = build_decl (TYPE_DECL, declarator, type);
4120       if ((specbits & (1 << (int) RID_SIGNED))
4121           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4122         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4123       decl_attributes (&decl, returned_attrs, 0);
4124       return decl;
4125     }
4126
4127   /* Detect the case of an array type of unspecified size
4128      which came, as such, direct from a typedef name.
4129      We must copy the type, so that each identifier gets
4130      a distinct type, so that each identifier's size can be
4131      controlled separately by its own initializer.  */
4132
4133   if (type != 0 && typedef_type != 0
4134       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4135       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4136     {
4137       type = build_array_type (TREE_TYPE (type), 0);
4138       if (size_varies)
4139         C_TYPE_VARIABLE_SIZE (type) = 1;
4140     }
4141
4142   /* If this is a type name (such as, in a cast or sizeof),
4143      compute the type and return it now.  */
4144
4145   if (decl_context == TYPENAME)
4146     {
4147       /* Note that the grammar rejects storage classes
4148          in typenames, fields or parameters */
4149       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4150           && type_quals)
4151         pedwarn ("ISO C forbids const or volatile function types");
4152       if (type_quals)
4153         type = c_build_qualified_type (type, type_quals);
4154       decl_attributes (&type, returned_attrs, 0);
4155       return type;
4156     }
4157
4158   /* Aside from typedefs and type names (handle above),
4159      `void' at top level (not within pointer)
4160      is allowed only in public variables.
4161      We don't complain about parms either, but that is because
4162      a better error message can be made later.  */
4163
4164   if (VOID_TYPE_P (type) && decl_context != PARM
4165       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4166             && ((specbits & (1 << (int) RID_EXTERN))
4167                 || (current_scope == global_scope
4168                     && !(specbits
4169                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4170     {
4171       error ("variable or field `%s' declared void", name);
4172       type = integer_type_node;
4173     }
4174
4175   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4176      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4177
4178   {
4179     tree decl;
4180
4181     if (decl_context == PARM)
4182       {
4183         tree type_as_written;
4184         tree promoted_type;
4185
4186         /* A parameter declared as an array of T is really a pointer to T.
4187            One declared as a function is really a pointer to a function.  */
4188
4189         if (TREE_CODE (type) == ARRAY_TYPE)
4190           {
4191             /* Transfer const-ness of array into that of type pointed to.  */
4192             type = TREE_TYPE (type);
4193             if (type_quals)
4194               type = c_build_qualified_type (type, type_quals);
4195             type = build_pointer_type (type);
4196             type_quals = TYPE_UNQUALIFIED;
4197             if (array_ptr_quals)
4198               {
4199                 tree new_ptr_quals, new_ptr_attrs;
4200                 int erred = 0;
4201                 split_specs_attrs (array_ptr_quals, &new_ptr_quals, &new_ptr_attrs);
4202                 /* We don't yet implement attributes in this context.  */
4203                 if (new_ptr_attrs != NULL_TREE)
4204                   warning ("attributes in parameter array declarator ignored");
4205
4206                 constp = 0;
4207                 volatilep = 0;
4208                 restrictp = 0;
4209                 for (; new_ptr_quals; new_ptr_quals = TREE_CHAIN (new_ptr_quals))
4210                   {
4211                     tree qualifier = TREE_VALUE (new_ptr_quals);
4212
4213                     if (C_IS_RESERVED_WORD (qualifier))
4214                       {
4215                         if (C_RID_CODE (qualifier) == RID_CONST)
4216                           constp++;
4217                         else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4218                           volatilep++;
4219                         else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4220                           restrictp++;
4221                         else
4222                           erred++;
4223                       }
4224                     else
4225                       erred++;
4226                   }
4227
4228                 if (erred)
4229                   error ("invalid type modifier within array declarator");
4230
4231                 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4232                               | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4233                               | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4234               }
4235             size_varies = 0;
4236           }
4237         else if (TREE_CODE (type) == FUNCTION_TYPE)
4238           {
4239             if (pedantic && type_quals)
4240               pedwarn ("ISO C forbids qualified function types");
4241             if (type_quals)
4242               type = c_build_qualified_type (type, type_quals);
4243             type = build_pointer_type (type);
4244             type_quals = TYPE_UNQUALIFIED;
4245           }
4246         else if (type_quals)
4247           type = c_build_qualified_type (type, type_quals);
4248
4249         type_as_written = type;
4250
4251         decl = build_decl (PARM_DECL, declarator, type);
4252         if (size_varies)
4253           C_DECL_VARIABLE_SIZE (decl) = 1;
4254
4255         /* Compute the type actually passed in the parmlist,
4256            for the case where there is no prototype.
4257            (For example, shorts and chars are passed as ints.)
4258            When there is a prototype, this is overridden later.  */
4259
4260         if (type == error_mark_node)
4261           promoted_type = type;
4262         else
4263           promoted_type = c_type_promotes_to (type);
4264
4265         DECL_ARG_TYPE (decl) = promoted_type;
4266         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4267       }
4268     else if (decl_context == FIELD)
4269       {
4270         /* Structure field.  It may not be a function.  */
4271
4272         if (TREE_CODE (type) == FUNCTION_TYPE)
4273           {
4274             error ("field `%s' declared as a function", name);
4275             type = build_pointer_type (type);
4276           }
4277         else if (TREE_CODE (type) != ERROR_MARK
4278                  && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4279           {
4280             error ("field `%s' has incomplete type", name);
4281             type = error_mark_node;
4282           }
4283         /* Move type qualifiers down to element of an array.  */
4284         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4285           {
4286             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4287                                                              type_quals),
4288                                      TYPE_DOMAIN (type));
4289           }
4290         decl = build_decl (FIELD_DECL, declarator, type);
4291         DECL_NONADDRESSABLE_P (decl) = bitfield;
4292
4293         if (size_varies)
4294           C_DECL_VARIABLE_SIZE (decl) = 1;
4295       }
4296     else if (TREE_CODE (type) == FUNCTION_TYPE)
4297       {
4298         /* Every function declaration is "external"
4299            except for those which are inside a function body
4300            in which `auto' is used.
4301            That is a case not specified by ANSI C,
4302            and we use it for forward declarations for nested functions.  */
4303         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4304                           || current_scope == global_scope);
4305
4306         if (specbits & (1 << (int) RID_AUTO)
4307             && (pedantic || current_scope == global_scope))
4308           pedwarn ("invalid storage class for function `%s'", name);
4309         if (specbits & (1 << (int) RID_REGISTER))
4310           error ("invalid storage class for function `%s'", name);
4311         if (specbits & (1 << (int) RID_THREAD))
4312           error ("invalid storage class for function `%s'", name);
4313         /* Function declaration not at file scope.
4314            Storage classes other than `extern' are not allowed
4315            and `extern' makes no difference.  */
4316         if (current_scope != global_scope
4317             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4318             && pedantic)
4319           pedwarn ("invalid storage class for function `%s'", name);
4320
4321         decl = build_decl (FUNCTION_DECL, declarator, type);
4322         decl = build_decl_attribute_variant (decl, decl_attr);
4323
4324         DECL_LANG_SPECIFIC (decl)
4325           = ggc_alloc_cleared (sizeof (struct lang_decl));
4326
4327         if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4328           pedwarn ("ISO C forbids qualified function types");
4329
4330         /* GNU C interprets a `volatile void' return type to indicate
4331            that the function does not return.  */
4332         if ((type_quals & TYPE_QUAL_VOLATILE)
4333             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4334           warning ("`noreturn' function returns non-void value");
4335
4336         if (extern_ref)
4337           DECL_EXTERNAL (decl) = 1;
4338         /* Record absence of global scope for `static' or `auto'.  */
4339         TREE_PUBLIC (decl)
4340           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4341
4342         if (defaulted_int)
4343           C_FUNCTION_IMPLICIT_INT (decl) = 1;
4344
4345         /* Record presence of `inline', if it is reasonable.  */
4346         if (MAIN_NAME_P (declarator))
4347           {
4348             if (inlinep)
4349               warning ("cannot inline function `main'");
4350           }
4351         else if (inlinep)
4352           {
4353             /* Assume that otherwise the function can be inlined.  */
4354             DECL_DECLARED_INLINE_P (decl) = 1;
4355
4356             /* Do not mark bare declarations as DECL_INLINE.  Doing so
4357                in the presence of multiple declarations can result in
4358                the abstract origin pointing between the declarations,
4359                which will confuse dwarf2out.  */
4360             if (initialized)
4361               {
4362                 DECL_INLINE (decl) = 1;
4363                 if (specbits & (1 << (int) RID_EXTERN))
4364                   current_extern_inline = 1;
4365               }
4366           }
4367         /* If -finline-functions, assume it can be inlined.  This does
4368            two things: let the function be deferred until it is actually
4369            needed, and let dwarf2 know that the function is inlinable.  */
4370         else if (flag_inline_trees == 2 && initialized)
4371           {
4372             if (!DECL_INLINE (decl))
4373                 DID_INLINE_FUNC (decl) = 1;
4374             DECL_INLINE (decl) = 1;
4375             DECL_DECLARED_INLINE_P (decl) = 0;
4376           }
4377       }
4378     else
4379       {
4380         /* It's a variable.  */
4381         /* An uninitialized decl with `extern' is a reference.  */
4382         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4383
4384         /* Move type qualifiers down to element of an array.  */
4385         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4386           {
4387             int saved_align = TYPE_ALIGN(type);
4388             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4389                                                              type_quals),
4390                                      TYPE_DOMAIN (type));
4391             TYPE_ALIGN (type) = saved_align;
4392           }
4393         else if (type_quals)
4394           type = c_build_qualified_type (type, type_quals);
4395
4396         /* It is invalid to create an `extern' declaration for a
4397            variable if there is a global declaration that is
4398            `static'.  */
4399         if (extern_ref && current_scope != global_scope)
4400           {
4401             tree global_decl;
4402
4403             global_decl = identifier_global_value (declarator);
4404             if (global_decl
4405                 && TREE_CODE (global_decl) == VAR_DECL
4406                 && !TREE_PUBLIC (global_decl))
4407               error ("variable previously declared `static' redeclared "
4408                      "`extern'");
4409           }
4410
4411         decl = build_decl (VAR_DECL, declarator, type);
4412         if (size_varies)
4413           C_DECL_VARIABLE_SIZE (decl) = 1;
4414
4415         if (inlinep)
4416           pedwarn ("%Hvariable '%D' declared `inline'",
4417                    &DECL_SOURCE_LOCATION (decl), decl);
4418
4419         DECL_EXTERNAL (decl) = extern_ref;
4420
4421         /* At file scope, the presence of a `static' or `register' storage
4422            class specifier, or the absence of all storage class specifiers
4423            makes this declaration a definition (perhaps tentative).  Also,
4424            the absence of both `static' and `register' makes it public.  */
4425         if (current_scope == global_scope)
4426           {
4427             TREE_PUBLIC (decl) = !(specbits & ((1 << (int) RID_STATIC)
4428                                                | (1 << (int) RID_REGISTER)));
4429             TREE_STATIC (decl) = !extern_ref;
4430           }
4431         /* Not at file scope, only `static' makes a static definition.  */
4432         else
4433           {
4434             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4435             TREE_PUBLIC (decl) = extern_ref;
4436           }
4437
4438         if (specbits & 1 << (int) RID_THREAD)
4439           {
4440             if (targetm.have_tls)
4441               DECL_THREAD_LOCAL (decl) = 1;
4442             else
4443               /* A mere warning is sure to result in improper semantics
4444                  at runtime.  Don't bother to allow this to compile.  */
4445               error ("thread-local storage not supported for this target");
4446           }
4447       }
4448
4449     /* Record `register' declaration for warnings on &
4450        and in case doing stupid register allocation.  */
4451
4452     if (specbits & (1 << (int) RID_REGISTER))
4453       DECL_REGISTER (decl) = 1;
4454
4455     /* Record constancy and volatility.  */
4456     c_apply_type_quals_to_decl (type_quals, decl);
4457
4458     /* If a type has volatile components, it should be stored in memory.
4459        Otherwise, the fact that those components are volatile
4460        will be ignored, and would even crash the compiler.  */
4461     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4462       c_mark_addressable (decl);
4463
4464 #ifdef ENABLE_CHECKING
4465   /* This is the earliest point at which we might know the assembler
4466      name of a variable.  Thus, if it's known before this, die horribly.  */
4467   if (DECL_ASSEMBLER_NAME_SET_P (decl))
4468     abort ();
4469 #endif
4470
4471     decl_attributes (&decl, returned_attrs, 0);
4472
4473     return decl;
4474   }
4475 }
4476 \f
4477 /* Decode the parameter-list info for a function type or function definition.
4478    The argument is the value returned by `get_parm_info' (or made in parse.y
4479    if there is an identifier list instead of a parameter decl list).
4480    These two functions are separate because when a function returns
4481    or receives functions then each is called multiple times but the order
4482    of calls is different.  The last call to `grokparms' is always the one
4483    that contains the formal parameter names of a function definition.
4484
4485    Store in `last_function_parms' a chain of the decls of parms.
4486    Also store in `last_function_parm_tags' a chain of the struct, union,
4487    and enum tags declared among the parms.
4488
4489    Return a list of arg types to use in the FUNCTION_TYPE for this function.
4490
4491    FUNCDEF_FLAG is nonzero for a function definition, 0 for
4492    a mere declaration.  A nonempty identifier-list gets an error message
4493    when FUNCDEF_FLAG is zero.  */
4494
4495 static tree
4496 grokparms (tree parms_info, int funcdef_flag)
4497 {
4498   tree first_parm = TREE_CHAIN (parms_info);
4499
4500   last_function_parms = TREE_PURPOSE (parms_info);
4501   last_function_parm_tags = TREE_VALUE (parms_info);
4502
4503   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
4504       && !in_system_header)
4505     warning ("function declaration isn't a prototype");
4506
4507   if (first_parm != 0
4508       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4509     {
4510       if (! funcdef_flag)
4511         pedwarn ("parameter names (without types) in function declaration");
4512
4513       last_function_parms = first_parm;
4514       return 0;
4515     }
4516   else
4517     {
4518       tree parm;
4519       tree typelt;
4520       /* If the arg types are incomplete in a declaration,
4521          they must include undefined tags.
4522          These tags can never be defined in the scope of the declaration,
4523          so the types can never be completed,
4524          and no call can be compiled successfully.  */
4525       for (parm = last_function_parms, typelt = first_parm;
4526            parm;
4527            parm = TREE_CHAIN (parm))
4528         /* Skip over any enumeration constants declared here.  */
4529         if (TREE_CODE (parm) == PARM_DECL)
4530           {
4531             /* Barf if the parameter itself has an incomplete type.  */
4532             tree type = TREE_VALUE (typelt);
4533             if (type == error_mark_node)
4534               continue;
4535             if (!COMPLETE_TYPE_P (type))
4536               {
4537                 if (funcdef_flag && DECL_NAME (parm) != 0)
4538                   error ("parameter `%s' has incomplete type",
4539                          IDENTIFIER_POINTER (DECL_NAME (parm)));
4540                 else
4541                   warning ("parameter has incomplete type");
4542                 if (funcdef_flag)
4543                   {
4544                     TREE_VALUE (typelt) = error_mark_node;
4545                     TREE_TYPE (parm) = error_mark_node;
4546                   }
4547               }
4548             typelt = TREE_CHAIN (typelt);
4549           }
4550
4551       return first_parm;
4552     }
4553 }
4554
4555 /* Return a tree_list node with info on a parameter list just parsed.
4556    The TREE_PURPOSE is a chain of decls of those parms.
4557    The TREE_VALUE is a list of structure, union and enum tags defined.
4558    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4559    This tree_list node is later fed to `grokparms'.
4560
4561    VOID_AT_END nonzero means append `void' to the end of the type-list.
4562    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
4563
4564 tree
4565 get_parm_info (int void_at_end)
4566 {
4567   tree decl, t;
4568   tree types = 0;
4569   int erred = 0;
4570   tree tags = gettags ();
4571   tree parms = getdecls ();
4572   tree new_parms = 0;
4573   tree order = current_scope->parm_order;
4574
4575   /* Just `void' (and no ellipsis) is special.  There are really no parms.
4576      But if the `void' is qualified (by `const' or `volatile') or has a
4577      storage class specifier (`register'), then the behavior is undefined;
4578      by not counting it as the special case of `void' we will cause an
4579      error later.  Typedefs for `void' are OK (see DR#157).  */
4580   if (void_at_end && parms != 0
4581       && TREE_CHAIN (parms) == 0
4582       && VOID_TYPE_P (TREE_TYPE (parms))
4583       && ! TREE_THIS_VOLATILE (parms)
4584       && ! TREE_READONLY (parms)
4585       && ! DECL_REGISTER (parms)
4586       && DECL_NAME (parms) == 0)
4587     {
4588       parms = NULL_TREE;
4589       storedecls (NULL_TREE);
4590       return tree_cons (NULL_TREE, NULL_TREE,
4591                         tree_cons (NULL_TREE, void_type_node, NULL_TREE));
4592     }
4593
4594   /* Extract enumerator values and other non-parms declared with the parms.
4595      Likewise any forward parm decls that didn't have real parm decls.  */
4596   for (decl = parms; decl;)
4597     {
4598       tree next = TREE_CHAIN (decl);
4599
4600       if (TREE_CODE (decl) != PARM_DECL)
4601         {
4602           TREE_CHAIN (decl) = new_parms;
4603           new_parms = decl;
4604         }
4605       else if (TREE_ASM_WRITTEN (decl))
4606         {
4607           error ("%Hparameter '%D' has just a forward declaration",
4608                  &DECL_SOURCE_LOCATION (decl), decl);
4609           TREE_CHAIN (decl) = new_parms;
4610           new_parms = decl;
4611         }
4612       decl = next;
4613     }
4614
4615   /* Put the parm decls back in the order they were in in the parm list.  */
4616   for (t = order; t; t = TREE_CHAIN (t))
4617     {
4618       if (TREE_CHAIN (t))
4619         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
4620       else
4621         TREE_CHAIN (TREE_VALUE (t)) = 0;
4622     }
4623
4624   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
4625                        new_parms);
4626
4627   /* Store the parmlist in the scope structure since the old one
4628      is no longer a valid list.  (We have changed the chain pointers.)  */
4629   storedecls (new_parms);
4630
4631   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
4632     /* There may also be declarations for enumerators if an enumeration
4633        type is declared among the parms.  Ignore them here.  */
4634     if (TREE_CODE (decl) == PARM_DECL)
4635       {
4636         /* Since there is a prototype,
4637            args are passed in their declared types.  */
4638         tree type = TREE_TYPE (decl);
4639         DECL_ARG_TYPE (decl) = type;
4640         if (PROMOTE_PROTOTYPES
4641             && INTEGRAL_TYPE_P (type)
4642             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4643           DECL_ARG_TYPE (decl) = integer_type_node;
4644
4645         types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
4646         if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
4647             && DECL_NAME (decl) == 0)
4648           {
4649             error ("`void' in parameter list must be the entire list");
4650             erred = 1;
4651           }
4652       }
4653
4654   if (void_at_end)
4655     return tree_cons (new_parms, tags,
4656                       nreverse (tree_cons (NULL_TREE, void_type_node, types)));
4657
4658   return tree_cons (new_parms, tags, nreverse (types));
4659 }
4660
4661 /* At end of parameter list, warn about any struct, union or enum tags
4662    defined within.  Do so because these types cannot ever become complete.  */
4663
4664 void
4665 parmlist_tags_warning (void)
4666 {
4667   tree elt;
4668   static int already;
4669
4670   for (elt = current_scope->tags; elt; elt = TREE_CHAIN (elt))
4671     {
4672       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
4673       /* An anonymous union parm type is meaningful as a GNU extension.
4674          So don't warn for that.  */
4675       if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
4676         continue;
4677       if (TREE_PURPOSE (elt) != 0)
4678         {
4679           if (code == RECORD_TYPE)
4680             warning ("`struct %s' declared inside parameter list",
4681                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4682           else if (code == UNION_TYPE)
4683             warning ("`union %s' declared inside parameter list",
4684                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4685           else
4686             warning ("`enum %s' declared inside parameter list",
4687                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4688         }
4689       else
4690         {
4691           /* For translation these need to be separate warnings */
4692           if (code == RECORD_TYPE)
4693             warning ("anonymous struct declared inside parameter list");
4694           else if (code == UNION_TYPE)
4695             warning ("anonymous union declared inside parameter list");
4696           else
4697             warning ("anonymous enum declared inside parameter list");
4698         }
4699       if (! already)
4700         {
4701           warning ("its scope is only this definition or declaration, which is probably not what you want");
4702           already = 1;
4703         }
4704     }
4705 }
4706 \f
4707 /* Get the struct, enum or union (CODE says which) with tag NAME.
4708    Define the tag as a forward-reference if it is not defined.  */
4709
4710 tree
4711 xref_tag (enum tree_code code, tree name)
4712 {
4713   /* If a cross reference is requested, look up the type
4714      already defined for this tag and return it.  */
4715
4716   tree ref = lookup_tag (code, name, 0);
4717   /* If this is the right type of tag, return what we found.
4718      (This reference will be shadowed by shadow_tag later if appropriate.)
4719      If this is the wrong type of tag, do not return it.  If it was the
4720      wrong type in the same scope, we will have had an error
4721      message already; if in a different scope and declaring
4722      a name, pending_xref_error will give an error message; but if in a
4723      different scope and not declaring a name, this tag should
4724      shadow the previous declaration of a different type of tag, and
4725      this would not work properly if we return the reference found.
4726      (For example, with "struct foo" in an outer scope, "union foo;"
4727      must shadow that tag with a new one of union type.)  */
4728   if (ref && TREE_CODE (ref) == code)
4729     return ref;
4730
4731   /* If no such tag is yet defined, create a forward-reference node
4732      and record it as the "definition".
4733      When a real declaration of this type is found,
4734      the forward-reference will be altered into a real type.  */
4735
4736   ref = make_node (code);
4737   if (code == ENUMERAL_TYPE)
4738     {
4739       /* Give the type a default layout like unsigned int
4740          to avoid crashing if it does not get defined.  */
4741       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
4742       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
4743       TYPE_USER_ALIGN (ref) = 0;
4744       TREE_UNSIGNED (ref) = 1;
4745       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
4746       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
4747       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
4748     }
4749
4750   pushtag (name, ref);
4751
4752   return ref;
4753 }
4754 \f
4755 /* Make sure that the tag NAME is defined *in the current scope*
4756    at least as a forward reference.
4757    CODE says which kind of tag NAME ought to be.  */
4758
4759 tree
4760 start_struct (enum tree_code code, tree name)
4761 {
4762   /* If there is already a tag defined at this scope
4763      (as a forward reference), just return it.  */
4764
4765   tree ref = 0;
4766
4767   if (name != 0)
4768     ref = lookup_tag (code, name, 1);
4769   if (ref && TREE_CODE (ref) == code)
4770     {
4771       if (TYPE_FIELDS (ref))
4772         {
4773           if (code == UNION_TYPE)
4774             error ("redefinition of `union %s'", IDENTIFIER_POINTER (name));
4775           else
4776             error ("redefinition of `struct %s'", IDENTIFIER_POINTER (name));
4777         }
4778     }
4779   else
4780     {
4781       /* Otherwise create a forward-reference just so the tag is in scope.  */
4782
4783       ref = make_node (code);
4784       pushtag (name, ref);
4785     }
4786
4787   C_TYPE_BEING_DEFINED (ref) = 1;
4788   TYPE_PACKED (ref) = flag_pack_struct;
4789   return ref;
4790 }
4791
4792 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
4793    of a structure component, returning a FIELD_DECL node.
4794    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
4795
4796    This is done during the parsing of the struct declaration.
4797    The FIELD_DECL nodes are chained together and the lot of them
4798    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
4799
4800 tree
4801 grokfield (tree declarator, tree declspecs, tree width)
4802 {
4803   tree value;
4804
4805   if (declarator == NULL_TREE && width == NULL_TREE)
4806     {
4807       /* This is an unnamed decl.
4808
4809          If we have something of the form "union { list } ;" then this
4810          is the anonymous union extension.  Similarly for struct.
4811
4812          If this is something of the form "struct foo;", then
4813            If MS extensions are enabled, this is handled as an
4814              anonymous struct.
4815            Otherwise this is a forward declaration of a structure tag.
4816
4817          If this is something of the form "foo;" and foo is a TYPE_DECL, then
4818            If MS extensions are enabled and foo names a structure, then
4819              again this is an anonymous struct.
4820            Otherwise this is an error.
4821
4822          Oh what a horrid tangled web we weave.  I wonder if MS consciously
4823          took this from Plan 9 or if it was an accident of implementation
4824          that took root before someone noticed the bug...  */
4825
4826       tree type = TREE_VALUE (declspecs);
4827
4828       if (flag_ms_extensions && TREE_CODE (type) == TYPE_DECL)
4829         type = TREE_TYPE (type);
4830       if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE)
4831         {
4832           if (flag_ms_extensions)
4833             ; /* ok */
4834           else if (flag_iso)
4835             goto warn_unnamed_field;
4836           else if (TYPE_NAME (type) == NULL)
4837             ; /* ok */
4838           else
4839             goto warn_unnamed_field;
4840         }
4841       else
4842         {
4843         warn_unnamed_field:
4844           warning ("declaration does not declare anything");
4845           return NULL_TREE;
4846         }
4847     }
4848
4849   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
4850
4851   finish_decl (value, NULL_TREE, NULL_TREE);
4852   DECL_INITIAL (value) = width;
4853
4854   if (c_dialect_objc ())
4855     objc_check_decl (value);
4856   return value;
4857 }
4858 \f
4859 /* Generate an error for any duplicate field names in FIELDLIST.  Munge
4860    the list such that this does not present a problem later.  */
4861
4862 static void
4863 detect_field_duplicates (tree fieldlist)
4864 {
4865   tree x, y;
4866   int timeout = 10;
4867
4868   /* First, see if there are more than "a few" fields.
4869      This is trivially true if there are zero or one fields.  */
4870   if (!fieldlist)
4871     return;
4872   x = TREE_CHAIN (fieldlist);
4873   if (!x)
4874     return;
4875   do {
4876     timeout--;
4877     x = TREE_CHAIN (x);
4878   } while (timeout > 0 && x);
4879
4880   /* If there were "few" fields, avoid the overhead of allocating
4881      a hash table.  Instead just do the nested traversal thing.  */
4882   if (timeout > 0)
4883     {
4884       for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
4885         if (DECL_NAME (x))
4886           {
4887             for (y = fieldlist; y != x; y = TREE_CHAIN (y))
4888               if (DECL_NAME (y) == DECL_NAME (x))
4889                 {
4890                   error ("%Hduplicate member '%D'",
4891                          &DECL_SOURCE_LOCATION (x), x);
4892                   DECL_NAME (x) = NULL_TREE;
4893                 }
4894           }
4895     }
4896   else
4897     {
4898       htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
4899       void **slot;
4900
4901       for (x = fieldlist; x ; x = TREE_CHAIN (x))
4902         if ((y = DECL_NAME (x)) != 0)
4903           {
4904             slot = htab_find_slot (htab, y, INSERT);
4905             if (*slot)
4906               {
4907                 error ("%Hduplicate member '%D'",
4908                        &DECL_SOURCE_LOCATION (x), x);
4909                 DECL_NAME (x) = NULL_TREE;
4910               }
4911             *slot = y;
4912           }
4913
4914       htab_delete (htab);
4915     }
4916 }
4917
4918 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
4919    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
4920    ATTRIBUTES are attributes to be applied to the structure.  */
4921
4922 tree
4923 finish_struct (tree t, tree fieldlist, tree attributes)
4924 {
4925   tree x;
4926   int toplevel = global_scope == current_scope;
4927   int saw_named_field;
4928
4929   /* If this type was previously laid out as a forward reference,
4930      make sure we lay it out again.  */
4931
4932   TYPE_SIZE (t) = 0;
4933
4934   decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
4935
4936   /* Nameless union parm types are useful as GCC extension.  */
4937   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
4938     /* Otherwise, warn about any struct or union def. in parmlist.  */
4939     if (in_parm_level_p ())
4940       {
4941         if (pedantic)
4942           pedwarn ("%s defined inside parms",
4943                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
4944         else
4945           warning ("%s defined inside parms",
4946                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
4947       }
4948
4949   if (pedantic)
4950     {
4951       for (x = fieldlist; x; x = TREE_CHAIN (x))
4952         if (DECL_NAME (x) != 0)
4953           break;
4954
4955       if (x == 0)
4956         pedwarn ("%s has no %s",
4957                  TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
4958                  fieldlist ? _("named members") : _("members"));
4959     }
4960
4961   /* Install struct as DECL_CONTEXT of each field decl.
4962      Also process specified field sizes,m which is found in the DECL_INITIAL.
4963      Store 0 there, except for ": 0" fields (so we can find them
4964      and delete them, below).  */
4965
4966   saw_named_field = 0;
4967   for (x = fieldlist; x; x = TREE_CHAIN (x))
4968     {
4969       DECL_CONTEXT (x) = t;
4970       DECL_PACKED (x) |= TYPE_PACKED (t);
4971
4972       /* If any field is const, the structure type is pseudo-const.  */
4973       if (TREE_READONLY (x))
4974         C_TYPE_FIELDS_READONLY (t) = 1;
4975       else
4976         {
4977           /* A field that is pseudo-const makes the structure likewise.  */
4978           tree t1 = TREE_TYPE (x);
4979           while (TREE_CODE (t1) == ARRAY_TYPE)
4980             t1 = TREE_TYPE (t1);
4981           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
4982               && C_TYPE_FIELDS_READONLY (t1))
4983             C_TYPE_FIELDS_READONLY (t) = 1;
4984         }
4985
4986       /* Any field that is volatile means variables of this type must be
4987          treated in some ways as volatile.  */
4988       if (TREE_THIS_VOLATILE (x))
4989         C_TYPE_FIELDS_VOLATILE (t) = 1;
4990
4991       /* Any field of nominal variable size implies structure is too.  */
4992       if (C_DECL_VARIABLE_SIZE (x))
4993         C_TYPE_VARIABLE_SIZE (t) = 1;
4994
4995       /* Detect invalid nested redefinition.  */
4996       if (TREE_TYPE (x) == t)
4997         error ("nested redefinition of `%s'",
4998                IDENTIFIER_POINTER (TYPE_NAME (t)));
4999
5000       /* Detect invalid bit-field size.  */
5001       if (DECL_INITIAL (x))
5002         STRIP_NOPS (DECL_INITIAL (x));
5003       if (DECL_INITIAL (x))
5004         {
5005           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5006             constant_expression_warning (DECL_INITIAL (x));
5007           else
5008             {
5009               error ("%Hbit-field '%D' width not an integer constant",
5010                      &DECL_SOURCE_LOCATION (x), x);
5011               DECL_INITIAL (x) = NULL;
5012             }
5013         }
5014
5015       /* Detect invalid bit-field type.  */
5016       if (DECL_INITIAL (x)
5017           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5018           && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE
5019           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5020         {
5021           error ("%Hbit-field '%D' has invalid type",
5022                  &DECL_SOURCE_LOCATION (x), x);
5023           DECL_INITIAL (x) = NULL;
5024         }
5025
5026       if (DECL_INITIAL (x) && pedantic
5027           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5028           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5029           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != boolean_type_node
5030           /* Accept an enum that's equivalent to int or unsigned int.  */
5031           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5032                && (TYPE_PRECISION (TREE_TYPE (x))
5033                    == TYPE_PRECISION (integer_type_node))))
5034         pedwarn ("%Hbit-field '%D' type invalid in ISO C",
5035                  &DECL_SOURCE_LOCATION (x), x);
5036
5037       /* Detect and ignore out of range field width and process valid
5038          field widths.  */
5039       if (DECL_INITIAL (x))
5040         {
5041           int max_width
5042             = (TYPE_MAIN_VARIANT (TREE_TYPE (x)) == boolean_type_node
5043                ? CHAR_TYPE_SIZE : TYPE_PRECISION (TREE_TYPE (x)));
5044
5045           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5046             error ("%Hnegative width in bit-field '%D'",
5047                    &DECL_SOURCE_LOCATION (x), x);
5048           else if (0 < compare_tree_int (DECL_INITIAL (x), max_width))
5049             pedwarn ("%Hwidth of '%D' exceeds its type",
5050                      &DECL_SOURCE_LOCATION (x), x);
5051           else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5052             error ("%Hzero width for bit-field '%D'",
5053                    &DECL_SOURCE_LOCATION (x), x);
5054           else
5055             {
5056               /* The test above has assured us that TREE_INT_CST_HIGH is 0.  */
5057               unsigned HOST_WIDE_INT width
5058                 = tree_low_cst (DECL_INITIAL (x), 1);
5059
5060               if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5061                   && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5062                                              TREE_UNSIGNED (TREE_TYPE (x)))
5063                       || (width
5064                           < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5065                                            TREE_UNSIGNED (TREE_TYPE (x))))))
5066                 warning ("%H'%D' is narrower than values of its type",
5067                          &DECL_SOURCE_LOCATION (x), x);
5068
5069               DECL_SIZE (x) = bitsize_int (width);
5070               DECL_BIT_FIELD (x) = 1;
5071               SET_DECL_C_BIT_FIELD (x);
5072             }
5073         }
5074
5075       DECL_INITIAL (x) = 0;
5076
5077       /* Detect flexible array member in an invalid context.  */
5078       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5079           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5080           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5081           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5082         {
5083           if (TREE_CODE (t) == UNION_TYPE)
5084             error ("%Hflexible array member in union",
5085                    &DECL_SOURCE_LOCATION (x));
5086           else if (TREE_CHAIN (x) != NULL_TREE)
5087             error ("%Hflexible array member not at end of struct",
5088                    &DECL_SOURCE_LOCATION (x));
5089           else if (! saw_named_field)
5090             error ("%Hflexible array member in otherwise empty struct",
5091                    &DECL_SOURCE_LOCATION (x));
5092         }
5093
5094       if (pedantic && TREE_CODE (t) == RECORD_TYPE
5095           && flexible_array_type_p (TREE_TYPE (x)))
5096         pedwarn ("%Hinvalid use of structure with flexible array member",
5097                  &DECL_SOURCE_LOCATION (x));
5098
5099       if (DECL_NAME (x))
5100         saw_named_field = 1;
5101     }
5102
5103   detect_field_duplicates (fieldlist);
5104
5105   /* Now we have the nearly final fieldlist.  Record it,
5106      then lay out the structure or union (including the fields).  */
5107
5108   TYPE_FIELDS (t) = fieldlist;
5109
5110   layout_type (t);
5111
5112   /* Delete all zero-width bit-fields from the fieldlist */
5113   {
5114     tree *fieldlistp = &fieldlist;
5115     while (*fieldlistp)
5116       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5117         *fieldlistp = TREE_CHAIN (*fieldlistp);
5118       else
5119         fieldlistp = &TREE_CHAIN (*fieldlistp);
5120   }
5121
5122   /* Now we have the truly final field list.
5123      Store it in this type and in the variants.  */
5124
5125   TYPE_FIELDS (t) = fieldlist;
5126
5127   /* If there are lots of fields, sort so we can look through them fast.
5128     We arbitrarily consider 16 or more elts to be "a lot".  */
5129
5130   {
5131     int len = 0;
5132
5133     for (x = fieldlist; x; x = TREE_CHAIN (x))
5134       {
5135         if (len > 15 || DECL_NAME (x) == NULL)
5136           break;
5137         len += 1;
5138       }
5139
5140     if (len > 15)
5141       {
5142         tree *field_array;
5143         struct lang_type *space;
5144         struct sorted_fields_type *space2;
5145
5146         len += list_length (x);
5147
5148         /* Use the same allocation policy here that make_node uses, to
5149           ensure that this lives as long as the rest of the struct decl.
5150           All decls in an inline function need to be saved.  */
5151
5152         space = ggc_alloc (sizeof (struct lang_type));
5153         space2 = ggc_alloc (sizeof (struct sorted_fields_type) + len * sizeof (tree));
5154
5155         len = 0;
5156         space->s = space2;
5157         field_array = &space2->elts[0];
5158         for (x = fieldlist; x; x = TREE_CHAIN (x))
5159           {
5160             field_array[len++] = x;
5161
5162             /* If there is anonymous struct or union, break out of the loop.  */
5163             if (DECL_NAME (x) == NULL)
5164               break;
5165           }
5166         /* Found no anonymous struct/union.  Add the TYPE_LANG_SPECIFIC.  */
5167         if (x == NULL)
5168           {
5169             TYPE_LANG_SPECIFIC (t) = space;
5170             TYPE_LANG_SPECIFIC (t)->s->len = len;
5171             field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
5172             qsort (field_array, len, sizeof (tree), field_decl_cmp);
5173           }
5174       }
5175   }
5176
5177   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5178     {
5179       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5180       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5181       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5182       TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5183     }
5184
5185   /* If this was supposed to be a transparent union, but we can't
5186      make it one, warn and turn off the flag.  */
5187   if (TREE_CODE (t) == UNION_TYPE
5188       && TYPE_TRANSPARENT_UNION (t)
5189       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5190     {
5191       TYPE_TRANSPARENT_UNION (t) = 0;
5192       warning ("union cannot be made transparent");
5193     }
5194
5195   /* If this structure or union completes the type of any previous
5196      variable declaration, lay it out and output its rtl.  */
5197
5198   if (current_scope->incomplete_list != NULL_TREE)
5199     {
5200       tree prev = NULL_TREE;
5201
5202       for (x = current_scope->incomplete_list; x; x = TREE_CHAIN (x))
5203         {
5204           tree decl = TREE_VALUE (x);
5205
5206           if (TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TYPE_MAIN_VARIANT (t)
5207               && TREE_CODE (decl) != TYPE_DECL)
5208             {
5209               layout_decl (decl, 0);
5210               /* This is a no-op in c-lang.c or something real in objc-act.c.  */
5211               if (c_dialect_objc ())
5212                 objc_check_decl (decl);
5213               rest_of_decl_compilation (decl, NULL, toplevel, 0);
5214               if (! toplevel)
5215                 expand_decl (decl);
5216               /* Unlink X from the incomplete list.  */
5217               if (prev)
5218                 TREE_CHAIN (prev) = TREE_CHAIN (x);
5219               else
5220                 current_scope->incomplete_list = TREE_CHAIN (x);
5221             }
5222           else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5223                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5224             {
5225               tree element = TREE_TYPE (decl);
5226               while (TREE_CODE (element) == ARRAY_TYPE)
5227                 element = TREE_TYPE (element);
5228               if (element == t)
5229                 {
5230                   layout_array_type (TREE_TYPE (decl));
5231                   if (TREE_CODE (decl) != TYPE_DECL)
5232                     {
5233                       layout_decl (decl, 0);
5234                       if (c_dialect_objc ())
5235                         objc_check_decl (decl);
5236                       rest_of_decl_compilation (decl, NULL, toplevel, 0);
5237                       if (! toplevel)
5238                         expand_decl (decl);
5239                     }
5240                   /* Unlink X from the incomplete list.  */
5241                   if (prev)
5242                     TREE_CHAIN (prev) = TREE_CHAIN (x);
5243                   else
5244                     current_scope->incomplete_list = TREE_CHAIN (x);
5245                 }
5246             }
5247         }
5248     }
5249
5250   /* Finish debugging output for this type.  */
5251   rest_of_type_compilation (t, toplevel);
5252
5253   return t;
5254 }
5255
5256 /* Lay out the type T, and its element type, and so on.  */
5257
5258 static void
5259 layout_array_type (tree t)
5260 {
5261   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5262     layout_array_type (TREE_TYPE (t));
5263   layout_type (t);
5264 }
5265 \f
5266 /* Begin compiling the definition of an enumeration type.
5267    NAME is its name (or null if anonymous).
5268    Returns the type object, as yet incomplete.
5269    Also records info about it so that build_enumerator
5270    may be used to declare the individual values as they are read.  */
5271
5272 tree
5273 start_enum (tree name)
5274 {
5275   tree enumtype = 0;
5276
5277   /* If this is the real definition for a previous forward reference,
5278      fill in the contents in the same object that used to be the
5279      forward reference.  */
5280
5281   if (name != 0)
5282     enumtype = lookup_tag (ENUMERAL_TYPE, name, 1);
5283
5284   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5285     {
5286       enumtype = make_node (ENUMERAL_TYPE);
5287       pushtag (name, enumtype);
5288     }
5289
5290   C_TYPE_BEING_DEFINED (enumtype) = 1;
5291
5292   if (TYPE_VALUES (enumtype) != 0)
5293     {
5294       /* This enum is a named one that has been declared already.  */
5295       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5296
5297       /* Completely replace its old definition.
5298          The old enumerators remain defined, however.  */
5299       TYPE_VALUES (enumtype) = 0;
5300     }
5301
5302   enum_next_value = integer_zero_node;
5303   enum_overflow = 0;
5304
5305   if (flag_short_enums)
5306     TYPE_PACKED (enumtype) = 1;
5307
5308   return enumtype;
5309 }
5310
5311 /* After processing and defining all the values of an enumeration type,
5312    install their decls in the enumeration type and finish it off.
5313    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5314    and ATTRIBUTES are the specified attributes.
5315    Returns ENUMTYPE.  */
5316
5317 tree
5318 finish_enum (tree enumtype, tree values, tree attributes)
5319 {
5320   tree pair, tem;
5321   tree minnode = 0, maxnode = 0, enum_value_type;
5322   int precision, unsign;
5323   int toplevel = (global_scope == current_scope);
5324
5325   if (in_parm_level_p ())
5326     warning ("enum defined inside parms");
5327
5328   decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5329
5330   /* Calculate the maximum value of any enumerator in this type.  */
5331
5332   if (values == error_mark_node)
5333     minnode = maxnode = integer_zero_node;
5334   else
5335     {
5336       minnode = maxnode = TREE_VALUE (values);
5337       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5338         {
5339           tree value = TREE_VALUE (pair);
5340           if (tree_int_cst_lt (maxnode, value))
5341             maxnode = value;
5342           if (tree_int_cst_lt (value, minnode))
5343             minnode = value;
5344         }
5345     }
5346
5347   /* Construct the final type of this enumeration.  It is the same
5348      as one of the integral types - the narrowest one that fits, except
5349      that normally we only go as narrow as int - and signed iff any of
5350      the values are negative.  */
5351   unsign = (tree_int_cst_sgn (minnode) >= 0);
5352   precision = MAX (min_precision (minnode, unsign),
5353                    min_precision (maxnode, unsign));
5354   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5355     {
5356       tree narrowest = c_common_type_for_size (precision, unsign);
5357       if (narrowest == 0)
5358         {
5359           warning ("enumeration values exceed range of largest integer");
5360           narrowest = long_long_integer_type_node;
5361         }
5362
5363       precision = TYPE_PRECISION (narrowest);
5364     }
5365   else
5366     precision = TYPE_PRECISION (integer_type_node);
5367
5368   if (precision == TYPE_PRECISION (integer_type_node))
5369     enum_value_type = c_common_type_for_size (precision, 0);
5370   else
5371     enum_value_type = enumtype;
5372
5373   TYPE_MIN_VALUE (enumtype) = minnode;
5374   TYPE_MAX_VALUE (enumtype) = maxnode;
5375   TYPE_PRECISION (enumtype) = precision;
5376   TREE_UNSIGNED (enumtype) = unsign;
5377   TYPE_SIZE (enumtype) = 0;
5378   layout_type (enumtype);
5379
5380   if (values != error_mark_node)
5381     {
5382       /* Change the type of the enumerators to be the enum type.  We
5383          need to do this irrespective of the size of the enum, for
5384          proper type checking.  Replace the DECL_INITIALs of the
5385          enumerators, and the value slots of the list, with copies
5386          that have the enum type; they cannot be modified in place
5387          because they may be shared (e.g.  integer_zero_node) Finally,
5388          change the purpose slots to point to the names of the decls.  */
5389       for (pair = values; pair; pair = TREE_CHAIN (pair))
5390         {
5391           tree enu = TREE_PURPOSE (pair);
5392
5393           TREE_TYPE (enu) = enumtype;
5394
5395           /* The ISO C Standard mandates enumerators to have type int,
5396              even though the underlying type of an enum type is
5397              unspecified.  Here we convert any enumerators that fit in
5398              an int to type int, to avoid promotions to unsigned types
5399              when comparing integers with enumerators that fit in the
5400              int range.  When -pedantic is given, build_enumerator()
5401              would have already taken care of those that don't fit.  */
5402           if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5403             DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5404           else
5405             DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5406
5407           TREE_PURPOSE (pair) = DECL_NAME (enu);
5408           TREE_VALUE (pair) = DECL_INITIAL (enu);
5409         }
5410
5411       TYPE_VALUES (enumtype) = values;
5412     }
5413
5414   /* Fix up all variant types of this enum type.  */
5415   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5416     {
5417       if (tem == enumtype)
5418         continue;
5419       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5420       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5421       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5422       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5423       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5424       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5425       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5426       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5427       TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5428       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5429     }
5430
5431   /* Finish debugging output for this type.  */
5432   rest_of_type_compilation (enumtype, toplevel);
5433
5434   return enumtype;
5435 }
5436
5437 /* Build and install a CONST_DECL for one value of the
5438    current enumeration type (one that was begun with start_enum).
5439    Return a tree-list containing the CONST_DECL and its value.
5440    Assignment of sequential values by default is handled here.  */
5441
5442 tree
5443 build_enumerator (tree name, tree value)
5444 {
5445   tree decl, type;
5446
5447   /* Validate and default VALUE.  */
5448
5449   /* Remove no-op casts from the value.  */
5450   if (value)
5451     STRIP_TYPE_NOPS (value);
5452
5453   if (value != 0)
5454     {
5455       if (TREE_CODE (value) == INTEGER_CST)
5456         {
5457           value = default_conversion (value);
5458           constant_expression_warning (value);
5459         }
5460       else
5461         {
5462           error ("enumerator value for `%s' not integer constant",
5463                  IDENTIFIER_POINTER (name));
5464           value = 0;
5465         }
5466     }
5467
5468   /* Default based on previous value.  */
5469   /* It should no longer be possible to have NON_LVALUE_EXPR
5470      in the default.  */
5471   if (value == 0)
5472     {
5473       value = enum_next_value;
5474       if (enum_overflow)
5475         error ("overflow in enumeration values");
5476     }
5477
5478   if (pedantic && ! int_fits_type_p (value, integer_type_node))
5479     {
5480       pedwarn ("ISO C restricts enumerator values to range of `int'");
5481       value = convert (integer_type_node, value);
5482     }
5483
5484   /* Set basis for default for next value.  */
5485   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5486   enum_overflow = tree_int_cst_lt (enum_next_value, value);
5487
5488   /* Now create a declaration for the enum value name.  */
5489
5490   type = TREE_TYPE (value);
5491   type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5492                                       TYPE_PRECISION (integer_type_node)),
5493                                  (TYPE_PRECISION (type)
5494                                   >= TYPE_PRECISION (integer_type_node)
5495                                   && TREE_UNSIGNED (type)));
5496
5497   decl = build_decl (CONST_DECL, name, type);
5498   DECL_INITIAL (decl) = convert (type, value);
5499   pushdecl (decl);
5500
5501   return tree_cons (decl, value, NULL_TREE);
5502 }
5503
5504 \f
5505 /* Create the FUNCTION_DECL for a function definition.
5506    DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5507    the declaration; they describe the function's name and the type it returns,
5508    but twisted together in a fashion that parallels the syntax of C.
5509
5510    This function creates a binding context for the function body
5511    as well as setting up the FUNCTION_DECL in current_function_decl.
5512
5513    Returns 1 on success.  If the DECLARATOR is not suitable for a function
5514    (it defines a datum instead), we return 0, which tells
5515    yyparse to report a parse error.  */
5516
5517 int
5518 start_function (tree declspecs, tree declarator, tree attributes)
5519 {
5520   tree decl1, old_decl;
5521   tree restype;
5522   int old_immediate_size_expand = immediate_size_expand;
5523
5524   current_function_returns_value = 0;  /* Assume, until we see it does.  */
5525   current_function_returns_null = 0;
5526   current_function_returns_abnormally = 0;
5527   warn_about_return_type = 0;
5528   current_extern_inline = 0;
5529
5530   /* Don't expand any sizes in the return type of the function.  */
5531   immediate_size_expand = 0;
5532
5533   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5534
5535   /* If the declarator is not suitable for a function definition,
5536      cause a syntax error.  */
5537   if (decl1 == 0)
5538     {
5539       immediate_size_expand = old_immediate_size_expand;
5540       return 0;
5541     }
5542
5543   decl_attributes (&decl1, attributes, 0);
5544
5545   if (DECL_DECLARED_INLINE_P (decl1)
5546       && DECL_UNINLINABLE (decl1)
5547       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
5548     warning ("%Hinline function '%D' given attribute noinline",
5549              &DECL_SOURCE_LOCATION (decl1), decl1);
5550
5551   announce_function (decl1);
5552
5553   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
5554     {
5555       error ("return type is an incomplete type");
5556       /* Make it return void instead.  */
5557       TREE_TYPE (decl1)
5558         = build_function_type (void_type_node,
5559                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5560     }
5561
5562   if (warn_about_return_type)
5563     pedwarn_c99 ("return type defaults to `int'");
5564
5565   /* Save the parm names or decls from this function's declarator
5566      where store_parm_decls will find them.  */
5567   current_function_parms = last_function_parms;
5568   current_function_parm_tags = last_function_parm_tags;
5569
5570   /* Make the init_value nonzero so pushdecl knows this is not tentative.
5571      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
5572   DECL_INITIAL (decl1) = error_mark_node;
5573
5574   /* If this definition isn't a prototype and we had a prototype declaration
5575      before, copy the arg type info from that prototype.
5576      But not if what we had before was a builtin function.  */
5577   old_decl = lookup_name_current_level (DECL_NAME (decl1));
5578   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5579       && !DECL_BUILT_IN (old_decl)
5580       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5581           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5582       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5583     {
5584       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5585       current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
5586     }
5587
5588   /* Optionally warn of old-fashioned def with no previous prototype.  */
5589   if (warn_strict_prototypes
5590       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5591       && C_DECL_ISNT_PROTOTYPE (old_decl))
5592     warning ("function declaration isn't a prototype");
5593   /* Optionally warn of any global def with no previous prototype.  */
5594   else if (warn_missing_prototypes
5595            && TREE_PUBLIC (decl1)
5596            && ! MAIN_NAME_P (DECL_NAME (decl1))
5597            && C_DECL_ISNT_PROTOTYPE (old_decl))
5598     warning ("%Hno previous prototype for '%D'",
5599              &DECL_SOURCE_LOCATION (decl1), decl1);
5600   /* Optionally warn of any def with no previous prototype
5601      if the function has already been used.  */
5602   else if (warn_missing_prototypes
5603            && old_decl != 0 && TREE_USED (old_decl)
5604            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
5605     warning ("%H'%D' was used with no prototype before its definition",
5606              &DECL_SOURCE_LOCATION (decl1), decl1);
5607   /* Optionally warn of any global def with no previous declaration.  */
5608   else if (warn_missing_declarations
5609            && TREE_PUBLIC (decl1)
5610            && old_decl == 0
5611            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5612     warning ("%Hno previous declaration for '%D'",
5613              &DECL_SOURCE_LOCATION (decl1), decl1);
5614   /* Optionally warn of any def with no previous declaration
5615      if the function has already been used.  */
5616   else if (warn_missing_declarations
5617            && old_decl != 0 && TREE_USED (old_decl)
5618            && C_DECL_IMPLICIT (old_decl))
5619     warning ("%H`%D' was used with no declaration before its definition",
5620              &DECL_SOURCE_LOCATION (decl1), decl1);
5621
5622   /* This is a definition, not a reference.
5623      So normally clear DECL_EXTERNAL.
5624      However, `extern inline' acts like a declaration
5625      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
5626   DECL_EXTERNAL (decl1) = current_extern_inline;
5627
5628   /* This function exists in static storage.
5629      (This does not mean `static' in the C sense!)  */
5630   TREE_STATIC (decl1) = 1;
5631
5632   /* A nested function is not global.  */
5633   if (current_function_decl != 0)
5634     TREE_PUBLIC (decl1) = 0;
5635
5636 #ifdef ENABLE_CHECKING
5637   /* This is the earliest point at which we might know the assembler
5638      name of the function.  Thus, if it's set before this, die horribly.  */
5639   if (DECL_ASSEMBLER_NAME_SET_P (decl1))
5640     abort ();
5641 #endif
5642
5643   /* If #pragma weak was used, mark the decl weak now.  */
5644   if (current_scope == global_scope)
5645     maybe_apply_pragma_weak (decl1);
5646
5647   /* Warn for unlikely, improbable, or stupid declarations of `main'.  */
5648   if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
5649     {
5650       tree args;
5651       int argct = 0;
5652       const location_t *locus = &DECL_SOURCE_LOCATION (decl1);
5653
5654       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5655           != integer_type_node)
5656         pedwarn ("%Hreturn type of '%D' is not `int'", locus, decl1);
5657
5658       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
5659            args = TREE_CHAIN (args))
5660         {
5661           tree type = args ? TREE_VALUE (args) : 0;
5662
5663           if (type == void_type_node)
5664             break;
5665
5666           ++argct;
5667           switch (argct)
5668             {
5669             case 1:
5670               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
5671                 pedwarn ("%Hfirst argument of '%D' should be `int'",
5672                          locus, decl1);
5673               break;
5674
5675             case 2:
5676               if (TREE_CODE (type) != POINTER_TYPE
5677                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5678                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5679                       != char_type_node))
5680                 pedwarn ("%Hsecond argument of '%D' should be 'char **'",
5681                          locus, decl1);
5682               break;
5683
5684             case 3:
5685               if (TREE_CODE (type) != POINTER_TYPE
5686                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5687                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5688                       != char_type_node))
5689                 pedwarn ("%Hthird argument of '%D' should probably be "
5690                          "'char **'", locus, decl1);
5691               break;
5692             }
5693         }
5694
5695       /* It is intentional that this message does not mention the third
5696          argument because it's only mentioned in an appendix of the
5697          standard.  */
5698       if (argct > 0 && (argct < 2 || argct > 3))
5699         pedwarn ("%H'%D' takes only zero or two arguments", locus, decl1);
5700
5701       if (! TREE_PUBLIC (decl1))
5702         pedwarn ("%H'%D' is normally a non-static function", locus, decl1);
5703     }
5704
5705   /* Record the decl so that the function name is defined.
5706      If we already have a decl for this name, and it is a FUNCTION_DECL,
5707      use the old decl.  */
5708
5709   current_function_decl = pushdecl (decl1);
5710
5711   pushlevel (0);
5712   declare_parm_level ();
5713
5714   make_decl_rtl (current_function_decl, NULL);
5715
5716   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
5717   /* Promote the value to int before returning it.  */
5718   if (c_promoting_integer_type_p (restype))
5719     {
5720       /* It retains unsignedness if not really getting wider.  */
5721       if (TREE_UNSIGNED (restype)
5722           && (TYPE_PRECISION (restype)
5723                   == TYPE_PRECISION (integer_type_node)))
5724         restype = unsigned_type_node;
5725       else
5726         restype = integer_type_node;
5727     }
5728   DECL_RESULT (current_function_decl)
5729     = build_decl (RESULT_DECL, NULL_TREE, restype);
5730
5731   /* If this fcn was already referenced via a block-scope `extern' decl
5732      (or an implicit decl), propagate certain information about the usage.  */
5733   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
5734     TREE_ADDRESSABLE (current_function_decl) = 1;
5735
5736   immediate_size_expand = old_immediate_size_expand;
5737
5738   start_fname_decls ();
5739
5740   return 1;
5741 }
5742 \f
5743 /* Store the parameter declarations into the current function declaration.
5744    This is called after parsing the parameter declarations, before
5745    digesting the body of the function.
5746
5747    For an old-style definition, modify the function's type
5748    to specify at least the number of arguments.  */
5749
5750 void
5751 store_parm_decls (void)
5752 {
5753   tree fndecl = current_function_decl;
5754   tree parm;
5755
5756   /* This is either a chain of PARM_DECLs (if a prototype was used)
5757      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
5758   tree specparms = current_function_parms;
5759
5760   /* This is a list of types declared among parms in a prototype.  */
5761   tree parmtags = current_function_parm_tags;
5762
5763   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
5764   tree parmdecls = getdecls ();
5765
5766   /* This is a chain of any other decls that came in among the parm
5767      declarations.  If a parm is declared with  enum {foo, bar} x;
5768      then CONST_DECLs for foo and bar are put here.  */
5769   tree nonparms = 0;
5770
5771   /* The function containing FNDECL, if any.  */
5772   tree context = decl_function_context (fndecl);
5773
5774   /* Nonzero if this definition is written with a prototype.  */
5775   int prototype = 0;
5776
5777   bool saved_warn_shadow = warn_shadow;
5778
5779   /* Don't re-emit shadow warnings.  */
5780   warn_shadow = false;
5781
5782   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
5783     {
5784       /* This case is when the function was defined with an ANSI prototype.
5785          The parms already have decls, so we need not do anything here
5786          except record them as in effect
5787          and complain if any redundant old-style parm decls were written.  */
5788
5789       tree next;
5790       tree others = 0;
5791
5792       prototype = 1;
5793
5794       if (parmdecls != 0)
5795         {
5796           tree decl, link;
5797
5798           error ("%Hparm types given both in parmlist and separately",
5799                  &DECL_SOURCE_LOCATION (fndecl));
5800           /* Get rid of the erroneous decls; don't keep them on
5801              the list of parms, since they might not be PARM_DECLs.  */
5802           for (decl = current_scope->names;
5803                decl; decl = TREE_CHAIN (decl))
5804             if (DECL_NAME (decl))
5805               IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)) = 0;
5806           for (link = current_scope->shadowed;
5807                link; link = TREE_CHAIN (link))
5808             IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
5809           current_scope->names = 0;
5810           current_scope->shadowed = 0;
5811         }
5812
5813       specparms = nreverse (specparms);
5814       for (parm = specparms; parm; parm = next)
5815         {
5816           const location_t *locus = &DECL_SOURCE_LOCATION (parm);
5817           next = TREE_CHAIN (parm);
5818           if (TREE_CODE (parm) == PARM_DECL)
5819             {
5820               if (DECL_NAME (parm) == 0)
5821                 error ("%Hparameter name omitted", locus);
5822               else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
5823                        && VOID_TYPE_P (TREE_TYPE (parm)))
5824                 {
5825                   error ("%Hparameter '%D' declared void", locus, parm);
5826                   /* Change the type to error_mark_node so this parameter
5827                      will be ignored by assign_parms.  */
5828                   TREE_TYPE (parm) = error_mark_node;
5829                 }
5830               pushdecl (parm);
5831             }
5832           else
5833             {
5834               /* If we find an enum constant or a type tag,
5835                  put it aside for the moment.  */
5836               TREE_CHAIN (parm) = 0;
5837               others = chainon (others, parm);
5838             }
5839         }
5840
5841       /* Get the decls in their original chain order
5842          and record in the function.  */
5843       DECL_ARGUMENTS (fndecl) = getdecls ();
5844
5845       /* Now pushdecl the enum constants.  */
5846       for (parm = others; parm; parm = next)
5847         {
5848           next = TREE_CHAIN (parm);
5849           if (DECL_NAME (parm) == 0)
5850             ;
5851           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
5852             ;
5853           else if (TREE_CODE (parm) != PARM_DECL)
5854             pushdecl (parm);
5855         }
5856
5857       storetags (chainon (parmtags, gettags ()));
5858     }
5859   else
5860     {
5861       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
5862          each with a parm name as the TREE_VALUE.
5863
5864          PARMDECLS is a chain of declarations for parameters.
5865          Warning! It can also contain CONST_DECLs which are not parameters
5866          but are names of enumerators of any enum types
5867          declared among the parameters.
5868
5869          First match each formal parameter name with its declaration.
5870          Associate decls with the names and store the decls
5871          into the TREE_PURPOSE slots.  */
5872
5873       /* We use DECL_WEAK as a flag to show which parameters have been
5874          seen already since it is not used on PARM_DECL or CONST_DECL.  */
5875       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
5876         DECL_WEAK (parm) = 0;
5877
5878       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
5879         {
5880           tree tail, found = NULL;
5881
5882           if (TREE_VALUE (parm) == 0)
5883             {
5884               error ("%Hparameter name missing from parameter list",
5885                      &DECL_SOURCE_LOCATION (fndecl));
5886               TREE_PURPOSE (parm) = 0;
5887               continue;
5888             }
5889
5890           /* See if any of the parmdecls specifies this parm by name.
5891              Ignore any enumerator decls.  */
5892           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
5893             if (DECL_NAME (tail) == TREE_VALUE (parm)
5894                 && TREE_CODE (tail) == PARM_DECL)
5895               {
5896                 found = tail;
5897                 break;
5898               }
5899
5900           /* If declaration already marked, we have a duplicate name.
5901              Complain, and don't use this decl twice.  */
5902           if (found && DECL_WEAK (found))
5903             {
5904               error ("%Hmultiple parameters named '%D'",
5905                      &DECL_SOURCE_LOCATION (found), found);
5906               found = 0;
5907             }
5908
5909           /* If the declaration says "void", complain and ignore it.  */
5910           if (found && VOID_TYPE_P (TREE_TYPE (found)))
5911             {
5912               error ("%Hparameter '%D' declared void",
5913                      &DECL_SOURCE_LOCATION (found), found);
5914               TREE_TYPE (found) = integer_type_node;
5915               DECL_ARG_TYPE (found) = integer_type_node;
5916               layout_decl (found, 0);
5917             }
5918
5919           /* If no declaration found, default to int.  */
5920           if (!found)
5921             {
5922               found = build_decl (PARM_DECL, TREE_VALUE (parm),
5923                                   integer_type_node);
5924               DECL_ARG_TYPE (found) = TREE_TYPE (found);
5925               DECL_SOURCE_LOCATION (found) = DECL_SOURCE_LOCATION (fndecl);
5926               if (flag_isoc99)
5927                 pedwarn ("%Htype of '%D' defaults to `int'",
5928                          &DECL_SOURCE_LOCATION (found), found);
5929               else if (extra_warnings)
5930                 warning ("%Htype of '%D' defaults to `int'",
5931                          &DECL_SOURCE_LOCATION (found), found);
5932               pushdecl (found);
5933             }
5934
5935           TREE_PURPOSE (parm) = found;
5936
5937           /* Mark this decl as "already found".  */
5938           DECL_WEAK (found) = 1;
5939         }
5940
5941       /* Put anything which is on the parmdecls chain and which is
5942          not a PARM_DECL onto the list NONPARMS.  (The types of
5943          non-parm things which might appear on the list include
5944          enumerators and NULL-named TYPE_DECL nodes.) Complain about
5945          any actual PARM_DECLs not matched with any names.  */
5946
5947       nonparms = 0;
5948       for (parm = parmdecls; parm;)
5949         {
5950           const location_t *locus = &DECL_SOURCE_LOCATION (parm);
5951           tree next = TREE_CHAIN (parm);
5952           TREE_CHAIN (parm) = 0;
5953
5954           if (TREE_CODE (parm) != PARM_DECL)
5955             nonparms = chainon (nonparms, parm);
5956           else
5957             {
5958               /* Complain about args with incomplete types.  */
5959               if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
5960                 {
5961                   error ("%Hparameter '%D' has incomplete type", locus, parm);
5962                   TREE_TYPE (parm) = error_mark_node;
5963                 }
5964
5965               if (! DECL_WEAK (parm))
5966                 {
5967                   error ("%Hdeclaration for parameter '%D' but no such "
5968                          "parameter", locus, parm);
5969                   /* Pretend the parameter was not missing.
5970                      This gets us to a standard state and minimizes
5971                      further error messages.  */
5972                   specparms
5973                     = chainon (specparms,
5974                                tree_cons (parm, NULL_TREE, NULL_TREE));
5975                 }
5976             }
5977
5978           parm = next;
5979         }
5980
5981       /* Chain the declarations together in the order of the list of
5982          names.  Store that chain in the function decl, replacing the
5983          list of names.  */
5984       parm = specparms;
5985       DECL_ARGUMENTS (fndecl) = 0;
5986       {
5987         tree last;
5988         for (last = 0; parm; parm = TREE_CHAIN (parm))
5989           if (TREE_PURPOSE (parm))
5990             {
5991               if (last == 0)
5992                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
5993               else
5994                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
5995               last = TREE_PURPOSE (parm);
5996               TREE_CHAIN (last) = 0;
5997             }
5998       }
5999
6000       /* If there was a previous prototype,
6001          set the DECL_ARG_TYPE of each argument according to
6002          the type previously specified, and report any mismatches.  */
6003
6004       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6005         {
6006           tree type;
6007           for (parm = DECL_ARGUMENTS (fndecl),
6008                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6009                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6010                                  != void_type_node));
6011                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6012             {
6013               if (parm == 0 || type == 0
6014                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6015                 {
6016                   error ("number of arguments doesn't match prototype");
6017                   error ("%Hprototype declaration",
6018                          &current_function_prototype_locus);
6019                   break;
6020                 }
6021               /* Type for passing arg must be consistent with that
6022                  declared for the arg.  ISO C says we take the unqualified
6023                  type for parameters declared with qualified type.  */
6024               if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6025                                TYPE_MAIN_VARIANT (TREE_VALUE (type)),
6026                                COMPARE_STRICT))
6027                 {
6028                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6029                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6030                     {
6031                       /* Adjust argument to match prototype.  E.g. a previous
6032                          `int foo(float);' prototype causes
6033                          `int foo(x) float x; {...}' to be treated like
6034                          `int foo(float x) {...}'.  This is particularly
6035                          useful for argument types like uid_t.  */
6036                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6037
6038                       if (PROMOTE_PROTOTYPES
6039                           && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6040                           && TYPE_PRECISION (TREE_TYPE (parm))
6041                           < TYPE_PRECISION (integer_type_node))
6042                         DECL_ARG_TYPE (parm) = integer_type_node;
6043
6044                       if (pedantic)
6045                         {
6046                           pedwarn ("promoted argument `%s' doesn't match prototype",
6047                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6048                           warning ("%Hprototype declaration",
6049                                    &current_function_prototype_locus);
6050                         }
6051                     }
6052                   else
6053                     {
6054                       error ("argument `%s' doesn't match prototype",
6055                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6056                       error ("%Hprototype declaration",
6057                              &current_function_prototype_locus);
6058                     }
6059                 }
6060             }
6061           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6062         }
6063
6064       /* Otherwise, create a prototype that would match.  */
6065
6066       else
6067         {
6068           tree actual = 0, last = 0, type;
6069
6070           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6071             {
6072               type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6073               if (last)
6074                 TREE_CHAIN (last) = type;
6075               else
6076                 actual = type;
6077               last = type;
6078             }
6079           type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6080           if (last)
6081             TREE_CHAIN (last) = type;
6082           else
6083             actual = type;
6084
6085           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6086              of the type of this function, but we need to avoid having this
6087              affect the types of other similarly-typed functions, so we must
6088              first force the generation of an identical (but separate) type
6089              node for the relevant function type.  The new node we create
6090              will be a variant of the main variant of the original function
6091              type.  */
6092
6093           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6094
6095           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6096         }
6097
6098       /* Now store the final chain of decls for the arguments
6099          as the decl-chain of the current lexical scope.
6100          Put the enumerators in as well, at the front so that
6101          DECL_ARGUMENTS is not modified.  */
6102
6103       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6104     }
6105
6106   /* Make sure the scope for the top of the function body
6107      gets a BLOCK if there are any in the function.
6108      Otherwise, the dbx output is wrong.  */
6109
6110   keep_next_if_subblocks = 1;
6111
6112   /* Write a record describing this function definition to the prototypes
6113      file (if requested).  */
6114
6115   gen_aux_info_record (fndecl, 1, 0, prototype);
6116
6117   /* Initialize the RTL code for the function.  */
6118   init_function_start (fndecl);
6119
6120   /* Begin the statement tree for this function.  */
6121   begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6122
6123   /* If this is a nested function, save away the sizes of any
6124      variable-size types so that we can expand them when generating
6125      RTL.  */
6126   if (context)
6127     {
6128       tree t;
6129
6130       DECL_LANG_SPECIFIC (fndecl)->pending_sizes
6131         = nreverse (get_pending_sizes ());
6132       for (t = DECL_LANG_SPECIFIC (fndecl)->pending_sizes;
6133            t;
6134            t = TREE_CHAIN (t))
6135         SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = context;
6136     }
6137
6138   /* This function is being processed in whole-function mode.  */
6139   cfun->x_whole_function_mode_p = 1;
6140
6141   /* Even though we're inside a function body, we still don't want to
6142      call expand_expr to calculate the size of a variable-sized array.
6143      We haven't necessarily assigned RTL to all variables yet, so it's
6144      not safe to try to expand expressions involving them.  */
6145   immediate_size_expand = 0;
6146   cfun->x_dont_save_pending_sizes_p = 1;
6147
6148   warn_shadow = saved_warn_shadow;
6149 }
6150 \f
6151 /* Finish up a function declaration and compile that function
6152    all the way to assembler language output.  The free the storage
6153    for the function definition.
6154
6155    This is called after parsing the body of the function definition.
6156
6157    NESTED is nonzero if the function being finished is nested in another.
6158    CAN_DEFER_P is nonzero if the function may be deferred.  */
6159
6160 void
6161 finish_function (int nested, int can_defer_p)
6162 {
6163   tree fndecl = current_function_decl;
6164
6165   /* When a function declaration is totally empty, e.g.
6166         void foo(void) { }
6167      (the argument list is irrelevant) the compstmt rule will not
6168      bother calling pushlevel/poplevel, which means we get here with
6169      the scope stack out of sync.  Detect this situation by
6170      noticing that current_scope is still as
6171      store_parm_decls left it, and do a dummy push/pop to get back to
6172      consistency.  Note that the call to pushlevel does not actually
6173      push another scope - see there for details.  */
6174   if (current_scope->parm_flag && keep_next_if_subblocks)
6175     {
6176       pushlevel (0);
6177       poplevel (1, 0, 1);
6178     }
6179
6180   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6181
6182   /* Must mark the RESULT_DECL as being in this function.  */
6183
6184   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6185
6186   if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6187     {
6188       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6189           != integer_type_node)
6190         {
6191           /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6192              If warn_main is -1 (-Wno-main) we don't want to be warned.  */
6193           if (!warn_main)
6194             pedwarn ("%Hreturn type of '%D' is not `int'",
6195                      &DECL_SOURCE_LOCATION (fndecl), fndecl);
6196         }
6197       else
6198         {
6199 #ifdef DEFAULT_MAIN_RETURN
6200           /* Make it so that `main' always returns success by default.  */
6201           DEFAULT_MAIN_RETURN;
6202 #else
6203           if (flag_isoc99)
6204             c_expand_return (integer_zero_node);
6205 #endif
6206         }
6207     }
6208
6209   finish_fname_decls ();
6210
6211   /* Tie off the statement tree for this function.  */
6212   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6213
6214   /* Complain if there's just no return statement.  */
6215   if (warn_return_type
6216       && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6217       && !current_function_returns_value && !current_function_returns_null
6218       /* Don't complain if we abort.  */
6219       && !current_function_returns_abnormally
6220       /* Don't warn for main().  */
6221       && !MAIN_NAME_P (DECL_NAME (fndecl))
6222       /* Or if they didn't actually specify a return type.  */
6223       && !C_FUNCTION_IMPLICIT_INT (fndecl)
6224       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
6225          inline function, as we might never be compiled separately.  */
6226       && DECL_INLINE (fndecl))
6227     warning ("no return statement in function returning non-void");
6228
6229   /* Clear out memory we no longer need.  */
6230   free_after_parsing (cfun);
6231   /* Since we never call rest_of_compilation, we never clear
6232      CFUN.  Do so explicitly.  */
6233   free_after_compilation (cfun);
6234   cfun = NULL;
6235
6236   if (flag_unit_at_a_time && can_defer_p)
6237     {
6238       cgraph_finalize_function (fndecl, DECL_SAVED_TREE (fndecl));
6239       current_function_decl = NULL;
6240       return;
6241     }
6242
6243   if (! nested)
6244     {
6245       /* Function is parsed.
6246          Generate RTL for the body of this function or defer
6247          it for later expansion.  */
6248       int uninlinable = 1;
6249
6250       /* There's no reason to do any of the work here if we're only doing
6251          semantic analysis; this code just generates RTL.  */
6252       if (flag_syntax_only)
6253         {
6254           current_function_decl = NULL;
6255           DECL_SAVED_TREE (fndecl) = NULL_TREE;
6256           return;
6257         }
6258
6259       if (flag_inline_trees)
6260         {
6261           /* First, cache whether the current function is inlinable.  Some
6262              predicates depend on cfun and current_function_decl to
6263              function completely.  */
6264           timevar_push (TV_INTEGRATION);
6265           uninlinable = ! tree_inlinable_function_p (fndecl, 0);
6266
6267           if (can_defer_p
6268               /* We defer functions marked inline *even if* the function
6269                  itself is not inlinable.  This is because we don't yet
6270                  know if the function will actually be used; we may be
6271                  able to avoid emitting it entirely.  */
6272               && (! uninlinable || DECL_DECLARED_INLINE_P (fndecl))
6273               /* Save function tree for inlining.  Should return 0 if the
6274                  language does not support function deferring or the
6275                  function could not be deferred.  */
6276               && defer_fn (fndecl))
6277             {
6278               /* Let the back-end know that this function exists.  */
6279               (*debug_hooks->deferred_inline_function) (fndecl);
6280               timevar_pop (TV_INTEGRATION);
6281               current_function_decl = NULL;
6282               return;
6283             }
6284
6285           /* Then, inline any functions called in it.  */
6286           optimize_inline_calls (fndecl);
6287           timevar_pop (TV_INTEGRATION);
6288         }
6289
6290       c_expand_body (fndecl);
6291
6292       /* Keep the function body if it's needed for inlining or dumping.  */
6293       if (uninlinable && !dump_enabled_p (TDI_all))
6294         {
6295           /* Allow the body of the function to be garbage collected.  */
6296           DECL_SAVED_TREE (fndecl) = NULL_TREE;
6297         }
6298
6299       /* Let the error reporting routines know that we're outside a
6300          function.  For a nested function, this value is used in
6301          c_pop_function_context and then reset via pop_function_context.  */
6302       current_function_decl = NULL;
6303     }
6304 }
6305
6306 /* Generate the RTL for a deferred function FNDECL.  */
6307
6308 void
6309 c_expand_deferred_function (tree fndecl)
6310 {
6311   /* DECL_INLINE or DECL_RESULT might got cleared after the inline
6312      function was deferred, e.g. in duplicate_decls.  */
6313   if (DECL_INLINE (fndecl) && DECL_RESULT (fndecl))
6314     {
6315       if (flag_inline_trees)
6316         {
6317           timevar_push (TV_INTEGRATION);
6318           optimize_inline_calls (fndecl);
6319           timevar_pop (TV_INTEGRATION);
6320         }
6321       c_expand_body (fndecl);
6322       current_function_decl = NULL;
6323     }
6324 }
6325
6326 /* Called to move the SAVE_EXPRs for parameter declarations in a
6327    nested function into the nested function.  DATA is really the
6328    nested FUNCTION_DECL.  */
6329
6330 static tree
6331 set_save_expr_context (tree *tp,
6332                        int *walk_subtrees,
6333                        void *data)
6334 {
6335   if (TREE_CODE (*tp) == SAVE_EXPR && !SAVE_EXPR_CONTEXT (*tp))
6336     SAVE_EXPR_CONTEXT (*tp) = (tree) data;
6337   /* Do not walk back into the SAVE_EXPR_CONTEXT; that will cause
6338      circularity.  */
6339   else if (DECL_P (*tp))
6340     *walk_subtrees = 0;
6341
6342   return NULL_TREE;
6343 }
6344
6345 /* Generate the RTL for the body of FNDECL.  If NESTED_P is nonzero,
6346    then we are already in the process of generating RTL for another
6347    function.  If can_defer_p is zero, we won't attempt to defer the
6348    generation of RTL.  */
6349
6350 static void
6351 c_expand_body_1 (tree fndecl, int nested_p)
6352 {
6353   timevar_push (TV_EXPAND);
6354
6355   if (nested_p)
6356     {
6357       /* Make sure that we will evaluate variable-sized types involved
6358          in our function's type.  */
6359       expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl)->pending_sizes);
6360       /* Squirrel away our current state.  */
6361       push_function_context ();
6362     }
6363
6364   /* Initialize the RTL code for the function.  */
6365   current_function_decl = fndecl;
6366   input_location = DECL_SOURCE_LOCATION (fndecl);
6367   init_function_start (fndecl);
6368
6369   /* This function is being processed in whole-function mode.  */
6370   cfun->x_whole_function_mode_p = 1;
6371
6372   /* Even though we're inside a function body, we still don't want to
6373      call expand_expr to calculate the size of a variable-sized array.
6374      We haven't necessarily assigned RTL to all variables yet, so it's
6375      not safe to try to expand expressions involving them.  */
6376   immediate_size_expand = 0;
6377   cfun->x_dont_save_pending_sizes_p = 1;
6378
6379   /* Set up parameters and prepare for return, for the function.  */
6380   expand_function_start (fndecl, 0);
6381
6382   /* If the function has a variably modified type, there may be
6383      SAVE_EXPRs in the parameter types.  Their context must be set to
6384      refer to this function; they cannot be expanded in the containing
6385      function.  */
6386   if (decl_function_context (fndecl)
6387       && variably_modified_type_p (TREE_TYPE (fndecl)))
6388     walk_tree (&TREE_TYPE (fndecl), set_save_expr_context, fndecl,
6389                NULL);
6390
6391   /* If this function is `main', emit a call to `__main'
6392      to run global initializers, etc.  */
6393   if (DECL_NAME (fndecl)
6394       && MAIN_NAME_P (DECL_NAME (fndecl))
6395       && DECL_CONTEXT (fndecl) == NULL_TREE)
6396     expand_main_function ();
6397
6398   /* Generate the RTL for this function.  */
6399   expand_stmt (DECL_SAVED_TREE (fndecl));
6400
6401   /* We hard-wired immediate_size_expand to zero above.
6402      expand_function_end will decrement this variable.  So, we set the
6403      variable to one here, so that after the decrement it will remain
6404      zero.  */
6405   immediate_size_expand = 1;
6406
6407   /* Allow language dialects to perform special processing.  */
6408   if (lang_expand_function_end)
6409     (*lang_expand_function_end) ();
6410
6411   /* Generate rtl for function exit.  */
6412   expand_function_end ();
6413
6414   /* If this is a nested function, protect the local variables in the stack
6415      above us from being collected while we're compiling this function.  */
6416   if (nested_p)
6417     ggc_push_context ();
6418
6419   /* Run the optimizers and output the assembler code for this function.  */
6420   rest_of_compilation (fndecl);
6421
6422   /* Undo the GC context switch.  */
6423   if (nested_p)
6424     ggc_pop_context ();
6425
6426   /* With just -Wextra, complain only if function returns both with
6427      and without a value.  */
6428   if (extra_warnings
6429       && current_function_returns_value
6430       && current_function_returns_null)
6431     warning ("this function may return with or without a value");
6432
6433   /* If requested, warn about function definitions where the function will
6434      return a value (usually of some struct or union type) which itself will
6435      take up a lot of stack space.  */
6436
6437   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6438     {
6439       tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6440
6441       if (ret_type && TYPE_SIZE_UNIT (ret_type)
6442           && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
6443           && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
6444                                    larger_than_size))
6445         {
6446           const location_t *locus = &DECL_SOURCE_LOCATION (fndecl);
6447           unsigned int size_as_int
6448             = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
6449
6450           if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
6451             warning ("%Hsize of return value of '%D' is %u bytes",
6452                      locus, fndecl, size_as_int);
6453           else
6454             warning ("%Hsize of return value of '%D' is larger than %wd bytes",
6455                      locus, fndecl, larger_than_size);
6456         }
6457     }
6458
6459   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p
6460       && ! flag_inline_trees)
6461     {
6462       /* Stop pointing to the local nodes about to be freed.
6463          But DECL_INITIAL must remain nonzero so we know this
6464          was an actual function definition.
6465          For a nested function, this is done in c_pop_function_context.
6466          If rest_of_compilation set this to 0, leave it 0.  */
6467       if (DECL_INITIAL (fndecl) != 0)
6468         DECL_INITIAL (fndecl) = error_mark_node;
6469
6470       DECL_ARGUMENTS (fndecl) = 0;
6471     }
6472
6473   if (DECL_STATIC_CONSTRUCTOR (fndecl))
6474     {
6475       if (targetm.have_ctors_dtors)
6476         (* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
6477                                          DEFAULT_INIT_PRIORITY);
6478       else
6479         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6480     }
6481
6482   if (DECL_STATIC_DESTRUCTOR (fndecl))
6483     {
6484       if (targetm.have_ctors_dtors)
6485         (* targetm.asm_out.destructor) (XEXP (DECL_RTL (fndecl), 0),
6486                                         DEFAULT_INIT_PRIORITY);
6487       else
6488         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6489     }
6490
6491   if (nested_p)
6492     /* Return to the enclosing function.  */
6493     pop_function_context ();
6494   timevar_pop (TV_EXPAND);
6495 }
6496
6497 /* Like c_expand_body_1 but only for unnested functions.  */
6498
6499 void
6500 c_expand_body (tree fndecl)
6501 {
6502   c_expand_body_1 (fndecl, 0);
6503 }
6504 \f
6505 /* Check the declarations given in a for-loop for satisfying the C99
6506    constraints.  */
6507 void
6508 check_for_loop_decls (void)
6509 {
6510   tree t;
6511
6512   if (!flag_isoc99)
6513     {
6514       /* If we get here, declarations have been used in a for loop without
6515          the C99 for loop scope.  This doesn't make much sense, so don't
6516          allow it.  */
6517       error ("`for' loop initial declaration used outside C99 mode");
6518       return;
6519     }
6520   /* C99 subclause 6.8.5 paragraph 3:
6521
6522        [#3]  The  declaration  part  of  a for statement shall only
6523        declare identifiers for objects having storage class auto or
6524        register.
6525
6526      It isn't clear whether, in this sentence, "identifiers" binds to
6527      "shall only declare" or to "objects" - that is, whether all identifiers
6528      declared must be identifiers for objects, or whether the restriction
6529      only applies to those that are.  (A question on this in comp.std.c
6530      in November 2000 received no answer.)  We implement the strictest
6531      interpretation, to avoid creating an extension which later causes
6532      problems.  */
6533
6534   for (t = gettags (); t; t = TREE_CHAIN (t))
6535     {
6536       if (TREE_PURPOSE (t) != 0)
6537         {
6538           enum tree_code code = TREE_CODE (TREE_VALUE (t));
6539
6540           if (code == RECORD_TYPE)
6541             error ("`struct %s' declared in `for' loop initial declaration",
6542                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6543           else if (code == UNION_TYPE)
6544             error ("`union %s' declared in `for' loop initial declaration",
6545                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6546           else
6547             error ("`enum %s' declared in `for' loop initial declaration",
6548                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6549         }
6550     }
6551
6552   for (t = getdecls (); t; t = TREE_CHAIN (t))
6553     {
6554       const location_t *locus = &DECL_SOURCE_LOCATION (t);
6555       if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
6556         error ("%Hdeclaration of non-variable '%D' in 'for' loop "
6557                "initial declaration", locus, t);
6558       else if (TREE_STATIC (t))
6559         error ("%Hdeclaration of static variable '%D' in 'for' loop "
6560                "initial declaration", locus, t);
6561       else if (DECL_EXTERNAL (t))
6562         error ("%Hdeclaration of 'extern' variable '%D' in 'for' loop "
6563                "initial declaration", locus, t);
6564     }
6565 }
6566 \f
6567 /* Save and restore the variables in this file and elsewhere
6568    that keep track of the progress of compilation of the current function.
6569    Used for nested functions.  */
6570
6571 struct language_function GTY(())
6572 {
6573   struct c_language_function base;
6574   int returns_value;
6575   int returns_null;
6576   int returns_abnormally;
6577   int warn_about_return_type;
6578   int extern_inline;
6579   struct c_scope *scope;
6580 };
6581
6582 /* Save and reinitialize the variables
6583    used during compilation of a C function.  */
6584
6585 void
6586 c_push_function_context (struct function *f)
6587 {
6588   struct language_function *p;
6589   p = ggc_alloc (sizeof (struct language_function));
6590   f->language = p;
6591
6592   p->base.x_stmt_tree = c_stmt_tree;
6593   p->base.x_scope_stmt_stack = c_scope_stmt_stack;
6594   p->returns_value = current_function_returns_value;
6595   p->returns_null = current_function_returns_null;
6596   p->returns_abnormally = current_function_returns_abnormally;
6597   p->warn_about_return_type = warn_about_return_type;
6598   p->extern_inline = current_extern_inline;
6599   p->scope = current_scope;
6600 }
6601
6602 /* Restore the variables used during compilation of a C function.  */
6603
6604 void
6605 c_pop_function_context (struct function *f)
6606 {
6607   struct language_function *p = f->language;
6608
6609   if (DECL_SAVED_INSNS (current_function_decl) == 0
6610       && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6611     {
6612       /* Stop pointing to the local nodes about to be freed.  */
6613       /* But DECL_INITIAL must remain nonzero so we know this
6614          was an actual function definition.  */
6615       DECL_INITIAL (current_function_decl) = error_mark_node;
6616       DECL_ARGUMENTS (current_function_decl) = 0;
6617     }
6618
6619   c_stmt_tree = p->base.x_stmt_tree;
6620   c_scope_stmt_stack = p->base.x_scope_stmt_stack;
6621   current_function_returns_value = p->returns_value;
6622   current_function_returns_null = p->returns_null;
6623   current_function_returns_abnormally = p->returns_abnormally;
6624   warn_about_return_type = p->warn_about_return_type;
6625   current_extern_inline = p->extern_inline;
6626   current_scope = p->scope;
6627
6628   f->language = NULL;
6629 }
6630
6631 /* Copy the DECL_LANG_SPECIFIC data associated with DECL.  */
6632
6633 void
6634 c_dup_lang_specific_decl (tree decl)
6635 {
6636   struct lang_decl *ld;
6637
6638   if (!DECL_LANG_SPECIFIC (decl))
6639     return;
6640
6641   ld = ggc_alloc (sizeof (struct lang_decl));
6642   memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
6643   DECL_LANG_SPECIFIC (decl) = ld;
6644 }
6645
6646 /* The functions below are required for functionality of doing
6647    function at once processing in the C front end. Currently these
6648    functions are not called from anywhere in the C front end, but as
6649    these changes continue, that will change.  */
6650
6651 /* Returns nonzero if the current statement is a full expression,
6652    i.e. temporaries created during that statement should be destroyed
6653    at the end of the statement.  */
6654
6655 int
6656 stmts_are_full_exprs_p (void)
6657 {
6658   return 0;
6659 }
6660
6661 /* Returns the stmt_tree (if any) to which statements are currently
6662    being added.  If there is no active statement-tree, NULL is
6663    returned.  */
6664
6665 stmt_tree
6666 current_stmt_tree (void)
6667 {
6668   return &c_stmt_tree;
6669 }
6670
6671 /* Returns the stack of SCOPE_STMTs for the current function.  */
6672
6673 tree *
6674 current_scope_stmt_stack (void)
6675 {
6676   return &c_scope_stmt_stack;
6677 }
6678
6679 /* Nonzero if TYPE is an anonymous union or struct type.  Always 0 in
6680    C.  */
6681
6682 int
6683 anon_aggr_type_p (tree node ATTRIBUTE_UNUSED)
6684 {
6685   return 0;
6686 }
6687
6688 /* Dummy function in place of callback used by C++.  */
6689
6690 void
6691 extract_interface_info (void)
6692 {
6693 }
6694
6695 /* Return a new COMPOUND_STMT, after adding it to the current
6696    statement tree.  */
6697
6698 tree
6699 c_begin_compound_stmt (void)
6700 {
6701   tree stmt;
6702
6703   /* Create the COMPOUND_STMT.  */
6704   stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
6705
6706   return stmt;
6707 }
6708
6709 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
6710    common code.  */
6711
6712 void
6713 c_expand_decl_stmt (tree t)
6714 {
6715   tree decl = DECL_STMT_DECL (t);
6716
6717   /* Expand nested functions.  */
6718   if (TREE_CODE (decl) == FUNCTION_DECL
6719       && DECL_CONTEXT (decl) == current_function_decl
6720       && DECL_SAVED_TREE (decl))
6721     c_expand_body_1 (decl, 1);
6722 }
6723
6724 /* Return the global value of T as a symbol.  */
6725
6726 tree
6727 identifier_global_value (tree t)
6728 {
6729   tree decl = IDENTIFIER_SYMBOL_VALUE (t);
6730   if (decl == 0 || C_DECL_FILE_SCOPE (decl))
6731     return decl;
6732
6733   /* Shadowed by something else; find the true global value.  */
6734   for (decl = global_scope->names; decl; decl = TREE_CHAIN (decl))
6735     if (DECL_NAME (decl) == t)
6736       return decl;
6737
6738   /* Only local values for this decl.  */
6739   return 0;
6740 }
6741
6742 /* Record a builtin type for C.  If NAME is non-NULL, it is the name used;
6743    otherwise the name is found in ridpointers from RID_INDEX.  */
6744
6745 void
6746 record_builtin_type (enum rid rid_index, const char *name, tree type)
6747 {
6748   tree id;
6749   if (name == 0)
6750     id = ridpointers[(int) rid_index];
6751   else
6752     id = get_identifier (name);
6753   pushdecl (build_decl (TYPE_DECL, id, type));
6754 }
6755
6756 /* Build the void_list_node (void_type_node having been created).  */
6757 tree
6758 build_void_list_node (void)
6759 {
6760   tree t = build_tree_list (NULL_TREE, void_type_node);
6761   return t;
6762 }
6763
6764 /* Return something to represent absolute declarators containing a *.
6765    TARGET is the absolute declarator that the * contains.
6766    TYPE_QUALS_ATTRS is a list of modifiers such as const or volatile
6767    to apply to the pointer type, represented as identifiers, possible mixed
6768    with attributes.
6769
6770    We return an INDIRECT_REF whose "contents" are TARGET (inside a TREE_LIST,
6771    if attributes are present) and whose type is the modifier list.  */
6772
6773 tree
6774 make_pointer_declarator (tree type_quals_attrs, tree target)
6775 {
6776   tree quals, attrs;
6777   tree itarget = target;
6778   split_specs_attrs (type_quals_attrs, &quals, &attrs);
6779   if (attrs != NULL_TREE)
6780     itarget = tree_cons (attrs, target, NULL_TREE);
6781   return build1 (INDIRECT_REF, quals, itarget);
6782 }
6783
6784 /* A wrapper around lhd_set_decl_assembler_name that gives static
6785    variables their C names if they are at file scope and only one
6786    translation unit is being compiled, for backwards compatibility
6787    with certain bizzare assembler hacks (like crtstuff.c).  */
6788
6789 void
6790 c_static_assembler_name (tree decl)
6791 {
6792   if (num_in_fnames == 1
6793       && !TREE_PUBLIC (decl) && DECL_CONTEXT (decl)
6794       && TREE_CODE (DECL_CONTEXT (decl)) == TRANSLATION_UNIT_DECL)
6795     SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
6796   else
6797     lhd_set_decl_assembler_name (decl);
6798 }
6799
6800 /* Hash and equality functions for link_hash_table: key off
6801    DECL_ASSEMBLER_NAME.  */
6802
6803 static hashval_t
6804 link_hash_hash (const void *x_p)
6805 {
6806   tree x = (tree)x_p;
6807   return (hashval_t) (long)DECL_ASSEMBLER_NAME (x);
6808 }
6809
6810 static int
6811 link_hash_eq (const void *x1_p, const void *x2_p)
6812 {
6813   tree x1 = (tree)x1_p;
6814   tree x2 = (tree)x2_p;
6815   return DECL_ASSEMBLER_NAME (x1) == DECL_ASSEMBLER_NAME (x2);
6816 }
6817
6818 /* Propagate information between definitions and uses between multiple
6819    translation units in TU_LIST based on linkage rules.  */
6820
6821 void
6822 merge_translation_unit_decls (void)
6823 {
6824   const tree tu_list = current_file_decl;
6825   tree tu;
6826   tree decl;
6827   htab_t link_hash_table;
6828   tree block;
6829
6830   /* Create the BLOCK that poplevel would have created, but don't
6831      actually call poplevel since that's expensive.  */
6832   block = make_node (BLOCK);
6833   BLOCK_VARS (block) = current_scope->names;
6834   TREE_USED (block) = 1;
6835   DECL_INITIAL (current_file_decl) = block;
6836
6837   /* If only one translation unit seen, no copying necessary.  */
6838   if (TREE_CHAIN (tu_list) == NULL_TREE)
6839     return;
6840
6841   link_hash_table = htab_create (1021, link_hash_hash, link_hash_eq, NULL);
6842
6843   /* Enter any actual definitions into the hash table.  */
6844   for (tu = tu_list; tu; tu = TREE_CHAIN (tu))
6845     for (decl = BLOCK_VARS (DECL_INITIAL (tu)); decl; decl = TREE_CHAIN (decl))
6846       if (TREE_PUBLIC (decl) && ! DECL_EXTERNAL (decl))
6847         {
6848           PTR *slot;
6849           slot = htab_find_slot (link_hash_table, decl, INSERT);
6850
6851           /* If we've already got a definition, work out which one is
6852              the real one, put it into the hash table, and make the
6853              other one DECL_EXTERNAL.  This is important to avoid
6854              putting out two definitions of the same symbol in the
6855              assembly output.  */
6856           if (*slot != NULL)
6857             {
6858               tree old_decl = (tree) *slot;
6859
6860               /* If this is weak or common or whatever, suppress it
6861                  in favour of the other definition.  */
6862               if (DECL_WEAK (decl))
6863                 DECL_EXTERNAL (decl) = 1;
6864               else if (DECL_WEAK (old_decl) && ! DECL_WEAK (decl))
6865                 DECL_EXTERNAL (old_decl) = 1;
6866               else if (DECL_COMMON (decl) || DECL_ONE_ONLY (decl))
6867                 DECL_EXTERNAL (decl) = 1;
6868               else if (DECL_COMMON (old_decl) || DECL_ONE_ONLY (old_decl))
6869                 DECL_EXTERNAL (old_decl) = 1;
6870
6871               if (DECL_EXTERNAL (decl))
6872                 {
6873                   DECL_INITIAL (decl) = NULL_TREE;
6874                   DECL_COMMON (decl) = 0;
6875                   DECL_ONE_ONLY (decl) = 0;
6876                   DECL_WEAK (decl) = 0;
6877                 }
6878               else if (DECL_EXTERNAL (old_decl))
6879                 {
6880                   DECL_INITIAL (old_decl) = NULL_TREE;
6881                   DECL_COMMON (old_decl) = 0;
6882                   DECL_ONE_ONLY (old_decl) = 0;
6883                   DECL_WEAK (old_decl) = 0;
6884                   *slot = decl;
6885                 }
6886               else
6887                 {
6888                   error ("%Hredefinition of global '%D'",
6889                          &DECL_SOURCE_LOCATION (decl), decl);
6890                   error ("%H'%D' previously defined here",
6891                          &DECL_SOURCE_LOCATION (old_decl), old_decl);
6892                 }
6893             }
6894           else
6895             *slot = decl;
6896         }
6897
6898   /* Now insert the desired information from all the definitions
6899      into any plain declarations.  */
6900   for (tu = tu_list; tu; tu = TREE_CHAIN (tu))
6901     for (decl = BLOCK_VARS (DECL_INITIAL (tu)); decl; decl = TREE_CHAIN (decl))
6902       if (TREE_PUBLIC (decl) && DECL_EXTERNAL (decl))
6903         {
6904           tree global_decl;
6905           global_decl = htab_find (link_hash_table, decl);
6906
6907           if (! global_decl)
6908             continue;
6909
6910           /* Print any appropriate error messages, and partially merge
6911              the decls.  */
6912           (void) duplicate_decls (decl, global_decl, true, true);
6913         }
6914
6915   htab_delete (link_hash_table);
6916 }
6917
6918 /* Perform final processing on file-scope data.  */
6919
6920 void
6921 c_write_global_declarations(void)
6922 {
6923   tree link;
6924
6925   for (link = current_file_decl; link; link = TREE_CHAIN (link))
6926     {
6927       tree globals = BLOCK_VARS (DECL_INITIAL (link));
6928       int len = list_length (globals);
6929       tree *vec = xmalloc (sizeof (tree) * len);
6930       int i;
6931       tree decl;
6932
6933       /* Process the decls in reverse order--earliest first.
6934          Put them into VEC from back to front, then take out from front.  */
6935
6936       for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
6937         vec[len - i - 1] = decl;
6938
6939       wrapup_global_declarations (vec, len);
6940
6941       check_global_declarations (vec, len);
6942
6943       /* Clean up.  */
6944       free (vec);
6945     }
6946 }
6947
6948 /* Reset the parser's state in preparation for a new file.  */
6949
6950 void
6951 c_reset_state (void)
6952 {
6953   tree link;
6954   tree file_scope_decl;
6955
6956   /* Pop the global scope.  */
6957   if (current_scope != global_scope)
6958       current_scope = global_scope;
6959   file_scope_decl = current_file_decl;
6960   DECL_INITIAL (file_scope_decl) = poplevel (1, 0, 0);
6961   truly_local_externals = NULL_TREE;
6962
6963   /* Start a new global binding level.  */
6964   pushlevel (0);
6965   global_scope = current_scope;
6966   current_file_decl = build_decl (TRANSLATION_UNIT_DECL, NULL, NULL);
6967   TREE_CHAIN (current_file_decl) = file_scope_decl;
6968
6969   /* Reintroduce the global declarations.  */
6970   for (link = builtin_decls; link; link = TREE_CHAIN (link))
6971     pushdecl (copy_node (link));
6972 }
6973
6974 #include "gt-c-decl.h"