gcc/c-decl.c

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