gcc/c-decl.c

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