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