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