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