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    nonzero if "static" is inside the [], zero otherwise.  VLA_UNSPEC_P
2695    is nonzero 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 nonzero 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         error ("typedef `%s' is initialized (use __typeof__ instead)",
2825                IDENTIFIER_POINTER (DECL_NAME (decl)));
2826         initialized = 0;
2827         break;
2828
2829       case FUNCTION_DECL:
2830         error ("function `%s' is initialized like a variable",
2831                IDENTIFIER_POINTER (DECL_NAME (decl)));
2832         initialized = 0;
2833         break;
2834
2835       case PARM_DECL:
2836         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
2837         error ("parameter `%s' is initialized",
2838                IDENTIFIER_POINTER (DECL_NAME (decl)));
2839         initialized = 0;
2840         break;
2841
2842       default:
2843         /* Don't allow initializations for incomplete types
2844            except for arrays which might be completed by the initialization.  */
2845
2846         /* This can happen if the array size is an undefined macro.  We already
2847            gave a warning, so we don't need another one.  */
2848         if (TREE_TYPE (decl) == error_mark_node)
2849           initialized = 0;
2850         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
2851           {
2852             /* A complete type is ok if size is fixed.  */
2853
2854             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
2855                 || C_DECL_VARIABLE_SIZE (decl))
2856               {
2857                 error ("variable-sized object may not be initialized");
2858                 initialized = 0;
2859               }
2860           }
2861         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
2862           {
2863             error ("variable `%s' has initializer but incomplete type",
2864                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2865             initialized = 0;
2866           }
2867         else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
2868           {
2869             error ("elements of array `%s' have incomplete type",
2870                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2871             initialized = 0;
2872           }
2873       }
2874
2875   if (initialized)
2876     {
2877 #if 0
2878       /* Seems redundant with grokdeclarator.  */
2879       if (current_binding_level != global_binding_level
2880           && DECL_EXTERNAL (decl)
2881           && TREE_CODE (decl) != FUNCTION_DECL)
2882         warning ("declaration of `%s' has `extern' and is initialized",
2883                  IDENTIFIER_POINTER (DECL_NAME (decl)));
2884 #endif
2885       DECL_EXTERNAL (decl) = 0;
2886       if (current_binding_level == global_binding_level)
2887         TREE_STATIC (decl) = 1;
2888
2889       /* Tell `pushdecl' this is an initialized decl
2890          even though we don't yet have the initializer expression.
2891          Also tell `finish_decl' it may store the real initializer.  */
2892       DECL_INITIAL (decl) = error_mark_node;
2893     }
2894
2895   /* If this is a function declaration, write a record describing it to the
2896      prototypes file (if requested).  */
2897
2898   if (TREE_CODE (decl) == FUNCTION_DECL)
2899     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
2900
2901   /* ANSI specifies that a tentative definition which is not merged with
2902      a non-tentative definition behaves exactly like a definition with an
2903      initializer equal to zero.  (Section 3.7.2)
2904
2905      -fno-common gives strict ANSI behavior, though this tends to break
2906      a large body of code that grew up without this rule.
2907
2908      Thread-local variables are never common, since there's no entrenched
2909      body of code to break, and it allows more efficient variable references
2910      in the presense of dynamic linking.  */
2911
2912   if (TREE_CODE (decl) == VAR_DECL
2913       && !initialized
2914       && TREE_PUBLIC (decl)
2915       && !DECL_THREAD_LOCAL (decl)
2916       && !flag_no_common)
2917     DECL_COMMON (decl) = 1;
2918
2919   /* Set attributes here so if duplicate decl, will have proper attributes.  */
2920   decl_attributes (&decl, attributes, 0);
2921
2922   /* If #pragma weak was used, mark the decl weak now.  */
2923   if (current_binding_level == global_binding_level)
2924     maybe_apply_pragma_weak (decl);
2925
2926   if (TREE_CODE (decl) == FUNCTION_DECL
2927       && DECL_DECLARED_INLINE_P (decl)
2928       && DECL_UNINLINABLE (decl)
2929       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
2930     warning_with_decl (decl,
2931                        "inline function `%s' given attribute noinline");
2932
2933   /* Add this decl to the current binding level.
2934      TEM may equal DECL or it may be a previous decl of the same name.  */
2935   tem = pushdecl (decl);
2936
2937   /* For a local variable, define the RTL now.  */
2938   if (current_binding_level != global_binding_level
2939       /* But not if this is a duplicate decl
2940          and we preserved the rtl from the previous one
2941          (which may or may not happen).  */
2942       && !DECL_RTL_SET_P (tem)
2943       && !DECL_CONTEXT (tem))
2944     {
2945       if (TREE_TYPE (tem) != error_mark_node
2946           && COMPLETE_TYPE_P (TREE_TYPE (tem)))
2947         expand_decl (tem);
2948       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
2949                && DECL_INITIAL (tem) != 0)
2950         expand_decl (tem);
2951     }
2952
2953   return tem;
2954 }
2955
2956 /* Finish processing of a declaration;
2957    install its initial value.
2958    If the length of an array type is not known before,
2959    it must be determined now, from the initial value, or it is an error.  */
2960
2961 void
2962 finish_decl (decl, init, asmspec_tree)
2963      tree decl, init;
2964      tree asmspec_tree;
2965 {
2966   tree type = TREE_TYPE (decl);
2967   int was_incomplete = (DECL_SIZE (decl) == 0);
2968   const char *asmspec = 0;
2969
2970   /* If a name was specified, get the string.  */
2971   if (current_binding_level == global_binding_level)
2972     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
2973   if (asmspec_tree)
2974     asmspec = TREE_STRING_POINTER (asmspec_tree);
2975
2976   /* If `start_decl' didn't like having an initialization, ignore it now.  */
2977   if (init != 0 && DECL_INITIAL (decl) == 0)
2978     init = 0;
2979
2980   /* Don't crash if parm is initialized.  */
2981   if (TREE_CODE (decl) == PARM_DECL)
2982     init = 0;
2983
2984   if (init)
2985     store_init_value (decl, init);
2986
2987   /* Deduce size of array from initialization, if not already known */
2988   if (TREE_CODE (type) == ARRAY_TYPE
2989       && TYPE_DOMAIN (type) == 0
2990       && TREE_CODE (decl) != TYPE_DECL)
2991     {
2992       int do_default
2993         = (TREE_STATIC (decl)
2994            /* Even if pedantic, an external linkage array
2995               may have incomplete type at first.  */
2996            ? pedantic && !TREE_PUBLIC (decl)
2997            : !DECL_EXTERNAL (decl));
2998       int failure
2999         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3000
3001       /* Get the completed type made by complete_array_type.  */
3002       type = TREE_TYPE (decl);
3003
3004       if (failure == 1)
3005         error_with_decl (decl, "initializer fails to determine size of `%s'");
3006
3007       else if (failure == 2)
3008         {
3009           if (do_default)
3010             error_with_decl (decl, "array size missing in `%s'");
3011           /* If a `static' var's size isn't known,
3012              make it extern as well as static, so it does not get
3013              allocated.
3014              If it is not `static', then do not mark extern;
3015              finish_incomplete_decl will give it a default size
3016              and it will get allocated.  */
3017           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3018             DECL_EXTERNAL (decl) = 1;
3019         }
3020
3021       /* TYPE_MAX_VALUE is always one less than the number of elements
3022          in the array, because we start counting at zero.  Therefore,
3023          warn only if the value is less than zero.  */
3024       else if (pedantic && TYPE_DOMAIN (type) != 0
3025               && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3026         error_with_decl (decl, "zero or negative size array `%s'");
3027
3028       layout_decl (decl, 0);
3029     }
3030
3031   if (TREE_CODE (decl) == VAR_DECL)
3032     {
3033       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3034           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3035         layout_decl (decl, 0);
3036
3037       if (DECL_SIZE (decl) == 0
3038           /* Don't give an error if we already gave one earlier.  */
3039           && TREE_TYPE (decl) != error_mark_node
3040           && (TREE_STATIC (decl)
3041               ?
3042                 /* A static variable with an incomplete type
3043                    is an error if it is initialized.
3044                    Also if it is not file scope.
3045                    Otherwise, let it through, but if it is not `extern'
3046                    then it may cause an error message later.  */
3047                 (DECL_INITIAL (decl) != 0
3048                  || DECL_CONTEXT (decl) != 0)
3049               :
3050                 /* An automatic variable with an incomplete type
3051                    is an error.  */
3052                 !DECL_EXTERNAL (decl)))
3053         {
3054           error_with_decl (decl, "storage size of `%s' isn't known");
3055           TREE_TYPE (decl) = error_mark_node;
3056         }
3057
3058       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3059           && DECL_SIZE (decl) != 0)
3060         {
3061           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3062             constant_expression_warning (DECL_SIZE (decl));
3063           else
3064             error_with_decl (decl, "storage size of `%s' isn't constant");
3065         }
3066
3067       if (TREE_USED (type))
3068         TREE_USED (decl) = 1;
3069     }
3070
3071   /* If this is a function and an assembler name is specified, it isn't
3072      builtin any more.  Also reset DECL_RTL so we can give it its new
3073      name.  */
3074   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3075     {
3076       DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3077       SET_DECL_RTL (decl, NULL_RTX);
3078       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3079     }
3080
3081   /* Output the assembler code and/or RTL code for variables and functions,
3082      unless the type is an undefined structure or union.
3083      If not, it will get done when the type is completed.  */
3084
3085   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3086     {
3087       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
3088       if (flag_objc)
3089         objc_check_decl (decl);
3090
3091       if (!DECL_CONTEXT (decl))
3092         {
3093           if (DECL_INITIAL (decl) == NULL_TREE
3094               || DECL_INITIAL (decl) == error_mark_node)
3095             /* Don't output anything
3096                when a tentative file-scope definition is seen.
3097                But at end of compilation, do output code for them.  */
3098             DECL_DEFER_OUTPUT (decl) = 1;
3099           rest_of_decl_compilation (decl, asmspec,
3100                                     (DECL_CONTEXT (decl) == 0
3101                                      || TREE_ASM_WRITTEN (decl)), 0);
3102         }
3103       else
3104         {
3105           /* This is a local variable.  If there is an ASMSPEC, the
3106              user has requested that we handle it specially.  */
3107           if (asmspec)
3108             {
3109               /* In conjunction with an ASMSPEC, the `register'
3110                  keyword indicates that we should place the variable
3111                  in a particular register.  */
3112               if (DECL_REGISTER (decl))
3113                 DECL_C_HARD_REGISTER (decl) = 1;
3114
3115               /* If this is not a static variable, issue a warning.
3116                  It doesn't make any sense to give an ASMSPEC for an
3117                  ordinary, non-register local variable.  Historically,
3118                  GCC has accepted -- but ignored -- the ASMSPEC in
3119                  this case.  */
3120               if (TREE_CODE (decl) == VAR_DECL
3121                   && !DECL_REGISTER (decl)
3122                   && !TREE_STATIC (decl))
3123                 warning_with_decl (decl,
3124                                    "ignoring asm-specifier for non-static local variable `%s'");
3125               else
3126                 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3127             }
3128
3129           if (TREE_CODE (decl) != FUNCTION_DECL)
3130             add_decl_stmt (decl);
3131         }
3132
3133       if (DECL_CONTEXT (decl) != 0)
3134         {
3135           /* Recompute the RTL of a local array now
3136              if it used to be an incomplete type.  */
3137           if (was_incomplete
3138               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3139             {
3140               /* If we used it already as memory, it must stay in memory.  */
3141               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3142               /* If it's still incomplete now, no init will save it.  */
3143               if (DECL_SIZE (decl) == 0)
3144                 DECL_INITIAL (decl) = 0;
3145             }
3146         }
3147     }
3148
3149   if (TREE_CODE (decl) == TYPE_DECL)
3150     {
3151       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
3152       if (flag_objc)
3153         objc_check_decl (decl);
3154       rest_of_decl_compilation (decl, NULL, DECL_CONTEXT (decl) == 0, 0);
3155     }
3156
3157   /* At the end of a declaration, throw away any variable type sizes
3158      of types defined inside that declaration.  There is no use
3159      computing them in the following function definition.  */
3160   if (current_binding_level == global_binding_level)
3161     get_pending_sizes ();
3162 }
3163
3164 /* Given a parsed parameter declaration,
3165    decode it into a PARM_DECL and push that on the current binding level.
3166    Also, for the sake of forward parm decls,
3167    record the given order of parms in `parm_order'.  */
3168
3169 void
3170 push_parm_decl (parm)
3171      tree parm;
3172 {
3173   tree decl;
3174   int old_immediate_size_expand = immediate_size_expand;
3175   /* Don't try computing parm sizes now -- wait till fn is called.  */
3176   immediate_size_expand = 0;
3177
3178   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3179                          TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3180   decl_attributes (&decl, TREE_VALUE (parm), 0);
3181
3182 #if 0
3183   if (DECL_NAME (decl))
3184     {
3185       tree olddecl;
3186       olddecl = lookup_name (DECL_NAME (decl));
3187       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3188         pedwarn_with_decl (decl,
3189                            "ISO C forbids parameter `%s' shadowing typedef");
3190     }
3191 #endif
3192
3193   decl = pushdecl (decl);
3194
3195   immediate_size_expand = old_immediate_size_expand;
3196
3197   current_binding_level->parm_order
3198     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3199
3200   /* Add this decl to the current binding level.  */
3201   finish_decl (decl, NULL_TREE, NULL_TREE);
3202 }
3203
3204 /* Clear the given order of parms in `parm_order'.
3205    Used at start of parm list,
3206    and also at semicolon terminating forward decls.  */
3207
3208 void
3209 clear_parm_order ()
3210 {
3211   current_binding_level->parm_order = NULL_TREE;
3212 }
3213 \f
3214 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
3215    literal, which may be an incomplete array type completed by the
3216    initializer; INIT is a CONSTRUCTOR that initializes the compound
3217    literal.  */
3218
3219 tree
3220 build_compound_literal (type, init)
3221      tree type;
3222      tree init;
3223 {
3224   /* We do not use start_decl here because we have a type, not a declarator;
3225      and do not use finish_decl because the decl should be stored inside
3226      the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT.  */
3227   tree decl = build_decl (VAR_DECL, NULL_TREE, type);
3228   tree complit;
3229   tree stmt;
3230   DECL_EXTERNAL (decl) = 0;
3231   TREE_PUBLIC (decl) = 0;
3232   TREE_STATIC (decl) = (current_binding_level == global_binding_level);
3233   DECL_CONTEXT (decl) = current_function_decl;
3234   TREE_USED (decl) = 1;
3235   TREE_TYPE (decl) = type;
3236   TREE_READONLY (decl) = TREE_READONLY (type);
3237   store_init_value (decl, init);
3238
3239   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3240     {
3241       int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3242       if (failure)
3243         abort ();
3244     }
3245
3246   type = TREE_TYPE (decl);
3247   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3248     return error_mark_node;
3249
3250   stmt = build_stmt (DECL_STMT, decl);
3251   complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3252   TREE_SIDE_EFFECTS (complit) = 1;
3253
3254   layout_decl (decl, 0);
3255
3256   if (TREE_STATIC (decl))
3257     {
3258       /* This decl needs a name for the assembler output.  We also need
3259          a unique suffix to be added to the name.  */
3260       char *name;
3261       extern int var_labelno;
3262
3263       ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal", var_labelno);
3264       var_labelno++;
3265       DECL_NAME (decl) = get_identifier (name);
3266       DECL_DEFER_OUTPUT (decl) = 1;
3267       DECL_COMDAT (decl) = 1;
3268       DECL_ARTIFICIAL (decl) = 1;
3269       pushdecl (decl);
3270       rest_of_decl_compilation (decl, NULL, 1, 0);
3271     }
3272
3273   return complit;
3274 }
3275 \f
3276 /* Make TYPE a complete type based on INITIAL_VALUE.
3277    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3278    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3279
3280 int
3281 complete_array_type (type, initial_value, do_default)
3282      tree type;
3283      tree initial_value;
3284      int do_default;
3285 {
3286   tree maxindex = NULL_TREE;
3287   int value = 0;
3288
3289   if (initial_value)
3290     {
3291       /* Note MAXINDEX  is really the maximum index,
3292          one less than the size.  */
3293       if (TREE_CODE (initial_value) == STRING_CST)
3294         {
3295           int eltsize
3296             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3297           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3298                                    / eltsize) - 1, 0);
3299         }
3300       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3301         {
3302           tree elts = CONSTRUCTOR_ELTS (initial_value);
3303           maxindex = build_int_2 (-1, -1);
3304           for (; elts; elts = TREE_CHAIN (elts))
3305             {
3306               if (TREE_PURPOSE (elts))
3307                 maxindex = TREE_PURPOSE (elts);
3308               else
3309                 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3310                                         maxindex, integer_one_node));
3311             }
3312           maxindex = copy_node (maxindex);
3313         }
3314       else
3315         {
3316           /* Make an error message unless that happened already.  */
3317           if (initial_value != error_mark_node)
3318             value = 1;
3319
3320           /* Prevent further error messages.  */
3321           maxindex = build_int_2 (0, 0);
3322         }
3323     }
3324
3325   if (!maxindex)
3326     {
3327       if (do_default)
3328         maxindex = build_int_2 (0, 0);
3329       value = 2;
3330     }
3331
3332   if (maxindex)
3333     {
3334       TYPE_DOMAIN (type) = build_index_type (maxindex);
3335       if (!TREE_TYPE (maxindex))
3336         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3337     }
3338
3339   /* Lay out the type now that we can get the real answer.  */
3340
3341   layout_type (type);
3342
3343   return value;
3344 }
3345 \f
3346 /* Determine whether TYPE is a structure with a flexible array member,
3347    or a union containing such a structure (possibly recursively).  */
3348
3349 static bool
3350 flexible_array_type_p (type)
3351      tree type;
3352 {
3353   tree x;
3354   switch (TREE_CODE (type))
3355     {
3356     case RECORD_TYPE:
3357       x = TYPE_FIELDS (type);
3358       if (x == NULL_TREE)
3359         return false;
3360       while (TREE_CHAIN (x) != NULL_TREE)
3361         x = TREE_CHAIN (x);
3362       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3363           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3364           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3365           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3366         return true;
3367       return false;
3368     case UNION_TYPE:
3369       for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3370         {
3371           if (flexible_array_type_p (TREE_TYPE (x)))
3372             return true;
3373         }
3374       return false;
3375     default:
3376     return false;
3377   }
3378 }
3379 \f
3380 /* Given declspecs and a declarator,
3381    determine the name and type of the object declared
3382    and construct a ..._DECL node for it.
3383    (In one case we can return a ..._TYPE node instead.
3384     For invalid input we sometimes return 0.)
3385
3386    DECLSPECS is a chain of tree_list nodes whose value fields
3387     are the storage classes and type specifiers.
3388
3389    DECL_CONTEXT says which syntactic context this declaration is in:
3390      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3391      FUNCDEF for a function definition.  Like NORMAL but a few different
3392       error messages in each case.  Return value may be zero meaning
3393       this definition is too screwy to try to parse.
3394      PARM for a parameter declaration (either within a function prototype
3395       or before a function body).  Make a PARM_DECL, or return void_type_node.
3396      TYPENAME if for a typename (in a cast or sizeof).
3397       Don't make a DECL node; just return the ..._TYPE node.
3398      FIELD for a struct or union field; make a FIELD_DECL.
3399      BITFIELD for a field with specified width.
3400    INITIALIZED is 1 if the decl has an initializer.
3401
3402    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3403    It may also be so in the PARM case, for a prototype where the
3404    argument type is specified but not the name.
3405
3406    This function is where the complicated C meanings of `static'
3407    and `extern' are interpreted.  */
3408
3409 static tree
3410 grokdeclarator (declarator, declspecs, decl_context, initialized)
3411      tree declspecs;
3412      tree declarator;
3413      enum decl_context decl_context;
3414      int initialized;
3415 {
3416   int specbits = 0;
3417   tree spec;
3418   tree type = NULL_TREE;
3419   int longlong = 0;
3420   int constp;
3421   int restrictp;
3422   int volatilep;
3423   int type_quals = TYPE_UNQUALIFIED;
3424   int inlinep;
3425   int explicit_int = 0;
3426   int explicit_char = 0;
3427   int defaulted_int = 0;
3428   tree typedef_decl = 0;
3429   const char *name;
3430   tree typedef_type = 0;
3431   int funcdef_flag = 0;
3432   enum tree_code innermost_code = ERROR_MARK;
3433   int bitfield = 0;
3434   int size_varies = 0;
3435   tree decl_attr = NULL_TREE;
3436   tree array_ptr_quals = NULL_TREE;
3437   int array_parm_static = 0;
3438   tree returned_attrs = NULL_TREE;
3439
3440   if (decl_context == BITFIELD)
3441     bitfield = 1, decl_context = FIELD;
3442
3443   if (decl_context == FUNCDEF)
3444     funcdef_flag = 1, decl_context = NORMAL;
3445
3446   /* Look inside a declarator for the name being declared
3447      and get it as a string, for an error message.  */
3448   {
3449     tree decl = declarator;
3450     name = 0;
3451
3452     while (decl)
3453       switch (TREE_CODE (decl))
3454         {
3455         case ARRAY_REF:
3456         case INDIRECT_REF:
3457         case CALL_EXPR:
3458           innermost_code = TREE_CODE (decl);
3459           decl = TREE_OPERAND (decl, 0);
3460           break;
3461
3462         case TREE_LIST:
3463           decl = TREE_VALUE (decl);
3464           break;
3465
3466         case IDENTIFIER_NODE:
3467           name = IDENTIFIER_POINTER (decl);
3468           decl = 0;
3469           break;
3470
3471         default:
3472           abort ();
3473         }
3474     if (name == 0)
3475       name = "type name";
3476   }
3477
3478   /* A function definition's declarator must have the form of
3479      a function declarator.  */
3480
3481   if (funcdef_flag && innermost_code != CALL_EXPR)
3482     return 0;
3483
3484   /* Anything declared one level down from the top level
3485      must be one of the parameters of a function
3486      (because the body is at least two levels down).  */
3487
3488   /* If this looks like a function definition, make it one,
3489      even if it occurs where parms are expected.
3490      Then store_parm_decls will reject it and not use it as a parm.  */
3491   if (decl_context == NORMAL && !funcdef_flag
3492       && current_binding_level->parm_flag)
3493     decl_context = PARM;
3494
3495   /* Look through the decl specs and record which ones appear.
3496      Some typespecs are defined as built-in typenames.
3497      Others, the ones that are modifiers of other types,
3498      are represented by bits in SPECBITS: set the bits for
3499      the modifiers that appear.  Storage class keywords are also in SPECBITS.
3500
3501      If there is a typedef name or a type, store the type in TYPE.
3502      This includes builtin typedefs such as `int'.
3503
3504      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3505      and did not come from a user typedef.
3506
3507      Set LONGLONG if `long' is mentioned twice.  */
3508
3509   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3510     {
3511       tree id = TREE_VALUE (spec);
3512
3513       /* If the entire declaration is itself tagged as deprecated then
3514          suppress reports of deprecated items.  */
3515       if (id && TREE_DEPRECATED (id))
3516         {
3517           if (deprecated_state != DEPRECATED_SUPPRESS)
3518             warn_deprecated_use (id);
3519         }
3520
3521       if (id == ridpointers[(int) RID_INT])
3522         explicit_int = 1;
3523       if (id == ridpointers[(int) RID_CHAR])
3524         explicit_char = 1;
3525
3526       if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3527         {
3528           enum rid i = C_RID_CODE (id);
3529           if ((int) i <= (int) RID_LAST_MODIFIER)
3530             {
3531               if (i == RID_LONG && (specbits & (1 << (int) RID_LONG)))
3532                 {
3533                   if (longlong)
3534                     error ("`long long long' is too long for GCC");
3535                   else
3536                     {
3537                       if (pedantic && !flag_isoc99 && ! in_system_header
3538                           && warn_long_long)
3539                         pedwarn ("ISO C90 does not support `long long'");
3540                       longlong = 1;
3541                     }
3542                 }
3543               else if (specbits & (1 << (int) i))
3544                 error ("duplicate `%s'", IDENTIFIER_POINTER (id));
3545
3546               /* Diagnose "__thread extern".  Recall that this list
3547                  is in the reverse order seen in the text.  */
3548               if (i == RID_THREAD
3549                   && (specbits & (1 << (int) RID_EXTERN
3550                                   | 1 << (int) RID_STATIC)))
3551                 {
3552                   if (specbits & 1 << (int) RID_EXTERN)
3553                     error ("`__thread' before `extern'");
3554                   else
3555                     error ("`__thread' before `static'");
3556                 }
3557
3558               specbits |= 1 << (int) i;
3559               goto found;
3560             }
3561         }
3562       if (type)
3563         error ("two or more data types in declaration of `%s'", name);
3564       /* Actual typedefs come to us as TYPE_DECL nodes.  */
3565       else if (TREE_CODE (id) == TYPE_DECL)
3566         {
3567           if (TREE_TYPE (id) == error_mark_node)
3568             ; /* Allow the type to default to int to avoid cascading errors.  */
3569           else
3570             {
3571               type = TREE_TYPE (id);
3572               decl_attr = DECL_ATTRIBUTES (id);
3573               typedef_decl = id;
3574             }
3575         }
3576       /* Built-in types come as identifiers.  */
3577       else if (TREE_CODE (id) == IDENTIFIER_NODE)
3578         {
3579           tree t = lookup_name (id);
3580           if (TREE_TYPE (t) == error_mark_node)
3581             ;
3582           else if (!t || TREE_CODE (t) != TYPE_DECL)
3583             error ("`%s' fails to be a typedef or built in type",
3584                    IDENTIFIER_POINTER (id));
3585           else
3586             {
3587               type = TREE_TYPE (t);
3588               typedef_decl = t;
3589             }
3590         }
3591       else if (TREE_CODE (id) != ERROR_MARK)
3592         type = id;
3593
3594     found:
3595       ;
3596     }
3597
3598   typedef_type = type;
3599   if (type)
3600     size_varies = C_TYPE_VARIABLE_SIZE (type);
3601
3602   /* No type at all: default to `int', and set DEFAULTED_INT
3603      because it was not a user-defined typedef.  */
3604
3605   if (type == 0)
3606     {
3607       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3608                           | (1 << (int) RID_SIGNED)
3609                           | (1 << (int) RID_UNSIGNED)
3610                           | (1 << (int) RID_COMPLEX))))
3611           /* Don't warn about typedef foo = bar.  */
3612           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3613           && ! in_system_header)
3614         {
3615           /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3616              and this is a function, or if -Wimplicit; prefer the former
3617              warning since it is more explicit.  */
3618           if ((warn_implicit_int || warn_return_type || flag_isoc99)
3619               && funcdef_flag)
3620             warn_about_return_type = 1;
3621           else if (warn_implicit_int || flag_isoc99)
3622             pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
3623                          name);
3624         }
3625
3626       defaulted_int = 1;
3627       type = integer_type_node;
3628     }
3629
3630   /* Now process the modifiers that were specified
3631      and check for invalid combinations.  */
3632
3633   /* Long double is a special combination.  */
3634
3635   if ((specbits & 1 << (int) RID_LONG) && ! longlong
3636       && TYPE_MAIN_VARIANT (type) == double_type_node)
3637     {
3638       specbits &= ~(1 << (int) RID_LONG);
3639       type = long_double_type_node;
3640     }
3641
3642   /* Check all other uses of type modifiers.  */
3643
3644   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3645                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3646     {
3647       int ok = 0;
3648
3649       if ((specbits & 1 << (int) RID_LONG)
3650           && (specbits & 1 << (int) RID_SHORT))
3651         error ("both long and short specified for `%s'", name);
3652       else if (((specbits & 1 << (int) RID_LONG)
3653                 || (specbits & 1 << (int) RID_SHORT))
3654                && explicit_char)
3655         error ("long or short specified with char for `%s'", name);
3656       else if (((specbits & 1 << (int) RID_LONG)
3657                 || (specbits & 1 << (int) RID_SHORT))
3658                && TREE_CODE (type) == REAL_TYPE)
3659         {
3660           static int already = 0;
3661
3662           error ("long or short specified with floating type for `%s'", name);
3663           if (! already && ! pedantic)
3664             {
3665               error ("the only valid combination is `long double'");
3666               already = 1;
3667             }
3668         }
3669       else if ((specbits & 1 << (int) RID_SIGNED)
3670                && (specbits & 1 << (int) RID_UNSIGNED))
3671         error ("both signed and unsigned specified for `%s'", name);
3672       else if (TREE_CODE (type) != INTEGER_TYPE)
3673         error ("long, short, signed or unsigned invalid for `%s'", name);
3674       else
3675         {
3676           ok = 1;
3677           if (!explicit_int && !defaulted_int && !explicit_char)
3678             {
3679               error ("long, short, signed or unsigned used invalidly for `%s'",
3680                      name);
3681               ok = 0;
3682             }
3683         }
3684
3685       /* Discard the type modifiers if they are invalid.  */
3686       if (! ok)
3687         {
3688           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3689                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3690           longlong = 0;
3691         }
3692     }
3693
3694   if ((specbits & (1 << (int) RID_COMPLEX))
3695       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
3696     {
3697       error ("complex invalid for `%s'", name);
3698       specbits &= ~(1 << (int) RID_COMPLEX);
3699     }
3700
3701   /* Decide whether an integer type is signed or not.
3702      Optionally treat bitfields as signed by default.  */
3703   if (specbits & 1 << (int) RID_UNSIGNED
3704       || (bitfield && ! flag_signed_bitfields
3705           && (explicit_int || defaulted_int || explicit_char
3706               /* A typedef for plain `int' without `signed'
3707                  can be controlled just like plain `int'.  */
3708               || ! (typedef_decl != 0
3709                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3710           && TREE_CODE (type) != ENUMERAL_TYPE
3711           && !(specbits & 1 << (int) RID_SIGNED)))
3712     {
3713       if (longlong)
3714         type = long_long_unsigned_type_node;
3715       else if (specbits & 1 << (int) RID_LONG)
3716         type = long_unsigned_type_node;
3717       else if (specbits & 1 << (int) RID_SHORT)
3718         type = short_unsigned_type_node;
3719       else if (type == char_type_node)
3720         type = unsigned_char_type_node;
3721       else if (typedef_decl)
3722         type = c_common_unsigned_type (type);
3723       else
3724         type = unsigned_type_node;
3725     }
3726   else if ((specbits & 1 << (int) RID_SIGNED)
3727            && type == char_type_node)
3728     type = signed_char_type_node;
3729   else if (longlong)
3730     type = long_long_integer_type_node;
3731   else if (specbits & 1 << (int) RID_LONG)
3732     type = long_integer_type_node;
3733   else if (specbits & 1 << (int) RID_SHORT)
3734     type = short_integer_type_node;
3735
3736   if (specbits & 1 << (int) RID_COMPLEX)
3737     {
3738       if (pedantic && !flag_isoc99)
3739         pedwarn ("ISO C90 does not support complex types");
3740       /* If we just have "complex", it is equivalent to
3741          "complex double", but if any modifiers at all are specified it is
3742          the complex form of TYPE.  E.g, "complex short" is
3743          "complex short int".  */
3744
3745       if (defaulted_int && ! longlong
3746           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3747                             | (1 << (int) RID_SIGNED)
3748                             | (1 << (int) RID_UNSIGNED))))
3749         {
3750           if (pedantic)
3751             pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
3752           type = complex_double_type_node;
3753         }
3754       else if (type == integer_type_node)
3755         {
3756           if (pedantic)
3757             pedwarn ("ISO C does not support complex integer types");
3758           type = complex_integer_type_node;
3759         }
3760       else if (type == float_type_node)
3761         type = complex_float_type_node;
3762       else if (type == double_type_node)
3763         type = complex_double_type_node;
3764       else if (type == long_double_type_node)
3765         type = complex_long_double_type_node;
3766       else
3767         {
3768           if (pedantic)
3769             pedwarn ("ISO C does not support complex integer types");
3770           type = build_complex_type (type);
3771         }
3772     }
3773
3774   /* Figure out the type qualifiers for the declaration.  There are
3775      two ways a declaration can become qualified.  One is something
3776      like `const int i' where the `const' is explicit.  Another is
3777      something like `typedef const int CI; CI i' where the type of the
3778      declaration contains the `const'.  */
3779   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
3780   restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
3781   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
3782   inlinep = !! (specbits & (1 << (int) RID_INLINE));
3783   if (constp > 1 && ! flag_isoc99)
3784     pedwarn ("duplicate `const'");
3785   if (restrictp > 1 && ! flag_isoc99)
3786     pedwarn ("duplicate `restrict'");
3787   if (volatilep > 1 && ! flag_isoc99)
3788     pedwarn ("duplicate `volatile'");
3789   if (! flag_gen_aux_info && (TYPE_QUALS (type)))
3790     type = TYPE_MAIN_VARIANT (type);
3791   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
3792                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
3793                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
3794
3795   /* Warn if two storage classes are given. Default to `auto'.  */
3796
3797   {
3798     int nclasses = 0;
3799
3800     if (specbits & 1 << (int) RID_AUTO) nclasses++;
3801     if (specbits & 1 << (int) RID_STATIC) nclasses++;
3802     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
3803     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
3804     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
3805
3806     /* "static __thread" and "extern __thread" are allowed.  */
3807     if ((specbits & (1 << (int) RID_THREAD
3808                      | 1 << (int) RID_STATIC
3809                      | 1 << (int) RID_EXTERN)) == (1 << (int) RID_THREAD))
3810       nclasses++;
3811
3812     /* Warn about storage classes that are invalid for certain
3813        kinds of declarations (parameters, typenames, etc.).  */
3814
3815     if (nclasses > 1)
3816       error ("multiple storage classes in declaration of `%s'", name);
3817     else if (funcdef_flag
3818              && (specbits
3819                  & ((1 << (int) RID_REGISTER)
3820                     | (1 << (int) RID_AUTO)
3821                     | (1 << (int) RID_TYPEDEF)
3822                     | (1 << (int) RID_THREAD))))
3823       {
3824         if (specbits & 1 << (int) RID_AUTO
3825             && (pedantic || current_binding_level == global_binding_level))
3826           pedwarn ("function definition declared `auto'");
3827         if (specbits & 1 << (int) RID_REGISTER)
3828           error ("function definition declared `register'");
3829         if (specbits & 1 << (int) RID_TYPEDEF)
3830           error ("function definition declared `typedef'");
3831         if (specbits & 1 << (int) RID_THREAD)
3832           error ("function definition declared `__thread'");
3833         specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3834                       | (1 << (int) RID_AUTO) | (1 << (int) RID_THREAD));
3835       }
3836     else if (decl_context != NORMAL && nclasses > 0)
3837       {
3838         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
3839           ;
3840         else
3841           {
3842             switch (decl_context)
3843               {
3844               case FIELD:
3845                 error ("storage class specified for structure field `%s'",
3846                        name);
3847                 break;
3848               case PARM:
3849                 error ("storage class specified for parameter `%s'", name);
3850                 break;
3851               default:
3852                 error ("storage class specified for typename");
3853                 break;
3854               }
3855             specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3856                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
3857                           | (1 << (int) RID_EXTERN) | (1 << (int) RID_THREAD));
3858           }
3859       }
3860     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
3861       {
3862         /* `extern' with initialization is invalid if not at top level.  */
3863         if (current_binding_level == global_binding_level)
3864           warning ("`%s' initialized and declared `extern'", name);
3865         else
3866           error ("`%s' has both `extern' and initializer", name);
3867       }
3868     else if (current_binding_level == global_binding_level)
3869       {
3870         if (specbits & 1 << (int) RID_AUTO)
3871           error ("top-level declaration of `%s' specifies `auto'", name);
3872       }
3873     else
3874       {
3875         if (specbits & 1 << (int) RID_EXTERN && funcdef_flag)
3876           error ("nested function `%s' declared `extern'", name);
3877         else if ((specbits & (1 << (int) RID_THREAD
3878                                | 1 << (int) RID_EXTERN
3879                                | 1 << (int) RID_STATIC))
3880                  == (1 << (int) RID_THREAD))
3881           {
3882             error ("function-scope `%s' implicitly auto and declared `__thread'",
3883                    name);
3884             specbits &= ~(1 << (int) RID_THREAD);
3885           }
3886       }
3887   }
3888
3889   /* Now figure out the structure of the declarator proper.
3890      Descend through it, creating more complex types, until we reach
3891      the declared identifier (or NULL_TREE, in an absolute declarator).  */
3892
3893   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
3894     {
3895       if (type == error_mark_node)
3896         {
3897           declarator = TREE_OPERAND (declarator, 0);
3898           continue;
3899         }
3900
3901       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3902          an INDIRECT_REF (for *...),
3903          a CALL_EXPR (for ...(...)),
3904          a TREE_LIST (for nested attributes),
3905          an identifier (for the name being declared)
3906          or a null pointer (for the place in an absolute declarator
3907          where the name was omitted).
3908          For the last two cases, we have just exited the loop.
3909
3910          At this point, TYPE is the type of elements of an array,
3911          or for a function to return, or for a pointer to point to.
3912          After this sequence of ifs, TYPE is the type of the
3913          array or function or pointer, and DECLARATOR has had its
3914          outermost layer removed.  */
3915
3916       if (array_ptr_quals != NULL_TREE || array_parm_static)
3917         {
3918           /* Only the innermost declarator (making a parameter be of
3919              array type which is converted to pointer type)
3920              may have static or type qualifiers.  */
3921           error ("static or type qualifiers in non-parameter array declarator");
3922           array_ptr_quals = NULL_TREE;
3923           array_parm_static = 0;
3924         }
3925
3926       if (TREE_CODE (declarator) == TREE_LIST)
3927         {
3928           /* We encode a declarator with embedded attributes using
3929              a TREE_LIST.  */
3930           tree attrs = TREE_PURPOSE (declarator);
3931           tree inner_decl;
3932           int attr_flags = 0;
3933           declarator = TREE_VALUE (declarator);
3934           inner_decl = declarator;
3935           while (inner_decl != NULL_TREE
3936                  && TREE_CODE (inner_decl) == TREE_LIST)
3937             inner_decl = TREE_VALUE (inner_decl);
3938           if (inner_decl == NULL_TREE
3939               || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
3940             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
3941           else if (TREE_CODE (inner_decl) == CALL_EXPR)
3942             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
3943           else if (TREE_CODE (inner_decl) == ARRAY_REF)
3944             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
3945           returned_attrs = decl_attributes (&type,
3946                                             chainon (returned_attrs, attrs),
3947                                             attr_flags);
3948         }
3949       else if (TREE_CODE (declarator) == ARRAY_REF)
3950         {
3951           tree itype = NULL_TREE;
3952           tree size = TREE_OPERAND (declarator, 1);
3953           /* The index is a signed object `sizetype' bits wide.  */
3954           tree index_type = c_common_signed_type (sizetype);
3955
3956           array_ptr_quals = TREE_TYPE (declarator);
3957           array_parm_static = TREE_STATIC (declarator);
3958
3959           declarator = TREE_OPERAND (declarator, 0);
3960
3961           /* Check for some types that there cannot be arrays of.  */
3962
3963           if (VOID_TYPE_P (type))
3964             {
3965               error ("declaration of `%s' as array of voids", name);
3966               type = error_mark_node;
3967             }
3968
3969           if (TREE_CODE (type) == FUNCTION_TYPE)
3970             {
3971               error ("declaration of `%s' as array of functions", name);
3972               type = error_mark_node;
3973             }
3974
3975           if (pedantic && flexible_array_type_p (type))
3976             pedwarn ("invalid use of structure with flexible array member");
3977
3978           if (size == error_mark_node)
3979             type = error_mark_node;
3980
3981           if (type == error_mark_node)
3982             continue;
3983
3984           /* If size was specified, set ITYPE to a range-type for that size.
3985              Otherwise, ITYPE remains null.  finish_decl may figure it out
3986              from an initial value.  */
3987
3988           if (size)
3989             {
3990               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3991               STRIP_TYPE_NOPS (size);
3992
3993               if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
3994                 {
3995                   error ("size of array `%s' has non-integer type", name);
3996                   size = integer_one_node;
3997                 }
3998
3999               if (pedantic && integer_zerop (size))
4000                 pedwarn ("ISO C forbids zero-size array `%s'", name);
4001
4002               if (TREE_CODE (size) == INTEGER_CST)
4003                 {
4004                   constant_expression_warning (size);
4005                   if (tree_int_cst_sgn (size) < 0)
4006                     {
4007                       error ("size of array `%s' is negative", name);
4008                       size = integer_one_node;
4009                     }
4010                 }
4011               else
4012                 {
4013                   /* Make sure the array size remains visibly nonconstant
4014                      even if it is (eg) a const variable with known value.  */
4015                   size_varies = 1;
4016
4017                   if (!flag_isoc99 && pedantic)
4018                     {
4019                       if (TREE_CONSTANT (size))
4020                         pedwarn ("ISO C90 forbids array `%s' whose size can't be evaluated",
4021                                  name);
4022                       else
4023                         pedwarn ("ISO C90 forbids variable-size array `%s'",
4024                                  name);
4025                     }
4026                 }
4027
4028               if (integer_zerop (size))
4029                 {
4030                   /* A zero-length array cannot be represented with an
4031                      unsigned index type, which is what we'll get with
4032                      build_index_type.  Create an open-ended range instead.  */
4033                   itype = build_range_type (sizetype, size, NULL_TREE);
4034                 }
4035               else
4036                 {
4037                   /* Compute the maximum valid index, that is, size - 1.
4038                      Do the calculation in index_type, so that if it is
4039                      a variable the computations will be done in the
4040                      proper mode.  */
4041                   itype = fold (build (MINUS_EXPR, index_type,
4042                                        convert (index_type, size),
4043                                        convert (index_type, size_one_node)));
4044
4045                   /* If that overflowed, the array is too big.
4046                      ??? While a size of INT_MAX+1 technically shouldn't
4047                      cause an overflow (because we subtract 1), the overflow
4048                      is recorded during the conversion to index_type, before
4049                      the subtraction.  Handling this case seems like an
4050                      unnecessary complication.  */
4051                   if (TREE_OVERFLOW (itype))
4052                     {
4053                       error ("size of array `%s' is too large", name);
4054                       type = error_mark_node;
4055                       continue;
4056                     }
4057
4058                   if (size_varies)
4059                     itype = variable_size (itype);
4060                   itype = build_index_type (itype);
4061                 }
4062             }
4063           else if (decl_context == FIELD)
4064             {
4065               if (pedantic && !flag_isoc99 && !in_system_header)
4066                 pedwarn ("ISO C90 does not support flexible array members");
4067
4068               /* ISO C99 Flexible array members are effectively identical
4069                  to GCC's zero-length array extension.  */
4070               itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4071             }
4072
4073           /* If pedantic, complain about arrays of incomplete types.  */
4074
4075           if (pedantic && !COMPLETE_TYPE_P (type))
4076             pedwarn ("array type has incomplete element type");
4077
4078 #if 0
4079           /* We shouldn't have a function type here at all!
4080              Functions aren't allowed as array elements.  */
4081           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4082               && (constp || volatilep))
4083             pedwarn ("ISO C forbids const or volatile function types");
4084 #endif
4085
4086           /* Build the array type itself, then merge any constancy or
4087              volatility into the target type.  We must do it in this order
4088              to ensure that the TYPE_MAIN_VARIANT field of the array type
4089              is set correctly.  */
4090
4091           type = build_array_type (type, itype);
4092           if (type_quals)
4093             type = c_build_qualified_type (type, type_quals);
4094
4095           if (size_varies)
4096             C_TYPE_VARIABLE_SIZE (type) = 1;
4097
4098           /* The GCC extension for zero-length arrays differs from
4099              ISO flexible array members in that sizeof yields zero.  */
4100           if (size && integer_zerop (size))
4101             {
4102               layout_type (type);
4103               TYPE_SIZE (type) = bitsize_zero_node;
4104               TYPE_SIZE_UNIT (type) = size_zero_node;
4105             }
4106           if (decl_context != PARM
4107               && (array_ptr_quals != NULL_TREE || array_parm_static))
4108             {
4109               error ("static or type qualifiers in non-parameter array declarator");
4110               array_ptr_quals = NULL_TREE;
4111               array_parm_static = 0;
4112             }
4113         }
4114       else if (TREE_CODE (declarator) == CALL_EXPR)
4115         {
4116           tree arg_types;
4117
4118           /* Declaring a function type.
4119              Make sure we have a valid type for the function to return.  */
4120           if (type == error_mark_node)
4121             continue;
4122
4123           size_varies = 0;
4124
4125           /* Warn about some types functions can't return.  */
4126
4127           if (TREE_CODE (type) == FUNCTION_TYPE)
4128             {
4129               error ("`%s' declared as function returning a function", name);
4130               type = integer_type_node;
4131             }
4132           if (TREE_CODE (type) == ARRAY_TYPE)
4133             {
4134               error ("`%s' declared as function returning an array", name);
4135               type = integer_type_node;
4136             }
4137
4138           /* Construct the function type and go to the next
4139              inner layer of declarator.  */
4140
4141           arg_types = grokparms (TREE_OPERAND (declarator, 1),
4142                                  funcdef_flag
4143                                  /* Say it's a definition
4144                                     only for the CALL_EXPR
4145                                     closest to the identifier.  */
4146                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4147           /* Type qualifiers before the return type of the function
4148              qualify the return type, not the function type.  */
4149           if (type_quals)
4150             {
4151               /* Type qualifiers on a function return type are normally
4152                  permitted by the standard but have no effect, so give a
4153                  warning at -W.  Qualifiers on a void return type have
4154                  meaning as a GNU extension, and are banned on function
4155                  definitions in ISO C.  FIXME: strictly we shouldn't
4156                  pedwarn for qualified void return types except on function
4157                  definitions, but not doing so could lead to the undesirable
4158                  state of a "volatile void" function return type not being
4159                  warned about, and a use of the function being compiled
4160                  with GNU semantics, with no diagnostics under -pedantic.  */
4161               if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4162                 pedwarn ("ISO C forbids qualified void function return type");
4163               else if (extra_warnings
4164                        && !(VOID_TYPE_P (type)
4165                             && type_quals == TYPE_QUAL_VOLATILE))
4166                 warning ("type qualifiers ignored on function return type");
4167
4168               type = c_build_qualified_type (type, type_quals);
4169             }
4170           type_quals = TYPE_UNQUALIFIED;
4171
4172           type = build_function_type (type, arg_types);
4173           declarator = TREE_OPERAND (declarator, 0);
4174
4175           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4176              the formal parameter list of this FUNCTION_TYPE to point to
4177              the FUNCTION_TYPE node itself.  */
4178
4179           {
4180             tree link;
4181
4182             for (link = last_function_parm_tags;
4183                  link;
4184                  link = TREE_CHAIN (link))
4185               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4186           }
4187         }
4188       else if (TREE_CODE (declarator) == INDIRECT_REF)
4189         {
4190           /* Merge any constancy or volatility into the target type
4191              for the pointer.  */
4192
4193           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4194               && type_quals)
4195             pedwarn ("ISO C forbids qualified function types");
4196           if (type_quals)
4197             type = c_build_qualified_type (type, type_quals);
4198           type_quals = TYPE_UNQUALIFIED;
4199           size_varies = 0;
4200
4201           type = build_pointer_type (type);
4202
4203           /* Process a list of type modifier keywords
4204              (such as const or volatile) that were given inside the `*'.  */
4205
4206           if (TREE_TYPE (declarator))
4207             {
4208               tree typemodlist;
4209               int erred = 0;
4210
4211               constp = 0;
4212               volatilep = 0;
4213               restrictp = 0;
4214               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4215                    typemodlist = TREE_CHAIN (typemodlist))
4216                 {
4217                   tree qualifier = TREE_VALUE (typemodlist);
4218
4219                   if (C_IS_RESERVED_WORD (qualifier))
4220                     {
4221                       if (C_RID_CODE (qualifier) == RID_CONST)
4222                         constp++;
4223                       else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4224                         volatilep++;
4225                       else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4226                         restrictp++;
4227                       else
4228                         erred++;
4229                     }
4230                   else
4231                     erred++;
4232                 }
4233
4234               if (erred)
4235                 error ("invalid type modifier within pointer declarator");
4236               if (constp > 1 && ! flag_isoc99)
4237                 pedwarn ("duplicate `const'");
4238               if (volatilep > 1 && ! flag_isoc99)
4239                 pedwarn ("duplicate `volatile'");
4240               if (restrictp > 1 && ! flag_isoc99)
4241                 pedwarn ("duplicate `restrict'");
4242
4243               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4244                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4245                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4246             }
4247
4248           declarator = TREE_OPERAND (declarator, 0);
4249         }
4250       else
4251         abort ();
4252
4253     }
4254
4255   /* Now TYPE has the actual type.  */
4256
4257   /* Did array size calculations overflow?  */
4258
4259   if (TREE_CODE (type) == ARRAY_TYPE
4260       && COMPLETE_TYPE_P (type)
4261       && TREE_OVERFLOW (TYPE_SIZE (type)))
4262     {
4263       error ("size of array `%s' is too large", name);
4264       /* If we proceed with the array type as it is, we'll eventually
4265          crash in tree_low_cst().  */
4266       type = error_mark_node;
4267     }
4268
4269   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4270
4271   if (specbits & (1 << (int) RID_TYPEDEF))
4272     {
4273       tree decl;
4274       /* Note that the grammar rejects storage classes
4275          in typenames, fields or parameters */
4276       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4277           && type_quals)
4278         pedwarn ("ISO C forbids qualified function types");
4279       if (type_quals)
4280         type = c_build_qualified_type (type, type_quals);
4281       decl = build_decl (TYPE_DECL, declarator, type);
4282       if ((specbits & (1 << (int) RID_SIGNED))
4283           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4284         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4285       decl_attributes (&decl, returned_attrs, 0);
4286       return decl;
4287     }
4288
4289   /* Detect the case of an array type of unspecified size
4290      which came, as such, direct from a typedef name.
4291      We must copy the type, so that each identifier gets
4292      a distinct type, so that each identifier's size can be
4293      controlled separately by its own initializer.  */
4294
4295   if (type != 0 && typedef_type != 0
4296       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4297       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4298     {
4299       type = build_array_type (TREE_TYPE (type), 0);
4300       if (size_varies)
4301         C_TYPE_VARIABLE_SIZE (type) = 1;
4302     }
4303
4304   /* If this is a type name (such as, in a cast or sizeof),
4305      compute the type and return it now.  */
4306
4307   if (decl_context == TYPENAME)
4308     {
4309       /* Note that the grammar rejects storage classes
4310          in typenames, fields or parameters */
4311       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4312           && type_quals)
4313         pedwarn ("ISO C forbids const or volatile function types");
4314       if (type_quals)
4315         type = c_build_qualified_type (type, type_quals);
4316       decl_attributes (&type, returned_attrs, 0);
4317       return type;
4318     }
4319
4320   /* Aside from typedefs and type names (handle above),
4321      `void' at top level (not within pointer)
4322      is allowed only in public variables.
4323      We don't complain about parms either, but that is because
4324      a better error message can be made later.  */
4325
4326   if (VOID_TYPE_P (type) && decl_context != PARM
4327       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4328             && ((specbits & (1 << (int) RID_EXTERN))
4329                 || (current_binding_level == global_binding_level
4330                     && !(specbits
4331                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4332     {
4333       error ("variable or field `%s' declared void", name);
4334       type = integer_type_node;
4335     }
4336
4337   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4338      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4339
4340   {
4341     tree decl;
4342
4343     if (decl_context == PARM)
4344       {
4345         tree type_as_written;
4346         tree promoted_type;
4347
4348         /* A parameter declared as an array of T is really a pointer to T.
4349            One declared as a function is really a pointer to a function.  */
4350
4351         if (TREE_CODE (type) == ARRAY_TYPE)
4352           {
4353             /* Transfer const-ness of array into that of type pointed to.  */
4354             type = TREE_TYPE (type);
4355             if (type_quals)
4356               type = c_build_qualified_type (type, type_quals);
4357             type = build_pointer_type (type);
4358             type_quals = TYPE_UNQUALIFIED;
4359             if (array_ptr_quals)
4360               {
4361                 tree new_ptr_quals, new_ptr_attrs;
4362                 int erred = 0;
4363                 split_specs_attrs (array_ptr_quals, &new_ptr_quals, &new_ptr_attrs);
4364                 /* We don't yet implement attributes in this context.  */
4365                 if (new_ptr_attrs != NULL_TREE)
4366                   warning ("attributes in parameter array declarator ignored");
4367
4368                 constp = 0;
4369                 volatilep = 0;
4370                 restrictp = 0;
4371                 for (; new_ptr_quals; new_ptr_quals = TREE_CHAIN (new_ptr_quals))
4372                   {
4373                     tree qualifier = TREE_VALUE (new_ptr_quals);
4374
4375                     if (C_IS_RESERVED_WORD (qualifier))
4376                       {
4377                         if (C_RID_CODE (qualifier) == RID_CONST)
4378                           constp++;
4379                         else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4380                           volatilep++;
4381                         else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4382                           restrictp++;
4383                         else
4384                           erred++;
4385                       }
4386                     else
4387                       erred++;
4388                   }
4389
4390                 if (erred)
4391                   error ("invalid type modifier within array declarator");
4392
4393                 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4394                               | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4395                               | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4396               }
4397             size_varies = 0;
4398           }
4399         else if (TREE_CODE (type) == FUNCTION_TYPE)
4400           {
4401             if (pedantic && type_quals)
4402               pedwarn ("ISO C forbids qualified function types");
4403             if (type_quals)
4404               type = c_build_qualified_type (type, type_quals);
4405             type = build_pointer_type (type);
4406             type_quals = TYPE_UNQUALIFIED;
4407           }
4408         else if (type_quals)
4409           type = c_build_qualified_type (type, type_quals);
4410
4411         type_as_written = type;
4412
4413         decl = build_decl (PARM_DECL, declarator, type);
4414         if (size_varies)
4415           C_DECL_VARIABLE_SIZE (decl) = 1;
4416
4417         /* Compute the type actually passed in the parmlist,
4418            for the case where there is no prototype.
4419            (For example, shorts and chars are passed as ints.)
4420            When there is a prototype, this is overridden later.  */
4421
4422         if (type == error_mark_node)
4423           promoted_type = type;
4424         else
4425           promoted_type = c_type_promotes_to (type);
4426
4427         DECL_ARG_TYPE (decl) = promoted_type;
4428         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4429       }
4430     else if (decl_context == FIELD)
4431       {
4432         /* Structure field.  It may not be a function.  */
4433
4434         if (TREE_CODE (type) == FUNCTION_TYPE)
4435           {
4436             error ("field `%s' declared as a function", name);
4437             type = build_pointer_type (type);
4438           }
4439         else if (TREE_CODE (type) != ERROR_MARK
4440                  && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4441           {
4442             error ("field `%s' has incomplete type", name);
4443             type = error_mark_node;
4444           }
4445         /* Move type qualifiers down to element of an array.  */
4446         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4447           {
4448             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4449                                                              type_quals),
4450                                      TYPE_DOMAIN (type));
4451 #if 0
4452             /* Leave the field const or volatile as well.  */
4453             type_quals = TYPE_UNQUALIFIED;
4454 #endif
4455           }
4456         decl = build_decl (FIELD_DECL, declarator, type);
4457         DECL_NONADDRESSABLE_P (decl) = bitfield;
4458
4459         if (size_varies)
4460           C_DECL_VARIABLE_SIZE (decl) = 1;
4461       }
4462     else if (TREE_CODE (type) == FUNCTION_TYPE)
4463       {
4464         /* Every function declaration is "external"
4465            except for those which are inside a function body
4466            in which `auto' is used.
4467            That is a case not specified by ANSI C,
4468            and we use it for forward declarations for nested functions.  */
4469         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4470                           || current_binding_level == global_binding_level);
4471
4472         if (specbits & (1 << (int) RID_AUTO)
4473             && (pedantic || current_binding_level == global_binding_level))
4474           pedwarn ("invalid storage class for function `%s'", name);
4475         if (specbits & (1 << (int) RID_REGISTER))
4476           error ("invalid storage class for function `%s'", name);
4477         if (specbits & (1 << (int) RID_THREAD))
4478           error ("invalid storage class for function `%s'", name);
4479         /* Function declaration not at top level.
4480            Storage classes other than `extern' are not allowed
4481            and `extern' makes no difference.  */
4482         if (current_binding_level != global_binding_level
4483             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4484             && pedantic)
4485           pedwarn ("invalid storage class for function `%s'", name);
4486
4487         decl = build_decl (FUNCTION_DECL, declarator, type);
4488         decl = build_decl_attribute_variant (decl, decl_attr);
4489
4490         DECL_LANG_SPECIFIC (decl) = (struct lang_decl *)
4491           ggc_alloc_cleared (sizeof (struct lang_decl));
4492
4493         if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4494           pedwarn ("ISO C forbids qualified function types");
4495
4496         /* GNU C interprets a `volatile void' return type to indicate
4497            that the function does not return.  */
4498         if ((type_quals & TYPE_QUAL_VOLATILE)
4499             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4500           warning ("`noreturn' function returns non-void value");
4501
4502         if (extern_ref)
4503           DECL_EXTERNAL (decl) = 1;
4504         /* Record absence of global scope for `static' or `auto'.  */
4505         TREE_PUBLIC (decl)
4506           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4507
4508         if (defaulted_int)
4509           C_FUNCTION_IMPLICIT_INT (decl) = 1;
4510
4511         /* Record presence of `inline', if it is reasonable.  */
4512         if (MAIN_NAME_P (declarator))
4513           {
4514             if (inlinep)
4515               warning ("cannot inline function `main'");
4516           }
4517         else if (inlinep)
4518           {
4519             /* Assume that otherwise the function can be inlined.  */
4520             DECL_DECLARED_INLINE_P (decl) = 1;
4521
4522             /* Do not mark bare declarations as DECL_INLINE.  Doing so
4523                in the presence of multiple declarations can result in
4524                the abstract origin pointing between the declarations,
4525                which will confuse dwarf2out.  */
4526             if (initialized)
4527               {
4528                 DECL_INLINE (decl) = 1;
4529                 if (specbits & (1 << (int) RID_EXTERN))
4530                   current_extern_inline = 1;
4531               }
4532           }
4533         /* If -finline-functions, assume it can be inlined.  This does
4534            two things: let the function be deferred until it is actually
4535            needed, and let dwarf2 know that the function is inlinable.  */
4536         else if (flag_inline_trees == 2 && initialized)
4537           {
4538             DECL_INLINE (decl) = 1;
4539             DECL_DECLARED_INLINE_P (decl) = 0;
4540           }
4541       }
4542     else
4543       {
4544         /* It's a variable.  */
4545         /* An uninitialized decl with `extern' is a reference.  */
4546         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4547
4548         /* Move type qualifiers down to element of an array.  */
4549         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4550           {
4551             int saved_align = TYPE_ALIGN(type);
4552             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4553                                                              type_quals),
4554                                      TYPE_DOMAIN (type));
4555             TYPE_ALIGN (type) = saved_align;
4556 #if 0 /* Leave the variable const or volatile as well.  */
4557             type_quals = TYPE_UNQUALIFIED;
4558 #endif
4559           }
4560         else if (type_quals)
4561           type = c_build_qualified_type (type, type_quals);
4562
4563         decl = build_decl (VAR_DECL, declarator, type);
4564         if (size_varies)
4565           C_DECL_VARIABLE_SIZE (decl) = 1;
4566
4567         if (inlinep)
4568           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4569
4570         DECL_EXTERNAL (decl) = extern_ref;
4571
4572         /* At top level, the presence of a `static' or `register' storage
4573            class specifier, or the absence of all storage class specifiers
4574            makes this declaration a definition (perhaps tentative).  Also,
4575            the absence of both `static' and `register' makes it public.  */
4576         if (current_binding_level == global_binding_level)
4577           {
4578             TREE_PUBLIC (decl) = !(specbits & ((1 << (int) RID_STATIC)
4579                                                | (1 << (int) RID_REGISTER)));
4580             TREE_STATIC (decl) = !extern_ref;
4581           }
4582         /* Not at top level, only `static' makes a static definition.  */
4583         else
4584           {
4585             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4586             TREE_PUBLIC (decl) = extern_ref;
4587           }
4588
4589         if (specbits & 1 << (int) RID_THREAD)
4590           {
4591             if (targetm.have_tls)
4592               DECL_THREAD_LOCAL (decl) = 1;
4593             else
4594               /* A mere warning is sure to result in improper semantics
4595                  at runtime.  Don't bother to allow this to compile.  */
4596               error ("thread-local storage not supported for this target");
4597           }
4598       }
4599
4600     /* Record `register' declaration for warnings on &
4601        and in case doing stupid register allocation.  */
4602
4603     if (specbits & (1 << (int) RID_REGISTER))
4604       DECL_REGISTER (decl) = 1;
4605
4606     /* Record constancy and volatility.  */
4607     c_apply_type_quals_to_decl (type_quals, decl);
4608
4609     /* If a type has volatile components, it should be stored in memory.
4610        Otherwise, the fact that those components are volatile
4611        will be ignored, and would even crash the compiler.  */
4612     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4613       c_mark_addressable (decl);
4614
4615     decl_attributes (&decl, returned_attrs, 0);
4616
4617     return decl;
4618   }
4619 }
4620 \f
4621 /* Decode the parameter-list info for a function type or function definition.
4622    The argument is the value returned by `get_parm_info' (or made in parse.y
4623    if there is an identifier list instead of a parameter decl list).
4624    These two functions are separate because when a function returns
4625    or receives functions then each is called multiple times but the order
4626    of calls is different.  The last call to `grokparms' is always the one
4627    that contains the formal parameter names of a function definition.
4628
4629    Store in `last_function_parms' a chain of the decls of parms.
4630    Also store in `last_function_parm_tags' a chain of the struct, union,
4631    and enum tags declared among the parms.
4632
4633    Return a list of arg types to use in the FUNCTION_TYPE for this function.
4634
4635    FUNCDEF_FLAG is nonzero for a function definition, 0 for
4636    a mere declaration.  A nonempty identifier-list gets an error message
4637    when FUNCDEF_FLAG is zero.  */
4638
4639 static tree
4640 grokparms (parms_info, funcdef_flag)
4641      tree parms_info;
4642      int funcdef_flag;
4643 {
4644   tree first_parm = TREE_CHAIN (parms_info);
4645
4646   last_function_parms = TREE_PURPOSE (parms_info);
4647   last_function_parm_tags = TREE_VALUE (parms_info);
4648
4649   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
4650       && !in_system_header)
4651     warning ("function declaration isn't a prototype");
4652
4653   if (first_parm != 0
4654       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4655     {
4656       if (! funcdef_flag)
4657         pedwarn ("parameter names (without types) in function declaration");
4658
4659       last_function_parms = first_parm;
4660       return 0;
4661     }
4662   else
4663     {
4664       tree parm;
4665       tree typelt;
4666       /* We no longer test FUNCDEF_FLAG.
4667          If the arg types are incomplete in a declaration,
4668          they must include undefined tags.
4669          These tags can never be defined in the scope of the declaration,
4670          so the types can never be completed,
4671          and no call can be compiled successfully.  */
4672 #if 0
4673       /* In a fcn definition, arg types must be complete.  */
4674       if (funcdef_flag)
4675 #endif
4676         for (parm = last_function_parms, typelt = first_parm;
4677              parm;
4678              parm = TREE_CHAIN (parm))
4679           /* Skip over any enumeration constants declared here.  */
4680           if (TREE_CODE (parm) == PARM_DECL)
4681             {
4682               /* Barf if the parameter itself has an incomplete type.  */
4683               tree type = TREE_VALUE (typelt);
4684               if (type == error_mark_node)
4685                 continue;
4686               if (!COMPLETE_TYPE_P (type))
4687                 {
4688                   if (funcdef_flag && DECL_NAME (parm) != 0)
4689                     error ("parameter `%s' has incomplete type",
4690                            IDENTIFIER_POINTER (DECL_NAME (parm)));
4691                   else
4692                     warning ("parameter has incomplete type");
4693                   if (funcdef_flag)
4694                     {
4695                       TREE_VALUE (typelt) = error_mark_node;
4696                       TREE_TYPE (parm) = error_mark_node;
4697                     }
4698                 }
4699 #if 0
4700               /* This has been replaced by parm_tags_warning, which
4701                  uses a more accurate criterion for what to warn
4702                  about.  */
4703               else
4704                 {
4705                   /* Now warn if is a pointer to an incomplete type.  */
4706                   while (TREE_CODE (type) == POINTER_TYPE
4707                          || TREE_CODE (type) == REFERENCE_TYPE)
4708                     type = TREE_TYPE (type);
4709                   type = TYPE_MAIN_VARIANT (type);
4710                   if (!COMPLETE_TYPE_P (type))
4711                     {
4712                       if (DECL_NAME (parm) != 0)
4713                         warning ("parameter `%s' points to incomplete type",
4714                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
4715                       else
4716                         warning ("parameter points to incomplete type");
4717                     }
4718                 }
4719 #endif
4720               typelt = TREE_CHAIN (typelt);
4721             }
4722
4723       return first_parm;
4724     }
4725 }
4726
4727 /* Return a tree_list node with info on a parameter list just parsed.
4728    The TREE_PURPOSE is a chain of decls of those parms.
4729    The TREE_VALUE is a list of structure, union and enum tags defined.
4730    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4731    This tree_list node is later fed to `grokparms'.
4732
4733    VOID_AT_END nonzero means append `void' to the end of the type-list.
4734    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
4735
4736 tree
4737 get_parm_info (void_at_end)
4738      int void_at_end;
4739 {
4740   tree decl, t;
4741   tree types = 0;
4742   int erred = 0;
4743   tree tags = gettags ();
4744   tree parms = getdecls ();
4745   tree new_parms = 0;
4746   tree order = current_binding_level->parm_order;
4747
4748   /* Just `void' (and no ellipsis) is special.  There are really no parms.
4749      But if the `void' is qualified (by `const' or `volatile') or has a
4750      storage class specifier (`register'), then the behavior is undefined;
4751      by not counting it as the special case of `void' we will cause an
4752      error later.  Typedefs for `void' are OK (see DR#157).  */
4753   if (void_at_end && parms != 0
4754       && TREE_CHAIN (parms) == 0
4755       && VOID_TYPE_P (TREE_TYPE (parms))
4756       && ! TREE_THIS_VOLATILE (parms)
4757       && ! TREE_READONLY (parms)
4758       && ! DECL_REGISTER (parms)
4759       && DECL_NAME (parms) == 0)
4760     {
4761       parms = NULL_TREE;
4762       storedecls (NULL_TREE);
4763       return tree_cons (NULL_TREE, NULL_TREE,
4764                         tree_cons (NULL_TREE, void_type_node, NULL_TREE));
4765     }
4766
4767   /* Extract enumerator values and other non-parms declared with the parms.
4768      Likewise any forward parm decls that didn't have real parm decls.  */
4769   for (decl = parms; decl;)
4770     {
4771       tree next = TREE_CHAIN (decl);
4772
4773       if (TREE_CODE (decl) != PARM_DECL)
4774         {
4775           TREE_CHAIN (decl) = new_parms;
4776           new_parms = decl;
4777         }
4778       else if (TREE_ASM_WRITTEN (decl))
4779         {
4780           error_with_decl (decl,
4781                            "parameter `%s' has just a forward declaration");
4782           TREE_CHAIN (decl) = new_parms;
4783           new_parms = decl;
4784         }
4785       decl = next;
4786     }
4787
4788   /* Put the parm decls back in the order they were in in the parm list.  */
4789   for (t = order; t; t = TREE_CHAIN (t))
4790     {
4791       if (TREE_CHAIN (t))
4792         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
4793       else
4794         TREE_CHAIN (TREE_VALUE (t)) = 0;
4795     }
4796
4797   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
4798                        new_parms);
4799
4800   /* Store the parmlist in the binding level since the old one
4801      is no longer a valid list.  (We have changed the chain pointers.)  */
4802   storedecls (new_parms);
4803
4804   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
4805     /* There may also be declarations for enumerators if an enumeration
4806        type is declared among the parms.  Ignore them here.  */
4807     if (TREE_CODE (decl) == PARM_DECL)
4808       {
4809         /* Since there is a prototype,
4810            args are passed in their declared types.  */
4811         tree type = TREE_TYPE (decl);
4812         DECL_ARG_TYPE (decl) = type;
4813         if (PROMOTE_PROTOTYPES
4814             && INTEGRAL_TYPE_P (type)
4815             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4816           DECL_ARG_TYPE (decl) = integer_type_node;
4817
4818         types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
4819         if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
4820             && DECL_NAME (decl) == 0)
4821           {
4822             error ("`void' in parameter list must be the entire list");
4823             erred = 1;
4824           }
4825       }
4826
4827   if (void_at_end)
4828     return tree_cons (new_parms, tags,
4829                       nreverse (tree_cons (NULL_TREE, void_type_node, types)));
4830
4831   return tree_cons (new_parms, tags, nreverse (types));
4832 }
4833
4834 /* At end of parameter list, warn about any struct, union or enum tags
4835    defined within.  Do so because these types cannot ever become complete.  */
4836
4837 void
4838 parmlist_tags_warning ()
4839 {
4840   tree elt;
4841   static int already;
4842
4843   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
4844     {
4845       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
4846       /* An anonymous union parm type is meaningful as a GNU extension.
4847          So don't warn for that.  */
4848       if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
4849         continue;
4850       if (TREE_PURPOSE (elt) != 0)
4851         {
4852           if (code == RECORD_TYPE)
4853             warning ("`struct %s' declared inside parameter list",
4854                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4855           else if (code == UNION_TYPE)
4856             warning ("`union %s' declared inside parameter list",
4857                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4858           else
4859             warning ("`enum %s' declared inside parameter list",
4860                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4861         }
4862       else
4863         {
4864           /* For translation these need to be separate warnings */
4865           if (code == RECORD_TYPE)
4866             warning ("anonymous struct declared inside parameter list");
4867           else if (code == UNION_TYPE)
4868             warning ("anonymous union declared inside parameter list");
4869           else
4870             warning ("anonymous enum declared inside parameter list");
4871         }
4872       if (! already)
4873         {
4874           warning ("its scope is only this definition or declaration, which is probably not what you want");
4875           already = 1;
4876         }
4877     }
4878 }
4879 \f
4880 /* Get the struct, enum or union (CODE says which) with tag NAME.
4881    Define the tag as a forward-reference if it is not defined.  */
4882
4883 tree
4884 xref_tag (code, name)
4885      enum tree_code code;
4886      tree name;
4887 {
4888   /* If a cross reference is requested, look up the type
4889      already defined for this tag and return it.  */
4890
4891   tree ref = lookup_tag (code, name, current_binding_level, 0);
4892   /* If this is the right type of tag, return what we found.
4893      (This reference will be shadowed by shadow_tag later if appropriate.)
4894      If this is the wrong type of tag, do not return it.  If it was the
4895      wrong type in the same binding level, we will have had an error
4896      message already; if in a different binding level and declaring
4897      a name, pending_xref_error will give an error message; but if in a
4898      different binding level and not declaring a name, this tag should
4899      shadow the previous declaration of a different type of tag, and
4900      this would not work properly if we return the reference found.
4901      (For example, with "struct foo" in an outer scope, "union foo;"
4902      must shadow that tag with a new one of union type.)  */
4903   if (ref && TREE_CODE (ref) == code)
4904     return ref;
4905
4906   /* If no such tag is yet defined, create a forward-reference node
4907      and record it as the "definition".
4908      When a real declaration of this type is found,
4909      the forward-reference will be altered into a real type.  */
4910
4911   ref = make_node (code);
4912   if (code == ENUMERAL_TYPE)
4913     {
4914       /* Give the type a default layout like unsigned int
4915          to avoid crashing if it does not get defined.  */
4916       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
4917       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
4918       TYPE_USER_ALIGN (ref) = 0;
4919       TREE_UNSIGNED (ref) = 1;
4920       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
4921       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
4922       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
4923     }
4924
4925   pushtag (name, ref);
4926
4927   return ref;
4928 }
4929 \f
4930 /* Make sure that the tag NAME is defined *in the current binding level*
4931    at least as a forward reference.
4932    CODE says which kind of tag NAME ought to be.  */
4933
4934 tree
4935 start_struct (code, name)
4936      enum tree_code code;
4937      tree name;
4938 {
4939   /* If there is already a tag defined at this binding level
4940      (as a forward reference), just return it.  */
4941
4942   tree ref = 0;
4943
4944   if (name != 0)
4945     ref = lookup_tag (code, name, current_binding_level, 1);
4946   if (ref && TREE_CODE (ref) == code)
4947     {
4948       C_TYPE_BEING_DEFINED (ref) = 1;
4949       TYPE_PACKED (ref) = flag_pack_struct;
4950       if (TYPE_FIELDS (ref))
4951         {
4952           if (code == UNION_TYPE)
4953             error ("redefinition of `union %s'",
4954                    IDENTIFIER_POINTER (name));
4955           else
4956             error ("redefinition of `struct %s'",
4957                    IDENTIFIER_POINTER (name));
4958         }
4959
4960       return ref;
4961     }
4962
4963   /* Otherwise create a forward-reference just so the tag is in scope.  */
4964
4965   ref = make_node (code);
4966   pushtag (name, ref);
4967   C_TYPE_BEING_DEFINED (ref) = 1;
4968   TYPE_PACKED (ref) = flag_pack_struct;
4969   return ref;
4970 }
4971
4972 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
4973    of a structure component, returning a FIELD_DECL node.
4974    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
4975
4976    This is done during the parsing of the struct declaration.
4977    The FIELD_DECL nodes are chained together and the lot of them
4978    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
4979
4980 tree
4981 grokfield (filename, line, declarator, declspecs, width)
4982      const char *filename ATTRIBUTE_UNUSED;
4983      int line ATTRIBUTE_UNUSED;
4984      tree declarator, declspecs, width;
4985 {
4986   tree value;
4987
4988   if (declarator == NULL_TREE && width == NULL_TREE)
4989     {
4990       /* This is an unnamed decl.
4991
4992          If we have something of the form "union { list } ;" then this
4993          is the anonymous union extension.  Similarly for struct.
4994
4995          If this is something of the form "struct foo;", then
4996            If MS extensions are enabled, this is handled as an
4997              anonymous struct.
4998            Otherwise this is a forward declaration of a structure tag.
4999
5000          If this is something of the form "foo;" and foo is a TYPE_DECL, then
5001            If MS extensions are enabled and foo names a structure, then
5002              again this is an anonymous struct.
5003            Otherwise this is an error.
5004
5005          Oh what a horrid tangled web we weave.  I wonder if MS consiously
5006          took this from Plan 9 or if it was an accident of implementation
5007          that took root before someone noticed the bug...  */
5008
5009       tree type = TREE_VALUE (declspecs);
5010
5011       if (flag_ms_extensions && TREE_CODE (type) == TYPE_DECL)
5012         type = TREE_TYPE (type);
5013       if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE)
5014         {
5015           if (flag_ms_extensions)
5016             ; /* ok */
5017           else if (flag_iso)
5018             goto warn_unnamed_field;
5019           else if (TYPE_NAME (type) == NULL)
5020             ; /* ok */
5021           else
5022             goto warn_unnamed_field;
5023         }
5024       else
5025         {
5026         warn_unnamed_field:
5027           warning ("declaration does not declare anything");
5028           return NULL_TREE;
5029         }
5030     }
5031
5032   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5033
5034   finish_decl (value, NULL_TREE, NULL_TREE);
5035   DECL_INITIAL (value) = width;
5036
5037   if (flag_objc)
5038     objc_check_decl (value);
5039   return value;
5040 }
5041 \f
5042 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5043    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5044    ATTRIBUTES are attributes to be applied to the structure.  */
5045
5046 tree
5047 finish_struct (t, fieldlist, attributes)
5048      tree t;
5049      tree fieldlist;
5050      tree attributes;
5051 {
5052   tree x;
5053   int toplevel = global_binding_level == current_binding_level;
5054   int saw_named_field;
5055
5056   /* If this type was previously laid out as a forward reference,
5057      make sure we lay it out again.  */
5058
5059   TYPE_SIZE (t) = 0;
5060
5061   decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5062
5063   /* Nameless union parm types are useful as GCC extension.  */
5064   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5065     /* Otherwise, warn about any struct or union def. in parmlist.  */
5066     if (in_parm_level_p ())
5067       {
5068         if (pedantic)
5069           pedwarn ("%s defined inside parms",
5070                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5071         else
5072           warning ("%s defined inside parms",
5073                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5074       }
5075
5076   if (pedantic)
5077     {
5078       for (x = fieldlist; x; x = TREE_CHAIN (x))
5079         if (DECL_NAME (x) != 0)
5080           break;
5081
5082       if (x == 0)
5083         pedwarn ("%s has no %s",
5084                  TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
5085                  fieldlist ? _("named members") : _("members"));
5086     }
5087
5088   /* Install struct as DECL_CONTEXT of each field decl.
5089      Also process specified field sizes,m which is found in the DECL_INITIAL.
5090      Store 0 there, except for ": 0" fields (so we can find them
5091      and delete them, below).  */
5092
5093   saw_named_field = 0;
5094   for (x = fieldlist; x; x = TREE_CHAIN (x))
5095     {
5096       DECL_CONTEXT (x) = t;
5097       DECL_PACKED (x) |= TYPE_PACKED (t);
5098
5099       /* If any field is const, the structure type is pseudo-const.  */
5100       if (TREE_READONLY (x))
5101         C_TYPE_FIELDS_READONLY (t) = 1;
5102       else
5103         {
5104           /* A field that is pseudo-const makes the structure likewise.  */
5105           tree t1 = TREE_TYPE (x);
5106           while (TREE_CODE (t1) == ARRAY_TYPE)
5107             t1 = TREE_TYPE (t1);
5108           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5109               && C_TYPE_FIELDS_READONLY (t1))
5110             C_TYPE_FIELDS_READONLY (t) = 1;
5111         }
5112
5113       /* Any field that is volatile means variables of this type must be
5114          treated in some ways as volatile.  */
5115       if (TREE_THIS_VOLATILE (x))
5116         C_TYPE_FIELDS_VOLATILE (t) = 1;
5117
5118       /* Any field of nominal variable size implies structure is too.  */
5119       if (C_DECL_VARIABLE_SIZE (x))
5120         C_TYPE_VARIABLE_SIZE (t) = 1;
5121
5122       /* Detect invalid nested redefinition.  */
5123       if (TREE_TYPE (x) == t)
5124         error ("nested redefinition of `%s'",
5125                IDENTIFIER_POINTER (TYPE_NAME (t)));
5126
5127       /* Detect invalid bit-field size.  */
5128       if (DECL_INITIAL (x))
5129         STRIP_NOPS (DECL_INITIAL (x));
5130       if (DECL_INITIAL (x))
5131         {
5132           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5133             constant_expression_warning (DECL_INITIAL (x));
5134           else
5135             {
5136               error_with_decl (x,
5137                                "bit-field `%s' width not an integer constant");
5138               DECL_INITIAL (x) = NULL;
5139             }
5140         }
5141
5142       /* Detect invalid bit-field type.  */
5143       if (DECL_INITIAL (x)
5144           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5145           && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE
5146           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5147         {
5148           error_with_decl (x, "bit-field `%s' has invalid type");
5149           DECL_INITIAL (x) = NULL;
5150         }
5151
5152       if (DECL_INITIAL (x) && pedantic
5153           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5154           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5155           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != c_bool_type_node
5156           /* Accept an enum that's equivalent to int or unsigned int.  */
5157           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5158                && (TYPE_PRECISION (TREE_TYPE (x))
5159                    == TYPE_PRECISION (integer_type_node))))
5160         pedwarn_with_decl (x, "bit-field `%s' type invalid in ISO C");
5161
5162       /* Detect and ignore out of range field width and process valid
5163          field widths.  */
5164       if (DECL_INITIAL (x))
5165         {
5166           int max_width
5167             = (TYPE_MAIN_VARIANT (TREE_TYPE (x)) == c_bool_type_node
5168                ? CHAR_TYPE_SIZE : TYPE_PRECISION (TREE_TYPE (x)));
5169
5170           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5171             error_with_decl (x, "negative width in bit-field `%s'");
5172           else if (0 < compare_tree_int (DECL_INITIAL (x), max_width))
5173             pedwarn_with_decl (x, "width of `%s' exceeds its type");
5174           else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5175             error_with_decl (x, "zero width for bit-field `%s'");
5176           else
5177             {
5178               /* The test above has assured us that TREE_INT_CST_HIGH is 0.  */
5179               unsigned HOST_WIDE_INT width
5180                 = tree_low_cst (DECL_INITIAL (x), 1);
5181
5182               if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5183                   && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5184                                              TREE_UNSIGNED (TREE_TYPE (x)))
5185                       || (width
5186                           < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5187                                            TREE_UNSIGNED (TREE_TYPE (x))))))
5188                 warning_with_decl (x,
5189                                    "`%s' is narrower than values of its type");
5190
5191               DECL_SIZE (x) = bitsize_int (width);
5192               DECL_BIT_FIELD (x) = 1;
5193               SET_DECL_C_BIT_FIELD (x);
5194
5195               if (width == 0
5196                   && ! (* targetm.ms_bitfield_layout_p) (t))
5197                 {
5198                   /* field size 0 => force desired amount of alignment.  */
5199 #ifdef EMPTY_FIELD_BOUNDARY
5200                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5201 #endif
5202 #ifdef PCC_BITFIELD_TYPE_MATTERS
5203                   if (PCC_BITFIELD_TYPE_MATTERS)
5204                     {
5205                       DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5206                                             TYPE_ALIGN (TREE_TYPE (x)));
5207                       DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5208                     }
5209 #endif
5210                 }
5211             }
5212         }
5213
5214       else if (TREE_TYPE (x) != error_mark_node)
5215         {
5216           unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5217                                     : TYPE_ALIGN (TREE_TYPE (x)));
5218
5219           /* Non-bit-fields are aligned for their type, except packed
5220              fields which require only BITS_PER_UNIT alignment.  */
5221           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5222           if (! DECL_PACKED (x))
5223             DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5224         }
5225
5226       DECL_INITIAL (x) = 0;
5227
5228       /* Detect flexible array member in an invalid context.  */
5229       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5230           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5231           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5232           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5233         {
5234           if (TREE_CODE (t) == UNION_TYPE)
5235             error_with_decl (x, "flexible array member in union");
5236           else if (TREE_CHAIN (x) != NULL_TREE)
5237             error_with_decl (x, "flexible array member not at end of struct");
5238           else if (! saw_named_field)
5239             error_with_decl (x, "flexible array member in otherwise empty struct");
5240         }
5241
5242       if (pedantic && TREE_CODE (t) == RECORD_TYPE
5243           && flexible_array_type_p (TREE_TYPE (x)))
5244         pedwarn_with_decl (x, "invalid use of structure with flexible array member");
5245
5246       if (DECL_NAME (x))
5247         saw_named_field = 1;
5248     }
5249
5250   /* Delete all duplicate fields from the fieldlist */
5251   for (x = fieldlist; x && TREE_CHAIN (x);)
5252     /* Anonymous fields aren't duplicates.  */
5253     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5254       x = TREE_CHAIN (x);
5255     else
5256       {
5257         tree y = fieldlist;
5258
5259         while (1)
5260           {
5261             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5262               break;
5263             if (y == x)
5264               break;
5265             y = TREE_CHAIN (y);
5266           }
5267         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5268           {
5269             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5270             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5271           }
5272         else
5273           x = TREE_CHAIN (x);
5274       }
5275
5276   /* Now we have the nearly final fieldlist.  Record it,
5277      then lay out the structure or union (including the fields).  */
5278
5279   TYPE_FIELDS (t) = fieldlist;
5280
5281   layout_type (t);
5282
5283   /* Delete all zero-width bit-fields from the fieldlist */
5284   {
5285     tree *fieldlistp = &fieldlist;
5286     while (*fieldlistp)
5287       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5288         *fieldlistp = TREE_CHAIN (*fieldlistp);
5289       else
5290         fieldlistp = &TREE_CHAIN (*fieldlistp);
5291   }
5292
5293   /* Now we have the truly final field list.
5294      Store it in this type and in the variants.  */
5295
5296   TYPE_FIELDS (t) = fieldlist;
5297
5298   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5299     {
5300       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5301       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5302       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5303       TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5304     }
5305
5306   /* If this was supposed to be a transparent union, but we can't
5307      make it one, warn and turn off the flag.  */
5308   if (TREE_CODE (t) == UNION_TYPE
5309       && TYPE_TRANSPARENT_UNION (t)
5310       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5311     {
5312       TYPE_TRANSPARENT_UNION (t) = 0;
5313       warning ("union cannot be made transparent");
5314     }
5315
5316   /* If this structure or union completes the type of any previous
5317      variable declaration, lay it out and output its rtl.  */
5318
5319   if (current_binding_level->incomplete_list != NULL_TREE)
5320     {
5321       tree prev = NULL_TREE;
5322
5323       for (x = current_binding_level->incomplete_list; x; x = TREE_CHAIN (x))
5324         {
5325           tree decl = TREE_VALUE (x);
5326
5327           if (TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TYPE_MAIN_VARIANT (t)
5328               && TREE_CODE (decl) != TYPE_DECL)
5329             {
5330               layout_decl (decl, 0);
5331               /* This is a no-op in c-lang.c or something real in objc-act.c.  */
5332               if (flag_objc)
5333                 objc_check_decl (decl);
5334               rest_of_decl_compilation (decl, NULL, toplevel, 0);
5335               if (! toplevel)
5336                 expand_decl (decl);
5337               /* Unlink X from the incomplete list.  */
5338               if (prev)
5339                 TREE_CHAIN (prev) = TREE_CHAIN (x);
5340               else
5341                 current_binding_level->incomplete_list = TREE_CHAIN (x);
5342             }
5343           else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5344                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5345             {
5346               tree element = TREE_TYPE (decl);
5347               while (TREE_CODE (element) == ARRAY_TYPE)
5348                 element = TREE_TYPE (element);
5349               if (element == t)
5350                 {
5351                   layout_array_type (TREE_TYPE (decl));
5352                   if (TREE_CODE (decl) != TYPE_DECL)
5353                     {
5354                       layout_decl (decl, 0);
5355                       if (flag_objc)
5356                         objc_check_decl (decl);
5357                       rest_of_decl_compilation (decl, NULL, toplevel, 0);
5358                       if (! toplevel)
5359                         expand_decl (decl);
5360                     }
5361                   /* Unlink X from the incomplete list.  */
5362                   if (prev)
5363                     TREE_CHAIN (prev) = TREE_CHAIN (x);
5364                   else
5365                     current_binding_level->incomplete_list = TREE_CHAIN (x);
5366                 }
5367             }
5368         }
5369     }
5370
5371   /* Finish debugging output for this type.  */
5372   rest_of_type_compilation (t, toplevel);
5373
5374   return t;
5375 }
5376
5377 /* Lay out the type T, and its element type, and so on.  */
5378
5379 static void
5380 layout_array_type (t)
5381      tree t;
5382 {
5383   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5384     layout_array_type (TREE_TYPE (t));
5385   layout_type (t);
5386 }
5387 \f
5388 /* Begin compiling the definition of an enumeration type.
5389    NAME is its name (or null if anonymous).
5390    Returns the type object, as yet incomplete.
5391    Also records info about it so that build_enumerator
5392    may be used to declare the individual values as they are read.  */
5393
5394 tree
5395 start_enum (name)
5396      tree name;
5397 {
5398   tree enumtype = 0;
5399
5400   /* If this is the real definition for a previous forward reference,
5401      fill in the contents in the same object that used to be the
5402      forward reference.  */
5403
5404   if (name != 0)
5405     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5406
5407   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5408     {
5409       enumtype = make_node (ENUMERAL_TYPE);
5410       pushtag (name, enumtype);
5411     }
5412
5413   C_TYPE_BEING_DEFINED (enumtype) = 1;
5414
5415   if (TYPE_VALUES (enumtype) != 0)
5416     {
5417       /* This enum is a named one that has been declared already.  */
5418       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5419
5420       /* Completely replace its old definition.
5421          The old enumerators remain defined, however.  */
5422       TYPE_VALUES (enumtype) = 0;
5423     }
5424
5425   enum_next_value = integer_zero_node;
5426   enum_overflow = 0;
5427
5428   if (flag_short_enums)
5429     TYPE_PACKED (enumtype) = 1;
5430
5431   return enumtype;
5432 }
5433
5434 /* After processing and defining all the values of an enumeration type,
5435    install their decls in the enumeration type and finish it off.
5436    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5437    and ATTRIBUTES are the specified attributes.
5438    Returns ENUMTYPE.  */
5439
5440 tree
5441 finish_enum (enumtype, values, attributes)
5442      tree enumtype;
5443      tree values;
5444      tree attributes;
5445 {
5446   tree pair, tem;
5447   tree minnode = 0, maxnode = 0, enum_value_type;
5448   int precision, unsign;
5449   int toplevel = (global_binding_level == current_binding_level);
5450
5451   if (in_parm_level_p ())
5452     warning ("enum defined inside parms");
5453
5454   decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5455
5456   /* Calculate the maximum value of any enumerator in this type.  */
5457
5458   if (values == error_mark_node)
5459     minnode = maxnode = integer_zero_node;
5460   else
5461     {
5462       minnode = maxnode = TREE_VALUE (values);
5463       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5464         {
5465           tree value = TREE_VALUE (pair);
5466           if (tree_int_cst_lt (maxnode, value))
5467             maxnode = value;
5468           if (tree_int_cst_lt (value, minnode))
5469             minnode = value;
5470         }
5471     }
5472
5473   /* Construct the final type of this enumeration.  It is the same
5474      as one of the integral types - the narrowest one that fits, except
5475      that normally we only go as narrow as int - and signed iff any of
5476      the values are negative.  */
5477   unsign = (tree_int_cst_sgn (minnode) >= 0);
5478   precision = MAX (min_precision (minnode, unsign),
5479                    min_precision (maxnode, unsign));
5480   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5481     {
5482       tree narrowest = c_common_type_for_size (precision, unsign);
5483       if (narrowest == 0)
5484         {
5485           warning ("enumeration values exceed range of largest integer");
5486           narrowest = long_long_integer_type_node;
5487         }
5488
5489       precision = TYPE_PRECISION (narrowest);
5490     }
5491   else
5492     precision = TYPE_PRECISION (integer_type_node);
5493
5494   if (precision == TYPE_PRECISION (integer_type_node))
5495     enum_value_type = c_common_type_for_size (precision, 0);
5496   else
5497     enum_value_type = enumtype;
5498
5499   TYPE_MIN_VALUE (enumtype) = minnode;
5500   TYPE_MAX_VALUE (enumtype) = maxnode;
5501   TYPE_PRECISION (enumtype) = precision;
5502   TREE_UNSIGNED (enumtype) = unsign;
5503   TYPE_SIZE (enumtype) = 0;
5504   layout_type (enumtype);
5505
5506   if (values != error_mark_node)
5507     {
5508       /* Change the type of the enumerators to be the enum type.  We
5509          need to do this irrespective of the size of the enum, for
5510          proper type checking.  Replace the DECL_INITIALs of the
5511          enumerators, and the value slots of the list, with copies
5512          that have the enum type; they cannot be modified in place
5513          because they may be shared (e.g.  integer_zero_node) Finally,
5514          change the purpose slots to point to the names of the decls.  */
5515       for (pair = values; pair; pair = TREE_CHAIN (pair))
5516         {
5517           tree enu = TREE_PURPOSE (pair);
5518
5519           TREE_TYPE (enu) = enumtype;
5520           DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5521           DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5522           DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5523           DECL_USER_ALIGN (enu) = TYPE_USER_ALIGN (enumtype);
5524           DECL_MODE (enu) = TYPE_MODE (enumtype);
5525
5526           /* The ISO C Standard mandates enumerators to have type int,
5527              even though the underlying type of an enum type is
5528              unspecified.  Here we convert any enumerators that fit in
5529              an int to type int, to avoid promotions to unsigned types
5530              when comparing integers with enumerators that fit in the
5531              int range.  When -pedantic is given, build_enumerator()
5532              would have already taken care of those that don't fit.  */
5533           if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5534             DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5535           else
5536             DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5537
5538           TREE_PURPOSE (pair) = DECL_NAME (enu);
5539           TREE_VALUE (pair) = DECL_INITIAL (enu);
5540         }
5541
5542       TYPE_VALUES (enumtype) = values;
5543     }
5544
5545   /* Fix up all variant types of this enum type.  */
5546   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5547     {
5548       if (tem == enumtype)
5549         continue;
5550       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5551       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5552       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5553       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5554       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5555       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5556       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5557       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5558       TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5559       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5560     }
5561
5562   /* Finish debugging output for this type.  */
5563   rest_of_type_compilation (enumtype, toplevel);
5564
5565   return enumtype;
5566 }
5567
5568 /* Build and install a CONST_DECL for one value of the
5569    current enumeration type (one that was begun with start_enum).
5570    Return a tree-list containing the CONST_DECL and its value.
5571    Assignment of sequential values by default is handled here.  */
5572
5573 tree
5574 build_enumerator (name, value)
5575      tree name, value;
5576 {
5577   tree decl, type;
5578
5579   /* Validate and default VALUE.  */
5580
5581   /* Remove no-op casts from the value.  */
5582   if (value)
5583     STRIP_TYPE_NOPS (value);
5584
5585   if (value != 0)
5586     {
5587       if (TREE_CODE (value) == INTEGER_CST)
5588         {
5589           value = default_conversion (value);
5590           constant_expression_warning (value);
5591         }
5592       else
5593         {
5594           error ("enumerator value for `%s' not integer constant",
5595                  IDENTIFIER_POINTER (name));
5596           value = 0;
5597         }
5598     }
5599
5600   /* Default based on previous value.  */
5601   /* It should no longer be possible to have NON_LVALUE_EXPR
5602      in the default.  */
5603   if (value == 0)
5604     {
5605       value = enum_next_value;
5606       if (enum_overflow)
5607         error ("overflow in enumeration values");
5608     }
5609
5610   if (pedantic && ! int_fits_type_p (value, integer_type_node))
5611     {
5612       pedwarn ("ISO C restricts enumerator values to range of `int'");
5613       value = convert (integer_type_node, value);
5614     }
5615
5616   /* Set basis for default for next value.  */
5617   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5618   enum_overflow = tree_int_cst_lt (enum_next_value, value);
5619
5620   /* Now create a declaration for the enum value name.  */
5621
5622   type = TREE_TYPE (value);
5623   type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5624                                       TYPE_PRECISION (integer_type_node)),
5625                                  (TYPE_PRECISION (type)
5626                                   >= TYPE_PRECISION (integer_type_node)
5627                                   && TREE_UNSIGNED (type)));
5628
5629   decl = build_decl (CONST_DECL, name, type);
5630   DECL_INITIAL (decl) = convert (type, value);
5631   pushdecl (decl);
5632
5633   return tree_cons (decl, value, NULL_TREE);
5634 }
5635
5636 \f
5637 /* Create the FUNCTION_DECL for a function definition.
5638    DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5639    the declaration; they describe the function's name and the type it returns,
5640    but twisted together in a fashion that parallels the syntax of C.
5641
5642    This function creates a binding context for the function body
5643    as well as setting up the FUNCTION_DECL in current_function_decl.
5644
5645    Returns 1 on success.  If the DECLARATOR is not suitable for a function
5646    (it defines a datum instead), we return 0, which tells
5647    yyparse to report a parse error.  */
5648
5649 int
5650 start_function (declspecs, declarator, attributes)
5651      tree declarator, declspecs, attributes;
5652 {
5653   tree decl1, old_decl;
5654   tree restype;
5655   int old_immediate_size_expand = immediate_size_expand;
5656
5657   current_function_returns_value = 0;  /* Assume, until we see it does.  */
5658   current_function_returns_null = 0;
5659   current_function_returns_abnormally = 0;
5660   warn_about_return_type = 0;
5661   current_extern_inline = 0;
5662   named_labels = 0;
5663   shadowed_labels = 0;
5664
5665   /* Don't expand any sizes in the return type of the function.  */
5666   immediate_size_expand = 0;
5667
5668   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5669
5670   /* If the declarator is not suitable for a function definition,
5671      cause a syntax error.  */
5672   if (decl1 == 0)
5673     {
5674       immediate_size_expand = old_immediate_size_expand;
5675       return 0;
5676     }
5677
5678   decl_attributes (&decl1, attributes, 0);
5679
5680   /* If #pragma weak was used, mark the decl weak now.  */
5681   if (current_binding_level == global_binding_level)
5682     maybe_apply_pragma_weak (decl1);
5683
5684   if (DECL_DECLARED_INLINE_P (decl1)
5685       && DECL_UNINLINABLE (decl1)
5686       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
5687     warning_with_decl (decl1,
5688                        "inline function `%s' given attribute noinline");
5689
5690   announce_function (decl1);
5691
5692   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
5693     {
5694       error ("return type is an incomplete type");
5695       /* Make it return void instead.  */
5696       TREE_TYPE (decl1)
5697         = build_function_type (void_type_node,
5698                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5699     }
5700
5701   if (warn_about_return_type)
5702     pedwarn_c99 ("return type defaults to `int'");
5703
5704   /* Save the parm names or decls from this function's declarator
5705      where store_parm_decls will find them.  */
5706   current_function_parms = last_function_parms;
5707   current_function_parm_tags = last_function_parm_tags;
5708
5709   /* Make the init_value nonzero so pushdecl knows this is not tentative.
5710      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
5711   DECL_INITIAL (decl1) = error_mark_node;
5712
5713   /* If this definition isn't a prototype and we had a prototype declaration
5714      before, copy the arg type info from that prototype.
5715      But not if what we had before was a builtin function.  */
5716   old_decl = lookup_name_current_level (DECL_NAME (decl1));
5717   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5718       && !DECL_BUILT_IN (old_decl)
5719       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5720           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5721       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5722     {
5723       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5724       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
5725       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
5726     }
5727
5728   /* If there is no explicit declaration, look for any out-of-scope implicit
5729      declarations.  */
5730   if (old_decl == 0)
5731     old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
5732
5733   /* Optionally warn of old-fashioned def with no previous prototype.  */
5734   if (warn_strict_prototypes
5735       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5736       && !(old_decl != 0
5737            && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
5738                || (DECL_BUILT_IN (old_decl)
5739                    && ! C_DECL_ANTICIPATED (old_decl)))))
5740     warning ("function declaration isn't a prototype");
5741   /* Optionally warn of any global def with no previous prototype.  */
5742   else if (warn_missing_prototypes
5743            && TREE_PUBLIC (decl1)
5744            && !(old_decl != 0
5745                 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
5746                     || (DECL_BUILT_IN (old_decl)
5747                         && ! C_DECL_ANTICIPATED (old_decl))))
5748            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5749     warning_with_decl (decl1, "no previous prototype for `%s'");
5750   /* Optionally warn of any def with no previous prototype
5751      if the function has already been used.  */
5752   else if (warn_missing_prototypes
5753            && old_decl != 0 && TREE_USED (old_decl)
5754            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
5755     warning_with_decl (decl1,
5756                        "`%s' was used with no prototype before its definition");
5757   /* Optionally warn of any global def with no previous declaration.  */
5758   else if (warn_missing_declarations
5759            && TREE_PUBLIC (decl1)
5760            && old_decl == 0
5761            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5762     warning_with_decl (decl1, "no previous declaration for `%s'");
5763   /* Optionally warn of any def with no previous declaration
5764      if the function has already been used.  */
5765   else if (warn_missing_declarations
5766            && old_decl != 0 && TREE_USED (old_decl)
5767            && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
5768     warning_with_decl (decl1,
5769                        "`%s' was used with no declaration before its definition");
5770
5771   /* This is a definition, not a reference.
5772      So normally clear DECL_EXTERNAL.
5773      However, `extern inline' acts like a declaration
5774      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
5775   DECL_EXTERNAL (decl1) = current_extern_inline;
5776
5777   /* This function exists in static storage.
5778      (This does not mean `static' in the C sense!)  */
5779   TREE_STATIC (decl1) = 1;
5780
5781   /* A nested function is not global.  */
5782   if (current_function_decl != 0)
5783     TREE_PUBLIC (decl1) = 0;
5784
5785   /* Warn for unlikely, improbable, or stupid declarations of `main'.  */
5786   if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
5787     {
5788       tree args;
5789       int argct = 0;
5790
5791       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5792           != integer_type_node)
5793         pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
5794
5795       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
5796            args = TREE_CHAIN (args))
5797         {
5798           tree type = args ? TREE_VALUE (args) : 0;
5799
5800           if (type == void_type_node)
5801             break;
5802
5803           ++argct;
5804           switch (argct)
5805             {
5806             case 1:
5807               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
5808                 pedwarn_with_decl (decl1,
5809                                    "first argument of `%s' should be `int'");
5810               break;
5811
5812             case 2:
5813               if (TREE_CODE (type) != POINTER_TYPE
5814                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5815                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5816                       != char_type_node))
5817                 pedwarn_with_decl (decl1,
5818                                    "second argument of `%s' should be `char **'");
5819               break;
5820
5821             case 3:
5822               if (TREE_CODE (type) != POINTER_TYPE
5823                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5824                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5825                       != char_type_node))
5826                 pedwarn_with_decl (decl1,
5827                                    "third argument of `%s' should probably be `char **'");
5828               break;
5829             }
5830         }
5831
5832       /* It is intentional that this message does not mention the third
5833          argument because it's only mentioned in an appendix of the
5834          standard.  */
5835       if (argct > 0 && (argct < 2 || argct > 3))
5836         pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
5837
5838       if (! TREE_PUBLIC (decl1))
5839         pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
5840     }
5841
5842   /* Record the decl so that the function name is defined.
5843      If we already have a decl for this name, and it is a FUNCTION_DECL,
5844      use the old decl.  */
5845
5846   current_function_decl = pushdecl (decl1);
5847
5848   pushlevel (0);
5849   declare_parm_level (1);
5850   current_binding_level->subblocks_tag_transparent = 1;
5851
5852   make_decl_rtl (current_function_decl, NULL);
5853
5854   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
5855   /* Promote the value to int before returning it.  */
5856   if (c_promoting_integer_type_p (restype))
5857     {
5858       /* It retains unsignedness if not really getting wider.  */
5859       if (TREE_UNSIGNED (restype)
5860           && (TYPE_PRECISION (restype)
5861                   == TYPE_PRECISION (integer_type_node)))
5862         restype = unsigned_type_node;
5863       else
5864         restype = integer_type_node;
5865     }
5866   DECL_RESULT (current_function_decl)
5867     = build_decl (RESULT_DECL, NULL_TREE, restype);
5868
5869   /* If this fcn was already referenced via a block-scope `extern' decl
5870      (or an implicit decl), propagate certain information about the usage.  */
5871   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
5872     TREE_ADDRESSABLE (current_function_decl) = 1;
5873
5874   immediate_size_expand = old_immediate_size_expand;
5875
5876   start_fname_decls ();
5877
5878   return 1;
5879 }
5880 \f
5881 /* Store the parameter declarations into the current function declaration.
5882    This is called after parsing the parameter declarations, before
5883    digesting the body of the function.
5884
5885    For an old-style definition, modify the function's type
5886    to specify at least the number of arguments.  */
5887
5888 void
5889 store_parm_decls ()
5890 {
5891   tree fndecl = current_function_decl;
5892   tree parm;
5893
5894   /* This is either a chain of PARM_DECLs (if a prototype was used)
5895      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
5896   tree specparms = current_function_parms;
5897
5898   /* This is a list of types declared among parms in a prototype.  */
5899   tree parmtags = current_function_parm_tags;
5900
5901   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
5902   tree parmdecls = getdecls ();
5903
5904   /* This is a chain of any other decls that came in among the parm
5905      declarations.  If a parm is declared with  enum {foo, bar} x;
5906      then CONST_DECLs for foo and bar are put here.  */
5907   tree nonparms = 0;
5908
5909   /* The function containing FNDECL, if any.  */
5910   tree context = decl_function_context (fndecl);
5911
5912   /* Nonzero if this definition is written with a prototype.  */
5913   int prototype = 0;
5914
5915   int saved_warn_shadow = warn_shadow;
5916
5917   /* Don't re-emit shadow warnings.  */
5918   warn_shadow = 0;
5919
5920   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
5921     {
5922       /* This case is when the function was defined with an ANSI prototype.
5923          The parms already have decls, so we need not do anything here
5924          except record them as in effect
5925          and complain if any redundant old-style parm decls were written.  */
5926
5927       tree next;
5928       tree others = 0;
5929
5930       prototype = 1;
5931
5932       if (parmdecls != 0)
5933         {
5934           tree decl, link;
5935
5936           error_with_decl (fndecl,
5937                            "parm types given both in parmlist and separately");
5938           /* Get rid of the erroneous decls; don't keep them on
5939              the list of parms, since they might not be PARM_DECLs.  */
5940           for (decl = current_binding_level->names;
5941                decl; decl = TREE_CHAIN (decl))
5942             if (DECL_NAME (decl))
5943               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
5944           for (link = current_binding_level->shadowed;
5945                link; link = TREE_CHAIN (link))
5946             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
5947           current_binding_level->names = 0;
5948           current_binding_level->shadowed = 0;
5949         }
5950
5951       specparms = nreverse (specparms);
5952       for (parm = specparms; parm; parm = next)
5953         {
5954           next = TREE_CHAIN (parm);
5955           if (TREE_CODE (parm) == PARM_DECL)
5956             {
5957               if (DECL_NAME (parm) == 0)
5958                 error_with_decl (parm, "parameter name omitted");
5959               else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
5960                        && VOID_TYPE_P (TREE_TYPE (parm)))
5961                 {
5962                   error_with_decl (parm, "parameter `%s' declared void");
5963                   /* Change the type to error_mark_node so this parameter
5964                      will be ignored by assign_parms.  */
5965                   TREE_TYPE (parm) = error_mark_node;
5966                 }
5967               pushdecl (parm);
5968             }
5969           else
5970             {
5971               /* If we find an enum constant or a type tag,
5972                  put it aside for the moment.  */
5973               TREE_CHAIN (parm) = 0;
5974               others = chainon (others, parm);
5975             }
5976         }
5977
5978       /* Get the decls in their original chain order
5979          and record in the function.  */
5980       DECL_ARGUMENTS (fndecl) = getdecls ();
5981
5982 #if 0
5983       /* If this function takes a variable number of arguments,
5984          add a phony parameter to the end of the parm list,
5985          to represent the position of the first unnamed argument.  */
5986       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
5987           != void_type_node)
5988         {
5989           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
5990           /* Let's hope the address of the unnamed parm
5991              won't depend on its type.  */
5992           TREE_TYPE (dummy) = integer_type_node;
5993           DECL_ARG_TYPE (dummy) = integer_type_node;
5994           DECL_ARGUMENTS (fndecl) = chainon (DECL_ARGUMENTS (fndecl), dummy);
5995         }
5996 #endif
5997
5998       /* Now pushdecl the enum constants.  */
5999       for (parm = others; parm; parm = next)
6000         {
6001           next = TREE_CHAIN (parm);
6002           if (DECL_NAME (parm) == 0)
6003             ;
6004           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6005             ;
6006           else if (TREE_CODE (parm) != PARM_DECL)
6007             pushdecl (parm);
6008         }
6009
6010       storetags (chainon (parmtags, gettags ()));
6011     }
6012   else
6013     {
6014       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6015          each with a parm name as the TREE_VALUE.
6016
6017          PARMDECLS is a chain of declarations for parameters.
6018          Warning! It can also contain CONST_DECLs which are not parameters
6019          but are names of enumerators of any enum types
6020          declared among the parameters.
6021
6022          First match each formal parameter name with its declaration.
6023          Associate decls with the names and store the decls
6024          into the TREE_PURPOSE slots.  */
6025
6026       /* We use DECL_WEAK as a flag to show which parameters have been
6027          seen already since it is not used on PARM_DECL or CONST_DECL.  */
6028       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6029         DECL_WEAK (parm) = 0;
6030
6031       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6032         {
6033           tree tail, found = NULL;
6034
6035           if (TREE_VALUE (parm) == 0)
6036             {
6037               error_with_decl (fndecl,
6038                                "parameter name missing from parameter list");
6039               TREE_PURPOSE (parm) = 0;
6040               continue;
6041             }
6042
6043           /* See if any of the parmdecls specifies this parm by name.
6044              Ignore any enumerator decls.  */
6045           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6046             if (DECL_NAME (tail) == TREE_VALUE (parm)
6047                 && TREE_CODE (tail) == PARM_DECL)
6048               {
6049                 found = tail;
6050                 break;
6051               }
6052
6053           /* If declaration already marked, we have a duplicate name.
6054              Complain, and don't use this decl twice.  */
6055           if (found && DECL_WEAK (found))
6056             {
6057               error_with_decl (found, "multiple parameters named `%s'");
6058               found = 0;
6059             }
6060
6061           /* If the declaration says "void", complain and ignore it.  */
6062           if (found && VOID_TYPE_P (TREE_TYPE (found)))
6063             {
6064               error_with_decl (found, "parameter `%s' declared void");
6065               TREE_TYPE (found) = integer_type_node;
6066               DECL_ARG_TYPE (found) = integer_type_node;
6067               layout_decl (found, 0);
6068             }
6069
6070           /* If no declaration found, default to int.  */
6071           if (!found)
6072             {
6073               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6074                                   integer_type_node);
6075               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6076               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6077               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6078               if (flag_isoc99)
6079                 pedwarn_with_decl (found, "type of `%s' defaults to `int'");
6080               else if (extra_warnings)
6081                 warning_with_decl (found, "type of `%s' defaults to `int'");
6082               pushdecl (found);
6083             }
6084
6085           TREE_PURPOSE (parm) = found;
6086
6087           /* Mark this decl as "already found".  */
6088           DECL_WEAK (found) = 1;
6089         }
6090
6091       /* Put anything which is on the parmdecls chain and which is
6092          not a PARM_DECL onto the list NONPARMS.  (The types of
6093          non-parm things which might appear on the list include
6094          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6095          any actual PARM_DECLs not matched with any names.  */
6096
6097       nonparms = 0;
6098       for (parm = parmdecls; parm;)
6099         {
6100           tree next = TREE_CHAIN (parm);
6101           TREE_CHAIN (parm) = 0;
6102
6103           if (TREE_CODE (parm) != PARM_DECL)
6104             nonparms = chainon (nonparms, parm);
6105           else
6106             {
6107               /* Complain about args with incomplete types.  */
6108               if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6109                 {
6110                   error_with_decl (parm, "parameter `%s' has incomplete type");
6111                   TREE_TYPE (parm) = error_mark_node;
6112                 }
6113
6114               if (! DECL_WEAK (parm))
6115                 {
6116                   error_with_decl (parm,
6117                                    "declaration for parameter `%s' but no such parameter");
6118                   /* Pretend the parameter was not missing.
6119                      This gets us to a standard state and minimizes
6120                      further error messages.  */
6121                   specparms
6122                     = chainon (specparms,
6123                                tree_cons (parm, NULL_TREE, NULL_TREE));
6124                 }
6125             }
6126
6127           parm = next;
6128         }
6129
6130       /* Chain the declarations together in the order of the list of
6131          names.  Store that chain in the function decl, replacing the
6132          list of names.  */
6133       parm = specparms;
6134       DECL_ARGUMENTS (fndecl) = 0;
6135       {
6136         tree last;
6137         for (last = 0; parm; parm = TREE_CHAIN (parm))
6138           if (TREE_PURPOSE (parm))
6139             {
6140               if (last == 0)
6141                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6142               else
6143                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6144               last = TREE_PURPOSE (parm);
6145               TREE_CHAIN (last) = 0;
6146             }
6147       }
6148
6149       /* If there was a previous prototype,
6150          set the DECL_ARG_TYPE of each argument according to
6151          the type previously specified, and report any mismatches.  */
6152
6153       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6154         {
6155           tree type;
6156           for (parm = DECL_ARGUMENTS (fndecl),
6157                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6158                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6159                                  != void_type_node));
6160                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6161             {
6162               if (parm == 0 || type == 0
6163                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6164                 {
6165                   error ("number of arguments doesn't match prototype");
6166                   error_with_file_and_line (current_function_prototype_file,
6167                                             current_function_prototype_line,
6168                                             "prototype declaration");
6169                   break;
6170                 }
6171               /* Type for passing arg must be consistent with that
6172                  declared for the arg.  ISO C says we take the unqualified
6173                  type for parameters declared with qualified type.  */
6174               if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6175                                TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6176                 {
6177                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6178                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6179                     {
6180                       /* Adjust argument to match prototype.  E.g. a previous
6181                          `int foo(float);' prototype causes
6182                          `int foo(x) float x; {...}' to be treated like
6183                          `int foo(float x) {...}'.  This is particularly
6184                          useful for argument types like uid_t.  */
6185                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6186
6187                       if (PROMOTE_PROTOTYPES
6188                           && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6189                           && TYPE_PRECISION (TREE_TYPE (parm))
6190                           < TYPE_PRECISION (integer_type_node))
6191                         DECL_ARG_TYPE (parm) = integer_type_node;
6192
6193                       if (pedantic)
6194                         {
6195                           pedwarn ("promoted argument `%s' doesn't match prototype",
6196                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6197                           warning_with_file_and_line
6198                             (current_function_prototype_file,
6199                              current_function_prototype_line,
6200                              "prototype declaration");
6201                         }
6202                     }
6203                   else
6204                     {
6205                       error ("argument `%s' doesn't match prototype",
6206                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6207                       error_with_file_and_line (current_function_prototype_file,
6208                                                 current_function_prototype_line,
6209                                                 "prototype declaration");
6210                     }
6211                 }
6212             }
6213           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6214         }
6215
6216       /* Otherwise, create a prototype that would match.  */
6217
6218       else
6219         {
6220           tree actual = 0, last = 0, type;
6221
6222           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6223             {
6224               type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6225               if (last)
6226                 TREE_CHAIN (last) = type;
6227               else
6228                 actual = type;
6229               last = type;
6230             }
6231           type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6232           if (last)
6233             TREE_CHAIN (last) = type;
6234           else
6235             actual = type;
6236
6237           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6238              of the type of this function, but we need to avoid having this
6239              affect the types of other similarly-typed functions, so we must
6240              first force the generation of an identical (but separate) type
6241              node for the relevant function type.  The new node we create
6242              will be a variant of the main variant of the original function
6243              type.  */
6244
6245           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6246
6247           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6248         }
6249
6250       /* Now store the final chain of decls for the arguments
6251          as the decl-chain of the current lexical scope.
6252          Put the enumerators in as well, at the front so that
6253          DECL_ARGUMENTS is not modified.  */
6254
6255       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6256     }
6257
6258   /* Make sure the binding level for the top of the function body
6259      gets a BLOCK if there are any in the function.
6260      Otherwise, the dbx output is wrong.  */
6261
6262   keep_next_if_subblocks = 1;
6263
6264   /* ??? This might be an improvement,
6265      but needs to be thought about some more.  */
6266 #if 0
6267   keep_next_level_flag = 1;
6268 #endif
6269
6270   /* Write a record describing this function definition to the prototypes
6271      file (if requested).  */
6272
6273   gen_aux_info_record (fndecl, 1, 0, prototype);
6274
6275   /* Initialize the RTL code for the function.  */
6276   init_function_start (fndecl, input_filename, lineno);
6277
6278   /* Begin the statement tree for this function.  */
6279   begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6280
6281   /* If this is a nested function, save away the sizes of any
6282      variable-size types so that we can expand them when generating
6283      RTL.  */
6284   if (context)
6285     {
6286       tree t;
6287
6288       DECL_LANG_SPECIFIC (fndecl)->pending_sizes
6289         = nreverse (get_pending_sizes ());
6290       for (t = DECL_LANG_SPECIFIC (fndecl)->pending_sizes;
6291            t;
6292            t = TREE_CHAIN (t))
6293         SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = context;
6294     }
6295
6296   /* This function is being processed in whole-function mode.  */
6297   cfun->x_whole_function_mode_p = 1;
6298
6299   /* Even though we're inside a function body, we still don't want to
6300      call expand_expr to calculate the size of a variable-sized array.
6301      We haven't necessarily assigned RTL to all variables yet, so it's
6302      not safe to try to expand expressions involving them.  */
6303   immediate_size_expand = 0;
6304   cfun->x_dont_save_pending_sizes_p = 1;
6305
6306   warn_shadow = saved_warn_shadow;
6307 }
6308 \f
6309 /* Finish up a function declaration and compile that function
6310    all the way to assembler language output.  The free the storage
6311    for the function definition.
6312
6313    This is called after parsing the body of the function definition.
6314
6315    NESTED is nonzero if the function being finished is nested in another.
6316    CAN_DEFER_P is nonzero if the function may be deferred.  */
6317
6318 void
6319 finish_function (nested, can_defer_p)
6320      int nested;
6321      int can_defer_p;
6322 {
6323   tree fndecl = current_function_decl;
6324
6325 #if 0
6326   /* This caused &foo to be of type ptr-to-const-function which then
6327      got a warning when stored in a ptr-to-function variable.  */
6328   TREE_READONLY (fndecl) = 1;
6329 #endif
6330
6331   poplevel (1, 0, 1);
6332   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6333
6334   /* Must mark the RESULT_DECL as being in this function.  */
6335
6336   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6337
6338   if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6339     {
6340       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6341           != integer_type_node)
6342         {
6343           /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6344              If warn_main is -1 (-Wno-main) we don't want to be warned.  */
6345           if (! warn_main)
6346             pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6347         }
6348       else
6349         {
6350 #ifdef DEFAULT_MAIN_RETURN
6351           /* Make it so that `main' always returns success by default.  */
6352           DEFAULT_MAIN_RETURN;
6353 #else
6354           if (flag_isoc99)
6355             c_expand_return (integer_zero_node);
6356 #endif
6357         }
6358     }
6359
6360   finish_fname_decls ();
6361
6362   /* Tie off the statement tree for this function.  */
6363   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6364
6365   /* Complain if there's just no return statement.  */
6366   if (warn_return_type
6367       && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6368       && !current_function_returns_value && !current_function_returns_null
6369       /* Don't complain if we abort.  */
6370       && !current_function_returns_abnormally
6371       /* Don't warn for main().  */
6372       && !MAIN_NAME_P (DECL_NAME (fndecl))
6373       /* Or if they didn't actually specify a return type.  */
6374       && !C_FUNCTION_IMPLICIT_INT (fndecl)
6375       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
6376          inline function, as we might never be compiled separately.  */
6377       && DECL_INLINE (fndecl))
6378     warning ("no return statement in function returning non-void");
6379
6380   /* Clear out memory we no longer need.  */
6381   free_after_parsing (cfun);
6382   /* Since we never call rest_of_compilation, we never clear
6383      CFUN.  Do so explicitly.  */
6384   free_after_compilation (cfun);
6385   cfun = NULL;
6386
6387   if (! nested)
6388     {
6389       /* Generate RTL for the body of this function.  */
6390       c_expand_body (fndecl, nested, can_defer_p);
6391
6392       /* Let the error reporting routines know that we're outside a
6393          function.  For a nested function, this value is used in
6394          c_pop_function_context and then reset via pop_function_context.  */
6395       current_function_decl = NULL;
6396     }
6397 }
6398
6399 /* Generate the RTL for a deferred function FNDECL.  */
6400
6401 void
6402 c_expand_deferred_function (fndecl)
6403      tree fndecl;
6404 {
6405   /* DECL_INLINE or DECL_RESULT might got cleared after the inline
6406      function was deferred, e.g. in duplicate_decls.  */
6407   if (DECL_INLINE (fndecl) && DECL_RESULT (fndecl))
6408     {
6409       c_expand_body (fndecl, 0, 0);
6410       current_function_decl = NULL;
6411     }
6412 }
6413
6414 /* Generate the RTL for the body of FNDECL.  If NESTED_P is nonzero,
6415    then we are already in the process of generating RTL for another
6416    function.  If can_defer_p is zero, we won't attempt to defer the
6417    generation of RTL.  */
6418
6419 static void
6420 c_expand_body (fndecl, nested_p, can_defer_p)
6421      tree fndecl;
6422      int nested_p, can_defer_p;
6423 {
6424   int uninlinable = 1;
6425
6426   /* There's no reason to do any of the work here if we're only doing
6427      semantic analysis; this code just generates RTL.  */
6428   if (flag_syntax_only)
6429     return;
6430
6431   if (flag_inline_trees)
6432     {
6433       /* First, cache whether the current function is inlinable.  Some
6434          predicates depend on cfun and current_function_decl to
6435          function completely.  */
6436       timevar_push (TV_INTEGRATION);
6437       uninlinable = ! tree_inlinable_function_p (fndecl);
6438
6439       if (! uninlinable && can_defer_p
6440           /* Save function tree for inlining.  Should return 0 if the
6441              language does not support function deferring or the
6442              function could not be deferred.  */
6443           && defer_fn (fndecl))
6444         {
6445           /* Let the back-end know that this function exists.  */
6446           (*debug_hooks->deferred_inline_function) (fndecl);
6447           timevar_pop (TV_INTEGRATION);
6448           return;
6449         }
6450
6451       /* Then, inline any functions called in it.  */
6452       optimize_inline_calls (fndecl);
6453       timevar_pop (TV_INTEGRATION);
6454     }
6455
6456   timevar_push (TV_EXPAND);
6457
6458   if (nested_p)
6459     {
6460       /* Make sure that we will evaluate variable-sized types involved
6461          in our function's type.  */
6462       expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl)->pending_sizes);
6463       /* Squirrel away our current state.  */
6464       push_function_context ();
6465     }
6466
6467   /* Initialize the RTL code for the function.  */
6468   current_function_decl = fndecl;
6469   input_filename = DECL_SOURCE_FILE (fndecl);
6470   init_function_start (fndecl, input_filename, DECL_SOURCE_LINE (fndecl));
6471
6472   /* This function is being processed in whole-function mode.  */
6473   cfun->x_whole_function_mode_p = 1;
6474
6475   /* Even though we're inside a function body, we still don't want to
6476      call expand_expr to calculate the size of a variable-sized array.
6477      We haven't necessarily assigned RTL to all variables yet, so it's
6478      not safe to try to expand expressions involving them.  */
6479   immediate_size_expand = 0;
6480   cfun->x_dont_save_pending_sizes_p = 1;
6481
6482   /* Set up parameters and prepare for return, for the function.  */
6483   expand_function_start (fndecl, 0);
6484
6485   /* If this function is `main', emit a call to `__main'
6486      to run global initializers, etc.  */
6487   if (DECL_NAME (fndecl)
6488       && MAIN_NAME_P (DECL_NAME (fndecl))
6489       && DECL_CONTEXT (fndecl) == NULL_TREE)
6490     expand_main_function ();
6491
6492   /* Generate the RTL for this function.  */
6493   expand_stmt (DECL_SAVED_TREE (fndecl));
6494   if (uninlinable)
6495     {
6496       /* Allow the body of the function to be garbage collected.  */
6497       DECL_SAVED_TREE (fndecl) = NULL_TREE;
6498     }
6499
6500   /* We hard-wired immediate_size_expand to zero above.
6501      expand_function_end will decrement this variable.  So, we set the
6502      variable to one here, so that after the decrement it will remain
6503      zero.  */
6504   immediate_size_expand = 1;
6505
6506   /* Allow language dialects to perform special processing.  */
6507   if (lang_expand_function_end)
6508     (*lang_expand_function_end) ();
6509
6510   /* Generate rtl for function exit.  */
6511   expand_function_end (input_filename, lineno, 0);
6512
6513   /* If this is a nested function, protect the local variables in the stack
6514      above us from being collected while we're compiling this function.  */
6515   if (nested_p)
6516     ggc_push_context ();
6517
6518   /* Run the optimizers and output the assembler code for this function.  */
6519   rest_of_compilation (fndecl);
6520
6521   /* Undo the GC context switch.  */
6522   if (nested_p)
6523     ggc_pop_context ();
6524
6525   /* With just -W, complain only if function returns both with
6526      and without a value.  */
6527   if (extra_warnings
6528       && current_function_returns_value
6529       && current_function_returns_null)
6530     warning ("this function may return with or without a value");
6531
6532   /* If requested, warn about function definitions where the function will
6533      return a value (usually of some struct or union type) which itself will
6534      take up a lot of stack space.  */
6535
6536   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6537     {
6538       tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6539
6540       if (ret_type && TYPE_SIZE_UNIT (ret_type)
6541           && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
6542           && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
6543                                    larger_than_size))
6544         {
6545           unsigned int size_as_int
6546             = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
6547
6548           if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
6549             warning_with_decl (fndecl,
6550                                "size of return value of `%s' is %u bytes",
6551                                size_as_int);
6552           else
6553             warning_with_decl (fndecl,
6554                                "size of return value of `%s' is larger than %d bytes",
6555                                larger_than_size);
6556         }
6557     }
6558
6559   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p
6560       && ! flag_inline_trees)
6561     {
6562       /* Stop pointing to the local nodes about to be freed.
6563          But DECL_INITIAL must remain nonzero so we know this
6564          was an actual function definition.
6565          For a nested function, this is done in c_pop_function_context.
6566          If rest_of_compilation set this to 0, leave it 0.  */
6567       if (DECL_INITIAL (fndecl) != 0)
6568         DECL_INITIAL (fndecl) = error_mark_node;
6569
6570       DECL_ARGUMENTS (fndecl) = 0;
6571     }
6572
6573   if (DECL_STATIC_CONSTRUCTOR (fndecl))
6574     {
6575       if (targetm.have_ctors_dtors)
6576         (* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
6577                                          DEFAULT_INIT_PRIORITY);
6578       else
6579         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6580     }
6581
6582   if (DECL_STATIC_DESTRUCTOR (fndecl))
6583     {
6584       if (targetm.have_ctors_dtors)
6585         (* targetm.asm_out.destructor) (XEXP (DECL_RTL (fndecl), 0),
6586                                         DEFAULT_INIT_PRIORITY);
6587       else
6588         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6589     }
6590
6591   if (nested_p)
6592     /* Return to the enclosing function.  */
6593     pop_function_context ();
6594   timevar_pop (TV_EXPAND);
6595 }
6596 \f
6597 /* Check the declarations given in a for-loop for satisfying the C99
6598    constraints.  */
6599 void
6600 check_for_loop_decls ()
6601 {
6602   tree t;
6603
6604   if (!flag_isoc99)
6605     {
6606       /* If we get here, declarations have been used in a for loop without
6607          the C99 for loop scope.  This doesn't make much sense, so don't
6608          allow it.  */
6609       error ("`for' loop initial declaration used outside C99 mode");
6610       return;
6611     }
6612   /* C99 subclause 6.8.5 paragraph 3:
6613
6614        [#3]  The  declaration  part  of  a for statement shall only
6615        declare identifiers for objects having storage class auto or
6616        register.
6617
6618      It isn't clear whether, in this sentence, "identifiers" binds to
6619      "shall only declare" or to "objects" - that is, whether all identifiers
6620      declared must be identifiers for objects, or whether the restriction
6621      only applies to those that are.  (A question on this in comp.std.c
6622      in November 2000 received no answer.)  We implement the strictest
6623      interpretation, to avoid creating an extension which later causes
6624      problems.  */
6625
6626   for (t = gettags (); t; t = TREE_CHAIN (t))
6627     {
6628       if (TREE_PURPOSE (t) != 0)
6629         {
6630           enum tree_code code = TREE_CODE (TREE_VALUE (t));
6631
6632           if (code == RECORD_TYPE)
6633             error ("`struct %s' declared in `for' loop initial declaration",
6634                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6635           else if (code == UNION_TYPE)
6636             error ("`union %s' declared in `for' loop initial declaration",
6637                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6638           else
6639             error ("`enum %s' declared in `for' loop initial declaration",
6640                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6641         }
6642     }
6643
6644   for (t = getdecls (); t; t = TREE_CHAIN (t))
6645     {
6646       if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
6647         error_with_decl (t, "declaration of non-variable `%s' in `for' loop initial declaration");
6648       else if (TREE_STATIC (t))
6649         error_with_decl (t, "declaration of static variable `%s' in `for' loop initial declaration");
6650       else if (DECL_EXTERNAL (t))
6651         error_with_decl (t, "declaration of `extern' variable `%s' in `for' loop initial declaration");
6652     }
6653 }
6654 \f
6655 /* Save and restore the variables in this file and elsewhere
6656    that keep track of the progress of compilation of the current function.
6657    Used for nested functions.  */
6658
6659 struct language_function GTY(())
6660 {
6661   struct c_language_function base;
6662   tree named_labels;
6663   tree shadowed_labels;
6664   int returns_value;
6665   int returns_null;
6666   int returns_abnormally;
6667   int warn_about_return_type;
6668   int extern_inline;
6669   struct binding_level *binding_level;
6670 };
6671
6672 /* Save and reinitialize the variables
6673    used during compilation of a C function.  */
6674
6675 void
6676 c_push_function_context (f)
6677      struct function *f;
6678 {
6679   struct language_function *p;
6680   p = ((struct language_function *)
6681        ggc_alloc (sizeof (struct language_function)));
6682   f->language = p;
6683
6684   p->base.x_stmt_tree = c_stmt_tree;
6685   p->base.x_scope_stmt_stack = c_scope_stmt_stack;
6686   p->named_labels = named_labels;
6687   p->shadowed_labels = shadowed_labels;
6688   p->returns_value = current_function_returns_value;
6689   p->returns_null = current_function_returns_null;
6690   p->returns_abnormally = current_function_returns_abnormally;
6691   p->warn_about_return_type = warn_about_return_type;
6692   p->extern_inline = current_extern_inline;
6693   p->binding_level = current_binding_level;
6694 }
6695
6696 /* Restore the variables used during compilation of a C function.  */
6697
6698 void
6699 c_pop_function_context (f)
6700      struct function *f;
6701 {
6702   struct language_function *p = f->language;
6703   tree link;
6704
6705   /* Bring back all the labels that were shadowed.  */
6706   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
6707     if (DECL_NAME (TREE_VALUE (link)) != 0)
6708       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
6709         = TREE_VALUE (link);
6710
6711   if (DECL_SAVED_INSNS (current_function_decl) == 0
6712       && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6713     {
6714       /* Stop pointing to the local nodes about to be freed.  */
6715       /* But DECL_INITIAL must remain nonzero so we know this
6716          was an actual function definition.  */
6717       DECL_INITIAL (current_function_decl) = error_mark_node;
6718       DECL_ARGUMENTS (current_function_decl) = 0;
6719     }
6720
6721   c_stmt_tree = p->base.x_stmt_tree;
6722   c_scope_stmt_stack = p->base.x_scope_stmt_stack;
6723   named_labels = p->named_labels;
6724   shadowed_labels = p->shadowed_labels;
6725   current_function_returns_value = p->returns_value;
6726   current_function_returns_null = p->returns_null;
6727   current_function_returns_abnormally = p->returns_abnormally;
6728   warn_about_return_type = p->warn_about_return_type;
6729   current_extern_inline = p->extern_inline;
6730   current_binding_level = p->binding_level;
6731
6732   f->language = NULL;
6733 }
6734
6735 /* Copy the DECL_LANG_SPECIFIC data associated with DECL.  */
6736
6737 void
6738 c_dup_lang_specific_decl (decl)
6739      tree decl;
6740 {
6741   struct lang_decl *ld;
6742
6743   if (!DECL_LANG_SPECIFIC (decl))
6744     return;
6745
6746   ld = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl));
6747   memcpy ((char *) ld, (char *) DECL_LANG_SPECIFIC (decl),
6748           sizeof (struct lang_decl));
6749   DECL_LANG_SPECIFIC (decl) = ld;
6750 }
6751
6752 /* The functions below are required for functionality of doing
6753    function at once processing in the C front end. Currently these
6754    functions are not called from anywhere in the C front end, but as
6755    these changes continue, that will change.  */
6756
6757 /* Returns nonzero if the current statement is a full expression,
6758    i.e. temporaries created during that statement should be destroyed
6759    at the end of the statement.  */
6760
6761 int
6762 stmts_are_full_exprs_p ()
6763 {
6764   return 0;
6765 }
6766
6767 /* Returns the stmt_tree (if any) to which statements are currently
6768    being added.  If there is no active statement-tree, NULL is
6769    returned.  */
6770
6771 stmt_tree
6772 current_stmt_tree ()
6773 {
6774   return &c_stmt_tree;
6775 }
6776
6777 /* Returns the stack of SCOPE_STMTs for the current function.  */
6778
6779 tree *
6780 current_scope_stmt_stack ()
6781 {
6782   return &c_scope_stmt_stack;
6783 }
6784
6785 /* Nonzero if TYPE is an anonymous union or struct type.  Always 0 in
6786    C.  */
6787
6788 int
6789 anon_aggr_type_p (node)
6790      tree node ATTRIBUTE_UNUSED;
6791 {
6792   return 0;
6793 }
6794
6795 /* Dummy function in place of callback used by C++.  */
6796
6797 void
6798 extract_interface_info ()
6799 {
6800 }
6801
6802 /* Return a new COMPOUND_STMT, after adding it to the current
6803    statement tree.  */
6804
6805 tree
6806 c_begin_compound_stmt ()
6807 {
6808   tree stmt;
6809
6810   /* Create the COMPOUND_STMT.  */
6811   stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
6812
6813   return stmt;
6814 }
6815
6816 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
6817    common code.  */
6818
6819 void
6820 c_expand_decl_stmt (t)
6821      tree t;
6822 {
6823   tree decl = DECL_STMT_DECL (t);
6824
6825   /* Expand nested functions.  */
6826   if (TREE_CODE (decl) == FUNCTION_DECL
6827       && DECL_CONTEXT (decl) == current_function_decl
6828       && DECL_SAVED_TREE (decl))
6829     c_expand_body (decl, /*nested_p=*/1, /*can_defer_p=*/0);
6830 }
6831
6832 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
6833    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
6834
6835 tree
6836 identifier_global_value (t)
6837      tree t;
6838 {
6839   return IDENTIFIER_GLOBAL_VALUE (t);
6840 }
6841
6842 /* Record a builtin type for C.  If NAME is non-NULL, it is the name used;
6843    otherwise the name is found in ridpointers from RID_INDEX.  */
6844
6845 void
6846 record_builtin_type (rid_index, name, type)
6847      enum rid rid_index;
6848      const char *name;
6849      tree type;
6850 {
6851   tree id;
6852   if (name == 0)
6853     id = ridpointers[(int) rid_index];
6854   else
6855     id = get_identifier (name);
6856   pushdecl (build_decl (TYPE_DECL, id, type));
6857 }
6858
6859 /* Build the void_list_node (void_type_node having been created).  */
6860 tree
6861 build_void_list_node ()
6862 {
6863   tree t = build_tree_list (NULL_TREE, void_type_node);
6864   return t;
6865 }
6866
6867 /* Return something to represent absolute declarators containing a *.
6868    TARGET is the absolute declarator that the * contains.
6869    TYPE_QUALS_ATTRS is a list of modifiers such as const or volatile
6870    to apply to the pointer type, represented as identifiers, possible mixed
6871    with attributes.
6872
6873    We return an INDIRECT_REF whose "contents" are TARGET (inside a TREE_LIST,
6874    if attributes are present) and whose type is the modifier list.  */
6875
6876 tree
6877 make_pointer_declarator (type_quals_attrs, target)
6878      tree type_quals_attrs, target;
6879 {
6880   tree quals, attrs;
6881   tree itarget = target;
6882   split_specs_attrs (type_quals_attrs, &quals, &attrs);
6883   if (attrs != NULL_TREE)
6884     itarget = tree_cons (attrs, target, NULL_TREE);
6885   return build1 (INDIRECT_REF, quals, itarget);
6886 }
6887
6888 #include "gt-c-decl.h"