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