gcc/c-decl.c

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