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