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 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 "intl.h"
  32 #include "tree.h"
  33 #include "tree-inline.h"
  34 #include "rtl.h"
  35 #include "flags.h"
  36 #include "function.h"
  37 #include "output.h"
  38 #include "expr.h"
  39 #include "c-tree.h"
  40 #include "toplev.h"
  41 #include "ggc.h"
  42 #include "tm_p.h"
  43 #include "cpplib.h"
  44 #include "target.h"
  45 #include "debug.h"
  46 #include "timevar.h"
  47 #include "c-common.h"
  48 #include "c-pragma.h"
  49
  50 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
  51 enum decl_context
  52 { NORMAL,                       /* Ordinary declaration */
  53   FUNCDEF,                      /* Function definition */
  54   PARM,                         /* Declaration of parm before function body */
  55   FIELD,                        /* Declaration inside struct or union */
  56   BITFIELD,                     /* Likewise but with specified width */
  57   TYPENAME};                    /* Typename (inside cast or sizeof)  */
  58
  59 \f
  60 /* Nonzero if we have seen an invalid cross reference
  61    to a struct, union, or enum, but not yet printed the message.  */
  62
  63 tree pending_invalid_xref;
  64 /* File and line to appear in the eventual error message.  */
  65 const char *pending_invalid_xref_file;
  66 int pending_invalid_xref_line;
  67
  68 /* While defining an enum type, this is 1 plus the last enumerator
  69    constant value.  Note that will do not have to save this or `enum_overflow'
  70    around nested function definition since such a definition could only
  71    occur in an enum value expression and we don't use these variables in
  72    that case.  */
  73
  74 static tree enum_next_value;
  75
  76 /* Nonzero means that there was overflow computing enum_next_value.  */
  77
  78 static int enum_overflow;
  79
  80 /* Parsing a function declarator leaves a list of parameter names
  81    or a chain or parameter decls here.  */
  82
  83 static tree last_function_parms;
  84
  85 /* Parsing a function declarator leaves here a chain of structure
  86    and enum types declared in the parmlist.  */
  87
  88 static tree last_function_parm_tags;
  89
  90 /* After parsing the declarator that starts a function definition,
  91    `start_function' puts here the list of parameter names or chain of decls.
  92    `store_parm_decls' finds it here.  */
  93
  94 static tree current_function_parms;
  95
  96 /* Similar, for last_function_parm_tags.  */
  97 static tree current_function_parm_tags;
  98
  99 /* Similar, for the file and line that the prototype came from if this is
 100    an old-style definition.  */
 101 static const char *current_function_prototype_file;
 102 static int current_function_prototype_line;
 103
 104 /* The current statement tree.  */
 105
 106 static GTY(()) struct stmt_tree_s c_stmt_tree;
 107
 108 /* The current scope statement stack.  */
 109
 110 static GTY(()) tree c_scope_stmt_stack;
 111
 112 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 113    that have names.  Here so we can clear out their names' definitions
 114    at the end of the function.  */
 115
 116 static GTY(()) tree named_labels;
 117
 118 /* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
 119
 120 static GTY(()) tree shadowed_labels;
 121
 122 /* Set to 0 at beginning of a function definition, set to 1 if
 123    a return statement that specifies a return value is seen.  */
 124
 125 int current_function_returns_value;
 126
 127 /* Set to 0 at beginning of a function definition, set to 1 if
 128    a return statement with no argument is seen.  */
 129
 130 int current_function_returns_null;
 131
 132 /* Set to 0 at beginning of a function definition, set to 1 if
 133    a call to a noreturn function is seen.  */
 134
 135 int current_function_returns_abnormally;
 136
 137 /* Set to nonzero by `grokdeclarator' for a function
 138    whose return type is defaulted, if warnings for this are desired.  */
 139
 140 static int warn_about_return_type;
 141
 142 /* Nonzero when starting a function declared `extern inline'.  */
 143
 144 static int current_extern_inline;
 145 \f
 146 /* For each binding contour we allocate a binding_level structure
 147  * which records the names defined in that contour.
 148  * Contours include:
 149  *  0) the global one
 150  *  1) one for each function definition,
 151  *     where internal declarations of the parameters appear.
 152  *  2) one for each compound statement,
 153  *     to record its declarations.
 154  *
 155  * The current meaning of a name can be found by searching the levels from
 156  * the current one out to the global one.
 157  */
 158
 159 /* Note that the information in the `names' component of the global contour
 160    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 161
 162 struct binding_level GTY(())
 163   {
 164     /* A chain of _DECL nodes for all variables, constants, functions,
 165        and typedef types.  These are in the reverse of the order supplied.
 166      */
 167     tree names;
 168
 169     /* A list of structure, union and enum definitions,
 170      * for looking up tag names.
 171      * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 172      * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 173      * or ENUMERAL_TYPE node.
 174      */
 175     tree tags;
 176
 177     /* For each level, a list of shadowed outer-level local definitions
 178        to be restored when this level is popped.
 179        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 180        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
 181     tree shadowed;
 182
 183     /* For each level (except not the global one),
 184        a chain of BLOCK nodes for all the levels
 185        that were entered and exited one level down.  */
 186     tree blocks;
 187
 188     /* The BLOCK node for this level, if one has been preallocated.
 189        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 190     tree this_block;
 191
 192     /* The binding level which this one is contained in (inherits from).  */
 193     struct binding_level *level_chain;
 194
 195     /* Nonzero for the level that holds the parameters of a function.  */
 196     char parm_flag;
 197
 198     /* Nonzero if this level "doesn't exist" for tags.  */
 199     char tag_transparent;
 200
 201     /* Nonzero if sublevels of this level "don't exist" for tags.
 202        This is set in the parm level of a function definition
 203        while reading the function body, so that the outermost block
 204        of the function body will be tag-transparent.  */
 205     char subblocks_tag_transparent;
 206
 207     /* Nonzero means make a BLOCK for this level regardless of all else.  */
 208     char keep;
 209
 210     /* Nonzero means make a BLOCK if this level has any subblocks.  */
 211     char keep_if_subblocks;
 212
 213     /* List of decls in `names' that have incomplete structure or
 214        union types.  */
 215     tree incomplete_list;
 216
 217     /* A list of decls giving the (reversed) specified order of parms,
 218        not including any forward-decls in the parmlist.
 219        This is so we can put the parms in proper order for assign_parms.  */
 220     tree parm_order;
 221   };
 222
 223 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
 224
 225 /* The binding level currently in effect.  */
 226
 227 static GTY(()) struct binding_level *current_binding_level;
 228
 229 /* A chain of binding_level structures awaiting reuse.  */
 230
 231 static GTY((deletable (""))) struct binding_level *free_binding_level;
 232
 233 /* The outermost binding level, for names of file scope.
 234    This is created when the compiler is started and exists
 235    through the entire run.  */
 236
 237 static GTY(()) struct binding_level *global_binding_level;
 238
 239 /* Binding level structures are initialized by copying this one.  */
 240
 241 static struct binding_level clear_binding_level
 242   = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, NULL,
 243      NULL};
 244
 245 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 246
 247 static int keep_next_level_flag;
 248
 249 /* Nonzero means make a BLOCK for the next level pushed
 250    if it has subblocks.  */
 251
 252 static int keep_next_if_subblocks;
 253
 254 /* The chain of outer levels of label scopes.
 255    This uses the same data structure used for binding levels,
 256    but it works differently: each link in the chain records
 257    saved values of named_labels and shadowed_labels for
 258    a label binding level outside the current one.  */
 259
 260 static GTY(()) struct binding_level *label_level_chain;
 261
 262 /* Functions called automatically at the beginning and end of execution.  */
 263
 264 tree static_ctors, static_dtors;
 265
 266 /* Forward declarations.  */
 267
 268 static struct binding_level * make_binding_level        PARAMS ((void));
 269 static void pop_binding_level           PARAMS ((struct binding_level **));
 270 static void clear_limbo_values          PARAMS ((tree));
 271 static int duplicate_decls              PARAMS ((tree, tree, int));
 272 static int redeclaration_error_message  PARAMS ((tree, tree));
 273 static void storedecls                  PARAMS ((tree));
 274 static void storetags                   PARAMS ((tree));
 275 static tree lookup_tag                  PARAMS ((enum tree_code, tree,
 276                                                  struct binding_level *, int));
 277 static tree lookup_tag_reverse          PARAMS ((tree));
 278 static tree grokdeclarator              PARAMS ((tree, tree, enum decl_context,
 279                                                  int));
 280 static tree grokparms                   PARAMS ((tree, int));
 281 static void layout_array_type           PARAMS ((tree));
 282 static tree c_make_fname_decl           PARAMS ((tree, int));
 283 static void c_expand_body               PARAMS ((tree, int, int));
 284 static void warn_if_shadowing           PARAMS ((tree, tree));
 285 static bool flexible_array_type_p       PARAMS ((tree));
 286 \f
 287 /* States indicating how grokdeclarator() should handle declspecs marked
 288    with __attribute__((deprecated)).  An object declared as
 289    __attribute__((deprecated)) suppresses warnings of uses of other
 290    deprecated items.  */
 291
 292 enum deprecated_states {
 293   DEPRECATED_NORMAL,
 294   DEPRECATED_SUPPRESS
 295 };
 296
 297 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 298
 299 void
 300 c_print_identifier (file, node, indent)
 301      FILE *file;
 302      tree node;
 303      int indent;
 304 {
 305   print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
 306   print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
 307   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
 308   print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
 309   print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
 310   print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
 311   if (C_IS_RESERVED_WORD (node))
 312     {
 313       tree rid = ridpointers[C_RID_CODE (node)];
 314       indent_to (file, indent + 4);
 315       fprintf (file, "rid ");
 316       fprintf (file, HOST_PTR_PRINTF, (void *)rid);
 317       fprintf (file, " \"%s\"", IDENTIFIER_POINTER (rid));
 318     }
 319 }
 320 \f
 321 /* Hook called at end of compilation to assume 1 elt
 322    for a top-level tentative array defn that wasn't complete before.  */
 323
 324 void
 325 c_finish_incomplete_decl (decl)
 326      tree decl;
 327 {
 328   if (TREE_CODE (decl) == VAR_DECL)
 329     {
 330       tree type = TREE_TYPE (decl);
 331       if (type != error_mark_node
 332           && TREE_CODE (type) == ARRAY_TYPE
 333           && ! DECL_EXTERNAL (decl)
 334           && TYPE_DOMAIN (type) == 0)
 335         {
 336           warning_with_decl (decl, "array `%s' assumed to have one element");
 337
 338           complete_array_type (type, NULL_TREE, 1);
 339
 340           layout_decl (decl, 0);
 341         }
 342     }
 343 }
 344 \f
 345 /* Reuse or create a struct for this binding level.  */
 346
 347 static struct binding_level *
 348 make_binding_level ()
 349 {
 350   if (free_binding_level)
 351     {
 352       struct binding_level *result = free_binding_level;
 353       free_binding_level = result->level_chain;
 354       return result;
 355     }
 356   else
 357     return (struct binding_level *) ggc_alloc (sizeof (struct binding_level));
 358 }
 359
 360 /* Remove a binding level from a list and add it to the level chain.  */
 361
 362 static void
 363 pop_binding_level (lp)
 364      struct binding_level **lp;
 365 {
 366   struct binding_level *l = *lp;
 367   *lp = l->level_chain;
 368
 369   memset (l, 0, sizeof (struct binding_level));
 370   l->level_chain = free_binding_level;
 371   free_binding_level = l;
 372 }
 373
 374 /* Nonzero if we are currently in the global binding level.  */
 375
 376 int
 377 global_bindings_p ()
 378 {
 379   return current_binding_level == global_binding_level;
 380 }
 381
 382 void
 383 keep_next_level ()
 384 {
 385   keep_next_level_flag = 1;
 386 }
 387
 388 /* Nonzero if the current level needs to have a BLOCK made.  */
 389
 390 int
 391 kept_level_p ()
 392 {
 393   return ((current_binding_level->keep_if_subblocks
 394            && current_binding_level->blocks != 0)
 395           || current_binding_level->keep
 396           || current_binding_level->names != 0
 397           || (current_binding_level->tags != 0
 398               && !current_binding_level->tag_transparent));
 399 }
 400
 401 /* Identify this binding level as a level of parameters.
 402    DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
 403    But it turns out there is no way to pass the right value for
 404    DEFINITION_FLAG, so we ignore it.  */
 405
 406 void
 407 declare_parm_level (definition_flag)
 408      int definition_flag ATTRIBUTE_UNUSED;
 409 {
 410   current_binding_level->parm_flag = 1;
 411 }
 412
 413 /* Nonzero if currently making parm declarations.  */
 414
 415 int
 416 in_parm_level_p ()
 417 {
 418   return current_binding_level->parm_flag;
 419 }
 420
 421 /* Enter a new binding level.
 422    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 423    not for that of tags.  */
 424
 425 void
 426 pushlevel (tag_transparent)
 427      int tag_transparent;
 428 {
 429   struct binding_level *newlevel = NULL_BINDING_LEVEL;
 430
 431   /* If this is the top level of a function,
 432      just make sure that NAMED_LABELS is 0.  */
 433
 434   if (current_binding_level == global_binding_level)
 435     {
 436       named_labels = 0;
 437     }
 438
 439   newlevel = make_binding_level ();
 440
 441   /* Add this level to the front of the chain (stack) of levels that
 442      are active.  */
 443
 444   *newlevel = clear_binding_level;
 445   newlevel->tag_transparent
 446     = (tag_transparent
 447        || (current_binding_level
 448            ? current_binding_level->subblocks_tag_transparent
 449            : 0));
 450   newlevel->level_chain = current_binding_level;
 451   current_binding_level = newlevel;
 452   newlevel->keep = keep_next_level_flag;
 453   keep_next_level_flag = 0;
 454   newlevel->keep_if_subblocks = keep_next_if_subblocks;
 455   keep_next_if_subblocks = 0;
 456 }
 457
 458 /* Clear the limbo values of all identifiers defined in BLOCK or a subblock.  */
 459
 460 static void
 461 clear_limbo_values (block)
 462      tree block;
 463 {
 464   tree tem;
 465
 466   for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
 467     if (DECL_NAME (tem) != 0)
 468       IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
 469
 470   for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
 471     clear_limbo_values (tem);
 472 }
 473
 474 /* Exit a binding level.
 475    Pop the level off, and restore the state of the identifier-decl mappings
 476    that were in effect when this level was entered.
 477
 478    If KEEP is nonzero, this level had explicit declarations, so
 479    and create a "block" (a BLOCK node) for the level
 480    to record its declarations and subblocks for symbol table output.
 481
 482    If FUNCTIONBODY is nonzero, this level is the body of a function,
 483    so create a block as if KEEP were set and also clear out all
 484    label names.
 485
 486    If REVERSE is nonzero, reverse the order of decls before putting
 487    them into the BLOCK.  */
 488
 489 tree
 490 poplevel (keep, reverse, functionbody)
 491      int keep;
 492      int reverse;
 493      int functionbody;
 494 {
 495   tree link;
 496   /* The chain of decls was accumulated in reverse order.
 497      Put it into forward order, just for cleanliness.  */
 498   tree decls;
 499   tree tags = current_binding_level->tags;
 500   tree subblocks = current_binding_level->blocks;
 501   tree block = 0;
 502   tree decl;
 503   int block_previously_created;
 504
 505   keep |= current_binding_level->keep;
 506
 507   /* This warning is turned off because it causes warnings for
 508      declarations like `extern struct foo *x'.  */
 509 #if 0
 510   /* Warn about incomplete structure types in this level.  */
 511   for (link = tags; link; link = TREE_CHAIN (link))
 512     if (!COMPLETE_TYPE_P (TREE_VALUE (link)))
 513       {
 514         tree type = TREE_VALUE (link);
 515         tree type_name = TYPE_NAME (type);
 516         char *id = IDENTIFIER_POINTER (TREE_CODE (type_name) == IDENTIFIER_NODE
 517                                        ? type_name
 518                                        : DECL_NAME (type_name));
 519         switch (TREE_CODE (type))
 520           {
 521           case RECORD_TYPE:
 522             error ("`struct %s' incomplete in scope ending here", id);
 523             break;
 524           case UNION_TYPE:
 525             error ("`union %s' incomplete in scope ending here", id);
 526             break;
 527           case ENUMERAL_TYPE:
 528             error ("`enum %s' incomplete in scope ending here", id);
 529             break;
 530           }
 531       }
 532 #endif /* 0 */
 533
 534   /* Get the decls in the order they were written.
 535      Usually current_binding_level->names is in reverse order.
 536      But parameter decls were previously put in forward order.  */
 537
 538   if (reverse)
 539     current_binding_level->names
 540       = decls = nreverse (current_binding_level->names);
 541   else
 542     decls = current_binding_level->names;
 543
 544   /* Output any nested inline functions within this block
 545      if they weren't already output.  */
 546
 547   for (decl = decls; decl; decl = TREE_CHAIN (decl))
 548     if (TREE_CODE (decl) == FUNCTION_DECL
 549         && ! TREE_ASM_WRITTEN (decl)
 550         && DECL_INITIAL (decl) != 0
 551         && TREE_ADDRESSABLE (decl))
 552       {
 553         /* If this decl was copied from a file-scope decl
 554            on account of a block-scope extern decl,
 555            propagate TREE_ADDRESSABLE to the file-scope decl.
 556
 557            DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
 558            true, since then the decl goes through save_for_inline_copying.  */
 559         if (DECL_ABSTRACT_ORIGIN (decl) != 0
 560             && DECL_ABSTRACT_ORIGIN (decl) != decl)
 561           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
 562       }
 563
 564   /* We used to warn about unused variables in expand_end_bindings,
 565      i.e. while generating RTL.  But in function-at-a-time mode we may
 566      choose to never expand a function at all (e.g. auto inlining), so
 567      we do this explicitly now.  */
 568   warn_about_unused_variables (getdecls ());
 569
 570   /* If there were any declarations or structure tags in that level,
 571      or if this level is a function body,
 572      create a BLOCK to record them for the life of this function.  */
 573
 574   block = 0;
 575   block_previously_created = (current_binding_level->this_block != 0);
 576   if (block_previously_created)
 577     block = current_binding_level->this_block;
 578   else if (keep || functionbody
 579            || (current_binding_level->keep_if_subblocks && subblocks != 0))
 580     block = make_node (BLOCK);
 581   if (block != 0)
 582     {
 583       BLOCK_VARS (block) = decls;
 584       BLOCK_SUBBLOCKS (block) = subblocks;
 585     }
 586
 587   /* In each subblock, record that this is its superior.  */
 588
 589   for (link = subblocks; link; link = TREE_CHAIN (link))
 590     BLOCK_SUPERCONTEXT (link) = block;
 591
 592   /* Clear out the meanings of the local variables of this level.  */
 593
 594   for (link = decls; link; link = TREE_CHAIN (link))
 595     {
 596       if (DECL_NAME (link) != 0)
 597         {
 598           /* If the ident. was used or addressed via a local extern decl,
 599              don't forget that fact.  */
 600           if (DECL_EXTERNAL (link))
 601             {
 602               if (TREE_USED (link))
 603                 TREE_USED (DECL_NAME (link)) = 1;
 604               if (TREE_ADDRESSABLE (link))
 605                 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
 606             }
 607           IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
 608         }
 609     }
 610
 611   /* Restore all name-meanings of the outer levels
 612      that were shadowed by this level.  */
 613
 614   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
 615     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
 616
 617   /* If the level being exited is the top level of a function,
 618      check over all the labels, and clear out the current
 619      (function local) meanings of their names.  */
 620
 621   if (functionbody)
 622     {
 623       clear_limbo_values (block);
 624
 625       /* If this is the top level block of a function,
 626          the vars are the function's parameters.
 627          Don't leave them in the BLOCK because they are
 628          found in the FUNCTION_DECL instead.  */
 629
 630       BLOCK_VARS (block) = 0;
 631
 632       /* Clear out the definitions of all label names,
 633          since their scopes end here,
 634          and add them to BLOCK_VARS.  */
 635
 636       for (link = named_labels; link; link = TREE_CHAIN (link))
 637         {
 638           tree label = TREE_VALUE (link);
 639
 640           if (DECL_INITIAL (label) == 0)
 641             {
 642               error_with_decl (label, "label `%s' used but not defined");
 643               /* Avoid crashing later.  */
 644               define_label (input_filename, lineno,
 645                             DECL_NAME (label));
 646             }
 647           else if (warn_unused_label && !TREE_USED (label))
 648             warning_with_decl (label, "label `%s' defined but not used");
 649           IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
 650
 651           /* Put the labels into the "variables" of the
 652              top-level block, so debugger can see them.  */
 653           TREE_CHAIN (label) = BLOCK_VARS (block);
 654           BLOCK_VARS (block) = label;
 655         }
 656     }
 657
 658   /* Pop the current level, and free the structure for reuse.  */
 659
 660   pop_binding_level (&current_binding_level);
 661
 662   /* Dispose of the block that we just made inside some higher level.  */
 663   if (functionbody)
 664     DECL_INITIAL (current_function_decl) = block;
 665   else if (block)
 666     {
 667       if (!block_previously_created)
 668         current_binding_level->blocks
 669           = chainon (current_binding_level->blocks, block);
 670     }
 671   /* If we did not make a block for the level just exited,
 672      any blocks made for inner levels
 673      (since they cannot be recorded as subblocks in that level)
 674      must be carried forward so they will later become subblocks
 675      of something else.  */
 676   else if (subblocks)
 677     current_binding_level->blocks
 678       = chainon (current_binding_level->blocks, subblocks);
 679
 680   /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
 681      binding contour so that they point to the appropriate construct, i.e.
 682      either to the current FUNCTION_DECL node, or else to the BLOCK node
 683      we just constructed.
 684
 685      Note that for tagged types whose scope is just the formal parameter
 686      list for some function type specification, we can't properly set
 687      their TYPE_CONTEXTs here, because we don't have a pointer to the
 688      appropriate FUNCTION_TYPE node readily available to us.  For those
 689      cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
 690      in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
 691      node which will represent the "scope" for these "parameter list local"
 692      tagged types.  */
 693
 694   if (functionbody)
 695     for (link = tags; link; link = TREE_CHAIN (link))
 696       TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
 697   else if (block)
 698     for (link = tags; link; link = TREE_CHAIN (link))
 699       TYPE_CONTEXT (TREE_VALUE (link)) = block;
 700
 701   if (block)
 702     TREE_USED (block) = 1;
 703
 704   return block;
 705 }
 706
 707 /* Insert BLOCK at the end of the list of subblocks of the
 708    current binding level.  This is used when a BIND_EXPR is expanded,
 709    to handle the BLOCK node inside the BIND_EXPR.  */
 710
 711 void
 712 insert_block (block)
 713      tree block;
 714 {
 715   TREE_USED (block) = 1;
 716   current_binding_level->blocks
 717     = chainon (current_binding_level->blocks, block);
 718 }
 719
 720 /* Set the BLOCK node for the innermost scope
 721    (the one we are currently in).  */
 722
 723 void
 724 set_block (block)
 725      tree block;
 726 {
 727   current_binding_level->this_block = block;
 728   current_binding_level->names = chainon (current_binding_level->names,
 729                                           BLOCK_VARS (block));
 730   current_binding_level->blocks = chainon (current_binding_level->blocks,
 731                                            BLOCK_SUBBLOCKS (block));
 732 }
 733 \f
 734 void
 735 push_label_level ()
 736 {
 737   struct binding_level *newlevel;
 738
 739   newlevel = make_binding_level ();
 740
 741   /* Add this level to the front of the chain (stack) of label levels.  */
 742
 743   newlevel->level_chain = label_level_chain;
 744   label_level_chain = newlevel;
 745
 746   newlevel->names = named_labels;
 747   newlevel->shadowed = shadowed_labels;
 748   named_labels = 0;
 749   shadowed_labels = 0;
 750 }
 751
 752 void
 753 pop_label_level ()
 754 {
 755   struct binding_level *level = label_level_chain;
 756   tree link, prev;
 757
 758   /* Clear out the definitions of the declared labels in this level.
 759      Leave in the list any ordinary, non-declared labels.  */
 760   for (link = named_labels, prev = 0; link;)
 761     {
 762       if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
 763         {
 764           if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
 765             {
 766               error_with_decl (TREE_VALUE (link),
 767                                "label `%s' used but not defined");
 768               /* Avoid crashing later.  */
 769               define_label (input_filename, lineno,
 770                             DECL_NAME (TREE_VALUE (link)));
 771             }
 772           else if (warn_unused_label && !TREE_USED (TREE_VALUE (link)))
 773             warning_with_decl (TREE_VALUE (link),
 774                                "label `%s' defined but not used");
 775           IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
 776
 777           /* Delete this element from the list.  */
 778           link = TREE_CHAIN (link);
 779           if (prev)
 780             TREE_CHAIN (prev) = link;
 781           else
 782             named_labels = link;
 783         }
 784       else
 785         {
 786           prev = link;
 787           link = TREE_CHAIN (link);
 788         }
 789     }
 790
 791   /* Bring back all the labels that were shadowed.  */
 792   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
 793     if (DECL_NAME (TREE_VALUE (link)) != 0)
 794       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
 795         = TREE_VALUE (link);
 796
 797   named_labels = chainon (named_labels, level->names);
 798   shadowed_labels = level->shadowed;
 799
 800   /* Pop the current level, and free the structure for reuse.  */
 801   pop_binding_level (&label_level_chain);
 802 }
 803 \f
 804 /* Push a definition or a declaration of struct, union or enum tag "name".
 805    "type" should be the type node.
 806    We assume that the tag "name" is not already defined.
 807
 808    Note that the definition may really be just a forward reference.
 809    In that case, the TYPE_SIZE will be zero.  */
 810
 811 void
 812 pushtag (name, type)
 813      tree name, type;
 814 {
 815   struct binding_level *b;
 816
 817   /* Find the proper binding level for this type tag.  */
 818
 819   for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
 820     continue;
 821
 822   if (name)
 823     {
 824       /* Record the identifier as the type's name if it has none.  */
 825
 826       if (TYPE_NAME (type) == 0)
 827         TYPE_NAME (type) = name;
 828     }
 829
 830   b->tags = tree_cons (name, type, b->tags);
 831
 832   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
 833      tagged type we just added to the current binding level.  This fake
 834      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
 835      to output a representation of a tagged type, and it also gives
 836      us a convenient place to record the "scope start" address for the
 837      tagged type.  */
 838
 839   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
 840
 841   /* An approximation for now, so we can tell this is a function-scope tag.
 842      This will be updated in poplevel.  */
 843   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
 844 }
 845 \f
 846 /* Handle when a new declaration NEWDECL
 847    has the same name as an old one OLDDECL
 848    in the same binding contour.
 849    Prints an error message if appropriate.
 850
 851    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
 852    Otherwise, return 0.
 853
 854    When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
 855    and OLDDECL is in an outer binding level and should thus not be changed.  */
 856
 857 static int
 858 duplicate_decls (newdecl, olddecl, different_binding_level)
 859      tree newdecl, olddecl;
 860      int different_binding_level;
 861 {
 862   int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
 863   int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
 864                            && DECL_INITIAL (newdecl) != 0);
 865   tree oldtype = TREE_TYPE (olddecl);
 866   tree newtype = TREE_TYPE (newdecl);
 867   int errmsg = 0;
 868
 869   if (DECL_P (olddecl))
 870     {
 871       if (TREE_CODE (newdecl) == FUNCTION_DECL
 872           && TREE_CODE (olddecl) == FUNCTION_DECL
 873           && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
 874         {
 875           if (DECL_DECLARED_INLINE_P (newdecl)
 876               && DECL_UNINLINABLE (newdecl)
 877               && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
 878             /* Already warned elsewhere.  */;
 879           else if (DECL_DECLARED_INLINE_P (olddecl)
 880                    && DECL_UNINLINABLE (olddecl)
 881                    && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
 882             /* Already warned.  */;
 883           else if (DECL_DECLARED_INLINE_P (newdecl)
 884                    && ! DECL_DECLARED_INLINE_P (olddecl)
 885                    && DECL_UNINLINABLE (olddecl)
 886                    && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
 887             {
 888               warning_with_decl (newdecl,
 889                                  "function `%s' redeclared as inline");
 890               warning_with_decl (olddecl,
 891                                  "previous declaration of function `%s' with attribute noinline");
 892             }
 893           else if (DECL_DECLARED_INLINE_P (olddecl)
 894                    && DECL_UNINLINABLE (newdecl)
 895                    && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
 896             {
 897               warning_with_decl (newdecl,
 898                                  "function `%s' redeclared with attribute noinline");
 899               warning_with_decl (olddecl,
 900                                  "previous declaration of function `%s' was inline");
 901             }
 902         }
 903
 904       DECL_ATTRIBUTES (newdecl)
 905         = (*targetm.merge_decl_attributes) (olddecl, newdecl);
 906     }
 907
 908   if (TREE_CODE (newtype) == ERROR_MARK
 909       || TREE_CODE (oldtype) == ERROR_MARK)
 910     types_match = 0;
 911
 912   /* New decl is completely inconsistent with the old one =>
 913      tell caller to replace the old one.
 914      This is always an error except in the case of shadowing a builtin.  */
 915   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
 916     {
 917       if (TREE_CODE (olddecl) == FUNCTION_DECL
 918           && (DECL_BUILT_IN (olddecl)
 919               || DECL_BUILT_IN_NONANSI (olddecl)))
 920         {
 921           /* If you declare a built-in or predefined function name as static,
 922              the old definition is overridden,
 923              but optionally warn this was a bad choice of name.  */
 924           if (!TREE_PUBLIC (newdecl))
 925             {
 926               if (!warn_shadow)
 927                 ;
 928               else if (DECL_BUILT_IN (olddecl))
 929                 warning_with_decl (newdecl, "shadowing built-in function `%s'");
 930               else
 931                 warning_with_decl (newdecl, "shadowing library function `%s'");
 932             }
 933           /* Likewise, if the built-in is not ansi, then programs can
 934              override it even globally without an error.  */
 935           else if (! DECL_BUILT_IN (olddecl))
 936             warning_with_decl (newdecl,
 937                                "library function `%s' declared as non-function");
 938
 939           else if (DECL_BUILT_IN_NONANSI (olddecl))
 940             warning_with_decl (newdecl,
 941                                "built-in function `%s' declared as non-function");
 942           else
 943             warning_with_decl (newdecl,
 944                                "built-in function `%s' declared as non-function");
 945         }
 946       else
 947         {
 948           error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
 949           error_with_decl (olddecl, "previous declaration of `%s'");
 950         }
 951
 952       return 0;
 953     }
 954
 955   /* For real parm decl following a forward decl,
 956      return 1 so old decl will be reused.  */
 957   if (types_match && TREE_CODE (newdecl) == PARM_DECL
 958       && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
 959     return 1;
 960
 961   /* The new declaration is the same kind of object as the old one.
 962      The declarations may partially match.  Print warnings if they don't
 963      match enough.  Ultimately, copy most of the information from the new
 964      decl to the old one, and keep using the old one.  */
 965
 966   if (TREE_CODE (olddecl) == FUNCTION_DECL && DECL_BUILT_IN (olddecl))
 967     {
 968       /* A function declaration for a built-in function.  */
 969       if (!TREE_PUBLIC (newdecl))
 970         {
 971           /* If you declare a built-in function name as static, the
 972              built-in definition is overridden,
 973              but optionally warn this was a bad choice of name.  */
 974           if (warn_shadow)
 975             warning_with_decl (newdecl, "shadowing built-in function `%s'");
 976           /* Discard the old built-in function.  */
 977           return 0;
 978         }
 979       else if (!types_match)
 980         {
 981           /* Accept the return type of the new declaration if same modes.  */
 982           tree oldreturntype = TREE_TYPE (oldtype);
 983           tree newreturntype = TREE_TYPE (newtype);
 984
 985           if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
 986             {
 987               /* Function types may be shared, so we can't just modify
 988                  the return type of olddecl's function type.  */
 989               tree trytype
 990                 = build_function_type (newreturntype,
 991                                        TYPE_ARG_TYPES (oldtype));
 992               trytype = build_type_attribute_variant (trytype,
 993                                                       TYPE_ATTRIBUTES (oldtype));
 994
 995               types_match = comptypes (newtype, trytype);
 996               if (types_match)
 997                 oldtype = trytype;
 998             }
 999           /* Accept harmless mismatch in first argument type also.
1000              This is for the ffs and fprintf builtins.  */
1001           if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
1002               && TYPE_ARG_TYPES (oldtype) != 0
1003               && TREE_VALUE (TYPE_ARG_TYPES (newtype)) != 0
1004               && TREE_VALUE (TYPE_ARG_TYPES (oldtype)) != 0
1005               && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (newtype)))
1006                   == TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (oldtype)))))
1007             {
1008               /* Function types may be shared, so we can't just modify
1009                  the return type of olddecl's function type.  */
1010               tree trytype
1011                 = build_function_type (TREE_TYPE (oldtype),
1012                                        tree_cons (NULL_TREE,
1013                                                   TREE_VALUE (TYPE_ARG_TYPES (newtype)),
1014                                                   TREE_CHAIN (TYPE_ARG_TYPES (oldtype))));
1015               trytype = build_type_attribute_variant (trytype,
1016                                                       TYPE_ATTRIBUTES (oldtype));
1017
1018               types_match = comptypes (newtype, trytype);
1019               if (types_match)
1020                 oldtype = trytype;
1021             }
1022           if (! different_binding_level)
1023             TREE_TYPE (olddecl) = oldtype;
1024         }
1025       else if (TYPE_ARG_TYPES (oldtype) == NULL
1026                && TYPE_ARG_TYPES (newtype) != NULL)
1027         {
1028           /* For bcmp, bzero, fputs the builtin type has arguments not
1029              specified.  Use the ones from the prototype so that type checking
1030              is done for them.  */
1031           tree trytype
1032             = build_function_type (TREE_TYPE (oldtype),
1033                                    TYPE_ARG_TYPES (newtype));
1034           trytype = build_type_attribute_variant (trytype,
1035                                                   TYPE_ATTRIBUTES (oldtype));
1036
1037           oldtype = trytype;
1038           if (! different_binding_level)
1039             TREE_TYPE (olddecl) = oldtype;
1040         }
1041       if (!types_match)
1042         {
1043           /* If types don't match for a built-in, throw away the built-in.  */
1044           warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1045           return 0;
1046         }
1047     }
1048   else if (TREE_CODE (olddecl) == FUNCTION_DECL
1049            && DECL_SOURCE_LINE (olddecl) == 0)
1050     {
1051       /* A function declaration for a predeclared function
1052          that isn't actually built in.  */
1053       if (!TREE_PUBLIC (newdecl))
1054         {
1055           /* If you declare it as static, the
1056              default definition is overridden.  */
1057           return 0;
1058         }
1059       else if (!types_match)
1060         {
1061           /* If the types don't match, preserve volatility indication.
1062              Later on, we will discard everything else about the
1063              default declaration.  */
1064           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1065         }
1066     }
1067   /* Permit char *foo () to match void *foo (...) if not pedantic,
1068      if one of them came from a system header file.  */
1069   else if (!types_match
1070            && TREE_CODE (olddecl) == FUNCTION_DECL
1071            && TREE_CODE (newdecl) == FUNCTION_DECL
1072            && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
1073            && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
1074            && (DECL_IN_SYSTEM_HEADER (olddecl)
1075                || DECL_IN_SYSTEM_HEADER (newdecl))
1076            && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
1077                 && TYPE_ARG_TYPES (oldtype) == 0
1078                 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
1079                 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
1080                ||
1081                (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
1082                 && TYPE_ARG_TYPES (newtype) == 0
1083                 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
1084                 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
1085     {
1086       if (pedantic)
1087         pedwarn_with_decl (newdecl, "conflicting types for `%s'");
1088       /* Make sure we keep void * as ret type, not char *.  */
1089       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
1090         TREE_TYPE (newdecl) = newtype = oldtype;
1091
1092       /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1093          we will come back here again.  */
1094       DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1095     }
1096   else if (!types_match
1097            /* Permit char *foo (int, ...); followed by char *foo ();
1098               if not pedantic.  */
1099            && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1100                  && ! pedantic
1101                  /* Return types must still match.  */
1102                  && comptypes (TREE_TYPE (oldtype),
1103                                TREE_TYPE (newtype))
1104                  && TYPE_ARG_TYPES (newtype) == 0))
1105     {
1106       error_with_decl (newdecl, "conflicting types for `%s'");
1107       /* Check for function type mismatch
1108          involving an empty arglist vs a nonempty one.  */
1109       if (TREE_CODE (olddecl) == FUNCTION_DECL
1110           && comptypes (TREE_TYPE (oldtype),
1111                         TREE_TYPE (newtype))
1112           && ((TYPE_ARG_TYPES (oldtype) == 0
1113                && DECL_INITIAL (olddecl) == 0)
1114               ||
1115               (TYPE_ARG_TYPES (newtype) == 0
1116                && DECL_INITIAL (newdecl) == 0)))
1117         {
1118           /* Classify the problem further.  */
1119           tree t = TYPE_ARG_TYPES (oldtype);
1120           if (t == 0)
1121             t = TYPE_ARG_TYPES (newtype);
1122           for (; t; t = TREE_CHAIN (t))
1123             {
1124               tree type = TREE_VALUE (t);
1125
1126               if (TREE_CHAIN (t) == 0
1127                   && TYPE_MAIN_VARIANT (type) != void_type_node)
1128                 {
1129                   error ("a parameter list with an ellipsis can't match an empty parameter name list declaration");
1130                   break;
1131                 }
1132
1133               if (c_type_promotes_to (type) != type)
1134                 {
1135                   error ("an argument type that has a default promotion can't match an empty parameter name list declaration");
1136                   break;
1137                 }
1138             }
1139         }
1140       error_with_decl (olddecl, "previous declaration of `%s'");
1141     }
1142   /* TLS cannot follow non-TLS declaration.  */
1143   else if (TREE_CODE (olddecl) == VAR_DECL && TREE_CODE (newdecl) == VAR_DECL
1144            && !DECL_THREAD_LOCAL (olddecl) && DECL_THREAD_LOCAL (newdecl))
1145     {
1146       error_with_decl (newdecl, "thread-local declaration of `%s' follows non thread-local declaration");
1147       error_with_decl (olddecl, "previous declaration of `%s'");
1148     }
1149   /* non-TLS declaration cannot follow TLS declaration.  */
1150   else if (TREE_CODE (olddecl) == VAR_DECL && TREE_CODE (newdecl) == VAR_DECL
1151            && DECL_THREAD_LOCAL (olddecl) && !DECL_THREAD_LOCAL (newdecl))
1152     {
1153       error_with_decl (newdecl, "non thread-local declaration of `%s' follows thread-local declaration");
1154       error_with_decl (olddecl, "previous declaration of `%s'");
1155     }
1156   else
1157     {
1158       errmsg = redeclaration_error_message (newdecl, olddecl);
1159       if (errmsg)
1160         {
1161           switch (errmsg)
1162             {
1163             case 1:
1164               error_with_decl (newdecl, "redefinition of `%s'");
1165               break;
1166             case 2:
1167               error_with_decl (newdecl, "redeclaration of `%s'");
1168               break;
1169             case 3:
1170               error_with_decl (newdecl, "conflicting declarations of `%s'");
1171               break;
1172             default:
1173               abort ();
1174             }
1175
1176           error_with_decl (olddecl,
1177                            ((DECL_INITIAL (olddecl)
1178                              && current_binding_level == global_binding_level)
1179                             ? "`%s' previously defined here"
1180                             : "`%s' previously declared here"));
1181           return 0;
1182         }
1183       else if (TREE_CODE (newdecl) == TYPE_DECL
1184                && (DECL_IN_SYSTEM_HEADER (olddecl)
1185                    || DECL_IN_SYSTEM_HEADER (newdecl)))
1186         {
1187           warning_with_decl (newdecl, "redefinition of `%s'");
1188           warning_with_decl
1189             (olddecl,
1190              ((DECL_INITIAL (olddecl)
1191                && current_binding_level == global_binding_level)
1192               ? "`%s' previously defined here"
1193               : "`%s' previously declared here"));
1194         }
1195       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1196                && DECL_INITIAL (olddecl) != 0
1197                && TYPE_ARG_TYPES (oldtype) == 0
1198                && TYPE_ARG_TYPES (newtype) != 0
1199                && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1200         {
1201           tree type, parm;
1202           int nargs;
1203           /* Prototype decl follows defn w/o prototype.  */
1204
1205           for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1206                type = TYPE_ARG_TYPES (newtype),
1207                nargs = 1;
1208                ;
1209                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1210             {
1211               if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1212                   && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1213                 {
1214                   warning_with_decl (newdecl, "prototype for `%s' follows");
1215                   warning_with_decl (olddecl, "non-prototype definition here");
1216                   break;
1217                 }
1218               if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1219                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1220                 {
1221                   error_with_decl (newdecl,
1222                                    "prototype for `%s' follows and number of arguments doesn't match");
1223                   error_with_decl (olddecl, "non-prototype definition here");
1224                   errmsg = 1;
1225                   break;
1226                 }
1227               /* Type for passing arg must be consistent
1228                  with that declared for the arg.  */
1229               if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type)))
1230                 {
1231                   error_with_decl (newdecl,
1232                                    "prototype for `%s' follows and argument %d doesn't match",
1233                                    nargs);
1234                   error_with_decl (olddecl, "non-prototype definition here");
1235                   errmsg = 1;
1236                   break;
1237                 }
1238             }
1239         }
1240       /* Warn about mismatches in various flags.  */
1241       else
1242         {
1243           /* Warn if function is now inline
1244              but was previously declared not inline and has been called.  */
1245           if (TREE_CODE (olddecl) == FUNCTION_DECL
1246               && ! DECL_DECLARED_INLINE_P (olddecl)
1247               && DECL_DECLARED_INLINE_P (newdecl)
1248               && TREE_USED (olddecl))
1249             warning_with_decl (newdecl,
1250                                "`%s' declared inline after being called");
1251           if (TREE_CODE (olddecl) == FUNCTION_DECL
1252               && ! DECL_DECLARED_INLINE_P (olddecl)
1253               && DECL_DECLARED_INLINE_P (newdecl)
1254               && DECL_INITIAL (olddecl) != 0)
1255             warning_with_decl (newdecl,
1256                                "`%s' declared inline after its definition");
1257
1258           /* If pedantic, warn when static declaration follows a non-static
1259              declaration.  Otherwise, do so only for functions.  */
1260           if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1261               && TREE_PUBLIC (olddecl)
1262               && !TREE_PUBLIC (newdecl))
1263             warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1264
1265           /* If warn_traditional, warn when a non-static function
1266              declaration follows a static one.  */
1267           if (warn_traditional && !in_system_header
1268               && TREE_CODE (olddecl) == FUNCTION_DECL
1269               && !TREE_PUBLIC (olddecl)
1270               && TREE_PUBLIC (newdecl))
1271             warning_with_decl (newdecl, "non-static declaration for `%s' follows static");
1272
1273           /* Warn when const declaration follows a non-const
1274              declaration, but not for functions.  */
1275           if (TREE_CODE (olddecl) != FUNCTION_DECL
1276               && !TREE_READONLY (olddecl)
1277               && TREE_READONLY (newdecl))
1278             warning_with_decl (newdecl, "const declaration for `%s' follows non-const");
1279           /* These bits are logically part of the type, for variables.
1280              But not for functions
1281              (where qualifiers are not valid ANSI anyway).  */
1282           else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1283               && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1284                   || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1285             pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1286         }
1287     }
1288
1289   /* Optionally warn about more than one declaration for the same name.  */
1290   if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1291       /* Don't warn about a function declaration
1292          followed by a definition.  */
1293       && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1294            && DECL_INITIAL (olddecl) == 0)
1295       /* Don't warn about extern decl followed by (tentative) definition.  */
1296       && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1297     {
1298       warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
1299       warning_with_decl (olddecl, "previous declaration of `%s'");
1300     }
1301
1302   /* Copy all the DECL_... slots specified in the new decl
1303      except for any that we copy here from the old type.
1304
1305      Past this point, we don't change OLDTYPE and NEWTYPE
1306      even if we change the types of NEWDECL and OLDDECL.  */
1307
1308   if (types_match)
1309     {
1310       /* When copying info to olddecl, we store into write_olddecl
1311          instead.  This allows us to avoid modifying olddecl when
1312          different_binding_level is true.  */
1313       tree write_olddecl = different_binding_level ? newdecl : olddecl;
1314
1315       /* Merge the data types specified in the two decls.  */
1316       if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1317         {
1318           if (different_binding_level)
1319             {
1320               if (TYPE_ARG_TYPES (oldtype) != 0
1321                   && TYPE_ARG_TYPES (newtype) == 0)
1322                 TREE_TYPE (newdecl) = common_type (newtype, oldtype);
1323               else
1324                 TREE_TYPE (newdecl)
1325                   = build_type_attribute_variant
1326                     (newtype,
1327                      merge_attributes (TYPE_ATTRIBUTES (newtype),
1328                                        TYPE_ATTRIBUTES (oldtype)));
1329             }
1330           else
1331             TREE_TYPE (newdecl)
1332               = TREE_TYPE (olddecl)
1333                 = common_type (newtype, oldtype);
1334         }
1335
1336       /* Lay the type out, unless already done.  */
1337       if (oldtype != TREE_TYPE (newdecl))
1338         {
1339           if (TREE_TYPE (newdecl) != error_mark_node)
1340             layout_type (TREE_TYPE (newdecl));
1341           if (TREE_CODE (newdecl) != FUNCTION_DECL
1342               && TREE_CODE (newdecl) != TYPE_DECL
1343               && TREE_CODE (newdecl) != CONST_DECL)
1344             layout_decl (newdecl, 0);
1345         }
1346       else
1347         {
1348           /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
1349           DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1350           DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1351           DECL_MODE (newdecl) = DECL_MODE (olddecl);
1352           if (TREE_CODE (olddecl) != FUNCTION_DECL)
1353             if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1354               {
1355                 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1356                 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1357               }
1358         }
1359
1360       /* Keep the old rtl since we can safely use it.  */
1361       COPY_DECL_RTL (olddecl, newdecl);
1362
1363       /* Merge the type qualifiers.  */
1364       if (TREE_READONLY (newdecl))
1365         TREE_READONLY (write_olddecl) = 1;
1366
1367       if (TREE_THIS_VOLATILE (newdecl))
1368         {
1369           TREE_THIS_VOLATILE (write_olddecl) = 1;
1370           if (TREE_CODE (newdecl) == VAR_DECL
1371               /* If an automatic variable is re-declared in the same
1372                  function scope, but the old declaration was not
1373                  volatile, make_var_volatile() would crash because the
1374                  variable would have been assigned to a pseudo, not a
1375                  MEM.  Since this duplicate declaration is invalid
1376                  anyway, we just skip the call.  */
1377               && errmsg == 0)
1378             make_var_volatile (newdecl);
1379         }
1380
1381       /* Keep source location of definition rather than declaration.  */
1382       /* When called with different_binding_level set, keep the old
1383          information so that meaningful diagnostics can be given.  */
1384       if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1385           && ! different_binding_level)
1386         {
1387           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1388           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1389         }
1390
1391       /* Merge the unused-warning information.  */
1392       if (DECL_IN_SYSTEM_HEADER (olddecl))
1393         DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1394       else if (DECL_IN_SYSTEM_HEADER (newdecl))
1395         DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1396
1397       /* Merge the initialization information.  */
1398       /* When called with different_binding_level set, don't copy over
1399          DECL_INITIAL, so that we don't accidentally change function
1400          declarations into function definitions.  */
1401       if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1402         DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1403
1404       /* Merge the section attribute.
1405          We want to issue an error if the sections conflict but that must be
1406          done later in decl_attributes since we are called before attributes
1407          are assigned.  */
1408       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1409         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1410
1411       /* Copy the assembler name.
1412          Currently, it can only be defined in the prototype.  */
1413       COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1414
1415       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1416         {
1417           DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1418           DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1419           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1420           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1421             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1422         }
1423     }
1424   /* If cannot merge, then use the new type and qualifiers,
1425      and don't preserve the old rtl.  */
1426   else if (! different_binding_level)
1427     {
1428       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1429       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1430       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1431       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1432     }
1433
1434   /* Merge the storage class information.  */
1435   merge_weak (newdecl, olddecl);
1436
1437   /* For functions, static overrides non-static.  */
1438   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1439     {
1440       TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1441       /* This is since we don't automatically
1442          copy the attributes of NEWDECL into OLDDECL.  */
1443       /* No need to worry about different_binding_level here because
1444          then TREE_PUBLIC (newdecl) was true.  */
1445       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1446       /* If this clears `static', clear it in the identifier too.  */
1447       if (! TREE_PUBLIC (olddecl))
1448         TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1449     }
1450   if (DECL_EXTERNAL (newdecl))
1451     {
1452       if (! different_binding_level)
1453         {
1454           /* Don't mess with these flags on local externs; they remain
1455              external even if there's a declaration at file scope which
1456              isn't.  */
1457           TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1458           DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1459         }
1460       /* An extern decl does not override previous storage class.  */
1461       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1462       if (! DECL_EXTERNAL (newdecl))
1463         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1464     }
1465   else
1466     {
1467       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1468       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1469     }
1470
1471   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1472     {
1473       /* If we're redefining a function previously defined as extern
1474          inline, make sure we emit debug info for the inline before we
1475          throw it away, in case it was inlined into a function that hasn't
1476          been written out yet.  */
1477       if (new_is_definition && DECL_INITIAL (olddecl) && TREE_USED (olddecl))
1478         {
1479           (*debug_hooks->outlining_inline_function) (olddecl);
1480
1481           /* The new defn must not be inline.  */
1482           DECL_INLINE (newdecl) = 0;
1483           DECL_UNINLINABLE (newdecl) = 1;
1484         }
1485       else
1486         {
1487           /* If either decl says `inline', this fn is inline,
1488              unless its definition was passed already.  */
1489           if (DECL_DECLARED_INLINE_P (newdecl)
1490               || DECL_DECLARED_INLINE_P (olddecl))
1491             DECL_DECLARED_INLINE_P (newdecl) = 1;
1492
1493           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1494             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1495         }
1496
1497       if (DECL_BUILT_IN (olddecl))
1498         {
1499           /* Get rid of any built-in function if new arg types don't match it
1500              or if we have a function definition.  */
1501           if (! types_match || new_is_definition)
1502             {
1503               if (! different_binding_level)
1504                 {
1505                   TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1506                   DECL_BUILT_IN_CLASS (olddecl) = NOT_BUILT_IN;
1507                 }
1508             }
1509           else
1510             {
1511               /* If redeclaring a builtin function, and not a definition,
1512                  it stays built in.  */
1513               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1514               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1515             }
1516         }
1517
1518       /* Also preserve various other info from the definition.  */
1519       if (! new_is_definition)
1520         {
1521           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1522           /* When called with different_binding_level set, don't copy over
1523              DECL_INITIAL, so that we don't accidentally change function
1524              declarations into function definitions.  */
1525           if (! different_binding_level)
1526             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1527           DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1528           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1529           DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
1530           DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1531
1532           /* Set DECL_INLINE on the declaration if we've got a body
1533              from which to instantiate.  */
1534           if (DECL_INLINE (olddecl) && ! DECL_UNINLINABLE (newdecl))
1535             {
1536               DECL_INLINE (newdecl) = 1;
1537               DECL_ABSTRACT_ORIGIN (newdecl)
1538                 = (different_binding_level
1539                    ? DECL_ORIGIN (olddecl)
1540                    : DECL_ABSTRACT_ORIGIN (olddecl));
1541             }
1542         }
1543       else
1544         {
1545           /* If a previous declaration said inline, mark the
1546              definition as inlinable.  */
1547           if (DECL_DECLARED_INLINE_P (newdecl)
1548               && ! DECL_UNINLINABLE (newdecl))
1549             DECL_INLINE (newdecl) = 1;
1550         }
1551     }
1552   if (different_binding_level)
1553     return 0;
1554
1555   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1556      But preserve OLDDECL's DECL_UID.  */
1557   {
1558     unsigned olddecl_uid = DECL_UID (olddecl);
1559
1560     memcpy ((char *) olddecl + sizeof (struct tree_common),
1561             (char *) newdecl + sizeof (struct tree_common),
1562             sizeof (struct tree_decl) - sizeof (struct tree_common));
1563     DECL_UID (olddecl) = olddecl_uid;
1564   }
1565
1566   /* NEWDECL contains the merged attribute lists.
1567      Update OLDDECL to be the same.  */
1568   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1569
1570   return 1;
1571 }
1572
1573 /* Check whether decl-node X shadows an existing declaration.
1574    OLDLOCAL is the old IDENTIFIER_LOCAL_VALUE of the DECL_NAME of X,
1575    which might be a NULL_TREE.  */
1576 static void
1577 warn_if_shadowing (x, oldlocal)
1578      tree x, oldlocal;
1579 {
1580   tree name;
1581
1582   if (DECL_EXTERNAL (x))
1583     return;
1584
1585   name = DECL_NAME (x);
1586
1587   /* Warn if shadowing an argument at the top level of the body.  */
1588   if (oldlocal != 0
1589       /* This warning doesn't apply to the parms of a nested fcn.  */
1590       && ! current_binding_level->parm_flag
1591       /* Check that this is one level down from the parms.  */
1592       && current_binding_level->level_chain->parm_flag
1593       /* Check that the decl being shadowed
1594          comes from the parm level, one level up.  */
1595       && chain_member (oldlocal, current_binding_level->level_chain->names))
1596     {
1597       if (TREE_CODE (oldlocal) == PARM_DECL)
1598         pedwarn ("declaration of `%s' shadows a parameter",
1599                  IDENTIFIER_POINTER (name));
1600       else
1601         pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1602                  IDENTIFIER_POINTER (name));
1603     }
1604   /* Maybe warn if shadowing something else.  */
1605   else if (warn_shadow
1606            /* No shadow warnings for internally generated vars.  */
1607            && DECL_SOURCE_LINE (x) != 0
1608            /* No shadow warnings for vars made for inlining.  */
1609            && ! DECL_FROM_INLINE (x))
1610     {
1611       if (TREE_CODE (x) == PARM_DECL
1612           && current_binding_level->level_chain->parm_flag)
1613         /* Don't warn about the parm names in function declarator
1614            within a function declarator.
1615            It would be nice to avoid warning in any function
1616            declarator in a declaration, as opposed to a definition,
1617            but there is no way to tell it's not a definition.  */
1618         ;
1619       else if (oldlocal)
1620         {
1621           if (TREE_CODE (oldlocal) == PARM_DECL)
1622             shadow_warning ("a parameter", name, oldlocal);
1623           else
1624             shadow_warning ("a previous local", name, oldlocal);
1625         }
1626       else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1627                && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1628         shadow_warning ("a global declaration", name,
1629                         IDENTIFIER_GLOBAL_VALUE (name));
1630     }
1631 }
1632
1633 /* Record a decl-node X as belonging to the current lexical scope.
1634    Check for errors (such as an incompatible declaration for the same
1635    name already seen in the same scope).
1636
1637    Returns either X or an old decl for the same name.
1638    If an old decl is returned, it may have been smashed
1639    to agree with what X says.  */
1640
1641 tree
1642 pushdecl (x)
1643      tree x;
1644 {
1645   tree t;
1646   tree name = DECL_NAME (x);
1647   struct binding_level *b = current_binding_level;
1648
1649   /* Functions need the lang_decl data.  */
1650   if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
1651     DECL_LANG_SPECIFIC (x) = (struct lang_decl *)
1652       ggc_alloc_cleared (sizeof (struct lang_decl));
1653
1654   DECL_CONTEXT (x) = current_function_decl;
1655   /* A local extern declaration for a function doesn't constitute nesting.
1656      A local auto declaration does, since it's a forward decl
1657      for a nested function coming later.  */
1658   if ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
1659       && DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x))
1660     DECL_CONTEXT (x) = 0;
1661
1662   if (name)
1663     {
1664       int different_binding_level = 0;
1665
1666       if (warn_nested_externs
1667           && DECL_EXTERNAL (x)
1668           && b != global_binding_level
1669           && x != IDENTIFIER_IMPLICIT_DECL (name)
1670           /* No error messages for __FUNCTION__ and __PRETTY_FUNCTION__.  */
1671           && !DECL_IN_SYSTEM_HEADER (x))
1672         warning ("nested extern declaration of `%s'",
1673                  IDENTIFIER_POINTER (name));
1674
1675       t = lookup_name_current_level (name);
1676       if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
1677         {
1678           t = IDENTIFIER_GLOBAL_VALUE (name);
1679           /* Type decls at global scope don't conflict with externs declared
1680              inside lexical blocks.  */
1681           if (! t || TREE_CODE (t) == TYPE_DECL)
1682             /* If there's no visible global declaration, try for an
1683                invisible one.  */
1684             t = IDENTIFIER_LIMBO_VALUE (name);
1685           different_binding_level = 1;
1686         }
1687       if (t != 0 && t == error_mark_node)
1688         /* error_mark_node is 0 for a while during initialization!  */
1689         {
1690           t = 0;
1691           error_with_decl (x, "`%s' used prior to declaration");
1692         }
1693
1694       /* If this decl is `static' and an implicit decl was seen previously,
1695          warn.  */
1696       if (TREE_PUBLIC (name)
1697           /* Don't test for DECL_EXTERNAL, because grokdeclarator
1698              sets this for all functions.  */
1699           && ! TREE_PUBLIC (x)
1700           && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
1701           /* We used to warn also for explicit extern followed by static,
1702              but sometimes you need to do it that way.  */
1703           && IDENTIFIER_IMPLICIT_DECL (name) != 0)
1704         {
1705           pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1706                    IDENTIFIER_POINTER (name));
1707           pedwarn_with_file_and_line
1708             (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
1709              DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
1710              "previous declaration of `%s'",
1711              IDENTIFIER_POINTER (name));
1712           TREE_THIS_VOLATILE (name) = 1;
1713         }
1714
1715       if (t != 0 && duplicate_decls (x, t, different_binding_level))
1716         {
1717           if (TREE_CODE (t) == PARM_DECL)
1718             {
1719               /* Don't allow more than one "real" duplicate
1720                  of a forward parm decl.  */
1721               TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
1722               return t;
1723             }
1724           return t;
1725         }
1726
1727       /* If we are processing a typedef statement, generate a whole new
1728          ..._TYPE node (which will be just an variant of the existing
1729          ..._TYPE node with identical properties) and then install the
1730          TYPE_DECL node generated to represent the typedef name as the
1731          TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1732
1733          The whole point here is to end up with a situation where each
1734          and every ..._TYPE node the compiler creates will be uniquely
1735          associated with AT MOST one node representing a typedef name.
1736          This way, even though the compiler substitutes corresponding
1737          ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1738          early on, later parts of the compiler can always do the reverse
1739          translation and get back the corresponding typedef name.  For
1740          example, given:
1741
1742                 typedef struct S MY_TYPE;
1743                 MY_TYPE object;
1744
1745          Later parts of the compiler might only know that `object' was of
1746          type `struct S' if it were not for code just below.  With this
1747          code however, later parts of the compiler see something like:
1748
1749                 struct S' == struct S
1750                 typedef struct S' MY_TYPE;
1751                 struct S' object;
1752
1753          And they can then deduce (from the node for type struct S') that
1754          the original object declaration was:
1755
1756                 MY_TYPE object;
1757
1758          Being able to do this is important for proper support of protoize,
1759          and also for generating precise symbolic debugging information
1760          which takes full account of the programmer's (typedef) vocabulary.
1761
1762          Obviously, we don't want to generate a duplicate ..._TYPE node if
1763          the TYPE_DECL node that we are now processing really represents a
1764          standard built-in type.
1765
1766          Since all standard types are effectively declared at line zero
1767          in the source file, we can easily check to see if we are working
1768          on a standard type by checking the current value of lineno.  */
1769
1770       if (TREE_CODE (x) == TYPE_DECL)
1771         {
1772           if (DECL_SOURCE_LINE (x) == 0)
1773             {
1774               if (TYPE_NAME (TREE_TYPE (x)) == 0)
1775                 TYPE_NAME (TREE_TYPE (x)) = x;
1776             }
1777           else if (TREE_TYPE (x) != error_mark_node
1778                    && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
1779             {
1780               tree tt = TREE_TYPE (x);
1781               DECL_ORIGINAL_TYPE (x) = tt;
1782               tt = build_type_copy (tt);
1783               TYPE_NAME (tt) = x;
1784               TREE_USED (tt) = TREE_USED (x);
1785               TREE_TYPE (x) = tt;
1786             }
1787         }
1788
1789       /* Multiple external decls of the same identifier ought to match.
1790          We get warnings about inline functions where they are defined.
1791          Avoid duplicate warnings where they are used.  */
1792       if (TREE_PUBLIC (x)
1793           && ! (TREE_CODE (x) == FUNCTION_DECL && DECL_INLINE (x)))
1794         {
1795           tree decl;
1796
1797           if (IDENTIFIER_LIMBO_VALUE (name) != 0)
1798             /* Decls in limbo are always extern, so no need to check that.  */
1799             decl = IDENTIFIER_LIMBO_VALUE (name);
1800           else
1801             decl = 0;
1802
1803           if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
1804               /* If old decl is built-in, we already warned if we should.  */
1805               && !DECL_BUILT_IN (decl))
1806             {
1807               pedwarn_with_decl (x,
1808                                  "type mismatch with previous external decl");
1809               pedwarn_with_decl (decl, "previous external decl of `%s'");
1810             }
1811         }
1812
1813       /* If a function has had an implicit declaration, and then is defined,
1814          make sure they are compatible.  */
1815
1816       if (IDENTIFIER_IMPLICIT_DECL (name) != 0
1817           && IDENTIFIER_GLOBAL_VALUE (name) == 0
1818           && TREE_CODE (x) == FUNCTION_DECL
1819           && ! comptypes (TREE_TYPE (x),
1820                           TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
1821         {
1822           warning_with_decl (x, "type mismatch with previous implicit declaration");
1823           warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
1824                              "previous implicit declaration of `%s'");
1825         }
1826
1827       /* This name is new in its binding level.
1828          Install the new declaration and return it.  */
1829       if (b == global_binding_level)
1830         {
1831           /* Install a global value.  */
1832
1833           /* If the first global decl has external linkage,
1834              warn if we later see static one.  */
1835           if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
1836             TREE_PUBLIC (name) = 1;
1837
1838           IDENTIFIER_GLOBAL_VALUE (name) = x;
1839
1840           /* We no longer care about any previous block level declarations.  */
1841           IDENTIFIER_LIMBO_VALUE (name) = 0;
1842
1843           /* Don't forget if the function was used via an implicit decl.  */
1844           if (IDENTIFIER_IMPLICIT_DECL (name)
1845               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
1846             TREE_USED (x) = 1, TREE_USED (name) = 1;
1847
1848           /* Don't forget if its address was taken in that way.  */
1849           if (IDENTIFIER_IMPLICIT_DECL (name)
1850               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
1851             TREE_ADDRESSABLE (x) = 1;
1852
1853           /* Warn about mismatches against previous implicit decl.  */
1854           if (IDENTIFIER_IMPLICIT_DECL (name) != 0
1855               /* If this real decl matches the implicit, don't complain.  */
1856               && ! (TREE_CODE (x) == FUNCTION_DECL
1857                     && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
1858                         == integer_type_node)))
1859             pedwarn ("`%s' was previously implicitly declared to return `int'",
1860                      IDENTIFIER_POINTER (name));
1861
1862           /* If this decl is `static' and an `extern' was seen previously,
1863              that is erroneous.  */
1864           if (TREE_PUBLIC (name)
1865               && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
1866             {
1867               /* Okay to redeclare an ANSI built-in as static.  */
1868               if (t != 0 && DECL_BUILT_IN (t))
1869                 ;
1870               /* Okay to declare a non-ANSI built-in as anything.  */
1871               else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
1872                 ;
1873               /* Okay to have global type decl after an earlier extern
1874                  declaration inside a lexical block.  */
1875               else if (TREE_CODE (x) == TYPE_DECL)
1876                 ;
1877               else if (IDENTIFIER_IMPLICIT_DECL (name))
1878                 {
1879                   if (! TREE_THIS_VOLATILE (name))
1880                     pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1881                              IDENTIFIER_POINTER (name));
1882                 }
1883               else
1884                 pedwarn ("`%s' was declared `extern' and later `static'",
1885                          IDENTIFIER_POINTER (name));
1886             }
1887         }
1888       else
1889         {
1890           /* Here to install a non-global value.  */
1891           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1892           tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
1893
1894           IDENTIFIER_LOCAL_VALUE (name) = x;
1895
1896           /* If this is an extern function declaration, see if we
1897              have a global definition or declaration for the function.  */
1898           if (oldlocal == 0
1899               && oldglobal != 0
1900               && TREE_CODE (x) == FUNCTION_DECL
1901               && TREE_CODE (oldglobal) == FUNCTION_DECL
1902               && DECL_EXTERNAL (x)
1903               && ! DECL_DECLARED_INLINE_P (x))
1904             {
1905               /* We have one.  Their types must agree.  */
1906               if (! comptypes (TREE_TYPE (x),
1907                                TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
1908                 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
1909               else
1910                 {
1911                   /* Inner extern decl is inline if global one is.
1912                      Copy enough to really inline it.  */
1913                   if (DECL_DECLARED_INLINE_P (oldglobal))
1914                     {
1915                       DECL_DECLARED_INLINE_P (x)
1916                         = DECL_DECLARED_INLINE_P (oldglobal);
1917                       DECL_INLINE (x) = DECL_INLINE (oldglobal);
1918                       DECL_INITIAL (x) = (current_function_decl == oldglobal
1919                                           ? 0 : DECL_INITIAL (oldglobal));
1920                       DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
1921                       DECL_NUM_STMTS (x) = DECL_NUM_STMTS (oldglobal);
1922                       DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
1923                       DECL_RESULT (x) = DECL_RESULT (oldglobal);
1924                       TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
1925                       DECL_ABSTRACT_ORIGIN (x)
1926                         = DECL_ABSTRACT_ORIGIN (oldglobal);
1927                     }
1928                   /* Inner extern decl is built-in if global one is.  */
1929                   if (DECL_BUILT_IN (oldglobal))
1930                     {
1931                       DECL_BUILT_IN_CLASS (x) = DECL_BUILT_IN_CLASS (oldglobal);
1932                       DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
1933                     }
1934                   /* Keep the arg types from a file-scope fcn defn.  */
1935                   if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
1936                       && DECL_INITIAL (oldglobal)
1937                       && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
1938                     TREE_TYPE (x) = TREE_TYPE (oldglobal);
1939                 }
1940             }
1941
1942 #if 0
1943           /* This case is probably sometimes the right thing to do.  */
1944           /* If we have a local external declaration,
1945              then any file-scope declaration should not
1946              have been static.  */
1947           if (oldlocal == 0 && oldglobal != 0
1948               && !TREE_PUBLIC (oldglobal)
1949               && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
1950             warning ("`%s' locally external but globally static",
1951                      IDENTIFIER_POINTER (name));
1952 #endif
1953
1954           /* If we have a local external declaration,
1955              and no file-scope declaration has yet been seen,
1956              then if we later have a file-scope decl it must not be static.  */
1957           if (oldlocal == 0
1958               && DECL_EXTERNAL (x)
1959               && TREE_PUBLIC (x))
1960             {
1961               if (oldglobal == 0)
1962                 TREE_PUBLIC (name) = 1;
1963
1964               /* Save this decl, so that we can do type checking against
1965                  other decls after it falls out of scope.
1966
1967                  Only save it once.  This prevents temporary decls created in
1968                  expand_inline_function from being used here, since this
1969                  will have been set when the inline function was parsed.
1970                  It also helps give slightly better warnings.  */
1971               if (IDENTIFIER_LIMBO_VALUE (name) == 0)
1972                 IDENTIFIER_LIMBO_VALUE (name) = x;
1973             }
1974
1975           warn_if_shadowing (x, oldlocal);
1976
1977           /* If storing a local value, there may already be one (inherited).
1978              If so, record it for restoration when this binding level ends.  */
1979           if (oldlocal != 0)
1980             b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1981         }
1982
1983       /* Keep list of variables in this level with incomplete type.
1984          If the input is erroneous, we can have error_mark in the type
1985          slot (e.g. "f(void a, ...)") - that doesn't count as an
1986          incomplete type.  */
1987       if (TREE_TYPE (x) != error_mark_node
1988           && !COMPLETE_TYPE_P (TREE_TYPE (x)))
1989         {
1990           tree element = TREE_TYPE (x);
1991
1992           while (TREE_CODE (element) == ARRAY_TYPE)
1993             element = TREE_TYPE (element);
1994           if (TREE_CODE (element) == RECORD_TYPE
1995               || TREE_CODE (element) == UNION_TYPE)
1996             b->incomplete_list = tree_cons (NULL_TREE, x, b->incomplete_list);
1997         }
1998     }
1999
2000   /* Put decls on list in reverse order.
2001      We will reverse them later if necessary.  */
2002   TREE_CHAIN (x) = b->names;
2003   b->names = x;
2004
2005   return x;
2006 }
2007
2008 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
2009
2010 tree
2011 pushdecl_top_level (x)
2012      tree x;
2013 {
2014   tree t;
2015   struct binding_level *b = current_binding_level;
2016
2017   current_binding_level = global_binding_level;
2018   t = pushdecl (x);
2019   current_binding_level = b;
2020   return t;
2021 }
2022 \f
2023 /* Generate an implicit declaration for identifier FUNCTIONID
2024    as a function of type int ().  Print a warning if appropriate.  */
2025
2026 tree
2027 implicitly_declare (functionid)
2028      tree functionid;
2029 {
2030   tree decl;
2031   int traditional_warning = 0;
2032   /* Only one "implicit declaration" warning per identifier.  */
2033   int implicit_warning;
2034
2035   /* We used to reuse an old implicit decl here,
2036      but this loses with inline functions because it can clobber
2037      the saved decl chains.  */
2038 #if 0
2039   if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2040     decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2041   else
2042 #endif
2043     decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2044
2045   /* Warn of implicit decl following explicit local extern decl.
2046      This is probably a program designed for traditional C.  */
2047   if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2048     traditional_warning = 1;
2049
2050   /* Warn once of an implicit declaration.  */
2051   implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2052
2053   DECL_EXTERNAL (decl) = 1;
2054   TREE_PUBLIC (decl) = 1;
2055
2056   /* Record that we have an implicit decl and this is it.  */
2057   IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2058
2059   /* ANSI standard says implicit declarations are in the innermost block.
2060      So we record the decl in the standard fashion.  */
2061   pushdecl (decl);
2062
2063   /* This is a no-op in c-lang.c or something real in objc-act.c.  */
2064   if (flag_objc)
2065     objc_check_decl (decl);
2066
2067   rest_of_decl_compilation (decl, NULL, 0, 0);
2068
2069   if (implicit_warning)
2070     implicit_decl_warning (functionid);
2071   else if (warn_traditional && traditional_warning)
2072     warning ("function `%s' was previously declared within a block",
2073              IDENTIFIER_POINTER (functionid));
2074
2075   /* Write a record describing this implicit function declaration to the
2076      prototypes file (if requested).  */
2077
2078   gen_aux_info_record (decl, 0, 1, 0);
2079
2080   /* Possibly apply some default attributes to this implicit declaration.  */
2081   decl_attributes (&decl, NULL_TREE, 0);
2082
2083   return decl;
2084 }
2085
2086 void
2087 implicit_decl_warning (id)
2088      tree id;
2089 {
2090   const char *name = IDENTIFIER_POINTER (id);
2091   if (mesg_implicit_function_declaration == 2)
2092     error ("implicit declaration of function `%s'", name);
2093   else if (mesg_implicit_function_declaration == 1)
2094     warning ("implicit declaration of function `%s'", name);
2095 }
2096
2097 /* Return zero if the declaration NEWDECL is valid
2098    when the declaration OLDDECL (assumed to be for the same name)
2099    has already been seen.
2100    Otherwise return 1 if NEWDECL is a redefinition, 2 if it is a redeclaration,
2101    and 3 if it is a conflicting declaration.  */
2102
2103 static int
2104 redeclaration_error_message (newdecl, olddecl)
2105      tree newdecl, olddecl;
2106 {
2107   if (TREE_CODE (newdecl) == TYPE_DECL)
2108     {
2109       /* Do not complain about type redeclarations where at least one
2110          declaration was in a system header.  */
2111       if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2112         return 0;
2113       return 1;
2114     }
2115   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2116     {
2117       /* Declarations of functions can insist on internal linkage
2118          but they can't be inconsistent with internal linkage,
2119          so there can be no error on that account.
2120          However defining the same name twice is no good.  */
2121       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2122           /* However, defining once as extern inline and a second
2123              time in another way is ok.  */
2124           && ! (DECL_DECLARED_INLINE_P (olddecl) && DECL_EXTERNAL (olddecl)
2125                && ! (DECL_DECLARED_INLINE_P (newdecl)
2126                      && DECL_EXTERNAL (newdecl))))
2127         return 1;
2128       return 0;
2129     }
2130   else if (DECL_CONTEXT (newdecl) == NULL_TREE)
2131     {
2132       /* Objects declared at top level:  */
2133       /* If at least one is a reference, it's ok.  */
2134       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2135         return 0;
2136       /* Reject two definitions.  */
2137       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2138         return 1;
2139       /* Now we have two tentative defs, or one tentative and one real def.  */
2140       /* Insist that the linkage match.  */
2141       if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2142         return 3;
2143       return 0;
2144     }
2145   else if (current_binding_level->parm_flag
2146            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2147     return 0;
2148   else
2149     {
2150       /* Newdecl has block scope.  If olddecl has block scope also, then
2151          reject two definitions, and reject a definition together with an
2152          external reference.  Otherwise, it is OK, because newdecl must
2153          be an extern reference to olddecl.  */
2154       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2155           && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2156         return 2;
2157       return 0;
2158     }
2159 }
2160 \f
2161 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2162    Create one if none exists so far for the current function.
2163    This function is called for both label definitions and label references.  */
2164
2165 tree
2166 lookup_label (id)
2167      tree id;
2168 {
2169   tree decl = IDENTIFIER_LABEL_VALUE (id);
2170
2171   if (current_function_decl == 0)
2172     {
2173       error ("label %s referenced outside of any function",
2174              IDENTIFIER_POINTER (id));
2175       return 0;
2176     }
2177
2178   /* Use a label already defined or ref'd with this name.  */
2179   if (decl != 0)
2180     {
2181       /* But not if it is inherited and wasn't declared to be inheritable.  */
2182       if (DECL_CONTEXT (decl) != current_function_decl
2183           && ! C_DECLARED_LABEL_FLAG (decl))
2184         return shadow_label (id);
2185       return decl;
2186     }
2187
2188   decl = build_decl (LABEL_DECL, id, void_type_node);
2189
2190   /* A label not explicitly declared must be local to where it's ref'd.  */
2191   DECL_CONTEXT (decl) = current_function_decl;
2192
2193   DECL_MODE (decl) = VOIDmode;
2194
2195   /* Say where one reference is to the label,
2196      for the sake of the error if it is not defined.  */
2197   DECL_SOURCE_LINE (decl) = lineno;
2198   DECL_SOURCE_FILE (decl) = input_filename;
2199
2200   IDENTIFIER_LABEL_VALUE (id) = decl;
2201
2202   named_labels = tree_cons (NULL_TREE, decl, named_labels);
2203
2204   return decl;
2205 }
2206
2207 /* Make a label named NAME in the current function,
2208    shadowing silently any that may be inherited from containing functions
2209    or containing scopes.
2210
2211    Note that valid use, if the label being shadowed
2212    comes from another scope in the same function,
2213    requires calling declare_nonlocal_label right away.  */
2214
2215 tree
2216 shadow_label (name)
2217      tree name;
2218 {
2219   tree decl = IDENTIFIER_LABEL_VALUE (name);
2220
2221   if (decl != 0)
2222     {
2223       tree dup;
2224
2225       /* Check to make sure that the label hasn't already been declared
2226          at this label scope */
2227       for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2228         if (TREE_VALUE (dup) == decl)
2229           {
2230             error ("duplicate label declaration `%s'",
2231                    IDENTIFIER_POINTER (name));
2232             error_with_decl (TREE_VALUE (dup),
2233                              "this is a previous declaration");
2234             /* Just use the previous declaration.  */
2235             return lookup_label (name);
2236           }
2237
2238       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2239       IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2240     }
2241
2242   return lookup_label (name);
2243 }
2244
2245 /* Define a label, specifying the location in the source file.
2246    Return the LABEL_DECL node for the label, if the definition is valid.
2247    Otherwise return 0.  */
2248
2249 tree
2250 define_label (filename, line, name)
2251      const char *filename;
2252      int line;
2253      tree name;
2254 {
2255   tree decl = lookup_label (name);
2256
2257   /* If label with this name is known from an outer context, shadow it.  */
2258   if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2259     {
2260       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2261       IDENTIFIER_LABEL_VALUE (name) = 0;
2262       decl = lookup_label (name);
2263     }
2264
2265   if (warn_traditional && !in_system_header && lookup_name (name))
2266     warning_with_file_and_line (filename, line,
2267                                 "traditional C lacks a separate namespace for labels, identifier `%s' conflicts",
2268                                 IDENTIFIER_POINTER (name));
2269
2270   if (DECL_INITIAL (decl) != 0)
2271     {
2272       error_with_file_and_line (filename, line, "duplicate label `%s'",
2273                                 IDENTIFIER_POINTER (name));
2274       return 0;
2275     }
2276   else
2277     {
2278       /* Mark label as having been defined.  */
2279       DECL_INITIAL (decl) = error_mark_node;
2280       /* Say where in the source.  */
2281       DECL_SOURCE_FILE (decl) = filename;
2282       DECL_SOURCE_LINE (decl) = line;
2283       return decl;
2284     }
2285 }
2286 \f
2287 /* Return the list of declarations of the current level.
2288    Note that this list is in reverse order unless/until
2289    you nreverse it; and when you do nreverse it, you must
2290    store the result back using `storedecls' or you will lose.  */
2291
2292 tree
2293 getdecls ()
2294 {
2295   return current_binding_level->names;
2296 }
2297
2298 /* Return the list of type-tags (for structs, etc) of the current level.  */
2299
2300 tree
2301 gettags ()
2302 {
2303   return current_binding_level->tags;
2304 }
2305
2306 /* Store the list of declarations of the current level.
2307    This is done for the parameter declarations of a function being defined,
2308    after they are modified in the light of any missing parameters.  */
2309
2310 static void
2311 storedecls (decls)
2312      tree decls;
2313 {
2314   current_binding_level->names = decls;
2315 }
2316
2317 /* Similarly, store the list of tags of the current level.  */
2318
2319 static void
2320 storetags (tags)
2321      tree tags;
2322 {
2323   current_binding_level->tags = tags;
2324 }
2325 \f
2326 /* Given NAME, an IDENTIFIER_NODE,
2327    return the structure (or union or enum) definition for that name.
2328    Searches binding levels from BINDING_LEVEL up to the global level.
2329    If THISLEVEL_ONLY is nonzero, searches only the specified context
2330    (but skips any tag-transparent contexts to find one that is
2331    meaningful for tags).
2332    CODE says which kind of type the caller wants;
2333    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2334    If the wrong kind of type is found, an error is reported.  */
2335
2336 static tree
2337 lookup_tag (code, name, binding_level, thislevel_only)
2338      enum tree_code code;
2339      struct binding_level *binding_level;
2340      tree name;
2341      int thislevel_only;
2342 {
2343   struct binding_level *level;
2344   int thislevel = 1;
2345
2346   for (level = binding_level; level; level = level->level_chain)
2347     {
2348       tree tail;
2349       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2350         {
2351           if (TREE_PURPOSE (tail) == name)
2352             {
2353               if (TREE_CODE (TREE_VALUE (tail)) != code)
2354                 {
2355                   /* Definition isn't the kind we were looking for.  */
2356                   pending_invalid_xref = name;
2357                   pending_invalid_xref_file = input_filename;
2358                   pending_invalid_xref_line = lineno;
2359                   /* If in the same binding level as a declaration as a tag
2360                      of a different type, this must not be allowed to
2361                      shadow that tag, so give the error immediately.
2362                      (For example, "struct foo; union foo;" is invalid.)  */
2363                   if (thislevel)
2364                     pending_xref_error ();
2365                 }
2366               return TREE_VALUE (tail);
2367             }
2368         }
2369       if (! level->tag_transparent)
2370         {
2371           if (thislevel_only)
2372             return NULL_TREE;
2373           thislevel = 0;
2374         }
2375     }
2376   return NULL_TREE;
2377 }
2378
2379 /* Print an error message now
2380    for a recent invalid struct, union or enum cross reference.
2381    We don't print them immediately because they are not invalid
2382    when used in the `struct foo;' construct for shadowing.  */
2383
2384 void
2385 pending_xref_error ()
2386 {
2387   if (pending_invalid_xref != 0)
2388     error_with_file_and_line (pending_invalid_xref_file,
2389                               pending_invalid_xref_line,
2390                               "`%s' defined as wrong kind of tag",
2391                               IDENTIFIER_POINTER (pending_invalid_xref));
2392   pending_invalid_xref = 0;
2393 }
2394
2395 /* Given a type, find the tag that was defined for it and return the tag name.
2396    Otherwise return 0.  */
2397
2398 static tree
2399 lookup_tag_reverse (type)
2400      tree type;
2401 {
2402   struct binding_level *level;
2403
2404   for (level = current_binding_level; level; level = level->level_chain)
2405     {
2406       tree tail;
2407       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2408         {
2409           if (TREE_VALUE (tail) == type)
2410             return TREE_PURPOSE (tail);
2411         }
2412     }
2413   return NULL_TREE;
2414 }
2415 \f
2416 /* Look up NAME in the current binding level and its superiors
2417    in the namespace of variables, functions and typedefs.
2418    Return a ..._DECL node of some kind representing its definition,
2419    or return 0 if it is undefined.  */
2420
2421 tree
2422 lookup_name (name)
2423      tree name;
2424 {
2425   tree val;
2426
2427   if (current_binding_level != global_binding_level
2428       && IDENTIFIER_LOCAL_VALUE (name))
2429     val = IDENTIFIER_LOCAL_VALUE (name);
2430   else
2431     val = IDENTIFIER_GLOBAL_VALUE (name);
2432   return val;
2433 }
2434
2435 /* Similar to `lookup_name' but look only at current binding level.  */
2436
2437 tree
2438 lookup_name_current_level (name)
2439      tree name;
2440 {
2441   tree t;
2442
2443   if (current_binding_level == global_binding_level)
2444     return IDENTIFIER_GLOBAL_VALUE (name);
2445
2446   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2447     return 0;
2448
2449   for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2450     if (DECL_NAME (t) == name)
2451       break;
2452
2453   return t;
2454 }
2455 \f
2456 /* Create the predefined scalar types of C,
2457    and some nodes representing standard constants (0, 1, (void *) 0).
2458    Initialize the global binding level.
2459    Make definitions for built-in primitive functions.  */
2460
2461 void
2462 c_init_decl_processing ()
2463 {
2464   tree endlink;
2465   tree ptr_ftype_void, ptr_ftype_ptr;
2466
2467   /* Adds some ggc roots, and reserved words for c-parse.in.  */
2468   c_parse_init ();
2469
2470   current_function_decl = NULL;
2471   named_labels = NULL;
2472   current_binding_level = NULL_BINDING_LEVEL;
2473   free_binding_level = NULL_BINDING_LEVEL;
2474
2475   /* Make the binding_level structure for global names.  */
2476   pushlevel (0);
2477   global_binding_level = current_binding_level;
2478
2479   build_common_tree_nodes (flag_signed_char);
2480
2481   c_common_nodes_and_builtins ();
2482
2483   boolean_type_node = integer_type_node;
2484   boolean_true_node = integer_one_node;
2485   boolean_false_node = integer_zero_node;
2486
2487   c_bool_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
2488   TREE_SET_CODE (c_bool_type_node, BOOLEAN_TYPE);
2489   TYPE_MAX_VALUE (c_bool_type_node) = build_int_2 (1, 0);
2490   TREE_TYPE (TYPE_MAX_VALUE (c_bool_type_node)) = c_bool_type_node;
2491   TYPE_PRECISION (c_bool_type_node) = 1;
2492   pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2493                         c_bool_type_node));
2494   c_bool_false_node = build_int_2 (0, 0);
2495   TREE_TYPE (c_bool_false_node) = c_bool_type_node;
2496   c_bool_true_node = build_int_2 (1, 0);
2497   TREE_TYPE (c_bool_true_node) = c_bool_type_node;
2498
2499   endlink = void_list_node;
2500   ptr_ftype_void = build_function_type (ptr_type_node, endlink);
2501   ptr_ftype_ptr
2502     = build_function_type (ptr_type_node,
2503                            tree_cons (NULL_TREE, ptr_type_node, endlink));
2504
2505   pedantic_lvalues = pedantic;
2506
2507   make_fname_decl = c_make_fname_decl;
2508   start_fname_decls ();
2509 }
2510
2511 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2512    decl, NAME is the initialization string and TYPE_DEP indicates whether
2513    NAME depended on the type of the function.  As we don't yet implement
2514    delayed emission of static data, we mark the decl as emitted
2515    so it is not placed in the output.  Anything using it must therefore pull
2516    out the STRING_CST initializer directly.  This does mean that these names
2517    are string merging candidates, which is wrong for C99's __func__.  FIXME.  */
2518
2519 static tree
2520 c_make_fname_decl (id, type_dep)
2521      tree id;
2522      int type_dep;
2523 {
2524   const char *name = fname_as_string (type_dep);
2525   tree decl, type, init;
2526   size_t length = strlen (name);
2527
2528   type =  build_array_type
2529           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
2530            build_index_type (size_int (length)));
2531
2532   decl = build_decl (VAR_DECL, id, type);
2533   /* We don't push the decl, so have to set its context here.  */
2534   DECL_CONTEXT (decl) = current_function_decl;
2535
2536   TREE_STATIC (decl) = 1;
2537   TREE_READONLY (decl) = 1;
2538   DECL_ARTIFICIAL (decl) = 1;
2539
2540   init = build_string (length + 1, name);
2541   TREE_TYPE (init) = type;
2542   DECL_INITIAL (decl) = init;
2543
2544   TREE_USED (decl) = 1;
2545
2546   finish_decl (decl, init, NULL_TREE);
2547
2548   return decl;
2549 }
2550
2551 /* Return a definition for a builtin function named NAME and whose data type
2552    is TYPE.  TYPE should be a function type with argument types.
2553    FUNCTION_CODE tells later passes how to compile calls to this function.
2554    See tree.h for its possible values.
2555
2556    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2557    the name to be called if we can't opencode the function.  If
2558    ATTRS is nonzero, use that for the function's attribute list.  */
2559
2560 tree
2561 builtin_function (name, type, function_code, class, library_name, attrs)
2562      const char *name;
2563      tree type;
2564      int function_code;
2565      enum built_in_class class;
2566      const char *library_name;
2567      tree attrs;
2568 {
2569   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
2570   DECL_EXTERNAL (decl) = 1;
2571   TREE_PUBLIC (decl) = 1;
2572   if (library_name)
2573     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2574   make_decl_rtl (decl, NULL);
2575   pushdecl (decl);
2576   DECL_BUILT_IN_CLASS (decl) = class;
2577   DECL_FUNCTION_CODE (decl) = function_code;
2578
2579   /* Warn if a function in the namespace for users
2580      is used without an occasion to consider it declared.  */
2581   if (name[0] != '_' || name[1] != '_')
2582     C_DECL_ANTICIPATED (decl) = 1;
2583
2584   /* Possibly apply some default attributes to this built-in function.  */
2585   if (attrs)
2586     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2587   else
2588     decl_attributes (&decl, NULL_TREE, 0);
2589
2590   return decl;
2591 }
2592
2593 /* Apply default attributes to a function, if a system function with default
2594    attributes.  */
2595
2596 void
2597 c_insert_default_attributes (decl)
2598      tree decl;
2599 {
2600   if (!TREE_PUBLIC (decl))
2601     return;
2602   c_common_insert_default_attributes (decl);
2603 }
2604 \f
2605 /* Called when a declaration is seen that contains no names to declare.
2606    If its type is a reference to a structure, union or enum inherited
2607    from a containing scope, shadow that tag name for the current scope
2608    with a forward reference.
2609    If its type defines a new named structure or union
2610    or defines an enum, it is valid but we need not do anything here.
2611    Otherwise, it is an error.  */
2612
2613 void
2614 shadow_tag (declspecs)
2615      tree declspecs;
2616 {
2617   shadow_tag_warned (declspecs, 0);
2618 }
2619
2620 void
2621 shadow_tag_warned (declspecs, warned)
2622      tree declspecs;
2623      int warned;
2624      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
2625         no pedwarn.  */
2626 {
2627   int found_tag = 0;
2628   tree link;
2629   tree specs, attrs;
2630
2631   pending_invalid_xref = 0;
2632
2633   /* Remove the attributes from declspecs, since they will confuse the
2634      following code.  */
2635   split_specs_attrs (declspecs, &specs, &attrs);
2636
2637   for (link = specs; link; link = TREE_CHAIN (link))
2638     {
2639       tree value = TREE_VALUE (link);
2640       enum tree_code code = TREE_CODE (value);
2641
2642       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2643         /* Used to test also that TYPE_SIZE (value) != 0.
2644            That caused warning for `struct foo;' at top level in the file.  */
2645         {
2646           tree name = lookup_tag_reverse (value);
2647           tree t;
2648
2649           found_tag++;
2650
2651           if (name == 0)
2652             {
2653               if (warned != 1 && code != ENUMERAL_TYPE)
2654                 /* Empty unnamed enum OK */
2655                 {
2656                   pedwarn ("unnamed struct/union that defines no instances");
2657                   warned = 1;
2658                 }
2659             }
2660           else
2661             {
2662               t = lookup_tag (code, name, current_binding_level, 1);
2663
2664               if (t == 0)
2665                 {
2666                   t = make_node (code);
2667                   pushtag (name, t);
2668                 }
2669             }
2670         }
2671       else
2672         {
2673           if (!warned && ! in_system_header)
2674             {
2675               warning ("useless keyword or type name in empty declaration");
2676               warned = 2;
2677             }
2678         }
2679     }
2680
2681   if (found_tag > 1)
2682     error ("two types specified in one empty declaration");
2683
2684   if (warned != 1)
2685     {
2686       if (found_tag == 0)
2687         pedwarn ("empty declaration");
2688     }
2689 }
2690 \f
2691 /* Construct an array declarator.  EXPR is the expression inside [], or
2692    NULL_TREE.  QUALS are the type qualifiers inside the [] (to be applied
2693    to the pointer to which a parameter array is converted).  STATIC_P is
2694    non-zero if "static" is inside the [], zero otherwise.  VLA_UNSPEC_P
2695    is non-zero is the array is [*], a VLA of unspecified length which is
2696    nevertheless a complete type (not currently implemented by GCC),
2697    zero otherwise.  The declarator is constructed as an ARRAY_REF
2698    (to be decoded by grokdeclarator), whose operand 0 is what's on the
2699    left of the [] (filled by in set_array_declarator_type) and operand 1
2700    is the expression inside; whose TREE_TYPE is the type qualifiers and
2701    which has TREE_STATIC set if "static" is used.  */
2702
2703 tree
2704 build_array_declarator (expr, quals, static_p, vla_unspec_p)
2705      tree expr;
2706      tree quals;
2707      int static_p;
2708      int vla_unspec_p;
2709 {
2710   tree decl;
2711   decl = build_nt (ARRAY_REF, NULL_TREE, expr);
2712   TREE_TYPE (decl) = quals;
2713   TREE_STATIC (decl) = (static_p ? 1 : 0);
2714   if (pedantic && !flag_isoc99)
2715     {
2716       if (static_p || quals != NULL_TREE)
2717         pedwarn ("ISO C90 does not support `static' or type qualifiers in parameter array declarators");
2718       if (vla_unspec_p)
2719         pedwarn ("ISO C90 does not support `[*]' array declarators");
2720     }
2721   if (vla_unspec_p)
2722     warning ("GCC does not yet properly implement `[*]' array declarators");
2723   return decl;
2724 }
2725
2726 /* Set the type of an array declarator.  DECL is the declarator, as
2727    constructed by build_array_declarator; TYPE is what appears on the left
2728    of the [] and goes in operand 0.  ABSTRACT_P is non-zero if it is an
2729    abstract declarator, zero otherwise; this is used to reject static and
2730    type qualifiers in abstract declarators, where they are not in the
2731    C99 grammar.  */
2732
2733 tree
2734 set_array_declarator_type (decl, type, abstract_p)
2735      tree decl;
2736      tree type;
2737      int abstract_p;
2738 {
2739   TREE_OPERAND (decl, 0) = type;
2740   if (abstract_p && (TREE_TYPE (decl) != NULL_TREE || TREE_STATIC (decl)))
2741     error ("static or type qualifiers in abstract declarator");
2742   return decl;
2743 }
2744 \f
2745 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
2746
2747 tree
2748 groktypename (typename)
2749      tree typename;
2750 {
2751   tree specs, attrs;
2752
2753   if (TREE_CODE (typename) != TREE_LIST)
2754     return typename;
2755
2756   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
2757
2758   typename = grokdeclarator (TREE_VALUE (typename), specs, TYPENAME, 0);
2759
2760   /* Apply attributes.  */
2761   decl_attributes (&typename, attrs, 0);
2762
2763   return typename;
2764 }
2765
2766 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
2767
2768 tree
2769 groktypename_in_parm_context (typename)
2770      tree typename;
2771 {
2772   if (TREE_CODE (typename) != TREE_LIST)
2773     return typename;
2774   return grokdeclarator (TREE_VALUE (typename),
2775                          TREE_PURPOSE (typename),
2776                          PARM, 0);
2777 }
2778
2779 /* Decode a declarator in an ordinary declaration or data definition.
2780    This is called as soon as the type information and variable name
2781    have been parsed, before parsing the initializer if any.
2782    Here we create the ..._DECL node, fill in its type,
2783    and put it on the list of decls for the current context.
2784    The ..._DECL node is returned as the value.
2785
2786    Exception: for arrays where the length is not specified,
2787    the type is left null, to be filled in by `finish_decl'.
2788
2789    Function definitions do not come here; they go to start_function
2790    instead.  However, external and forward declarations of functions
2791    do go through here.  Structure field declarations are done by
2792    grokfield and not through here.  */
2793
2794 tree
2795 start_decl (declarator, declspecs, initialized, attributes)
2796      tree declarator, declspecs;
2797      int initialized;
2798      tree attributes;
2799 {
2800   tree decl;
2801   tree tem;
2802
2803   /* An object declared as __attribute__((deprecated)) suppresses
2804      warnings of uses of other deprecated items.  */
2805   if (lookup_attribute ("deprecated", attributes))
2806     deprecated_state = DEPRECATED_SUPPRESS;
2807
2808   decl = grokdeclarator (declarator, declspecs,
2809                          NORMAL, initialized);
2810
2811   deprecated_state = DEPRECATED_NORMAL;
2812
2813   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
2814       && MAIN_NAME_P (DECL_NAME (decl)))
2815     warning_with_decl (decl, "`%s' is usually a function");
2816
2817   if (initialized)
2818     /* Is it valid for this decl to have an initializer at all?
2819        If not, set INITIALIZED to zero, which will indirectly
2820        tell `finish_decl' to ignore the initializer once it is parsed.  */
2821     switch (TREE_CODE (decl))
2822       {
2823       case TYPE_DECL:
2824         /* typedef foo = bar  means give foo the same type as bar.
2825            We haven't parsed bar yet, so `finish_decl' will fix that up.
2826            Any other case of an initialization in a TYPE_DECL is an error.  */
2827         if (pedantic || list_length (declspecs) > 1)
2828           {
2829             error ("typedef `%s' is initialized",
2830                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2831             initialized = 0;
2832           }
2833         break;
2834
2835       case FUNCTION_DECL:
2836         error ("function `%s' is initialized like a variable",
2837                IDENTIFIER_POINTER (DECL_NAME (decl)));
2838         initialized = 0;
2839         break;
2840
2841       case PARM_DECL:
2842         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
2843         error ("parameter `%s' is initialized",
2844                IDENTIFIER_POINTER (DECL_NAME (decl)));
2845         initialized = 0;
2846         break;
2847
2848       default:
2849         /* Don't allow initializations for incomplete types
2850            except for arrays which might be completed by the initialization.  */
2851
2852         /* This can happen if the array size is an undefined macro.  We already
2853            gave a warning, so we don't need another one.  */
2854         if (TREE_TYPE (decl) == error_mark_node)
2855           initialized = 0;
2856         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
2857           {
2858             /* A complete type is ok if size is fixed.  */
2859
2860             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
2861                 || C_DECL_VARIABLE_SIZE (decl))
2862               {
2863                 error ("variable-sized object may not be initialized");
2864                 initialized = 0;
2865               }
2866           }
2867         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
2868           {
2869             error ("variable `%s' has initializer but incomplete type",
2870                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2871             initialized = 0;
2872           }
2873         else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
2874           {
2875             error ("elements of array `%s' have incomplete type",
2876                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2877             initialized = 0;
2878           }
2879       }
2880
2881   if (initialized)
2882     {
2883 #if 0
2884       /* Seems redundant with grokdeclarator.  */
2885       if (current_binding_level != global_binding_level
2886           && DECL_EXTERNAL (decl)
2887           && TREE_CODE (decl) != FUNCTION_DECL)
2888         warning ("declaration of `%s' has `extern' and is initialized",
2889                  IDENTIFIER_POINTER (DECL_NAME (decl)));
2890 #endif
2891       DECL_EXTERNAL (decl) = 0;
2892       if (current_binding_level == global_binding_level)
2893         TREE_STATIC (decl) = 1;
2894
2895       /* Tell `pushdecl' this is an initialized decl
2896          even though we don't yet have the initializer expression.
2897          Also tell `finish_decl' it may store the real initializer.  */
2898       DECL_INITIAL (decl) = error_mark_node;
2899     }
2900
2901   /* If this is a function declaration, write a record describing it to the
2902      prototypes file (if requested).  */
2903
2904   if (TREE_CODE (decl) == FUNCTION_DECL)
2905     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
2906
2907   /* ANSI specifies that a tentative definition which is not merged with
2908      a non-tentative definition behaves exactly like a definition with an
2909      initializer equal to zero.  (Section 3.7.2)
2910
2911      -fno-common gives strict ANSI behavior, though this tends to break
2912      a large body of code that grew up without this rule.
2913
2914      Thread-local variables are never common, since there's no entrenched
2915      body of code to break, and it allows more efficient variable references
2916      in the presense of dynamic linking.  */
2917
2918   if (TREE_CODE (decl) == VAR_DECL
2919       && !initialized
2920       && TREE_PUBLIC (decl)
2921       && !DECL_THREAD_LOCAL (decl)
2922       && !flag_no_common)
2923     DECL_COMMON (decl) = 1;
2924
2925   /* Set attributes here so if duplicate decl, will have proper attributes.  */
2926   decl_attributes (&decl, attributes, 0);
2927
2928   /* If #pragma weak was used, mark the decl weak now.  */
2929   if (current_binding_level == global_binding_level)
2930     maybe_apply_pragma_weak (decl);
2931
2932   if (TREE_CODE (decl) == FUNCTION_DECL
2933       && DECL_DECLARED_INLINE_P (decl)
2934       && DECL_UNINLINABLE (decl)
2935       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
2936     warning_with_decl (decl,
2937                        "inline function `%s' given attribute noinline");
2938
2939   /* Add this decl to the current binding level.
2940      TEM may equal DECL or it may be a previous decl of the same name.  */
2941   tem = pushdecl (decl);
2942
2943   /* For a local variable, define the RTL now.  */
2944   if (current_binding_level != global_binding_level
2945       /* But not if this is a duplicate decl
2946          and we preserved the rtl from the previous one
2947          (which may or may not happen).  */
2948       && !DECL_RTL_SET_P (tem)
2949       && !DECL_CONTEXT (tem))
2950     {
2951       if (TREE_TYPE (tem) != error_mark_node
2952           && COMPLETE_TYPE_P (TREE_TYPE (tem)))
2953         expand_decl (tem);
2954       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
2955                && DECL_INITIAL (tem) != 0)
2956         expand_decl (tem);
2957     }
2958
2959   return tem;
2960 }
2961
2962 /* Finish processing of a declaration;
2963    install its initial value.
2964    If the length of an array type is not known before,
2965    it must be determined now, from the initial value, or it is an error.  */
2966
2967 void
2968 finish_decl (decl, init, asmspec_tree)
2969      tree decl, init;
2970      tree asmspec_tree;
2971 {
2972   tree type = TREE_TYPE (decl);
2973   int was_incomplete = (DECL_SIZE (decl) == 0);
2974   const char *asmspec = 0;
2975
2976   /* If a name was specified, get the string.  */
2977   if (current_binding_level == global_binding_level)
2978     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
2979   if (asmspec_tree)
2980     asmspec = TREE_STRING_POINTER (asmspec_tree);
2981
2982   /* If `start_decl' didn't like having an initialization, ignore it now.  */
2983   if (init != 0 && DECL_INITIAL (decl) == 0)
2984     init = 0;
2985
2986   /* Don't crash if parm is initialized.  */
2987   if (TREE_CODE (decl) == PARM_DECL)
2988     init = 0;
2989
2990   if (init)
2991     {
2992       if (TREE_CODE (decl) != TYPE_DECL)
2993         store_init_value (decl, init);
2994       else
2995         {
2996           /* typedef foo = bar; store the type of bar as the type of foo.  */
2997           TREE_TYPE (decl) = TREE_TYPE (init);
2998           DECL_INITIAL (decl) = init = 0;
2999         }
3000     }
3001
3002   /* Deduce size of array from initialization, if not already known */
3003   if (TREE_CODE (type) == ARRAY_TYPE
3004       && TYPE_DOMAIN (type) == 0
3005       && TREE_CODE (decl) != TYPE_DECL)
3006     {
3007       int do_default
3008         = (TREE_STATIC (decl)
3009            /* Even if pedantic, an external linkage array
3010               may have incomplete type at first.  */
3011            ? pedantic && !TREE_PUBLIC (decl)
3012            : !DECL_EXTERNAL (decl));
3013       int failure
3014         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3015
3016       /* Get the completed type made by complete_array_type.  */
3017       type = TREE_TYPE (decl);
3018
3019       if (failure == 1)
3020         error_with_decl (decl, "initializer fails to determine size of `%s'");
3021
3022       else if (failure == 2)
3023         {
3024           if (do_default)
3025             error_with_decl (decl, "array size missing in `%s'");
3026           /* If a `static' var's size isn't known,
3027              make it extern as well as static, so it does not get
3028              allocated.
3029              If it is not `static', then do not mark extern;
3030              finish_incomplete_decl will give it a default size
3031              and it will get allocated.  */
3032           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3033             DECL_EXTERNAL (decl) = 1;
3034         }
3035
3036       /* TYPE_MAX_VALUE is always one less than the number of elements
3037          in the array, because we start counting at zero.  Therefore,
3038          warn only if the value is less than zero.  */
3039       else if (pedantic && TYPE_DOMAIN (type) != 0
3040               && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3041         error_with_decl (decl, "zero or negative size array `%s'");
3042
3043       layout_decl (decl, 0);
3044     }
3045
3046   if (TREE_CODE (decl) == VAR_DECL)
3047     {
3048       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3049           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3050         layout_decl (decl, 0);
3051
3052       if (DECL_SIZE (decl) == 0
3053           /* Don't give an error if we already gave one earlier.  */
3054           && TREE_TYPE (decl) != error_mark_node
3055           && (TREE_STATIC (decl)
3056               ?
3057                 /* A static variable with an incomplete type
3058                    is an error if it is initialized.
3059                    Also if it is not file scope.
3060                    Otherwise, let it through, but if it is not `extern'
3061                    then it may cause an error message later.  */
3062                 (DECL_INITIAL (decl) != 0
3063                  || DECL_CONTEXT (decl) != 0)
3064               :
3065                 /* An automatic variable with an incomplete type
3066                    is an error.  */
3067                 !DECL_EXTERNAL (decl)))
3068         {
3069           error_with_decl (decl, "storage size of `%s' isn't known");
3070           TREE_TYPE (decl) = error_mark_node;
3071         }
3072
3073       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3074           && DECL_SIZE (decl) != 0)
3075         {
3076           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3077             constant_expression_warning (DECL_SIZE (decl));
3078           else
3079             error_with_decl (decl, "storage size of `%s' isn't constant");
3080         }
3081
3082       if (TREE_USED (type))
3083         TREE_USED (decl) = 1;
3084     }
3085
3086   /* If this is a function and an assembler name is specified, it isn't
3087      builtin any more.  Also reset DECL_RTL so we can give it its new
3088      name.  */
3089   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3090     {
3091       DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3092       SET_DECL_RTL (decl, NULL_RTX);
3093       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3094     }
3095
3096   /* Output the assembler code and/or RTL code for variables and functions,
3097      unless the type is an undefined structure or union.
3098      If not, it will get done when the type is completed.  */
3099
3100   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3101     {
3102       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
3103       if (flag_objc)
3104         objc_check_decl (decl);
3105
3106       if (!DECL_CONTEXT (decl))
3107         {
3108           if (DECL_INITIAL (decl) == NULL_TREE
3109               || DECL_INITIAL (decl) == error_mark_node)
3110             /* Don't output anything
3111                when a tentative file-scope definition is seen.
3112                But at end of compilation, do output code for them.  */
3113             DECL_DEFER_OUTPUT (decl) = 1;
3114           rest_of_decl_compilation (decl, asmspec,
3115                                     (DECL_CONTEXT (decl) == 0
3116                                      || TREE_ASM_WRITTEN (decl)), 0);
3117         }
3118       else
3119         {
3120           /* This is a local variable.  If there is an ASMSPEC, the
3121              user has requested that we handle it specially.  */
3122           if (asmspec)
3123             {
3124               /* In conjunction with an ASMSPEC, the `register'
3125                  keyword indicates that we should place the variable
3126                  in a particular register.  */
3127               if (DECL_REGISTER (decl))
3128                 DECL_C_HARD_REGISTER (decl) = 1;
3129
3130               /* If this is not a static variable, issue a warning.
3131                  It doesn't make any sense to give an ASMSPEC for an
3132                  ordinary, non-register local variable.  Historically,
3133                  GCC has accepted -- but ignored -- the ASMSPEC in
3134                  this case.  */
3135               if (TREE_CODE (decl) == VAR_DECL
3136                   && !DECL_REGISTER (decl)
3137                   && !TREE_STATIC (decl))
3138                 warning_with_decl (decl,
3139                                    "ignoring asm-specifier for non-static local variable `%s'");
3140               else
3141                 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3142             }
3143
3144           if (TREE_CODE (decl) != FUNCTION_DECL)
3145             add_decl_stmt (decl);
3146         }
3147
3148       if (DECL_CONTEXT (decl) != 0)
3149         {
3150           /* Recompute the RTL of a local array now
3151              if it used to be an incomplete type.  */
3152           if (was_incomplete
3153               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3154             {
3155               /* If we used it already as memory, it must stay in memory.  */
3156               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3157               /* If it's still incomplete now, no init will save it.  */
3158               if (DECL_SIZE (decl) == 0)
3159                 DECL_INITIAL (decl) = 0;
3160             }
3161         }
3162     }
3163
3164   if (TREE_CODE (decl) == TYPE_DECL)
3165     {
3166       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
3167       if (flag_objc)
3168         objc_check_decl (decl);
3169       rest_of_decl_compilation (decl, NULL, DECL_CONTEXT (decl) == 0, 0);
3170     }
3171
3172   /* At the end of a declaration, throw away any variable type sizes
3173      of types defined inside that declaration.  There is no use
3174      computing them in the following function definition.  */
3175   if (current_binding_level == global_binding_level)
3176     get_pending_sizes ();
3177 }
3178
3179 /* Given a parsed parameter declaration,
3180    decode it into a PARM_DECL and push that on the current binding level.
3181    Also, for the sake of forward parm decls,
3182    record the given order of parms in `parm_order'.  */
3183
3184 void
3185 push_parm_decl (parm)
3186      tree parm;
3187 {
3188   tree decl;
3189   int old_immediate_size_expand = immediate_size_expand;
3190   /* Don't try computing parm sizes now -- wait till fn is called.  */
3191   immediate_size_expand = 0;
3192
3193   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3194                          TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3195   decl_attributes (&decl, TREE_VALUE (parm), 0);
3196
3197 #if 0
3198   if (DECL_NAME (decl))
3199     {
3200       tree olddecl;
3201       olddecl = lookup_name (DECL_NAME (decl));
3202       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3203         pedwarn_with_decl (decl,
3204                            "ISO C forbids parameter `%s' shadowing typedef");
3205     }
3206 #endif
3207
3208   decl = pushdecl (decl);
3209
3210   immediate_size_expand = old_immediate_size_expand;
3211
3212   current_binding_level->parm_order
3213     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3214
3215   /* Add this decl to the current binding level.  */
3216   finish_decl (decl, NULL_TREE, NULL_TREE);
3217 }
3218
3219 /* Clear the given order of parms in `parm_order'.
3220    Used at start of parm list,
3221    and also at semicolon terminating forward decls.  */
3222
3223 void
3224 clear_parm_order ()
3225 {
3226   current_binding_level->parm_order = NULL_TREE;
3227 }
3228 \f
3229 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
3230    literal, which may be an incomplete array type completed by the
3231    initializer; INIT is a CONSTRUCTOR that initializes the compound
3232    literal.  */
3233
3234 tree
3235 build_compound_literal (type, init)
3236      tree type;
3237      tree init;
3238 {
3239   /* We do not use start_decl here because we have a type, not a declarator;
3240      and do not use finish_decl because the decl should be stored inside
3241      the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT.  */
3242   tree decl = build_decl (VAR_DECL, NULL_TREE, type);
3243   tree complit;
3244   tree stmt;
3245   DECL_EXTERNAL (decl) = 0;
3246   TREE_PUBLIC (decl) = 0;
3247   TREE_STATIC (decl) = (current_binding_level == global_binding_level);
3248   DECL_CONTEXT (decl) = current_function_decl;
3249   TREE_USED (decl) = 1;
3250   TREE_TYPE (decl) = type;
3251   TREE_READONLY (decl) = TREE_READONLY (type);
3252   store_init_value (decl, init);
3253
3254   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3255     {
3256       int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3257       if (failure)
3258         abort ();
3259     }
3260
3261   type = TREE_TYPE (decl);
3262   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3263     return error_mark_node;
3264
3265   stmt = build_stmt (DECL_STMT, decl);
3266   complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3267   TREE_SIDE_EFFECTS (complit) = 1;
3268
3269   layout_decl (decl, 0);
3270
3271   if (TREE_STATIC (decl))
3272     {
3273       /* This decl needs a name for the assembler output.  We also need
3274          a unique suffix to be added to the name.  */
3275       char *name;
3276       extern int var_labelno;
3277
3278       ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal", var_labelno);
3279       var_labelno++;
3280       DECL_NAME (decl) = get_identifier (name);
3281       DECL_DEFER_OUTPUT (decl) = 1;
3282       DECL_COMDAT (decl) = 1;
3283       DECL_ARTIFICIAL (decl) = 1;
3284       pushdecl (decl);
3285       rest_of_decl_compilation (decl, NULL, 1, 0);
3286     }
3287
3288   return complit;
3289 }
3290 \f
3291 /* Make TYPE a complete type based on INITIAL_VALUE.
3292    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3293    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3294
3295 int
3296 complete_array_type (type, initial_value, do_default)
3297      tree type;
3298      tree initial_value;
3299      int do_default;
3300 {
3301   tree maxindex = NULL_TREE;
3302   int value = 0;
3303
3304   if (initial_value)
3305     {
3306       /* Note MAXINDEX  is really the maximum index,
3307          one less than the size.  */
3308       if (TREE_CODE (initial_value) == STRING_CST)
3309         {
3310           int eltsize
3311             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3312           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3313                                    / eltsize) - 1, 0);
3314         }
3315       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3316         {
3317           tree elts = CONSTRUCTOR_ELTS (initial_value);
3318           maxindex = build_int_2 (-1, -1);
3319           for (; elts; elts = TREE_CHAIN (elts))
3320             {
3321               if (TREE_PURPOSE (elts))
3322                 maxindex = TREE_PURPOSE (elts);
3323               else
3324                 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3325                                         maxindex, integer_one_node));
3326             }
3327           maxindex = copy_node (maxindex);
3328         }
3329       else
3330         {
3331           /* Make an error message unless that happened already.  */
3332           if (initial_value != error_mark_node)
3333             value = 1;
3334
3335           /* Prevent further error messages.  */
3336           maxindex = build_int_2 (0, 0);
3337         }
3338     }
3339
3340   if (!maxindex)
3341     {
3342       if (do_default)
3343         maxindex = build_int_2 (0, 0);
3344       value = 2;
3345     }
3346
3347   if (maxindex)
3348     {
3349       TYPE_DOMAIN (type) = build_index_type (maxindex);
3350       if (!TREE_TYPE (maxindex))
3351         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3352     }
3353
3354   /* Lay out the type now that we can get the real answer.  */
3355
3356   layout_type (type);
3357
3358   return value;
3359 }
3360 \f
3361 /* Determine whether TYPE is a structure with a flexible array member,
3362    or a union containing such a structure (possibly recursively).  */
3363
3364 static bool
3365 flexible_array_type_p (type)
3366      tree type;
3367 {
3368   tree x;
3369   switch (TREE_CODE (type))
3370     {
3371     case RECORD_TYPE:
3372       x = TYPE_FIELDS (type);
3373       if (x == NULL_TREE)
3374         return false;
3375       while (TREE_CHAIN (x) != NULL_TREE)
3376         x = TREE_CHAIN (x);
3377       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3378           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3379           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3380           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3381         return true;
3382       return false;
3383     case UNION_TYPE:
3384       for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3385         {
3386           if (flexible_array_type_p (TREE_TYPE (x)))
3387             return true;
3388         }
3389       return false;
3390     default:
3391     return false;
3392   }
3393 }
3394 \f
3395 /* Given declspecs and a declarator,
3396    determine the name and type of the object declared
3397    and construct a ..._DECL node for it.
3398    (In one case we can return a ..._TYPE node instead.
3399     For invalid input we sometimes return 0.)
3400
3401    DECLSPECS is a chain of tree_list nodes whose value fields
3402     are the storage classes and type specifiers.
3403
3404    DECL_CONTEXT says which syntactic context this declaration is in:
3405      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3406      FUNCDEF for a function definition.  Like NORMAL but a few different
3407       error messages in each case.  Return value may be zero meaning
3408       this definition is too screwy to try to parse.
3409      PARM for a parameter declaration (either within a function prototype
3410       or before a function body).  Make a PARM_DECL, or return void_type_node.
3411      TYPENAME if for a typename (in a cast or sizeof).
3412       Don't make a DECL node; just return the ..._TYPE node.
3413      FIELD for a struct or union field; make a FIELD_DECL.
3414      BITFIELD for a field with specified width.
3415    INITIALIZED is 1 if the decl has an initializer.
3416
3417    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3418    It may also be so in the PARM case, for a prototype where the
3419    argument type is specified but not the name.
3420
3421    This function is where the complicated C meanings of `static'
3422    and `extern' are interpreted.  */
3423
3424 static tree
3425 grokdeclarator (declarator, declspecs, decl_context, initialized)
3426      tree declspecs;
3427      tree declarator;
3428      enum decl_context decl_context;
3429      int initialized;
3430 {
3431   int specbits = 0;
3432   tree spec;
3433   tree type = NULL_TREE;
3434   int longlong = 0;
3435   int constp;
3436   int restrictp;
3437   int volatilep;
3438   int type_quals = TYPE_UNQUALIFIED;
3439   int inlinep;
3440   int explicit_int = 0;
3441   int explicit_char = 0;
3442   int defaulted_int = 0;
3443   tree typedef_decl = 0;
3444   const char *name;
3445   tree typedef_type = 0;
3446   int funcdef_flag = 0;
3447   enum tree_code innermost_code = ERROR_MARK;
3448   int bitfield = 0;
3449   int size_varies = 0;
3450   tree decl_attr = NULL_TREE;
3451   tree array_ptr_quals = NULL_TREE;
3452   int array_parm_static = 0;
3453   tree returned_attrs = NULL_TREE;
3454
3455   if (decl_context == BITFIELD)
3456     bitfield = 1, decl_context = FIELD;
3457
3458   if (decl_context == FUNCDEF)
3459     funcdef_flag = 1, decl_context = NORMAL;
3460
3461   /* Look inside a declarator for the name being declared
3462      and get it as a string, for an error message.  */
3463   {
3464     tree decl = declarator;
3465     name = 0;
3466
3467     while (decl)
3468       switch (TREE_CODE (decl))
3469         {
3470         case ARRAY_REF:
3471         case INDIRECT_REF:
3472         case CALL_EXPR:
3473           innermost_code = TREE_CODE (decl);
3474           decl = TREE_OPERAND (decl, 0);
3475           break;
3476
3477         case TREE_LIST:
3478           decl = TREE_VALUE (decl);
3479           break;
3480
3481         case IDENTIFIER_NODE:
3482           name = IDENTIFIER_POINTER (decl);
3483           decl = 0;
3484           break;
3485
3486         default:
3487           abort ();
3488         }
3489     if (name == 0)
3490       name = "type name";
3491   }
3492
3493   /* A function definition's declarator must have the form of
3494      a function declarator.  */
3495
3496   if (funcdef_flag && innermost_code != CALL_EXPR)
3497     return 0;
3498
3499   /* Anything declared one level down from the top level
3500      must be one of the parameters of a function
3501      (because the body is at least two levels down).  */
3502
3503   /* If this looks like a function definition, make it one,
3504      even if it occurs where parms are expected.
3505      Then store_parm_decls will reject it and not use it as a parm.  */
3506   if (decl_context == NORMAL && !funcdef_flag
3507       && current_binding_level->parm_flag)
3508     decl_context = PARM;
3509
3510   /* Look through the decl specs and record which ones appear.
3511      Some typespecs are defined as built-in typenames.
3512      Others, the ones that are modifiers of other types,
3513      are represented by bits in SPECBITS: set the bits for
3514      the modifiers that appear.  Storage class keywords are also in SPECBITS.
3515
3516      If there is a typedef name or a type, store the type in TYPE.
3517      This includes builtin typedefs such as `int'.
3518
3519      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3520      and did not come from a user typedef.
3521
3522      Set LONGLONG if `long' is mentioned twice.  */
3523
3524   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3525     {
3526       tree id = TREE_VALUE (spec);
3527
3528       /* If the entire declaration is itself tagged as deprecated then
3529          suppress reports of deprecated items.  */
3530       if (id && TREE_DEPRECATED (id))
3531         {
3532           if (deprecated_state != DEPRECATED_SUPPRESS)
3533             warn_deprecated_use (id);
3534         }
3535
3536       if (id == ridpointers[(int) RID_INT])
3537         explicit_int = 1;
3538       if (id == ridpointers[(int) RID_CHAR])
3539         explicit_char = 1;
3540
3541       if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3542         {
3543           enum rid i = C_RID_CODE (id);
3544           if ((int) i <= (int) RID_LAST_MODIFIER)
3545             {
3546               if (i == RID_LONG && (specbits & (1 << (int) RID_LONG)))
3547                 {
3548                   if (longlong)
3549                     error ("`long long long' is too long for GCC");
3550                   else
3551                     {
3552                       if (pedantic && !flag_isoc99 && ! in_system_header
3553                           && warn_long_long)
3554                         pedwarn ("ISO C90 does not support `long long'");
3555                       longlong = 1;
3556                     }
3557                 }
3558               else if (specbits & (1 << (int) i))
3559                 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3560
3561               /* Diagnose "__thread extern".  Recall that this list
3562                  is in the reverse order seen in the text.  */
3563               if (i == RID_THREAD
3564                   && (specbits & (1 << (int) RID_EXTERN
3565                                   | 1 << (int) RID_STATIC)))
3566                 {
3567                   if (specbits & 1 << (int) RID_EXTERN)
3568                     error ("`__thread' before `extern'");
3569                   else
3570                     error ("`__thread' before `static'");
3571                 }
3572
3573               specbits |= 1 << (int) i;
3574               goto found;
3575             }
3576         }
3577       if (type)
3578         error ("two or more data types in declaration of `%s'", name);
3579       /* Actual typedefs come to us as TYPE_DECL nodes.  */
3580       else if (TREE_CODE (id) == TYPE_DECL)
3581         {
3582           if (TREE_TYPE (id) == error_mark_node)
3583             ; /* Allow the type to default to int to avoid cascading errors.  */
3584           else
3585             {
3586               type = TREE_TYPE (id);
3587               decl_attr = DECL_ATTRIBUTES (id);
3588               typedef_decl = id;
3589             }
3590         }
3591       /* Built-in types come as identifiers.  */
3592       else if (TREE_CODE (id) == IDENTIFIER_NODE)
3593         {
3594           tree t = lookup_name (id);
3595           if (TREE_TYPE (t) == error_mark_node)
3596             ;
3597           else if (!t || TREE_CODE (t) != TYPE_DECL)
3598             error ("`%s' fails to be a typedef or built in type",
3599                    IDENTIFIER_POINTER (id));
3600           else
3601             {
3602               type = TREE_TYPE (t);
3603               typedef_decl = t;
3604             }
3605         }
3606       else if (TREE_CODE (id) != ERROR_MARK)
3607         type = id;
3608
3609     found:
3610       ;
3611     }
3612
3613   typedef_type = type;
3614   if (type)
3615     size_varies = C_TYPE_VARIABLE_SIZE (type);
3616
3617   /* No type at all: default to `int', and set DEFAULTED_INT
3618      because it was not a user-defined typedef.  */
3619
3620   if (type == 0)
3621     {
3622       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3623                           | (1 << (int) RID_SIGNED)
3624                           | (1 << (int) RID_UNSIGNED)
3625                           | (1 << (int) RID_COMPLEX))))
3626           /* Don't warn about typedef foo = bar.  */
3627           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3628           && ! in_system_header)
3629         {
3630           /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3631              and this is a function, or if -Wimplicit; prefer the former
3632              warning since it is more explicit.  */
3633           if ((warn_implicit_int || warn_return_type || flag_isoc99)
3634               && funcdef_flag)
3635             warn_about_return_type = 1;
3636           else if (warn_implicit_int || flag_isoc99)
3637             pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
3638                          name);
3639         }
3640
3641       defaulted_int = 1;
3642       type = integer_type_node;
3643     }
3644
3645   /* Now process the modifiers that were specified
3646      and check for invalid combinations.  */
3647
3648   /* Long double is a special combination.  */
3649
3650   if ((specbits & 1 << (int) RID_LONG) && ! longlong
3651       && TYPE_MAIN_VARIANT (type) == double_type_node)
3652     {
3653       specbits &= ~(1 << (int) RID_LONG);
3654       type = long_double_type_node;
3655     }
3656
3657   /* Check all other uses of type modifiers.  */
3658
3659   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3660                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3661     {
3662       int ok = 0;
3663
3664       if ((specbits & 1 << (int) RID_LONG)
3665           && (specbits & 1 << (int) RID_SHORT))
3666         error ("both long and short specified for `%s'", name);
3667       else if (((specbits & 1 << (int) RID_LONG)
3668                 || (specbits & 1 << (int) RID_SHORT))
3669                && explicit_char)
3670         error ("long or short specified with char for `%s'", name);
3671       else if (((specbits & 1 << (int) RID_LONG)
3672                 || (specbits & 1 << (int) RID_SHORT))
3673                && TREE_CODE (type) == REAL_TYPE)
3674         {
3675           static int already = 0;
3676
3677           error ("long or short specified with floating type for `%s'", name);
3678           if (! already && ! pedantic)
3679             {
3680               error ("the only valid combination is `long double'");
3681               already = 1;
3682             }
3683         }
3684       else if ((specbits & 1 << (int) RID_SIGNED)
3685                && (specbits & 1 << (int) RID_UNSIGNED))
3686         error ("both signed and unsigned specified for `%s'", name);
3687       else if (TREE_CODE (type) != INTEGER_TYPE)
3688         error ("long, short, signed or unsigned invalid for `%s'", name);
3689       else
3690         {
3691           ok = 1;
3692           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
3693             {
3694               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
3695                        name);
3696               if (flag_pedantic_errors)
3697                 ok = 0;
3698             }
3699         }
3700
3701       /* Discard the type modifiers if they are invalid.  */
3702       if (! ok)
3703         {
3704           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3705                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3706           longlong = 0;
3707         }
3708     }
3709
3710   if ((specbits & (1 << (int) RID_COMPLEX))
3711       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
3712     {
3713       error ("complex invalid for `%s'", name);
3714       specbits &= ~(1 << (int) RID_COMPLEX);
3715     }
3716
3717   /* Decide whether an integer type is signed or not.
3718      Optionally treat bitfields as signed by default.  */
3719   if (specbits & 1 << (int) RID_UNSIGNED
3720       || (bitfield && ! flag_signed_bitfields
3721           && (explicit_int || defaulted_int || explicit_char
3722               /* A typedef for plain `int' without `signed'
3723                  can be controlled just like plain `int'.  */
3724               || ! (typedef_decl != 0
3725                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3726           && TREE_CODE (type) != ENUMERAL_TYPE
3727           && !(specbits & 1 << (int) RID_SIGNED)))
3728     {
3729       if (longlong)
3730         type = long_long_unsigned_type_node;
3731       else if (specbits & 1 << (int) RID_LONG)
3732         type = long_unsigned_type_node;
3733       else if (specbits & 1 << (int) RID_SHORT)
3734         type = short_unsigned_type_node;
3735       else if (type == char_type_node)
3736         type = unsigned_char_type_node;
3737       else if (typedef_decl)
3738         type = c_common_unsigned_type (type);
3739       else
3740         type = unsigned_type_node;
3741     }
3742   else if ((specbits & 1 << (int) RID_SIGNED)
3743            && type == char_type_node)
3744     type = signed_char_type_node;
3745   else if (longlong)
3746     type = long_long_integer_type_node;
3747   else if (specbits & 1 << (int) RID_LONG)
3748     type = long_integer_type_node;
3749   else if (specbits & 1 << (int) RID_SHORT)
3750     type = short_integer_type_node;
3751
3752   if (specbits & 1 << (int) RID_COMPLEX)
3753     {
3754       if (pedantic && !flag_isoc99)
3755         pedwarn ("ISO C90 does not support complex types");
3756       /* If we just have "complex", it is equivalent to
3757          "complex double", but if any modifiers at all are specified it is
3758          the complex form of TYPE.  E.g, "complex short" is
3759          "complex short int".  */
3760
3761       if (defaulted_int && ! longlong
3762           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3763                             | (1 << (int) RID_SIGNED)
3764                             | (1 << (int) RID_UNSIGNED))))
3765         {
3766           if (pedantic)
3767             pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
3768           type = complex_double_type_node;
3769         }
3770       else if (type == integer_type_node)
3771         {
3772           if (pedantic)
3773             pedwarn ("ISO C does not support complex integer types");
3774           type = complex_integer_type_node;
3775         }
3776       else if (type == float_type_node)
3777         type = complex_float_type_node;
3778       else if (type == double_type_node)
3779         type = complex_double_type_node;
3780       else if (type == long_double_type_node)
3781         type = complex_long_double_type_node;
3782       else
3783         {
3784           if (pedantic)
3785             pedwarn ("ISO C does not support complex integer types");
3786           type = build_complex_type (type);
3787         }
3788     }
3789
3790   /* Figure out the type qualifiers for the declaration.  There are
3791      two ways a declaration can become qualified.  One is something
3792      like `const int i' where the `const' is explicit.  Another is
3793      something like `typedef const int CI; CI i' where the type of the
3794      declaration contains the `const'.  */
3795   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
3796   restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
3797   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
3798   inlinep = !! (specbits & (1 << (int) RID_INLINE));
3799   if (constp > 1 && ! flag_isoc99)
3800     pedwarn ("duplicate `const'");
3801   if (restrictp > 1 && ! flag_isoc99)
3802     pedwarn ("duplicate `restrict'");
3803   if (volatilep > 1 && ! flag_isoc99)
3804     pedwarn ("duplicate `volatile'");
3805   if (! flag_gen_aux_info && (TYPE_QUALS (type)))
3806     type = TYPE_MAIN_VARIANT (type);
3807   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
3808                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
3809                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
3810
3811   /* Warn if two storage classes are given. Default to `auto'.  */
3812
3813   {
3814     int nclasses = 0;
3815
3816     if (specbits & 1 << (int) RID_AUTO) nclasses++;
3817     if (specbits & 1 << (int) RID_STATIC) nclasses++;
3818     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
3819     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
3820     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
3821
3822     /* "static __thread" and "extern __thread" are allowed.  */
3823     if ((specbits & (1 << (int) RID_THREAD
3824                      | 1 << (int) RID_STATIC
3825                      | 1 << (int) RID_EXTERN)) == (1 << (int) RID_THREAD))
3826       nclasses++;
3827
3828     /* Warn about storage classes that are invalid for certain
3829        kinds of declarations (parameters, typenames, etc.).  */
3830
3831     if (nclasses > 1)
3832       error ("multiple storage classes in declaration of `%s'", name);
3833     else if (funcdef_flag
3834              && (specbits
3835                  & ((1 << (int) RID_REGISTER)
3836                     | (1 << (int) RID_AUTO)
3837                     | (1 << (int) RID_TYPEDEF)
3838                     | (1 << (int) RID_THREAD))))
3839       {
3840         if (specbits & 1 << (int) RID_AUTO
3841             && (pedantic || current_binding_level == global_binding_level))
3842           pedwarn ("function definition declared `auto'");
3843         if (specbits & 1 << (int) RID_REGISTER)
3844           error ("function definition declared `register'");
3845         if (specbits & 1 << (int) RID_TYPEDEF)
3846           error ("function definition declared `typedef'");
3847         if (specbits & 1 << (int) RID_THREAD)
3848           error ("function definition declared `__thread'");
3849         specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3850                       | (1 << (int) RID_AUTO) | (1 << (int) RID_THREAD));
3851       }
3852     else if (decl_context != NORMAL && nclasses > 0)
3853       {
3854         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
3855           ;
3856         else
3857           {
3858             switch (decl_context)
3859               {
3860               case FIELD:
3861                 error ("storage class specified for structure field `%s'",
3862                        name);
3863                 break;
3864               case PARM:
3865                 error ("storage class specified for parameter `%s'", name);
3866                 break;
3867               default:
3868                 error ("storage class specified for typename");
3869                 break;
3870               }
3871             specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3872                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
3873                           | (1 << (int) RID_EXTERN) | (1 << (int) RID_THREAD));
3874           }
3875       }
3876     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
3877       {
3878         /* `extern' with initialization is invalid if not at top level.  */
3879         if (current_binding_level == global_binding_level)
3880           warning ("`%s' initialized and declared `extern'", name);
3881         else
3882           error ("`%s' has both `extern' and initializer", name);
3883       }
3884     else if (current_binding_level == global_binding_level)
3885       {
3886         if (specbits & 1 << (int) RID_AUTO)
3887           error ("top-level declaration of `%s' specifies `auto'", name);
3888       }
3889     else
3890       {
3891         if (specbits & 1 << (int) RID_EXTERN && funcdef_flag)
3892           error ("nested function `%s' declared `extern'", name);
3893         else if ((specbits & (1 << (int) RID_THREAD
3894                                | 1 << (int) RID_EXTERN
3895                                | 1 << (int) RID_STATIC))
3896                  == (1 << (int) RID_THREAD))
3897           {
3898             error ("function-scope `%s' implicitly auto and declared `__thread'",
3899                    name);
3900             specbits &= ~(1 << (int) RID_THREAD);
3901           }
3902       }
3903   }
3904
3905   /* Now figure out the structure of the declarator proper.
3906      Descend through it, creating more complex types, until we reach
3907      the declared identifier (or NULL_TREE, in an absolute declarator).  */
3908
3909   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
3910     {
3911       if (type == error_mark_node)
3912         {
3913           declarator = TREE_OPERAND (declarator, 0);
3914           continue;
3915         }
3916
3917       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3918          an INDIRECT_REF (for *...),
3919          a CALL_EXPR (for ...(...)),
3920          a TREE_LIST (for nested attributes),
3921          an identifier (for the name being declared)
3922          or a null pointer (for the place in an absolute declarator
3923          where the name was omitted).
3924          For the last two cases, we have just exited the loop.
3925
3926          At this point, TYPE is the type of elements of an array,
3927          or for a function to return, or for a pointer to point to.
3928          After this sequence of ifs, TYPE is the type of the
3929          array or function or pointer, and DECLARATOR has had its
3930          outermost layer removed.  */
3931
3932       if (array_ptr_quals != NULL_TREE || array_parm_static)
3933         {
3934           /* Only the innermost declarator (making a parameter be of
3935              array type which is converted to pointer type)
3936              may have static or type qualifiers.  */
3937           error ("static or type qualifiers in non-parameter array declarator");
3938           array_ptr_quals = NULL_TREE;
3939           array_parm_static = 0;
3940         }
3941
3942       if (TREE_CODE (declarator) == TREE_LIST)
3943         {
3944           /* We encode a declarator with embedded attributes using
3945              a TREE_LIST.  */
3946           tree attrs = TREE_PURPOSE (declarator);
3947           tree inner_decl;
3948           int attr_flags = 0;
3949           declarator = TREE_VALUE (declarator);
3950           inner_decl = declarator;
3951           while (inner_decl != NULL_TREE
3952                  && TREE_CODE (inner_decl) == TREE_LIST)
3953             inner_decl = TREE_VALUE (inner_decl);
3954           if (inner_decl == NULL_TREE
3955               || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
3956             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
3957           else if (TREE_CODE (inner_decl) == CALL_EXPR)
3958             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
3959           else if (TREE_CODE (inner_decl) == ARRAY_REF)
3960             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
3961           returned_attrs = decl_attributes (&type,
3962                                             chainon (returned_attrs, attrs),
3963                                             attr_flags);
3964         }
3965       else if (TREE_CODE (declarator) == ARRAY_REF)
3966         {
3967           tree itype = NULL_TREE;
3968           tree size = TREE_OPERAND (declarator, 1);
3969           /* The index is a signed object `sizetype' bits wide.  */
3970           tree index_type = c_common_signed_type (sizetype);
3971
3972           array_ptr_quals = TREE_TYPE (declarator);
3973           array_parm_static = TREE_STATIC (declarator);
3974
3975           declarator = TREE_OPERAND (declarator, 0);
3976
3977           /* Check for some types that there cannot be arrays of.  */
3978
3979           if (VOID_TYPE_P (type))
3980             {
3981               error ("declaration of `%s' as array of voids", name);
3982               type = error_mark_node;
3983             }
3984
3985           if (TREE_CODE (type) == FUNCTION_TYPE)
3986             {
3987               error ("declaration of `%s' as array of functions", name);
3988               type = error_mark_node;
3989             }
3990
3991           if (pedantic && flexible_array_type_p (type))
3992             pedwarn ("invalid use of structure with flexible array member");
3993
3994           if (size == error_mark_node)
3995             type = error_mark_node;
3996
3997           if (type == error_mark_node)
3998             continue;
3999
4000           /* If size was specified, set ITYPE to a range-type for that size.
4001              Otherwise, ITYPE remains null.  finish_decl may figure it out
4002              from an initial value.  */
4003
4004           if (size)
4005             {
4006               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4007               STRIP_TYPE_NOPS (size);
4008
4009               if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
4010                 {
4011                   error ("size of array `%s' has non-integer type", name);
4012                   size = integer_one_node;
4013