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