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 (pedantic
5035             && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl))) == void_type_node
5036             && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (decl)))
5037                 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (decl))))
5038             && ! DECL_IN_SYSTEM_HEADER (decl))
5039           pedwarn ("ANSI C forbids const or volatile void function return type");
5040
5041         if (volatilep
5042             && TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
5043           warning ("`noreturn' function returns non-void value");
5044
5045         if (extern_ref)
5046           DECL_EXTERNAL (decl) = 1;
5047         /* Record absence of global scope for `static' or `auto'.  */
5048         TREE_PUBLIC (decl)
5049           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
5050
5051         /* Record presence of `inline', if it is reasonable.  */
5052         if (inlinep)
5053           {
5054             tree last = tree_last (TYPE_ARG_TYPES (type));
5055
5056             if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
5057               warning ("cannot inline function `main'");
5058             else if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last))
5059                               != void_type_node))
5060               warning ("inline declaration ignored for function with `...'");
5061             else
5062               /* Assume that otherwise the function can be inlined.  */
5063               DECL_INLINE (decl) = 1;
5064
5065             if (specbits & (1 << (int) RID_EXTERN))
5066               current_extern_inline = 1;
5067           }
5068       }
5069     else
5070       {
5071         /* It's a variable.  */
5072         /* An uninitialized decl with `extern' is a reference.  */
5073         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
5074
5075         /* Move type qualifiers down to element of an array.  */
5076         if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
5077           {
5078             type = build_array_type (c_build_type_variant (TREE_TYPE (type),
5079                                                            constp, volatilep),
5080                                      TYPE_DOMAIN (type));
5081 #if 0 /* Leave the variable const or volatile as well.  */
5082             constp = volatilep = 0;
5083 #endif
5084           }
5085
5086         /* If this is a block level extern, it must live past the end
5087            of the function so that we can check it against other
5088            extern declarations (IDENTIFIER_LIMBO_VALUE).  */
5089         if (extern_ref && allocation_temporary_p ())
5090           end_temporary_allocation ();
5091
5092         decl = build_decl (VAR_DECL, declarator, type);
5093         if (size_varies)
5094           C_DECL_VARIABLE_SIZE (decl) = 1;
5095
5096         if (inlinep)
5097           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
5098
5099         DECL_EXTERNAL (decl) = extern_ref;
5100         /* At top level, the presence of a `static' or `register' storage
5101            class specifier, or the absence of all storage class specifiers
5102            makes this declaration a definition (perhaps tentative).  Also,
5103            the absence of both `static' and `register' makes it public.  */
5104         if (current_binding_level == global_binding_level)
5105           {
5106             TREE_PUBLIC (decl)
5107               = !(specbits
5108                   & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
5109             TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5110           }
5111         /* Not at top level, only `static' makes a static definition.  */
5112         else
5113           {
5114             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
5115             TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5116           }
5117
5118         if (specbits & 1 << (int) RID_ITERATOR)
5119           ITERATOR_P (decl) = 1;
5120       }
5121
5122     /* Record `register' declaration for warnings on &
5123        and in case doing stupid register allocation.  */
5124
5125     if (specbits & (1 << (int) RID_REGISTER))
5126       DECL_REGISTER (decl) = 1;
5127
5128     /* Record constancy and volatility.  */
5129
5130     if (constp)
5131       TREE_READONLY (decl) = 1;
5132     if (volatilep)
5133       {
5134         TREE_SIDE_EFFECTS (decl) = 1;
5135         TREE_THIS_VOLATILE (decl) = 1;
5136       }
5137     /* If a type has volatile components, it should be stored in memory.
5138        Otherwise, the fact that those components are volatile
5139        will be ignored, and would even crash the compiler.  */
5140     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
5141       mark_addressable (decl);
5142
5143     pop_obstacks ();
5144
5145     return decl;
5146   }
5147 }
5148 \f
5149 /* Decode the parameter-list info for a function type or function definition.
5150    The argument is the value returned by `get_parm_info' (or made in parse.y
5151    if there is an identifier list instead of a parameter decl list).
5152    These two functions are separate because when a function returns
5153    or receives functions then each is called multiple times but the order
5154    of calls is different.  The last call to `grokparms' is always the one
5155    that contains the formal parameter names of a function definition.
5156
5157    Store in `last_function_parms' a chain of the decls of parms.
5158    Also store in `last_function_parm_tags' a chain of the struct, union,
5159    and enum tags declared among the parms.
5160
5161    Return a list of arg types to use in the FUNCTION_TYPE for this function.
5162
5163    FUNCDEF_FLAG is nonzero for a function definition, 0 for
5164    a mere declaration.  A nonempty identifier-list gets an error message
5165    when FUNCDEF_FLAG is zero.  */
5166
5167 static tree
5168 grokparms (parms_info, funcdef_flag)
5169      tree parms_info;
5170      int funcdef_flag;
5171 {
5172   tree first_parm = TREE_CHAIN (parms_info);
5173
5174   last_function_parms = TREE_PURPOSE (parms_info);
5175   last_function_parm_tags = TREE_VALUE (parms_info);
5176
5177   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
5178       && !in_system_header)
5179     warning ("function declaration isn't a prototype");
5180
5181   if (first_parm != 0
5182       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
5183     {
5184       if (! funcdef_flag)
5185         pedwarn ("parameter names (without types) in function declaration");
5186
5187       last_function_parms = first_parm;
5188       return 0;
5189     }
5190   else
5191     {
5192       tree parm;
5193       tree typelt;
5194       /* We no longer test FUNCDEF_FLAG.
5195          If the arg types are incomplete in a declaration,
5196          they must include undefined tags.
5197          These tags can never be defined in the scope of the declaration,
5198          so the types can never be completed,
5199          and no call can be compiled successfully.  */
5200 #if 0
5201       /* In a fcn definition, arg types must be complete.  */
5202       if (funcdef_flag)
5203 #endif
5204         for (parm = last_function_parms, typelt = first_parm;
5205              parm;
5206              parm = TREE_CHAIN (parm))
5207           /* Skip over any enumeration constants declared here.  */
5208           if (TREE_CODE (parm) == PARM_DECL)
5209             {
5210               /* Barf if the parameter itself has an incomplete type.  */
5211               tree type = TREE_VALUE (typelt);
5212               if (TYPE_SIZE (type) == 0)
5213                 {
5214                   if (funcdef_flag && DECL_NAME (parm) != 0)
5215                     error ("parameter `%s' has incomplete type",
5216                            IDENTIFIER_POINTER (DECL_NAME (parm)));
5217                   else
5218                     warning ("parameter has incomplete type");
5219                   if (funcdef_flag)
5220                     {
5221                       TREE_VALUE (typelt) = error_mark_node;
5222                       TREE_TYPE (parm) = error_mark_node;
5223                     }
5224                 }
5225 #if 0  /* This has been replaced by parm_tags_warning
5226           which uses a more accurate criterion for what to warn about.  */
5227               else
5228                 {
5229                   /* Now warn if is a pointer to an incomplete type.  */
5230                   while (TREE_CODE (type) == POINTER_TYPE
5231                          || TREE_CODE (type) == REFERENCE_TYPE)
5232                     type = TREE_TYPE (type);
5233                   type = TYPE_MAIN_VARIANT (type);
5234                   if (TYPE_SIZE (type) == 0)
5235                     {
5236                       if (DECL_NAME (parm) != 0)
5237                         warning ("parameter `%s' points to incomplete type",
5238                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
5239                       else
5240                         warning ("parameter points to incomplete type");
5241                     }
5242                 }
5243 #endif
5244               typelt = TREE_CHAIN (typelt);
5245             }
5246
5247       /* Allocate the list of types the way we allocate a type.  */
5248       if (first_parm && ! TREE_PERMANENT (first_parm))
5249         {
5250           /* Construct a copy of the list of types
5251              on the saveable obstack.  */
5252           tree result = NULL;
5253           for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt))
5254             result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt),
5255                                          result);
5256           return nreverse (result);
5257         }
5258       else
5259         /* The list we have is permanent already.  */
5260         return first_parm;
5261     }
5262 }
5263
5264
5265 /* Return a tree_list node with info on a parameter list just parsed.
5266    The TREE_PURPOSE is a chain of decls of those parms.
5267    The TREE_VALUE is a list of structure, union and enum tags defined.
5268    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5269    This tree_list node is later fed to `grokparms'.
5270
5271    VOID_AT_END nonzero means append `void' to the end of the type-list.
5272    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
5273
5274 tree
5275 get_parm_info (void_at_end)
5276      int void_at_end;
5277 {
5278   register tree decl, t;
5279   register tree types = 0;
5280   int erred = 0;
5281   tree tags = gettags ();
5282   tree parms = getdecls ();
5283   tree new_parms = 0;
5284   tree order = current_binding_level->parm_order;
5285
5286   /* Just `void' (and no ellipsis) is special.  There are really no parms.  */
5287   if (void_at_end && parms != 0
5288       && TREE_CHAIN (parms) == 0
5289       && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
5290       && DECL_NAME (parms) == 0)
5291     {
5292       parms = NULL_TREE;
5293       storedecls (NULL_TREE);
5294       return saveable_tree_cons (NULL_TREE, NULL_TREE,
5295                                  saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5296     }
5297
5298   /* Extract enumerator values and other non-parms declared with the parms.
5299      Likewise any forward parm decls that didn't have real parm decls.  */
5300   for (decl = parms; decl; )
5301     {
5302       tree next = TREE_CHAIN (decl);
5303
5304       if (TREE_CODE (decl) != PARM_DECL)
5305         {
5306           TREE_CHAIN (decl) = new_parms;
5307           new_parms = decl;
5308         }
5309       else if (TREE_ASM_WRITTEN (decl))
5310         {
5311           error_with_decl (decl, "parameter `%s' has just a forward declaration");
5312           TREE_CHAIN (decl) = new_parms;
5313           new_parms = decl;
5314         }
5315       decl = next;
5316     }
5317
5318   /* Put the parm decls back in the order they were in in the parm list.  */
5319   for (t = order; t; t = TREE_CHAIN (t))
5320     {
5321       if (TREE_CHAIN (t))
5322         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5323       else
5324         TREE_CHAIN (TREE_VALUE (t)) = 0;
5325     }
5326
5327   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5328                        new_parms);
5329
5330   /* Store the parmlist in the binding level since the old one
5331      is no longer a valid list.  (We have changed the chain pointers.)  */
5332   storedecls (new_parms);
5333
5334   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5335     /* There may also be declarations for enumerators if an enumeration
5336        type is declared among the parms.  Ignore them here.  */
5337     if (TREE_CODE (decl) == PARM_DECL)
5338       {
5339         /* Since there is a prototype,
5340            args are passed in their declared types.  */
5341         tree type = TREE_TYPE (decl);
5342         DECL_ARG_TYPE (decl) = type;
5343 #ifdef PROMOTE_PROTOTYPES
5344         if ((TREE_CODE (type) == INTEGER_TYPE
5345              || TREE_CODE (type) == ENUMERAL_TYPE)
5346             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5347           DECL_ARG_TYPE (decl) = integer_type_node;
5348 #endif
5349
5350         types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5351         if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
5352             && DECL_NAME (decl) == 0)
5353           {
5354             error ("`void' in parameter list must be the entire list");
5355             erred = 1;
5356           }
5357       }
5358
5359   if (void_at_end)
5360     return saveable_tree_cons (new_parms, tags,
5361                                nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
5362
5363   return saveable_tree_cons (new_parms, tags, nreverse (types));
5364 }
5365
5366 /* At end of parameter list, warn about any struct, union or enum tags
5367    defined within.  Do so because these types cannot ever become complete.  */
5368
5369 void
5370 parmlist_tags_warning ()
5371 {
5372   tree elt;
5373   static int already;
5374
5375   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5376     {
5377       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5378       /* An anonymous union parm type is meaningful as a GNU extension.
5379          So don't warn for that.  */
5380       if (code == UNION_TYPE && !pedantic)
5381         continue;
5382       if (TREE_PURPOSE (elt) != 0)
5383         warning ("`%s %s' declared inside parameter list",
5384                  (code == RECORD_TYPE ? "struct"
5385                   : code == UNION_TYPE ? "union"
5386                   : "enum"),
5387                  IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5388       else
5389         warning ("anonymous %s declared inside parameter list",
5390                  (code == RECORD_TYPE ? "struct"
5391                   : code == UNION_TYPE ? "union"
5392                   : "enum"));
5393
5394       if (! already)
5395         {
5396           warning ("its scope is only this definition or declaration,");
5397           warning ("which is probably not what you want.");
5398           already = 1;
5399         }
5400     }
5401 }
5402 \f
5403 /* Get the struct, enum or union (CODE says which) with tag NAME.
5404    Define the tag as a forward-reference if it is not defined.  */
5405
5406 tree
5407 xref_tag (code, name)
5408      enum tree_code code;
5409      tree name;
5410 {
5411   int temporary = allocation_temporary_p ();
5412
5413   /* If a cross reference is requested, look up the type
5414      already defined for this tag and return it.  */
5415
5416   register tree ref = lookup_tag (code, name, current_binding_level, 0);
5417   /* Even if this is the wrong type of tag, return what we found.
5418      There will be an error message anyway, from pending_xref_error.
5419      If we create an empty xref just for an invalid use of the type,
5420      the main result is to create lots of superfluous error messages.  */
5421   if (ref)
5422     return ref;
5423
5424   push_obstacks_nochange ();
5425
5426   if (current_binding_level == global_binding_level && temporary)
5427     end_temporary_allocation ();
5428
5429   /* If no such tag is yet defined, create a forward-reference node
5430      and record it as the "definition".
5431      When a real declaration of this type is found,
5432      the forward-reference will be altered into a real type.  */
5433
5434   ref = make_node (code);
5435   if (code == ENUMERAL_TYPE)
5436     {
5437       /* (In ANSI, Enums can be referred to only if already defined.)  */
5438       if (pedantic)
5439         pedwarn ("ANSI C forbids forward references to `enum' types");
5440       /* Give the type a default layout like unsigned int
5441          to avoid crashing if it does not get defined.  */
5442       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5443       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5444       TREE_UNSIGNED (ref) = 1;
5445       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5446       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5447       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5448     }
5449
5450   pushtag (name, ref);
5451
5452   pop_obstacks ();
5453
5454   return ref;
5455 }
5456 \f
5457 /* Make sure that the tag NAME is defined *in the current binding level*
5458    at least as a forward reference.
5459    CODE says which kind of tag NAME ought to be.
5460
5461    We also do a push_obstacks_nochange
5462    whose matching pop is in finish_struct.  */
5463
5464 tree
5465 start_struct (code, name)
5466      enum tree_code code;
5467      tree name;
5468 {
5469   /* If there is already a tag defined at this binding level
5470      (as a forward reference), just return it.  */
5471
5472   register tree ref = 0;
5473
5474   push_obstacks_nochange ();
5475   if (current_binding_level == global_binding_level)
5476     end_temporary_allocation ();
5477
5478   if (name != 0)
5479     ref = lookup_tag (code, name, current_binding_level, 1);
5480   if (ref && TREE_CODE (ref) == code)
5481     {
5482       C_TYPE_BEING_DEFINED (ref) = 1;
5483       if (TYPE_FIELDS (ref))
5484         error ((code == UNION_TYPE ? "redefinition of `union %s'"
5485                 : "redefinition of `struct %s'"),
5486                IDENTIFIER_POINTER (name));
5487
5488       return ref;
5489     }
5490
5491   /* Otherwise create a forward-reference just so the tag is in scope.  */
5492
5493   ref = make_node (code);
5494   pushtag (name, ref);
5495   C_TYPE_BEING_DEFINED (ref) = 1;
5496   TYPE_PACKED (ref) = flag_pack_struct;
5497   return ref;
5498 }
5499
5500 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5501    of a structure component, returning a FIELD_DECL node.
5502    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5503
5504    This is done during the parsing of the struct declaration.
5505    The FIELD_DECL nodes are chained together and the lot of them
5506    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5507
5508 tree
5509 grokfield (filename, line, declarator, declspecs, width)
5510      char *filename;
5511      int line;
5512      tree declarator, declspecs, width;
5513 {
5514   tree value;
5515
5516   /* The corresponding pop_obstacks is in finish_decl.  */
5517   push_obstacks_nochange ();
5518
5519   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5520
5521   finish_decl (value, NULL_TREE, NULL_TREE);
5522   DECL_INITIAL (value) = width;
5523
5524   maybe_objc_check_decl (value);
5525   return value;
5526 }
5527 \f
5528 /* Function to help qsort sort FIELD_DECLs by name order.  */
5529
5530 static int
5531 field_decl_cmp (xp, yp)
5532      const GENERIC_PTR xp;
5533      const GENERIC_PTR yp;
5534 {
5535   tree *x = (tree *)xp, *y = (tree *)yp;
5536
5537   if (DECL_NAME (*x) == DECL_NAME (*y))
5538     return 0;
5539   if (DECL_NAME (*x) == NULL)
5540     return -1;
5541   if (DECL_NAME (*y) == NULL)
5542     return 1;
5543   if (DECL_NAME (*x) < DECL_NAME (*y))
5544     return -1;
5545   return 1;
5546 }
5547
5548 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5549    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5550    ATTRIBUTES are attributes to be applied to the structure.
5551
5552    We also do a pop_obstacks to match the push in start_struct.  */
5553
5554 tree
5555 finish_struct (t, fieldlist, attributes)
5556      tree t;
5557      tree fieldlist;
5558      tree attributes;
5559 {
5560   register tree x;
5561   int old_momentary;
5562   int toplevel = global_binding_level == current_binding_level;
5563
5564   /* If this type was previously laid out as a forward reference,
5565      make sure we lay it out again.  */
5566
5567   TYPE_SIZE (t) = 0;
5568
5569   decl_attributes (t, attributes, NULL_TREE);
5570
5571   /* Nameless union parm types are useful as GCC extension.  */
5572   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5573     /* Otherwise, warn about any struct or union def. in parmlist.  */
5574     if (in_parm_level_p ())
5575       {
5576         if (pedantic)
5577           pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5578                     : "structure defined inside parms"));
5579         else if (! flag_traditional)
5580           warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5581                     : "structure defined inside parms"));
5582       }
5583
5584   old_momentary = suspend_momentary ();
5585
5586   if (pedantic)
5587     {
5588       for (x = fieldlist; x; x = TREE_CHAIN (x))
5589         if (DECL_NAME (x) != 0)
5590           break;
5591
5592       if (x == 0)
5593         pedwarn ("%s has no %smembers",
5594                  (TREE_CODE (t) == UNION_TYPE ? "union" : "structure"),
5595                  (fieldlist ? "named " : ""));
5596     }
5597
5598   /* Install struct as DECL_CONTEXT of each field decl.
5599      Also process specified field sizes.
5600      Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
5601      The specified size is found in the DECL_INITIAL.
5602      Store 0 there, except for ": 0" fields (so we can find them
5603      and delete them, below).  */
5604
5605   for (x = fieldlist; x; x = TREE_CHAIN (x))
5606     {
5607       DECL_CONTEXT (x) = t;
5608       DECL_PACKED (x) |= TYPE_PACKED (t);
5609       DECL_FIELD_SIZE (x) = 0;
5610
5611       /* If any field is const, the structure type is pseudo-const.  */
5612       if (TREE_READONLY (x))
5613         C_TYPE_FIELDS_READONLY (t) = 1;
5614       else
5615         {
5616           /* A field that is pseudo-const makes the structure likewise.  */
5617           tree t1 = TREE_TYPE (x);
5618           while (TREE_CODE (t1) == ARRAY_TYPE)
5619             t1 = TREE_TYPE (t1);
5620           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5621               && C_TYPE_FIELDS_READONLY (t1))
5622             C_TYPE_FIELDS_READONLY (t) = 1;
5623         }
5624
5625       /* Any field that is volatile means variables of this type must be
5626          treated in some ways as volatile.  */
5627       if (TREE_THIS_VOLATILE (x))
5628         C_TYPE_FIELDS_VOLATILE (t) = 1;
5629
5630       /* Any field of nominal variable size implies structure is too.  */
5631       if (C_DECL_VARIABLE_SIZE (x))
5632         C_TYPE_VARIABLE_SIZE (t) = 1;
5633
5634       /* Detect invalid nested redefinition.  */
5635       if (TREE_TYPE (x) == t)
5636         error ("nested redefinition of `%s'",
5637                IDENTIFIER_POINTER (TYPE_NAME (t)));
5638
5639       /* Detect invalid bit-field size.  */
5640       if (DECL_INITIAL (x))
5641         STRIP_NOPS (DECL_INITIAL (x));
5642       if (DECL_INITIAL (x))
5643         {
5644           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5645             constant_expression_warning (DECL_INITIAL (x));
5646           else
5647             {
5648               error_with_decl (x, "bit-field `%s' width not an integer constant");
5649               DECL_INITIAL (x) = NULL;
5650             }
5651         }
5652
5653       /* Detect invalid bit-field type.  */
5654       if (DECL_INITIAL (x)
5655           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5656           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5657         {
5658           error_with_decl (x, "bit-field `%s' has invalid type");
5659           DECL_INITIAL (x) = NULL;
5660         }
5661       if (DECL_INITIAL (x) && pedantic
5662           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5663           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5664           /* Accept an enum that's equivalent to int or unsigned int.  */
5665           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5666                && (TYPE_PRECISION (TREE_TYPE (x))
5667                    == TYPE_PRECISION (integer_type_node))))
5668         pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
5669
5670       /* Detect and ignore out of range field width.  */
5671       if (DECL_INITIAL (x))
5672         {
5673           unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5674
5675           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5676             {
5677               DECL_INITIAL (x) = NULL;
5678               error_with_decl (x, "negative width in bit-field `%s'");
5679             }
5680           else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
5681                    || width > TYPE_PRECISION (TREE_TYPE (x)))
5682             {
5683               DECL_INITIAL (x) = NULL;
5684               pedwarn_with_decl (x, "width of `%s' exceeds its type");
5685             }
5686           else if (width == 0 && DECL_NAME (x) != 0)
5687             {
5688               error_with_decl (x, "zero width for bit-field `%s'");
5689               DECL_INITIAL (x) = NULL;
5690             }
5691         }
5692
5693       /* Process valid field width.  */
5694       if (DECL_INITIAL (x))
5695         {
5696           register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5697
5698           if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5699               && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5700                                          TREE_UNSIGNED (TREE_TYPE (x)))
5701                   || width < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5702                                             TREE_UNSIGNED (TREE_TYPE (x)))))
5703             warning_with_decl (x, "`%s' is narrower than values of its type");
5704
5705           DECL_FIELD_SIZE (x) = width;
5706           DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
5707           DECL_INITIAL (x) = NULL;
5708
5709           if (width == 0)
5710             {
5711               /* field size 0 => force desired amount of alignment.  */
5712 #ifdef EMPTY_FIELD_BOUNDARY
5713               DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5714 #endif
5715 #ifdef PCC_BITFIELD_TYPE_MATTERS
5716               if (PCC_BITFIELD_TYPE_MATTERS)
5717                 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5718                                       TYPE_ALIGN (TREE_TYPE (x)));
5719 #endif
5720             }
5721         }
5722       else if (TREE_TYPE (x) != error_mark_node)
5723         {
5724           int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5725                            : TYPE_ALIGN (TREE_TYPE (x)));
5726           /* Non-bit-fields are aligned for their type, except packed
5727              fields which require only BITS_PER_UNIT alignment.  */
5728           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5729         }
5730     }
5731
5732   /* Now DECL_INITIAL is null on all members.  */
5733
5734   /* Delete all duplicate fields from the fieldlist */
5735   for (x = fieldlist; x && TREE_CHAIN (x);)
5736     /* Anonymous fields aren't duplicates.  */
5737     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5738       x = TREE_CHAIN (x);
5739     else
5740       {
5741         register tree y = fieldlist;
5742
5743         while (1)
5744           {
5745             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5746               break;
5747             if (y == x)
5748               break;
5749             y = TREE_CHAIN (y);
5750           }
5751         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5752           {
5753             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5754             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5755           }
5756         else x = TREE_CHAIN (x);
5757       }
5758
5759   /* Now we have the nearly final fieldlist.  Record it,
5760      then lay out the structure or union (including the fields).  */
5761
5762   TYPE_FIELDS (t) = fieldlist;
5763
5764   layout_type (t);
5765
5766   /* Delete all zero-width bit-fields from the front of the fieldlist */
5767   while (fieldlist
5768          && DECL_INITIAL (fieldlist))
5769     fieldlist = TREE_CHAIN (fieldlist);
5770   /* Delete all such members from the rest of the fieldlist */
5771   for (x = fieldlist; x;)
5772     {
5773       if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
5774         TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5775       else x = TREE_CHAIN (x);
5776     }
5777
5778   /*  Now we have the truly final field list.
5779       Store it in this type and in the variants.  */
5780
5781   TYPE_FIELDS (t) = fieldlist;
5782
5783   /* If there are lots of fields, sort so we can look through them fast.
5784      We arbitrarily consider 16 or more elts to be "a lot".  */
5785   {
5786     int len = 0;
5787
5788     for (x = fieldlist; x; x = TREE_CHAIN (x))
5789       {
5790         if (len > 15)
5791           break;
5792         len += 1;
5793       }
5794     if (len > 15)
5795       {
5796         tree *field_array;
5797         char *space;
5798
5799         len += list_length (x);
5800         /* Use the same allocation policy here that make_node uses, to
5801            ensure that this lives as long as the rest of the struct decl.
5802            All decls in an inline function need to be saved.  */
5803         if (allocation_temporary_p ())
5804           space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
5805         else
5806           space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
5807
5808         TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
5809         TYPE_LANG_SPECIFIC (t)->len = len;
5810
5811         field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
5812         len = 0;
5813         for (x = fieldlist; x; x = TREE_CHAIN (x))
5814           field_array[len++] = x;
5815
5816         qsort (field_array, len, sizeof (tree), field_decl_cmp);
5817       }
5818   }
5819
5820   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5821     {
5822       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5823       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5824       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5825     }
5826
5827   /* If this was supposed to be a transparent union, but we can't
5828      make it one, warn and turn off the flag.  */
5829   if (TREE_CODE (t) == UNION_TYPE
5830       && TYPE_TRANSPARENT_UNION (t)
5831       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5832     {
5833       TYPE_TRANSPARENT_UNION (t) = 0;
5834       warning ("union cannot be made transparent");
5835     }
5836
5837   /* If this structure or union completes the type of any previous
5838      variable declaration, lay it out and output its rtl.  */
5839
5840   if (current_binding_level->n_incomplete != 0)
5841     {
5842       tree decl;
5843       for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5844         {
5845           if (TREE_TYPE (decl) == t
5846               && TREE_CODE (decl) != TYPE_DECL)
5847             {
5848               layout_decl (decl, 0);
5849               /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
5850               maybe_objc_check_decl (decl);
5851               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
5852               if (! toplevel)
5853                 expand_decl (decl);
5854               --current_binding_level->n_incomplete;
5855             }
5856           else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
5857                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5858             {
5859               tree element = TREE_TYPE (decl);
5860               while (TREE_CODE (element) == ARRAY_TYPE)
5861                 element = TREE_TYPE (element);
5862               if (element == t)
5863                 layout_array_type (TREE_TYPE (decl));
5864             }
5865         }
5866     }
5867
5868   resume_momentary (old_momentary);
5869
5870   /* Finish debugging output for this type.  */
5871   rest_of_type_compilation (t, toplevel);
5872
5873   /* The matching push is in start_struct.  */
5874   pop_obstacks ();
5875
5876   return t;
5877 }
5878
5879 /* Lay out the type T, and its element type, and so on.  */
5880
5881 static void
5882 layout_array_type (t)
5883      tree t;
5884 {
5885   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5886     layout_array_type (TREE_TYPE (t));
5887   layout_type (t);
5888 }
5889 \f
5890 /* Begin compiling the definition of an enumeration type.
5891    NAME is its name (or null if anonymous).
5892    Returns the type object, as yet incomplete.
5893    Also records info about it so that build_enumerator
5894    may be used to declare the individual values as they are read.  */
5895
5896 tree
5897 start_enum (name)
5898      tree name;
5899 {
5900   register tree enumtype = 0;
5901
5902   /* If this is the real definition for a previous forward reference,
5903      fill in the contents in the same object that used to be the
5904      forward reference.  */
5905
5906   if (name != 0)
5907     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5908
5909   /* The corresponding pop_obstacks is in finish_enum.  */
5910   push_obstacks_nochange ();
5911   /* If these symbols and types are global, make them permanent.  */
5912   if (current_binding_level == global_binding_level)
5913     end_temporary_allocation ();
5914
5915   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5916     {
5917       enumtype = make_node (ENUMERAL_TYPE);
5918       pushtag (name, enumtype);
5919     }
5920
5921   C_TYPE_BEING_DEFINED (enumtype) = 1;
5922
5923   if (TYPE_VALUES (enumtype) != 0)
5924     {
5925       /* This enum is a named one that has been declared already.  */
5926       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5927
5928       /* Completely replace its old definition.
5929          The old enumerators remain defined, however.  */
5930       TYPE_VALUES (enumtype) = 0;
5931     }
5932
5933   enum_next_value = integer_zero_node;
5934   enum_overflow = 0;
5935
5936   if (flag_short_enums)
5937     TYPE_PACKED (enumtype) = 1;
5938
5939   return enumtype;
5940 }
5941
5942 /* After processing and defining all the values of an enumeration type,
5943    install their decls in the enumeration type and finish it off.
5944    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5945    and ATTRIBUTES are the specified attributes.
5946    Returns ENUMTYPE.  */
5947
5948 tree
5949 finish_enum (enumtype, values, attributes)
5950      tree enumtype;
5951      tree values;
5952      tree attributes;
5953 {
5954   register tree pair, tem;
5955   tree minnode = 0, maxnode = 0;
5956   int lowprec, highprec, precision;
5957   int toplevel = global_binding_level == current_binding_level;
5958
5959   if (in_parm_level_p ())
5960     warning ("enum defined inside parms");
5961
5962   decl_attributes (enumtype, attributes, NULL_TREE);
5963
5964   /* Calculate the maximum value of any enumerator in this type.  */
5965
5966   if (values == error_mark_node)
5967     minnode = maxnode = integer_zero_node;
5968   else
5969     for (pair = values; pair; pair = TREE_CHAIN (pair))
5970       {
5971         tree value = TREE_VALUE (pair);
5972         if (pair == values)
5973           minnode = maxnode = TREE_VALUE (pair);
5974         else
5975           {
5976             if (tree_int_cst_lt (maxnode, value))
5977               maxnode = value;
5978             if (tree_int_cst_lt (value, minnode))
5979               minnode = value;
5980           }
5981       }
5982
5983   TYPE_MIN_VALUE (enumtype) = minnode;
5984   TYPE_MAX_VALUE (enumtype) = maxnode;
5985
5986   /* An enum can have some negative values; then it is signed.  */
5987   TREE_UNSIGNED (enumtype) = tree_int_cst_sgn (minnode) >= 0;
5988
5989   /* Determine the precision this type needs.  */
5990
5991   lowprec = min_precision (minnode, TREE_UNSIGNED (enumtype));
5992   highprec = min_precision (maxnode, TREE_UNSIGNED (enumtype));
5993   precision = MAX (lowprec, highprec);
5994
5995   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5996     {
5997       tree narrowest = type_for_size (precision, 1);
5998       if (narrowest == 0)
5999         {
6000           warning ("enumeration values exceed range of largest integer");
6001           narrowest = long_long_integer_type_node;
6002         }
6003
6004       TYPE_PRECISION (enumtype) = TYPE_PRECISION (narrowest);
6005     }
6006   else
6007     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
6008
6009   TYPE_SIZE (enumtype) = 0;
6010   layout_type (enumtype);
6011
6012   if (values != error_mark_node)
6013     {
6014       /* Change the type of the enumerators to be the enum type.
6015          Formerly this was done only for enums that fit in an int,
6016          but the comment said it was done only for enums wider than int.
6017          It seems necessary to do this for wide enums,
6018          and best not to change what's done for ordinary narrower ones.  */
6019       for (pair = values; pair; pair = TREE_CHAIN (pair))
6020         {
6021           TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
6022           DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
6023           if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL)
6024             DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
6025         }
6026
6027       /* Replace the decl nodes in VALUES with their names.  */
6028       for (pair = values; pair; pair = TREE_CHAIN (pair))
6029         TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
6030
6031       TYPE_VALUES (enumtype) = values;
6032     }
6033
6034   /* Fix up all variant types of this enum type.  */
6035   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
6036     {
6037       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
6038       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
6039       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
6040       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
6041       TYPE_MODE (tem) = TYPE_MODE (enumtype);
6042       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
6043       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
6044       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
6045     }
6046
6047   /* Finish debugging output for this type.  */
6048   rest_of_type_compilation (enumtype, toplevel);
6049
6050   /* This matches a push in start_enum.  */
6051   pop_obstacks ();
6052
6053   return enumtype;
6054 }
6055
6056 /* Build and install a CONST_DECL for one value of the
6057    current enumeration type (one that was begun with start_enum).
6058    Return a tree-list containing the CONST_DECL and its value.
6059    Assignment of sequential values by default is handled here.  */
6060
6061 tree
6062 build_enumerator (name, value)
6063      tree name, value;
6064 {
6065   register tree decl, type;
6066
6067   /* Validate and default VALUE.  */
6068
6069   /* Remove no-op casts from the value.  */
6070   if (value)
6071     STRIP_TYPE_NOPS (value);
6072
6073   if (value != 0)
6074     {
6075       if (TREE_CODE (value) == INTEGER_CST)
6076         {
6077           value = default_conversion (value);
6078           constant_expression_warning (value);
6079         }
6080       else
6081         {
6082           error ("enumerator value for `%s' not integer constant",
6083                  IDENTIFIER_POINTER (name));
6084           value = 0;
6085         }
6086     }
6087
6088   /* Default based on previous value.  */
6089   /* It should no longer be possible to have NON_LVALUE_EXPR
6090      in the default.  */
6091   if (value == 0)
6092     {
6093       value = enum_next_value;
6094       if (enum_overflow)
6095         error ("overflow in enumeration values");
6096     }
6097
6098   if (pedantic && ! int_fits_type_p (value, integer_type_node))
6099     {
6100       pedwarn ("ANSI C restricts enumerator values to range of `int'");
6101       value = integer_zero_node;
6102     }
6103
6104   /* Set basis for default for next value.  */
6105   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
6106   enum_overflow = tree_int_cst_lt (enum_next_value, value);
6107
6108   /* Now create a declaration for the enum value name.  */
6109
6110   type = TREE_TYPE (value);
6111   type = type_for_size (MAX (TYPE_PRECISION (type),
6112                              TYPE_PRECISION (integer_type_node)),
6113                         ((flag_traditional
6114                           || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
6115                          && TREE_UNSIGNED (type)));
6116
6117   decl = build_decl (CONST_DECL, name, type);
6118   DECL_INITIAL (decl) = value;
6119   TREE_TYPE (value) = type;
6120   pushdecl (decl);
6121
6122   return saveable_tree_cons (decl, value, NULL_TREE);
6123 }
6124 \f
6125 /* Create the FUNCTION_DECL for a function definition.
6126    DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of
6127    the declaration; they describe the function's name and the type it returns,
6128    but twisted together in a fashion that parallels the syntax of C.
6129
6130    This function creates a binding context for the function body
6131    as well as setting up the FUNCTION_DECL in current_function_decl.
6132
6133    Returns 1 on success.  If the DECLARATOR is not suitable for a function
6134    (it defines a datum instead), we return 0, which tells
6135    yyparse to report a parse error.
6136
6137    NESTED is nonzero for a function nested within another function.  */
6138
6139 int
6140 start_function (declspecs, declarator, prefix_attributes, attributes, nested)
6141      tree declarator, declspecs, prefix_attributes, attributes;
6142      int nested;
6143 {
6144   tree decl1, old_decl;
6145   tree restype;
6146   int old_immediate_size_expand = immediate_size_expand;
6147
6148   current_function_returns_value = 0;  /* Assume, until we see it does.  */
6149   current_function_returns_null = 0;
6150   warn_about_return_type = 0;
6151   current_extern_inline = 0;
6152   c_function_varargs = 0;
6153   named_labels = 0;
6154   shadowed_labels = 0;
6155
6156   /* Don't expand any sizes in the return type of the function.  */
6157   immediate_size_expand = 0;
6158
6159   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
6160
6161   /* If the declarator is not suitable for a function definition,
6162      cause a syntax error.  */
6163   if (decl1 == 0)
6164     return 0;
6165
6166   decl_attributes (decl1, prefix_attributes, attributes);
6167
6168   announce_function (decl1);
6169
6170   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
6171     {
6172       error ("return-type is an incomplete type");
6173       /* Make it return void instead.  */
6174       TREE_TYPE (decl1)
6175         = build_function_type (void_type_node,
6176                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6177     }
6178
6179   if (warn_about_return_type)
6180     warning ("return-type defaults to `int'");
6181
6182   /* Save the parm names or decls from this function's declarator
6183      where store_parm_decls will find them.  */
6184   current_function_parms = last_function_parms;
6185   current_function_parm_tags = last_function_parm_tags;
6186
6187   /* Make the init_value nonzero so pushdecl knows this is not tentative.
6188      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
6189   DECL_INITIAL (decl1) = error_mark_node;
6190
6191   /* If this definition isn't a prototype and we had a prototype declaration
6192      before, copy the arg type info from that prototype.
6193      But not if what we had before was a builtin function.  */
6194   old_decl = lookup_name_current_level (DECL_NAME (decl1));
6195   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6196       && !DECL_BUILT_IN (old_decl)
6197       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6198           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
6199       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6200     {
6201       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
6202       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
6203       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
6204     }
6205
6206   /* If there is no explicit declaration, look for any out-of-scope implicit
6207      declarations.  */
6208   if (old_decl == 0)
6209     old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
6210
6211   /* Optionally warn of old-fashioned def with no previous prototype.  */
6212   if (warn_strict_prototypes
6213       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6214       && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
6215     warning ("function declaration isn't a prototype");
6216   /* Optionally warn of any global def with no previous prototype.  */
6217   else if (warn_missing_prototypes
6218            && TREE_PUBLIC (decl1)
6219            && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
6220            && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6221     warning_with_decl (decl1, "no previous prototype for `%s'");
6222   /* Optionally warn of any def with no previous prototype
6223      if the function has already been used.  */
6224   else if (warn_missing_prototypes
6225            && old_decl != 0 && TREE_USED (old_decl)
6226            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6227     warning_with_decl (decl1,
6228                       "`%s' was used with no prototype before its definition");
6229   /* Optionally warn of any global def with no previous declaration.  */
6230   else if (warn_missing_declarations
6231            && TREE_PUBLIC (decl1)
6232            && old_decl == 0
6233            && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6234     warning_with_decl (decl1, "no previous declaration for `%s'");
6235   /* Optionally warn of any def with no previous declaration
6236      if the function has already been used.  */
6237   else if (warn_missing_declarations
6238            && old_decl != 0 && TREE_USED (old_decl)
6239            && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
6240     warning_with_decl (decl1,
6241                     "`%s' was used with no declaration before its definition");
6242
6243   /* This is a definition, not a reference.
6244      So normally clear DECL_EXTERNAL.
6245      However, `extern inline' acts like a declaration
6246      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
6247   DECL_EXTERNAL (decl1) = current_extern_inline;
6248
6249   /* This function exists in static storage.
6250      (This does not mean `static' in the C sense!)  */
6251   TREE_STATIC (decl1) = 1;
6252
6253   /* A nested function is not global.  */
6254   if (current_function_decl != 0)
6255     TREE_PUBLIC (decl1) = 0;
6256
6257   /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6258   if (warn_main
6259       && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))) == 0)
6260     {
6261       tree args;
6262       int argct = 0;
6263
6264       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6265            != integer_type_node)
6266         pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
6267
6268       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6269            args = TREE_CHAIN (args))
6270         {
6271           tree type = args ? TREE_VALUE (args) : 0;
6272
6273           if (type == void_type_node)
6274             break;
6275
6276           ++argct;
6277           switch (argct)
6278             {
6279             case 1:
6280               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6281                 pedwarn_with_decl (decl1,
6282                                    "first argument of `%s' should be `int'");
6283               break;
6284
6285             case 2:
6286               if (TREE_CODE (type) != POINTER_TYPE
6287                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6288                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6289                       != char_type_node))
6290                 pedwarn_with_decl (decl1,
6291                                "second argument of `%s' should be `char **'");
6292               break;
6293
6294             case 3:
6295               if (TREE_CODE (type) != POINTER_TYPE
6296                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6297                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6298                       != char_type_node))
6299                 pedwarn_with_decl (decl1,
6300                    "third argument of `%s' should probably be `char **'");
6301               break;
6302             }
6303         }
6304
6305       /* It is intentional that this message does not mention the third
6306          argument, which is warned for only pedantically, because it's
6307          blessed by mention in an appendix of the standard. */
6308       if (argct > 0 && (argct < 2 || argct > 3))
6309         pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6310
6311       if (argct == 3 && pedantic)
6312         pedwarn_with_decl (decl1, "third argument of `%s' is deprecated");
6313
6314       if (! TREE_PUBLIC (decl1))
6315         pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6316     }
6317
6318   /* Record the decl so that the function name is defined.
6319      If we already have a decl for this name, and it is a FUNCTION_DECL,
6320      use the old decl.  */
6321
6322   current_function_decl = pushdecl (decl1);
6323
6324   pushlevel (0);
6325   declare_parm_level (1);
6326   current_binding_level->subblocks_tag_transparent = 1;
6327
6328   make_function_rtl (current_function_decl);
6329
6330   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6331   /* Promote the value to int before returning it.  */
6332   if (C_PROMOTING_INTEGER_TYPE_P (restype))
6333     {
6334       /* It retains unsignedness if traditional
6335          or if not really getting wider.  */
6336       if (TREE_UNSIGNED (restype)
6337           && (flag_traditional
6338               || (TYPE_PRECISION (restype)
6339                   == TYPE_PRECISION (integer_type_node))))
6340         restype = unsigned_type_node;
6341       else
6342         restype = integer_type_node;
6343     }
6344   DECL_RESULT (current_function_decl)
6345     = build_decl (RESULT_DECL, NULL_TREE, restype);
6346
6347   if (!nested)
6348     /* Allocate further tree nodes temporarily during compilation
6349        of this function only.  */
6350     temporary_allocation ();
6351
6352   /* If this fcn was already referenced via a block-scope `extern' decl
6353      (or an implicit decl), propagate certain information about the usage.  */
6354   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6355     TREE_ADDRESSABLE (current_function_decl) = 1;
6356
6357   immediate_size_expand = old_immediate_size_expand;
6358
6359   return 1;
6360 }
6361
6362 /* Record that this function is going to be a varargs function.
6363    This is called before store_parm_decls, which is too early
6364    to call mark_varargs directly.  */
6365
6366 void
6367 c_mark_varargs ()
6368 {
6369   c_function_varargs = 1;
6370 }
6371 \f
6372 /* Store the parameter declarations into the current function declaration.
6373    This is called after parsing the parameter declarations, before
6374    digesting the body of the function.
6375
6376    For an old-style definition, modify the function's type
6377    to specify at least the number of arguments.  */
6378
6379 void
6380 store_parm_decls ()
6381 {
6382   register tree fndecl = current_function_decl;
6383   register tree parm;
6384
6385   /* This is either a chain of PARM_DECLs (if a prototype was used)
6386      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
6387   tree specparms = current_function_parms;
6388
6389   /* This is a list of types declared among parms in a prototype.  */
6390   tree parmtags = current_function_parm_tags;
6391
6392   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
6393   register tree parmdecls = getdecls ();
6394
6395   /* This is a chain of any other decls that came in among the parm
6396      declarations.  If a parm is declared with  enum {foo, bar} x;
6397      then CONST_DECLs for foo and bar are put here.  */
6398   tree nonparms = 0;
6399
6400   /* Nonzero if this definition is written with a prototype.  */
6401   int prototype = 0;
6402
6403   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6404     {
6405       /* This case is when the function was defined with an ANSI prototype.
6406          The parms already have decls, so we need not do anything here
6407          except record them as in effect
6408          and complain if any redundant old-style parm decls were written.  */
6409
6410       register tree next;
6411       tree others = 0;
6412
6413       prototype = 1;
6414
6415       if (parmdecls != 0)
6416         {
6417           tree decl, link;
6418
6419           error_with_decl (fndecl,
6420                            "parm types given both in parmlist and separately");
6421           /* Get rid of the erroneous decls; don't keep them on
6422              the list of parms, since they might not be PARM_DECLs.  */
6423           for (decl = current_binding_level->names;
6424                decl; decl = TREE_CHAIN (decl))
6425             if (DECL_NAME (decl))
6426               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6427           for (link = current_binding_level->shadowed;
6428                link; link = TREE_CHAIN (link))
6429             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6430           current_binding_level->names = 0;
6431           current_binding_level->shadowed = 0;
6432         }
6433
6434       specparms = nreverse (specparms);
6435       for (parm = specparms; parm; parm = next)
6436         {
6437           next = TREE_CHAIN (parm);
6438           if (TREE_CODE (parm) == PARM_DECL)
6439             {
6440               if (DECL_NAME (parm) == 0)
6441                 error_with_decl (parm, "parameter name omitted");
6442               else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6443                 {
6444                   error_with_decl (parm, "parameter `%s' declared void");
6445                   /* Change the type to error_mark_node so this parameter
6446                      will be ignored by assign_parms.  */
6447                   TREE_TYPE (parm) = error_mark_node;
6448                 }
6449               pushdecl (parm);
6450             }
6451           else
6452             {
6453               /* If we find an enum constant or a type tag,
6454                  put it aside for the moment.  */
6455               TREE_CHAIN (parm) = 0;
6456               others = chainon (others, parm);
6457             }
6458         }
6459
6460       /* Get the decls in their original chain order
6461          and record in the function.  */
6462       DECL_ARGUMENTS (fndecl) = getdecls ();
6463
6464 #if 0
6465       /* If this function takes a variable number of arguments,
6466          add a phony parameter to the end of the parm list,
6467          to represent the position of the first unnamed argument.  */
6468       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6469           != void_type_node)
6470         {
6471           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6472           /* Let's hope the address of the unnamed parm
6473              won't depend on its type.  */
6474           TREE_TYPE (dummy) = integer_type_node;
6475           DECL_ARG_TYPE (dummy) = integer_type_node;
6476           DECL_ARGUMENTS (fndecl)
6477             = chainon (DECL_ARGUMENTS (fndecl), dummy);
6478         }
6479 #endif
6480
6481       /* Now pushdecl the enum constants.  */
6482       for (parm = others; parm; parm = next)
6483         {
6484           next = TREE_CHAIN (parm);
6485           if (DECL_NAME (parm) == 0)
6486             ;
6487           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6488             ;
6489           else if (TREE_CODE (parm) != PARM_DECL)
6490             pushdecl (parm);
6491         }
6492
6493       storetags (chainon (parmtags, gettags ()));
6494     }
6495   else
6496     {
6497       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6498          each with a parm name as the TREE_VALUE.
6499
6500          PARMDECLS is a chain of declarations for parameters.
6501          Warning! It can also contain CONST_DECLs which are not parameters
6502          but are names of enumerators of any enum types
6503          declared among the parameters.
6504
6505          First match each formal parameter name with its declaration.
6506          Associate decls with the names and store the decls
6507          into the TREE_PURPOSE slots.  */
6508
6509       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6510         DECL_RESULT (parm) = 0;
6511
6512       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6513         {
6514           register tree tail, found = NULL;
6515
6516           if (TREE_VALUE (parm) == 0)
6517             {
6518               error_with_decl (fndecl, "parameter name missing from parameter list");
6519               TREE_PURPOSE (parm) = 0;
6520               continue;
6521             }
6522
6523           /* See if any of the parmdecls specifies this parm by name.
6524              Ignore any enumerator decls.  */
6525           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6526             if (DECL_NAME (tail) == TREE_VALUE (parm)
6527                 && TREE_CODE (tail) == PARM_DECL)
6528               {
6529                 found = tail;
6530                 break;
6531               }
6532
6533           /* If declaration already marked, we have a duplicate name.
6534              Complain, and don't use this decl twice.   */
6535           if (found && DECL_RESULT (found) != 0)
6536             {
6537               error_with_decl (found, "multiple parameters named `%s'");
6538               found = 0;
6539             }
6540
6541           /* If the declaration says "void", complain and ignore it.  */
6542           if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6543             {
6544               error_with_decl (found, "parameter `%s' declared void");
6545               TREE_TYPE (found) = integer_type_node;
6546               DECL_ARG_TYPE (found) = integer_type_node;
6547               layout_decl (found, 0);
6548             }
6549
6550           /* Traditionally, a parm declared float is actually a double.  */
6551           if (found && flag_traditional
6552               && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6553             {
6554               TREE_TYPE (found) = double_type_node;
6555               DECL_ARG_TYPE (found) = double_type_node;
6556               layout_decl (found, 0);
6557             }
6558
6559           /* If no declaration found, default to int.  */
6560           if (!found)
6561             {
6562               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6563                                   integer_type_node);
6564               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6565               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6566               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6567               if (extra_warnings)
6568                 warning_with_decl (found, "type of `%s' defaults to `int'");
6569               pushdecl (found);
6570             }
6571
6572           TREE_PURPOSE (parm) = found;
6573
6574           /* Mark this decl as "already found" -- see test, above.
6575              It is safe to use DECL_RESULT for this
6576              since it is not used in PARM_DECLs or CONST_DECLs.  */
6577           DECL_RESULT (found) = error_mark_node;
6578         }
6579
6580       /* Put anything which is on the parmdecls chain and which is
6581          not a PARM_DECL onto the list NONPARMS.  (The types of
6582          non-parm things which might appear on the list include
6583          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6584          any actual PARM_DECLs not matched with any names.  */
6585
6586       nonparms = 0;
6587       for (parm = parmdecls; parm; )
6588         {
6589           tree next = TREE_CHAIN (parm);
6590           TREE_CHAIN (parm) = 0;
6591
6592           if (TREE_CODE (parm) != PARM_DECL)
6593             nonparms = chainon (nonparms, parm);
6594           else
6595             {
6596               /* Complain about args with incomplete types.  */
6597               if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6598                 {
6599                   error_with_decl (parm, "parameter `%s' has incomplete type");
6600                   TREE_TYPE (parm) = error_mark_node;
6601                 }
6602
6603               if (DECL_RESULT (parm) == 0)
6604                 {
6605                   error_with_decl (parm,
6606                                    "declaration for parameter `%s' but no such parameter");
6607                   /* Pretend the parameter was not missing.
6608                      This gets us to a standard state and minimizes
6609                      further error messages.  */
6610                   specparms
6611                     = chainon (specparms,
6612                                tree_cons (parm, NULL_TREE, NULL_TREE));
6613                 }
6614             }
6615
6616           parm = next;
6617         }
6618
6619       /* Chain the declarations together in the order of the list of names.  */
6620       /* Store that chain in the function decl, replacing the list of names.  */
6621       parm = specparms;
6622       DECL_ARGUMENTS (fndecl) = 0;
6623       {
6624         register tree last;
6625         for (last = 0; parm; parm = TREE_CHAIN (parm))
6626           if (TREE_PURPOSE (parm))
6627             {
6628               if (last == 0)
6629                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6630               else
6631                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6632               last = TREE_PURPOSE (parm);
6633               TREE_CHAIN (last) = 0;
6634             }
6635       }
6636
6637       /* If there was a previous prototype,
6638          set the DECL_ARG_TYPE of each argument according to
6639          the type previously specified, and report any mismatches.  */
6640
6641       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6642         {
6643           register tree type;
6644           for (parm = DECL_ARGUMENTS (fndecl),
6645                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6646                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6647                                  != void_type_node));
6648                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6649             {
6650               if (parm == 0 || type == 0
6651                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6652                 {
6653                   error ("number of arguments doesn't match prototype");
6654                   error_with_file_and_line (current_function_prototype_file,
6655                                             current_function_prototype_line,
6656                                             "prototype declaration");
6657                   break;
6658                 }
6659               /* Type for passing arg must be consistent
6660                  with that declared for the arg.  */
6661               if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6662                 {
6663                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6664                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6665                     {
6666                       /* Adjust argument to match prototype.  E.g. a previous
6667                          `int foo(float);' prototype causes
6668                          `int foo(x) float x; {...}' to be treated like
6669                          `int foo(float x) {...}'.  This is particularly
6670                          useful for argument types like uid_t.  */
6671                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6672 #ifdef PROMOTE_PROTOTYPES
6673                       if ((TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6674                            || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6675                           && TYPE_PRECISION (TREE_TYPE (parm))
6676                           < TYPE_PRECISION (integer_type_node))
6677                         DECL_ARG_TYPE (parm) = integer_type_node;
6678 #endif
6679                       if (pedantic)
6680                         {
6681                           pedwarn ("promoted argument `%s' doesn't match prototype",
6682                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6683                           warning_with_file_and_line
6684                             (current_function_prototype_file,
6685                              current_function_prototype_line,
6686                              "prototype declaration");
6687                         }
6688                     }
6689                   /* If -traditional, allow `int' argument to match
6690                      `unsigned' prototype.  */
6691                   else if (! (flag_traditional
6692                               && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6693                               && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6694                     {
6695                       error ("argument `%s' doesn't match prototype",
6696                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6697                       error_with_file_and_line (current_function_prototype_file,
6698                                                 current_function_prototype_line,
6699                                                 "prototype declaration");
6700                     }
6701                 }
6702             }
6703           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6704         }
6705
6706       /* Otherwise, create a prototype that would match.  */
6707
6708       else
6709         {
6710           tree actual = 0, last = 0, type;
6711
6712           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6713             {
6714               type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm),
6715                                      NULL_TREE);
6716               if (last)
6717                 TREE_CHAIN (last) = type;
6718               else
6719                 actual = type;
6720               last = type;
6721             }
6722           type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6723           if (last)
6724             TREE_CHAIN (last) = type;
6725           else
6726             actual = type;
6727
6728           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6729              of the type of this function, but we need to avoid having this
6730              affect the types of other similarly-typed functions, so we must
6731              first force the generation of an identical (but separate) type
6732              node for the relevant function type.  The new node we create
6733              will be a variant of the main variant of the original function
6734              type.  */
6735
6736           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6737
6738           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6739         }
6740
6741       /* Now store the final chain of decls for the arguments
6742          as the decl-chain of the current lexical scope.
6743          Put the enumerators in as well, at the front so that
6744          DECL_ARGUMENTS is not modified.  */
6745
6746       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6747     }
6748
6749   /* Make sure the binding level for the top of the function body
6750      gets a BLOCK if there are any in the function.
6751      Otherwise, the dbx output is wrong.  */
6752
6753   keep_next_if_subblocks = 1;
6754
6755   /* ??? This might be an improvement,
6756      but needs to be thought about some more.  */
6757 #if 0
6758   keep_next_level_flag = 1;
6759 #endif
6760
6761   /* Write a record describing this function definition to the prototypes
6762      file (if requested).  */
6763
6764   gen_aux_info_record (fndecl, 1, 0, prototype);
6765
6766   /* Initialize the RTL code for the function.  */
6767
6768   init_function_start (fndecl, input_filename, lineno);
6769
6770   /* If this is a varargs function, inform function.c.  */
6771
6772   if (c_function_varargs)
6773     mark_varargs ();
6774
6775   /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
6776
6777   declare_function_name ();
6778
6779   /* Set up parameters and prepare for return, for the function.  */
6780
6781   expand_function_start (fndecl, 0);
6782
6783   /* If this function is `main', emit a call to `__main'
6784      to run global initializers, etc.  */
6785   if (DECL_NAME (fndecl)
6786       && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
6787       && DECL_CONTEXT (fndecl) == NULL_TREE)
6788     expand_main_function ();
6789 }
6790 \f
6791 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6792    each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
6793    stands for an ellipsis in the identifier list.
6794
6795    PARMLIST is the data returned by get_parm_info for the
6796    parmlist that follows the semicolon.
6797
6798    We return a value of the same sort that get_parm_info returns,
6799    except that it describes the combination of identifiers and parmlist.  */
6800
6801 tree
6802 combine_parm_decls (specparms, parmlist, void_at_end)
6803      tree specparms, parmlist;
6804      int void_at_end;
6805 {
6806   register tree fndecl = current_function_decl;
6807   register tree parm;
6808
6809   tree parmdecls = TREE_PURPOSE (parmlist);
6810
6811   /* This is a chain of any other decls that came in among the parm
6812      declarations.  They were separated already by get_parm_info,
6813      so we just need to keep them separate.  */
6814   tree nonparms = TREE_VALUE (parmlist);
6815
6816   tree types = 0;
6817
6818   for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6819     DECL_RESULT (parm) = 0;
6820
6821   for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6822     {
6823       register tree tail, found = NULL;
6824
6825       /* See if any of the parmdecls specifies this parm by name.  */
6826       for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6827         if (DECL_NAME (tail) == TREE_VALUE (parm))
6828           {
6829             found = tail;
6830             break;
6831           }
6832
6833       /* If declaration already marked, we have a duplicate name.
6834          Complain, and don't use this decl twice.   */
6835       if (found && DECL_RESULT (found) != 0)
6836         {
6837           error_with_decl (found, "multiple parameters named `%s'");
6838           found = 0;
6839         }
6840
6841       /* If the declaration says "void", complain and ignore it.  */
6842       if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6843         {
6844           error_with_decl (found, "parameter `%s' declared void");
6845           TREE_TYPE (found) = integer_type_node;
6846           DECL_ARG_TYPE (found) = integer_type_node;
6847           layout_decl (found, 0);
6848         }
6849
6850       /* Traditionally, a parm declared float is actually a double.  */
6851       if (found && flag_traditional
6852           && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6853         {
6854           TREE_TYPE (found) = double_type_node;
6855           DECL_ARG_TYPE (found) = double_type_node;
6856           layout_decl (found, 0);
6857         }
6858
6859       /* If no declaration found, default to int.  */
6860       if (!found)
6861         {
6862           found = build_decl (PARM_DECL, TREE_VALUE (parm),
6863                               integer_type_node);
6864           DECL_ARG_TYPE (found) = TREE_TYPE (found);
6865           DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6866           DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6867           error_with_decl (found, "type of parameter `%s' is not declared");
6868           pushdecl (found);
6869         }
6870
6871       TREE_PURPOSE (parm) = found;
6872
6873       /* Mark this decl as "already found" -- see test, above.
6874          It is safe to use DECL_RESULT for this
6875          since it is not used in PARM_DECLs or CONST_DECLs.  */
6876       DECL_RESULT (found) = error_mark_node;
6877     }
6878
6879   /* Complain about any actual PARM_DECLs not matched with any names.  */
6880
6881   for (parm = parmdecls; parm; )
6882     {
6883       tree next = TREE_CHAIN (parm);
6884       TREE_CHAIN (parm) = 0;
6885
6886       /* Complain about args with incomplete types.  */
6887       if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6888         {
6889           error_with_decl (parm, "parameter `%s' has incomplete type");
6890           TREE_TYPE (parm) = error_mark_node;
6891         }
6892
6893       if (DECL_RESULT (parm) == 0)
6894         {
6895           error_with_decl (parm,
6896                            "declaration for parameter `%s' but no such parameter");
6897           /* Pretend the parameter was not missing.
6898              This gets us to a standard state and minimizes
6899              further error messages.  */
6900           specparms
6901             = chainon (specparms,
6902                        tree_cons (parm, NULL_TREE, NULL_TREE));
6903         }
6904
6905       parm = next;
6906     }
6907
6908   /* Chain the declarations together in the order of the list of names.
6909      At the same time, build up a list of their types, in reverse order.  */
6910
6911   parm = specparms;
6912   parmdecls = 0;
6913   {
6914     register tree last;
6915     for (last = 0; parm; parm = TREE_CHAIN (parm))
6916       if (TREE_PURPOSE (parm))
6917         {
6918           if (last == 0)
6919             parmdecls = TREE_PURPOSE (parm);
6920           else
6921             TREE_CHAIN (last) = TREE_PURPOSE (parm);
6922           last = TREE_PURPOSE (parm);
6923           TREE_CHAIN (last) = 0;
6924
6925           types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
6926         }
6927   }
6928
6929   if (void_at_end)
6930     return saveable_tree_cons (parmdecls, nonparms,
6931                                nreverse (saveable_tree_cons (NULL_TREE,
6932                                                              void_type_node,
6933                                                              types)));
6934
6935   return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
6936 }
6937 \f
6938 /* Finish up a function declaration and compile that function
6939    all the way to assembler language output.  The free the storage
6940    for the function definition.
6941
6942    This is called after parsing the body of the function definition.
6943
6944    NESTED is nonzero if the function being finished is nested in another.  */
6945
6946 void
6947 finish_function (nested)
6948      int nested;
6949 {
6950   register tree fndecl = current_function_decl;
6951
6952 /*  TREE_READONLY (fndecl) = 1;
6953     This caused &foo to be of type ptr-to-const-function
6954     which then got a warning when stored in a ptr-to-function variable.  */
6955
6956   poplevel (1, 0, 1);
6957   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6958
6959   /* Must mark the RESULT_DECL as being in this function.  */
6960
6961   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6962
6963   /* Obey `register' declarations if `setjmp' is called in this fn.  */
6964   if (flag_traditional && current_function_calls_setjmp)
6965     {
6966       setjmp_protect (DECL_INITIAL (fndecl));
6967       setjmp_protect_args ();
6968     }
6969
6970   if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
6971     {
6972       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6973           != integer_type_node)
6974         {
6975           /* You would expect the sense of this test to be the other way
6976              around, but if warn_main is set, we will already have warned,
6977              so this would be a duplicate.  This is the warning you get
6978              in some environments even if you *don't* ask for it, because
6979              these are environments where it may be more of a problem than
6980              usual.  */
6981           if (! warn_main)
6982             pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6983         }
6984       else
6985         {
6986 #ifdef DEFAULT_MAIN_RETURN
6987           /* Make it so that `main' always returns success by default.  */
6988           DEFAULT_MAIN_RETURN;
6989 #endif
6990         }
6991     }
6992
6993   /* Generate rtl for function exit.  */
6994   expand_function_end (input_filename, lineno, 0);
6995
6996   /* So we can tell if jump_optimize sets it to 1.  */
6997   can_reach_end = 0;
6998
6999   /* Run the optimizers and output the assembler code for this function.  */
7000   rest_of_compilation (fndecl);
7001
7002   current_function_returns_null |= can_reach_end;
7003
7004   if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
7005     warning ("`noreturn' function does return");
7006   else if (warn_return_type && can_reach_end
7007            && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
7008     /* If this function returns non-void and control can drop through,
7009        complain.  */
7010     warning ("control reaches end of non-void function");
7011   /* With just -W, complain only if function returns both with
7012      and without a value.  */
7013   else if (extra_warnings
7014            && current_function_returns_value && current_function_returns_null)
7015     warning ("this function may return with or without a value");
7016
7017   /* If requested, warn about function definitions where the function will
7018      return a value (usually of some struct or union type) which itself will
7019      take up a lot of stack space.  */
7020
7021   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
7022     {
7023       register tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
7024
7025       if (ret_type)
7026         {
7027           register tree ret_type_size = TYPE_SIZE (ret_type);
7028
7029           if (TREE_CODE (ret_type_size) == INTEGER_CST)
7030             {
7031               unsigned units
7032                 = TREE_INT_CST_LOW (ret_type_size) / BITS_PER_UNIT;
7033
7034               if (units > larger_than_size)
7035                 warning_with_decl (fndecl,
7036                                    "size of return value of `%s' is %u bytes",
7037                                    units);
7038             }
7039         }
7040     }
7041
7042   /* Free all the tree nodes making up this function.  */
7043   /* Switch back to allocating nodes permanently
7044      until we start another function.  */
7045   if (! nested)
7046     permanent_allocation (1);
7047
7048   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
7049     {
7050       /* Stop pointing to the local nodes about to be freed.  */
7051       /* But DECL_INITIAL must remain nonzero so we know this
7052          was an actual function definition.  */
7053       /* For a nested function, this is done in pop_c_function_context.  */
7054       /* If rest_of_compilation set this to 0, leave it 0.  */
7055       if (DECL_INITIAL (fndecl) != 0)
7056         DECL_INITIAL (fndecl) = error_mark_node;
7057       DECL_ARGUMENTS (fndecl) = 0;
7058     }
7059
7060   if (DECL_STATIC_CONSTRUCTOR (fndecl))
7061     {
7062 #ifndef ASM_OUTPUT_CONSTRUCTOR
7063       if (! flag_gnu_linker)
7064         static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
7065       else
7066 #endif
7067       assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7068     }
7069   if (DECL_STATIC_DESTRUCTOR (fndecl))
7070     {
7071 #ifndef ASM_OUTPUT_DESTRUCTOR
7072       if (! flag_gnu_linker)
7073         static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
7074       else
7075 #endif
7076       assemble_destructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7077     }
7078
7079   if (! nested)
7080     {
7081       /* Let the error reporting routines know that we're outside a
7082          function.  For a nested function, this value is used in
7083          pop_c_function_context and then reset via pop_function_context.  */
7084       current_function_decl = NULL;
7085     }
7086 }
7087 \f
7088 /* Save and restore the variables in this file and elsewhere
7089    that keep track of the progress of compilation of the current function.
7090    Used for nested functions.  */
7091
7092 struct c_function
7093 {
7094   struct c_function *next;
7095   tree named_labels;
7096   tree shadowed_labels;
7097   int returns_value;
7098   int returns_null;
7099   int warn_about_return_type;
7100   int extern_inline;
7101   struct binding_level *binding_level;
7102 };
7103
7104 struct c_function *c_function_chain;
7105
7106 /* Save and reinitialize the variables
7107    used during compilation of a C function.  */
7108
7109 void
7110 push_c_function_context ()
7111 {
7112   struct c_function *p
7113     = (struct c_function *) xmalloc (sizeof (struct c_function));
7114
7115   if (pedantic)
7116     pedwarn ("ANSI C forbids nested functions");
7117
7118   push_function_context ();
7119
7120   p->next = c_function_chain;
7121   c_function_chain = p;
7122
7123   p->named_labels = named_labels;
7124   p->shadowed_labels = shadowed_labels;
7125   p->returns_value = current_function_returns_value;
7126   p->returns_null = current_function_returns_null;
7127   p->warn_about_return_type = warn_about_return_type;
7128   p->extern_inline = current_extern_inline;
7129   p->binding_level = current_binding_level;
7130 }
7131
7132 /* Restore the variables used during compilation of a C function.  */
7133
7134 void
7135 pop_c_function_context ()
7136 {
7137   struct c_function *p = c_function_chain;
7138   tree link;
7139
7140   /* Bring back all the labels that were shadowed.  */
7141   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
7142     if (DECL_NAME (TREE_VALUE (link)) != 0)
7143       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
7144         = TREE_VALUE (link);
7145
7146   if (DECL_SAVED_INSNS (current_function_decl) == 0)
7147     {
7148       /* Stop pointing to the local nodes about to be freed.  */
7149       /* But DECL_INITIAL must remain nonzero so we know this
7150          was an actual function definition.  */
7151       DECL_INITIAL (current_function_decl) = error_mark_node;
7152       DECL_ARGUMENTS (current_function_decl) = 0;
7153     }
7154
7155   pop_function_context ();
7156
7157   c_function_chain = p->next;
7158
7159   named_labels = p->named_labels;
7160   shadowed_labels = p->shadowed_labels;
7161   current_function_returns_value = p->returns_value;
7162   current_function_returns_null = p->returns_null;
7163   warn_about_return_type = p->warn_about_return_type;
7164   current_extern_inline = p->extern_inline;
7165   current_binding_level = p->binding_level;
7166
7167   free (p);
7168 }
7169
7170 /* integrate_decl_tree calls this function, but since we don't use the
7171    DECL_LANG_SPECIFIC field, this is a no-op.  */
7172
7173 void
7174 copy_lang_decl (node)
7175      tree node;
7176 {
7177 }