gcc/c-decl.c

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