gcc/c-decl.c

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