gcc/c-decl.c

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