gcc/c-decl.c

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