gcc/c-decl.c

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