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