gcc/c-decl.c

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