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 flag_const_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     flag_const_strings = 1;
 717   else if (!strcmp (p, "-Wno-write-strings"))
 718     flag_const_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) = DECL_ORIGIN (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) = DECL_ORIGIN (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_dwarf_cfa", ptr_ftype_void,
3295                     BUILT_IN_DWARF_CFA, 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
3306     ("__builtin_eh_return",
3307      build_function_type (void_type_node,
3308                           tree_cons (NULL_TREE, ptr_type_node,
3309                                      tree_cons (NULL_TREE,
3310                                                 type_for_mode (ptr_mode, 0),
3311                                                 tree_cons (NULL_TREE,
3312                                                            ptr_type_node,
3313                                                            endlink)))),
3314      BUILT_IN_EH_RETURN, NULL_PTR);
3315
3316   builtin_function ("__builtin_alloca",
3317                     build_function_type (ptr_type_node,
3318                                          tree_cons (NULL_TREE,
3319                                                     sizetype,
3320                                                     endlink)),
3321                     BUILT_IN_ALLOCA, "alloca");
3322   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
3323   /* Define alloca, ffs as builtins.
3324      Declare _exit just to mark it as volatile.  */
3325   if (! flag_no_builtin && !flag_no_nonansi_builtin)
3326     {
3327       temp = builtin_function ("alloca",
3328                                build_function_type (ptr_type_node,
3329                                                     tree_cons (NULL_TREE,
3330                                                                sizetype,
3331                                                                endlink)),
3332                                BUILT_IN_ALLOCA, NULL_PTR);
3333       /* Suppress error if redefined as a non-function.  */
3334       DECL_BUILT_IN_NONANSI (temp) = 1;
3335       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
3336       /* Suppress error if redefined as a non-function.  */
3337       DECL_BUILT_IN_NONANSI (temp) = 1;
3338       temp = builtin_function ("_exit", void_ftype_any, NOT_BUILT_IN,
3339                                NULL_PTR);
3340       TREE_THIS_VOLATILE (temp) = 1;
3341       TREE_SIDE_EFFECTS (temp) = 1;
3342       /* Suppress error if redefined as a non-function.  */
3343       DECL_BUILT_IN_NONANSI (temp) = 1;
3344     }
3345
3346   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
3347   builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
3348                     NULL_PTR);
3349   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
3350                     NULL_PTR);
3351   builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3352                     NULL_PTR);
3353   builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
3354                     NULL_PTR);
3355   builtin_function ("__builtin_saveregs",
3356                     build_function_type (ptr_type_node, NULL_TREE),
3357                     BUILT_IN_SAVEREGS, NULL_PTR);
3358 /* EXPAND_BUILTIN_VARARGS is obsolete.  */
3359 #if 0
3360   builtin_function ("__builtin_varargs",
3361                     build_function_type (ptr_type_node,
3362                                          tree_cons (NULL_TREE,
3363                                                     integer_type_node,
3364                                                     endlink)),
3365                     BUILT_IN_VARARGS, NULL_PTR);
3366 #endif
3367   builtin_function ("__builtin_classify_type", default_function_type,
3368                     BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
3369   builtin_function ("__builtin_next_arg",
3370                     build_function_type (ptr_type_node, NULL_TREE),
3371                     BUILT_IN_NEXT_ARG, NULL_PTR);
3372   builtin_function ("__builtin_args_info",
3373                     build_function_type (integer_type_node,
3374                                          tree_cons (NULL_TREE,
3375                                                     integer_type_node,
3376                                                     endlink)),
3377                     BUILT_IN_ARGS_INFO, NULL_PTR);
3378
3379   /* Untyped call and return.  */
3380   builtin_function ("__builtin_apply_args",
3381                     build_function_type (ptr_type_node, NULL_TREE),
3382                     BUILT_IN_APPLY_ARGS, NULL_PTR);
3383
3384   temp = tree_cons (NULL_TREE,
3385                     build_pointer_type (build_function_type (void_type_node,
3386                                                              NULL_TREE)),
3387                     tree_cons (NULL_TREE,
3388                                ptr_type_node,
3389                                tree_cons (NULL_TREE,
3390                                           sizetype,
3391                                           endlink)));
3392   builtin_function ("__builtin_apply",
3393                     build_function_type (ptr_type_node, temp),
3394                     BUILT_IN_APPLY, NULL_PTR);
3395   builtin_function ("__builtin_return",
3396                     build_function_type (void_type_node,
3397                                          tree_cons (NULL_TREE,
3398                                                     ptr_type_node,
3399                                                     endlink)),
3400                     BUILT_IN_RETURN, NULL_PTR);
3401
3402   /* Currently under experimentation.  */
3403   builtin_function ("__builtin_memcpy", memcpy_ftype,
3404                     BUILT_IN_MEMCPY, "memcpy");
3405   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
3406                     BUILT_IN_MEMCMP, "memcmp");
3407   builtin_function ("__builtin_memset", memset_ftype,
3408                     BUILT_IN_MEMSET, "memset");
3409   builtin_function ("__builtin_strcmp", int_ftype_string_string,
3410                     BUILT_IN_STRCMP, "strcmp");
3411   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
3412                     BUILT_IN_STRCPY, "strcpy");
3413   builtin_function ("__builtin_strlen", strlen_ftype,
3414                     BUILT_IN_STRLEN, "strlen");
3415   builtin_function ("__builtin_sqrtf", float_ftype_float,
3416                     BUILT_IN_FSQRT, "sqrtf");
3417   builtin_function ("__builtin_fsqrt", double_ftype_double,
3418                     BUILT_IN_FSQRT, "sqrt");
3419   builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
3420                     BUILT_IN_FSQRT, "sqrtl");
3421   builtin_function ("__builtin_sinf", float_ftype_float,
3422                     BUILT_IN_SIN, "sinf");
3423   builtin_function ("__builtin_sin", double_ftype_double,
3424                     BUILT_IN_SIN, "sin");
3425   builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
3426                     BUILT_IN_SIN, "sinl");
3427   builtin_function ("__builtin_cosf", float_ftype_float,
3428                     BUILT_IN_COS, "cosf");
3429   builtin_function ("__builtin_cos", double_ftype_double,
3430                     BUILT_IN_COS, "cos");
3431   builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
3432                     BUILT_IN_COS, "cosl");
3433   builtin_function ("__builtin_setjmp",
3434                     build_function_type (integer_type_node,
3435                                          tree_cons (NULL_TREE,
3436                                                     ptr_type_node, endlink)),
3437                     BUILT_IN_SETJMP, NULL_PTR);
3438   builtin_function ("__builtin_longjmp",
3439                     build_function_type
3440                     (void_type_node,
3441                      tree_cons (NULL, ptr_type_node,
3442                                 tree_cons (NULL_TREE,
3443                                            integer_type_node,
3444                                            endlink))),
3445                     BUILT_IN_LONGJMP, NULL_PTR);
3446   builtin_function ("__builtin_trap",
3447                     build_function_type (void_type_node, endlink),
3448                     BUILT_IN_TRAP, NULL_PTR);
3449
3450   /* In an ANSI C program, it is okay to supply built-in meanings
3451      for these functions, since applications cannot validly use them
3452      with any other meaning.
3453      However, honor the -fno-builtin option.  */
3454   if (!flag_no_builtin)
3455     {
3456       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
3457       builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR);
3458       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
3459       builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3460                         NULL_PTR);
3461       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
3462       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
3463       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
3464                         NULL_PTR);
3465       builtin_function ("memset", memset_ftype, BUILT_IN_MEMSET, NULL_PTR);
3466       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
3467                         NULL_PTR);
3468       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
3469                         NULL_PTR);
3470       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
3471       builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR);
3472       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
3473       builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
3474                         NULL_PTR);
3475       builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR);
3476       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
3477       builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR);
3478       builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR);
3479       builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
3480       builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR);
3481
3482       /* Declare these functions volatile
3483          to avoid spurious "control drops through" warnings.  */
3484       /* Don't specify the argument types, to avoid errors
3485          from certain code which isn't valid in ANSI but which exists.  */
3486       temp = builtin_function ("abort", void_ftype_any, NOT_BUILT_IN,
3487                                NULL_PTR);
3488       TREE_THIS_VOLATILE (temp) = 1;
3489       TREE_SIDE_EFFECTS (temp) = 1;
3490       temp = builtin_function ("exit", void_ftype_any, NOT_BUILT_IN, NULL_PTR);
3491       TREE_THIS_VOLATILE (temp) = 1;
3492       TREE_SIDE_EFFECTS (temp) = 1;
3493     }
3494
3495 #if 0
3496   /* Support for these has not been written in either expand_builtin
3497      or build_function_call.  */
3498   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
3499   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
3500   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
3501                     NULL_PTR);
3502   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
3503                     NULL_PTR);
3504   builtin_function ("__builtin_fmod", double_ftype_double_double,
3505                     BUILT_IN_FMOD, NULL_PTR);
3506   builtin_function ("__builtin_frem", double_ftype_double_double,
3507                     BUILT_IN_FREM, NULL_PTR);
3508   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
3509                     NULL_PTR);
3510   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
3511                     NULL_PTR);
3512 #endif
3513
3514   pedantic_lvalues = pedantic;
3515
3516   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
3517   declare_function_name ();
3518
3519   start_identifier_warnings ();
3520
3521   /* Prepare to check format strings against argument lists.  */
3522   init_function_format_info ();
3523
3524   init_iterators ();
3525
3526   incomplete_decl_finalize_hook = finish_incomplete_decl;
3527
3528   lang_get_alias_set = c_get_alias_set;
3529 }
3530
3531 /* Return a definition for a builtin function named NAME and whose data type
3532    is TYPE.  TYPE should be a function type with argument types.
3533    FUNCTION_CODE tells later passes how to compile calls to this function.
3534    See tree.h for its possible values.
3535
3536    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3537    the name to be called if we can't opencode the function.  */
3538
3539 tree
3540 builtin_function (name, type, function_code, library_name)
3541      char *name;
3542      tree type;
3543      enum built_in_function function_code;
3544      char *library_name;
3545 {
3546   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3547   DECL_EXTERNAL (decl) = 1;
3548   TREE_PUBLIC (decl) = 1;
3549   /* If -traditional, permit redefining a builtin function any way you like.
3550      (Though really, if the program redefines these functions,
3551      it probably won't work right unless compiled with -fno-builtin.)  */
3552   if (flag_traditional && name[0] != '_')
3553     DECL_BUILT_IN_NONANSI (decl) = 1;
3554   if (library_name)
3555     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
3556   make_decl_rtl (decl, NULL_PTR, 1);
3557   pushdecl (decl);
3558   if (function_code != NOT_BUILT_IN)
3559     {
3560       DECL_BUILT_IN (decl) = 1;
3561       DECL_FUNCTION_CODE (decl) = function_code;
3562     }
3563   /* Warn if a function in the namespace for users
3564      is used without an occasion to consider it declared.  */
3565   if (name[0] != '_' || name[1] != '_')
3566     C_DECL_ANTICIPATED (decl) = 1;
3567
3568   return decl;
3569 }
3570 \f
3571 /* Called when a declaration is seen that contains no names to declare.
3572    If its type is a reference to a structure, union or enum inherited
3573    from a containing scope, shadow that tag name for the current scope
3574    with a forward reference.
3575    If its type defines a new named structure or union
3576    or defines an enum, it is valid but we need not do anything here.
3577    Otherwise, it is an error.  */
3578
3579 void
3580 shadow_tag (declspecs)
3581      tree declspecs;
3582 {
3583   shadow_tag_warned (declspecs, 0);
3584 }
3585
3586 void
3587 shadow_tag_warned (declspecs, warned)
3588      tree declspecs;
3589      int warned;
3590      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
3591         no pedwarn.  */
3592 {
3593   int found_tag = 0;
3594   register tree link;
3595   tree specs, attrs;
3596
3597   pending_invalid_xref = 0;
3598
3599   /* Remove the attributes from declspecs, since they will confuse the
3600      following code.  */
3601   split_specs_attrs (declspecs, &specs, &attrs);
3602
3603   for (link = specs; link; link = TREE_CHAIN (link))
3604     {
3605       register tree value = TREE_VALUE (link);
3606       register enum tree_code code = TREE_CODE (value);
3607
3608       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3609         /* Used to test also that TYPE_SIZE (value) != 0.
3610            That caused warning for `struct foo;' at top level in the file.  */
3611         {
3612           register tree name = lookup_tag_reverse (value);
3613           register tree t;
3614
3615           found_tag++;
3616
3617           if (name == 0)
3618             {
3619               if (warned != 1 && code != ENUMERAL_TYPE)
3620                 /* Empty unnamed enum OK */
3621                 {
3622                   pedwarn ("unnamed struct/union that defines no instances");
3623                   warned = 1;
3624                 }
3625             }
3626           else
3627             {
3628               t = lookup_tag (code, name, current_binding_level, 1);
3629
3630               if (t == 0)
3631                 {
3632                   t = make_node (code);
3633                   pushtag (name, t);
3634                 }
3635             }
3636         }
3637       else
3638         {
3639           if (!warned && ! in_system_header)
3640             {
3641               warning ("useless keyword or type name in empty declaration");
3642               warned = 2;
3643             }
3644         }
3645     }
3646
3647   if (found_tag > 1)
3648     error ("two types specified in one empty declaration");
3649
3650   if (warned != 1)
3651     {
3652       if (found_tag == 0)
3653         pedwarn ("empty declaration");
3654     }
3655 }
3656 \f
3657 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3658
3659 tree
3660 groktypename (typename)
3661      tree typename;
3662 {
3663   if (TREE_CODE (typename) != TREE_LIST)
3664     return typename;
3665   return grokdeclarator (TREE_VALUE (typename),
3666                          TREE_PURPOSE (typename),
3667                          TYPENAME, 0);
3668 }
3669
3670 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
3671
3672 tree
3673 groktypename_in_parm_context (typename)
3674      tree typename;
3675 {
3676   if (TREE_CODE (typename) != TREE_LIST)
3677     return typename;
3678   return grokdeclarator (TREE_VALUE (typename),
3679                          TREE_PURPOSE (typename),
3680                          PARM, 0);
3681 }
3682
3683 /* Decode a declarator in an ordinary declaration or data definition.
3684    This is called as soon as the type information and variable name
3685    have been parsed, before parsing the initializer if any.
3686    Here we create the ..._DECL node, fill in its type,
3687    and put it on the list of decls for the current context.
3688    The ..._DECL node is returned as the value.
3689
3690    Exception: for arrays where the length is not specified,
3691    the type is left null, to be filled in by `finish_decl'.
3692
3693    Function definitions do not come here; they go to start_function
3694    instead.  However, external and forward declarations of functions
3695    do go through here.  Structure field declarations are done by
3696    grokfield and not through here.  */
3697
3698 /* Set this to zero to debug not using the temporary obstack
3699    to parse initializers.  */
3700 int debug_temp_inits = 1;
3701
3702 tree
3703 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
3704      tree declarator, declspecs;
3705      int initialized;
3706      tree attributes, prefix_attributes;
3707 {
3708   register tree decl = grokdeclarator (declarator, declspecs,
3709                                        NORMAL, initialized);
3710   register tree tem;
3711   int init_written = initialized;
3712
3713   /* The corresponding pop_obstacks is in finish_decl.  */
3714   push_obstacks_nochange ();
3715
3716   if (warn_main && TREE_CODE (decl) != FUNCTION_DECL
3717       && !strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "main"))
3718     warning_with_decl (decl, "`%s' is usually a function");
3719
3720   if (initialized)
3721     /* Is it valid for this decl to have an initializer at all?
3722        If not, set INITIALIZED to zero, which will indirectly
3723        tell `finish_decl' to ignore the initializer once it is parsed.  */
3724     switch (TREE_CODE (decl))
3725       {
3726       case TYPE_DECL:
3727         /* typedef foo = bar  means give foo the same type as bar.
3728            We haven't parsed bar yet, so `finish_decl' will fix that up.
3729            Any other case of an initialization in a TYPE_DECL is an error.  */
3730         if (pedantic || list_length (declspecs) > 1)
3731           {
3732             error ("typedef `%s' is initialized",
3733                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3734             initialized = 0;
3735           }
3736         break;
3737
3738       case FUNCTION_DECL:
3739         error ("function `%s' is initialized like a variable",
3740                IDENTIFIER_POINTER (DECL_NAME (decl)));
3741         initialized = 0;
3742         break;
3743
3744       case PARM_DECL:
3745         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
3746         error ("parameter `%s' is initialized",
3747                IDENTIFIER_POINTER (DECL_NAME (decl)));
3748         initialized = 0;
3749         break;
3750
3751       default:
3752         /* Don't allow initializations for incomplete types
3753            except for arrays which might be completed by the initialization.  */
3754         if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
3755           {
3756             /* A complete type is ok if size is fixed.  */
3757
3758             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3759                 || C_DECL_VARIABLE_SIZE (decl))
3760               {
3761                 error ("variable-sized object may not be initialized");
3762                 initialized = 0;
3763               }
3764           }
3765         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3766           {
3767             error ("variable `%s' has initializer but incomplete type",
3768                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3769             initialized = 0;
3770           }
3771         else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
3772           {
3773             error ("elements of array `%s' have incomplete type",
3774                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3775             initialized = 0;
3776           }
3777       }
3778
3779   if (initialized)
3780     {
3781 #if 0  /* Seems redundant with grokdeclarator.  */
3782       if (current_binding_level != global_binding_level
3783           && DECL_EXTERNAL (decl)
3784           && TREE_CODE (decl) != FUNCTION_DECL)
3785         warning ("declaration of `%s' has `extern' and is initialized",
3786                  IDENTIFIER_POINTER (DECL_NAME (decl)));
3787 #endif
3788       DECL_EXTERNAL (decl) = 0;
3789       if (current_binding_level == global_binding_level)
3790         TREE_STATIC (decl) = 1;
3791
3792       /* Tell `pushdecl' this is an initialized decl
3793          even though we don't yet have the initializer expression.
3794          Also tell `finish_decl' it may store the real initializer.  */
3795       DECL_INITIAL (decl) = error_mark_node;
3796     }
3797
3798   /* If this is a function declaration, write a record describing it to the
3799      prototypes file (if requested).  */
3800
3801   if (TREE_CODE (decl) == FUNCTION_DECL)
3802     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3803
3804   /* ANSI specifies that a tentative definition which is not merged with
3805      a non-tentative definition behaves exactly like a definition with an
3806      initializer equal to zero.  (Section 3.7.2)
3807      -fno-common gives strict ANSI behavior.  Usually you don't want it.
3808      This matters only for variables with external linkage.  */
3809   if (! flag_no_common || ! TREE_PUBLIC (decl))
3810     DECL_COMMON (decl) = 1;
3811
3812 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
3813   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
3814 #endif
3815
3816   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3817   decl_attributes (decl, attributes, prefix_attributes);
3818
3819   /* Add this decl to the current binding level.
3820      TEM may equal DECL or it may be a previous decl of the same name.  */
3821   tem = pushdecl (decl);
3822
3823   /* For a local variable, define the RTL now.  */
3824   if (current_binding_level != global_binding_level
3825       /* But not if this is a duplicate decl
3826          and we preserved the rtl from the previous one
3827          (which may or may not happen).  */
3828       && DECL_RTL (tem) == 0)
3829     {
3830       if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
3831         expand_decl (tem);
3832       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3833                && DECL_INITIAL (tem) != 0)
3834         expand_decl (tem);
3835     }
3836
3837   if (init_written)
3838     {
3839       /* When parsing and digesting the initializer,
3840          use temporary storage.  Do this even if we will ignore the value.  */
3841       if (current_binding_level == global_binding_level && debug_temp_inits)
3842         temporary_allocation ();
3843     }
3844
3845   return tem;
3846 }
3847
3848 /* Finish processing of a declaration;
3849    install its initial value.
3850    If the length of an array type is not known before,
3851    it must be determined now, from the initial value, or it is an error.  */
3852
3853 void
3854 finish_decl (decl, init, asmspec_tree)
3855      tree decl, init;
3856      tree asmspec_tree;
3857 {
3858   register tree type = TREE_TYPE (decl);
3859   int was_incomplete = (DECL_SIZE (decl) == 0);
3860   int temporary = allocation_temporary_p ();
3861   char *asmspec = 0;
3862
3863   /* If a name was specified, get the string.   */
3864   if (asmspec_tree)
3865     asmspec = TREE_STRING_POINTER (asmspec_tree);
3866
3867   /* If `start_decl' didn't like having an initialization, ignore it now.  */
3868
3869   if (init != 0 && DECL_INITIAL (decl) == 0)
3870     init = 0;
3871   /* Don't crash if parm is initialized.  */
3872   if (TREE_CODE (decl) == PARM_DECL)
3873     init = 0;
3874
3875   if (ITERATOR_P (decl))
3876     {
3877       if (init == 0)
3878         error_with_decl (decl, "iterator has no initial value");
3879       else
3880         init = save_expr (init);
3881     }
3882
3883   if (init)
3884     {
3885       if (TREE_CODE (decl) != TYPE_DECL)
3886         store_init_value (decl, init);
3887       else
3888         {
3889           /* typedef foo = bar; store the type of bar as the type of foo.  */
3890           TREE_TYPE (decl) = TREE_TYPE (init);
3891           DECL_INITIAL (decl) = init = 0;
3892         }
3893     }
3894
3895   /* Pop back to the obstack that is current for this binding level.
3896      This is because MAXINDEX, rtl, etc. to be made below
3897      must go in the permanent obstack.  But don't discard the
3898      temporary data yet.  */
3899   pop_obstacks ();
3900 #if 0 /* pop_obstacks was near the end; this is what was here.  */
3901   if (current_binding_level == global_binding_level && temporary)
3902     end_temporary_allocation ();
3903 #endif
3904
3905   /* Deduce size of array from initialization, if not already known */
3906
3907   if (TREE_CODE (type) == ARRAY_TYPE
3908       && TYPE_DOMAIN (type) == 0
3909       && TREE_CODE (decl) != TYPE_DECL)
3910     {
3911       int do_default
3912         = (TREE_STATIC (decl)
3913            /* Even if pedantic, an external linkage array
3914               may have incomplete type at first.  */
3915            ? pedantic && !TREE_PUBLIC (decl)
3916            : !DECL_EXTERNAL (decl));
3917       int failure
3918         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3919
3920       /* Get the completed type made by complete_array_type.  */
3921       type = TREE_TYPE (decl);
3922
3923       if (failure == 1)
3924         error_with_decl (decl, "initializer fails to determine size of `%s'");
3925
3926       if (failure == 2)
3927         {
3928           if (do_default)
3929             error_with_decl (decl, "array size missing in `%s'");
3930           /* If a `static' var's size isn't known,
3931              make it extern as well as static, so it does not get
3932              allocated.
3933              If it is not `static', then do not mark extern;
3934              finish_incomplete_decl will give it a default size
3935              and it will get allocated.  */
3936           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3937             DECL_EXTERNAL (decl) = 1;
3938         }
3939
3940       /* TYPE_MAX_VALUE is always one less than the number of elements
3941          in the array, because we start counting at zero.  Therefore,
3942          warn only if the value is less than zero.  */
3943       if (pedantic && TYPE_DOMAIN (type) != 0
3944           && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3945         error_with_decl (decl, "zero or negative size array `%s'");
3946
3947       layout_decl (decl, 0);
3948     }
3949
3950   if (TREE_CODE (decl) == VAR_DECL)
3951     {
3952       if (DECL_SIZE (decl) == 0
3953           && TYPE_SIZE (TREE_TYPE (decl)) != 0)
3954         layout_decl (decl, 0);
3955
3956       if (DECL_SIZE (decl) == 0
3957           && (TREE_STATIC (decl)
3958               ?
3959                 /* A static variable with an incomplete type
3960                    is an error if it is initialized.
3961                    Also if it is not file scope.
3962                    Otherwise, let it through, but if it is not `extern'
3963                    then it may cause an error message later.  */
3964               /* A duplicate_decls call could have changed an extern
3965                  declaration into a file scope one.  This can be detected
3966                  by TREE_ASM_WRITTEN being set.  */
3967                 (DECL_INITIAL (decl) != 0
3968                  || (DECL_CONTEXT (decl) != 0 && ! TREE_ASM_WRITTEN (decl)))
3969               :
3970                 /* An automatic variable with an incomplete type
3971                    is an error.  */
3972                 !DECL_EXTERNAL (decl)))
3973         {
3974           error_with_decl (decl, "storage size of `%s' isn't known");
3975           TREE_TYPE (decl) = error_mark_node;
3976         }
3977
3978       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3979           && DECL_SIZE (decl) != 0)
3980         {
3981           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3982             constant_expression_warning (DECL_SIZE (decl));
3983           else
3984             error_with_decl (decl, "storage size of `%s' isn't constant");
3985         }
3986
3987       if (TREE_USED  (type))
3988         TREE_USED (decl) = 1;
3989     }
3990
3991   /* If this is a function and an assembler name is specified, it isn't
3992      builtin any more.  Also reset DECL_RTL so we can give it its new
3993      name.  */
3994   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3995       {
3996         DECL_BUILT_IN (decl) = 0;
3997         DECL_RTL (decl) = 0;
3998       }
3999
4000   /* Output the assembler code and/or RTL code for variables and functions,
4001      unless the type is an undefined structure or union.
4002      If not, it will get done when the type is completed.  */
4003
4004   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4005     {
4006       if ((flag_traditional || TREE_PERMANENT (decl))
4007           && allocation_temporary_p ())
4008         {
4009           push_obstacks_nochange ();
4010           end_temporary_allocation ();
4011           /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
4012           maybe_objc_check_decl (decl);
4013           rest_of_decl_compilation (decl, asmspec,
4014                                     (DECL_CONTEXT (decl) == 0
4015                                      || TREE_ASM_WRITTEN (decl)),
4016                                     0);
4017           pop_obstacks ();
4018         }
4019       else
4020         {
4021           /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
4022           maybe_objc_check_decl (decl);
4023           rest_of_decl_compilation (decl, asmspec, DECL_CONTEXT (decl) == 0,
4024                                     0);
4025         }
4026       if (DECL_CONTEXT (decl) != 0)
4027         {
4028           /* Recompute the RTL of a local array now
4029              if it used to be an incomplete type.  */
4030           if (was_incomplete
4031               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
4032             {
4033               /* If we used it already as memory, it must stay in memory.  */
4034               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4035               /* If it's still incomplete now, no init will save it.  */
4036               if (DECL_SIZE (decl) == 0)
4037                 DECL_INITIAL (decl) = 0;
4038               expand_decl (decl);
4039             }
4040           /* Compute and store the initial value.  */
4041           if (TREE_CODE (decl) != FUNCTION_DECL)
4042             expand_decl_init (decl);
4043         }
4044     }
4045
4046   if (TREE_CODE (decl) == TYPE_DECL)
4047     {
4048       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
4049       maybe_objc_check_decl (decl);
4050       rest_of_decl_compilation (decl, NULL_PTR, DECL_CONTEXT (decl) == 0,
4051                                 0);
4052     }
4053
4054   /* ??? After 2.3, test (init != 0) instead of TREE_CODE.  */
4055   /* This test used to include TREE_PERMANENT, however, we have the same
4056      problem with initializers at the function level.  Such initializers get
4057      saved until the end of the function on the momentary_obstack.  */
4058   if (!(TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
4059       && temporary
4060       /* DECL_INITIAL is not defined in PARM_DECLs, since it shares
4061          space with DECL_ARG_TYPE.  */
4062       && TREE_CODE (decl) != PARM_DECL)
4063     {
4064       /* We need to remember that this array HAD an initialization,
4065          but discard the actual temporary nodes,
4066          since we can't have a permanent node keep pointing to them.  */
4067       /* We make an exception for inline functions, since it's
4068          normal for a local extern redeclaration of an inline function
4069          to have a copy of the top-level decl's DECL_INLINE.  */
4070       if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
4071         {
4072           /* If this is a const variable, then preserve the
4073              initializer instead of discarding it so that we can optimize
4074              references to it.  */
4075           /* This test used to include TREE_STATIC, but this won't be set
4076              for function level initializers.  */
4077           if (TREE_READONLY (decl) || ITERATOR_P (decl))
4078             {
4079               preserve_initializer ();
4080               /* Hack?  Set the permanent bit for something that is permanent,
4081                  but not on the permanent obstack, so as to convince
4082                  output_constant_def to make its rtl on the permanent
4083                  obstack.  */
4084               TREE_PERMANENT (DECL_INITIAL (decl)) = 1;
4085
4086               /* The initializer and DECL must have the same (or equivalent
4087                  types), but if the initializer is a STRING_CST, its type
4088                  might not be on the right obstack, so copy the type
4089                  of DECL.  */
4090               TREE_TYPE (DECL_INITIAL (decl)) = type;
4091             }
4092           else
4093             DECL_INITIAL (decl) = error_mark_node;
4094         }
4095     }
4096
4097   /* If requested, warn about definitions of large data objects.  */
4098
4099   if (warn_larger_than
4100       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
4101       && !DECL_EXTERNAL (decl))
4102     {
4103       register tree decl_size = DECL_SIZE (decl);
4104
4105       if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
4106         {
4107            unsigned units = TREE_INT_CST_LOW(decl_size) / BITS_PER_UNIT;
4108
4109           if (units > larger_than_size)
4110             warning_with_decl (decl, "size of `%s' is %u bytes", units);
4111         }
4112     }
4113
4114 #if 0
4115   /* Resume permanent allocation, if not within a function.  */
4116   /* The corresponding push_obstacks_nochange is in start_decl,
4117      and in push_parm_decl and in grokfield.  */
4118   pop_obstacks ();
4119 #endif
4120
4121   /* If we have gone back from temporary to permanent allocation,
4122      actually free the temporary space that we no longer need.  */
4123   if (temporary && !allocation_temporary_p ())
4124     permanent_allocation (0);
4125
4126   /* At the end of a declaration, throw away any variable type sizes
4127      of types defined inside that declaration.  There is no use
4128      computing them in the following function definition.  */
4129   if (current_binding_level == global_binding_level)
4130     get_pending_sizes ();
4131 }
4132
4133 /* If DECL has a cleanup, build and return that cleanup here.
4134    This is a callback called by expand_expr.  */
4135
4136 tree
4137 maybe_build_cleanup (decl)
4138      tree decl ATTRIBUTE_UNUSED;
4139 {
4140   /* There are no cleanups in C.  */
4141   return NULL_TREE;
4142 }
4143
4144 /* Given a parsed parameter declaration,
4145    decode it into a PARM_DECL and push that on the current binding level.
4146    Also, for the sake of forward parm decls,
4147    record the given order of parms in `parm_order'.  */
4148
4149 void
4150 push_parm_decl (parm)
4151      tree parm;
4152 {
4153   tree decl;
4154   int old_immediate_size_expand = immediate_size_expand;
4155   /* Don't try computing parm sizes now -- wait till fn is called.  */
4156   immediate_size_expand = 0;
4157
4158   /* The corresponding pop_obstacks is in finish_decl.  */
4159   push_obstacks_nochange ();
4160
4161   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
4162                          TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
4163   decl_attributes (decl, TREE_VALUE (TREE_VALUE (parm)),
4164                    TREE_PURPOSE (TREE_VALUE (parm)));
4165
4166 #if 0
4167   if (DECL_NAME (decl))
4168     {
4169       tree olddecl;
4170       olddecl = lookup_name (DECL_NAME (decl));
4171       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
4172         pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef");
4173     }
4174 #endif
4175
4176   decl = pushdecl (decl);
4177
4178   immediate_size_expand = old_immediate_size_expand;
4179
4180   current_binding_level->parm_order
4181     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
4182
4183   /* Add this decl to the current binding level.  */
4184   finish_decl (decl, NULL_TREE, NULL_TREE);
4185 }
4186
4187 /* Clear the given order of parms in `parm_order'.
4188    Used at start of parm list,
4189    and also at semicolon terminating forward decls.  */
4190
4191 void
4192 clear_parm_order ()
4193 {
4194   current_binding_level->parm_order = NULL_TREE;
4195 }
4196 \f
4197 /* Make TYPE a complete type based on INITIAL_VALUE.
4198    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
4199    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
4200
4201 int
4202 complete_array_type (type, initial_value, do_default)
4203      tree type;
4204      tree initial_value;
4205      int do_default;
4206 {
4207   register tree maxindex = NULL_TREE;
4208   int value = 0;
4209
4210   if (initial_value)
4211     {
4212       /* Note MAXINDEX  is really the maximum index,
4213          one less than the size.  */
4214       if (TREE_CODE (initial_value) == STRING_CST)
4215         {
4216           int eltsize
4217             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
4218           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
4219                                    / eltsize) - 1, 0);
4220         }
4221       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
4222         {
4223           tree elts = CONSTRUCTOR_ELTS (initial_value);
4224           maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
4225           for (; elts; elts = TREE_CHAIN (elts))
4226             {
4227               if (TREE_PURPOSE (elts))
4228                 maxindex = TREE_PURPOSE (elts);
4229               else
4230                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
4231             }
4232           maxindex = copy_node (maxindex);
4233         }
4234       else
4235         {
4236           /* Make an error message unless that happened already.  */
4237           if (initial_value != error_mark_node)
4238             value = 1;
4239
4240           /* Prevent further error messages.  */
4241           maxindex = build_int_2 (0, 0);
4242         }
4243     }
4244
4245   if (!maxindex)
4246     {
4247       if (do_default)
4248         maxindex = build_int_2 (0, 0);
4249       value = 2;
4250     }
4251
4252   if (maxindex)
4253     {
4254       TYPE_DOMAIN (type) = build_index_type (maxindex);
4255       if (!TREE_TYPE (maxindex))
4256         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
4257     }
4258
4259   /* Lay out the type now that we can get the real answer.  */
4260
4261   layout_type (type);
4262
4263   return value;
4264 }
4265 \f
4266 /* Given declspecs and a declarator,
4267    determine the name and type of the object declared
4268    and construct a ..._DECL node for it.
4269    (In one case we can return a ..._TYPE node instead.
4270     For invalid input we sometimes return 0.)
4271
4272    DECLSPECS is a chain of tree_list nodes whose value fields
4273     are the storage classes and type specifiers.
4274
4275    DECL_CONTEXT says which syntactic context this declaration is in:
4276      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4277      FUNCDEF for a function definition.  Like NORMAL but a few different
4278       error messages in each case.  Return value may be zero meaning
4279       this definition is too screwy to try to parse.
4280      PARM for a parameter declaration (either within a function prototype
4281       or before a function body).  Make a PARM_DECL, or return void_type_node.
4282      TYPENAME if for a typename (in a cast or sizeof).
4283       Don't make a DECL node; just return the ..._TYPE node.
4284      FIELD for a struct or union field; make a FIELD_DECL.
4285      BITFIELD for a field with specified width.
4286    INITIALIZED is 1 if the decl has an initializer.
4287
4288    In the TYPENAME case, DECLARATOR is really an absolute declarator.
4289    It may also be so in the PARM case, for a prototype where the
4290    argument type is specified but not the name.
4291
4292    This function is where the complicated C meanings of `static'
4293    and `extern' are interpreted.  */
4294
4295 static tree
4296 grokdeclarator (declarator, declspecs, decl_context, initialized)
4297      tree declspecs;
4298      tree declarator;
4299      enum decl_context decl_context;
4300      int initialized;
4301 {
4302   int specbits = 0;
4303   tree spec;
4304   tree type = NULL_TREE;
4305   int longlong = 0;
4306   int constp;
4307   int volatilep;
4308   int inlinep;
4309   int explicit_int = 0;
4310   int explicit_char = 0;
4311   int defaulted_int = 0;
4312   tree typedef_decl = 0;
4313   char *name;
4314   tree typedef_type = 0;
4315   int funcdef_flag = 0;
4316   enum tree_code innermost_code = ERROR_MARK;
4317   int bitfield = 0;
4318   int size_varies = 0;
4319   tree decl_machine_attr = NULL_TREE;
4320
4321   if (decl_context == BITFIELD)
4322     bitfield = 1, decl_context = FIELD;
4323
4324   if (decl_context == FUNCDEF)
4325     funcdef_flag = 1, decl_context = NORMAL;
4326
4327   push_obstacks_nochange ();
4328
4329   if (flag_traditional && allocation_temporary_p ())
4330     end_temporary_allocation ();
4331
4332   /* Look inside a declarator for the name being declared
4333      and get it as a string, for an error message.  */
4334   {
4335     register tree decl = declarator;
4336     name = 0;
4337
4338     while (decl)
4339       switch (TREE_CODE (decl))
4340         {
4341         case ARRAY_REF:
4342         case INDIRECT_REF:
4343         case CALL_EXPR:
4344           innermost_code = TREE_CODE (decl);
4345           decl = TREE_OPERAND (decl, 0);
4346           break;
4347
4348         case IDENTIFIER_NODE:
4349           name = IDENTIFIER_POINTER (decl);
4350           decl = 0;
4351           break;
4352
4353         default:
4354           abort ();
4355         }
4356     if (name == 0)
4357       name = "type name";
4358   }
4359
4360   /* A function definition's declarator must have the form of
4361      a function declarator.  */
4362
4363   if (funcdef_flag && innermost_code != CALL_EXPR)
4364     return 0;
4365
4366   /* Anything declared one level down from the top level
4367      must be one of the parameters of a function
4368      (because the body is at least two levels down).  */
4369
4370   /* If this looks like a function definition, make it one,
4371      even if it occurs where parms are expected.
4372      Then store_parm_decls will reject it and not use it as a parm.  */
4373   if (decl_context == NORMAL && !funcdef_flag
4374       && current_binding_level->parm_flag)
4375     decl_context = PARM;
4376
4377   /* Look through the decl specs and record which ones appear.
4378      Some typespecs are defined as built-in typenames.
4379      Others, the ones that are modifiers of other types,
4380      are represented by bits in SPECBITS: set the bits for
4381      the modifiers that appear.  Storage class keywords are also in SPECBITS.
4382
4383      If there is a typedef name or a type, store the type in TYPE.
4384      This includes builtin typedefs such as `int'.
4385
4386      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
4387      and did not come from a user typedef.
4388
4389      Set LONGLONG if `long' is mentioned twice.  */
4390
4391   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
4392     {
4393       register int i;
4394       register tree id = TREE_VALUE (spec);
4395
4396       if (id == ridpointers[(int) RID_INT])
4397         explicit_int = 1;
4398       if (id == ridpointers[(int) RID_CHAR])
4399         explicit_char = 1;
4400
4401       if (TREE_CODE (id) == IDENTIFIER_NODE)
4402         for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
4403           {
4404             if (ridpointers[i] == id)
4405               {
4406                 if (i == (int) RID_LONG && specbits & (1<<i))
4407                   {
4408                     if (longlong)
4409                       error ("`long long long' is too long for GCC");
4410                     else
4411                       {
4412                         if (pedantic && ! in_system_header && warn_long_long)
4413                           pedwarn ("ANSI C does not support `long long'");
4414                         longlong = 1;
4415                       }
4416                   }
4417                 else if (specbits & (1 << i))
4418                   pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
4419                 specbits |= 1 << i;
4420                 goto found;
4421               }
4422           }
4423       if (type)
4424         error ("two or more data types in declaration of `%s'", name);
4425       /* Actual typedefs come to us as TYPE_DECL nodes.  */
4426       else if (TREE_CODE (id) == TYPE_DECL)
4427         {
4428           type = TREE_TYPE (id);
4429           decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
4430           typedef_decl = id;
4431         }
4432       /* Built-in types come as identifiers.  */
4433       else if (TREE_CODE (id) == IDENTIFIER_NODE)
4434         {
4435           register tree t = lookup_name (id);
4436           if (TREE_TYPE (t) == error_mark_node)
4437             ;
4438           else if (!t || TREE_CODE (t) != TYPE_DECL)
4439             error ("`%s' fails to be a typedef or built in type",
4440                    IDENTIFIER_POINTER (id));
4441           else
4442             {
4443               type = TREE_TYPE (t);
4444               typedef_decl = t;
4445             }
4446         }
4447       else if (TREE_CODE (id) != ERROR_MARK)
4448         type = id;
4449
4450     found: {}
4451     }
4452
4453   typedef_type = type;
4454   if (type)
4455     size_varies = C_TYPE_VARIABLE_SIZE (type);
4456
4457   /* No type at all: default to `int', and set DEFAULTED_INT
4458      because it was not a user-defined typedef.  */
4459
4460   if (type == 0)
4461     {
4462       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4463                           | (1 << (int) RID_SIGNED)
4464                           | (1 << (int) RID_UNSIGNED))))
4465           /* Don't warn about typedef foo = bar.  */
4466           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
4467           && ! (in_system_header && ! allocation_temporary_p ()))
4468         {
4469           /* C9x will probably require a diagnostic here.
4470              For now, issue a warning if -Wreturn-type and this is a function,
4471              or if -Wimplicit; prefer the former warning since it is more
4472              explicit.  */
4473           if ((warn_implicit_int || warn_return_type) && funcdef_flag)
4474             warn_about_return_type = 1;
4475           else if (warn_implicit_int)
4476             warning ("type defaults to `int' in declaration of `%s'", name);
4477         }
4478
4479       defaulted_int = 1;
4480       type = integer_type_node;
4481     }
4482
4483   /* Now process the modifiers that were specified
4484      and check for invalid combinations.  */
4485
4486   /* Long double is a special combination.  */
4487
4488   if ((specbits & 1 << (int) RID_LONG) && ! longlong
4489       && TYPE_MAIN_VARIANT (type) == double_type_node)
4490     {
4491       specbits &= ~ (1 << (int) RID_LONG);
4492       type = long_double_type_node;
4493     }
4494
4495   /* Check all other uses of type modifiers.  */
4496
4497   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4498                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4499     {
4500       int ok = 0;
4501
4502       if ((specbits & 1 << (int) RID_LONG)
4503           && (specbits & 1 << (int) RID_SHORT))
4504         error ("both long and short specified for `%s'", name);
4505       else if (((specbits & 1 << (int) RID_LONG)
4506                 || (specbits & 1 << (int) RID_SHORT))
4507                && explicit_char)
4508         error ("long or short specified with char for `%s'", name);
4509       else if (((specbits & 1 << (int) RID_LONG)
4510                 || (specbits & 1 << (int) RID_SHORT))
4511                && TREE_CODE (type) == REAL_TYPE)
4512         {
4513           static int already = 0;
4514
4515           error ("long or short specified with floating type for `%s'", name);
4516           if (! already && ! pedantic)
4517             {
4518               error ("the only valid combination is `long double'");
4519               already = 1;
4520             }
4521         }
4522       else if ((specbits & 1 << (int) RID_SIGNED)
4523                && (specbits & 1 << (int) RID_UNSIGNED))
4524         error ("both signed and unsigned specified for `%s'", name);
4525       else if (TREE_CODE (type) != INTEGER_TYPE)
4526         error ("long, short, signed or unsigned invalid for `%s'", name);
4527       else
4528         {
4529           ok = 1;
4530           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4531             {
4532               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4533                        name);
4534               if (flag_pedantic_errors)
4535                 ok = 0;
4536             }
4537         }
4538
4539       /* Discard the type modifiers if they are invalid.  */
4540       if (! ok)
4541         {
4542           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4543                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4544           longlong = 0;
4545         }
4546     }
4547
4548   if ((specbits & (1 << (int) RID_COMPLEX))
4549       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4550     {
4551       error ("complex invalid for `%s'", name);
4552       specbits &= ~ (1 << (int) RID_COMPLEX);
4553     }
4554
4555   /* Decide whether an integer type is signed or not.
4556      Optionally treat bitfields as signed by default.  */
4557   if (specbits & 1 << (int) RID_UNSIGNED
4558       /* Traditionally, all bitfields are unsigned.  */
4559       || (bitfield && flag_traditional
4560           && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
4561       || (bitfield && ! flag_signed_bitfields
4562           && (explicit_int || defaulted_int || explicit_char
4563               /* A typedef for plain `int' without `signed'
4564                  can be controlled just like plain `int'.  */
4565               || ! (typedef_decl != 0
4566                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4567           && TREE_CODE (type) != ENUMERAL_TYPE
4568           && !(specbits & 1 << (int) RID_SIGNED)))
4569     {
4570       if (longlong)
4571         type = long_long_unsigned_type_node;
4572       else if (specbits & 1 << (int) RID_LONG)
4573         type = long_unsigned_type_node;
4574       else if (specbits & 1 << (int) RID_SHORT)
4575         type = short_unsigned_type_node;
4576       else if (type == char_type_node)
4577         type = unsigned_char_type_node;
4578       else if (typedef_decl)
4579         type = unsigned_type (type);
4580       else
4581         type = unsigned_type_node;
4582     }
4583   else if ((specbits & 1 << (int) RID_SIGNED)
4584            && type == char_type_node)
4585     type = signed_char_type_node;
4586   else if (longlong)
4587     type = long_long_integer_type_node;
4588   else if (specbits & 1 << (int) RID_LONG)
4589     type = long_integer_type_node;
4590   else if (specbits & 1 << (int) RID_SHORT)
4591     type = short_integer_type_node;
4592
4593   if (specbits & 1 << (int) RID_COMPLEX)
4594     {
4595       /* If we just have "complex", it is equivalent to
4596          "complex double", but if any modifiers at all are specified it is
4597          the complex form of TYPE.  E.g, "complex short" is
4598          "complex short int".  */
4599
4600       if (defaulted_int && ! longlong
4601           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4602                             | (1 << (int) RID_SIGNED)
4603                             | (1 << (int) RID_UNSIGNED))))
4604         type = complex_double_type_node;
4605       else if (type == integer_type_node)
4606         type = complex_integer_type_node;
4607       else if (type == float_type_node)
4608         type = complex_float_type_node;
4609       else if (type == double_type_node)
4610         type = complex_double_type_node;
4611       else if (type == long_double_type_node)
4612         type = complex_long_double_type_node;
4613       else
4614         type = build_complex_type (type);
4615     }
4616
4617   /* Set CONSTP if this declaration is `const', whether by
4618      explicit specification or via a typedef.
4619      Likewise for VOLATILEP.  */
4620
4621   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4622   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4623   inlinep = !! (specbits & (1 << (int) RID_INLINE));
4624   if (constp > 1)
4625     pedwarn ("duplicate `const'");
4626   if (volatilep > 1)
4627     pedwarn ("duplicate `volatile'");
4628   if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
4629     type = TYPE_MAIN_VARIANT (type);
4630
4631   /* Warn if two storage classes are given. Default to `auto'.  */
4632
4633   {
4634     int nclasses = 0;
4635
4636     if (specbits & 1 << (int) RID_AUTO) nclasses++;
4637     if (specbits & 1 << (int) RID_STATIC) nclasses++;
4638     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4639     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4640     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4641     if (specbits & 1 << (int) RID_ITERATOR) nclasses++;
4642
4643     /* Warn about storage classes that are invalid for certain
4644        kinds of declarations (parameters, typenames, etc.).  */
4645
4646     if (nclasses > 1)
4647       error ("multiple storage classes in declaration of `%s'", name);
4648     else if (funcdef_flag
4649              && (specbits
4650                  & ((1 << (int) RID_REGISTER)
4651                     | (1 << (int) RID_AUTO)
4652                     | (1 << (int) RID_TYPEDEF))))
4653       {
4654         if (specbits & 1 << (int) RID_AUTO
4655             && (pedantic || current_binding_level == global_binding_level))
4656           pedwarn ("function definition declared `auto'");
4657         if (specbits & 1 << (int) RID_REGISTER)
4658           error ("function definition declared `register'");
4659         if (specbits & 1 << (int) RID_TYPEDEF)
4660           error ("function definition declared `typedef'");
4661         specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4662                        | (1 << (int) RID_AUTO));
4663       }
4664     else if (decl_context != NORMAL && nclasses > 0)
4665       {
4666         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4667           ;
4668         else
4669           {
4670             error ((decl_context == FIELD
4671                     ? "storage class specified for structure field `%s'"
4672                     : (decl_context == PARM
4673                        ? "storage class specified for parameter `%s'"
4674                        : "storage class specified for typename")),
4675                    name);
4676             specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4677                            | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4678                            | (1 << (int) RID_EXTERN));
4679           }
4680       }
4681     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4682       {
4683         /* `extern' with initialization is invalid if not at top level.  */
4684         if (current_binding_level == global_binding_level)
4685           warning ("`%s' initialized and declared `extern'", name);
4686         else
4687           error ("`%s' has both `extern' and initializer", name);
4688       }
4689     else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4690              && current_binding_level != global_binding_level)
4691       error ("nested function `%s' declared `extern'", name);
4692     else if (current_binding_level == global_binding_level
4693              && specbits & (1 << (int) RID_AUTO))
4694       error ("top-level declaration of `%s' specifies `auto'", name);
4695     else if ((specbits & 1 << (int) RID_ITERATOR)
4696              && TREE_CODE (declarator) != IDENTIFIER_NODE)
4697       {
4698         error ("iterator `%s' has derived type", name);
4699         type = error_mark_node;
4700       }
4701     else if ((specbits & 1 << (int) RID_ITERATOR)
4702              && TREE_CODE (type) != INTEGER_TYPE)
4703       {
4704         error ("iterator `%s' has noninteger type", name);
4705         type = error_mark_node;
4706       }
4707   }
4708
4709   /* Now figure out the structure of the declarator proper.
4710      Descend through it, creating more complex types, until we reach
4711      the declared identifier (or NULL_TREE, in an absolute declarator).  */
4712
4713   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4714     {
4715       if (type == error_mark_node)
4716         {
4717           declarator = TREE_OPERAND (declarator, 0);
4718           continue;
4719         }
4720
4721       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4722          an INDIRECT_REF (for *...),
4723          a CALL_EXPR (for ...(...)),
4724          an identifier (for the name being declared)
4725          or a null pointer (for the place in an absolute declarator
4726          where the name was omitted).
4727          For the last two cases, we have just exited the loop.
4728
4729          At this point, TYPE is the type of elements of an array,
4730          or for a function to return, or for a pointer to point to.
4731          After this sequence of ifs, TYPE is the type of the
4732          array or function or pointer, and DECLARATOR has had its
4733          outermost layer removed.  */
4734
4735       if (TREE_CODE (declarator) == ARRAY_REF)
4736         {
4737           register tree itype = NULL_TREE;
4738           register tree size = TREE_OPERAND (declarator, 1);
4739           /* An uninitialized decl with `extern' is a reference.  */
4740           int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4741           /* The index is a signed object `sizetype' bits wide.  */
4742           tree index_type = signed_type (sizetype);
4743
4744           declarator = TREE_OPERAND (declarator, 0);
4745
4746           /* Check for some types that there cannot be arrays of.  */
4747
4748           if (TYPE_MAIN_VARIANT (type) == void_type_node)
4749             {
4750               error ("declaration of `%s' as array of voids", name);
4751               type = error_mark_node;
4752             }
4753
4754           if (TREE_CODE (type) == FUNCTION_TYPE)
4755             {
4756               error ("declaration of `%s' as array of functions", name);
4757               type = error_mark_node;
4758             }
4759
4760           if (size == error_mark_node)
4761             type = error_mark_node;
4762
4763           if (type == error_mark_node)
4764             continue;
4765
4766           /* If this is a block level extern, it must live past the end
4767              of the function so that we can check it against other extern
4768              declarations (IDENTIFIER_LIMBO_VALUE).  */
4769           if (extern_ref && allocation_temporary_p ())
4770             end_temporary_allocation ();
4771
4772           /* If size was specified, set ITYPE to a range-type for that size.
4773              Otherwise, ITYPE remains null.  finish_decl may figure it out
4774              from an initial value.  */
4775
4776           if (size)
4777             {
4778               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4779               STRIP_TYPE_NOPS (size);
4780
4781               if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
4782                   && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
4783                 {
4784                   error ("size of array `%s' has non-integer type", name);
4785                   size = integer_one_node;
4786                 }
4787
4788               if (pedantic && integer_zerop (size))
4789                 pedwarn ("ANSI C forbids zero-size array `%s'", name);
4790
4791               if (TREE_CODE (size) == INTEGER_CST)
4792                 {
4793                   constant_expression_warning (size);
4794                   if (tree_int_cst_sgn (size) < 0)
4795                     {
4796                       error ("size of array `%s' is negative", name);
4797                       size = integer_one_node;
4798                     }
4799                 }
4800               else
4801                 {
4802                   /* Make sure the array size remains visibly nonconstant
4803                      even if it is (eg) a const variable with known value.  */
4804                   size_varies = 1;
4805
4806                   if (pedantic)
4807                     {
4808                       if (TREE_CONSTANT (size))
4809                         pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name);
4810                       else
4811                         pedwarn ("ANSI C forbids variable-size array `%s'", name);
4812                     }
4813                 }
4814
4815               /* Convert size to index_type, so that if it is a variable
4816                  the computations will be done in the proper mode.  */
4817               itype = fold (build (MINUS_EXPR, index_type,
4818                                    convert (index_type, size),
4819                                    convert (index_type, size_one_node)));
4820
4821               /* If that overflowed, the array is too big.
4822                  ??? While a size of INT_MAX+1 technically shouldn't cause
4823                  an overflow (because we subtract 1), the overflow is recorded
4824                  during the conversion to index_type, before the subtraction.
4825                  Handling this case seems like an unnecessary complication.  */
4826               if (TREE_OVERFLOW (itype))
4827                 {
4828                   error ("size of array `%s' is too large", name);
4829                   type = error_mark_node;
4830                   continue;
4831                 }
4832
4833               if (size_varies)
4834                 itype = variable_size (itype);
4835               itype = build_index_type (itype);
4836             }
4837
4838 #if 0 /* This had bad results for pointers to arrays, as in
4839          union incomplete (*foo)[4];  */
4840           /* Complain about arrays of incomplete types, except in typedefs.  */
4841
4842           if (TYPE_SIZE (type) == 0
4843               /* Avoid multiple warnings for nested array types.  */
4844               && TREE_CODE (type) != ARRAY_TYPE
4845               && !(specbits & (1 << (int) RID_TYPEDEF))
4846               && !C_TYPE_BEING_DEFINED (type))
4847             warning ("array type has incomplete element type");
4848 #endif
4849
4850 #if 0  /* We shouldn't have a function type here at all!
4851           Functions aren't allowed as array elements.  */
4852           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4853               && (constp || volatilep))
4854             pedwarn ("ANSI C forbids const or volatile function types");
4855 #endif
4856
4857           /* Build the array type itself, then merge any constancy or
4858              volatility into the target type.  We must do it in this order
4859              to ensure that the TYPE_MAIN_VARIANT field of the array type
4860              is set correctly.  */
4861
4862           type = build_array_type (type, itype);
4863           if (constp || volatilep)
4864             type = c_build_type_variant (type, constp, volatilep);
4865
4866 #if 0   /* don't clear these; leave them set so that the array type
4867            or the variable is itself const or volatile.  */
4868           constp = 0;
4869           volatilep = 0;
4870 #endif
4871
4872           if (size_varies)
4873             C_TYPE_VARIABLE_SIZE (type) = 1;
4874         }
4875       else if (TREE_CODE (declarator) == CALL_EXPR)
4876         {
4877           int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4878                             || current_binding_level == global_binding_level);
4879           tree arg_types;
4880
4881           /* Declaring a function type.
4882              Make sure we have a valid type for the function to return.  */
4883           if (type == error_mark_node)
4884             continue;
4885
4886           size_varies = 0;
4887
4888           /* Warn about some types functions can't return.  */
4889
4890           if (TREE_CODE (type) == FUNCTION_TYPE)
4891             {
4892               error ("`%s' declared as function returning a function", name);
4893               type = integer_type_node;
4894             }
4895           if (TREE_CODE (type) == ARRAY_TYPE)
4896             {
4897               error ("`%s' declared as function returning an array", name);
4898               type = integer_type_node;
4899             }
4900
4901 #ifndef TRADITIONAL_RETURN_FLOAT
4902           /* Traditionally, declaring return type float means double.  */
4903
4904           if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4905             type = double_type_node;
4906 #endif /* TRADITIONAL_RETURN_FLOAT */
4907
4908           /* If this is a block level extern, it must live past the end
4909              of the function so that we can check it against other extern
4910              declarations (IDENTIFIER_LIMBO_VALUE).  */
4911           if (extern_ref && allocation_temporary_p ())
4912             end_temporary_allocation ();
4913
4914           /* Construct the function type and go to the next
4915              inner layer of declarator.  */
4916
4917           arg_types = grokparms (TREE_OPERAND (declarator, 1),
4918                                  funcdef_flag
4919                                  /* Say it's a definition
4920                                     only for the CALL_EXPR
4921                                     closest to the identifier.  */
4922                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4923 #if 0 /* This seems to be false.  We turn off temporary allocation
4924          above in this function if -traditional.
4925          And this code caused inconsistent results with prototypes:
4926          callers would ignore them, and pass arguments wrong.  */
4927
4928           /* Omit the arg types if -traditional, since the arg types
4929              and the list links might not be permanent.  */
4930           type = build_function_type (type,
4931                                       flag_traditional
4932                                       ? NULL_TREE : arg_types);
4933 #endif
4934           /* ANSI seems to say that `const int foo ();'
4935              does not make the function foo const.  */
4936           if (constp || volatilep)
4937             type = c_build_type_variant (type, constp, volatilep);
4938           constp = 0;
4939           volatilep = 0;
4940
4941           type = build_function_type (type, arg_types);
4942           declarator = TREE_OPERAND (declarator, 0);
4943
4944           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4945              the formal parameter list of this FUNCTION_TYPE to point to
4946              the FUNCTION_TYPE node itself.  */
4947
4948           {
4949             register tree link;
4950
4951             for (link = last_function_parm_tags;
4952                  link;
4953                  link = TREE_CHAIN (link))
4954               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4955           }
4956         }
4957       else if (TREE_CODE (declarator) == INDIRECT_REF)
4958         {
4959           /* Merge any constancy or volatility into the target type
4960              for the pointer.  */
4961
4962           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4963               && (constp || volatilep))
4964             pedwarn ("ANSI C forbids const or volatile function types");
4965           if (constp || volatilep)
4966             type = c_build_type_variant (type, constp, volatilep);
4967           constp = 0;
4968           volatilep = 0;
4969           size_varies = 0;
4970
4971           type = build_pointer_type (type);
4972
4973           /* Process a list of type modifier keywords
4974              (such as const or volatile) that were given inside the `*'.  */
4975
4976           if (TREE_TYPE (declarator))
4977             {
4978               register tree typemodlist;
4979               int erred = 0;
4980               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4981                    typemodlist = TREE_CHAIN (typemodlist))
4982                 {
4983                   if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
4984                     constp++;
4985                   else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
4986                     volatilep++;
4987                   else if (!erred)
4988                     {
4989                       erred = 1;
4990                       error ("invalid type modifier within pointer declarator");
4991                     }
4992                 }
4993               if (constp > 1)
4994                 pedwarn ("duplicate `const'");
4995               if (volatilep > 1)
4996                 pedwarn ("duplicate `volatile'");
4997             }
4998
4999           declarator = TREE_OPERAND (declarator, 0);
5000         }
5001       else
5002         abort ();
5003
5004     }
5005
5006   /* Now TYPE has the actual type.  */
5007
5008   /* Did array size calculations overflow?  */
5009
5010   if (TREE_CODE (type) == ARRAY_TYPE
5011       && TYPE_SIZE (type)
5012       && TREE_OVERFLOW (TYPE_SIZE (type)))
5013     error ("size of array `%s' is too large", name);
5014
5015   /* If this is declaring a typedef name, return a TYPE_DECL.  */
5016
5017   if (specbits & (1 << (int) RID_TYPEDEF))
5018     {
5019       tree decl;
5020       /* Note that the grammar rejects storage classes
5021          in typenames, fields or parameters */
5022       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5023           && (constp || volatilep))
5024         pedwarn ("ANSI C forbids const or volatile function types");
5025       if (constp || volatilep)
5026         type = c_build_type_variant (type, constp, volatilep);
5027       decl = build_decl (TYPE_DECL, declarator, type);
5028       if ((specbits & (1 << (int) RID_SIGNED))
5029           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
5030         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
5031       pop_obstacks ();
5032       return decl;
5033     }
5034
5035   /* Detect the case of an array type of unspecified size
5036      which came, as such, direct from a typedef name.
5037      We must copy the type, so that each identifier gets
5038      a distinct type, so that each identifier's size can be
5039      controlled separately by its own initializer.  */
5040
5041   if (type != 0 && typedef_type != 0
5042       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
5043       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
5044     {
5045       type = build_array_type (TREE_TYPE (type), 0);
5046       if (size_varies)
5047         C_TYPE_VARIABLE_SIZE (type) = 1;
5048     }
5049
5050   /* If this is a type name (such as, in a cast or sizeof),
5051      compute the type and return it now.  */
5052
5053   if (decl_context == TYPENAME)
5054     {
5055       /* Note that the grammar rejects storage classes
5056          in typenames, fields or parameters */
5057       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5058           && (constp || volatilep))
5059         pedwarn ("ANSI C forbids const or volatile function types");
5060       if (constp || volatilep)
5061         type = c_build_type_variant (type, constp, volatilep);
5062       pop_obstacks ();
5063       return type;
5064     }
5065
5066   /* Aside from typedefs and type names (handle above),
5067      `void' at top level (not within pointer)
5068      is allowed only in public variables.
5069      We don't complain about parms either, but that is because
5070      a better error message can be made later.  */
5071
5072   if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM
5073       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
5074             && ((specbits & (1 << (int) RID_EXTERN))
5075                 || (current_binding_level == global_binding_level
5076                     && !(specbits
5077                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
5078     {
5079       error ("variable or field `%s' declared void", name);
5080       type = integer_type_node;
5081     }
5082
5083   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5084      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
5085
5086   {
5087     register tree decl;
5088
5089     if (decl_context == PARM)
5090       {
5091         tree type_as_written = type;
5092         tree main_type;
5093
5094         /* A parameter declared as an array of T is really a pointer to T.
5095            One declared as a function is really a pointer to a function.  */
5096
5097         if (TREE_CODE (type) == ARRAY_TYPE)
5098           {
5099             /* Transfer const-ness of array into that of type pointed to.  */
5100             type = TREE_TYPE (type);
5101             if (constp || volatilep)
5102               type = c_build_type_variant (type, constp, volatilep);
5103             type = build_pointer_type (type);
5104             volatilep = constp = 0;
5105             size_varies = 0;
5106           }
5107         else if (TREE_CODE (type) == FUNCTION_TYPE)
5108           {
5109             if (pedantic && (constp || volatilep))
5110               pedwarn ("ANSI C forbids const or volatile function types");
5111             if (constp || volatilep)
5112               type = c_build_type_variant (type, constp, volatilep);
5113             type = build_pointer_type (type);
5114             volatilep = constp = 0;
5115           }
5116
5117         decl = build_decl (PARM_DECL, declarator, type);
5118         if (size_varies)
5119           C_DECL_VARIABLE_SIZE (decl) = 1;
5120
5121         /* Compute the type actually passed in the parmlist,
5122            for the case where there is no prototype.
5123            (For example, shorts and chars are passed as ints.)
5124            When there is a prototype, this is overridden later.  */
5125
5126         DECL_ARG_TYPE (decl) = type;
5127         main_type = (type == error_mark_node
5128                      ? error_mark_node
5129                      : TYPE_MAIN_VARIANT (type));
5130         if (main_type == float_type_node)
5131           DECL_ARG_TYPE (decl) = double_type_node;
5132         /* Don't use TYPE_PRECISION to decide whether to promote,
5133            because we should convert short if it's the same size as int,
5134            but we should not convert long if it's the same size as int.  */
5135         else if (TREE_CODE (main_type) != ERROR_MARK
5136                  && C_PROMOTING_INTEGER_TYPE_P (main_type))
5137           {
5138             if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
5139                 && TREE_UNSIGNED (type))
5140               DECL_ARG_TYPE (decl) = unsigned_type_node;
5141             else
5142               DECL_ARG_TYPE (decl) = integer_type_node;
5143           }
5144
5145         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
5146       }
5147     else if (decl_context == FIELD)
5148       {
5149         /* Structure field.  It may not be a function.  */
5150
5151         if (TREE_CODE (type) == FUNCTION_TYPE)
5152           {
5153             error ("field `%s' declared as a function", name);
5154             type = build_pointer_type (type);
5155           }
5156         else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
5157           {
5158             error ("field `%s' has incomplete type", name);
5159             type = error_mark_node;
5160           }
5161         /* Move type qualifiers down to element of an array.  */
5162         if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
5163           {
5164             type = build_array_type (c_build_type_variant (TREE_TYPE (type),
5165                                                            constp, volatilep),
5166                                      TYPE_DOMAIN (type));
5167 #if 0 /* Leave the field const or volatile as well.  */
5168             constp = volatilep = 0;
5169 #endif
5170           }
5171         decl = build_decl (FIELD_DECL, declarator, type);
5172         if (size_varies)
5173           C_DECL_VARIABLE_SIZE (decl) = 1;
5174       }
5175     else if (TREE_CODE (type) == FUNCTION_TYPE)
5176       {
5177         /* Every function declaration is "external"
5178            except for those which are inside a function body
5179            in which `auto' is used.
5180            That is a case not specified by ANSI C,
5181            and we use it for forward declarations for nested functions.  */
5182         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
5183                           || current_binding_level == global_binding_level);
5184
5185         if (specbits & (1 << (int) RID_AUTO)
5186             && (pedantic || current_binding_level == global_binding_level))
5187           pedwarn ("invalid storage class for function `%s'", name);
5188         if (specbits & (1 << (int) RID_REGISTER))
5189           error ("invalid storage class for function `%s'", name);
5190         /* Function declaration not at top level.
5191            Storage classes other than `extern' are not allowed
5192            and `extern' makes no difference.  */
5193         if (current_binding_level != global_binding_level
5194             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
5195             && pedantic)
5196           pedwarn ("invalid storage class for function `%s'", name);
5197
5198         /* If this is a block level extern, it must live past the end
5199            of the function so that we can check it against other
5200            extern declarations (IDENTIFIER_LIMBO_VALUE).  */
5201         if (extern_ref && allocation_temporary_p ())
5202           end_temporary_allocation ();
5203
5204         decl = build_decl (FUNCTION_DECL, declarator, type);
5205         decl = build_decl_attribute_variant (decl, decl_machine_attr);
5206
5207         if (pedantic && (constp || volatilep)
5208             && ! DECL_IN_SYSTEM_HEADER (decl))
5209           pedwarn ("ANSI C forbids const or volatile functions");
5210
5211         if (pedantic
5212             && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl))) == void_type_node
5213             && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (decl)))
5214                 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (decl))))
5215             && ! DECL_IN_SYSTEM_HEADER (decl))
5216           pedwarn ("ANSI C forbids const or volatile void function return type");
5217
5218         if (volatilep
5219             && TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
5220           warning ("`noreturn' function returns non-void value");
5221
5222         if (extern_ref)
5223           DECL_EXTERNAL (decl) = 1;
5224         /* Record absence of global scope for `static' or `auto'.  */
5225         TREE_PUBLIC (decl)
5226           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
5227
5228         /* Record presence of `inline', if it is reasonable.  */
5229         if (inlinep)
5230           {
5231             if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
5232               warning ("cannot inline function `main'");
5233             else
5234               /* Assume that otherwise the function can be inlined.  */
5235               DECL_INLINE (decl) = 1;
5236
5237             if (specbits & (1 << (int) RID_EXTERN))
5238               current_extern_inline = 1;
5239           }
5240       }
5241     else
5242       {
5243         /* It's a variable.  */
5244         /* An uninitialized decl with `extern' is a reference.  */
5245         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
5246
5247         /* Move type qualifiers down to element of an array.  */
5248         if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
5249           {
5250             type = build_array_type (c_build_type_variant (TREE_TYPE (type),
5251                                                            constp, volatilep),
5252                                      TYPE_DOMAIN (type));
5253 #if 0 /* Leave the variable const or volatile as well.  */
5254             constp = volatilep = 0;
5255 #endif
5256           }
5257
5258         /* If this is a block level extern, it must live past the end
5259            of the function so that we can check it against other
5260            extern declarations (IDENTIFIER_LIMBO_VALUE).  */
5261         if (extern_ref && allocation_temporary_p ())
5262           end_temporary_allocation ();
5263
5264         decl = build_decl (VAR_DECL, declarator, type);
5265         if (size_varies)
5266           C_DECL_VARIABLE_SIZE (decl) = 1;
5267
5268         if (inlinep)
5269           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
5270
5271         DECL_EXTERNAL (decl) = extern_ref;
5272         /* At top level, the presence of a `static' or `register' storage
5273            class specifier, or the absence of all storage class specifiers
5274            makes this declaration a definition (perhaps tentative).  Also,
5275            the absence of both `static' and `register' makes it public.  */
5276         if (current_binding_level == global_binding_level)
5277           {
5278             TREE_PUBLIC (decl)
5279               = !(specbits
5280                   & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
5281             TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5282           }
5283         /* Not at top level, only `static' makes a static definition.  */
5284         else
5285           {
5286             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
5287             TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5288           }
5289
5290         if (specbits & 1 << (int) RID_ITERATOR)
5291           ITERATOR_P (decl) = 1;
5292       }
5293
5294     /* Record `register' declaration for warnings on &
5295        and in case doing stupid register allocation.  */
5296
5297     if (specbits & (1 << (int) RID_REGISTER))
5298       DECL_REGISTER (decl) = 1;
5299
5300     /* Record constancy and volatility.  */
5301
5302     if (constp)
5303       TREE_READONLY (decl) = 1;
5304     if (volatilep)
5305       {
5306         TREE_SIDE_EFFECTS (decl) = 1;
5307         TREE_THIS_VOLATILE (decl) = 1;
5308       }
5309     /* If a type has volatile components, it should be stored in memory.
5310        Otherwise, the fact that those components are volatile
5311        will be ignored, and would even crash the compiler.  */
5312     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
5313       mark_addressable (decl);
5314
5315     pop_obstacks ();
5316
5317     return decl;
5318   }
5319 }
5320 \f
5321 /* Decode the parameter-list info for a function type or function definition.
5322    The argument is the value returned by `get_parm_info' (or made in parse.y
5323    if there is an identifier list instead of a parameter decl list).
5324    These two functions are separate because when a function returns
5325    or receives functions then each is called multiple times but the order
5326    of calls is different.  The last call to `grokparms' is always the one
5327    that contains the formal parameter names of a function definition.
5328
5329    Store in `last_function_parms' a chain of the decls of parms.
5330    Also store in `last_function_parm_tags' a chain of the struct, union,
5331    and enum tags declared among the parms.
5332
5333    Return a list of arg types to use in the FUNCTION_TYPE for this function.
5334
5335    FUNCDEF_FLAG is nonzero for a function definition, 0 for
5336    a mere declaration.  A nonempty identifier-list gets an error message
5337    when FUNCDEF_FLAG is zero.  */
5338
5339 static tree
5340 grokparms (parms_info, funcdef_flag)
5341      tree parms_info;
5342      int funcdef_flag;
5343 {
5344   tree first_parm = TREE_CHAIN (parms_info);
5345
5346   last_function_parms = TREE_PURPOSE (parms_info);
5347   last_function_parm_tags = TREE_VALUE (parms_info);
5348
5349   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
5350       && !in_system_header)
5351     warning ("function declaration isn't a prototype");
5352
5353   if (first_parm != 0
5354       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
5355     {
5356       if (! funcdef_flag)
5357         pedwarn ("parameter names (without types) in function declaration");
5358
5359       last_function_parms = first_parm;
5360       return 0;
5361     }
5362   else
5363     {
5364       tree parm;
5365       tree typelt;
5366       /* We no longer test FUNCDEF_FLAG.
5367          If the arg types are incomplete in a declaration,
5368          they must include undefined tags.
5369          These tags can never be defined in the scope of the declaration,
5370          so the types can never be completed,
5371          and no call can be compiled successfully.  */
5372 #if 0
5373       /* In a fcn definition, arg types must be complete.  */
5374       if (funcdef_flag)
5375 #endif
5376         for (parm = last_function_parms, typelt = first_parm;
5377              parm;
5378              parm = TREE_CHAIN (parm))
5379           /* Skip over any enumeration constants declared here.  */
5380           if (TREE_CODE (parm) == PARM_DECL)
5381             {
5382               /* Barf if the parameter itself has an incomplete type.  */
5383               tree type = TREE_VALUE (typelt);
5384               if (TYPE_SIZE (type) == 0)
5385                 {
5386                   if (funcdef_flag && DECL_NAME (parm) != 0)
5387                     error ("parameter `%s' has incomplete type",
5388                            IDENTIFIER_POINTER (DECL_NAME (parm)));
5389                   else
5390                     warning ("parameter has incomplete type");
5391                   if (funcdef_flag)
5392                     {
5393                       TREE_VALUE (typelt) = error_mark_node;
5394                       TREE_TYPE (parm) = error_mark_node;
5395                     }
5396                 }
5397 #if 0  /* This has been replaced by parm_tags_warning
5398           which uses a more accurate criterion for what to warn about.  */
5399               else
5400                 {
5401                   /* Now warn if is a pointer to an incomplete type.  */
5402                   while (TREE_CODE (type) == POINTER_TYPE
5403                          || TREE_CODE (type) == REFERENCE_TYPE)
5404                     type = TREE_TYPE (type);
5405                   type = TYPE_MAIN_VARIANT (type);
5406                   if (TYPE_SIZE (type) == 0)
5407                     {
5408                       if (DECL_NAME (parm) != 0)
5409                         warning ("parameter `%s' points to incomplete type",
5410                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
5411                       else
5412                         warning ("parameter points to incomplete type");
5413                     }
5414                 }
5415 #endif
5416               typelt = TREE_CHAIN (typelt);
5417             }
5418
5419       /* Allocate the list of types the way we allocate a type.  */
5420       if (first_parm && ! TREE_PERMANENT (first_parm))
5421         {
5422           /* Construct a copy of the list of types
5423              on the saveable obstack.  */
5424           tree result = NULL;
5425           for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt))
5426             result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt),
5427                                          result);
5428           return nreverse (result);
5429         }
5430       else
5431         /* The list we have is permanent already.  */
5432         return first_parm;
5433     }
5434 }
5435
5436
5437 /* Return a tree_list node with info on a parameter list just parsed.
5438    The TREE_PURPOSE is a chain of decls of those parms.
5439    The TREE_VALUE is a list of structure, union and enum tags defined.
5440    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5441    This tree_list node is later fed to `grokparms'.
5442
5443    VOID_AT_END nonzero means append `void' to the end of the type-list.
5444    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
5445
5446 tree
5447 get_parm_info (void_at_end)
5448      int void_at_end;
5449 {
5450   register tree decl, t;
5451   register tree types = 0;
5452   int erred = 0;
5453   tree tags = gettags ();
5454   tree parms = getdecls ();
5455   tree new_parms = 0;
5456   tree order = current_binding_level->parm_order;
5457
5458   /* Just `void' (and no ellipsis) is special.  There are really no parms.  */
5459   if (void_at_end && parms != 0
5460       && TREE_CHAIN (parms) == 0
5461       && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
5462       && DECL_NAME (parms) == 0)
5463     {
5464       parms = NULL_TREE;
5465       storedecls (NULL_TREE);
5466       return saveable_tree_cons (NULL_TREE, NULL_TREE,
5467                                  saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5468     }
5469
5470   /* Extract enumerator values and other non-parms declared with the parms.
5471      Likewise any forward parm decls that didn't have real parm decls.  */
5472   for (decl = parms; decl; )
5473     {
5474       tree next = TREE_CHAIN (decl);
5475
5476       if (TREE_CODE (decl) != PARM_DECL)
5477         {
5478           TREE_CHAIN (decl) = new_parms;
5479           new_parms = decl;
5480         }
5481       else if (TREE_ASM_WRITTEN (decl))
5482         {
5483           error_with_decl (decl, "parameter `%s' has just a forward declaration");
5484           TREE_CHAIN (decl) = new_parms;
5485           new_parms = decl;
5486         }
5487       decl = next;
5488     }
5489
5490   /* Put the parm decls back in the order they were in in the parm list.  */
5491   for (t = order; t; t = TREE_CHAIN (t))
5492     {
5493       if (TREE_CHAIN (t))
5494         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5495       else
5496         TREE_CHAIN (TREE_VALUE (t)) = 0;
5497     }
5498
5499   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5500                        new_parms);
5501
5502   /* Store the parmlist in the binding level since the old one
5503      is no longer a valid list.  (We have changed the chain pointers.)  */
5504   storedecls (new_parms);
5505
5506   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5507     /* There may also be declarations for enumerators if an enumeration
5508        type is declared among the parms.  Ignore them here.  */
5509     if (TREE_CODE (decl) == PARM_DECL)
5510       {
5511         /* Since there is a prototype,
5512            args are passed in their declared types.  */
5513         tree type = TREE_TYPE (decl);
5514         DECL_ARG_TYPE (decl) = type;
5515 #ifdef PROMOTE_PROTOTYPES
5516         if ((TREE_CODE (type) == INTEGER_TYPE
5517              || TREE_CODE (type) == ENUMERAL_TYPE)
5518             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5519           DECL_ARG_TYPE (decl) = integer_type_node;
5520 #endif
5521
5522         types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5523         if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
5524             && DECL_NAME (decl) == 0)
5525           {
5526             error ("`void' in parameter list must be the entire list");
5527             erred = 1;
5528           }
5529       }
5530
5531   if (void_at_end)
5532     return saveable_tree_cons (new_parms, tags,
5533                                nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
5534
5535   return saveable_tree_cons (new_parms, tags, nreverse (types));
5536 }
5537
5538 /* At end of parameter list, warn about any struct, union or enum tags
5539    defined within.  Do so because these types cannot ever become complete.  */
5540
5541 void
5542 parmlist_tags_warning ()
5543 {
5544   tree elt;
5545   static int already;
5546
5547   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5548     {
5549       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5550       /* An anonymous union parm type is meaningful as a GNU extension.
5551          So don't warn for that.  */
5552       if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
5553         continue;
5554       if (TREE_PURPOSE (elt) != 0)
5555         warning ("`%s %s' declared inside parameter list",
5556                  (code == RECORD_TYPE ? "struct"
5557                   : code == UNION_TYPE ? "union"
5558                   : "enum"),
5559                  IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5560       else
5561         warning ("anonymous %s declared inside parameter list",
5562                  (code == RECORD_TYPE ? "struct"
5563                   : code == UNION_TYPE ? "union"
5564                   : "enum"));
5565
5566       if (! already)
5567         {
5568           warning ("its scope is only this definition or declaration,");
5569           warning ("which is probably not what you want.");
5570           already = 1;
5571         }
5572     }
5573 }
5574 \f
5575 /* Get the struct, enum or union (CODE says which) with tag NAME.
5576    Define the tag as a forward-reference if it is not defined.  */
5577
5578 tree
5579 xref_tag (code, name)
5580      enum tree_code code;
5581      tree name;
5582 {
5583   int temporary = allocation_temporary_p ();
5584
5585   /* If a cross reference is requested, look up the type
5586      already defined for this tag and return it.  */
5587
5588   register tree ref = lookup_tag (code, name, current_binding_level, 0);
5589   /* Even if this is the wrong type of tag, return what we found.
5590      There will be an error message anyway, from pending_xref_error.
5591      If we create an empty xref just for an invalid use of the type,
5592      the main result is to create lots of superfluous error messages.  */
5593   if (ref)
5594     return ref;
5595
5596   push_obstacks_nochange ();
5597
5598   if (current_binding_level == global_binding_level && temporary)
5599     end_temporary_allocation ();
5600
5601   /* If no such tag is yet defined, create a forward-reference node
5602      and record it as the "definition".
5603      When a real declaration of this type is found,
5604      the forward-reference will be altered into a real type.  */
5605
5606   ref = make_node (code);
5607   if (code == ENUMERAL_TYPE)
5608     {
5609       /* (In ANSI, Enums can be referred to only if already defined.)  */
5610       if (pedantic)
5611         pedwarn ("ANSI C forbids forward references to `enum' types");
5612       /* Give the type a default layout like unsigned int
5613          to avoid crashing if it does not get defined.  */
5614       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5615       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5616       TREE_UNSIGNED (ref) = 1;
5617       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5618       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5619       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5620     }
5621
5622   pushtag (name, ref);
5623
5624   pop_obstacks ();
5625
5626   return ref;
5627 }
5628 \f
5629 /* Make sure that the tag NAME is defined *in the current binding level*
5630    at least as a forward reference.
5631    CODE says which kind of tag NAME ought to be.
5632
5633    We also do a push_obstacks_nochange
5634    whose matching pop is in finish_struct.  */
5635
5636 tree
5637 start_struct (code, name)
5638      enum tree_code code;
5639      tree name;
5640 {
5641   /* If there is already a tag defined at this binding level
5642      (as a forward reference), just return it.  */
5643
5644   register tree ref = 0;
5645
5646   push_obstacks_nochange ();
5647   if (current_binding_level == global_binding_level)
5648     end_temporary_allocation ();
5649
5650   if (name != 0)
5651     ref = lookup_tag (code, name, current_binding_level, 1);
5652   if (ref && TREE_CODE (ref) == code)
5653     {
5654       C_TYPE_BEING_DEFINED (ref) = 1;
5655       TYPE_PACKED (ref) = flag_pack_struct;
5656       if (TYPE_FIELDS (ref))
5657         error ((code == UNION_TYPE ? "redefinition of `union %s'"
5658                 : "redefinition of `struct %s'"),
5659                IDENTIFIER_POINTER (name));
5660
5661       return ref;
5662     }
5663
5664   /* Otherwise create a forward-reference just so the tag is in scope.  */
5665
5666   ref = make_node (code);
5667   pushtag (name, ref);
5668   C_TYPE_BEING_DEFINED (ref) = 1;
5669   TYPE_PACKED (ref) = flag_pack_struct;
5670   return ref;
5671 }
5672
5673 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5674    of a structure component, returning a FIELD_DECL node.
5675    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5676
5677    This is done during the parsing of the struct declaration.
5678    The FIELD_DECL nodes are chained together and the lot of them
5679    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5680
5681 tree
5682 grokfield (filename, line, declarator, declspecs, width)
5683      char *filename;
5684      int line;
5685      tree declarator, declspecs, width;
5686 {
5687   tree value;
5688
5689   /* The corresponding pop_obstacks is in finish_decl.  */
5690   push_obstacks_nochange ();
5691
5692   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5693
5694   finish_decl (value, NULL_TREE, NULL_TREE);
5695   DECL_INITIAL (value) = width;
5696
5697   maybe_objc_check_decl (value);
5698   return value;
5699 }
5700 \f
5701 /* Function to help qsort sort FIELD_DECLs by name order.  */
5702
5703 static int
5704 field_decl_cmp (xp, yp)
5705      const GENERIC_PTR xp;
5706      const GENERIC_PTR yp;
5707 {
5708   tree *x = (tree *)xp, *y = (tree *)yp;
5709
5710   if (DECL_NAME (*x) == DECL_NAME (*y))
5711     return 0;
5712   if (DECL_NAME (*x) == NULL)
5713     return -1;
5714   if (DECL_NAME (*y) == NULL)
5715     return 1;
5716   if (DECL_NAME (*x) < DECL_NAME (*y))
5717     return -1;
5718   return 1;
5719 }
5720
5721 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5722    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5723    ATTRIBUTES are attributes to be applied to the structure.
5724
5725    We also do a pop_obstacks to match the push in start_struct.  */
5726
5727 tree
5728 finish_struct (t, fieldlist, attributes)
5729      tree t;
5730      tree fieldlist;
5731      tree attributes;
5732 {
5733   register tree x;
5734   int old_momentary;
5735   int toplevel = global_binding_level == current_binding_level;
5736
5737   /* If this type was previously laid out as a forward reference,
5738      make sure we lay it out again.  */
5739
5740   TYPE_SIZE (t) = 0;
5741
5742   decl_attributes (t, attributes, NULL_TREE);
5743
5744   /* Nameless union parm types are useful as GCC extension.  */
5745   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5746     /* Otherwise, warn about any struct or union def. in parmlist.  */
5747     if (in_parm_level_p ())
5748       {
5749         if (pedantic)
5750           pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5751                     : "structure defined inside parms"));
5752         else if (! flag_traditional)
5753           warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5754                     : "structure defined inside parms"));
5755       }
5756
5757   old_momentary = suspend_momentary ();
5758
5759   if (pedantic)
5760     {
5761       for (x = fieldlist; x; x = TREE_CHAIN (x))
5762         if (DECL_NAME (x) != 0)
5763           break;
5764
5765       if (x == 0)
5766         pedwarn ("%s has no %smembers",
5767                  (TREE_CODE (t) == UNION_TYPE ? "union" : "structure"),
5768                  (fieldlist ? "named " : ""));
5769     }
5770
5771   /* Install struct as DECL_CONTEXT of each field decl.
5772      Also process specified field sizes.
5773      Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
5774      The specified size is found in the DECL_INITIAL.
5775      Store 0 there, except for ": 0" fields (so we can find them
5776      and delete them, below).  */
5777
5778   for (x = fieldlist; x; x = TREE_CHAIN (x))
5779     {
5780       DECL_CONTEXT (x) = t;
5781       DECL_PACKED (x) |= TYPE_PACKED (t);
5782       DECL_FIELD_SIZE (x) = 0;
5783
5784       /* If any field is const, the structure type is pseudo-const.  */
5785       if (TREE_READONLY (x))
5786         C_TYPE_FIELDS_READONLY (t) = 1;
5787       else
5788         {
5789           /* A field that is pseudo-const makes the structure likewise.  */
5790           tree t1 = TREE_TYPE (x);
5791           while (TREE_CODE (t1) == ARRAY_TYPE)
5792             t1 = TREE_TYPE (t1);
5793           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5794               && C_TYPE_FIELDS_READONLY (t1))
5795             C_TYPE_FIELDS_READONLY (t) = 1;
5796         }
5797
5798       /* Any field that is volatile means variables of this type must be
5799          treated in some ways as volatile.  */
5800       if (TREE_THIS_VOLATILE (x))
5801         C_TYPE_FIELDS_VOLATILE (t) = 1;
5802
5803       /* Any field of nominal variable size implies structure is too.  */
5804       if (C_DECL_VARIABLE_SIZE (x))
5805         C_TYPE_VARIABLE_SIZE (t) = 1;
5806
5807       /* Detect invalid nested redefinition.  */
5808       if (TREE_TYPE (x) == t)
5809         error ("nested redefinition of `%s'",
5810                IDENTIFIER_POINTER (TYPE_NAME (t)));
5811
5812       /* Detect invalid bit-field size.  */
5813       if (DECL_INITIAL (x))
5814         STRIP_NOPS (DECL_INITIAL (x));
5815       if (DECL_INITIAL (x))
5816         {
5817           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5818             constant_expression_warning (DECL_INITIAL (x));
5819           else
5820             {
5821               error_with_decl (x, "bit-field `%s' width not an integer constant");
5822               DECL_INITIAL (x) = NULL;
5823             }
5824         }
5825
5826       /* Detect invalid bit-field type.  */
5827       if (DECL_INITIAL (x)
5828           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5829           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5830         {
5831           error_with_decl (x, "bit-field `%s' has invalid type");
5832           DECL_INITIAL (x) = NULL;
5833         }
5834       if (DECL_INITIAL (x) && pedantic
5835           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5836           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5837           /* Accept an enum that's equivalent to int or unsigned int.  */
5838           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5839                && (TYPE_PRECISION (TREE_TYPE (x))
5840                    == TYPE_PRECISION (integer_type_node))))
5841         pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
5842
5843       /* Detect and ignore out of range field width.  */
5844       if (DECL_INITIAL (x))
5845         {
5846           unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5847
5848           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5849             {
5850               DECL_INITIAL (x) = NULL;
5851               error_with_decl (x, "negative width in bit-field `%s'");
5852             }
5853           else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
5854                    || width > TYPE_PRECISION (TREE_TYPE (x)))
5855             {
5856               DECL_INITIAL (x) = NULL;
5857               pedwarn_with_decl (x, "width of `%s' exceeds its type");
5858             }
5859           else if (width == 0 && DECL_NAME (x) != 0)
5860             {
5861               error_with_decl (x, "zero width for bit-field `%s'");
5862               DECL_INITIAL (x) = NULL;
5863             }
5864         }
5865
5866       /* Process valid field width.  */
5867       if (DECL_INITIAL (x))
5868         {
5869           register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5870
5871           if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5872               && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5873                                          TREE_UNSIGNED (TREE_TYPE (x)))
5874                   || width < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5875                                             TREE_UNSIGNED (TREE_TYPE (x)))))
5876             warning_with_decl (x, "`%s' is narrower than values of its type");
5877
5878           DECL_FIELD_SIZE (x) = width;
5879           DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
5880           DECL_INITIAL (x) = NULL;
5881
5882           if (width == 0)
5883             {
5884               /* field size 0 => force desired amount of alignment.  */
5885 #ifdef EMPTY_FIELD_BOUNDARY
5886               DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5887 #endif
5888 #ifdef PCC_BITFIELD_TYPE_MATTERS
5889               if (PCC_BITFIELD_TYPE_MATTERS)
5890                 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5891                                       TYPE_ALIGN (TREE_TYPE (x)));
5892 #endif
5893             }
5894         }
5895       else if (TREE_TYPE (x) != error_mark_node)
5896         {
5897           unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5898                            : TYPE_ALIGN (TREE_TYPE (x)));
5899           /* Non-bit-fields are aligned for their type, except packed
5900              fields which require only BITS_PER_UNIT alignment.  */
5901           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5902         }
5903     }
5904
5905   /* Now DECL_INITIAL is null on all members.  */
5906
5907   /* Delete all duplicate fields from the fieldlist */
5908   for (x = fieldlist; x && TREE_CHAIN (x);)
5909     /* Anonymous fields aren't duplicates.  */
5910     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5911       x = TREE_CHAIN (x);
5912     else
5913       {
5914         register tree y = fieldlist;
5915
5916         while (1)
5917           {
5918             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5919               break;
5920             if (y == x)
5921               break;
5922             y = TREE_CHAIN (y);
5923           }
5924         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5925           {
5926             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5927             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5928           }
5929         else x = TREE_CHAIN (x);
5930       }
5931
5932   /* Now we have the nearly final fieldlist.  Record it,
5933      then lay out the structure or union (including the fields).  */
5934
5935   TYPE_FIELDS (t) = fieldlist;
5936
5937   layout_type (t);
5938
5939   /* Delete all zero-width bit-fields from the front of the fieldlist */
5940   while (fieldlist
5941          && DECL_INITIAL (fieldlist))
5942     fieldlist = TREE_CHAIN (fieldlist);
5943   /* Delete all such members from the rest of the fieldlist */
5944   for (x = fieldlist; x;)
5945     {
5946       if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
5947         TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5948       else x = TREE_CHAIN (x);
5949     }
5950
5951   /*  Now we have the truly final field list.
5952       Store it in this type and in the variants.  */
5953
5954   TYPE_FIELDS (t) = fieldlist;
5955
5956   /* If there are lots of fields, sort so we can look through them fast.
5957      We arbitrarily consider 16 or more elts to be "a lot".  */
5958   {
5959     int len = 0;
5960
5961     for (x = fieldlist; x; x = TREE_CHAIN (x))
5962       {
5963         if (len > 15)
5964           break;
5965         len += 1;
5966       }
5967     if (len > 15)
5968       {
5969         tree *field_array;
5970         char *space;
5971
5972         len += list_length (x);
5973         /* Use the same allocation policy here that make_node uses, to
5974            ensure that this lives as long as the rest of the struct decl.
5975            All decls in an inline function need to be saved.  */
5976         if (allocation_temporary_p ())
5977           space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
5978         else
5979           space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
5980
5981         TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
5982         TYPE_LANG_SPECIFIC (t)->len = len;
5983
5984         field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
5985         len = 0;
5986         for (x = fieldlist; x; x = TREE_CHAIN (x))
5987           field_array[len++] = x;
5988
5989         qsort (field_array, len, sizeof (tree), field_decl_cmp);
5990       }
5991   }
5992
5993   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5994     {
5995       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5996       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5997       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5998     }
5999
6000   /* If this was supposed to be a transparent union, but we can't
6001      make it one, warn and turn off the flag.  */
6002   if (TREE_CODE (t) == UNION_TYPE
6003       && TYPE_TRANSPARENT_UNION (t)
6004       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
6005     {
6006       TYPE_TRANSPARENT_UNION (t) = 0;
6007       warning ("union cannot be made transparent");
6008     }
6009
6010   /* If this structure or union completes the type of any previous
6011      variable declaration, lay it out and output its rtl.  */
6012
6013   if (current_binding_level->n_incomplete != 0)
6014     {
6015       tree decl;
6016       for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
6017         {
6018           if (TREE_TYPE (decl) == t
6019               && TREE_CODE (decl) != TYPE_DECL)
6020             {
6021               layout_decl (decl, 0);
6022               /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
6023               maybe_objc_check_decl (decl);
6024               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
6025               if (! toplevel)
6026                 expand_decl (decl);
6027               --current_binding_level->n_incomplete;
6028             }
6029           else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
6030                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
6031             {
6032               tree element = TREE_TYPE (decl);
6033               while (TREE_CODE (element) == ARRAY_TYPE)
6034                 element = TREE_TYPE (element);
6035               if (element == t)
6036                 layout_array_type (TREE_TYPE (decl));
6037             }
6038         }
6039     }
6040
6041   resume_momentary (old_momentary);
6042
6043   /* Finish debugging output for this type.  */
6044   rest_of_type_compilation (t, toplevel);
6045
6046   /* The matching push is in start_struct.  */
6047   pop_obstacks ();
6048
6049   return t;
6050 }
6051
6052 /* Lay out the type T, and its element type, and so on.  */
6053
6054 static void
6055 layout_array_type (t)
6056      tree t;
6057 {
6058   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
6059     layout_array_type (TREE_TYPE (t));
6060   layout_type (t);
6061 }
6062 \f
6063 /* Begin compiling the definition of an enumeration type.
6064    NAME is its name (or null if anonymous).
6065    Returns the type object, as yet incomplete.
6066    Also records info about it so that build_enumerator
6067    may be used to declare the individual values as they are read.  */
6068
6069 tree
6070 start_enum (name)
6071      tree name;
6072 {
6073   register tree enumtype = 0;
6074
6075   /* If this is the real definition for a previous forward reference,
6076      fill in the contents in the same object that used to be the
6077      forward reference.  */
6078
6079   if (name != 0)
6080     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
6081
6082   /* The corresponding pop_obstacks is in finish_enum.  */
6083   push_obstacks_nochange ();
6084   /* If these symbols and types are global, make them permanent.  */
6085   if (current_binding_level == global_binding_level)
6086     end_temporary_allocation ();
6087
6088   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
6089     {
6090       enumtype = make_node (ENUMERAL_TYPE);
6091       pushtag (name, enumtype);
6092     }
6093
6094   C_TYPE_BEING_DEFINED (enumtype) = 1;
6095
6096   if (TYPE_VALUES (enumtype) != 0)
6097     {
6098       /* This enum is a named one that has been declared already.  */
6099       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
6100
6101       /* Completely replace its old definition.
6102          The old enumerators remain defined, however.  */
6103       TYPE_VALUES (enumtype) = 0;
6104     }
6105
6106   enum_next_value = integer_zero_node;
6107   enum_overflow = 0;
6108
6109   if (flag_short_enums)
6110     TYPE_PACKED (enumtype) = 1;
6111
6112   return enumtype;
6113 }
6114
6115 /* After processing and defining all the values of an enumeration type,
6116    install their decls in the enumeration type and finish it off.
6117    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
6118    and ATTRIBUTES are the specified attributes.
6119    Returns ENUMTYPE.  */
6120
6121 tree
6122 finish_enum (enumtype, values, attributes)
6123      tree enumtype;
6124      tree values;
6125      tree attributes;
6126 {
6127   register tree pair, tem;
6128   tree minnode = 0, maxnode = 0;
6129   int lowprec, highprec, precision;
6130   int toplevel = global_binding_level == current_binding_level;
6131
6132   if (in_parm_level_p ())
6133     warning ("enum defined inside parms");
6134
6135   decl_attributes (enumtype, attributes, NULL_TREE);
6136
6137   /* Calculate the maximum value of any enumerator in this type.  */
6138
6139   if (values == error_mark_node)
6140     minnode = maxnode = integer_zero_node;
6141   else
6142     for (pair = values; pair; pair = TREE_CHAIN (pair))
6143       {
6144         tree value = TREE_VALUE (pair);
6145         if (pair == values)
6146           minnode = maxnode = TREE_VALUE (pair);
6147         else
6148           {
6149             if (tree_int_cst_lt (maxnode, value))
6150               maxnode = value;
6151             if (tree_int_cst_lt (value, minnode))
6152               minnode = value;
6153           }
6154       }
6155
6156   TYPE_MIN_VALUE (enumtype) = minnode;
6157   TYPE_MAX_VALUE (enumtype) = maxnode;
6158
6159   /* An enum can have some negative values; then it is signed.  */
6160   TREE_UNSIGNED (enumtype) = tree_int_cst_sgn (minnode) >= 0;
6161
6162   /* Determine the precision this type needs.  */
6163
6164   lowprec = min_precision (minnode, TREE_UNSIGNED (enumtype));
6165   highprec = min_precision (maxnode, TREE_UNSIGNED (enumtype));
6166   precision = MAX (lowprec, highprec);
6167
6168   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
6169     {
6170       tree narrowest = type_for_size (precision, 1);
6171       if (narrowest == 0)
6172         {
6173           warning ("enumeration values exceed range of largest integer");
6174           narrowest = long_long_integer_type_node;
6175         }
6176
6177       TYPE_PRECISION (enumtype) = TYPE_PRECISION (narrowest);
6178     }
6179   else
6180     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
6181
6182   TYPE_SIZE (enumtype) = 0;
6183   layout_type (enumtype);
6184
6185   if (values != error_mark_node)
6186     {
6187       /* Change the type of the enumerators to be the enum type.
6188          Formerly this was done only for enums that fit in an int,
6189          but the comment said it was done only for enums wider than int.
6190          It seems necessary to do this for wide enums,
6191          and best not to change what's done for ordinary narrower ones.  */
6192       for (pair = values; pair; pair = TREE_CHAIN (pair))
6193         {
6194           TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
6195           DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
6196           if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL)
6197             DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
6198         }
6199
6200       /* Replace the decl nodes in VALUES with their names.  */
6201       for (pair = values; pair; pair = TREE_CHAIN (pair))
6202         TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
6203
6204       TYPE_VALUES (enumtype) = values;
6205     }
6206
6207   /* Fix up all variant types of this enum type.  */
6208   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
6209     {
6210       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
6211       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
6212       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
6213       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
6214       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
6215       TYPE_MODE (tem) = TYPE_MODE (enumtype);
6216       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
6217       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
6218       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
6219     }
6220
6221   /* Finish debugging output for this type.  */
6222   rest_of_type_compilation (enumtype, toplevel);
6223
6224   /* This matches a push in start_enum.  */
6225   pop_obstacks ();
6226
6227   return enumtype;
6228 }
6229
6230 /* Build and install a CONST_DECL for one value of the
6231    current enumeration type (one that was begun with start_enum).
6232    Return a tree-list containing the CONST_DECL and its value.
6233    Assignment of sequential values by default is handled here.  */
6234
6235 tree
6236 build_enumerator (name, value)
6237      tree name, value;
6238 {
6239   register tree decl, type;
6240
6241   /* Validate and default VALUE.  */
6242
6243   /* Remove no-op casts from the value.  */
6244   if (value)
6245     STRIP_TYPE_NOPS (value);
6246
6247   if (value != 0)
6248     {
6249       if (TREE_CODE (value) == INTEGER_CST)
6250         {
6251           value = default_conversion (value);
6252           constant_expression_warning (value);
6253         }
6254       else
6255         {
6256           error ("enumerator value for `%s' not integer constant",
6257                  IDENTIFIER_POINTER (name));
6258           value = 0;
6259         }
6260     }
6261
6262   /* Default based on previous value.  */
6263   /* It should no longer be possible to have NON_LVALUE_EXPR
6264      in the default.  */
6265   if (value == 0)
6266     {
6267       value = enum_next_value;
6268       if (enum_overflow)
6269         error ("overflow in enumeration values");
6270     }
6271
6272   if (pedantic && ! int_fits_type_p (value, integer_type_node))
6273     {
6274       pedwarn ("ANSI C restricts enumerator values to range of `int'");
6275       value = integer_zero_node;
6276     }
6277
6278   /* Set basis for default for next value.  */
6279   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
6280   enum_overflow = tree_int_cst_lt (enum_next_value, value);
6281
6282   /* Now create a declaration for the enum value name.  */
6283
6284   type = TREE_TYPE (value);
6285   type = type_for_size (MAX (TYPE_PRECISION (type),
6286                              TYPE_PRECISION (integer_type_node)),
6287                         ((flag_traditional
6288                           || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
6289                          && TREE_UNSIGNED (type)));
6290
6291   decl = build_decl (CONST_DECL, name, type);
6292   DECL_INITIAL (decl) = value;
6293   TREE_TYPE (value) = type;
6294   pushdecl (decl);
6295
6296   return saveable_tree_cons (decl, value, NULL_TREE);
6297 }
6298 \f
6299 /* Create the FUNCTION_DECL for a function definition.
6300    DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of
6301    the declaration; they describe the function's name and the type it returns,
6302    but twisted together in a fashion that parallels the syntax of C.
6303
6304    This function creates a binding context for the function body
6305    as well as setting up the FUNCTION_DECL in current_function_decl.
6306
6307    Returns 1 on success.  If the DECLARATOR is not suitable for a function
6308    (it defines a datum instead), we return 0, which tells
6309    yyparse to report a parse error.
6310
6311    NESTED is nonzero for a function nested within another function.  */
6312
6313 int
6314 start_function (declspecs, declarator, prefix_attributes, attributes, nested)
6315      tree declarator, declspecs, prefix_attributes, attributes;
6316      int nested;
6317 {
6318   tree decl1, old_decl;
6319   tree restype;
6320   int old_immediate_size_expand = immediate_size_expand;
6321
6322   current_function_returns_value = 0;  /* Assume, until we see it does.  */
6323   current_function_returns_null = 0;
6324   warn_about_return_type = 0;
6325   current_extern_inline = 0;
6326   c_function_varargs = 0;
6327   named_labels = 0;
6328   shadowed_labels = 0;
6329
6330   /* Don't expand any sizes in the return type of the function.  */
6331   immediate_size_expand = 0;
6332
6333   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
6334
6335   /* If the declarator is not suitable for a function definition,
6336      cause a syntax error.  */
6337   if (decl1 == 0)
6338     {
6339       immediate_size_expand = old_immediate_size_expand;
6340       return 0;
6341     }
6342
6343   decl_attributes (decl1, prefix_attributes, attributes);
6344
6345   announce_function (decl1);
6346
6347   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
6348     {
6349       error ("return-type is an incomplete type");
6350       /* Make it return void instead.  */
6351       TREE_TYPE (decl1)
6352         = build_function_type (void_type_node,
6353                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6354     }
6355
6356   if (warn_about_return_type)
6357     warning ("return-type defaults to `int'");
6358
6359   /* Save the parm names or decls from this function's declarator
6360      where store_parm_decls will find them.  */
6361   current_function_parms = last_function_parms;
6362   current_function_parm_tags = last_function_parm_tags;
6363
6364   /* Make the init_value nonzero so pushdecl knows this is not tentative.
6365      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
6366   DECL_INITIAL (decl1) = error_mark_node;
6367
6368   /* If this definition isn't a prototype and we had a prototype declaration
6369      before, copy the arg type info from that prototype.
6370      But not if what we had before was a builtin function.  */
6371   old_decl = lookup_name_current_level (DECL_NAME (decl1));
6372   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6373       && !DECL_BUILT_IN (old_decl)
6374       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6375           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
6376       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6377     {
6378       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
6379       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
6380       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
6381     }
6382
6383   /* If there is no explicit declaration, look for any out-of-scope implicit
6384      declarations.  */
6385   if (old_decl == 0)
6386     old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
6387
6388   /* Optionally warn of old-fashioned def with no previous prototype.  */
6389   if (warn_strict_prototypes
6390       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6391       && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
6392     warning ("function declaration isn't a prototype");
6393   /* Optionally warn of any global def with no previous prototype.  */
6394   else if (warn_missing_prototypes
6395            && TREE_PUBLIC (decl1)
6396            && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
6397            && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6398     warning_with_decl (decl1, "no previous prototype for `%s'");
6399   /* Optionally warn of any def with no previous prototype
6400      if the function has already been used.  */
6401   else if (warn_missing_prototypes
6402            && old_decl != 0 && TREE_USED (old_decl)
6403            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6404     warning_with_decl (decl1,
6405                       "`%s' was used with no prototype before its definition");
6406   /* Optionally warn of any global def with no previous declaration.  */
6407   else if (warn_missing_declarations
6408            && TREE_PUBLIC (decl1)
6409            && old_decl == 0
6410            && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6411     warning_with_decl (decl1, "no previous declaration for `%s'");
6412   /* Optionally warn of any def with no previous declaration
6413      if the function has already been used.  */
6414   else if (warn_missing_declarations
6415            && old_decl != 0 && TREE_USED (old_decl)
6416            && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
6417     warning_with_decl (decl1,
6418                     "`%s' was used with no declaration before its definition");
6419
6420   /* This is a definition, not a reference.
6421      So normally clear DECL_EXTERNAL.
6422      However, `extern inline' acts like a declaration
6423      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
6424   DECL_EXTERNAL (decl1) = current_extern_inline;
6425
6426   /* This function exists in static storage.
6427      (This does not mean `static' in the C sense!)  */
6428   TREE_STATIC (decl1) = 1;
6429
6430   /* A nested function is not global.  */
6431   if (current_function_decl != 0)
6432     TREE_PUBLIC (decl1) = 0;
6433
6434   /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6435   if (warn_main
6436       && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))) == 0)
6437     {
6438       tree args;
6439       int argct = 0;
6440
6441       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6442            != integer_type_node)
6443         pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
6444
6445       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6446            args = TREE_CHAIN (args))
6447         {
6448           tree type = args ? TREE_VALUE (args) : 0;
6449
6450           if (type == void_type_node)
6451             break;
6452
6453           ++argct;
6454           switch (argct)
6455             {
6456             case 1:
6457               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6458                 pedwarn_with_decl (decl1,
6459                                    "first argument of `%s' should be `int'");
6460               break;
6461
6462             case 2:
6463               if (TREE_CODE (type) != POINTER_TYPE
6464                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6465                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6466                       != char_type_node))
6467                 pedwarn_with_decl (decl1,
6468                                "second argument of `%s' should be `char **'");
6469               break;
6470
6471             case 3:
6472               if (TREE_CODE (type) != POINTER_TYPE
6473                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6474                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6475                       != char_type_node))
6476                 pedwarn_with_decl (decl1,
6477                    "third argument of `%s' should probably be `char **'");
6478               break;
6479             }
6480         }
6481
6482       /* It is intentional that this message does not mention the third
6483          argument, which is warned for only pedantically, because it's
6484          blessed by mention in an appendix of the standard. */
6485       if (argct > 0 && (argct < 2 || argct > 3))
6486         pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6487
6488       if (argct == 3 && pedantic)
6489         pedwarn_with_decl (decl1, "third argument of `%s' is deprecated");
6490
6491       if (! TREE_PUBLIC (decl1))
6492         pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6493     }
6494
6495   /* Record the decl so that the function name is defined.
6496      If we already have a decl for this name, and it is a FUNCTION_DECL,
6497      use the old decl.  */
6498
6499   current_function_decl = pushdecl (decl1);
6500
6501   pushlevel (0);
6502   declare_parm_level (1);
6503   current_binding_level->subblocks_tag_transparent = 1;
6504
6505   make_function_rtl (current_function_decl);
6506
6507   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6508   /* Promote the value to int before returning it.  */
6509   if (C_PROMOTING_INTEGER_TYPE_P (restype))
6510     {
6511       /* It retains unsignedness if traditional
6512          or if not really getting wider.  */
6513       if (TREE_UNSIGNED (restype)
6514           && (flag_traditional
6515               || (TYPE_PRECISION (restype)
6516                   == TYPE_PRECISION (integer_type_node))))
6517         restype = unsigned_type_node;
6518       else
6519         restype = integer_type_node;
6520     }
6521   DECL_RESULT (current_function_decl)
6522     = build_decl (RESULT_DECL, NULL_TREE, restype);
6523
6524   if (!nested)
6525     /* Allocate further tree nodes temporarily during compilation
6526        of this function only.  */
6527     temporary_allocation ();
6528
6529   /* If this fcn was already referenced via a block-scope `extern' decl
6530      (or an implicit decl), propagate certain information about the usage.  */
6531   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6532     TREE_ADDRESSABLE (current_function_decl) = 1;
6533
6534   immediate_size_expand = old_immediate_size_expand;
6535
6536   return 1;
6537 }
6538
6539 /* Record that this function is going to be a varargs function.
6540    This is called before store_parm_decls, which is too early
6541    to call mark_varargs directly.  */
6542
6543 void
6544 c_mark_varargs ()
6545 {
6546   c_function_varargs = 1;
6547 }
6548 \f
6549 /* Store the parameter declarations into the current function declaration.
6550    This is called after parsing the parameter declarations, before
6551    digesting the body of the function.
6552
6553    For an old-style definition, modify the function's type
6554    to specify at least the number of arguments.  */
6555
6556 void
6557 store_parm_decls ()
6558 {
6559   register tree fndecl = current_function_decl;
6560   register tree parm;
6561
6562   /* This is either a chain of PARM_DECLs (if a prototype was used)
6563      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
6564   tree specparms = current_function_parms;
6565
6566   /* This is a list of types declared among parms in a prototype.  */
6567   tree parmtags = current_function_parm_tags;
6568
6569   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
6570   register tree parmdecls = getdecls ();
6571
6572   /* This is a chain of any other decls that came in among the parm
6573      declarations.  If a parm is declared with  enum {foo, bar} x;
6574      then CONST_DECLs for foo and bar are put here.  */
6575   tree nonparms = 0;
6576
6577   /* Nonzero if this definition is written with a prototype.  */
6578   int prototype = 0;
6579
6580   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6581     {
6582       /* This case is when the function was defined with an ANSI prototype.
6583          The parms already have decls, so we need not do anything here
6584          except record them as in effect
6585          and complain if any redundant old-style parm decls were written.  */
6586
6587       register tree next;
6588       tree others = 0;
6589
6590       prototype = 1;
6591
6592       if (parmdecls != 0)
6593         {
6594           tree decl, link;
6595
6596           error_with_decl (fndecl,
6597                            "parm types given both in parmlist and separately");
6598           /* Get rid of the erroneous decls; don't keep them on
6599              the list of parms, since they might not be PARM_DECLs.  */
6600           for (decl = current_binding_level->names;
6601                decl; decl = TREE_CHAIN (decl))
6602             if (DECL_NAME (decl))
6603               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6604           for (link = current_binding_level->shadowed;
6605                link; link = TREE_CHAIN (link))
6606             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6607           current_binding_level->names = 0;
6608           current_binding_level->shadowed = 0;
6609         }
6610
6611       specparms = nreverse (specparms);
6612       for (parm = specparms; parm; parm = next)
6613         {
6614           next = TREE_CHAIN (parm);
6615           if (TREE_CODE (parm) == PARM_DECL)
6616             {
6617               if (DECL_NAME (parm) == 0)
6618                 error_with_decl (parm, "parameter name omitted");
6619               else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6620                 {
6621                   error_with_decl (parm, "parameter `%s' declared void");
6622                   /* Change the type to error_mark_node so this parameter
6623                      will be ignored by assign_parms.  */
6624                   TREE_TYPE (parm) = error_mark_node;
6625                 }
6626               pushdecl (parm);
6627             }
6628           else
6629             {
6630               /* If we find an enum constant or a type tag,
6631                  put it aside for the moment.  */
6632               TREE_CHAIN (parm) = 0;
6633               others = chainon (others, parm);
6634             }
6635         }
6636
6637       /* Get the decls in their original chain order
6638          and record in the function.  */
6639       DECL_ARGUMENTS (fndecl) = getdecls ();
6640
6641 #if 0
6642       /* If this function takes a variable number of arguments,
6643          add a phony parameter to the end of the parm list,
6644          to represent the position of the first unnamed argument.  */
6645       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6646           != void_type_node)
6647         {
6648           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6649           /* Let's hope the address of the unnamed parm
6650              won't depend on its type.  */
6651           TREE_TYPE (dummy) = integer_type_node;
6652           DECL_ARG_TYPE (dummy) = integer_type_node;
6653           DECL_ARGUMENTS (fndecl)
6654             = chainon (DECL_ARGUMENTS (fndecl), dummy);
6655         }
6656 #endif
6657
6658       /* Now pushdecl the enum constants.  */
6659       for (parm = others; parm; parm = next)
6660         {
6661           next = TREE_CHAIN (parm);
6662           if (DECL_NAME (parm) == 0)
6663             ;
6664           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6665             ;
6666           else if (TREE_CODE (parm) != PARM_DECL)
6667             pushdecl (parm);
6668         }
6669
6670       storetags (chainon (parmtags, gettags ()));
6671     }
6672   else
6673     {
6674       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6675          each with a parm name as the TREE_VALUE.
6676
6677          PARMDECLS is a chain of declarations for parameters.
6678          Warning! It can also contain CONST_DECLs which are not parameters
6679          but are names of enumerators of any enum types
6680          declared among the parameters.
6681
6682          First match each formal parameter name with its declaration.
6683          Associate decls with the names and store the decls
6684          into the TREE_PURPOSE slots.  */
6685
6686       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6687         DECL_RESULT (parm) = 0;
6688
6689       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6690         {
6691           register tree tail, found = NULL;
6692
6693           if (TREE_VALUE (parm) == 0)
6694             {
6695               error_with_decl (fndecl, "parameter name missing from parameter list");
6696               TREE_PURPOSE (parm) = 0;
6697               continue;
6698             }
6699
6700           /* See if any of the parmdecls specifies this parm by name.
6701              Ignore any enumerator decls.  */
6702           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6703             if (DECL_NAME (tail) == TREE_VALUE (parm)
6704                 && TREE_CODE (tail) == PARM_DECL)
6705               {
6706                 found = tail;
6707                 break;
6708               }
6709
6710           /* If declaration already marked, we have a duplicate name.
6711              Complain, and don't use this decl twice.   */
6712           if (found && DECL_RESULT (found) != 0)
6713             {
6714               error_with_decl (found, "multiple parameters named `%s'");
6715               found = 0;
6716             }
6717
6718           /* If the declaration says "void", complain and ignore it.  */
6719           if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6720             {
6721               error_with_decl (found, "parameter `%s' declared void");
6722               TREE_TYPE (found) = integer_type_node;
6723               DECL_ARG_TYPE (found) = integer_type_node;
6724               layout_decl (found, 0);
6725             }
6726
6727           /* Traditionally, a parm declared float is actually a double.  */
6728           if (found && flag_traditional
6729               && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6730             {
6731               TREE_TYPE (found) = double_type_node;
6732               DECL_ARG_TYPE (found) = double_type_node;
6733               layout_decl (found, 0);
6734             }
6735
6736           /* If no declaration found, default to int.  */
6737           if (!found)
6738             {
6739               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6740                                   integer_type_node);
6741               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6742               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6743               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6744               if (extra_warnings)
6745                 warning_with_decl (found, "type of `%s' defaults to `int'");
6746               pushdecl (found);
6747             }
6748
6749           TREE_PURPOSE (parm) = found;
6750
6751           /* Mark this decl as "already found" -- see test, above.
6752              It is safe to use DECL_RESULT for this
6753              since it is not used in PARM_DECLs or CONST_DECLs.  */
6754           DECL_RESULT (found) = error_mark_node;
6755         }
6756
6757       /* Put anything which is on the parmdecls chain and which is
6758          not a PARM_DECL onto the list NONPARMS.  (The types of
6759          non-parm things which might appear on the list include
6760          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6761          any actual PARM_DECLs not matched with any names.  */
6762
6763       nonparms = 0;
6764       for (parm = parmdecls; parm; )
6765         {
6766           tree next = TREE_CHAIN (parm);
6767           TREE_CHAIN (parm) = 0;
6768
6769           if (TREE_CODE (parm) != PARM_DECL)
6770             nonparms = chainon (nonparms, parm);
6771           else
6772             {
6773               /* Complain about args with incomplete types.  */
6774               if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6775                 {
6776                   error_with_decl (parm, "parameter `%s' has incomplete type");
6777                   TREE_TYPE (parm) = error_mark_node;
6778                 }
6779
6780               if (DECL_RESULT (parm) == 0)
6781                 {
6782                   error_with_decl (parm,
6783                                    "declaration for parameter `%s' but no such parameter");
6784                   /* Pretend the parameter was not missing.
6785                      This gets us to a standard state and minimizes
6786                      further error messages.  */
6787                   specparms
6788                     = chainon (specparms,
6789                                tree_cons (parm, NULL_TREE, NULL_TREE));
6790                 }
6791             }
6792
6793           parm = next;
6794         }
6795
6796       /* Chain the declarations together in the order of the list of names.  */
6797       /* Store that chain in the function decl, replacing the list of names.  */
6798       parm = specparms;
6799       DECL_ARGUMENTS (fndecl) = 0;
6800       {
6801         register tree last;
6802         for (last = 0; parm; parm = TREE_CHAIN (parm))
6803           if (TREE_PURPOSE (parm))
6804             {
6805               if (last == 0)
6806                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6807               else
6808                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6809               last = TREE_PURPOSE (parm);
6810               TREE_CHAIN (last) = 0;
6811             }
6812       }
6813
6814       /* If there was a previous prototype,
6815          set the DECL_ARG_TYPE of each argument according to
6816          the type previously specified, and report any mismatches.  */
6817
6818       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6819         {
6820           register tree type;
6821           for (parm = DECL_ARGUMENTS (fndecl),
6822                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6823                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6824                                  != void_type_node));
6825                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6826             {
6827               if (parm == 0 || type == 0
6828                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6829                 {
6830                   error ("number of arguments doesn't match prototype");
6831                   error_with_file_and_line (current_function_prototype_file,
6832                                             current_function_prototype_line,
6833                                             "prototype declaration");
6834                   break;
6835                 }
6836               /* Type for passing arg must be consistent
6837                  with that declared for the arg.  */
6838               if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6839                 {
6840                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6841                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6842                     {
6843                       /* Adjust argument to match prototype.  E.g. a previous
6844                          `int foo(float);' prototype causes
6845                          `int foo(x) float x; {...}' to be treated like
6846                          `int foo(float x) {...}'.  This is particularly
6847                          useful for argument types like uid_t.  */
6848                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6849 #ifdef PROMOTE_PROTOTYPES
6850                       if ((TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6851                            || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6852                           && TYPE_PRECISION (TREE_TYPE (parm))
6853                           < TYPE_PRECISION (integer_type_node))
6854                         DECL_ARG_TYPE (parm) = integer_type_node;
6855 #endif
6856                       if (pedantic)
6857                         {
6858                           pedwarn ("promoted argument `%s' doesn't match prototype",
6859                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6860                           warning_with_file_and_line
6861                             (current_function_prototype_file,
6862                              current_function_prototype_line,
6863                              "prototype declaration");
6864                         }
6865                     }
6866                   /* If -traditional, allow `int' argument to match
6867                      `unsigned' prototype.  */
6868                   else if (! (flag_traditional
6869                               && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6870                               && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6871                     {
6872                       error ("argument `%s' doesn't match prototype",
6873                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6874                       error_with_file_and_line (current_function_prototype_file,
6875                                                 current_function_prototype_line,
6876                                                 "prototype declaration");
6877                     }
6878                 }
6879             }
6880           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6881         }
6882
6883       /* Otherwise, create a prototype that would match.  */
6884
6885       else
6886         {
6887           tree actual = 0, last = 0, type;
6888
6889           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6890             {
6891               type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm),
6892                                      NULL_TREE);
6893               if (last)
6894                 TREE_CHAIN (last) = type;
6895               else
6896                 actual = type;
6897               last = type;
6898             }
6899           type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6900           if (last)
6901             TREE_CHAIN (last) = type;
6902           else
6903             actual = type;
6904
6905           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6906              of the type of this function, but we need to avoid having this
6907              affect the types of other similarly-typed functions, so we must
6908              first force the generation of an identical (but separate) type
6909              node for the relevant function type.  The new node we create
6910              will be a variant of the main variant of the original function
6911              type.  */
6912
6913           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6914
6915           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6916         }
6917
6918       /* Now store the final chain of decls for the arguments
6919          as the decl-chain of the current lexical scope.
6920          Put the enumerators in as well, at the front so that
6921          DECL_ARGUMENTS is not modified.  */
6922
6923       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6924     }
6925
6926   /* Make sure the binding level for the top of the function body
6927      gets a BLOCK if there are any in the function.
6928      Otherwise, the dbx output is wrong.  */
6929
6930   keep_next_if_subblocks = 1;
6931
6932   /* ??? This might be an improvement,
6933      but needs to be thought about some more.  */
6934 #if 0
6935   keep_next_level_flag = 1;
6936 #endif
6937
6938   /* Write a record describing this function definition to the prototypes
6939      file (if requested).  */
6940
6941   gen_aux_info_record (fndecl, 1, 0, prototype);
6942
6943   /* Initialize the RTL code for the function.  */
6944
6945   init_function_start (fndecl, input_filename, lineno);
6946
6947   /* If this is a varargs function, inform function.c.  */
6948
6949   if (c_function_varargs)
6950     mark_varargs ();
6951
6952   /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
6953
6954   declare_function_name ();
6955
6956   /* Set up parameters and prepare for return, for the function.  */
6957
6958   expand_function_start (fndecl, 0);
6959
6960   /* If this function is `main', emit a call to `__main'
6961      to run global initializers, etc.  */
6962   if (DECL_NAME (fndecl)
6963       && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
6964       && DECL_CONTEXT (fndecl) == NULL_TREE)
6965     expand_main_function ();
6966 }
6967 \f
6968 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6969    each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
6970    stands for an ellipsis in the identifier list.
6971
6972    PARMLIST is the data returned by get_parm_info for the
6973    parmlist that follows the semicolon.
6974
6975    We return a value of the same sort that get_parm_info returns,
6976    except that it describes the combination of identifiers and parmlist.  */
6977
6978 tree
6979 combine_parm_decls (specparms, parmlist, void_at_end)
6980      tree specparms, parmlist;
6981      int void_at_end;
6982 {
6983   register tree fndecl = current_function_decl;
6984   register tree parm;
6985
6986   tree parmdecls = TREE_PURPOSE (parmlist);
6987
6988   /* This is a chain of any other decls that came in among the parm
6989      declarations.  They were separated already by get_parm_info,
6990      so we just need to keep them separate.  */
6991   tree nonparms = TREE_VALUE (parmlist);
6992
6993   tree types = 0;
6994
6995   for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6996     DECL_RESULT (parm) = 0;
6997
6998   for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6999     {
7000       register tree tail, found = NULL;
7001
7002       /* See if any of the parmdecls specifies this parm by name.  */
7003       for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
7004         if (DECL_NAME (tail) == TREE_VALUE (parm))
7005           {
7006             found = tail;
7007             break;
7008           }
7009
7010       /* If declaration already marked, we have a duplicate name.
7011          Complain, and don't use this decl twice.   */
7012       if (found && DECL_RESULT (found) != 0)
7013         {
7014           error_with_decl (found, "multiple parameters named `%s'");
7015           found = 0;
7016         }
7017
7018       /* If the declaration says "void", complain and ignore it.  */
7019       if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
7020         {
7021           error_with_decl (found, "parameter `%s' declared void");
7022           TREE_TYPE (found) = integer_type_node;
7023           DECL_ARG_TYPE (found) = integer_type_node;
7024           layout_decl (found, 0);
7025         }
7026
7027       /* Traditionally, a parm declared float is actually a double.  */
7028       if (found && flag_traditional
7029           && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
7030         {
7031           TREE_TYPE (found) = double_type_node;
7032           DECL_ARG_TYPE (found) = double_type_node;
7033           layout_decl (found, 0);
7034         }
7035
7036       /* If no declaration found, default to int.  */
7037       if (!found)
7038         {
7039           found = build_decl (PARM_DECL, TREE_VALUE (parm),
7040                               integer_type_node);
7041           DECL_ARG_TYPE (found) = TREE_TYPE (found);
7042           DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
7043           DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
7044           error_with_decl (found, "type of parameter `%s' is not declared");
7045           pushdecl (found);
7046         }
7047
7048       TREE_PURPOSE (parm) = found;
7049
7050       /* Mark this decl as "already found" -- see test, above.
7051          It is safe to use DECL_RESULT for this
7052          since it is not used in PARM_DECLs or CONST_DECLs.  */
7053       DECL_RESULT (found) = error_mark_node;
7054     }
7055
7056   /* Complain about any actual PARM_DECLs not matched with any names.  */
7057
7058   for (parm = parmdecls; parm; )
7059     {
7060       tree next = TREE_CHAIN (parm);
7061       TREE_CHAIN (parm) = 0;
7062
7063       /* Complain about args with incomplete types.  */
7064       if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
7065         {
7066           error_with_decl (parm, "parameter `%s' has incomplete type");
7067           TREE_TYPE (parm) = error_mark_node;
7068         }
7069
7070       if (DECL_RESULT (parm) == 0)
7071         {
7072           error_with_decl (parm,
7073                            "declaration for parameter `%s' but no such parameter");
7074           /* Pretend the parameter was not missing.
7075              This gets us to a standard state and minimizes
7076              further error messages.  */
7077           specparms
7078             = chainon (specparms,
7079                        tree_cons (parm, NULL_TREE, NULL_TREE));
7080         }
7081
7082       parm = next;
7083     }
7084
7085   /* Chain the declarations together in the order of the list of names.
7086      At the same time, build up a list of their types, in reverse order.  */
7087
7088   parm = specparms;
7089   parmdecls = 0;
7090   {
7091     register tree last;
7092     for (last = 0; parm; parm = TREE_CHAIN (parm))
7093       if (TREE_PURPOSE (parm))
7094         {
7095           if (last == 0)
7096             parmdecls = TREE_PURPOSE (parm);
7097           else
7098             TREE_CHAIN (last) = TREE_PURPOSE (parm);
7099           last = TREE_PURPOSE (parm);
7100           TREE_CHAIN (last) = 0;
7101
7102           types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
7103         }
7104   }
7105
7106   if (void_at_end)
7107     return saveable_tree_cons (parmdecls, nonparms,
7108                                nreverse (saveable_tree_cons (NULL_TREE,
7109                                                              void_type_node,
7110                                                              types)));
7111
7112   return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
7113 }
7114 \f
7115 /* Finish up a function declaration and compile that function
7116    all the way to assembler language output.  The free the storage
7117    for the function definition.
7118
7119    This is called after parsing the body of the function definition.
7120
7121    NESTED is nonzero if the function being finished is nested in another.  */
7122
7123 void
7124 finish_function (nested)
7125      int nested;
7126 {
7127   register tree fndecl = current_function_decl;
7128
7129 /*  TREE_READONLY (fndecl) = 1;
7130     This caused &foo to be of type ptr-to-const-function
7131     which then got a warning when stored in a ptr-to-function variable.  */
7132
7133   poplevel (1, 0, 1);
7134   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7135
7136   /* Must mark the RESULT_DECL as being in this function.  */
7137
7138   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
7139
7140   /* Obey `register' declarations if `setjmp' is called in this fn.  */
7141   if (flag_traditional && current_function_calls_setjmp)
7142     {
7143       setjmp_protect (DECL_INITIAL (fndecl));
7144       setjmp_protect_args ();
7145     }
7146
7147   if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
7148     {
7149       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
7150           != integer_type_node)
7151         {
7152           /* You would expect the sense of this test to be the other way
7153              around, but if warn_main is set, we will already have warned,
7154              so this would be a duplicate.  This is the warning you get
7155              in some environments even if you *don't* ask for it, because
7156              these are environments where it may be more of a problem than
7157              usual.  */
7158           if (! warn_main)
7159             pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
7160         }
7161       else
7162         {
7163 #ifdef DEFAULT_MAIN_RETURN
7164           /* Make it so that `main' always returns success by default.  */
7165           DEFAULT_MAIN_RETURN;
7166 #endif
7167         }
7168     }
7169
7170   /* Generate rtl for function exit.  */
7171   expand_function_end (input_filename, lineno, 0);
7172
7173   /* So we can tell if jump_optimize sets it to 1.  */
7174   can_reach_end = 0;
7175
7176   /* Run the optimizers and output the assembler code for this function.  */
7177   rest_of_compilation (fndecl);
7178
7179   current_function_returns_null |= can_reach_end;
7180
7181   if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
7182     warning ("`noreturn' function does return");
7183   else if (warn_return_type && can_reach_end
7184            && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
7185     /* If this function returns non-void and control can drop through,
7186        complain.  */
7187     warning ("control reaches end of non-void function");
7188   /* With just -W, complain only if function returns both with
7189      and without a value.  */
7190   else if (extra_warnings
7191            && current_function_returns_value && current_function_returns_null)
7192     warning ("this function may return with or without a value");
7193
7194   /* If requested, warn about function definitions where the function will
7195      return a value (usually of some struct or union type) which itself will
7196      take up a lot of stack space.  */
7197
7198   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
7199     {
7200       register tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
7201
7202       if (ret_type)
7203         {
7204           register tree ret_type_size = TYPE_SIZE (ret_type);
7205
7206           if (TREE_CODE (ret_type_size) == INTEGER_CST)
7207             {
7208               unsigned units
7209                 = TREE_INT_CST_LOW (ret_type_size) / BITS_PER_UNIT;
7210
7211               if (units > larger_than_size)
7212                 warning_with_decl (fndecl,
7213                                    "size of return value of `%s' is %u bytes",
7214                                    units);
7215             }
7216         }
7217     }
7218
7219   /* Free all the tree nodes making up this function.  */
7220   /* Switch back to allocating nodes permanently
7221      until we start another function.  */
7222   if (! nested)
7223     permanent_allocation (1);
7224
7225   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
7226     {
7227       /* Stop pointing to the local nodes about to be freed.  */
7228       /* But DECL_INITIAL must remain nonzero so we know this
7229          was an actual function definition.  */
7230       /* For a nested function, this is done in pop_c_function_context.  */
7231       /* If rest_of_compilation set this to 0, leave it 0.  */
7232       if (DECL_INITIAL (fndecl) != 0)
7233         DECL_INITIAL (fndecl) = error_mark_node;
7234       DECL_ARGUMENTS (fndecl) = 0;
7235     }
7236
7237   if (DECL_STATIC_CONSTRUCTOR (fndecl))
7238     {
7239 #ifndef ASM_OUTPUT_CONSTRUCTOR
7240       if (! flag_gnu_linker)
7241         static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
7242       else
7243 #endif
7244       assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7245     }
7246   if (DECL_STATIC_DESTRUCTOR (fndecl))
7247     {
7248 #ifndef ASM_OUTPUT_DESTRUCTOR
7249       if (! flag_gnu_linker)
7250         static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
7251       else
7252 #endif
7253       assemble_destructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7254     }
7255
7256   if (! nested)
7257     {
7258       /* Let the error reporting routines know that we're outside a
7259          function.  For a nested function, this value is used in
7260          pop_c_function_context and then reset via pop_function_context.  */
7261       current_function_decl = NULL;
7262     }
7263 }
7264 \f
7265 /* Save and restore the variables in this file and elsewhere
7266    that keep track of the progress of compilation of the current function.
7267    Used for nested functions.  */
7268
7269 struct c_function
7270 {
7271   struct c_function *next;
7272   tree named_labels;
7273   tree shadowed_labels;
7274   int returns_value;
7275   int returns_null;
7276   int warn_about_return_type;
7277   int extern_inline;
7278   struct binding_level *binding_level;
7279 };
7280
7281 struct c_function *c_function_chain;
7282
7283 /* Save and reinitialize the variables
7284    used during compilation of a C function.  */
7285
7286 void
7287 push_c_function_context ()
7288 {
7289   struct c_function *p
7290     = (struct c_function *) xmalloc (sizeof (struct c_function));
7291
7292   if (pedantic)
7293     pedwarn ("ANSI C forbids nested functions");
7294
7295   push_function_context ();
7296
7297   p->next = c_function_chain;
7298   c_function_chain = p;
7299
7300   p->named_labels = named_labels;
7301   p->shadowed_labels = shadowed_labels;
7302   p->returns_value = current_function_returns_value;
7303   p->returns_null = current_function_returns_null;
7304   p->warn_about_return_type = warn_about_return_type;
7305   p->extern_inline = current_extern_inline;
7306   p->binding_level = current_binding_level;
7307 }
7308
7309 /* Restore the variables used during compilation of a C function.  */
7310
7311 void
7312 pop_c_function_context ()
7313 {
7314   struct c_function *p = c_function_chain;
7315   tree link;
7316
7317   /* Bring back all the labels that were shadowed.  */
7318   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
7319     if (DECL_NAME (TREE_VALUE (link)) != 0)
7320       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
7321         = TREE_VALUE (link);
7322
7323   if (DECL_SAVED_INSNS (current_function_decl) == 0)
7324     {
7325       /* Stop pointing to the local nodes about to be freed.  */
7326       /* But DECL_INITIAL must remain nonzero so we know this
7327          was an actual function definition.  */
7328       DECL_INITIAL (current_function_decl) = error_mark_node;
7329       DECL_ARGUMENTS (current_function_decl) = 0;
7330     }
7331
7332   pop_function_context ();
7333
7334   c_function_chain = p->next;
7335
7336   named_labels = p->named_labels;
7337   shadowed_labels = p->shadowed_labels;
7338   current_function_returns_value = p->returns_value;
7339   current_function_returns_null = p->returns_null;
7340   warn_about_return_type = p->warn_about_return_type;
7341   current_extern_inline = p->extern_inline;
7342   current_binding_level = p->binding_level;
7343
7344   free (p);
7345 }
7346
7347 /* integrate_decl_tree calls this function, but since we don't use the
7348    DECL_LANG_SPECIFIC field, this is a no-op.  */
7349
7350 void
7351 copy_lang_decl (node)
7352      tree node ATTRIBUTE_UNUSED;
7353 {
7354 }