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