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