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           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1936             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1937         }
1938
1939       pop_obstacks ();
1940     }
1941   /* If cannot merge, then use the new type and qualifiers,
1942      and don't preserve the old rtl.  */
1943   else if (! different_binding_level)
1944     {
1945       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1946       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1947       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1948       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1949     }
1950
1951   /* Merge the storage class information.  */
1952   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
1953   /* For functions, static overrides non-static.  */
1954   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1955     {
1956       TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1957       /* This is since we don't automatically
1958          copy the attributes of NEWDECL into OLDDECL.  */
1959       /* No need to worry about different_binding_level here because
1960          then TREE_PUBLIC (newdecl) was true.  */
1961       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1962       /* If this clears `static', clear it in the identifier too.  */
1963       if (! TREE_PUBLIC (olddecl))
1964         TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1965     }
1966   if (DECL_EXTERNAL (newdecl))
1967     {
1968       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1969       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1970       /* An extern decl does not override previous storage class.  */
1971       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1972       if (! DECL_EXTERNAL (newdecl))
1973         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1974     }
1975   else
1976     {
1977       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1978       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1979     }
1980
1981   /* If either decl says `inline', this fn is inline,
1982      unless its definition was passed already.  */
1983   if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0)
1984     DECL_INLINE (olddecl) = 1;
1985   DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1986
1987   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1988     {
1989       if (DECL_BUILT_IN (olddecl))
1990         {
1991           /* Get rid of any built-in function if new arg types don't match it
1992              or if we have a function definition.  */
1993           if (! types_match || new_is_definition)
1994             {
1995               if (! different_binding_level)
1996                 {
1997                   TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1998                   DECL_BUILT_IN (olddecl) = 0;
1999                 }
2000             }
2001           else
2002             {
2003               /* If redeclaring a builtin function, and not a definition,
2004                  it stays built in.  */
2005               DECL_BUILT_IN (newdecl) = 1;
2006               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2007             }
2008         }
2009       /* Also preserve various other info from the definition.  */
2010       else if (! new_is_definition)
2011         DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
2012       if (! new_is_definition)
2013         {
2014           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2015           /* When called with different_binding_level set, don't copy over
2016              DECL_INITIAL, so that we don't accidentally change function
2017              declarations into function definitions.  */
2018           if (! different_binding_level)
2019             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2020           DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
2021           DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2022           if (DECL_INLINE (newdecl))
2023             DECL_ABSTRACT_ORIGIN (newdecl) = olddecl;
2024         }
2025     }
2026   if (different_binding_level)
2027     {
2028       /* Don't output a duplicate symbol or debugging information for this
2029          declaration.
2030
2031          Do not set TREE_ASM_WRITTEN for a FUNCTION_DECL since we may actually
2032          just have two declarations without a definition.  VAR_DECLs may need
2033          the same treatment, I'm not sure.  */
2034       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2035         DECL_IGNORED_P (newdecl) = 1;
2036       else
2037         TREE_ASM_WRITTEN (newdecl) = DECL_IGNORED_P (newdecl) = 1;
2038       return 0;
2039     }
2040
2041   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2042      But preserve OLDDECL's DECL_UID.  */
2043   {
2044     register unsigned olddecl_uid = DECL_UID (olddecl);
2045
2046     bcopy ((char *) newdecl + sizeof (struct tree_common),
2047            (char *) olddecl + sizeof (struct tree_common),
2048            sizeof (struct tree_decl) - sizeof (struct tree_common));
2049     DECL_UID (olddecl) = olddecl_uid;
2050   }
2051
2052   /* NEWDECL contains the merged attribute lists.
2053      Update OLDDECL to be the same.  */
2054   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
2055
2056   return 1;
2057 }
2058
2059 /* Record a decl-node X as belonging to the current lexical scope.
2060    Check for errors (such as an incompatible declaration for the same
2061    name already seen in the same scope).
2062
2063    Returns either X or an old decl for the same name.
2064    If an old decl is returned, it may have been smashed
2065    to agree with what X says.  */
2066
2067 tree
2068 pushdecl (x)
2069      tree x;
2070 {
2071   register tree t;
2072   register tree name = DECL_NAME (x);
2073   register struct binding_level *b = current_binding_level;
2074
2075   DECL_CONTEXT (x) = current_function_decl;
2076   /* A local extern declaration for a function doesn't constitute nesting.
2077      A local auto declaration does, since it's a forward decl
2078      for a nested function coming later.  */
2079   if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0
2080       && DECL_EXTERNAL (x))
2081     DECL_CONTEXT (x) = 0;
2082
2083   if (warn_nested_externs && DECL_EXTERNAL (x) && b != global_binding_level
2084       && x != IDENTIFIER_IMPLICIT_DECL (name)
2085       /* Don't print error messages for __FUNCTION__ and __PRETTY_FUNCTION__ */
2086       && !DECL_IN_SYSTEM_HEADER (x))
2087     warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name));
2088
2089   if (name)
2090     {
2091       char *file;
2092       int line;
2093       int different_binding_level = 0;
2094
2095       t = lookup_name_current_level (name);
2096       /* Don't type check externs here when -traditional.  This is so that
2097          code with conflicting declarations inside blocks will get warnings
2098          not errors.  X11 for instance depends on this.  */
2099       if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x) && ! flag_traditional)
2100         {
2101           t = IDENTIFIER_GLOBAL_VALUE (name);
2102           /* Type decls at global scope don't conflict with externs declared
2103              inside lexical blocks.  */
2104           if (t && TREE_CODE (t) == TYPE_DECL)
2105             t = 0;
2106           different_binding_level = 1;
2107         }
2108       if (t != 0 && t == error_mark_node)
2109         /* error_mark_node is 0 for a while during initialization!  */
2110         {
2111           t = 0;
2112           error_with_decl (x, "`%s' used prior to declaration");
2113         }
2114
2115       if (t != 0)
2116         {
2117           file = DECL_SOURCE_FILE (t);
2118           line = DECL_SOURCE_LINE (t);
2119         }
2120
2121       /* If this decl is `static' and an implicit decl was seen previously,
2122          warn.  But don't complain if -traditional,
2123          since traditional compilers don't complain.  */
2124       if (! flag_traditional && TREE_PUBLIC (name)
2125           /* Don't test for DECL_EXTERNAL, because grokdeclarator
2126              sets this for all functions.  */
2127           && ! TREE_PUBLIC (x)
2128           && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
2129           /* We used to warn also for explicit extern followed by static,
2130              but sometimes you need to do it that way.  */
2131           && IDENTIFIER_IMPLICIT_DECL (name) != 0)
2132         {
2133           pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2134                    IDENTIFIER_POINTER (name));
2135           pedwarn_with_file_and_line
2136             (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
2137              DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
2138              "previous declaration of `%s'",
2139              IDENTIFIER_POINTER (name));
2140           TREE_THIS_VOLATILE (name) = 1;
2141         }
2142
2143       if (t != 0 && duplicate_decls (x, t, different_binding_level))
2144         {
2145           if (TREE_CODE (t) == PARM_DECL)
2146             {
2147               /* Don't allow more than one "real" duplicate
2148                  of a forward parm decl.  */
2149               TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
2150               return t;
2151             }
2152           return t;
2153         }
2154
2155       /* If we are processing a typedef statement, generate a whole new
2156          ..._TYPE node (which will be just an variant of the existing
2157          ..._TYPE node with identical properties) and then install the
2158          TYPE_DECL node generated to represent the typedef name as the
2159          TYPE_NAME of this brand new (duplicate) ..._TYPE node.
2160
2161          The whole point here is to end up with a situation where each
2162          and every ..._TYPE node the compiler creates will be uniquely
2163          associated with AT MOST one node representing a typedef name.
2164          This way, even though the compiler substitutes corresponding
2165          ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
2166          early on, later parts of the compiler can always do the reverse
2167          translation and get back the corresponding typedef name.  For
2168          example, given:
2169
2170                 typedef struct S MY_TYPE;
2171                 MY_TYPE object;
2172
2173          Later parts of the compiler might only know that `object' was of
2174          type `struct S' if it were not for code just below.  With this
2175          code however, later parts of the compiler see something like:
2176
2177                 struct S' == struct S
2178                 typedef struct S' MY_TYPE;
2179                 struct S' object;
2180
2181          And they can then deduce (from the node for type struct S') that
2182          the original object declaration was:
2183
2184                 MY_TYPE object;
2185
2186          Being able to do this is important for proper support of protoize,
2187          and also for generating precise symbolic debugging information
2188          which takes full account of the programmer's (typedef) vocabulary.
2189
2190          Obviously, we don't want to generate a duplicate ..._TYPE node if
2191          the TYPE_DECL node that we are now processing really represents a
2192          standard built-in type.
2193
2194          Since all standard types are effectively declared at line zero
2195          in the source file, we can easily check to see if we are working
2196          on a standard type by checking the current value of lineno.  */
2197
2198       if (TREE_CODE (x) == TYPE_DECL)
2199         {
2200           if (DECL_SOURCE_LINE (x) == 0)
2201             {
2202               if (TYPE_NAME (TREE_TYPE (x)) == 0)
2203                 TYPE_NAME (TREE_TYPE (x)) = x;
2204             }
2205           else if (TREE_TYPE (x) != error_mark_node
2206                    && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
2207             {
2208               tree tt = TREE_TYPE (x);
2209               DECL_ORIGINAL_TYPE (x) = tt;
2210               tt = build_type_copy (tt);
2211               TYPE_NAME (tt) = x;
2212               TREE_TYPE (x) = tt;
2213             }
2214         }
2215
2216       /* Multiple external decls of the same identifier ought to match.
2217          Check against both global declarations (when traditional) and out of
2218          scope (limbo) block level declarations.
2219
2220          We get warnings about inline functions where they are defined.
2221          Avoid duplicate warnings where they are used.  */
2222       if (TREE_PUBLIC (x) && ! DECL_INLINE (x))
2223         {
2224           tree decl;
2225
2226           if (flag_traditional && IDENTIFIER_GLOBAL_VALUE (name) != 0
2227               && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
2228                   || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
2229             decl = IDENTIFIER_GLOBAL_VALUE (name);
2230           else if (IDENTIFIER_LIMBO_VALUE (name) != 0)
2231             /* Decls in limbo are always extern, so no need to check that.  */
2232             decl = IDENTIFIER_LIMBO_VALUE (name);
2233           else
2234             decl = 0;
2235
2236           if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
2237               /* If old decl is built-in, we already warned if we should.  */
2238               && !DECL_BUILT_IN (decl))
2239             {
2240               pedwarn_with_decl (x,
2241                                  "type mismatch with previous external decl");
2242               pedwarn_with_decl (decl, "previous external decl of `%s'");
2243             }
2244         }
2245
2246       /* If a function has had an implicit declaration, and then is defined,
2247          make sure they are compatible.  */
2248
2249       if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2250           && IDENTIFIER_GLOBAL_VALUE (name) == 0
2251           && TREE_CODE (x) == FUNCTION_DECL
2252           && ! comptypes (TREE_TYPE (x),
2253                           TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
2254         {
2255           warning_with_decl (x, "type mismatch with previous implicit declaration");
2256           warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
2257                              "previous implicit declaration of `%s'");
2258         }
2259
2260       /* In PCC-compatibility mode, extern decls of vars with no current decl
2261          take effect at top level no matter where they are.  */
2262       if (flag_traditional && DECL_EXTERNAL (x)
2263           && lookup_name (name) == 0)
2264         {
2265           tree type = TREE_TYPE (x);
2266
2267           /* But don't do this if the type contains temporary nodes.  */
2268           while (type)
2269             {
2270               if (type == error_mark_node)
2271                 break;
2272               if (! TREE_PERMANENT (type))
2273                 {
2274                   warning_with_decl (x, "type of external `%s' is not global");
2275                   /* By exiting the loop early, we leave TYPE nonzero,
2276                      and thus prevent globalization of the decl.  */
2277                   break;
2278                 }
2279               else if (TREE_CODE (type) == FUNCTION_TYPE
2280                        && TYPE_ARG_TYPES (type) != 0)
2281                 /* The types might not be truly local,
2282                    but the list of arg types certainly is temporary.
2283                    Since prototypes are nontraditional,
2284                    ok not to do the traditional thing.  */
2285                 break;
2286               type = TREE_TYPE (type);
2287             }
2288
2289           if (type == 0)
2290             b = global_binding_level;
2291         }
2292
2293       /* This name is new in its binding level.
2294          Install the new declaration and return it.  */
2295       if (b == global_binding_level)
2296         {
2297           /* Install a global value.  */
2298
2299           /* If the first global decl has external linkage,
2300              warn if we later see static one.  */
2301           if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
2302             TREE_PUBLIC (name) = 1;
2303
2304           IDENTIFIER_GLOBAL_VALUE (name) = x;
2305
2306           /* We no longer care about any previous block level declarations.  */
2307           IDENTIFIER_LIMBO_VALUE (name) = 0;
2308
2309           /* Don't forget if the function was used via an implicit decl.  */
2310           if (IDENTIFIER_IMPLICIT_DECL (name)
2311               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2312             TREE_USED (x) = 1, TREE_USED (name) = 1;
2313
2314           /* Don't forget if its address was taken in that way.  */
2315           if (IDENTIFIER_IMPLICIT_DECL (name)
2316               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2317             TREE_ADDRESSABLE (x) = 1;
2318
2319           /* Warn about mismatches against previous implicit decl.  */
2320           if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2321               /* If this real decl matches the implicit, don't complain.  */
2322               && ! (TREE_CODE (x) == FUNCTION_DECL
2323                     && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
2324                         == integer_type_node)))
2325             pedwarn ("`%s' was previously implicitly declared to return `int'",
2326                      IDENTIFIER_POINTER (name));
2327
2328           /* If this decl is `static' and an `extern' was seen previously,
2329              that is erroneous.  */
2330           if (TREE_PUBLIC (name)
2331               && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
2332             {
2333               /* Okay to redeclare an ANSI built-in as static.  */
2334               if (t != 0 && DECL_BUILT_IN (t))
2335                 ;
2336               /* Okay to declare a non-ANSI built-in as anything.  */
2337               else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
2338                 ;
2339               /* Okay to have global type decl after an earlier extern
2340                  declaration inside a lexical block.  */
2341               else if (TREE_CODE (x) == TYPE_DECL)
2342                 ;
2343               else if (IDENTIFIER_IMPLICIT_DECL (name))
2344                 {
2345                   if (! TREE_THIS_VOLATILE (name))
2346                     pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2347                              IDENTIFIER_POINTER (name));
2348                 }
2349               else
2350                 pedwarn ("`%s' was declared `extern' and later `static'",
2351                          IDENTIFIER_POINTER (name));
2352             }
2353         }
2354       else
2355         {
2356           /* Here to install a non-global value.  */
2357           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2358           tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2359           IDENTIFIER_LOCAL_VALUE (name) = x;
2360
2361           /* If this is an extern function declaration, see if we
2362              have a global definition or declaration for the function.  */
2363           if (oldlocal == 0
2364               && DECL_EXTERNAL (x) && !DECL_INLINE (x)
2365               && oldglobal != 0
2366               && TREE_CODE (x) == FUNCTION_DECL
2367               && TREE_CODE (oldglobal) == FUNCTION_DECL)
2368             {
2369               /* We have one.  Their types must agree.  */
2370               if (! comptypes (TREE_TYPE (x),
2371                                TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
2372                 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
2373               else
2374                 {
2375                   /* Inner extern decl is inline if global one is.
2376                      Copy enough to really inline it.  */
2377                   if (DECL_INLINE (oldglobal))
2378                     {
2379                       DECL_INLINE (x) = DECL_INLINE (oldglobal);
2380                       DECL_INITIAL (x) = (current_function_decl == oldglobal
2381                                           ? 0 : DECL_INITIAL (oldglobal));
2382                       DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
2383                       DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal);
2384                       DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
2385                       DECL_RESULT (x) = DECL_RESULT (oldglobal);
2386                       TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
2387                       DECL_ABSTRACT_ORIGIN (x) = oldglobal;
2388                     }
2389                   /* Inner extern decl is built-in if global one is.  */
2390                   if (DECL_BUILT_IN (oldglobal))
2391                     {
2392                       DECL_BUILT_IN (x) = DECL_BUILT_IN (oldglobal);
2393                       DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
2394                     }
2395                   /* Keep the arg types from a file-scope fcn defn.  */
2396                   if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
2397                       && DECL_INITIAL (oldglobal)
2398                       && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
2399                     TREE_TYPE (x) = TREE_TYPE (oldglobal);
2400                 }
2401             }
2402
2403 #if 0 /* This case is probably sometimes the right thing to do.  */
2404           /* If we have a local external declaration,
2405              then any file-scope declaration should not
2406              have been static.  */
2407           if (oldlocal == 0 && oldglobal != 0
2408               && !TREE_PUBLIC (oldglobal)
2409               && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
2410             warning ("`%s' locally external but globally static",
2411                      IDENTIFIER_POINTER (name));
2412 #endif
2413
2414           /* If we have a local external declaration,
2415              and no file-scope declaration has yet been seen,
2416              then if we later have a file-scope decl it must not be static.  */
2417           if (oldlocal == 0
2418               && DECL_EXTERNAL (x)
2419               && TREE_PUBLIC (x))
2420             {
2421               if (oldglobal == 0)
2422                 TREE_PUBLIC (name) = 1;
2423
2424               /* Save this decl, so that we can do type checking against
2425                  other decls after it falls out of scope.
2426
2427                  Only save it once.  This prevents temporary decls created in
2428                  expand_inline_function from being used here, since this
2429                  will have been set when the inline function was parsed.
2430                  It also helps give slightly better warnings.  */
2431               if (IDENTIFIER_LIMBO_VALUE (name) == 0)
2432                 IDENTIFIER_LIMBO_VALUE (name) = x;
2433             }
2434
2435           /* Warn if shadowing an argument at the top level of the body.  */
2436           if (oldlocal != 0 && !DECL_EXTERNAL (x)
2437               /* This warning doesn't apply to the parms of a nested fcn.  */
2438               && ! current_binding_level->parm_flag
2439               /* Check that this is one level down from the parms.  */
2440               && current_binding_level->level_chain->parm_flag
2441               /* Check that the decl being shadowed
2442                  comes from the parm level, one level up.  */
2443               && chain_member (oldlocal, current_binding_level->level_chain->names))
2444             {
2445               if (TREE_CODE (oldlocal) == PARM_DECL)
2446                 pedwarn ("declaration of `%s' shadows a parameter",
2447                          IDENTIFIER_POINTER (name));
2448               else
2449                 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
2450                          IDENTIFIER_POINTER (name));
2451             }
2452
2453           /* Maybe warn if shadowing something else.  */
2454           else if (warn_shadow && !DECL_EXTERNAL (x)
2455                    /* No shadow warnings for internally generated vars.  */
2456                    && DECL_SOURCE_LINE (x) != 0
2457                    /* No shadow warnings for vars made for inlining.  */
2458                    && ! DECL_FROM_INLINE (x))
2459             {
2460               char *warnstring = 0;
2461
2462               if (TREE_CODE (x) == PARM_DECL
2463                   && current_binding_level->level_chain->parm_flag)
2464                 /* Don't warn about the parm names in function declarator
2465                    within a function declarator.
2466                    It would be nice to avoid warning in any function
2467                    declarator in a declaration, as opposed to a definition,
2468                    but there is no way to tell it's not a definition.  */
2469                 ;
2470               else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
2471                 warnstring = "declaration of `%s' shadows a parameter";
2472               else if (oldlocal != 0)
2473                 warnstring = "declaration of `%s' shadows previous local";
2474               else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
2475                        && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
2476                 warnstring = "declaration of `%s' shadows global declaration";
2477
2478               if (warnstring)
2479                 warning (warnstring, IDENTIFIER_POINTER (name));
2480             }
2481
2482           /* If storing a local value, there may already be one (inherited).
2483              If so, record it for restoration when this binding level ends.  */
2484           if (oldlocal != 0)
2485             b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2486         }
2487
2488       /* Keep count of variables in this level with incomplete type.  */
2489       if (TYPE_SIZE (TREE_TYPE (x)) == 0)
2490         ++b->n_incomplete;
2491     }
2492
2493   /* Put decls on list in reverse order.
2494      We will reverse them later if necessary.  */
2495   TREE_CHAIN (x) = b->names;
2496   b->names = x;
2497
2498   return x;
2499 }
2500
2501 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
2502
2503 tree
2504 pushdecl_top_level (x)
2505      tree x;
2506 {
2507   register tree t;
2508   register struct binding_level *b = current_binding_level;
2509
2510   current_binding_level = global_binding_level;
2511   t = pushdecl (x);
2512   current_binding_level = b;
2513   return t;
2514 }
2515 \f
2516 /* Generate an implicit declaration for identifier FUNCTIONID
2517    as a function of type int ().  Print a warning if appropriate.  */
2518
2519 tree
2520 implicitly_declare (functionid)
2521      tree functionid;
2522 {
2523   register tree decl;
2524   int traditional_warning = 0;
2525   /* Only one "implicit declaration" warning per identifier.  */
2526   int implicit_warning;
2527
2528   /* Save the decl permanently so we can warn if definition follows.  */
2529   push_obstacks_nochange ();
2530   end_temporary_allocation ();
2531
2532   /* We used to reuse an old implicit decl here,
2533      but this loses with inline functions because it can clobber
2534      the saved decl chains.  */
2535 /*  if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2536     decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2537   else  */
2538     decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2539
2540   /* Warn of implicit decl following explicit local extern decl.
2541      This is probably a program designed for traditional C.  */
2542   if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2543     traditional_warning = 1;
2544
2545   /* Warn once of an implicit declaration.  */
2546   implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2547
2548   DECL_EXTERNAL (decl) = 1;
2549   TREE_PUBLIC (decl) = 1;
2550
2551   /* Record that we have an implicit decl and this is it.  */
2552   IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2553
2554   /* ANSI standard says implicit declarations are in the innermost block.
2555      So we record the decl in the standard fashion.
2556      If flag_traditional is set, pushdecl does it top-level.  */
2557   pushdecl (decl);
2558
2559   /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
2560   maybe_objc_check_decl (decl);
2561
2562   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
2563
2564   if (mesg_implicit_function_declaration && implicit_warning)
2565     {
2566       if (mesg_implicit_function_declaration == 2)
2567         error ("implicit declaration of function `%s'",
2568                  IDENTIFIER_POINTER (functionid));
2569       else
2570         warning ("implicit declaration of function `%s'",
2571                  IDENTIFIER_POINTER (functionid));
2572     }
2573   else if (warn_traditional && traditional_warning)
2574     warning ("function `%s' was previously declared within a block",
2575              IDENTIFIER_POINTER (functionid));
2576
2577   /* Write a record describing this implicit function declaration to the
2578      prototypes file (if requested).  */
2579
2580   gen_aux_info_record (decl, 0, 1, 0);
2581
2582   pop_obstacks ();
2583
2584   return decl;
2585 }
2586
2587 /* Return zero if the declaration NEWDECL is valid
2588    when the declaration OLDDECL (assumed to be for the same name)
2589    has already been seen.
2590    Otherwise return an error message format string with a %s
2591    where the identifier should go.  */
2592
2593 static char *
2594 redeclaration_error_message (newdecl, olddecl)
2595      tree newdecl, olddecl;
2596 {
2597   if (TREE_CODE (newdecl) == TYPE_DECL)
2598     {
2599       if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
2600         return 0;
2601       /* pushdecl creates distinct types for TYPE_DECLs by calling
2602          build_type_copy, so the above comparison generally fails.  We do
2603          another test against the TYPE_MAIN_VARIANT of the olddecl, which
2604          is equivalent to what this code used to do before the build_type_copy
2605          call.  The variant type distinction should not matter for traditional
2606          code, because it doesn't have type qualifiers.  */
2607       if (flag_traditional
2608           && TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)) == TREE_TYPE (newdecl))
2609         return 0;
2610       if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2611         return 0;
2612       return "redefinition of `%s'";
2613     }
2614   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2615     {
2616       /* Declarations of functions can insist on internal linkage
2617          but they can't be inconsistent with internal linkage,
2618          so there can be no error on that account.
2619          However defining the same name twice is no good.  */
2620       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2621           /* However, defining once as extern inline and a second
2622              time in another way is ok.  */
2623           && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
2624                && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
2625         return "redefinition of `%s'";
2626       return 0;
2627     }
2628   else if (current_binding_level == global_binding_level)
2629     {
2630       /* Objects declared at top level:  */
2631       /* If at least one is a reference, it's ok.  */
2632       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2633         return 0;
2634       /* Reject two definitions.  */
2635       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2636         return "redefinition of `%s'";
2637       /* Now we have two tentative defs, or one tentative and one real def.  */
2638       /* Insist that the linkage match.  */
2639       if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2640         return "conflicting declarations of `%s'";
2641       return 0;
2642     }
2643   else if (current_binding_level->parm_flag
2644            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2645     return 0;
2646   else
2647     {
2648       /* Newdecl has block scope.  If olddecl has block scope also, then
2649          reject two definitions, and reject a definition together with an
2650          external reference.  Otherwise, it is OK, because newdecl must
2651          be an extern reference to olddecl.  */
2652       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2653           && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2654         return "redeclaration of `%s'";
2655       return 0;
2656     }
2657 }
2658 \f
2659 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2660    Create one if none exists so far for the current function.
2661    This function is called for both label definitions and label references.  */
2662
2663 tree
2664 lookup_label (id)
2665      tree id;
2666 {
2667   register tree decl = IDENTIFIER_LABEL_VALUE (id);
2668
2669   if (current_function_decl == 0)
2670     {
2671       error ("label %s referenced outside of any function",
2672              IDENTIFIER_POINTER (id));
2673       return 0;
2674     }
2675
2676   /* Use a label already defined or ref'd with this name.  */
2677   if (decl != 0)
2678     {
2679       /* But not if it is inherited and wasn't declared to be inheritable.  */
2680       if (DECL_CONTEXT (decl) != current_function_decl
2681           && ! C_DECLARED_LABEL_FLAG (decl))
2682         return shadow_label (id);
2683       return decl;
2684     }
2685
2686   decl = build_decl (LABEL_DECL, id, void_type_node);
2687
2688   /* Make sure every label has an rtx.  */
2689   label_rtx (decl);
2690
2691   /* A label not explicitly declared must be local to where it's ref'd.  */
2692   DECL_CONTEXT (decl) = current_function_decl;
2693
2694   DECL_MODE (decl) = VOIDmode;
2695
2696   /* Say where one reference is to the label,
2697      for the sake of the error if it is not defined.  */
2698   DECL_SOURCE_LINE (decl) = lineno;
2699   DECL_SOURCE_FILE (decl) = input_filename;
2700
2701   IDENTIFIER_LABEL_VALUE (id) = decl;
2702
2703   named_labels = tree_cons (NULL_TREE, decl, named_labels);
2704
2705   return decl;
2706 }
2707
2708 /* Make a label named NAME in the current function,
2709    shadowing silently any that may be inherited from containing functions
2710    or containing scopes.
2711
2712    Note that valid use, if the label being shadowed
2713    comes from another scope in the same function,
2714    requires calling declare_nonlocal_label right away.  */
2715
2716 tree
2717 shadow_label (name)
2718      tree name;
2719 {
2720   register tree decl = IDENTIFIER_LABEL_VALUE (name);
2721
2722   if (decl != 0)
2723     {
2724       register tree dup;
2725
2726       /* Check to make sure that the label hasn't already been declared
2727          at this label scope */
2728       for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2729         if (TREE_VALUE (dup) == decl)
2730           {
2731             error ("duplicate label declaration `%s'",
2732                    IDENTIFIER_POINTER (name));
2733             error_with_decl (TREE_VALUE (dup),
2734                              "this is a previous declaration");
2735             /* Just use the previous declaration.  */
2736             return lookup_label (name);
2737           }
2738
2739       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2740       IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2741     }
2742
2743   return lookup_label (name);
2744 }
2745
2746 /* Define a label, specifying the location in the source file.
2747    Return the LABEL_DECL node for the label, if the definition is valid.
2748    Otherwise return 0.  */
2749
2750 tree
2751 define_label (filename, line, name)
2752      char *filename;
2753      int line;
2754      tree name;
2755 {
2756   tree decl = lookup_label (name);
2757
2758   /* If label with this name is known from an outer context, shadow it.  */
2759   if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2760     {
2761       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2762       IDENTIFIER_LABEL_VALUE (name) = 0;
2763       decl = lookup_label (name);
2764     }
2765
2766   if (DECL_INITIAL (decl) != 0)
2767     {
2768       error ("duplicate label `%s'", IDENTIFIER_POINTER (name));
2769       return 0;
2770     }
2771   else
2772     {
2773       /* Mark label as having been defined.  */
2774       DECL_INITIAL (decl) = error_mark_node;
2775       /* Say where in the source.  */
2776       DECL_SOURCE_FILE (decl) = filename;
2777       DECL_SOURCE_LINE (decl) = line;
2778       return decl;
2779     }
2780 }
2781 \f
2782 /* Return the list of declarations of the current level.
2783    Note that this list is in reverse order unless/until
2784    you nreverse it; and when you do nreverse it, you must
2785    store the result back using `storedecls' or you will lose.  */
2786
2787 tree
2788 getdecls ()
2789 {
2790   return current_binding_level->names;
2791 }
2792
2793 /* Return the list of type-tags (for structs, etc) of the current level.  */
2794
2795 tree
2796 gettags ()
2797 {
2798   return current_binding_level->tags;
2799 }
2800
2801 /* Store the list of declarations of the current level.
2802    This is done for the parameter declarations of a function being defined,
2803    after they are modified in the light of any missing parameters.  */
2804
2805 static void
2806 storedecls (decls)
2807      tree decls;
2808 {
2809   current_binding_level->names = decls;
2810 }
2811
2812 /* Similarly, store the list of tags of the current level.  */
2813
2814 static void
2815 storetags (tags)
2816      tree tags;
2817 {
2818   current_binding_level->tags = tags;
2819 }
2820 \f
2821 /* Given NAME, an IDENTIFIER_NODE,
2822    return the structure (or union or enum) definition for that name.
2823    Searches binding levels from BINDING_LEVEL up to the global level.
2824    If THISLEVEL_ONLY is nonzero, searches only the specified context
2825    (but skips any tag-transparent contexts to find one that is
2826    meaningful for tags).
2827    CODE says which kind of type the caller wants;
2828    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2829    If the wrong kind of type is found, an error is reported.  */
2830
2831 static tree
2832 lookup_tag (code, name, binding_level, thislevel_only)
2833      enum tree_code code;
2834      struct binding_level *binding_level;
2835      tree name;
2836      int thislevel_only;
2837 {
2838   register struct binding_level *level;
2839
2840   for (level = binding_level; level; level = level->level_chain)
2841     {
2842       register tree tail;
2843       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2844         {
2845           if (TREE_PURPOSE (tail) == name)
2846             {
2847               if (TREE_CODE (TREE_VALUE (tail)) != code)
2848                 {
2849                   /* Definition isn't the kind we were looking for.  */
2850                   pending_invalid_xref = name;
2851                   pending_invalid_xref_file = input_filename;
2852                   pending_invalid_xref_line = lineno;
2853                 }
2854               return TREE_VALUE (tail);
2855             }
2856         }
2857       if (thislevel_only && ! level->tag_transparent)
2858         return NULL_TREE;
2859     }
2860   return NULL_TREE;
2861 }
2862
2863 /* Print an error message now
2864    for a recent invalid struct, union or enum cross reference.
2865    We don't print them immediately because they are not invalid
2866    when used in the `struct foo;' construct for shadowing.  */
2867
2868 void
2869 pending_xref_error ()
2870 {
2871   if (pending_invalid_xref != 0)
2872     error_with_file_and_line (pending_invalid_xref_file,
2873                               pending_invalid_xref_line,
2874                               "`%s' defined as wrong kind of tag",
2875                               IDENTIFIER_POINTER (pending_invalid_xref));
2876   pending_invalid_xref = 0;
2877 }
2878
2879 /* Given a type, find the tag that was defined for it and return the tag name.
2880    Otherwise return 0.  */
2881
2882 static tree
2883 lookup_tag_reverse (type)
2884      tree type;
2885 {
2886   register struct binding_level *level;
2887
2888   for (level = current_binding_level; level; level = level->level_chain)
2889     {
2890       register tree tail;
2891       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2892         {
2893           if (TREE_VALUE (tail) == type)
2894             return TREE_PURPOSE (tail);
2895         }
2896     }
2897   return NULL_TREE;
2898 }
2899 \f
2900 /* Look up NAME in the current binding level and its superiors
2901    in the namespace of variables, functions and typedefs.
2902    Return a ..._DECL node of some kind representing its definition,
2903    or return 0 if it is undefined.  */
2904
2905 tree
2906 lookup_name (name)
2907      tree name;
2908 {
2909   register tree val;
2910   if (current_binding_level != global_binding_level
2911       && IDENTIFIER_LOCAL_VALUE (name))
2912     val = IDENTIFIER_LOCAL_VALUE (name);
2913   else
2914     val = IDENTIFIER_GLOBAL_VALUE (name);
2915   return val;
2916 }
2917
2918 /* Similar to `lookup_name' but look only at current binding level.  */
2919
2920 tree
2921 lookup_name_current_level (name)
2922      tree name;
2923 {
2924   register tree t;
2925
2926   if (current_binding_level == global_binding_level)
2927     return IDENTIFIER_GLOBAL_VALUE (name);
2928
2929   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2930     return 0;
2931
2932   for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2933     if (DECL_NAME (t) == name)
2934       break;
2935
2936   return t;
2937 }
2938 \f
2939 /* Create the predefined scalar types of C,
2940    and some nodes representing standard constants (0, 1, (void *) 0).
2941    Initialize the global binding level.
2942    Make definitions for built-in primitive functions.  */
2943
2944 void
2945 init_decl_processing ()
2946 {
2947   register tree endlink;
2948   /* Either char* or void*.  */
2949   tree traditional_ptr_type_node;
2950   /* Data types of memcpy and strlen.  */
2951   tree memcpy_ftype, memset_ftype, strlen_ftype;
2952   tree void_ftype_any, ptr_ftype_void, ptr_ftype_ptr;
2953   int wchar_type_size;
2954   tree temp;
2955   tree array_domain_type;
2956
2957   current_function_decl = NULL;
2958   named_labels = NULL;
2959   current_binding_level = NULL_BINDING_LEVEL;
2960   free_binding_level = NULL_BINDING_LEVEL;
2961   pushlevel (0);        /* make the binding_level structure for global names */
2962   global_binding_level = current_binding_level;
2963
2964   /* Define `int' and `char' first so that dbx will output them first.  */
2965
2966   integer_type_node = make_signed_type (INT_TYPE_SIZE);
2967   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
2968                         integer_type_node));
2969
2970   /* Define `char', which is like either `signed char' or `unsigned char'
2971      but not the same as either.  */
2972
2973   char_type_node
2974     = (flag_signed_char
2975        ? make_signed_type (CHAR_TYPE_SIZE)
2976        : make_unsigned_type (CHAR_TYPE_SIZE));
2977   pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
2978                         char_type_node));
2979
2980   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
2981   pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
2982                         long_integer_type_node));
2983
2984   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
2985   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
2986                         unsigned_type_node));
2987
2988   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
2989   pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
2990                         long_unsigned_type_node));
2991
2992   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
2993   pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),
2994                         long_long_integer_type_node));
2995
2996   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
2997   pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),
2998                         long_long_unsigned_type_node));
2999
3000   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
3001   pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
3002                         short_integer_type_node));
3003
3004   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
3005   pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
3006                         short_unsigned_type_node));
3007
3008   /* `unsigned long' is the standard type for sizeof.
3009      Traditionally, use a signed type.
3010      Note that stddef.h uses `unsigned long',
3011      and this must agree, even if long and int are the same size.  */
3012   set_sizetype
3013     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
3014   if (flag_traditional && TREE_UNSIGNED (sizetype))
3015     set_sizetype (signed_type (sizetype));
3016
3017   ptrdiff_type_node
3018     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
3019
3020   error_mark_node = make_node (ERROR_MARK);
3021   TREE_TYPE (error_mark_node) = error_mark_node;
3022
3023   /* Define both `signed char' and `unsigned char'.  */
3024   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
3025   pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
3026                         signed_char_type_node));
3027
3028   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
3029   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
3030                         unsigned_char_type_node));
3031
3032   intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
3033   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
3034
3035   intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
3036   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
3037
3038   intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
3039   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
3040
3041   intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
3042   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
3043
3044   intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
3045   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intTI_type_node));
3046
3047   unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
3048   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
3049
3050   unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
3051   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
3052
3053   unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
3054   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
3055
3056   unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
3057   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
3058
3059   unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
3060   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intTI_type_node));
3061
3062   float_type_node = make_node (REAL_TYPE);
3063   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
3064   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
3065                         float_type_node));
3066   layout_type (float_type_node);
3067
3068   double_type_node = make_node (REAL_TYPE);
3069   if (flag_short_double)
3070     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
3071   else
3072     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
3073   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
3074                         double_type_node));
3075   layout_type (double_type_node);
3076
3077   long_double_type_node = make_node (REAL_TYPE);
3078   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
3079   pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
3080                         long_double_type_node));
3081   layout_type (long_double_type_node);
3082
3083   complex_integer_type_node = make_node (COMPLEX_TYPE);
3084   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
3085                         complex_integer_type_node));
3086   TREE_TYPE (complex_integer_type_node) = integer_type_node;
3087   layout_type (complex_integer_type_node);
3088
3089   complex_float_type_node = make_node (COMPLEX_TYPE);
3090   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
3091                         complex_float_type_node));
3092   TREE_TYPE (complex_float_type_node) = float_type_node;
3093   layout_type (complex_float_type_node);
3094
3095   complex_double_type_node = make_node (COMPLEX_TYPE);
3096   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
3097                         complex_double_type_node));
3098   TREE_TYPE (complex_double_type_node) = double_type_node;
3099   layout_type (complex_double_type_node);
3100
3101   complex_long_double_type_node = make_node (COMPLEX_TYPE);
3102   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3103                         complex_long_double_type_node));
3104   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
3105   layout_type (complex_long_double_type_node);
3106
3107   wchar_type_node
3108     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
3109   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3110   signed_wchar_type_node = signed_type (wchar_type_node);
3111   unsigned_wchar_type_node = unsigned_type (wchar_type_node);
3112
3113   integer_zero_node = build_int_2 (0, 0);
3114   TREE_TYPE (integer_zero_node) = integer_type_node;
3115   integer_one_node = build_int_2 (1, 0);
3116   TREE_TYPE (integer_one_node) = integer_type_node;
3117
3118   boolean_type_node = integer_type_node;
3119   boolean_true_node = integer_one_node;
3120   boolean_false_node = integer_zero_node;
3121
3122   size_zero_node = build_int_2 (0, 0);
3123   TREE_TYPE (size_zero_node) = sizetype;
3124   size_one_node = build_int_2 (1, 0);
3125   TREE_TYPE (size_one_node) = sizetype;
3126
3127   void_type_node = make_node (VOID_TYPE);
3128   pushdecl (build_decl (TYPE_DECL,
3129                         ridpointers[(int) RID_VOID], void_type_node));
3130   layout_type (void_type_node); /* Uses integer_zero_node */
3131   /* We are not going to have real types in C with less than byte alignment,
3132      so we might as well not have any types that claim to have it.  */
3133   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
3134
3135   null_pointer_node = build_int_2 (0, 0);
3136   TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
3137   layout_type (TREE_TYPE (null_pointer_node));
3138
3139   string_type_node = build_pointer_type (char_type_node);
3140   const_string_type_node
3141     = build_pointer_type (build_type_variant (char_type_node, 1, 0));
3142
3143   /* Make a type to be the domain of a few array types
3144      whose domains don't really matter.
3145      200 is small enough that it always fits in size_t
3146      and large enough that it can hold most function names for the
3147      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3148   array_domain_type = build_index_type (build_int_2 (200, 0));
3149
3150   /* make a type for arrays of characters.
3151      With luck nothing will ever really depend on the length of this
3152      array type.  */
3153   char_array_type_node
3154     = build_array_type (char_type_node, array_domain_type);
3155   /* Likewise for arrays of ints.  */
3156   int_array_type_node
3157     = build_array_type (integer_type_node, array_domain_type);
3158   /* This is for wide string constants.  */
3159   wchar_array_type_node
3160     = build_array_type (wchar_type_node, array_domain_type);
3161
3162   default_function_type
3163     = build_function_type (integer_type_node, NULL_TREE);
3164
3165   ptr_type_node = build_pointer_type (void_type_node);
3166   const_ptr_type_node
3167     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
3168
3169   endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
3170
3171   void_ftype_any
3172     = build_function_type (void_type_node, NULL_TREE);
3173
3174   float_ftype_float
3175     = build_function_type (float_type_node,
3176                            tree_cons (NULL_TREE, float_type_node, endlink));
3177
3178   double_ftype_double
3179     = build_function_type (double_type_node,
3180                            tree_cons (NULL_TREE, double_type_node, endlink));
3181
3182   ldouble_ftype_ldouble
3183     = build_function_type (long_double_type_node,
3184                            tree_cons (NULL_TREE, long_double_type_node,
3185                                       endlink));
3186
3187   double_ftype_double_double
3188     = build_function_type (double_type_node,
3189                            tree_cons (NULL_TREE, double_type_node,
3190                                       tree_cons (NULL_TREE,
3191                                                  double_type_node, endlink)));
3192
3193   int_ftype_int
3194     = build_function_type (integer_type_node,
3195                            tree_cons (NULL_TREE, integer_type_node, endlink));
3196
3197   long_ftype_long
3198     = build_function_type (long_integer_type_node,
3199                            tree_cons (NULL_TREE,
3200                                       long_integer_type_node, endlink));
3201
3202   void_ftype_ptr_ptr_int
3203     = build_function_type (void_type_node,
3204                            tree_cons (NULL_TREE, ptr_type_node,
3205                                       tree_cons (NULL_TREE, ptr_type_node,
3206                                                  tree_cons (NULL_TREE,
3207                                                             integer_type_node,
3208                                                             endlink))));
3209
3210   int_ftype_cptr_cptr_sizet
3211     = build_function_type (integer_type_node,
3212                            tree_cons (NULL_TREE, const_ptr_type_node,
3213                                       tree_cons (NULL_TREE, const_ptr_type_node,
3214                                                  tree_cons (NULL_TREE,
3215                                                             sizetype,
3216                                                             endlink))));
3217
3218   void_ftype_ptr_int_int
3219     = build_function_type (void_type_node,
3220                            tree_cons (NULL_TREE, ptr_type_node,
3221                                       tree_cons (NULL_TREE, integer_type_node,
3222                                                  tree_cons (NULL_TREE,
3223                                                             integer_type_node,
3224                                                             endlink))));
3225
3226   string_ftype_ptr_ptr          /* strcpy prototype */
3227     = build_function_type (string_type_node,
3228                            tree_cons (NULL_TREE, string_type_node,
3229                                       tree_cons (NULL_TREE,
3230                                                  const_string_type_node,
3231                                                  endlink)));
3232
3233   int_ftype_string_string       /* strcmp prototype */
3234     = build_function_type (integer_type_node,
3235                            tree_cons (NULL_TREE, const_string_type_node,
3236                                       tree_cons (NULL_TREE,
3237                                                  const_string_type_node,
3238                                                  endlink)));
3239
3240   strlen_ftype          /* strlen prototype */
3241     = build_function_type (flag_traditional ? integer_type_node : sizetype,
3242                            tree_cons (NULL_TREE, const_string_type_node,
3243                                       endlink));
3244
3245   traditional_ptr_type_node
3246     = (flag_traditional ? string_type_node : ptr_type_node);
3247
3248   memcpy_ftype  /* memcpy prototype */
3249     = build_function_type (traditional_ptr_type_node,
3250                            tree_cons (NULL_TREE, ptr_type_node,
3251                                       tree_cons (NULL_TREE, const_ptr_type_node,
3252                                                  tree_cons (NULL_TREE,
3253                                                             sizetype,
3254                                                             endlink))));
3255
3256   memset_ftype  /* memset prototype */
3257     = build_function_type (traditional_ptr_type_node,
3258                            tree_cons (NULL_TREE, ptr_type_node,
3259                                       tree_cons (NULL_TREE, integer_type_node,
3260                                                  tree_cons (NULL_TREE,
3261                                                             sizetype,
3262                                                             endlink))));
3263
3264   ptr_ftype_void = build_function_type (ptr_type_node, endlink);
3265   ptr_ftype_ptr
3266     = build_function_type (ptr_type_node,
3267                            tree_cons (NULL_TREE, ptr_type_node, endlink));
3268
3269   builtin_function ("__builtin_constant_p", default_function_type,
3270                     BUILT_IN_CONSTANT_P, NULL_PTR);
3271
3272   builtin_function ("__builtin_return_address",
3273                     build_function_type (ptr_type_node,
3274                                          tree_cons (NULL_TREE,
3275                                                     unsigned_type_node,
3276                                                     endlink)),
3277                     BUILT_IN_RETURN_ADDRESS, NULL_PTR);
3278
3279   builtin_function ("__builtin_frame_address",
3280                     build_function_type (ptr_type_node,
3281                                          tree_cons (NULL_TREE,
3282                                                     unsigned_type_node,
3283                                                     endlink)),
3284                     BUILT_IN_FRAME_ADDRESS, NULL_PTR);
3285
3286   builtin_function ("__builtin_aggregate_incoming_address",
3287                     build_function_type (ptr_type_node, NULL_TREE),
3288                     BUILT_IN_AGGREGATE_INCOMING_ADDRESS, NULL_PTR);
3289
3290   /* Hooks for the DWARF 2 __throw routine.  */
3291   builtin_function ("__builtin_unwind_init",
3292                     build_function_type (void_type_node, endlink),
3293                     BUILT_IN_UNWIND_INIT, NULL_PTR);
3294   builtin_function ("__builtin_fp", ptr_ftype_void, BUILT_IN_FP, NULL_PTR);
3295   builtin_function ("__builtin_sp", ptr_ftype_void, BUILT_IN_SP, NULL_PTR);
3296   builtin_function ("__builtin_dwarf_fp_regnum",
3297                     build_function_type (unsigned_type_node, endlink),
3298                     BUILT_IN_DWARF_FP_REGNUM, NULL_PTR);
3299   builtin_function ("__builtin_dwarf_reg_size", int_ftype_int,
3300                     BUILT_IN_DWARF_REG_SIZE, NULL_PTR);
3301   builtin_function ("__builtin_frob_return_addr", ptr_ftype_ptr,
3302                     BUILT_IN_FROB_RETURN_ADDR, NULL_PTR);
3303   builtin_function ("__builtin_extract_return_addr", ptr_ftype_ptr,
3304                     BUILT_IN_EXTRACT_RETURN_ADDR, NULL_PTR);
3305   builtin_function ("__builtin_set_return_addr_reg",
3306                     build_function_type (void_type_node,
3307                                          tree_cons (NULL_TREE,
3308                                                     ptr_type_node,
3309                                                     endlink)),
3310                     BUILT_IN_SET_RETURN_ADDR_REG, NULL_PTR);
3311   builtin_function ("__builtin_eh_stub_old", ptr_ftype_void,
3312                     BUILT_IN_EH_STUB_OLD, NULL_PTR);
3313   builtin_function ("__builtin_eh_stub", ptr_ftype_void,
3314                     BUILT_IN_EH_STUB, NULL_PTR);
3315   builtin_function
3316     ("__builtin_set_eh_regs",
3317      build_function_type (void_type_node,
3318                           tree_cons (NULL_TREE, ptr_type_node,
3319                                      tree_cons (NULL_TREE,
3320                                                 type_for_mode (ptr_mode, 0),
3321                                                 endlink))),
3322      BUILT_IN_SET_EH_REGS, NULL_PTR);
3323
3324   builtin_function ("__builtin_alloca",
3325                     build_function_type (ptr_type_node,
3326                                          tree_cons (NULL_TREE,
3327                                                     sizetype,
3328                                                     endlink)),
3329                     BUILT_IN_ALLOCA, "alloca");
3330   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
3331   /* Define alloca, ffs as builtins.
3332      Declare _exit just to mark it as volatile.  */
3333   if (! flag_no_builtin && !flag_no_nonansi_builtin)
3334     {
3335       temp = builtin_function ("alloca",
3336                                build_function_type (ptr_type_node,
3337                                                     tree_cons (NULL_TREE,
3338                                                                sizetype,
3339                                                                endlink)),
3340                                BUILT_IN_ALLOCA, NULL_PTR);
3341       /* Suppress error if redefined as a non-function.  */
3342       DECL_BUILT_IN_NONANSI (temp) = 1;
3343       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
3344       /* Suppress error if redefined as a non-function.  */
3345       DECL_BUILT_IN_NONANSI (temp) = 1;
3346       temp = builtin_function ("_exit", void_ftype_any, NOT_BUILT_IN,
3347                                NULL_PTR);
3348       TREE_THIS_VOLATILE (temp) = 1;
3349       TREE_SIDE_EFFECTS (temp) = 1;
3350       /* Suppress error if redefined as a non-function.  */
3351       DECL_BUILT_IN_NONANSI (temp) = 1;
3352     }
3353
3354   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
3355   builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
3356                     NULL_PTR);
3357   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
3358                     NULL_PTR);
3359   builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3360                     NULL_PTR);
3361   builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
3362                     NULL_PTR);
3363   builtin_function ("__builtin_saveregs",
3364                     build_function_type (ptr_type_node, NULL_TREE),
3365                     BUILT_IN_SAVEREGS, NULL_PTR);
3366 /* EXPAND_BUILTIN_VARARGS is obsolete.  */
3367 #if 0
3368   builtin_function ("__builtin_varargs",
3369                     build_function_type (ptr_type_node,
3370                                          tree_cons (NULL_TREE,
3371                                                     integer_type_node,
3372                                                     endlink)),
3373                     BUILT_IN_VARARGS, NULL_PTR);
3374 #endif
3375   builtin_function ("__builtin_classify_type", default_function_type,
3376                     BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
3377   builtin_function ("__builtin_next_arg",
3378                     build_function_type (ptr_type_node, NULL_TREE),
3379                     BUILT_IN_NEXT_ARG, NULL_PTR);
3380   builtin_function ("__builtin_args_info",
3381                     build_function_type (integer_type_node,
3382                                          tree_cons (NULL_TREE,
3383                                                     integer_type_node,
3384                                                     endlink)),
3385                     BUILT_IN_ARGS_INFO, NULL_PTR);
3386
3387   /* Untyped call and return.  */
3388   builtin_function ("__builtin_apply_args",
3389                     build_function_type (ptr_type_node, NULL_TREE),
3390                     BUILT_IN_APPLY_ARGS, NULL_PTR);
3391
3392   temp = tree_cons (NULL_TREE,
3393                     build_pointer_type (build_function_type (void_type_node,
3394                                                              NULL_TREE)),
3395                     tree_cons (NULL_TREE,
3396                                ptr_type_node,
3397                                tree_cons (NULL_TREE,
3398                                           sizetype,
3399                                           endlink)));
3400   builtin_function ("__builtin_apply",
3401                     build_function_type (ptr_type_node, temp),
3402                     BUILT_IN_APPLY, NULL_PTR);
3403   builtin_function ("__builtin_return",
3404                     build_function_type (void_type_node,
3405                                          tree_cons (NULL_TREE,
3406                                                     ptr_type_node,
3407                                                     endlink)),
3408                     BUILT_IN_RETURN, NULL_PTR);
3409
3410   /* Currently under experimentation.  */
3411   builtin_function ("__builtin_memcpy", memcpy_ftype,
3412                     BUILT_IN_MEMCPY, "memcpy");
3413   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
3414                     BUILT_IN_MEMCMP, "memcmp");
3415   builtin_function ("__builtin_memset", memset_ftype,
3416                     BUILT_IN_MEMSET, "memset");
3417   builtin_function ("__builtin_strcmp", int_ftype_string_string,
3418                     BUILT_IN_STRCMP, "strcmp");
3419   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
3420                     BUILT_IN_STRCPY, "strcpy");
3421   builtin_function ("__builtin_strlen", strlen_ftype,
3422                     BUILT_IN_STRLEN, "strlen");
3423   builtin_function ("__builtin_sqrtf", float_ftype_float,
3424                     BUILT_IN_FSQRT, "sqrtf");
3425   builtin_function ("__builtin_fsqrt", double_ftype_double,
3426                     BUILT_IN_FSQRT, "sqrt");
3427   builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
3428                     BUILT_IN_FSQRT, "sqrtl");
3429   builtin_function ("__builtin_sinf", float_ftype_float,
3430                     BUILT_IN_SIN, "sinf");
3431   builtin_function ("__builtin_sin", double_ftype_double,
3432                     BUILT_IN_SIN, "sin");
3433   builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
3434                     BUILT_IN_SIN, "sinl");
3435   builtin_function ("__builtin_cosf", float_ftype_float,
3436                     BUILT_IN_COS, "cosf");
3437   builtin_function ("__builtin_cos", double_ftype_double,
3438                     BUILT_IN_COS, "cos");
3439   builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
3440                     BUILT_IN_COS, "cosl");
3441   builtin_function ("__builtin_setjmp",
3442                     build_function_type (integer_type_node,
3443                                          tree_cons (NULL_TREE,
3444                                                     ptr_type_node, endlink)),
3445                     BUILT_IN_SETJMP, NULL_PTR);
3446   builtin_function ("__builtin_longjmp",
3447                     build_function_type
3448                     (void_type_node,
3449                      tree_cons (NULL, ptr_type_node,
3450                                 tree_cons (NULL_TREE,
3451                                            integer_type_node,
3452                                            endlink))),
3453                     BUILT_IN_LONGJMP, NULL_PTR);
3454   builtin_function ("__builtin_trap",
3455                     build_function_type (void_type_node, endlink),
3456                     BUILT_IN_TRAP, NULL_PTR);
3457
3458   /* In an ANSI C program, it is okay to supply built-in meanings
3459      for these functions, since applications cannot validly use them
3460      with any other meaning.
3461      However, honor the -fno-builtin option.  */
3462   if (!flag_no_builtin)
3463     {
3464       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
3465       builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR);
3466       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
3467       builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3468                         NULL_PTR);
3469       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
3470       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
3471       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
3472                         NULL_PTR);
3473       builtin_function ("memset", memset_ftype, BUILT_IN_MEMSET, NULL_PTR);
3474       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
3475                         NULL_PTR);
3476       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
3477                         NULL_PTR);
3478       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
3479       builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR);
3480       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
3481       builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
3482                         NULL_PTR);
3483       builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR);
3484       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
3485       builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR);
3486       builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR);
3487       builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
3488       builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR);
3489
3490       /* Declare these functions volatile
3491          to avoid spurious "control drops through" warnings.  */
3492       /* Don't specify the argument types, to avoid errors
3493          from certain code which isn't valid in ANSI but which exists.  */
3494       temp = builtin_function ("abort", void_ftype_any, NOT_BUILT_IN,
3495                                NULL_PTR);
3496       TREE_THIS_VOLATILE (temp) = 1;
3497       TREE_SIDE_EFFECTS (temp) = 1;
3498       temp = builtin_function ("exit", void_ftype_any, NOT_BUILT_IN, NULL_PTR);
3499       TREE_THIS_VOLATILE (temp) = 1;
3500       TREE_SIDE_EFFECTS (temp) = 1;
3501     }
3502
3503 #if 0
3504   /* Support for these has not been written in either expand_builtin
3505      or build_function_call.  */
3506   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
3507   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
3508   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
3509                     NULL_PTR);
3510   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
3511                     NULL_PTR);
3512   builtin_function ("__builtin_fmod", double_ftype_double_double,
3513                     BUILT_IN_FMOD, NULL_PTR);
3514   builtin_function ("__builtin_frem", double_ftype_double_double,
3515                     BUILT_IN_FREM, NULL_PTR);
3516   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
3517                     NULL_PTR);
3518   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
3519                     NULL_PTR);
3520 #endif
3521
3522   pedantic_lvalues = pedantic;
3523
3524   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
3525   declare_function_name ();
3526
3527   start_identifier_warnings ();
3528
3529   /* Prepare to check format strings against argument lists.  */
3530   init_function_format_info ();
3531
3532   init_iterators ();
3533
3534   incomplete_decl_finalize_hook = finish_incomplete_decl;
3535
3536   lang_get_alias_set = &c_get_alias_set;
3537 }
3538
3539 /* Return a definition for a builtin function named NAME and whose data type
3540    is TYPE.  TYPE should be a function type with argument types.
3541    FUNCTION_CODE tells later passes how to compile calls to this function.
3542    See tree.h for its possible values.
3543
3544    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3545    the name to be called if we can't opencode the function.  */
3546
3547 tree
3548 builtin_function (name, type, function_code, library_name)
3549      char *name;
3550      tree type;
3551      enum built_in_function function_code;
3552      char *library_name;
3553 {
3554   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3555   DECL_EXTERNAL (decl) = 1;
3556   TREE_PUBLIC (decl) = 1;
3557   /* If -traditional, permit redefining a builtin function any way you like.
3558      (Though really, if the program redefines these functions,
3559      it probably won't work right unless compiled with -fno-builtin.)  */
3560   if (flag_traditional && name[0] != '_')
3561     DECL_BUILT_IN_NONANSI (decl) = 1;
3562   if (library_name)
3563     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
3564   make_decl_rtl (decl, NULL_PTR, 1);
3565   pushdecl (decl);
3566   if (function_code != NOT_BUILT_IN)
3567     {
3568       DECL_BUILT_IN (decl) = 1;
3569       DECL_FUNCTION_CODE (decl) = function_code;
3570     }
3571   /* Warn if a function in the namespace for users
3572      is used without an occasion to consider it declared.  */
3573   if (name[0] != '_' || name[1] != '_')
3574     C_DECL_ANTICIPATED (decl) = 1;
3575
3576   return decl;
3577 }
3578 \f
3579 /* Called when a declaration is seen that contains no names to declare.
3580    If its type is a reference to a structure, union or enum inherited
3581    from a containing scope, shadow that tag name for the current scope
3582    with a forward reference.
3583    If its type defines a new named structure or union
3584    or defines an enum, it is valid but we need not do anything here.
3585    Otherwise, it is an error.  */
3586
3587 void
3588 shadow_tag (declspecs)
3589      tree declspecs;
3590 {
3591   shadow_tag_warned (declspecs, 0);
3592 }
3593
3594 void
3595 shadow_tag_warned (declspecs, warned)
3596      tree declspecs;
3597      int warned;
3598      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
3599         no pedwarn.  */
3600 {
3601   int found_tag = 0;
3602   register tree link;
3603   tree specs, attrs;
3604
3605   pending_invalid_xref = 0;
3606
3607   /* Remove the attributes from declspecs, since they will confuse the
3608      following code.  */
3609   split_specs_attrs (declspecs, &specs, &attrs);
3610
3611   for (link = specs; link; link = TREE_CHAIN (link))
3612     {
3613       register tree value = TREE_VALUE (link);
3614       register enum tree_code code = TREE_CODE (value);
3615
3616       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3617         /* Used to test also that TYPE_SIZE (value) != 0.
3618            That caused warning for `struct foo;' at top level in the file.  */
3619         {
3620           register tree name = lookup_tag_reverse (value);
3621           register tree t;
3622
3623           found_tag++;
3624
3625           if (name == 0)
3626             {
3627               if (warned != 1 && code != ENUMERAL_TYPE)
3628                 /* Empty unnamed enum OK */
3629                 {
3630                   pedwarn ("unnamed struct/union that defines no instances");
3631                   warned = 1;
3632                 }
3633             }
3634           else
3635             {
3636               t = lookup_tag (code, name, current_binding_level, 1);
3637
3638               if (t == 0)
3639                 {
3640                   t = make_node (code);
3641                   pushtag (name, t);
3642                 }
3643             }
3644         }
3645       else
3646         {
3647           if (!warned && ! in_system_header)
3648             {
3649               warning ("useless keyword or type name in empty declaration");
3650               warned = 2;
3651             }
3652         }
3653     }
3654
3655   if (found_tag > 1)
3656     error ("two types specified in one empty declaration");
3657
3658   if (warned != 1)
3659     {
3660       if (found_tag == 0)
3661         pedwarn ("empty declaration");
3662     }
3663 }
3664 \f
3665 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3666
3667 tree
3668 groktypename (typename)
3669      tree typename;
3670 {
3671   if (TREE_CODE (typename) != TREE_LIST)
3672     return typename;
3673   return grokdeclarator (TREE_VALUE (typename),
3674                          TREE_PURPOSE (typename),
3675                          TYPENAME, 0);
3676 }
3677
3678 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
3679
3680 tree
3681 groktypename_in_parm_context (typename)
3682      tree typename;
3683 {
3684   if (TREE_CODE (typename) != TREE_LIST)
3685     return typename;
3686   return grokdeclarator (TREE_VALUE (typename),
3687                          TREE_PURPOSE (typename),
3688                          PARM, 0);
3689 }
3690
3691 /* Decode a declarator in an ordinary declaration or data definition.
3692    This is called as soon as the type information and variable name
3693    have been parsed, before parsing the initializer if any.
3694    Here we create the ..._DECL node, fill in its type,
3695    and put it on the list of decls for the current context.
3696    The ..._DECL node is returned as the value.
3697
3698    Exception: for arrays where the length is not specified,
3699    the type is left null, to be filled in by `finish_decl'.
3700
3701    Function definitions do not come here; they go to start_function
3702    instead.  However, external and forward declarations of functions
3703    do go through here.  Structure field declarations are done by
3704    grokfield and not through here.  */
3705
3706 /* Set this to zero to debug not using the temporary obstack
3707    to parse initializers.  */
3708 int debug_temp_inits = 1;
3709
3710 tree
3711 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
3712      tree declarator, declspecs;
3713      int initialized;
3714      tree attributes, prefix_attributes;
3715 {
3716   register tree decl = grokdeclarator (declarator, declspecs,
3717                                        NORMAL, initialized);
3718   register tree tem;
3719   int init_written = initialized;
3720
3721   /* The corresponding pop_obstacks is in finish_decl.  */
3722   push_obstacks_nochange ();
3723
3724   if (warn_main && TREE_CODE (decl) != FUNCTION_DECL
3725       && !strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "main"))
3726     warning_with_decl (decl, "`%s' is usually a function");
3727
3728   if (initialized)
3729     /* Is it valid for this decl to have an initializer at all?
3730        If not, set INITIALIZED to zero, which will indirectly
3731        tell `finish_decl' to ignore the initializer once it is parsed.  */
3732     switch (TREE_CODE (decl))
3733       {
3734       case TYPE_DECL:
3735         /* typedef foo = bar  means give foo the same type as bar.
3736            We haven't parsed bar yet, so `finish_decl' will fix that up.
3737            Any other case of an initialization in a TYPE_DECL is an error.  */
3738         if (pedantic || list_length (declspecs) > 1)
3739           {
3740             error ("typedef `%s' is initialized",
3741                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3742             initialized = 0;
3743           }
3744         break;
3745
3746       case FUNCTION_DECL:
3747         error ("function `%s' is initialized like a variable",
3748                IDENTIFIER_POINTER (DECL_NAME (decl)));
3749         initialized = 0;
3750         break;
3751
3752       case PARM_DECL:
3753         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
3754         error ("parameter `%s' is initialized",
3755                IDENTIFIER_POINTER (DECL_NAME (decl)));
3756         initialized = 0;
3757         break;
3758
3759       default:
3760         /* Don't allow initializations for incomplete types
3761            except for arrays which might be completed by the initialization.  */
3762         if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
3763           {
3764             /* A complete type is ok if size is fixed.  */
3765
3766             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3767                 || C_DECL_VARIABLE_SIZE (decl))
3768               {
3769                 error ("variable-sized object may not be initialized");
3770                 initialized = 0;
3771               }
3772           }
3773         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3774           {
3775             error ("variable `%s' has initializer but incomplete type",
3776                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3777             initialized = 0;
3778           }
3779         else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
3780           {
3781             error ("elements of array `%s' have incomplete type",
3782                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3783             initialized = 0;
3784           }
3785       }
3786
3787   if (initialized)
3788     {
3789 #if 0  /* Seems redundant with grokdeclarator.  */
3790       if (current_binding_level != global_binding_level
3791           && DECL_EXTERNAL (decl)
3792           && TREE_CODE (decl) != FUNCTION_DECL)
3793         warning ("declaration of `%s' has `extern' and is initialized",
3794                  IDENTIFIER_POINTER (DECL_NAME (decl)));
3795 #endif
3796       DECL_EXTERNAL (decl) = 0;
3797       if (current_binding_level == global_binding_level)
3798         TREE_STATIC (decl) = 1;
3799
3800       /* Tell `pushdecl' this is an initialized decl
3801          even though we don't yet have the initializer expression.
3802          Also tell `finish_decl' it may store the real initializer.  */
3803       DECL_INITIAL (decl) = error_mark_node;
3804     }
3805
3806   /* If this is a function declaration, write a record describing it to the
3807      prototypes file (if requested).  */
3808
3809   if (TREE_CODE (decl) == FUNCTION_DECL)
3810     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3811
3812   /* ANSI specifies that a tentative definition which is not merged with
3813      a non-tentative definition behaves exactly like a definition with an
3814      initializer equal to zero.  (Section 3.7.2)
3815      -fno-common gives strict ANSI behavior.  Usually you don't want it.
3816      This matters only for variables with external linkage.  */
3817   if (! flag_no_common || ! TREE_PUBLIC (decl))
3818     DECL_COMMON (decl) = 1;
3819
3820 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
3821   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
3822 #endif
3823
3824   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3825   decl_attributes (decl, attributes, prefix_attributes);
3826
3827   /* Add this decl to the current binding level.
3828      TEM may equal DECL or it may be a previous decl of the same name.  */
3829   tem = pushdecl (decl);
3830
3831   /* For a local variable, define the RTL now.  */
3832   if (current_binding_level != global_binding_level
3833       /* But not if this is a duplicate decl
3834          and we preserved the rtl from the previous one
3835          (which may or may not happen).  */
3836       && DECL_RTL (tem) == 0)
3837     {
3838       if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
3839         expand_decl (tem);
3840       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3841                && DECL_INITIAL (tem) != 0)
3842         expand_decl (tem);
3843     }
3844
3845   if (init_written)
3846     {
3847       /* When parsing and digesting the initializer,
3848          use temporary storage.  Do this even if we will ignore the value.  */
3849       if (current_binding_level == global_binding_level && debug_temp_inits)
3850         temporary_allocation ();
3851     }
3852
3853   return tem;
3854 }
3855
3856 /* Finish processing of a declaration;
3857    install its initial value.
3858    If the length of an array type is not known before,
3859    it must be determined now, from the initial value, or it is an error.  */
3860
3861 void
3862 finish_decl (decl, init, asmspec_tree)
3863      tree decl, init;
3864      tree asmspec_tree;
3865 {
3866   register tree type = TREE_TYPE (decl);
3867   int was_incomplete = (DECL_SIZE (decl) == 0);
3868   int temporary = allocation_temporary_p ();
3869   char *asmspec = 0;
3870
3871   /* If a name was specified, get the string.   */
3872   if (asmspec_tree)
3873     asmspec = TREE_STRING_POINTER (asmspec_tree);
3874
3875   /* If `start_decl' didn't like having an initialization, ignore it now.  */
3876
3877   if (init != 0 && DECL_INITIAL (decl) == 0)
3878     init = 0;
3879   /* Don't crash if parm is initialized.  */
3880   if (TREE_CODE (decl) == PARM_DECL)
3881     init = 0;
3882
3883   if (ITERATOR_P (decl))
3884     {
3885       if (init == 0)
3886         error_with_decl (decl, "iterator has no initial value");
3887       else
3888         init = save_expr (init);
3889     }
3890
3891   if (init)
3892     {
3893       if (TREE_CODE (decl) != TYPE_DECL)
3894         store_init_value (decl, init);
3895       else
3896         {
3897           /* typedef foo = bar; store the type of bar as the type of foo.  */
3898           TREE_TYPE (decl) = TREE_TYPE (init);
3899           DECL_INITIAL (decl) = init = 0;
3900         }
3901     }
3902
3903   /* Pop back to the obstack that is current for this binding level.
3904      This is because MAXINDEX, rtl, etc. to be made below
3905      must go in the permanent obstack.  But don't discard the
3906      temporary data yet.  */
3907   pop_obstacks ();
3908 #if 0 /* pop_obstacks was near the end; this is what was here.  */
3909   if (current_binding_level == global_binding_level && temporary)
3910     end_temporary_allocation ();
3911 #endif
3912
3913   /* Deduce size of array from initialization, if not already known */
3914
3915   if (TREE_CODE (type) == ARRAY_TYPE
3916       && TYPE_DOMAIN (type) == 0
3917       && TREE_CODE (decl) != TYPE_DECL)
3918     {
3919       int do_default
3920         = (TREE_STATIC (decl)
3921            /* Even if pedantic, an external linkage array
3922               may have incomplete type at first.  */
3923            ? pedantic && !TREE_PUBLIC (decl)
3924            : !DECL_EXTERNAL (decl));
3925       int failure
3926         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3927
3928       /* Get the completed type made by complete_array_type.  */
3929       type = TREE_TYPE (decl);
3930
3931       if (failure == 1)
3932         error_with_decl (decl, "initializer fails to determine size of `%s'");
3933
3934       if (failure == 2)
3935         {
3936           if (do_default)
3937             error_with_decl (decl, "array size missing in `%s'");
3938           /* If a `static' var's size isn't known,
3939              make it extern as well as static, so it does not get
3940              allocated.
3941              If it is not `static', then do not mark extern;
3942              finish_incomplete_decl will give it a default size
3943              and it will get allocated.  */
3944           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3945             DECL_EXTERNAL (decl) = 1;
3946         }
3947
3948       /* TYPE_MAX_VALUE is always one less than the number of elements
3949          in the array, because we start counting at zero.  Therefore,
3950          warn only if the value is less than zero.  */
3951       if (pedantic && TYPE_DOMAIN (type) != 0
3952           && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3953         error_with_decl (decl, "zero or negative size array `%s'");
3954
3955       layout_decl (decl, 0);
3956     }
3957
3958   if (TREE_CODE (decl) == VAR_DECL)
3959     {
3960       if (DECL_SIZE (decl) == 0
3961           && TYPE_SIZE (TREE_TYPE (decl)) != 0)
3962         layout_decl (decl, 0);
3963
3964       if (DECL_SIZE (decl) == 0
3965           && (TREE_STATIC (decl)
3966               ?
3967                 /* A static variable with an incomplete type
3968                    is an error if it is initialized.
3969                    Also if it is not file scope.
3970                    Otherwise, let it through, but if it is not `extern'
3971                    then it may cause an error message later.  */
3972               /* A duplicate_decls call could have changed an extern
3973                  declaration into a file scope one.  This can be detected
3974                  by TREE_ASM_WRITTEN being set.  */
3975                 (DECL_INITIAL (decl) != 0
3976                  || (DECL_CONTEXT (decl) != 0 && ! TREE_ASM_WRITTEN (decl)))
3977               :
3978                 /* An automatic variable with an incomplete type
3979                    is an error.  */
3980                 !DECL_EXTERNAL (decl)))
3981         {
3982           error_with_decl (decl, "storage size of `%s' isn't known");
3983           TREE_TYPE (decl) = error_mark_node;
3984         }
3985
3986       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3987           && DECL_SIZE (decl) != 0)
3988         {
3989           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3990             constant_expression_warning (DECL_SIZE (decl));
3991           else
3992             error_with_decl (decl, "storage size of `%s' isn't constant");
3993         }
3994
3995       if (TREE_USED  (type))
3996         TREE_USED (decl) = 1;
3997     }
3998
3999   /* If this is a function and an assembler name is specified, it isn't
4000      builtin any more.  Also reset DECL_RTL so we can give it its new
4001      name.  */
4002   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
4003       {
4004         DECL_BUILT_IN (decl) = 0;
4005         DECL_RTL (decl) = 0;
4006       }
4007
4008   /* Output the assembler code and/or RTL code for variables and functions,
4009      unless the type is an undefined structure or union.
4010      If not, it will get done when the type is completed.  */
4011
4012   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4013     {
4014       if ((flag_traditional || TREE_PERMANENT (decl))
4015           && allocation_temporary_p ())
4016         {
4017           push_obstacks_nochange ();
4018           end_temporary_allocation ();
4019           /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
4020           maybe_objc_check_decl (decl);
4021           rest_of_decl_compilation (decl, asmspec,
4022                                     (DECL_CONTEXT (decl) == 0
4023                                      || TREE_ASM_WRITTEN (decl)),
4024                                     0);
4025           pop_obstacks ();
4026         }
4027       else
4028         {
4029           /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
4030           maybe_objc_check_decl (decl);
4031           rest_of_decl_compilation (decl, asmspec, DECL_CONTEXT (decl) == 0,
4032                                     0);
4033         }
4034       if (DECL_CONTEXT (decl) != 0)
4035         {
4036           /* Recompute the RTL of a local array now
4037              if it used to be an incomplete type.  */
4038           if (was_incomplete
4039               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
4040             {
4041               /* If we used it already as memory, it must stay in memory.  */
4042               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4043               /* If it's still incomplete now, no init will save it.  */
4044               if (DECL_SIZE (decl) == 0)
4045                 DECL_INITIAL (decl) = 0;
4046               expand_decl (decl);
4047             }
4048           /* Compute and store the initial value.  */
4049           if (TREE_CODE (decl) != FUNCTION_DECL)
4050             expand_decl_init (decl);
4051         }
4052     }
4053
4054   if (TREE_CODE (decl) == TYPE_DECL)
4055     {
4056       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
4057       maybe_objc_check_decl (decl);
4058       rest_of_decl_compilation (decl, NULL_PTR, DECL_CONTEXT (decl) == 0,
4059                                 0);
4060     }
4061
4062   /* ??? After 2.3, test (init != 0) instead of TREE_CODE.  */
4063   /* This test used to include TREE_PERMANENT, however, we have the same
4064      problem with initializers at the function level.  Such initializers get
4065      saved until the end of the function on the momentary_obstack.  */
4066   if (!(TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
4067       && temporary
4068       /* DECL_INITIAL is not defined in PARM_DECLs, since it shares
4069          space with DECL_ARG_TYPE.  */
4070       && TREE_CODE (decl) != PARM_DECL)
4071     {
4072       /* We need to remember that this array HAD an initialization,
4073          but discard the actual temporary nodes,
4074          since we can't have a permanent node keep pointing to them.  */
4075       /* We make an exception for inline functions, since it's
4076          normal for a local extern redeclaration of an inline function
4077          to have a copy of the top-level decl's DECL_INLINE.  */
4078       if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
4079         {
4080           /* If this is a const variable, then preserve the
4081              initializer instead of discarding it so that we can optimize
4082              references to it.  */
4083           /* This test used to include TREE_STATIC, but this won't be set
4084              for function level initializers.  */
4085           if (TREE_READONLY (decl) || ITERATOR_P (decl))
4086             {
4087               preserve_initializer ();
4088               /* Hack?  Set the permanent bit for something that is permanent,
4089                  but not on the permanent obstack, so as to convince
4090                  output_constant_def to make its rtl on the permanent
4091                  obstack.  */
4092               TREE_PERMANENT (DECL_INITIAL (decl)) = 1;
4093
4094               /* The initializer and DECL must have the same (or equivalent
4095                  types), but if the initializer is a STRING_CST, its type
4096                  might not be on the right obstack, so copy the type
4097                  of DECL.  */
4098               TREE_TYPE (DECL_INITIAL (decl)) = type;
4099             }
4100           else
4101             DECL_INITIAL (decl) = error_mark_node;
4102         }
4103     }
4104
4105   /* If requested, warn about definitions of large data objects.  */
4106
4107   if (warn_larger_than
4108       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
4109       && !DECL_EXTERNAL (decl))
4110     {
4111       register tree decl_size = DECL_SIZE (decl);
4112
4113       if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
4114         {
4115            unsigned units = TREE_INT_CST_LOW(decl_size) / BITS_PER_UNIT;
4116
4117           if (units > larger_than_size)
4118             warning_with_decl (decl, "size of `%s' is %u bytes", units);
4119         }
4120     }
4121
4122 #if 0
4123   /* Resume permanent allocation, if not within a function.  */
4124   /* The corresponding push_obstacks_nochange is in start_decl,
4125      and in push_parm_decl and in grokfield.  */
4126   pop_obstacks ();
4127 #endif
4128
4129   /* If we have gone back from temporary to permanent allocation,
4130      actually free the temporary space that we no longer need.  */
4131   if (temporary && !allocation_temporary_p ())
4132     permanent_allocation (0);
4133
4134   /* At the end of a declaration, throw away any variable type sizes
4135      of types defined inside that declaration.  There is no use
4136      computing them in the following function definition.  */
4137   if (current_binding_level == global_binding_level)
4138     get_pending_sizes ();
4139 }
4140
4141 /* If DECL has a cleanup, build and return that cleanup here.
4142    This is a callback called by expand_expr.  */
4143
4144 tree
4145 maybe_build_cleanup (decl)
4146      tree decl ATTRIBUTE_UNUSED;
4147 {
4148   /* There are no cleanups in C.  */
4149   return NULL_TREE;
4150 }
4151
4152 /* Given a parsed parameter declaration,
4153    decode it into a PARM_DECL and push that on the current binding level.
4154    Also, for the sake of forward parm decls,
4155    record the given order of parms in `parm_order'.  */
4156
4157 void
4158 push_parm_decl (parm)
4159      tree parm;
4160 {
4161   tree decl;
4162   int old_immediate_size_expand = immediate_size_expand;
4163   /* Don't try computing parm sizes now -- wait till fn is called.  */
4164   immediate_size_expand = 0;
4165
4166   /* The corresponding pop_obstacks is in finish_decl.  */
4167   push_obstacks_nochange ();
4168
4169   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
4170                          TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
4171   decl_attributes (decl, TREE_VALUE (TREE_VALUE (parm)),
4172                    TREE_PURPOSE (TREE_VALUE (parm)));
4173
4174 #if 0
4175   if (DECL_NAME (decl))
4176     {
4177       tree olddecl;
4178       olddecl = lookup_name (DECL_NAME (decl));
4179       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
4180         pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef");
4181     }
4182 #endif
4183
4184   decl = pushdecl (decl);
4185
4186   immediate_size_expand = old_immediate_size_expand;
4187
4188   current_binding_level->parm_order
4189     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
4190
4191   /* Add this decl to the current binding level.  */
4192   finish_decl (decl, NULL_TREE, NULL_TREE);
4193 }
4194
4195 /* Clear the given order of parms in `parm_order'.
4196    Used at start of parm list,
4197    and also at semicolon terminating forward decls.  */
4198
4199 void
4200 clear_parm_order ()
4201 {
4202   current_binding_level->parm_order = NULL_TREE;
4203 }
4204 \f
4205 /* Make TYPE a complete type based on INITIAL_VALUE.
4206    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
4207    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
4208
4209 int
4210 complete_array_type (type, initial_value, do_default)
4211      tree type;
4212      tree initial_value;
4213      int do_default;
4214 {
4215   register tree maxindex = NULL_TREE;
4216   int value = 0;
4217
4218   if (initial_value)
4219     {
4220       /* Note MAXINDEX  is really the maximum index,
4221          one less than the size.  */
4222       if (TREE_CODE (initial_value) == STRING_CST)
4223         {
4224           int eltsize
4225             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
4226           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
4227                                    / eltsize) - 1, 0);
4228         }
4229       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
4230         {
4231           tree elts = CONSTRUCTOR_ELTS (initial_value);
4232           maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
4233           for (; elts; elts = TREE_CHAIN (elts))
4234             {
4235               if (TREE_PURPOSE (elts))
4236                 maxindex = TREE_PURPOSE (elts);
4237               else
4238                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
4239             }
4240           maxindex = copy_node (maxindex);
4241         }
4242       else
4243         {
4244           /* Make an error message unless that happened already.  */
4245           if (initial_value != error_mark_node)
4246             value = 1;
4247
4248           /* Prevent further error messages.  */
4249           maxindex = build_int_2 (0, 0);
4250         }
4251     }
4252
4253   if (!maxindex)
4254     {
4255       if (do_default)
4256         maxindex = build_int_2 (0, 0);
4257       value = 2;
4258     }
4259
4260   if (maxindex)
4261     {
4262       TYPE_DOMAIN (type) = build_index_type (maxindex);
4263       if (!TREE_TYPE (maxindex))
4264         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
4265     }
4266
4267   /* Lay out the type now that we can get the real answer.  */
4268
4269   layout_type (type);
4270
4271   return value;
4272 }
4273 \f
4274 /* Given declspecs and a declarator,
4275    determine the name and type of the object declared
4276    and construct a ..._DECL node for it.
4277    (In one case we can return a ..._TYPE node instead.
4278     For invalid input we sometimes return 0.)
4279
4280    DECLSPECS is a chain of tree_list nodes whose value fields
4281     are the storage classes and type specifiers.
4282
4283    DECL_CONTEXT says which syntactic context this declaration is in:
4284      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4285      FUNCDEF for a function definition.  Like NORMAL but a few different
4286       error messages in each case.  Return value may be zero meaning
4287       this definition is too screwy to try to parse.
4288      PARM for a parameter declaration (either within a function prototype
4289       or before a function body).  Make a PARM_DECL, or return void_type_node.
4290      TYPENAME if for a typename (in a cast or sizeof).
4291       Don't make a DECL node; just return the ..._TYPE node.
4292      FIELD for a struct or union field; make a FIELD_DECL.
4293      BITFIELD for a field with specified width.
4294    INITIALIZED is 1 if the decl has an initializer.
4295
4296    In the TYPENAME case, DECLARATOR is really an absolute declarator.
4297    It may also be so in the PARM case, for a prototype where the
4298    argument type is specified but not the name.
4299
4300    This function is where the complicated C meanings of `static'
4301    and `extern' are interpreted.  */
4302
4303 static tree
4304 grokdeclarator (declarator, declspecs, decl_context, initialized)
4305      tree declspecs;
4306      tree declarator;
4307      enum decl_context decl_context;
4308      int initialized;
4309 {
4310   int specbits = 0;
4311   tree spec;
4312   tree type = NULL_TREE;
4313   int longlong = 0;
4314   int constp;
4315   int volatilep;
4316   int inlinep;
4317   int explicit_int = 0;
4318   int explicit_char = 0;
4319   int defaulted_int = 0;
4320   tree typedef_decl = 0;
4321   char *name;
4322   tree typedef_type = 0;
4323   int funcdef_flag = 0;
4324   enum tree_code innermost_code = ERROR_MARK;
4325   int bitfield = 0;
4326   int size_varies = 0;
4327   tree decl_machine_attr = NULL_TREE;
4328
4329   if (decl_context == BITFIELD)
4330     bitfield = 1, decl_context = FIELD;
4331
4332   if (decl_context == FUNCDEF)
4333     funcdef_flag = 1, decl_context = NORMAL;
4334
4335   push_obstacks_nochange ();
4336
4337   if (flag_traditional && allocation_temporary_p ())
4338     end_temporary_allocation ();
4339
4340   /* Look inside a declarator for the name being declared
4341      and get it as a string, for an error message.  */
4342   {
4343     register tree decl = declarator;
4344     name = 0;
4345
4346     while (decl)
4347       switch (TREE_CODE (decl))
4348         {
4349         case ARRAY_REF:
4350         case INDIRECT_REF:
4351         case CALL_EXPR:
4352           innermost_code = TREE_CODE (decl);
4353           decl = TREE_OPERAND (decl, 0);
4354           break;
4355
4356         case IDENTIFIER_NODE:
4357           name = IDENTIFIER_POINTER (decl);
4358           decl = 0;
4359           break;
4360
4361         default:
4362           abort ();
4363         }
4364     if (name == 0)
4365       name = "type name";
4366   }
4367
4368   /* A function definition's declarator must have the form of
4369      a function declarator.  */
4370
4371   if (funcdef_flag && innermost_code != CALL_EXPR)
4372     return 0;
4373
4374   /* Anything declared one level down from the top level
4375      must be one of the parameters of a function
4376      (because the body is at least two levels down).  */
4377
4378   /* If this looks like a function definition, make it one,
4379      even if it occurs where parms are expected.
4380      Then store_parm_decls will reject it and not use it as a parm.  */
4381   if (decl_context == NORMAL && !funcdef_flag
4382       && current_binding_level->parm_flag)
4383     decl_context = PARM;
4384
4385   /* Look through the decl specs and record which ones appear.
4386      Some typespecs are defined as built-in typenames.
4387      Others, the ones that are modifiers of other types,
4388      are represented by bits in SPECBITS: set the bits for
4389      the modifiers that appear.  Storage class keywords are also in SPECBITS.
4390
4391      If there is a typedef name or a type, store the type in TYPE.
4392      This includes builtin typedefs such as `int'.
4393
4394      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
4395      and did not come from a user typedef.
4396
4397      Set LONGLONG if `long' is mentioned twice.  */
4398
4399   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
4400     {
4401       register int i;
4402       register tree id = TREE_VALUE (spec);
4403
4404       if (id == ridpointers[(int) RID_INT])
4405         explicit_int = 1;
4406       if (id == ridpointers[(int) RID_CHAR])
4407         explicit_char = 1;
4408
4409       if (TREE_CODE (id) == IDENTIFIER_NODE)
4410         for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
4411           {
4412             if (ridpointers[i] == id)
4413               {
4414                 if (i == (int) RID_LONG && specbits & (1<<i))
4415                   {
4416                     if (longlong)
4417                       error ("`long long long' is too long for GCC");
4418                     else
4419                       {
4420                         if (pedantic && ! in_system_header && warn_long_long)
4421                           pedwarn ("ANSI C does not support `long long'");
4422                         longlong = 1;
4423                       }
4424                   }
4425                 else if (specbits & (1 << i))
4426                   pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
4427                 specbits |= 1 << i;
4428                 goto found;
4429               }
4430           }
4431       if (type)
4432         error ("two or more data types in declaration of `%s'", name);
4433       /* Actual typedefs come to us as TYPE_DECL nodes.  */
4434       else if (TREE_CODE (id) == TYPE_DECL)
4435         {
4436           type = TREE_TYPE (id);
4437           decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
4438           typedef_decl = id;
4439         }
4440       /* Built-in types come as identifiers.  */
4441       else if (TREE_CODE (id) == IDENTIFIER_NODE)
4442         {
4443           register tree t = lookup_name (id);
4444           if (TREE_TYPE (t) == error_mark_node)
4445             ;
4446           else if (!t || TREE_CODE (t) != TYPE_DECL)
4447             error ("`%s' fails to be a typedef or built in type",
4448                    IDENTIFIER_POINTER (id));
4449           else
4450             {
4451               type = TREE_TYPE (t);
4452               typedef_decl = t;
4453             }
4454         }
4455       else if (TREE_CODE (id) != ERROR_MARK)
4456         type = id;
4457
4458     found: {}
4459     }
4460
4461   typedef_type = type;
4462   if (type)
4463     size_varies = C_TYPE_VARIABLE_SIZE (type);
4464
4465   /* No type at all: default to `int', and set DEFAULTED_INT
4466      because it was not a user-defined typedef.  */
4467
4468   if (type == 0)
4469     {
4470       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4471                           | (1 << (int) RID_SIGNED)
4472                           | (1 << (int) RID_UNSIGNED))))
4473           /* Don't warn about typedef foo = bar.  */
4474           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
4475           && ! (in_system_header && ! allocation_temporary_p ()))
4476         {
4477           /* C9x will probably require a diagnostic here.
4478              For now, issue a warning if -Wreturn-type and this is a function,
4479              or if -Wimplicit; prefer the former warning since it is more
4480              explicit.  */
4481           if ((warn_implicit_int || warn_return_type) && funcdef_flag)
4482             warn_about_return_type = 1;
4483           else if (warn_implicit_int)
4484             warning ("type defaults to `int' in declaration of `%s'", name);
4485         }
4486
4487       defaulted_int = 1;
4488       type = integer_type_node;
4489     }
4490
4491   /* Now process the modifiers that were specified
4492      and check for invalid combinations.  */
4493
4494   /* Long double is a special combination.  */
4495
4496   if ((specbits & 1 << (int) RID_LONG) && ! longlong
4497       && TYPE_MAIN_VARIANT (type) == double_type_node)
4498     {
4499       specbits &= ~ (1 << (int) RID_LONG);
4500       type = long_double_type_node;
4501     }
4502
4503   /* Check all other uses of type modifiers.  */
4504
4505   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4506                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4507     {
4508       int ok = 0;
4509
4510       if ((specbits & 1 << (int) RID_LONG)
4511           && (specbits & 1 << (int) RID_SHORT))
4512         error ("both long and short specified for `%s'", name);
4513       else if (((specbits & 1 << (int) RID_LONG)
4514                 || (specbits & 1 << (int) RID_SHORT))
4515                && explicit_char)
4516         error ("long or short specified with char for `%s'", name);
4517       else if (((specbits & 1 << (int) RID_LONG)
4518                 || (specbits & 1 << (int) RID_SHORT))
4519                && TREE_CODE (type) == REAL_TYPE)
4520         {
4521           static int already = 0;
4522
4523           error ("long or short specified with floating type for `%s'", name);
4524           if (! already && ! pedantic)
4525             {
4526               error ("the only valid combination is `long double'");
4527               already = 1;
4528             }
4529         }
4530       else if ((specbits & 1 << (int) RID_SIGNED)
4531                && (specbits & 1 << (int) RID_UNSIGNED))
4532         error ("both signed and unsigned specified for `%s'", name);
4533       else if (TREE_CODE (type) != INTEGER_TYPE)
4534         error ("long, short, signed or unsigned invalid for `%s'", name);
4535       else
4536         {
4537           ok = 1;
4538           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4539             {
4540               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4541                        name);
4542               if (flag_pedantic_errors)
4543                 ok = 0;
4544             }
4545         }
4546
4547       /* Discard the type modifiers if they are invalid.  */
4548       if (! ok)
4549         {
4550           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4551                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4552           longlong = 0;
4553         }
4554     }
4555
4556   if ((specbits & (1 << (int) RID_COMPLEX))
4557       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4558     {
4559       error ("complex invalid for `%s'", name);
4560       specbits &= ~ (1 << (int) RID_COMPLEX);
4561     }
4562
4563   /* Decide whether an integer type is signed or not.
4564      Optionally treat bitfields as signed by default.  */
4565   if (specbits & 1 << (int) RID_UNSIGNED
4566       /* Traditionally, all bitfields are unsigned.  */
4567       || (bitfield && flag_traditional
4568           && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
4569       || (bitfield && ! flag_signed_bitfields
4570           && (explicit_int || defaulted_int || explicit_char
4571               /* A typedef for plain `int' without `signed'
4572                  can be controlled just like plain `int'.  */
4573               || ! (typedef_decl != 0
4574                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4575           && TREE_CODE (type) != ENUMERAL_TYPE
4576           && !(specbits & 1 << (int) RID_SIGNED)))
4577     {
4578       if (longlong)
4579         type = long_long_unsigned_type_node;
4580       else if (specbits & 1 << (int) RID_LONG)
4581         type = long_unsigned_type_node;
4582       else if (specbits & 1 << (int) RID_SHORT)
4583         type = short_unsigned_type_node;
4584       else if (type == char_type_node)
4585         type = unsigned_char_type_node;
4586       else if (typedef_decl)
4587         type = unsigned_type (type);
4588       else
4589         type = unsigned_type_node;
4590     }
4591   else if ((specbits & 1 << (int) RID_SIGNED)
4592            && type == char_type_node)
4593     type = signed_char_type_node;
4594   else if (longlong)
4595     type = long_long_integer_type_node;
4596   else if (specbits & 1 << (int) RID_LONG)
4597     type = long_integer_type_node;
4598   else if (specbits & 1 << (int) RID_SHORT)
4599     type = short_integer_type_node;
4600
4601   if (specbits & 1 << (int) RID_COMPLEX)
4602     {
4603       /* If we just have "complex", it is equivalent to
4604          "complex double", but if any modifiers at all are specified it is
4605          the complex form of TYPE.  E.g, "complex short" is
4606          "complex short int".  */
4607
4608       if (defaulted_int && ! longlong
4609           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4610                             | (1 << (int) RID_SIGNED)
4611                             | (1 << (int) RID_UNSIGNED))))
4612         type = complex_double_type_node;
4613       else if (type == integer_type_node)
4614         type = complex_integer_type_node;
4615       else if (type == float_type_node)
4616         type = complex_float_type_node;
4617       else if (type == double_type_node)
4618         type = complex_double_type_node;
4619       else if (type == long_double_type_node)
4620         type = complex_long_double_type_node;
4621       else
4622         type = build_complex_type (type);
4623     }
4624
4625   /* Set CONSTP if this declaration is `const', whether by
4626      explicit specification or via a typedef.
4627      Likewise for VOLATILEP.  */
4628
4629   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4630   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4631   inlinep = !! (specbits & (1 << (int) RID_INLINE));
4632   if (constp > 1)
4633     pedwarn ("duplicate `const'");
4634   if (volatilep > 1)
4635     pedwarn ("duplicate `volatile'");
4636   if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
4637     type = TYPE_MAIN_VARIANT (type);
4638
4639   /* Warn if two storage classes are given. Default to `auto'.  */
4640
4641   {
4642     int nclasses = 0;
4643
4644     if (specbits & 1 << (int) RID_AUTO) nclasses++;
4645     if (specbits & 1 << (int) RID_STATIC) nclasses++;
4646     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4647     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4648     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4649     if (specbits & 1 << (int) RID_ITERATOR) nclasses++;
4650
4651     /* Warn about storage classes that are invalid for certain
4652        kinds of declarations (parameters, typenames, etc.).  */
4653
4654     if (nclasses > 1)
4655       error ("multiple storage classes in declaration of `%s'", name);
4656     else if (funcdef_flag
4657              && (specbits
4658                  & ((1 << (int) RID_REGISTER)
4659                     | (1 << (int) RID_AUTO)
4660                     | (1 << (int) RID_TYPEDEF))))
4661       {
4662         if (specbits & 1 << (int) RID_AUTO
4663             && (pedantic || current_binding_level == global_binding_level))
4664           pedwarn ("function definition declared `auto'");
4665         if (specbits & 1 << (int) RID_REGISTER)
4666           error ("function definition declared `register'");
4667         if (specbits & 1 << (int) RID_TYPEDEF)
4668           error ("function definition declared `typedef'");
4669         specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4670                        | (1 << (int) RID_AUTO));
4671       }
4672     else if (decl_context != NORMAL && nclasses > 0)
4673       {
4674         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4675           ;
4676         else
4677           {
4678             error ((decl_context == FIELD
4679                     ? "storage class specified for structure field `%s'"
4680                     : (decl_context == PARM
4681                        ? "storage class specified for parameter `%s'"
4682                        : "storage class specified for typename")),
4683                    name);
4684             specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4685                            | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4686                            | (1 << (int) RID_EXTERN));
4687           }
4688       }
4689     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4690       {
4691         /* `extern' with initialization is invalid if not at top level.  */
4692         if (current_binding_level == global_binding_level)
4693           warning ("`%s' initialized and declared `extern'", name);
4694         else
4695           error ("`%s' has both `extern' and initializer", name);
4696       }
4697     else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4698              && current_binding_level != global_binding_level)
4699       error ("nested function `%s' declared `extern'", name);
4700     else if (current_binding_level == global_binding_level
4701              && specbits & (1 << (int) RID_AUTO))
4702       error ("top-level declaration of `%s' specifies `auto'", name);
4703     else if ((specbits & 1 << (int) RID_ITERATOR)
4704              && TREE_CODE (declarator) != IDENTIFIER_NODE)
4705       {
4706         error ("iterator `%s' has derived type", name);
4707         type = error_mark_node;
4708       }
4709     else if ((specbits & 1 << (int) RID_ITERATOR)
4710              && TREE_CODE (type) != INTEGER_TYPE)
4711       {
4712         error ("iterator `%s' has noninteger type", name);
4713         type = error_mark_node;
4714       }
4715   }
4716
4717   /* Now figure out the structure of the declarator proper.
4718      Descend through it, creating more complex types, until we reach
4719      the declared identifier (or NULL_TREE, in an absolute declarator).  */
4720
4721   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4722     {
4723       if (type == error_mark_node)
4724         {
4725           declarator = TREE_OPERAND (declarator, 0);
4726           continue;
4727         }
4728
4729       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4730          an INDIRECT_REF (for *...),
4731          a CALL_EXPR (for ...(...)),
4732          an identifier (for the name being declared)
4733          or a null pointer (for the place in an absolute declarator
4734          where the name was omitted).
4735          For the last two cases, we have just exited the loop.
4736
4737          At this point, TYPE is the type of elements of an array,
4738          or for a function to return, or for a pointer to point to.
4739          After this sequence of ifs, TYPE is the type of the
4740          array or function or pointer, and DECLARATOR has had its
4741          outermost layer removed.  */
4742
4743       if (TREE_CODE (declarator) == ARRAY_REF)
4744         {
4745           register tree itype = NULL_TREE;
4746           register tree size = TREE_OPERAND (declarator, 1);
4747           /* An uninitialized decl with `extern' is a reference.  */
4748           int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4749           /* The index is a signed object `sizetype' bits wide.  */
4750           tree index_type = signed_type (sizetype);
4751
4752           declarator = TREE_OPERAND (declarator, 0);
4753
4754           /* Check for some types that there cannot be arrays of.  */
4755
4756           if (TYPE_MAIN_VARIANT (type) == void_type_node)
4757             {
4758               error ("declaration of `%s' as array of voids", name);
4759               type = error_mark_node;
4760             }
4761
4762           if (TREE_CODE (type) == FUNCTION_TYPE)
4763             {
4764               error ("declaration of `%s' as array of functions", name);
4765               type = error_mark_node;
4766             }
4767
4768           if (size == error_mark_node)
4769             type = error_mark_node;
4770
4771           if (type == error_mark_node)
4772             continue;
4773
4774           /* If this is a block level extern, it must live past the end
4775              of the function so that we can check it against other extern
4776              declarations (IDENTIFIER_LIMBO_VALUE).  */
4777           if (extern_ref && allocation_temporary_p ())
4778             end_temporary_allocation ();
4779
4780           /* If size was specified, set ITYPE to a range-type for that size.
4781              Otherwise, ITYPE remains null.  finish_decl may figure it out
4782              from an initial value.  */
4783
4784           if (size)
4785             {
4786               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4787               STRIP_TYPE_NOPS (size);
4788
4789               if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
4790                   && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
4791                 {
4792                   error ("size of array `%s' has non-integer type", name);
4793                   size = integer_one_node;
4794                 }
4795
4796               if (pedantic && integer_zerop (size))
4797                 pedwarn ("ANSI C forbids zero-size array `%s'", name);
4798
4799               if (TREE_CODE (size) == INTEGER_CST)
4800                 {
4801                   constant_expression_warning (size);
4802                   if (tree_int_cst_sgn (size) < 0)
4803                     {
4804                       error ("size of array `%s' is negative", name);
4805                       size = integer_one_node;
4806                     }
4807                 }
4808               else
4809                 {
4810                   /* Make sure the array size remains visibly nonconstant
4811                      even if it is (eg) a const variable with known value.  */
4812                   size_varies = 1;
4813
4814                   if (pedantic)
4815                     {
4816                       if (TREE_CONSTANT (size))
4817                         pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name);
4818                       else
4819                         pedwarn ("ANSI C forbids variable-size array `%s'", name);
4820                     }
4821                 }
4822
4823               /* Convert size to index_type, so that if it is a variable
4824                  the computations will be done in the proper mode.  */
4825               itype = fold (build (MINUS_EXPR, index_type,
4826                                    convert (index_type, size),
4827                                    convert (index_type, size_one_node)));
4828
4829               /* If that overflowed, the array is too big.
4830                  ??? While a size of INT_MAX+1 technically shouldn't cause
4831                  an overflow (because we subtract 1), the overflow is recorded
4832                  during the conversion to index_type, before the subtraction.
4833                  Handling this case seems like an unnecessary complication.  */
4834               if (TREE_OVERFLOW (itype))
4835                 {
4836                   error ("size of array `%s' is too large", name);
4837                   type = error_mark_node;
4838                   continue;
4839                 }
4840
4841               if (size_varies)
4842                 itype = variable_size (itype);
4843               itype = build_index_type (itype);
4844             }
4845
4846 #if 0 /* This had bad results for pointers to arrays, as in
4847          union incomplete (*foo)[4];  */
4848           /* Complain about arrays of incomplete types, except in typedefs.  */
4849
4850           if (TYPE_SIZE (type) == 0
4851               /* Avoid multiple warnings for nested array types.  */
4852               && TREE_CODE (type) != ARRAY_TYPE
4853               && !(specbits & (1 << (int) RID_TYPEDEF))
4854               && !C_TYPE_BEING_DEFINED (type))
4855             warning ("array type has incomplete element type");
4856 #endif
4857
4858 #if 0  /* We shouldn't have a function type here at all!
4859           Functions aren't allowed as array elements.  */
4860           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4861               && (constp || volatilep))
4862             pedwarn ("ANSI C forbids const or volatile function types");
4863 #endif
4864
4865           /* Build the array type itself, then merge any constancy or
4866              volatility into the target type.  We must do it in this order
4867              to ensure that the TYPE_MAIN_VARIANT field of the array type
4868              is set correctly.  */
4869
4870           type = build_array_type (type, itype);
4871           if (constp || volatilep)
4872             type = c_build_type_variant (type, constp, volatilep);
4873
4874 #if 0   /* don't clear these; leave them set so that the array type
4875            or the variable is itself const or volatile.  */
4876           constp = 0;
4877           volatilep = 0;
4878 #endif
4879
4880           if (size_varies)
4881             C_TYPE_VARIABLE_SIZE (type) = 1;
4882         }
4883       else if (TREE_CODE (declarator) == CALL_EXPR)
4884         {
4885           int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4886                             || current_binding_level == global_binding_level);
4887           tree arg_types;
4888
4889           /* Declaring a function type.
4890              Make sure we have a valid type for the function to return.  */
4891           if (type == error_mark_node)
4892             continue;
4893
4894           size_varies = 0;
4895
4896           /* Warn about some types functions can't return.  */
4897
4898           if (TREE_CODE (type) == FUNCTION_TYPE)
4899             {
4900               error ("`%s' declared as function returning a function", name);
4901               type = integer_type_node;
4902             }
4903           if (TREE_CODE (type) == ARRAY_TYPE)
4904             {
4905               error ("`%s' declared as function returning an array", name);
4906               type = integer_type_node;
4907             }
4908
4909 #ifndef TRADITIONAL_RETURN_FLOAT
4910           /* Traditionally, declaring return type float means double.  */
4911
4912           if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4913             type = double_type_node;
4914 #endif /* TRADITIONAL_RETURN_FLOAT */
4915
4916           /* If this is a block level extern, it must live past the end
4917              of the function so that we can check it against other extern
4918              declarations (IDENTIFIER_LIMBO_VALUE).  */
4919           if (extern_ref && allocation_temporary_p ())
4920             end_temporary_allocation ();
4921
4922           /* Construct the function type and go to the next
4923              inner layer of declarator.  */
4924
4925           arg_types = grokparms (TREE_OPERAND (declarator, 1),
4926                                  funcdef_flag
4927                                  /* Say it's a definition
4928                                     only for the CALL_EXPR
4929                                     closest to the identifier.  */
4930                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4931 #if 0 /* This seems to be false.  We turn off temporary allocation
4932          above in this function if -traditional.
4933          And this code caused inconsistent results with prototypes:
4934          callers would ignore them, and pass arguments wrong.  */
4935
4936           /* Omit the arg types if -traditional, since the arg types
4937              and the list links might not be permanent.  */
4938           type = build_function_type (type,
4939                                       flag_traditional
4940                                       ? NULL_TREE : arg_types);
4941 #endif
4942           /* ANSI seems to say that `const int foo ();'
4943              does not make the function foo const.  */
4944           if (constp || volatilep)
4945             type = c_build_type_variant (type, constp, volatilep);
4946           constp = 0;
4947           volatilep = 0;
4948
4949           type = build_function_type (type, arg_types);
4950           declarator = TREE_OPERAND (declarator, 0);
4951
4952           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4953              the formal parameter list of this FUNCTION_TYPE to point to
4954              the FUNCTION_TYPE node itself.  */
4955
4956           {
4957             register tree link;
4958
4959             for (link = last_function_parm_tags;
4960                  link;
4961                  link = TREE_CHAIN (link))
4962               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4963           }
4964         }
4965       else if (TREE_CODE (declarator) == INDIRECT_REF)
4966         {
4967           /* Merge any constancy or volatility into the target type
4968              for the pointer.  */
4969
4970           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4971               && (constp || volatilep))
4972             pedwarn ("ANSI C forbids const or volatile function types");
4973           if (constp || volatilep)
4974             type = c_build_type_variant (type, constp, volatilep);
4975           constp = 0;
4976           volatilep = 0;
4977           size_varies = 0;
4978
4979           type = build_pointer_type (type);
4980
4981           /* Process a list of type modifier keywords
4982              (such as const or volatile) that were given inside the `*'.  */
4983
4984           if (TREE_TYPE (declarator))
4985             {
4986               register tree typemodlist;
4987               int erred = 0;
4988               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4989                    typemodlist = TREE_CHAIN (typemodlist))
4990                 {
4991                   if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
4992                     constp++;
4993                   else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
4994                     volatilep++;
4995                   else if (!erred)
4996                     {
4997                       erred = 1;
4998                       error ("invalid type modifier within pointer declarator");
4999                     }
5000                 }
5001               if (constp > 1)
5002                 pedwarn ("duplicate `const'");
5003               if (volatilep > 1)
5004                 pedwarn ("duplicate `volatile'");
5005             }
5006
5007           declarator = TREE_OPERAND (declarator, 0);
5008         }
5009       else
5010         abort ();
5011
5012     }
5013
5014   /* Now TYPE has the actual type.  */
5015
5016   /* Did array size calculations overflow?  */
5017
5018   if (TREE_CODE (type) == ARRAY_TYPE
5019       && TYPE_SIZE (type)
5020       && TREE_OVERFLOW (TYPE_SIZE (type)))
5021     error ("size of array `%s' is too large", name);
5022
5023   /* If this is declaring a typedef name, return a TYPE_DECL.  */
5024
5025   if (specbits & (1 << (int) RID_TYPEDEF))
5026     {
5027       tree decl;
5028       /* Note that the grammar rejects storage classes
5029          in typenames, fields or parameters */
5030       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5031           && (constp || volatilep))
5032         pedwarn ("ANSI C forbids const or volatile function types");
5033       if (constp || volatilep)
5034         type = c_build_type_variant (type, constp, volatilep);
5035       decl = build_decl (TYPE_DECL, declarator, type);
5036       if ((specbits & (1 << (int) RID_SIGNED))
5037           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
5038         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
5039       pop_obstacks ();
5040       return decl;
5041     }
5042
5043   /* Detect the case of an array type of unspecified size
5044      which came, as such, direct from a typedef name.
5045      We must copy the type, so that each identifier gets
5046      a distinct type, so that each identifier's size can be
5047      controlled separately by its own initializer.  */
5048
5049   if (type != 0 && typedef_type != 0
5050       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
5051       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
5052     {
5053       type = build_array_type (TREE_TYPE (type), 0);
5054       if (size_varies)
5055         C_TYPE_VARIABLE_SIZE (type) = 1;
5056     }
5057
5058   /* If this is a type name (such as, in a cast or sizeof),
5059      compute the type and return it now.  */
5060
5061   if (decl_context == TYPENAME)
5062     {
5063       /* Note that the grammar rejects storage classes
5064          in typenames, fields or parameters */
5065       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5066           && (constp || volatilep))
5067         pedwarn ("ANSI C forbids const or volatile function types");
5068       if (constp || volatilep)
5069         type = c_build_type_variant (type, constp, volatilep);
5070       pop_obstacks ();
5071       return type;
5072     }
5073
5074   /* Aside from typedefs and type names (handle above),
5075      `void' at top level (not within pointer)
5076      is allowed only in public variables.
5077      We don't complain about parms either, but that is because
5078      a better error message can be made later.  */
5079
5080   if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM
5081       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
5082             && ((specbits & (1 << (int) RID_EXTERN))
5083                 || (current_binding_level == global_binding_level
5084                     && !(specbits
5085                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
5086     {
5087       error ("variable or field `%s' declared void", name);
5088       type = integer_type_node;
5089     }
5090
5091   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5092      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
5093
5094   {
5095     register tree decl;
5096
5097     if (decl_context == PARM)
5098       {
5099         tree type_as_written = type;
5100         tree main_type;
5101
5102         /* A parameter declared as an array of T is really a pointer to T.
5103            One declared as a function is really a pointer to a function.  */
5104
5105         if (TREE_CODE (type) == ARRAY_TYPE)
5106           {
5107             /* Transfer const-ness of array into that of type pointed to.  */
5108             type = TREE_TYPE (type);
5109             if (constp || volatilep)
5110               type = c_build_type_variant (type, constp, volatilep);
5111             type = build_pointer_type (type);
5112             volatilep = constp = 0;
5113             size_varies = 0;
5114           }
5115         else if (TREE_CODE (type) == FUNCTION_TYPE)
5116           {
5117             if (pedantic && (constp || volatilep))
5118               pedwarn ("ANSI C forbids const or volatile function types");
5119             if (constp || volatilep)
5120               type = c_build_type_variant (type, constp, volatilep);
5121             type = build_pointer_type (type);
5122             volatilep = constp = 0;
5123           }
5124
5125         decl = build_decl (PARM_DECL, declarator, type);
5126         if (size_varies)
5127           C_DECL_VARIABLE_SIZE (decl) = 1;
5128
5129         /* Compute the type actually passed in the parmlist,
5130            for the case where there is no prototype.
5131            (For example, shorts and chars are passed as ints.)
5132            When there is a prototype, this is overridden later.  */
5133
5134         DECL_ARG_TYPE (decl) = type;
5135         main_type = (type == error_mark_node
5136                      ? error_mark_node
5137                      : TYPE_MAIN_VARIANT (type));
5138         if (main_type == float_type_node)
5139           DECL_ARG_TYPE (decl) = double_type_node;
5140         /* Don't use TYPE_PRECISION to decide whether to promote,
5141            because we should convert short if it's the same size as int,
5142            but we should not convert long if it's the same size as int.  */
5143         else if (TREE_CODE (main_type) != ERROR_MARK
5144                  && C_PROMOTING_INTEGER_TYPE_P (main_type))
5145           {
5146             if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
5147                 && TREE_UNSIGNED (type))
5148               DECL_ARG_TYPE (decl) = unsigned_type_node;
5149             else
5150               DECL_ARG_TYPE (decl) = integer_type_node;
5151           }
5152
5153         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
5154       }
5155     else if (decl_context == FIELD)
5156       {
5157         /* Structure field.  It may not be a function.  */
5158
5159         if (TREE_CODE (type) == FUNCTION_TYPE)
5160           {
5161             error ("field `%s' declared as a function", name);
5162             type = build_pointer_type (type);
5163           }
5164         else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
5165           {
5166             error ("field `%s' has incomplete type", name);
5167             type = error_mark_node;
5168           }
5169         /* Move type qualifiers down to element of an array.  */
5170         if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
5171           {
5172             type = build_array_type (c_build_type_variant (TREE_TYPE (type),
5173                                                            constp, volatilep),
5174                                      TYPE_DOMAIN (type));
5175 #if 0 /* Leave the field const or volatile as well.  */
5176             constp = volatilep = 0;
5177 #endif
5178           }
5179         decl = build_decl (FIELD_DECL, declarator, type);
5180         if (size_varies)
5181           C_DECL_VARIABLE_SIZE (decl) = 1;
5182       }
5183     else if (TREE_CODE (type) == FUNCTION_TYPE)
5184       {
5185         /* Every function declaration is "external"
5186            except for those which are inside a function body
5187            in which `auto' is used.
5188            That is a case not specified by ANSI C,
5189            and we use it for forward declarations for nested functions.  */
5190         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
5191                           || current_binding_level == global_binding_level);
5192
5193         if (specbits & (1 << (int) RID_AUTO)
5194             && (pedantic || current_binding_level == global_binding_level))
5195           pedwarn ("invalid storage class for function `%s'", name);
5196         if (specbits & (1 << (int) RID_REGISTER))
5197           error ("invalid storage class for function `%s'", name);
5198         /* Function declaration not at top level.
5199            Storage classes other than `extern' are not allowed
5200            and `extern' makes no difference.  */
5201         if (current_binding_level != global_binding_level
5202             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
5203             && pedantic)
5204           pedwarn ("invalid storage class for function `%s'", name);
5205
5206         /* If this is a block level extern, it must live past the end
5207            of the function so that we can check it against other
5208            extern declarations (IDENTIFIER_LIMBO_VALUE).  */
5209         if (extern_ref && allocation_temporary_p ())
5210           end_temporary_allocation ();
5211
5212         decl = build_decl (FUNCTION_DECL, declarator, type);
5213         decl = build_decl_attribute_variant (decl, decl_machine_attr);
5214
5215         if (pedantic && (constp || volatilep)
5216             && ! DECL_IN_SYSTEM_HEADER (decl))
5217           pedwarn ("ANSI C forbids const or volatile functions");
5218
5219         if (pedantic
5220             && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl))) == void_type_node
5221             && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (decl)))
5222                 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (decl))))
5223             && ! DECL_IN_SYSTEM_HEADER (decl))
5224           pedwarn ("ANSI C forbids const or volatile void function return type");
5225
5226         if (volatilep
5227             && TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
5228           warning ("`noreturn' function returns non-void value");
5229
5230         if (extern_ref)
5231           DECL_EXTERNAL (decl) = 1;
5232         /* Record absence of global scope for `static' or `auto'.  */
5233         TREE_PUBLIC (decl)
5234           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
5235
5236         /* Record presence of `inline', if it is reasonable.  */
5237         if (inlinep)
5238           {
5239             if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
5240               warning ("cannot inline function `main'");
5241             else
5242               /* Assume that otherwise the function can be inlined.  */
5243               DECL_INLINE (decl) = 1;
5244
5245             if (specbits & (1 << (int) RID_EXTERN))
5246               current_extern_inline = 1;
5247           }
5248       }
5249     else
5250       {
5251         /* It's a variable.  */
5252         /* An uninitialized decl with `extern' is a reference.  */
5253         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
5254
5255         /* Move type qualifiers down to element of an array.  */
5256         if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
5257           {
5258             type = build_array_type (c_build_type_variant (TREE_TYPE (type),
5259                                                            constp, volatilep),
5260                                      TYPE_DOMAIN (type));
5261 #if 0 /* Leave the variable const or volatile as well.  */
5262             constp = volatilep = 0;
5263 #endif
5264           }
5265
5266         /* If this is a block level extern, it must live past the end
5267            of the function so that we can check it against other
5268            extern declarations (IDENTIFIER_LIMBO_VALUE).  */
5269         if (extern_ref && allocation_temporary_p ())
5270           end_temporary_allocation ();
5271
5272         decl = build_decl (VAR_DECL, declarator, type);
5273         if (size_varies)
5274           C_DECL_VARIABLE_SIZE (decl) = 1;
5275
5276         if (inlinep)
5277           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
5278
5279         DECL_EXTERNAL (decl) = extern_ref;
5280         /* At top level, the presence of a `static' or `register' storage
5281            class specifier, or the absence of all storage class specifiers
5282            makes this declaration a definition (perhaps tentative).  Also,
5283            the absence of both `static' and `register' makes it public.  */
5284         if (current_binding_level == global_binding_level)
5285           {
5286             TREE_PUBLIC (decl)
5287               = !(specbits
5288                   & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
5289             TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5290           }
5291         /* Not at top level, only `static' makes a static definition.  */
5292         else
5293           {
5294             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
5295             TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5296           }
5297
5298         if (specbits & 1 << (int) RID_ITERATOR)
5299           ITERATOR_P (decl) = 1;
5300       }
5301
5302     /* Record `register' declaration for warnings on &
5303        and in case doing stupid register allocation.  */
5304
5305     if (specbits & (1 << (int) RID_REGISTER))
5306       DECL_REGISTER (decl) = 1;
5307
5308     /* Record constancy and volatility.  */
5309
5310     if (constp)
5311       TREE_READONLY (decl) = 1;
5312     if (volatilep)
5313       {
5314         TREE_SIDE_EFFECTS (decl) = 1;
5315         TREE_THIS_VOLATILE (decl) = 1;
5316       }
5317     /* If a type has volatile components, it should be stored in memory.
5318        Otherwise, the fact that those components are volatile
5319        will be ignored, and would even crash the compiler.  */
5320     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
5321       mark_addressable (decl);
5322
5323     pop_obstacks ();
5324
5325     return decl;
5326   }
5327 }
5328 \f
5329 /* Decode the parameter-list info for a function type or function definition.
5330    The argument is the value returned by `get_parm_info' (or made in parse.y
5331    if there is an identifier list instead of a parameter decl list).
5332    These two functions are separate because when a function returns
5333    or receives functions then each is called multiple times but the order
5334    of calls is different.  The last call to `grokparms' is always the one
5335    that contains the formal parameter names of a function definition.
5336
5337    Store in `last_function_parms' a chain of the decls of parms.
5338    Also store in `last_function_parm_tags' a chain of the struct, union,
5339    and enum tags declared among the parms.
5340
5341    Return a list of arg types to use in the FUNCTION_TYPE for this function.
5342
5343    FUNCDEF_FLAG is nonzero for a function definition, 0 for
5344    a mere declaration.  A nonempty identifier-list gets an error message
5345    when FUNCDEF_FLAG is zero.  */
5346
5347 static tree
5348 grokparms (parms_info, funcdef_flag)
5349      tree parms_info;
5350      int funcdef_flag;
5351 {
5352   tree first_parm = TREE_CHAIN (parms_info);
5353
5354   last_function_parms = TREE_PURPOSE (parms_info);
5355   last_function_parm_tags = TREE_VALUE (parms_info);
5356
5357   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
5358       && !in_system_header)
5359     warning ("function declaration isn't a prototype");
5360
5361   if (first_parm != 0
5362       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
5363     {
5364       if (! funcdef_flag)
5365         pedwarn ("parameter names (without types) in function declaration");
5366
5367       last_function_parms = first_parm;
5368       return 0;
5369     }
5370   else
5371     {
5372       tree parm;
5373       tree typelt;
5374       /* We no longer test FUNCDEF_FLAG.
5375          If the arg types are incomplete in a declaration,
5376          they must include undefined tags.
5377          These tags can never be defined in the scope of the declaration,
5378          so the types can never be completed,
5379          and no call can be compiled successfully.  */
5380 #if 0
5381       /* In a fcn definition, arg types must be complete.  */
5382       if (funcdef_flag)
5383 #endif
5384         for (parm = last_function_parms, typelt = first_parm;
5385              parm;
5386              parm = TREE_CHAIN (parm))
5387           /* Skip over any enumeration constants declared here.  */
5388           if (TREE_CODE (parm) == PARM_DECL)
5389             {
5390               /* Barf if the parameter itself has an incomplete type.  */
5391               tree type = TREE_VALUE (typelt);
5392               if (TYPE_SIZE (type) == 0)
5393                 {
5394                   if (funcdef_flag && DECL_NAME (parm) != 0)
5395                     error ("parameter `%s' has incomplete type",
5396                            IDENTIFIER_POINTER (DECL_NAME (parm)));
5397                   else
5398                     warning ("parameter has incomplete type");
5399                   if (funcdef_flag)
5400                     {
5401                       TREE_VALUE (typelt) = error_mark_node;
5402                       TREE_TYPE (parm) = error_mark_node;
5403                     }
5404                 }
5405 #if 0  /* This has been replaced by parm_tags_warning
5406           which uses a more accurate criterion for what to warn about.  */
5407               else
5408                 {
5409                   /* Now warn if is a pointer to an incomplete type.  */
5410                   while (TREE_CODE (type) == POINTER_TYPE
5411                          || TREE_CODE (type) == REFERENCE_TYPE)
5412                     type = TREE_TYPE (type);
5413                   type = TYPE_MAIN_VARIANT (type);
5414                   if (TYPE_SIZE (type) == 0)
5415                     {
5416                       if (DECL_NAME (parm) != 0)
5417                         warning ("parameter `%s' points to incomplete type",
5418                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
5419                       else
5420                         warning ("parameter points to incomplete type");
5421                     }
5422                 }
5423 #endif
5424               typelt = TREE_CHAIN (typelt);
5425             }
5426
5427       /* Allocate the list of types the way we allocate a type.  */
5428       if (first_parm && ! TREE_PERMANENT (first_parm))
5429         {
5430           /* Construct a copy of the list of types
5431              on the saveable obstack.  */
5432           tree result = NULL;
5433           for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt))
5434             result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt),
5435                                          result);
5436           return nreverse (result);
5437         }
5438       else
5439         /* The list we have is permanent already.  */
5440         return first_parm;
5441     }
5442 }
5443
5444
5445 /* Return a tree_list node with info on a parameter list just parsed.
5446    The TREE_PURPOSE is a chain of decls of those parms.
5447    The TREE_VALUE is a list of structure, union and enum tags defined.
5448    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5449    This tree_list node is later fed to `grokparms'.
5450
5451    VOID_AT_END nonzero means append `void' to the end of the type-list.
5452    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
5453
5454 tree
5455 get_parm_info (void_at_end)
5456      int void_at_end;
5457 {
5458   register tree decl, t;
5459   register tree types = 0;
5460   int erred = 0;
5461   tree tags = gettags ();
5462   tree parms = getdecls ();
5463   tree new_parms = 0;
5464   tree order = current_binding_level->parm_order;
5465
5466   /* Just `void' (and no ellipsis) is special.  There are really no parms.  */
5467   if (void_at_end && parms != 0
5468       && TREE_CHAIN (parms) == 0
5469       && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
5470       && DECL_NAME (parms) == 0)
5471     {
5472       parms = NULL_TREE;
5473       storedecls (NULL_TREE);
5474       return saveable_tree_cons (NULL_TREE, NULL_TREE,
5475                                  saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5476     }
5477
5478   /* Extract enumerator values and other non-parms declared with the parms.
5479      Likewise any forward parm decls that didn't have real parm decls.  */
5480   for (decl = parms; decl; )
5481     {
5482       tree next = TREE_CHAIN (decl);
5483
5484       if (TREE_CODE (decl) != PARM_DECL)
5485         {
5486           TREE_CHAIN (decl) = new_parms;
5487           new_parms = decl;
5488         }
5489       else if (TREE_ASM_WRITTEN (decl))
5490         {
5491           error_with_decl (decl, "parameter `%s' has just a forward declaration");
5492           TREE_CHAIN (decl) = new_parms;
5493           new_parms = decl;
5494         }
5495       decl = next;
5496     }
5497
5498   /* Put the parm decls back in the order they were in in the parm list.  */
5499   for (t = order; t; t = TREE_CHAIN (t))
5500     {
5501       if (TREE_CHAIN (t))
5502         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5503       else
5504         TREE_CHAIN (TREE_VALUE (t)) = 0;
5505     }
5506
5507   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5508                        new_parms);
5509
5510   /* Store the parmlist in the binding level since the old one
5511      is no longer a valid list.  (We have changed the chain pointers.)  */
5512   storedecls (new_parms);
5513
5514   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5515     /* There may also be declarations for enumerators if an enumeration
5516        type is declared among the parms.  Ignore them here.  */
5517     if (TREE_CODE (decl) == PARM_DECL)
5518       {
5519         /* Since there is a prototype,
5520            args are passed in their declared types.  */
5521         tree type = TREE_TYPE (decl);
5522         DECL_ARG_TYPE (decl) = type;
5523 #ifdef PROMOTE_PROTOTYPES
5524         if ((TREE_CODE (type) == INTEGER_TYPE
5525              || TREE_CODE (type) == ENUMERAL_TYPE)
5526             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5527           DECL_ARG_TYPE (decl) = integer_type_node;
5528 #endif
5529
5530         types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5531         if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
5532             && DECL_NAME (decl) == 0)
5533           {
5534             error ("`void' in parameter list must be the entire list");
5535             erred = 1;
5536           }
5537       }
5538
5539   if (void_at_end)
5540     return saveable_tree_cons (new_parms, tags,
5541                                nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
5542
5543   return saveable_tree_cons (new_parms, tags, nreverse (types));
5544 }
5545
5546 /* At end of parameter list, warn about any struct, union or enum tags
5547    defined within.  Do so because these types cannot ever become complete.  */
5548
5549 void
5550 parmlist_tags_warning ()
5551 {
5552   tree elt;
5553   static int already;
5554
5555   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5556     {
5557       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5558       /* An anonymous union parm type is meaningful as a GNU extension.
5559          So don't warn for that.  */
5560       if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
5561         continue;
5562       if (TREE_PURPOSE (elt) != 0)
5563         warning ("`%s %s' declared inside parameter list",
5564                  (code == RECORD_TYPE ? "struct"
5565                   : code == UNION_TYPE ? "union"
5566                   : "enum"),
5567                  IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5568       else
5569         warning ("anonymous %s declared inside parameter list",
5570                  (code == RECORD_TYPE ? "struct"
5571                   : code == UNION_TYPE ? "union"
5572                   : "enum"));
5573
5574       if (! already)
5575         {
5576           warning ("its scope is only this definition or declaration,");
5577           warning ("which is probably not what you want.");
5578           already = 1;
5579         }
5580     }
5581 }
5582 \f
5583 /* Get the struct, enum or union (CODE says which) with tag NAME.
5584    Define the tag as a forward-reference if it is not defined.  */
5585
5586 tree
5587 xref_tag (code, name)
5588      enum tree_code code;
5589      tree name;
5590 {
5591   int temporary = allocation_temporary_p ();
5592
5593   /* If a cross reference is requested, look up the type
5594      already defined for this tag and return it.  */
5595
5596   register tree ref = lookup_tag (code, name, current_binding_level, 0);
5597   /* Even if this is the wrong type of tag, return what we found.
5598      There will be an error message anyway, from pending_xref_error.
5599      If we create an empty xref just for an invalid use of the type,
5600      the main result is to create lots of superfluous error messages.  */
5601   if (ref)
5602     return ref;
5603
5604   push_obstacks_nochange ();
5605
5606   if (current_binding_level == global_binding_level && temporary)
5607     end_temporary_allocation ();
5608
5609   /* If no such tag is yet defined, create a forward-reference node
5610      and record it as the "definition".
5611      When a real declaration of this type is found,
5612      the forward-reference will be altered into a real type.  */
5613
5614   ref = make_node (code);
5615   if (code == ENUMERAL_TYPE)
5616     {
5617       /* (In ANSI, Enums can be referred to only if already defined.)  */
5618       if (pedantic)
5619         pedwarn ("ANSI C forbids forward references to `enum' types");
5620       /* Give the type a default layout like unsigned int
5621          to avoid crashing if it does not get defined.  */
5622       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5623       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5624       TREE_UNSIGNED (ref) = 1;
5625       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5626       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5627       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5628     }
5629
5630   pushtag (name, ref);
5631
5632   pop_obstacks ();
5633
5634   return ref;
5635 }
5636 \f
5637 /* Make sure that the tag NAME is defined *in the current binding level*
5638    at least as a forward reference.
5639    CODE says which kind of tag NAME ought to be.
5640
5641    We also do a push_obstacks_nochange
5642    whose matching pop is in finish_struct.  */
5643
5644 tree
5645 start_struct (code, name)
5646      enum tree_code code;
5647      tree name;
5648 {
5649   /* If there is already a tag defined at this binding level
5650      (as a forward reference), just return it.  */
5651
5652   register tree ref = 0;
5653
5654   push_obstacks_nochange ();
5655   if (current_binding_level == global_binding_level)
5656     end_temporary_allocation ();
5657
5658   if (name != 0)
5659     ref = lookup_tag (code, name, current_binding_level, 1);
5660   if (ref && TREE_CODE (ref) == code)
5661     {
5662       C_TYPE_BEING_DEFINED (ref) = 1;
5663       TYPE_PACKED (ref) = flag_pack_struct;
5664       if (TYPE_FIELDS (ref))
5665         error ((code == UNION_TYPE ? "redefinition of `union %s'"
5666                 : "redefinition of `struct %s'"),
5667                IDENTIFIER_POINTER (name));
5668
5669       return ref;
5670     }
5671
5672   /* Otherwise create a forward-reference just so the tag is in scope.  */
5673
5674   ref = make_node (code);
5675   pushtag (name, ref);
5676   C_TYPE_BEING_DEFINED (ref) = 1;
5677   TYPE_PACKED (ref) = flag_pack_struct;
5678   return ref;
5679 }
5680
5681 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5682    of a structure component, returning a FIELD_DECL node.
5683    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5684
5685    This is done during the parsing of the struct declaration.
5686    The FIELD_DECL nodes are chained together and the lot of them
5687    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5688
5689 tree
5690 grokfield (filename, line, declarator, declspecs, width)
5691      char *filename;
5692      int line;
5693      tree declarator, declspecs, width;
5694 {
5695   tree value;
5696
5697   /* The corresponding pop_obstacks is in finish_decl.  */
5698   push_obstacks_nochange ();
5699
5700   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5701
5702   finish_decl (value, NULL_TREE, NULL_TREE);
5703   DECL_INITIAL (value) = width;
5704
5705   maybe_objc_check_decl (value);
5706   return value;
5707 }
5708 \f
5709 /* Function to help qsort sort FIELD_DECLs by name order.  */
5710
5711 static int
5712 field_decl_cmp (xp, yp)
5713      const GENERIC_PTR xp;
5714      const GENERIC_PTR yp;
5715 {
5716   tree *x = (tree *)xp, *y = (tree *)yp;
5717
5718   if (DECL_NAME (*x) == DECL_NAME (*y))
5719     return 0;
5720   if (DECL_NAME (*x) == NULL)
5721     return -1;
5722   if (DECL_NAME (*y) == NULL)
5723     return 1;
5724   if (DECL_NAME (*x) < DECL_NAME (*y))
5725     return -1;
5726   return 1;
5727 }
5728
5729 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5730    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5731    ATTRIBUTES are attributes to be applied to the structure.
5732
5733    We also do a pop_obstacks to match the push in start_struct.  */
5734
5735 tree
5736 finish_struct (t, fieldlist, attributes)
5737      tree t;
5738      tree fieldlist;
5739      tree attributes;
5740 {
5741   register tree x;
5742   int old_momentary;
5743   int toplevel = global_binding_level == current_binding_level;
5744
5745   /* If this type was previously laid out as a forward reference,
5746      make sure we lay it out again.  */
5747
5748   TYPE_SIZE (t) = 0;
5749
5750   decl_attributes (t, attributes, NULL_TREE);
5751
5752   /* Nameless union parm types are useful as GCC extension.  */
5753   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5754     /* Otherwise, warn about any struct or union def. in parmlist.  */
5755     if (in_parm_level_p ())
5756       {
5757         if (pedantic)
5758           pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5759                     : "structure defined inside parms"));
5760         else if (! flag_traditional)
5761           warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5762                     : "structure defined inside parms"));
5763       }
5764
5765   old_momentary = suspend_momentary ();
5766
5767   if (pedantic)
5768     {
5769       for (x = fieldlist; x; x = TREE_CHAIN (x))
5770         if (DECL_NAME (x) != 0)
5771           break;
5772
5773       if (x == 0)
5774         pedwarn ("%s has no %smembers",
5775                  (TREE_CODE (t) == UNION_TYPE ? "union" : "structure"),
5776                  (fieldlist ? "named " : ""));
5777     }
5778
5779   /* Install struct as DECL_CONTEXT of each field decl.
5780      Also process specified field sizes.
5781      Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
5782      The specified size is found in the DECL_INITIAL.
5783      Store 0 there, except for ": 0" fields (so we can find them
5784      and delete them, below).  */
5785
5786   for (x = fieldlist; x; x = TREE_CHAIN (x))
5787     {
5788       DECL_CONTEXT (x) = t;
5789       DECL_PACKED (x) |= TYPE_PACKED (t);
5790       DECL_FIELD_SIZE (x) = 0;
5791
5792       /* If any field is const, the structure type is pseudo-const.  */
5793       if (TREE_READONLY (x))
5794         C_TYPE_FIELDS_READONLY (t) = 1;
5795       else
5796         {
5797           /* A field that is pseudo-const makes the structure likewise.  */
5798           tree t1 = TREE_TYPE (x);
5799           while (TREE_CODE (t1) == ARRAY_TYPE)
5800             t1 = TREE_TYPE (t1);
5801           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5802               && C_TYPE_FIELDS_READONLY (t1))
5803             C_TYPE_FIELDS_READONLY (t) = 1;
5804         }
5805
5806       /* Any field that is volatile means variables of this type must be
5807          treated in some ways as volatile.  */
5808       if (TREE_THIS_VOLATILE (x))
5809         C_TYPE_FIELDS_VOLATILE (t) = 1;
5810
5811       /* Any field of nominal variable size implies structure is too.  */
5812       if (C_DECL_VARIABLE_SIZE (x))
5813         C_TYPE_VARIABLE_SIZE (t) = 1;
5814
5815       /* Detect invalid nested redefinition.  */
5816       if (TREE_TYPE (x) == t)
5817         error ("nested redefinition of `%s'",
5818                IDENTIFIER_POINTER (TYPE_NAME (t)));
5819
5820       /* Detect invalid bit-field size.  */
5821       if (DECL_INITIAL (x))
5822         STRIP_NOPS (DECL_INITIAL (x));
5823       if (DECL_INITIAL (x))
5824         {
5825           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5826             constant_expression_warning (DECL_INITIAL (x));
5827           else
5828             {
5829               error_with_decl (x, "bit-field `%s' width not an integer constant");
5830               DECL_INITIAL (x) = NULL;
5831             }
5832         }
5833
5834       /* Detect invalid bit-field type.  */
5835       if (DECL_INITIAL (x)
5836           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5837           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5838         {
5839           error_with_decl (x, "bit-field `%s' has invalid type");
5840           DECL_INITIAL (x) = NULL;
5841         }
5842       if (DECL_INITIAL (x) && pedantic
5843           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5844           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5845           /* Accept an enum that's equivalent to int or unsigned int.  */
5846           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5847                && (TYPE_PRECISION (TREE_TYPE (x))
5848                    == TYPE_PRECISION (integer_type_node))))
5849         pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
5850
5851       /* Detect and ignore out of range field width.  */
5852       if (DECL_INITIAL (x))
5853         {
5854           unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5855
5856           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5857             {
5858               DECL_INITIAL (x) = NULL;
5859               error_with_decl (x, "negative width in bit-field `%s'");
5860             }
5861           else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
5862                    || width > TYPE_PRECISION (TREE_TYPE (x)))
5863             {
5864               DECL_INITIAL (x) = NULL;
5865               pedwarn_with_decl (x, "width of `%s' exceeds its type");
5866             }
5867           else if (width == 0 && DECL_NAME (x) != 0)
5868             {
5869               error_with_decl (x, "zero width for bit-field `%s'");
5870               DECL_INITIAL (x) = NULL;
5871             }
5872         }
5873
5874       /* Process valid field width.  */
5875       if (DECL_INITIAL (x))
5876         {
5877           register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5878
5879           if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5880               && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5881                                          TREE_UNSIGNED (TREE_TYPE (x)))
5882                   || width < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5883                                             TREE_UNSIGNED (TREE_TYPE (x)))))
5884             warning_with_decl (x, "`%s' is narrower than values of its type");
5885
5886           DECL_FIELD_SIZE (x) = width;
5887           DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
5888           DECL_INITIAL (x) = NULL;
5889
5890           if (width == 0)
5891             {
5892               /* field size 0 => force desired amount of alignment.  */
5893 #ifdef EMPTY_FIELD_BOUNDARY
5894               DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5895 #endif
5896 #ifdef PCC_BITFIELD_TYPE_MATTERS
5897               if (PCC_BITFIELD_TYPE_MATTERS)
5898                 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5899                                       TYPE_ALIGN (TREE_TYPE (x)));
5900 #endif
5901             }
5902         }
5903       else if (TREE_TYPE (x) != error_mark_node)
5904         {
5905           unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5906                            : TYPE_ALIGN (TREE_TYPE (x)));
5907           /* Non-bit-fields are aligned for their type, except packed
5908              fields which require only BITS_PER_UNIT alignment.  */
5909           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5910         }
5911     }
5912
5913   /* Now DECL_INITIAL is null on all members.  */
5914
5915   /* Delete all duplicate fields from the fieldlist */
5916   for (x = fieldlist; x && TREE_CHAIN (x);)
5917     /* Anonymous fields aren't duplicates.  */
5918     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5919       x = TREE_CHAIN (x);
5920     else
5921       {
5922         register tree y = fieldlist;
5923
5924         while (1)
5925           {
5926             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5927               break;
5928             if (y == x)
5929               break;
5930             y = TREE_CHAIN (y);
5931           }
5932         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5933           {
5934             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5935             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5936           }
5937         else x = TREE_CHAIN (x);
5938       }
5939
5940   /* Now we have the nearly final fieldlist.  Record it,
5941      then lay out the structure or union (including the fields).  */
5942
5943   TYPE_FIELDS (t) = fieldlist;
5944
5945   layout_type (t);
5946
5947   /* Delete all zero-width bit-fields from the front of the fieldlist */
5948   while (fieldlist
5949          && DECL_INITIAL (fieldlist))
5950     fieldlist = TREE_CHAIN (fieldlist);
5951   /* Delete all such members from the rest of the fieldlist */
5952   for (x = fieldlist; x;)
5953     {
5954       if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
5955         TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5956       else x = TREE_CHAIN (x);
5957     }
5958
5959   /*  Now we have the truly final field list.
5960       Store it in this type and in the variants.  */
5961
5962   TYPE_FIELDS (t) = fieldlist;
5963
5964   /* If there are lots of fields, sort so we can look through them fast.
5965      We arbitrarily consider 16 or more elts to be "a lot".  */
5966   {
5967     int len = 0;
5968
5969     for (x = fieldlist; x; x = TREE_CHAIN (x))
5970       {
5971         if (len > 15)
5972           break;
5973         len += 1;
5974       }
5975     if (len > 15)
5976       {
5977         tree *field_array;
5978         char *space;
5979
5980         len += list_length (x);
5981         /* Use the same allocation policy here that make_node uses, to
5982            ensure that this lives as long as the rest of the struct decl.
5983            All decls in an inline function need to be saved.  */
5984         if (allocation_temporary_p ())
5985           space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
5986         else
5987           space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
5988
5989         TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
5990         TYPE_LANG_SPECIFIC (t)->len = len;
5991
5992         field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
5993         len = 0;
5994         for (x = fieldlist; x; x = TREE_CHAIN (x))
5995           field_array[len++] = x;
5996
5997         qsort (field_array, len, sizeof (tree), field_decl_cmp);
5998       }
5999   }
6000
6001   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
6002     {
6003       TYPE_FIELDS (x) = TYPE_FIELDS (t);
6004       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
6005       TYPE_ALIGN (x) = TYPE_ALIGN (t);
6006     }
6007
6008   /* If this was supposed to be a transparent union, but we can't
6009      make it one, warn and turn off the flag.  */
6010   if (TREE_CODE (t) == UNION_TYPE
6011       && TYPE_TRANSPARENT_UNION (t)
6012       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
6013     {
6014       TYPE_TRANSPARENT_UNION (t) = 0;
6015       warning ("union cannot be made transparent");
6016     }
6017
6018   /* If this structure or union completes the type of any previous
6019      variable declaration, lay it out and output its rtl.  */
6020
6021   if (current_binding_level->n_incomplete != 0)
6022     {
6023       tree decl;
6024       for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
6025         {
6026           if (TREE_TYPE (decl) == t
6027               && TREE_CODE (decl) != TYPE_DECL)
6028             {
6029               layout_decl (decl, 0);
6030               /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
6031               maybe_objc_check_decl (decl);
6032               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
6033               if (! toplevel)
6034                 expand_decl (decl);
6035               --current_binding_level->n_incomplete;
6036             }
6037           else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
6038                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
6039             {
6040               tree element = TREE_TYPE (decl);
6041               while (TREE_CODE (element) == ARRAY_TYPE)
6042                 element = TREE_TYPE (element);
6043               if (element == t)
6044                 layout_array_type (TREE_TYPE (decl));
6045             }
6046         }
6047     }
6048
6049   resume_momentary (old_momentary);
6050
6051   /* Finish debugging output for this type.  */
6052   rest_of_type_compilation (t, toplevel);
6053
6054   /* The matching push is in start_struct.  */
6055   pop_obstacks ();
6056
6057   return t;
6058 }
6059
6060 /* Lay out the type T, and its element type, and so on.  */
6061
6062 static void
6063 layout_array_type (t)
6064      tree t;
6065 {
6066   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
6067     layout_array_type (TREE_TYPE (t));
6068   layout_type (t);
6069 }
6070 \f
6071 /* Begin compiling the definition of an enumeration type.
6072    NAME is its name (or null if anonymous).
6073    Returns the type object, as yet incomplete.
6074    Also records info about it so that build_enumerator
6075    may be used to declare the individual values as they are read.  */
6076
6077 tree
6078 start_enum (name)
6079      tree name;
6080 {
6081   register tree enumtype = 0;
6082
6083   /* If this is the real definition for a previous forward reference,
6084      fill in the contents in the same object that used to be the
6085      forward reference.  */
6086
6087   if (name != 0)
6088     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
6089
6090   /* The corresponding pop_obstacks is in finish_enum.  */
6091   push_obstacks_nochange ();
6092   /* If these symbols and types are global, make them permanent.  */
6093   if (current_binding_level == global_binding_level)
6094     end_temporary_allocation ();
6095
6096   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
6097     {
6098       enumtype = make_node (ENUMERAL_TYPE);
6099       pushtag (name, enumtype);
6100     }
6101
6102   C_TYPE_BEING_DEFINED (enumtype) = 1;
6103
6104   if (TYPE_VALUES (enumtype) != 0)
6105     {
6106       /* This enum is a named one that has been declared already.  */
6107       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
6108
6109       /* Completely replace its old definition.
6110          The old enumerators remain defined, however.  */
6111       TYPE_VALUES (enumtype) = 0;
6112     }
6113
6114   enum_next_value = integer_zero_node;
6115   enum_overflow = 0;
6116
6117   if (flag_short_enums)
6118     TYPE_PACKED (enumtype) = 1;
6119
6120   return enumtype;
6121 }
6122
6123 /* After processing and defining all the values of an enumeration type,
6124    install their decls in the enumeration type and finish it off.
6125    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
6126    and ATTRIBUTES are the specified attributes.
6127    Returns ENUMTYPE.  */
6128
6129 tree
6130 finish_enum (enumtype, values, attributes)
6131      tree enumtype;
6132      tree values;
6133      tree attributes;
6134 {
6135   register tree pair, tem;
6136   tree minnode = 0, maxnode = 0;
6137   int lowprec, highprec, precision;
6138   int toplevel = global_binding_level == current_binding_level;
6139
6140   if (in_parm_level_p ())
6141     warning ("enum defined inside parms");
6142
6143   decl_attributes (enumtype, attributes, NULL_TREE);
6144
6145   /* Calculate the maximum value of any enumerator in this type.  */
6146
6147   if (values == error_mark_node)
6148     minnode = maxnode = integer_zero_node;
6149   else
6150     for (pair = values; pair; pair = TREE_CHAIN (pair))
6151       {
6152         tree value = TREE_VALUE (pair);
6153         if (pair == values)
6154           minnode = maxnode = TREE_VALUE (pair);
6155         else
6156           {
6157             if (tree_int_cst_lt (maxnode, value))
6158               maxnode = value;
6159             if (tree_int_cst_lt (value, minnode))
6160               minnode = value;
6161           }
6162       }
6163
6164   TYPE_MIN_VALUE (enumtype) = minnode;
6165   TYPE_MAX_VALUE (enumtype) = maxnode;
6166
6167   /* An enum can have some negative values; then it is signed.  */
6168   TREE_UNSIGNED (enumtype) = tree_int_cst_sgn (minnode) >= 0;
6169
6170   /* Determine the precision this type needs.  */
6171
6172   lowprec = min_precision (minnode, TREE_UNSIGNED (enumtype));
6173   highprec = min_precision (maxnode, TREE_UNSIGNED (enumtype));
6174   precision = MAX (lowprec, highprec);
6175
6176   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
6177     {
6178       tree narrowest = type_for_size (precision, 1);
6179       if (narrowest == 0)
6180         {
6181           warning ("enumeration values exceed range of largest integer");
6182           narrowest = long_long_integer_type_node;
6183         }
6184
6185       TYPE_PRECISION (enumtype) = TYPE_PRECISION (narrowest);
6186     }
6187   else
6188     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
6189
6190   TYPE_SIZE (enumtype) = 0;
6191   layout_type (enumtype);
6192
6193   if (values != error_mark_node)
6194     {
6195       /* Change the type of the enumerators to be the enum type.
6196          Formerly this was done only for enums that fit in an int,
6197          but the comment said it was done only for enums wider than int.
6198          It seems necessary to do this for wide enums,
6199          and best not to change what's done for ordinary narrower ones.  */
6200       for (pair = values; pair; pair = TREE_CHAIN (pair))
6201         {
6202           TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
6203           DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
6204           if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL)
6205             DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
6206         }
6207
6208       /* Replace the decl nodes in VALUES with their names.  */
6209       for (pair = values; pair; pair = TREE_CHAIN (pair))
6210         TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
6211
6212       TYPE_VALUES (enumtype) = values;
6213     }
6214
6215   /* Fix up all variant types of this enum type.  */
6216   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
6217     {
6218       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
6219       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
6220       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
6221       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
6222       TYPE_MODE (tem) = TYPE_MODE (enumtype);
6223       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
6224       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
6225       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
6226     }
6227
6228   /* Finish debugging output for this type.  */
6229   rest_of_type_compilation (enumtype, toplevel);
6230
6231   /* This matches a push in start_enum.  */
6232   pop_obstacks ();
6233
6234   return enumtype;
6235 }
6236
6237 /* Build and install a CONST_DECL for one value of the
6238    current enumeration type (one that was begun with start_enum).
6239    Return a tree-list containing the CONST_DECL and its value.
6240    Assignment of sequential values by default is handled here.  */
6241
6242 tree
6243 build_enumerator (name, value)
6244      tree name, value;
6245 {
6246   register tree decl, type;
6247
6248   /* Validate and default VALUE.  */
6249
6250   /* Remove no-op casts from the value.  */
6251   if (value)
6252     STRIP_TYPE_NOPS (value);
6253
6254   if (value != 0)
6255     {
6256       if (TREE_CODE (value) == INTEGER_CST)
6257         {
6258           value = default_conversion (value);
6259           constant_expression_warning (value);
6260         }
6261       else
6262         {
6263           error ("enumerator value for `%s' not integer constant",
6264                  IDENTIFIER_POINTER (name));
6265           value = 0;
6266         }
6267     }
6268
6269   /* Default based on previous value.  */
6270   /* It should no longer be possible to have NON_LVALUE_EXPR
6271      in the default.  */
6272   if (value == 0)
6273     {
6274       value = enum_next_value;
6275       if (enum_overflow)
6276         error ("overflow in enumeration values");
6277     }
6278
6279   if (pedantic && ! int_fits_type_p (value, integer_type_node))
6280     {
6281       pedwarn ("ANSI C restricts enumerator values to range of `int'");
6282       value = integer_zero_node;
6283     }
6284
6285   /* Set basis for default for next value.  */
6286   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
6287   enum_overflow = tree_int_cst_lt (enum_next_value, value);
6288
6289   /* Now create a declaration for the enum value name.  */
6290
6291   type = TREE_TYPE (value);
6292   type = type_for_size (MAX (TYPE_PRECISION (type),
6293                              TYPE_PRECISION (integer_type_node)),
6294                         ((flag_traditional
6295                           || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
6296                          && TREE_UNSIGNED (type)));
6297
6298   decl = build_decl (CONST_DECL, name, type);
6299   DECL_INITIAL (decl) = value;
6300   TREE_TYPE (value) = type;
6301   pushdecl (decl);
6302
6303   return saveable_tree_cons (decl, value, NULL_TREE);
6304 }
6305 \f
6306 /* Create the FUNCTION_DECL for a function definition.
6307    DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of
6308    the declaration; they describe the function's name and the type it returns,
6309    but twisted together in a fashion that parallels the syntax of C.
6310
6311    This function creates a binding context for the function body
6312    as well as setting up the FUNCTION_DECL in current_function_decl.
6313
6314    Returns 1 on success.  If the DECLARATOR is not suitable for a function
6315    (it defines a datum instead), we return 0, which tells
6316    yyparse to report a parse error.
6317
6318    NESTED is nonzero for a function nested within another function.  */
6319
6320 int
6321 start_function (declspecs, declarator, prefix_attributes, attributes, nested)
6322      tree declarator, declspecs, prefix_attributes, attributes;
6323      int nested;
6324 {
6325   tree decl1, old_decl;
6326   tree restype;
6327   int old_immediate_size_expand = immediate_size_expand;
6328
6329   current_function_returns_value = 0;  /* Assume, until we see it does.  */
6330   current_function_returns_null = 0;
6331   warn_about_return_type = 0;
6332   current_extern_inline = 0;
6333   c_function_varargs = 0;
6334   named_labels = 0;
6335   shadowed_labels = 0;
6336
6337   /* Don't expand any sizes in the return type of the function.  */
6338   immediate_size_expand = 0;
6339
6340   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
6341
6342   /* If the declarator is not suitable for a function definition,
6343      cause a syntax error.  */
6344   if (decl1 == 0)
6345     {
6346       immediate_size_expand = old_immediate_size_expand;
6347       return 0;
6348     }
6349
6350   decl_attributes (decl1, prefix_attributes, attributes);
6351
6352   announce_function (decl1);
6353
6354   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
6355     {
6356       error ("return-type is an incomplete type");
6357       /* Make it return void instead.  */
6358       TREE_TYPE (decl1)
6359         = build_function_type (void_type_node,
6360                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6361     }
6362
6363   if (warn_about_return_type)
6364     warning ("return-type defaults to `int'");
6365
6366   /* Save the parm names or decls from this function's declarator
6367      where store_parm_decls will find them.  */
6368   current_function_parms = last_function_parms;
6369   current_function_parm_tags = last_function_parm_tags;
6370
6371   /* Make the init_value nonzero so pushdecl knows this is not tentative.
6372      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
6373   DECL_INITIAL (decl1) = error_mark_node;
6374
6375   /* If this definition isn't a prototype and we had a prototype declaration
6376      before, copy the arg type info from that prototype.
6377      But not if what we had before was a builtin function.  */
6378   old_decl = lookup_name_current_level (DECL_NAME (decl1));
6379   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6380       && !DECL_BUILT_IN (old_decl)
6381       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6382           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
6383       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6384     {
6385       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
6386       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
6387       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
6388     }
6389
6390   /* If there is no explicit declaration, look for any out-of-scope implicit
6391      declarations.  */
6392   if (old_decl == 0)
6393     old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
6394
6395   /* Optionally warn of old-fashioned def with no previous prototype.  */
6396   if (warn_strict_prototypes
6397       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6398       && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
6399     warning ("function declaration isn't a prototype");
6400   /* Optionally warn of any global def with no previous prototype.  */
6401   else if (warn_missing_prototypes
6402            && TREE_PUBLIC (decl1)
6403            && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
6404            && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6405     warning_with_decl (decl1, "no previous prototype for `%s'");
6406   /* Optionally warn of any def with no previous prototype
6407      if the function has already been used.  */
6408   else if (warn_missing_prototypes
6409            && old_decl != 0 && TREE_USED (old_decl)
6410            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6411     warning_with_decl (decl1,
6412                       "`%s' was used with no prototype before its definition");
6413   /* Optionally warn of any global def with no previous declaration.  */
6414   else if (warn_missing_declarations
6415            && TREE_PUBLIC (decl1)
6416            && old_decl == 0
6417            && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6418     warning_with_decl (decl1, "no previous declaration for `%s'");
6419   /* Optionally warn of any def with no previous declaration
6420      if the function has already been used.  */
6421   else if (warn_missing_declarations
6422            && old_decl != 0 && TREE_USED (old_decl)
6423            && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
6424     warning_with_decl (decl1,
6425                     "`%s' was used with no declaration before its definition");
6426
6427   /* This is a definition, not a reference.
6428      So normally clear DECL_EXTERNAL.
6429      However, `extern inline' acts like a declaration
6430      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
6431   DECL_EXTERNAL (decl1) = current_extern_inline;
6432
6433   /* This function exists in static storage.
6434      (This does not mean `static' in the C sense!)  */
6435   TREE_STATIC (decl1) = 1;
6436
6437   /* A nested function is not global.  */
6438   if (current_function_decl != 0)
6439     TREE_PUBLIC (decl1) = 0;
6440
6441   /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6442   if (warn_main
6443       && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))) == 0)
6444     {
6445       tree args;
6446       int argct = 0;
6447
6448       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6449            != integer_type_node)
6450         pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
6451
6452       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6453            args = TREE_CHAIN (args))
6454         {
6455           tree type = args ? TREE_VALUE (args) : 0;
6456
6457           if (type == void_type_node)
6458             break;
6459
6460           ++argct;
6461           switch (argct)
6462             {
6463             case 1:
6464               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6465                 pedwarn_with_decl (decl1,
6466                                    "first argument of `%s' should be `int'");
6467               break;
6468
6469             case 2:
6470               if (TREE_CODE (type) != POINTER_TYPE
6471                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6472                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6473                       != char_type_node))
6474                 pedwarn_with_decl (decl1,
6475                                "second argument of `%s' should be `char **'");
6476               break;
6477
6478             case 3:
6479               if (TREE_CODE (type) != POINTER_TYPE
6480                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6481                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6482                       != char_type_node))
6483                 pedwarn_with_decl (decl1,
6484                    "third argument of `%s' should probably be `char **'");
6485               break;
6486             }
6487         }
6488
6489       /* It is intentional that this message does not mention the third
6490          argument, which is warned for only pedantically, because it's
6491          blessed by mention in an appendix of the standard. */
6492       if (argct > 0 && (argct < 2 || argct > 3))
6493         pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6494
6495       if (argct == 3 && pedantic)
6496         pedwarn_with_decl (decl1, "third argument of `%s' is deprecated");
6497
6498       if (! TREE_PUBLIC (decl1))
6499         pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6500     }
6501
6502   /* Record the decl so that the function name is defined.
6503      If we already have a decl for this name, and it is a FUNCTION_DECL,
6504      use the old decl.  */
6505
6506   current_function_decl = pushdecl (decl1);
6507
6508   pushlevel (0);
6509   declare_parm_level (1);
6510   current_binding_level->subblocks_tag_transparent = 1;
6511
6512   make_function_rtl (current_function_decl);
6513
6514   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6515   /* Promote the value to int before returning it.  */
6516   if (C_PROMOTING_INTEGER_TYPE_P (restype))
6517     {
6518       /* It retains unsignedness if traditional
6519          or if not really getting wider.  */
6520       if (TREE_UNSIGNED (restype)
6521           && (flag_traditional
6522               || (TYPE_PRECISION (restype)
6523                   == TYPE_PRECISION (integer_type_node))))
6524         restype = unsigned_type_node;
6525       else
6526         restype = integer_type_node;
6527     }
6528   DECL_RESULT (current_function_decl)
6529     = build_decl (RESULT_DECL, NULL_TREE, restype);
6530
6531   if (!nested)
6532     /* Allocate further tree nodes temporarily during compilation
6533        of this function only.  */
6534     temporary_allocation ();
6535
6536   /* If this fcn was already referenced via a block-scope `extern' decl
6537      (or an implicit decl), propagate certain information about the usage.  */
6538   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6539     TREE_ADDRESSABLE (current_function_decl) = 1;
6540
6541   immediate_size_expand = old_immediate_size_expand;
6542
6543   return 1;
6544 }
6545
6546 /* Record that this function is going to be a varargs function.
6547    This is called before store_parm_decls, which is too early
6548    to call mark_varargs directly.  */
6549
6550 void
6551 c_mark_varargs ()
6552 {
6553   c_function_varargs = 1;
6554 }
6555 \f
6556 /* Store the parameter declarations into the current function declaration.
6557    This is called after parsing the parameter declarations, before
6558    digesting the body of the function.
6559
6560    For an old-style definition, modify the function's type
6561    to specify at least the number of arguments.  */
6562
6563 void
6564 store_parm_decls ()
6565 {
6566   register tree fndecl = current_function_decl;
6567   register tree parm;
6568
6569   /* This is either a chain of PARM_DECLs (if a prototype was used)
6570      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
6571   tree specparms = current_function_parms;
6572
6573   /* This is a list of types declared among parms in a prototype.  */
6574   tree parmtags = current_function_parm_tags;
6575
6576   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
6577   register tree parmdecls = getdecls ();
6578
6579   /* This is a chain of any other decls that came in among the parm
6580      declarations.  If a parm is declared with  enum {foo, bar} x;
6581      then CONST_DECLs for foo and bar are put here.  */
6582   tree nonparms = 0;
6583
6584   /* Nonzero if this definition is written with a prototype.  */
6585   int prototype = 0;
6586
6587   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6588     {
6589       /* This case is when the function was defined with an ANSI prototype.
6590          The parms already have decls, so we need not do anything here
6591          except record them as in effect
6592          and complain if any redundant old-style parm decls were written.  */
6593
6594       register tree next;
6595       tree others = 0;
6596
6597       prototype = 1;
6598
6599       if (parmdecls != 0)
6600         {
6601           tree decl, link;
6602
6603           error_with_decl (fndecl,
6604                            "parm types given both in parmlist and separately");
6605           /* Get rid of the erroneous decls; don't keep them on
6606              the list of parms, since they might not be PARM_DECLs.  */
6607           for (decl = current_binding_level->names;
6608                decl; decl = TREE_CHAIN (decl))
6609             if (DECL_NAME (decl))
6610               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6611           for (link = current_binding_level->shadowed;
6612                link; link = TREE_CHAIN (link))
6613             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6614           current_binding_level->names = 0;
6615           current_binding_level->shadowed = 0;
6616         }
6617
6618       specparms = nreverse (specparms);
6619       for (parm = specparms; parm; parm = next)
6620         {
6621           next = TREE_CHAIN (parm);
6622           if (TREE_CODE (parm) == PARM_DECL)
6623             {
6624               if (DECL_NAME (parm) == 0)
6625                 error_with_decl (parm, "parameter name omitted");
6626               else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6627                 {
6628                   error_with_decl (parm, "parameter `%s' declared void");
6629                   /* Change the type to error_mark_node so this parameter
6630                      will be ignored by assign_parms.  */
6631                   TREE_TYPE (parm) = error_mark_node;
6632                 }
6633               pushdecl (parm);
6634             }
6635           else
6636             {
6637               /* If we find an enum constant or a type tag,
6638                  put it aside for the moment.  */
6639               TREE_CHAIN (parm) = 0;
6640               others = chainon (others, parm);
6641             }
6642         }
6643
6644       /* Get the decls in their original chain order
6645          and record in the function.  */
6646       DECL_ARGUMENTS (fndecl) = getdecls ();
6647
6648 #if 0
6649       /* If this function takes a variable number of arguments,
6650          add a phony parameter to the end of the parm list,
6651          to represent the position of the first unnamed argument.  */
6652       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6653           != void_type_node)
6654         {
6655           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6656           /* Let's hope the address of the unnamed parm
6657              won't depend on its type.  */
6658           TREE_TYPE (dummy) = integer_type_node;
6659           DECL_ARG_TYPE (dummy) = integer_type_node;
6660           DECL_ARGUMENTS (fndecl)
6661             = chainon (DECL_ARGUMENTS (fndecl), dummy);
6662         }
6663 #endif
6664
6665       /* Now pushdecl the enum constants.  */
6666       for (parm = others; parm; parm = next)
6667         {
6668           next = TREE_CHAIN (parm);
6669           if (DECL_NAME (parm) == 0)
6670             ;
6671           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6672             ;
6673           else if (TREE_CODE (parm) != PARM_DECL)
6674             pushdecl (parm);
6675         }
6676
6677       storetags (chainon (parmtags, gettags ()));
6678     }
6679   else
6680     {
6681       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6682          each with a parm name as the TREE_VALUE.
6683
6684          PARMDECLS is a chain of declarations for parameters.
6685          Warning! It can also contain CONST_DECLs which are not parameters
6686          but are names of enumerators of any enum types
6687          declared among the parameters.
6688
6689          First match each formal parameter name with its declaration.
6690          Associate decls with the names and store the decls
6691          into the TREE_PURPOSE slots.  */
6692
6693       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6694         DECL_RESULT (parm) = 0;
6695
6696       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6697         {
6698           register tree tail, found = NULL;
6699
6700           if (TREE_VALUE (parm) == 0)
6701             {
6702               error_with_decl (fndecl, "parameter name missing from parameter list");
6703               TREE_PURPOSE (parm) = 0;
6704               continue;
6705             }
6706
6707           /* See if any of the parmdecls specifies this parm by name.
6708              Ignore any enumerator decls.  */
6709           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6710             if (DECL_NAME (tail) == TREE_VALUE (parm)
6711                 && TREE_CODE (tail) == PARM_DECL)
6712               {
6713                 found = tail;
6714                 break;
6715               }
6716
6717           /* If declaration already marked, we have a duplicate name.
6718              Complain, and don't use this decl twice.   */
6719           if (found && DECL_RESULT (found) != 0)
6720             {
6721               error_with_decl (found, "multiple parameters named `%s'");
6722               found = 0;
6723             }
6724
6725           /* If the declaration says "void", complain and ignore it.  */
6726           if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6727             {
6728               error_with_decl (found, "parameter `%s' declared void");
6729               TREE_TYPE (found) = integer_type_node;
6730               DECL_ARG_TYPE (found) = integer_type_node;
6731               layout_decl (found, 0);
6732             }
6733
6734           /* Traditionally, a parm declared float is actually a double.  */
6735           if (found && flag_traditional
6736               && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6737             {
6738               TREE_TYPE (found) = double_type_node;
6739               DECL_ARG_TYPE (found) = double_type_node;
6740               layout_decl (found, 0);
6741             }
6742
6743           /* If no declaration found, default to int.  */
6744           if (!found)
6745             {
6746               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6747                                   integer_type_node);
6748               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6749               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6750               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6751               if (extra_warnings)
6752                 warning_with_decl (found, "type of `%s' defaults to `int'");
6753               pushdecl (found);
6754             }
6755
6756           TREE_PURPOSE (parm) = found;
6757
6758           /* Mark this decl as "already found" -- see test, above.
6759              It is safe to use DECL_RESULT for this
6760              since it is not used in PARM_DECLs or CONST_DECLs.  */
6761           DECL_RESULT (found) = error_mark_node;
6762         }
6763
6764       /* Put anything which is on the parmdecls chain and which is
6765          not a PARM_DECL onto the list NONPARMS.  (The types of
6766          non-parm things which might appear on the list include
6767          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6768          any actual PARM_DECLs not matched with any names.  */
6769
6770       nonparms = 0;
6771       for (parm = parmdecls; parm; )
6772         {
6773           tree next = TREE_CHAIN (parm);
6774           TREE_CHAIN (parm) = 0;
6775
6776           if (TREE_CODE (parm) != PARM_DECL)
6777             nonparms = chainon (nonparms, parm);
6778           else
6779             {
6780               /* Complain about args with incomplete types.  */
6781               if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6782                 {
6783                   error_with_decl (parm, "parameter `%s' has incomplete type");
6784                   TREE_TYPE (parm) = error_mark_node;
6785                 }
6786
6787               if (DECL_RESULT (parm) == 0)
6788                 {
6789                   error_with_decl (parm,
6790                                    "declaration for parameter `%s' but no such parameter");
6791                   /* Pretend the parameter was not missing.
6792                      This gets us to a standard state and minimizes
6793                      further error messages.  */
6794                   specparms
6795                     = chainon (specparms,
6796                                tree_cons (parm, NULL_TREE, NULL_TREE));
6797                 }
6798             }
6799
6800           parm = next;
6801         }
6802
6803       /* Chain the declarations together in the order of the list of names.  */
6804       /* Store that chain in the function decl, replacing the list of names.  */
6805       parm = specparms;
6806       DECL_ARGUMENTS (fndecl) = 0;
6807       {
6808         register tree last;
6809         for (last = 0; parm; parm = TREE_CHAIN (parm))
6810           if (TREE_PURPOSE (parm))
6811             {
6812               if (last == 0)
6813                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6814               else
6815                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6816               last = TREE_PURPOSE (parm);
6817               TREE_CHAIN (last) = 0;
6818             }
6819       }
6820
6821       /* If there was a previous prototype,
6822          set the DECL_ARG_TYPE of each argument according to
6823          the type previously specified, and report any mismatches.  */
6824
6825       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6826         {
6827           register tree type;
6828           for (parm = DECL_ARGUMENTS (fndecl),
6829                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6830                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6831                                  != void_type_node));
6832                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6833             {
6834               if (parm == 0 || type == 0
6835                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6836                 {
6837                   error ("number of arguments doesn't match prototype");
6838                   error_with_file_and_line (current_function_prototype_file,
6839                                             current_function_prototype_line,
6840                                             "prototype declaration");
6841                   break;
6842                 }
6843               /* Type for passing arg must be consistent
6844                  with that declared for the arg.  */
6845               if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6846                 {
6847                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6848                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6849                     {
6850                       /* Adjust argument to match prototype.  E.g. a previous
6851                          `int foo(float);' prototype causes
6852                          `int foo(x) float x; {...}' to be treated like
6853                          `int foo(float x) {...}'.  This is particularly
6854                          useful for argument types like uid_t.  */
6855                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6856 #ifdef PROMOTE_PROTOTYPES
6857                       if ((TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6858                            || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6859                           && TYPE_PRECISION (TREE_TYPE (parm))
6860                           < TYPE_PRECISION (integer_type_node))
6861                         DECL_ARG_TYPE (parm) = integer_type_node;
6862 #endif
6863                       if (pedantic)
6864                         {
6865                           pedwarn ("promoted argument `%s' doesn't match prototype",
6866                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6867                           warning_with_file_and_line
6868                             (current_function_prototype_file,
6869                              current_function_prototype_line,
6870                              "prototype declaration");
6871                         }
6872                     }
6873                   /* If -traditional, allow `int' argument to match
6874                      `unsigned' prototype.  */
6875                   else if (! (flag_traditional
6876                               && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6877                               && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6878                     {
6879                       error ("argument `%s' doesn't match prototype",
6880                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6881                       error_with_file_and_line (current_function_prototype_file,
6882                                                 current_function_prototype_line,
6883                                                 "prototype declaration");
6884                     }
6885                 }
6886             }
6887           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6888         }
6889
6890       /* Otherwise, create a prototype that would match.  */
6891
6892       else
6893         {
6894           tree actual = 0, last = 0, type;
6895
6896           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6897             {
6898               type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm),
6899                                      NULL_TREE);
6900               if (last)
6901                 TREE_CHAIN (last) = type;
6902               else
6903                 actual = type;
6904               last = type;
6905             }
6906           type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6907           if (last)
6908             TREE_CHAIN (last) = type;
6909           else
6910             actual = type;
6911
6912           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6913              of the type of this function, but we need to avoid having this
6914              affect the types of other similarly-typed functions, so we must
6915              first force the generation of an identical (but separate) type
6916              node for the relevant function type.  The new node we create
6917              will be a variant of the main variant of the original function
6918              type.  */
6919
6920           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6921
6922           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6923         }
6924
6925       /* Now store the final chain of decls for the arguments
6926          as the decl-chain of the current lexical scope.
6927          Put the enumerators in as well, at the front so that
6928          DECL_ARGUMENTS is not modified.  */
6929
6930       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6931     }
6932
6933   /* Make sure the binding level for the top of the function body
6934      gets a BLOCK if there are any in the function.
6935      Otherwise, the dbx output is wrong.  */
6936
6937   keep_next_if_subblocks = 1;
6938
6939   /* ??? This might be an improvement,
6940      but needs to be thought about some more.  */
6941 #if 0
6942   keep_next_level_flag = 1;
6943 #endif
6944
6945   /* Write a record describing this function definition to the prototypes
6946      file (if requested).  */
6947
6948   gen_aux_info_record (fndecl, 1, 0, prototype);
6949
6950   /* Initialize the RTL code for the function.  */
6951
6952   init_function_start (fndecl, input_filename, lineno);
6953
6954   /* If this is a varargs function, inform function.c.  */
6955
6956   if (c_function_varargs)
6957     mark_varargs ();
6958
6959   /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
6960
6961   declare_function_name ();
6962
6963   /* Set up parameters and prepare for return, for the function.  */
6964
6965   expand_function_start (fndecl, 0);
6966
6967   /* If this function is `main', emit a call to `__main'
6968      to run global initializers, etc.  */
6969   if (DECL_NAME (fndecl)
6970       && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
6971       && DECL_CONTEXT (fndecl) == NULL_TREE)
6972     expand_main_function ();
6973 }
6974 \f
6975 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6976    each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
6977    stands for an ellipsis in the identifier list.
6978
6979    PARMLIST is the data returned by get_parm_info for the
6980    parmlist that follows the semicolon.
6981
6982    We return a value of the same sort that get_parm_info returns,
6983    except that it describes the combination of identifiers and parmlist.  */
6984
6985 tree
6986 combine_parm_decls (specparms, parmlist, void_at_end)
6987      tree specparms, parmlist;
6988      int void_at_end;
6989 {
6990   register tree fndecl = current_function_decl;
6991   register tree parm;
6992
6993   tree parmdecls = TREE_PURPOSE (parmlist);
6994
6995   /* This is a chain of any other decls that came in among the parm
6996      declarations.  They were separated already by get_parm_info,
6997      so we just need to keep them separate.  */
6998   tree nonparms = TREE_VALUE (parmlist);
6999
7000   tree types = 0;
7001
7002   for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
7003     DECL_RESULT (parm) = 0;
7004
7005   for (parm = specparms; parm; parm = TREE_CHAIN (parm))
7006     {
7007       register tree tail, found = NULL;
7008
7009       /* See if any of the parmdecls specifies this parm by name.  */
7010       for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
7011         if (DECL_NAME (tail) == TREE_VALUE (parm))
7012           {
7013             found = tail;
7014             break;
7015           }
7016
7017       /* If declaration already marked, we have a duplicate name.
7018          Complain, and don't use this decl twice.   */
7019       if (found && DECL_RESULT (found) != 0)
7020         {
7021           error_with_decl (found, "multiple parameters named `%s'");
7022           found = 0;
7023         }
7024
7025       /* If the declaration says "void", complain and ignore it.  */
7026       if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
7027         {
7028           error_with_decl (found, "parameter `%s' declared void");
7029           TREE_TYPE (found) = integer_type_node;
7030           DECL_ARG_TYPE (found) = integer_type_node;
7031           layout_decl (found, 0);
7032         }
7033
7034       /* Traditionally, a parm declared float is actually a double.  */
7035       if (found && flag_traditional
7036           && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
7037         {
7038           TREE_TYPE (found) = double_type_node;
7039           DECL_ARG_TYPE (found) = double_type_node;
7040           layout_decl (found, 0);
7041         }
7042
7043       /* If no declaration found, default to int.  */
7044       if (!found)
7045         {
7046           found = build_decl (PARM_DECL, TREE_VALUE (parm),
7047                               integer_type_node);
7048           DECL_ARG_TYPE (found) = TREE_TYPE (found);
7049           DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
7050           DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
7051           error_with_decl (found, "type of parameter `%s' is not declared");
7052           pushdecl (found);
7053         }
7054
7055       TREE_PURPOSE (parm) = found;
7056
7057       /* Mark this decl as "already found" -- see test, above.
7058          It is safe to use DECL_RESULT for this
7059          since it is not used in PARM_DECLs or CONST_DECLs.  */
7060       DECL_RESULT (found) = error_mark_node;
7061     }
7062
7063   /* Complain about any actual PARM_DECLs not matched with any names.  */
7064
7065   for (parm = parmdecls; parm; )
7066     {
7067       tree next = TREE_CHAIN (parm);
7068       TREE_CHAIN (parm) = 0;
7069
7070       /* Complain about args with incomplete types.  */
7071       if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
7072         {
7073           error_with_decl (parm, "parameter `%s' has incomplete type");
7074           TREE_TYPE (parm) = error_mark_node;
7075         }
7076
7077       if (DECL_RESULT (parm) == 0)
7078         {
7079           error_with_decl (parm,
7080                            "declaration for parameter `%s' but no such parameter");
7081           /* Pretend the parameter was not missing.
7082              This gets us to a standard state and minimizes
7083              further error messages.  */
7084           specparms
7085             = chainon (specparms,
7086                        tree_cons (parm, NULL_TREE, NULL_TREE));
7087         }
7088
7089       parm = next;
7090     }
7091
7092   /* Chain the declarations together in the order of the list of names.
7093      At the same time, build up a list of their types, in reverse order.  */
7094
7095   parm = specparms;
7096   parmdecls = 0;
7097   {
7098     register tree last;
7099     for (last = 0; parm; parm = TREE_CHAIN (parm))
7100       if (TREE_PURPOSE (parm))
7101         {
7102           if (last == 0)
7103             parmdecls = TREE_PURPOSE (parm);
7104           else
7105             TREE_CHAIN (last) = TREE_PURPOSE (parm);
7106           last = TREE_PURPOSE (parm);
7107           TREE_CHAIN (last) = 0;
7108
7109           types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
7110         }
7111   }
7112
7113   if (void_at_end)
7114     return saveable_tree_cons (parmdecls, nonparms,
7115                                nreverse (saveable_tree_cons (NULL_TREE,
7116                                                              void_type_node,
7117                                                              types)));
7118
7119   return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
7120 }
7121 \f
7122 /* Finish up a function declaration and compile that function
7123    all the way to assembler language output.  The free the storage
7124    for the function definition.
7125
7126    This is called after parsing the body of the function definition.
7127
7128    NESTED is nonzero if the function being finished is nested in another.  */
7129
7130 void
7131 finish_function (nested)
7132      int nested;
7133 {
7134   register tree fndecl = current_function_decl;
7135
7136 /*  TREE_READONLY (fndecl) = 1;
7137     This caused &foo to be of type ptr-to-const-function
7138     which then got a warning when stored in a ptr-to-function variable.  */
7139
7140   poplevel (1, 0, 1);
7141   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7142
7143   /* Must mark the RESULT_DECL as being in this function.  */
7144
7145   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
7146
7147   /* Obey `register' declarations if `setjmp' is called in this fn.  */
7148   if (flag_traditional && current_function_calls_setjmp)
7149     {
7150       setjmp_protect (DECL_INITIAL (fndecl));
7151       setjmp_protect_args ();
7152     }
7153
7154   if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
7155     {
7156       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
7157           != integer_type_node)
7158         {
7159           /* You would expect the sense of this test to be the other way
7160              around, but if warn_main is set, we will already have warned,
7161              so this would be a duplicate.  This is the warning you get
7162              in some environments even if you *don't* ask for it, because
7163              these are environments where it may be more of a problem than
7164              usual.  */
7165           if (! warn_main)
7166             pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
7167         }
7168       else
7169         {
7170 #ifdef DEFAULT_MAIN_RETURN
7171           /* Make it so that `main' always returns success by default.  */
7172           DEFAULT_MAIN_RETURN;
7173 #endif
7174         }
7175     }
7176
7177   /* Generate rtl for function exit.  */
7178   expand_function_end (input_filename, lineno, 0);
7179
7180   /* So we can tell if jump_optimize sets it to 1.  */
7181   can_reach_end = 0;
7182
7183   /* Run the optimizers and output the assembler code for this function.  */
7184   rest_of_compilation (fndecl);
7185
7186   current_function_returns_null |= can_reach_end;
7187
7188   if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
7189     warning ("`noreturn' function does return");
7190   else if (warn_return_type && can_reach_end
7191            && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
7192     /* If this function returns non-void and control can drop through,
7193        complain.  */
7194     warning ("control reaches end of non-void function");
7195   /* With just -W, complain only if function returns both with
7196      and without a value.  */
7197   else if (extra_warnings
7198            && current_function_returns_value && current_function_returns_null)
7199     warning ("this function may return with or without a value");
7200
7201   /* If requested, warn about function definitions where the function will
7202      return a value (usually of some struct or union type) which itself will
7203      take up a lot of stack space.  */
7204
7205   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
7206     {
7207       register tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
7208
7209       if (ret_type)
7210         {
7211           register tree ret_type_size = TYPE_SIZE (ret_type);
7212
7213           if (TREE_CODE (ret_type_size) == INTEGER_CST)
7214             {
7215               unsigned units
7216                 = TREE_INT_CST_LOW (ret_type_size) / BITS_PER_UNIT;
7217
7218               if (units > larger_than_size)
7219                 warning_with_decl (fndecl,
7220                                    "size of return value of `%s' is %u bytes",
7221                                    units);
7222             }
7223         }
7224     }
7225
7226   /* Free all the tree nodes making up this function.  */
7227   /* Switch back to allocating nodes permanently
7228      until we start another function.  */
7229   if (! nested)
7230     permanent_allocation (1);
7231
7232   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
7233     {
7234       /* Stop pointing to the local nodes about to be freed.  */
7235       /* But DECL_INITIAL must remain nonzero so we know this
7236          was an actual function definition.  */
7237       /* For a nested function, this is done in pop_c_function_context.  */
7238       /* If rest_of_compilation set this to 0, leave it 0.  */
7239       if (DECL_INITIAL (fndecl) != 0)
7240         DECL_INITIAL (fndecl) = error_mark_node;
7241       DECL_ARGUMENTS (fndecl) = 0;
7242     }
7243
7244   if (DECL_STATIC_CONSTRUCTOR (fndecl))
7245     {
7246 #ifndef ASM_OUTPUT_CONSTRUCTOR
7247       if (! flag_gnu_linker)
7248         static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
7249       else
7250 #endif
7251       assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7252     }
7253   if (DECL_STATIC_DESTRUCTOR (fndecl))
7254     {
7255 #ifndef ASM_OUTPUT_DESTRUCTOR
7256       if (! flag_gnu_linker)
7257         static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
7258       else
7259 #endif
7260       assemble_destructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7261     }
7262
7263   if (! nested)
7264     {
7265       /* Let the error reporting routines know that we're outside a
7266          function.  For a nested function, this value is used in
7267          pop_c_function_context and then reset via pop_function_context.  */
7268       current_function_decl = NULL;
7269     }
7270 }
7271 \f
7272 /* Save and restore the variables in this file and elsewhere
7273    that keep track of the progress of compilation of the current function.
7274    Used for nested functions.  */
7275
7276 struct c_function
7277 {
7278   struct c_function *next;
7279   tree named_labels;
7280   tree shadowed_labels;
7281   int returns_value;
7282   int returns_null;
7283   int warn_about_return_type;
7284   int extern_inline;
7285   struct binding_level *binding_level;
7286 };
7287
7288 struct c_function *c_function_chain;
7289
7290 /* Save and reinitialize the variables
7291    used during compilation of a C function.  */
7292
7293 void
7294 push_c_function_context ()
7295 {
7296   struct c_function *p
7297     = (struct c_function *) xmalloc (sizeof (struct c_function));
7298
7299   if (pedantic)
7300     pedwarn ("ANSI C forbids nested functions");
7301
7302   push_function_context ();
7303
7304   p->next = c_function_chain;
7305   c_function_chain = p;
7306
7307   p->named_labels = named_labels;
7308   p->shadowed_labels = shadowed_labels;
7309   p->returns_value = current_function_returns_value;
7310   p->returns_null = current_function_returns_null;
7311   p->warn_about_return_type = warn_about_return_type;
7312   p->extern_inline = current_extern_inline;
7313   p->binding_level = current_binding_level;
7314 }
7315
7316 /* Restore the variables used during compilation of a C function.  */
7317
7318 void
7319 pop_c_function_context ()
7320 {
7321   struct c_function *p = c_function_chain;
7322   tree link;
7323
7324   /* Bring back all the labels that were shadowed.  */
7325   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
7326     if (DECL_NAME (TREE_VALUE (link)) != 0)
7327       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
7328         = TREE_VALUE (link);
7329
7330   if (DECL_SAVED_INSNS (current_function_decl) == 0)
7331     {
7332       /* Stop pointing to the local nodes about to be freed.  */
7333       /* But DECL_INITIAL must remain nonzero so we know this
7334          was an actual function definition.  */
7335       DECL_INITIAL (current_function_decl) = error_mark_node;
7336       DECL_ARGUMENTS (current_function_decl) = 0;
7337     }
7338
7339   pop_function_context ();
7340
7341   c_function_chain = p->next;
7342
7343   named_labels = p->named_labels;
7344   shadowed_labels = p->shadowed_labels;
7345   current_function_returns_value = p->returns_value;
7346   current_function_returns_null = p->returns_null;
7347   warn_about_return_type = p->warn_about_return_type;
7348   current_extern_inline = p->extern_inline;
7349   current_binding_level = p->binding_level;
7350
7351   free (p);
7352 }
7353
7354 /* integrate_decl_tree calls this function, but since we don't use the
7355    DECL_LANG_SPECIFIC field, this is a no-op.  */
7356
7357 void
7358 copy_lang_decl (node)
7359      tree node ATTRIBUTE_UNUSED;
7360 {
7361 }