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