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