gcc/c-decl.c

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