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