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