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