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