gcc/c-decl.c

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