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