contrib/gcc/c-decl.c

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