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