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