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, ptr_type_node,
3088                                      tree_cons (NULL_TREE,
3089                                                 type_for_mode (ptr_mode, 0),
3090                                                 tree_cons (NULL_TREE,
3091                                                            ptr_type_node,
3092                                                            endlink)))),
3093      BUILT_IN_EH_RETURN, BUILT_IN_NORMAL, NULL_PTR);
3094
3095   pedantic_lvalues = pedantic;
3096
3097   /* Create the global bindings for __FUNCTION__, __PRETTY_FUNCTION__,
3098      and __func__.  */
3099   function_id_node = get_identifier ("__FUNCTION__");
3100   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
3101   func_id_node = get_identifier ("__func__");
3102   make_fname_decl = c_make_fname_decl;
3103   declare_function_name ();
3104
3105   start_identifier_warnings ();
3106
3107   /* Prepare to check format strings against argument lists.  */
3108   init_function_format_info ();
3109
3110   incomplete_decl_finalize_hook = finish_incomplete_decl;
3111
3112   /* Record our roots.  */
3113
3114   ggc_add_tree_root (c_global_trees, CTI_MAX);
3115   ggc_add_root (&c_stmt_tree, 1, sizeof c_stmt_tree, mark_stmt_tree);
3116   ggc_add_tree_root (&c_scope_stmt_stack, 1);
3117   ggc_add_tree_root (&named_labels, 1);
3118   ggc_add_tree_root (&shadowed_labels, 1);
3119   ggc_add_root (&current_binding_level, 1, sizeof current_binding_level,
3120                 mark_binding_level);
3121   ggc_add_root (&label_level_chain, 1, sizeof label_level_chain,
3122                 mark_binding_level);
3123   ggc_add_tree_root (&static_ctors, 1);
3124   ggc_add_tree_root (&static_dtors, 1);
3125 }
3126
3127 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3128    decl, NAME is the initialization string and TYPE_DEP indicates whether
3129    NAME depended on the type of the function.  As we don't yet implement
3130    delayed emission of static data, we mark the decl as emitted
3131    so it is not placed in the output.  Anything using it must therefore pull
3132    out the STRING_CST initializer directly.  This does mean that these names
3133    are string merging candidates, which is wrong for C99's __func__.  FIXME.  */
3134
3135 static tree
3136 c_make_fname_decl (id, name, type_dep)
3137      tree id;
3138      const char *name;
3139      int type_dep ATTRIBUTE_UNUSED;
3140 {
3141   tree decl, type, init;
3142   size_t length = strlen (name);
3143
3144   type =  build_array_type
3145           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
3146            build_index_type (build_int_2 (length, 0)));
3147
3148   decl = build_decl (VAR_DECL, id, type);
3149   TREE_STATIC (decl) = 1;
3150   TREE_READONLY (decl) = 1;
3151   TREE_ASM_WRITTEN (decl) = 1;
3152   DECL_SOURCE_LINE (decl) = 0;
3153   DECL_ARTIFICIAL (decl) = 1;
3154   DECL_IN_SYSTEM_HEADER (decl) = 1;
3155   DECL_IGNORED_P (decl) = 1;
3156   init = build_string (length + 1, name);
3157   TREE_TYPE (init) = type;
3158   DECL_INITIAL (decl) = init;
3159   finish_decl (pushdecl (decl), init, NULL_TREE);
3160
3161   return decl;
3162 }
3163
3164 /* Return a definition for a builtin function named NAME and whose data type
3165    is TYPE.  TYPE should be a function type with argument types.
3166    FUNCTION_CODE tells later passes how to compile calls to this function.
3167    See tree.h for its possible values.
3168
3169    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3170    the name to be called if we can't opencode the function.  */
3171
3172 tree
3173 builtin_function (name, type, function_code, class, library_name)
3174      const char *name;
3175      tree type;
3176      int function_code;
3177      enum built_in_class class;
3178      const char *library_name;
3179 {
3180   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3181   DECL_EXTERNAL (decl) = 1;
3182   TREE_PUBLIC (decl) = 1;
3183   /* If -traditional, permit redefining a builtin function any way you like.
3184      (Though really, if the program redefines these functions,
3185      it probably won't work right unless compiled with -fno-builtin.)  */
3186   if (flag_traditional && name[0] != '_')
3187     DECL_BUILT_IN_NONANSI (decl) = 1;
3188   if (library_name)
3189     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
3190   make_decl_rtl (decl, NULL_PTR);
3191   pushdecl (decl);
3192   DECL_BUILT_IN_CLASS (decl) = class;
3193   DECL_FUNCTION_CODE (decl) = function_code;
3194
3195   /* Warn if a function in the namespace for users
3196      is used without an occasion to consider it declared.  */
3197   if (name[0] != '_' || name[1] != '_')
3198     C_DECL_ANTICIPATED (decl) = 1;
3199
3200   return decl;
3201 }
3202 \f
3203 /* Called when a declaration is seen that contains no names to declare.
3204    If its type is a reference to a structure, union or enum inherited
3205    from a containing scope, shadow that tag name for the current scope
3206    with a forward reference.
3207    If its type defines a new named structure or union
3208    or defines an enum, it is valid but we need not do anything here.
3209    Otherwise, it is an error.  */
3210
3211 void
3212 shadow_tag (declspecs)
3213      tree declspecs;
3214 {
3215   shadow_tag_warned (declspecs, 0);
3216 }
3217
3218 void
3219 shadow_tag_warned (declspecs, warned)
3220      tree declspecs;
3221      int warned;
3222      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
3223         no pedwarn.  */
3224 {
3225   int found_tag = 0;
3226   register tree link;
3227   tree specs, attrs;
3228
3229   pending_invalid_xref = 0;
3230
3231   /* Remove the attributes from declspecs, since they will confuse the
3232      following code.  */
3233   split_specs_attrs (declspecs, &specs, &attrs);
3234
3235   for (link = specs; link; link = TREE_CHAIN (link))
3236     {
3237       register tree value = TREE_VALUE (link);
3238       register enum tree_code code = TREE_CODE (value);
3239
3240       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3241         /* Used to test also that TYPE_SIZE (value) != 0.
3242            That caused warning for `struct foo;' at top level in the file.  */
3243         {
3244           register tree name = lookup_tag_reverse (value);
3245           register tree t;
3246
3247           found_tag++;
3248
3249           if (name == 0)
3250             {
3251               if (warned != 1 && code != ENUMERAL_TYPE)
3252                 /* Empty unnamed enum OK */
3253                 {
3254                   pedwarn ("unnamed struct/union that defines no instances");
3255                   warned = 1;
3256                 }
3257             }
3258           else
3259             {
3260               t = lookup_tag (code, name, current_binding_level, 1);
3261
3262               if (t == 0)
3263                 {
3264                   t = make_node (code);
3265                   pushtag (name, t);
3266                 }
3267             }
3268         }
3269       else
3270         {
3271           if (!warned && ! in_system_header)
3272             {
3273               warning ("useless keyword or type name in empty declaration");
3274               warned = 2;
3275             }
3276         }
3277     }
3278
3279   if (found_tag > 1)
3280     error ("two types specified in one empty declaration");
3281
3282   if (warned != 1)
3283     {
3284       if (found_tag == 0)
3285         pedwarn ("empty declaration");
3286     }
3287 }
3288 \f
3289 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3290
3291 tree
3292 groktypename (typename)
3293      tree typename;
3294 {
3295   if (TREE_CODE (typename) != TREE_LIST)
3296     return typename;
3297   return grokdeclarator (TREE_VALUE (typename),
3298                          TREE_PURPOSE (typename),
3299                          TYPENAME, 0);
3300 }
3301
3302 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
3303
3304 tree
3305 groktypename_in_parm_context (typename)
3306      tree typename;
3307 {
3308   if (TREE_CODE (typename) != TREE_LIST)
3309     return typename;
3310   return grokdeclarator (TREE_VALUE (typename),
3311                          TREE_PURPOSE (typename),
3312                          PARM, 0);
3313 }
3314
3315 /* Decode a declarator in an ordinary declaration or data definition.
3316    This is called as soon as the type information and variable name
3317    have been parsed, before parsing the initializer if any.
3318    Here we create the ..._DECL node, fill in its type,
3319    and put it on the list of decls for the current context.
3320    The ..._DECL node is returned as the value.
3321
3322    Exception: for arrays where the length is not specified,
3323    the type is left null, to be filled in by `finish_decl'.
3324
3325    Function definitions do not come here; they go to start_function
3326    instead.  However, external and forward declarations of functions
3327    do go through here.  Structure field declarations are done by
3328    grokfield and not through here.  */
3329
3330 tree
3331 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
3332      tree declarator, declspecs;
3333      int initialized;
3334      tree attributes, prefix_attributes;
3335 {
3336   register tree decl = grokdeclarator (declarator, declspecs,
3337                                        NORMAL, initialized);
3338   register tree tem;
3339
3340   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3341       && MAIN_NAME_P (DECL_NAME (decl)))
3342     warning_with_decl (decl, "`%s' is usually a function");
3343
3344   if (initialized)
3345     /* Is it valid for this decl to have an initializer at all?
3346        If not, set INITIALIZED to zero, which will indirectly
3347        tell `finish_decl' to ignore the initializer once it is parsed.  */
3348     switch (TREE_CODE (decl))
3349       {
3350       case TYPE_DECL:
3351         /* typedef foo = bar  means give foo the same type as bar.
3352            We haven't parsed bar yet, so `finish_decl' will fix that up.
3353            Any other case of an initialization in a TYPE_DECL is an error.  */
3354         if (pedantic || list_length (declspecs) > 1)
3355           {
3356             error ("typedef `%s' is initialized",
3357                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3358             initialized = 0;
3359           }
3360         break;
3361
3362       case FUNCTION_DECL:
3363         error ("function `%s' is initialized like a variable",
3364                IDENTIFIER_POINTER (DECL_NAME (decl)));
3365         initialized = 0;
3366         break;
3367
3368       case PARM_DECL:
3369         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
3370         error ("parameter `%s' is initialized",
3371                IDENTIFIER_POINTER (DECL_NAME (decl)));
3372         initialized = 0;
3373         break;
3374
3375       default:
3376         /* Don't allow initializations for incomplete types
3377            except for arrays which might be completed by the initialization.  */
3378
3379         /* This can happen if the array size is an undefined macro.  We already
3380            gave a warning, so we don't need another one.  */
3381         if (TREE_TYPE (decl) == error_mark_node)
3382           initialized = 0;
3383         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3384           {
3385             /* A complete type is ok if size is fixed.  */
3386
3387             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3388                 || C_DECL_VARIABLE_SIZE (decl))
3389               {
3390                 error ("variable-sized object may not be initialized");
3391                 initialized = 0;
3392               }
3393           }
3394         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3395           {
3396             error ("variable `%s' has initializer but incomplete type",
3397                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3398             initialized = 0;
3399           }
3400         else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
3401           {
3402             error ("elements of array `%s' have incomplete type",
3403                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3404             initialized = 0;
3405           }
3406       }
3407
3408   if (initialized)
3409     {
3410 #if 0
3411       /* Seems redundant with grokdeclarator.  */
3412       if (current_binding_level != global_binding_level
3413           && DECL_EXTERNAL (decl)
3414           && TREE_CODE (decl) != FUNCTION_DECL)
3415         warning ("declaration of `%s' has `extern' and is initialized",
3416                  IDENTIFIER_POINTER (DECL_NAME (decl)));
3417 #endif
3418       DECL_EXTERNAL (decl) = 0;
3419       if (current_binding_level == global_binding_level)
3420         TREE_STATIC (decl) = 1;
3421
3422       /* Tell `pushdecl' this is an initialized decl
3423          even though we don't yet have the initializer expression.
3424          Also tell `finish_decl' it may store the real initializer.  */
3425       DECL_INITIAL (decl) = error_mark_node;
3426     }
3427
3428   /* If this is a function declaration, write a record describing it to the
3429      prototypes file (if requested).  */
3430
3431   if (TREE_CODE (decl) == FUNCTION_DECL)
3432     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3433
3434   /* ANSI specifies that a tentative definition which is not merged with
3435      a non-tentative definition behaves exactly like a definition with an
3436      initializer equal to zero.  (Section 3.7.2)
3437      -fno-common gives strict ANSI behavior.  Usually you don't want it.
3438      This matters only for variables with external linkage.  */
3439   if (! flag_no_common || ! TREE_PUBLIC (decl))
3440     DECL_COMMON (decl) = 1;
3441
3442 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
3443   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
3444 #endif
3445
3446   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3447   decl_attributes (decl, attributes, prefix_attributes);
3448
3449   /* Add this decl to the current binding level.
3450      TEM may equal DECL or it may be a previous decl of the same name.  */
3451   tem = pushdecl (decl);
3452
3453   /* For a local variable, define the RTL now.  */
3454   if (current_binding_level != global_binding_level
3455       /* But not if this is a duplicate decl
3456          and we preserved the rtl from the previous one
3457          (which may or may not happen).  */
3458       && !DECL_RTL_SET_P (tem)
3459       && !DECL_CONTEXT (tem))
3460     {
3461       if (TREE_TYPE (tem) != error_mark_node
3462           && COMPLETE_TYPE_P (TREE_TYPE (tem)))
3463         expand_decl (tem);
3464       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3465                && DECL_INITIAL (tem) != 0)
3466         expand_decl (tem);
3467     }
3468
3469   return tem;
3470 }
3471
3472 /* Finish processing of a declaration;
3473    install its initial value.
3474    If the length of an array type is not known before,
3475    it must be determined now, from the initial value, or it is an error.  */
3476
3477 void
3478 finish_decl (decl, init, asmspec_tree)
3479      tree decl, init;
3480      tree asmspec_tree;
3481 {
3482   register tree type = TREE_TYPE (decl);
3483   int was_incomplete = (DECL_SIZE (decl) == 0);
3484   const char *asmspec = 0;
3485
3486   /* If a name was specified, get the string.   */
3487   if (asmspec_tree)
3488     asmspec = TREE_STRING_POINTER (asmspec_tree);
3489
3490   /* If `start_decl' didn't like having an initialization, ignore it now.  */
3491
3492   if (init != 0 && DECL_INITIAL (decl) == 0)
3493     init = 0;
3494   /* Don't crash if parm is initialized.  */
3495   if (TREE_CODE (decl) == PARM_DECL)
3496     init = 0;
3497
3498   if (init)
3499     {
3500       if (TREE_CODE (decl) != TYPE_DECL)
3501         store_init_value (decl, init);
3502       else
3503         {
3504           /* typedef foo = bar; store the type of bar as the type of foo.  */
3505           TREE_TYPE (decl) = TREE_TYPE (init);
3506           DECL_INITIAL (decl) = init = 0;
3507         }
3508     }
3509
3510   /* Deduce size of array from initialization, if not already known */
3511
3512   if (TREE_CODE (type) == ARRAY_TYPE
3513       && TYPE_DOMAIN (type) == 0
3514       && TREE_CODE (decl) != TYPE_DECL)
3515     {
3516       int do_default
3517         = (TREE_STATIC (decl)
3518            /* Even if pedantic, an external linkage array
3519               may have incomplete type at first.  */
3520            ? pedantic && !TREE_PUBLIC (decl)
3521            : !DECL_EXTERNAL (decl));
3522       int failure
3523         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3524
3525       /* Get the completed type made by complete_array_type.  */
3526       type = TREE_TYPE (decl);
3527
3528       if (failure == 1)
3529         error_with_decl (decl, "initializer fails to determine size of `%s'");
3530
3531       else if (failure == 2)
3532         {
3533           if (do_default)
3534             error_with_decl (decl, "array size missing in `%s'");
3535           /* If a `static' var's size isn't known,
3536              make it extern as well as static, so it does not get
3537              allocated.
3538              If it is not `static', then do not mark extern;
3539              finish_incomplete_decl will give it a default size
3540              and it will get allocated.  */
3541           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3542             DECL_EXTERNAL (decl) = 1;
3543         }
3544
3545       /* TYPE_MAX_VALUE is always one less than the number of elements
3546          in the array, because we start counting at zero.  Therefore,
3547          warn only if the value is less than zero.  */
3548       else if (pedantic && TYPE_DOMAIN (type) != 0
3549               && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3550         error_with_decl (decl, "zero or negative size array `%s'");
3551
3552       layout_decl (decl, 0);
3553     }
3554
3555   if (TREE_CODE (decl) == VAR_DECL)
3556     {
3557       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3558           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3559         layout_decl (decl, 0);
3560
3561       if (DECL_SIZE (decl) == 0
3562           /* Don't give an error if we already gave one earlier.  */
3563           && TREE_TYPE (decl) != error_mark_node
3564           && (TREE_STATIC (decl)
3565               ?
3566                 /* A static variable with an incomplete type
3567                    is an error if it is initialized.
3568                    Also if it is not file scope.
3569                    Otherwise, let it through, but if it is not `extern'
3570                    then it may cause an error message later.  */
3571                 (DECL_INITIAL (decl) != 0
3572                  || DECL_CONTEXT (decl) != 0)
3573               :
3574                 /* An automatic variable with an incomplete type
3575                    is an error.  */
3576                 !DECL_EXTERNAL (decl)))
3577         {
3578           error_with_decl (decl, "storage size of `%s' isn't known");
3579           TREE_TYPE (decl) = error_mark_node;
3580         }
3581
3582       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3583           && DECL_SIZE (decl) != 0)
3584         {
3585           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3586             constant_expression_warning (DECL_SIZE (decl));
3587           else
3588             error_with_decl (decl, "storage size of `%s' isn't constant");
3589         }
3590
3591       if (TREE_USED (type))
3592         TREE_USED (decl) = 1;
3593     }
3594
3595   /* If this is a function and an assembler name is specified, it isn't
3596      builtin any more.  Also reset DECL_RTL so we can give it its new
3597      name.  */
3598   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3599     {
3600       DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3601       SET_DECL_RTL (decl, NULL_RTX);
3602       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3603     }
3604
3605   /* Output the assembler code and/or RTL code for variables and functions,
3606      unless the type is an undefined structure or union.
3607      If not, it will get done when the type is completed.  */
3608
3609   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3610     {
3611       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
3612       maybe_objc_check_decl (decl);
3613
3614       if (!DECL_CONTEXT (decl))
3615         {
3616           if (DECL_INITIAL (decl) == NULL_TREE
3617               || DECL_INITIAL (decl) == error_mark_node)
3618             /* Don't output anything
3619                when a tentative file-scope definition is seen.
3620                But at end of compilation, do output code for them.  */
3621             DECL_DEFER_OUTPUT (decl) = 1;
3622           rest_of_decl_compilation (decl, asmspec,
3623                                     (DECL_CONTEXT (decl) == 0
3624                                      || TREE_ASM_WRITTEN (decl)), 0);
3625         }
3626       else
3627         {
3628           if (asmspec)
3629             {
3630               SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3631               DECL_C_HARD_REGISTER (decl) = 1;
3632             }
3633           add_decl_stmt (decl);
3634         }
3635
3636       if (DECL_CONTEXT (decl) != 0)
3637         {
3638           /* Recompute the RTL of a local array now
3639              if it used to be an incomplete type.  */
3640           if (was_incomplete
3641               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3642             {
3643               /* If we used it already as memory, it must stay in memory.  */
3644               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3645               /* If it's still incomplete now, no init will save it.  */
3646               if (DECL_SIZE (decl) == 0)
3647                 DECL_INITIAL (decl) = 0;
3648             }
3649         }
3650     }
3651
3652   if (TREE_CODE (decl) == TYPE_DECL)
3653     {
3654       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
3655       maybe_objc_check_decl (decl);
3656       rest_of_decl_compilation (decl, NULL_PTR, DECL_CONTEXT (decl) == 0, 0);
3657     }
3658
3659   /* At the end of a declaration, throw away any variable type sizes
3660      of types defined inside that declaration.  There is no use
3661      computing them in the following function definition.  */
3662   if (current_binding_level == global_binding_level)
3663     get_pending_sizes ();
3664 }
3665
3666 /* If DECL has a cleanup, build and return that cleanup here.
3667    This is a callback called by expand_expr.  */
3668
3669 tree
3670 maybe_build_cleanup (decl)
3671      tree decl ATTRIBUTE_UNUSED;
3672 {
3673   /* There are no cleanups in C.  */
3674   return NULL_TREE;
3675 }
3676
3677 /* Given a parsed parameter declaration,
3678    decode it into a PARM_DECL and push that on the current binding level.
3679    Also, for the sake of forward parm decls,
3680    record the given order of parms in `parm_order'.  */
3681
3682 void
3683 push_parm_decl (parm)
3684      tree parm;
3685 {
3686   tree decl;
3687   int old_immediate_size_expand = immediate_size_expand;
3688   /* Don't try computing parm sizes now -- wait till fn is called.  */
3689   immediate_size_expand = 0;
3690
3691   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3692                          TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3693   decl_attributes (decl, TREE_VALUE (TREE_VALUE (parm)),
3694                    TREE_PURPOSE (TREE_VALUE (parm)));
3695
3696 #if 0
3697   if (DECL_NAME (decl))
3698     {
3699       tree olddecl;
3700       olddecl = lookup_name (DECL_NAME (decl));
3701       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3702         pedwarn_with_decl (decl,
3703                            "ANSI C forbids parameter `%s' shadowing typedef");
3704     }
3705 #endif
3706
3707   decl = pushdecl (decl);
3708
3709   immediate_size_expand = old_immediate_size_expand;
3710
3711   current_binding_level->parm_order
3712     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3713
3714   /* Add this decl to the current binding level.  */
3715   finish_decl (decl, NULL_TREE, NULL_TREE);
3716 }
3717
3718 /* Clear the given order of parms in `parm_order'.
3719    Used at start of parm list,
3720    and also at semicolon terminating forward decls.  */
3721
3722 void
3723 clear_parm_order ()
3724 {
3725   current_binding_level->parm_order = NULL_TREE;
3726 }
3727 \f
3728 /* Make TYPE a complete type based on INITIAL_VALUE.
3729    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3730    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3731
3732 int
3733 complete_array_type (type, initial_value, do_default)
3734      tree type;
3735      tree initial_value;
3736      int do_default;
3737 {
3738   register tree maxindex = NULL_TREE;
3739   int value = 0;
3740
3741   if (initial_value)
3742     {
3743       /* Note MAXINDEX  is really the maximum index,
3744          one less than the size.  */
3745       if (TREE_CODE (initial_value) == STRING_CST)
3746         {
3747           int eltsize
3748             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3749           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3750                                    / eltsize) - 1, 0);
3751         }
3752       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3753         {
3754           tree elts = CONSTRUCTOR_ELTS (initial_value);
3755           maxindex = build_int_2 (-1, -1);
3756           for (; elts; elts = TREE_CHAIN (elts))
3757             {
3758               if (TREE_PURPOSE (elts))
3759                 maxindex = TREE_PURPOSE (elts);
3760               else
3761                 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3762                                         maxindex, integer_one_node));
3763             }
3764           maxindex = copy_node (maxindex);
3765         }
3766       else
3767         {
3768           /* Make an error message unless that happened already.  */
3769           if (initial_value != error_mark_node)
3770             value = 1;
3771
3772           /* Prevent further error messages.  */
3773           maxindex = build_int_2 (0, 0);
3774         }
3775     }
3776
3777   if (!maxindex)
3778     {
3779       if (do_default)
3780         maxindex = build_int_2 (0, 0);
3781       value = 2;
3782     }
3783
3784   if (maxindex)
3785     {
3786       TYPE_DOMAIN (type) = build_index_type (maxindex);
3787       if (!TREE_TYPE (maxindex))
3788         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3789     }
3790
3791   /* Lay out the type now that we can get the real answer.  */
3792
3793   layout_type (type);
3794
3795   return value;
3796 }
3797 \f
3798 /* Given declspecs and a declarator,
3799    determine the name and type of the object declared
3800    and construct a ..._DECL node for it.
3801    (In one case we can return a ..._TYPE node instead.
3802     For invalid input we sometimes return 0.)
3803
3804    DECLSPECS is a chain of tree_list nodes whose value fields
3805     are the storage classes and type specifiers.
3806
3807    DECL_CONTEXT says which syntactic context this declaration is in:
3808      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3809      FUNCDEF for a function definition.  Like NORMAL but a few different
3810       error messages in each case.  Return value may be zero meaning
3811       this definition is too screwy to try to parse.
3812      PARM for a parameter declaration (either within a function prototype
3813       or before a function body).  Make a PARM_DECL, or return void_type_node.
3814      TYPENAME if for a typename (in a cast or sizeof).
3815       Don't make a DECL node; just return the ..._TYPE node.
3816      FIELD for a struct or union field; make a FIELD_DECL.
3817      BITFIELD for a field with specified width.
3818    INITIALIZED is 1 if the decl has an initializer.
3819
3820    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3821    It may also be so in the PARM case, for a prototype where the
3822    argument type is specified but not the name.
3823
3824    This function is where the complicated C meanings of `static'
3825    and `extern' are interpreted.  */
3826
3827 static tree
3828 grokdeclarator (declarator, declspecs, decl_context, initialized)
3829      tree declspecs;
3830      tree declarator;
3831      enum decl_context decl_context;
3832      int initialized;
3833 {
3834   int specbits = 0;
3835   tree spec;
3836   tree type = NULL_TREE;
3837   int longlong = 0;
3838   int constp;
3839   int restrictp;
3840   int volatilep;
3841   int type_quals = TYPE_UNQUALIFIED;
3842   int inlinep;
3843   int explicit_int = 0;
3844   int explicit_char = 0;
3845   int defaulted_int = 0;
3846   tree typedef_decl = 0;
3847   const char *name;
3848   tree typedef_type = 0;
3849   int funcdef_flag = 0;
3850   enum tree_code innermost_code = ERROR_MARK;
3851   int bitfield = 0;
3852   int size_varies = 0;
3853   tree decl_machine_attr = NULL_TREE;
3854
3855   if (decl_context == BITFIELD)
3856     bitfield = 1, decl_context = FIELD;
3857
3858   if (decl_context == FUNCDEF)
3859     funcdef_flag = 1, decl_context = NORMAL;
3860
3861   /* Look inside a declarator for the name being declared
3862      and get it as a string, for an error message.  */
3863   {
3864     register tree decl = declarator;
3865     name = 0;
3866
3867     while (decl)
3868       switch (TREE_CODE (decl))
3869         {
3870         case ARRAY_REF:
3871         case INDIRECT_REF:
3872         case CALL_EXPR:
3873           innermost_code = TREE_CODE (decl);
3874           decl = TREE_OPERAND (decl, 0);
3875           break;
3876
3877         case IDENTIFIER_NODE:
3878           name = IDENTIFIER_POINTER (decl);
3879           decl = 0;
3880           break;
3881
3882         default:
3883           abort ();
3884         }
3885     if (name == 0)
3886       name = "type name";
3887   }
3888
3889   /* A function definition's declarator must have the form of
3890      a function declarator.  */
3891
3892   if (funcdef_flag && innermost_code != CALL_EXPR)
3893     return 0;
3894
3895   /* Anything declared one level down from the top level
3896      must be one of the parameters of a function
3897      (because the body is at least two levels down).  */
3898
3899   /* If this looks like a function definition, make it one,
3900      even if it occurs where parms are expected.
3901      Then store_parm_decls will reject it and not use it as a parm.  */
3902   if (decl_context == NORMAL && !funcdef_flag
3903       && current_binding_level->parm_flag)
3904     decl_context = PARM;
3905
3906   /* Look through the decl specs and record which ones appear.
3907      Some typespecs are defined as built-in typenames.
3908      Others, the ones that are modifiers of other types,
3909      are represented by bits in SPECBITS: set the bits for
3910      the modifiers that appear.  Storage class keywords are also in SPECBITS.
3911
3912      If there is a typedef name or a type, store the type in TYPE.
3913      This includes builtin typedefs such as `int'.
3914
3915      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3916      and did not come from a user typedef.
3917
3918      Set LONGLONG if `long' is mentioned twice.  */
3919
3920   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3921     {
3922       register tree id = TREE_VALUE (spec);
3923
3924       if (id == ridpointers[(int) RID_INT])
3925         explicit_int = 1;
3926       if (id == ridpointers[(int) RID_CHAR])
3927         explicit_char = 1;
3928
3929       if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3930         {
3931           enum rid i = C_RID_CODE (id);
3932           if ((int) i <= (int) RID_LAST_MODIFIER)
3933             {
3934               if (i == RID_LONG && (specbits & (1 << (int) i)))
3935                 {
3936                   if (longlong)
3937                     error ("`long long long' is too long for GCC");
3938                   else
3939                     {
3940                       if (pedantic && !flag_isoc99 && ! in_system_header
3941                           && warn_long_long)
3942                         pedwarn ("ISO C89 does not support `long long'");
3943                       longlong = 1;
3944                     }
3945                 }
3946               else if (specbits & (1 << (int) i))
3947                 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3948               specbits |= 1 << (int) i;
3949               goto found;
3950             }
3951         }
3952       if (type)
3953         error ("two or more data types in declaration of `%s'", name);
3954       /* Actual typedefs come to us as TYPE_DECL nodes.  */
3955       else if (TREE_CODE (id) == TYPE_DECL)
3956         {
3957           type = TREE_TYPE (id);
3958           decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
3959           typedef_decl = id;
3960         }
3961       /* Built-in types come as identifiers.  */
3962       else if (TREE_CODE (id) == IDENTIFIER_NODE)
3963         {
3964           register tree t = lookup_name (id);
3965           if (TREE_TYPE (t) == error_mark_node)
3966             ;
3967           else if (!t || TREE_CODE (t) != TYPE_DECL)
3968             error ("`%s' fails to be a typedef or built in type",
3969                    IDENTIFIER_POINTER (id));
3970           else
3971             {
3972               type = TREE_TYPE (t);
3973               typedef_decl = t;
3974             }
3975         }
3976       else if (TREE_CODE (id) != ERROR_MARK)
3977         type = id;
3978
3979     found:
3980       ;
3981     }
3982
3983   typedef_type = type;
3984   if (type)
3985     size_varies = C_TYPE_VARIABLE_SIZE (type);
3986
3987   /* No type at all: default to `int', and set DEFAULTED_INT
3988      because it was not a user-defined typedef.  */
3989
3990   if (type == 0)
3991     {
3992       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3993                           | (1 << (int) RID_SIGNED)
3994                           | (1 << (int) RID_UNSIGNED)
3995                           | (1 << (int) RID_COMPLEX))))
3996           /* Don't warn about typedef foo = bar.  */
3997           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3998           && ! in_system_header)
3999         {
4000           /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
4001              and this is a function, or if -Wimplicit; prefer the former
4002              warning since it is more explicit.  */
4003           if ((warn_implicit_int || warn_return_type || flag_isoc99)
4004               && funcdef_flag)
4005             warn_about_return_type = 1;
4006           else if (warn_implicit_int || flag_isoc99)
4007             pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
4008                          name);
4009         }
4010
4011       defaulted_int = 1;
4012       type = integer_type_node;
4013     }
4014
4015   /* Now process the modifiers that were specified
4016      and check for invalid combinations.  */
4017
4018   /* Long double is a special combination.  */
4019
4020   if ((specbits & 1 << (int) RID_LONG) && ! longlong
4021       && TYPE_MAIN_VARIANT (type) == double_type_node)
4022     {
4023       specbits &= ~(1 << (int) RID_LONG);
4024       type = long_double_type_node;
4025     }
4026
4027   /* Check all other uses of type modifiers.  */
4028
4029   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4030                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4031     {
4032       int ok = 0;
4033
4034       if ((specbits & 1 << (int) RID_LONG)
4035           && (specbits & 1 << (int) RID_SHORT))
4036         error ("both long and short specified for `%s'", name);
4037       else if (((specbits & 1 << (int) RID_LONG)
4038                 || (specbits & 1 << (int) RID_SHORT))
4039                && explicit_char)
4040         error ("long or short specified with char for `%s'", name);
4041       else if (((specbits & 1 << (int) RID_LONG)
4042                 || (specbits & 1 << (int) RID_SHORT))
4043                && TREE_CODE (type) == REAL_TYPE)
4044         {
4045           static int already = 0;
4046
4047           error ("long or short specified with floating type for `%s'", name);
4048           if (! already && ! pedantic)
4049             {
4050               error ("the only valid combination is `long double'");
4051               already = 1;
4052             }
4053         }
4054       else if ((specbits & 1 << (int) RID_SIGNED)
4055                && (specbits & 1 << (int) RID_UNSIGNED))
4056         error ("both signed and unsigned specified for `%s'", name);
4057       else if (TREE_CODE (type) != INTEGER_TYPE)
4058         error ("long, short, signed or unsigned invalid for `%s'", name);
4059       else
4060         {
4061           ok = 1;
4062           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4063             {
4064               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4065                        name);
4066               if (flag_pedantic_errors)
4067                 ok = 0;
4068             }
4069         }
4070
4071       /* Discard the type modifiers if they are invalid.  */
4072       if (! ok)
4073         {
4074           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4075                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4076           longlong = 0;
4077         }
4078     }
4079
4080   if ((specbits & (1 << (int) RID_COMPLEX))
4081       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4082     {
4083       error ("complex invalid for `%s'", name);
4084       specbits &= ~(1 << (int) RID_COMPLEX);
4085     }
4086
4087   /* Decide whether an integer type is signed or not.
4088      Optionally treat bitfields as signed by default.  */
4089   if (specbits & 1 << (int) RID_UNSIGNED
4090       /* Traditionally, all bitfields are unsigned.  */
4091       || (bitfield && flag_traditional
4092           && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
4093       || (bitfield && ! flag_signed_bitfields
4094           && (explicit_int || defaulted_int || explicit_char
4095               /* A typedef for plain `int' without `signed'
4096                  can be controlled just like plain `int'.  */
4097               || ! (typedef_decl != 0
4098                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4099           && TREE_CODE (type) != ENUMERAL_TYPE
4100           && !(specbits & 1 << (int) RID_SIGNED)))
4101     {
4102       if (longlong)
4103         type = long_long_unsigned_type_node;
4104       else if (specbits & 1 << (int) RID_LONG)
4105         type = long_unsigned_type_node;
4106       else if (specbits & 1 << (int) RID_SHORT)
4107         type = short_unsigned_type_node;
4108       else if (type == char_type_node)
4109         type = unsigned_char_type_node;
4110       else if (typedef_decl)
4111         type = unsigned_type (type);
4112       else
4113         type = unsigned_type_node;
4114     }
4115   else if ((specbits & 1 << (int) RID_SIGNED)
4116            && type == char_type_node)
4117     type = signed_char_type_node;
4118   else if (longlong)
4119     type = long_long_integer_type_node;
4120   else if (specbits & 1 << (int) RID_LONG)
4121     type = long_integer_type_node;
4122   else if (specbits & 1 << (int) RID_SHORT)
4123     type = short_integer_type_node;
4124
4125   if (specbits & 1 << (int) RID_COMPLEX)
4126     {
4127       if (pedantic && !flag_isoc99)
4128         pedwarn ("ISO C89 does not support complex types");
4129       /* If we just have "complex", it is equivalent to
4130          "complex double", but if any modifiers at all are specified it is
4131          the complex form of TYPE.  E.g, "complex short" is
4132          "complex short int".  */
4133
4134       if (defaulted_int && ! longlong
4135           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4136                             | (1 << (int) RID_SIGNED)
4137                             | (1 << (int) RID_UNSIGNED))))
4138         {
4139           if (pedantic)
4140             pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
4141           type = complex_double_type_node;
4142         }
4143       else if (type == integer_type_node)
4144         {
4145           if (pedantic)
4146             pedwarn ("ISO C does not support complex integer types");
4147           type = complex_integer_type_node;
4148         }
4149       else if (type == float_type_node)
4150         type = complex_float_type_node;
4151       else if (type == double_type_node)
4152         type = complex_double_type_node;
4153       else if (type == long_double_type_node)
4154         type = complex_long_double_type_node;
4155       else
4156         {
4157           if (pedantic)
4158             pedwarn ("ISO C does not support complex integer types");
4159           type = build_complex_type (type);
4160         }
4161     }
4162
4163   /* Figure out the type qualifiers for the declaration.  There are
4164      two ways a declaration can become qualified.  One is something
4165      like `const int i' where the `const' is explicit.  Another is
4166      something like `typedef const int CI; CI i' where the type of the
4167      declaration contains the `const'.  */
4168   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4169   restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
4170   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4171   inlinep = !! (specbits & (1 << (int) RID_INLINE));
4172   if (constp > 1 && ! flag_isoc99)
4173     pedwarn ("duplicate `const'");
4174   if (restrictp > 1 && ! flag_isoc99)
4175     pedwarn ("duplicate `restrict'");
4176   if (volatilep > 1 && ! flag_isoc99)
4177     pedwarn ("duplicate `volatile'");
4178   if (! flag_gen_aux_info && (TYPE_QUALS (type)))
4179     type = TYPE_MAIN_VARIANT (type);
4180   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4181                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4182                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4183
4184   /* Warn if two storage classes are given. Default to `auto'.  */
4185
4186   {
4187     int nclasses = 0;
4188
4189     if (specbits & 1 << (int) RID_AUTO) nclasses++;
4190     if (specbits & 1 << (int) RID_STATIC) nclasses++;
4191     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4192     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4193     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4194
4195     /* Warn about storage classes that are invalid for certain
4196        kinds of declarations (parameters, typenames, etc.).  */
4197
4198     if (nclasses > 1)
4199       error ("multiple storage classes in declaration of `%s'", name);
4200     else if (funcdef_flag
4201              && (specbits
4202                  & ((1 << (int) RID_REGISTER)
4203                     | (1 << (int) RID_AUTO)
4204                     | (1 << (int) RID_TYPEDEF))))
4205       {
4206         if (specbits & 1 << (int) RID_AUTO
4207             && (pedantic || current_binding_level == global_binding_level))
4208           pedwarn ("function definition declared `auto'");
4209         if (specbits & 1 << (int) RID_REGISTER)
4210           error ("function definition declared `register'");
4211         if (specbits & 1 << (int) RID_TYPEDEF)
4212           error ("function definition declared `typedef'");
4213         specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4214                       | (1 << (int) RID_AUTO));
4215       }
4216     else if (decl_context != NORMAL && nclasses > 0)
4217       {
4218         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4219           ;
4220         else
4221           {
4222             switch (decl_context)
4223               {
4224               case FIELD:
4225                 error ("storage class specified for structure field `%s'",
4226                        name);
4227                 break;
4228               case PARM:
4229                 error ("storage class specified for parameter `%s'", name);
4230                 break;
4231               default:
4232                 error ("storage class specified for typename");
4233                 break;
4234               }
4235             specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4236                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4237                           | (1 << (int) RID_EXTERN));
4238           }
4239       }
4240     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4241       {
4242         /* `extern' with initialization is invalid if not at top level.  */
4243         if (current_binding_level == global_binding_level)
4244           warning ("`%s' initialized and declared `extern'", name);
4245         else
4246           error ("`%s' has both `extern' and initializer", name);
4247       }
4248     else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4249              && current_binding_level != global_binding_level)
4250       error ("nested function `%s' declared `extern'", name);
4251     else if (current_binding_level == global_binding_level
4252              && specbits & (1 << (int) RID_AUTO))
4253       error ("top-level declaration of `%s' specifies `auto'", name);
4254   }
4255
4256   /* Now figure out the structure of the declarator proper.
4257      Descend through it, creating more complex types, until we reach
4258      the declared identifier (or NULL_TREE, in an absolute declarator).  */
4259
4260   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4261     {
4262       if (type == error_mark_node)
4263         {
4264           declarator = TREE_OPERAND (declarator, 0);
4265           continue;
4266         }
4267
4268       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4269          an INDIRECT_REF (for *...),
4270          a CALL_EXPR (for ...(...)),
4271          an identifier (for the name being declared)
4272          or a null pointer (for the place in an absolute declarator
4273          where the name was omitted).
4274          For the last two cases, we have just exited the loop.
4275
4276          At this point, TYPE is the type of elements of an array,
4277          or for a function to return, or for a pointer to point to.
4278          After this sequence of ifs, TYPE is the type of the
4279          array or function or pointer, and DECLARATOR has had its
4280          outermost layer removed.  */
4281
4282       if (TREE_CODE (declarator) == ARRAY_REF)
4283         {
4284           register tree itype = NULL_TREE;
4285           register tree size = TREE_OPERAND (declarator, 1);
4286           /* The index is a signed object `sizetype' bits wide.  */
4287           tree index_type = signed_type (sizetype);
4288
4289           declarator = TREE_OPERAND (declarator, 0);
4290
4291           /* Check for some types that there cannot be arrays of.  */
4292
4293           if (VOID_TYPE_P (type))
4294             {
4295               error ("declaration of `%s' as array of voids", name);
4296               type = error_mark_node;
4297             }
4298
4299           if (TREE_CODE (type) == FUNCTION_TYPE)
4300             {
4301               error ("declaration of `%s' as array of functions", name);
4302               type = error_mark_node;
4303             }
4304
4305           if (size == error_mark_node)
4306             type = error_mark_node;
4307
4308           if (type == error_mark_node)
4309             continue;
4310
4311           /* If size was specified, set ITYPE to a range-type for that size.
4312              Otherwise, ITYPE remains null.  finish_decl may figure it out
4313              from an initial value.  */
4314
4315           if (size)
4316             {
4317               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4318               STRIP_TYPE_NOPS (size);
4319
4320               if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
4321                   && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
4322                 {
4323                   error ("size of array `%s' has non-integer type", name);
4324                   size = integer_one_node;
4325                 }
4326
4327               if (pedantic && integer_zerop (size))
4328                 pedwarn ("ISO C forbids zero-size array `%s'", name);
4329
4330               if (TREE_CODE (size) == INTEGER_CST)
4331                 {
4332                   constant_expression_warning (size);
4333                   if (tree_int_cst_sgn (size) < 0)
4334                     {
4335                       error ("size of array `%s' is negative", name);
4336                       size = integer_one_node;
4337                     }
4338                 }
4339               else
4340                 {
4341                   /* Make sure the array size remains visibly nonconstant
4342                      even if it is (eg) a const variable with known value.  */
4343                   size_varies = 1;
4344
4345                   if (pedantic)
4346                     {
4347                       if (TREE_CONSTANT (size))
4348                         pedwarn ("ISO C89 forbids array `%s' whose size can't be evaluated",
4349                                  name);
4350                       else
4351                         pedwarn ("ISO C89 forbids variable-size array `%s'",
4352                                  name);
4353                     }
4354                 }
4355
4356               if (integer_zerop (size))
4357                 {
4358                   /* A zero-length array cannot be represented with an
4359                      unsigned index type, which is what we'll get with
4360                      build_index_type.  Create an open-ended range instead.  */
4361                   itype = build_range_type (sizetype, size, NULL_TREE);
4362                 }
4363               else
4364                 {
4365                   /* Compute the maximum valid index, that is, size - 1.
4366                      Do the calculation in index_type, so that if it is
4367                      a variable the computations will be done in the
4368                      proper mode.  */
4369                   itype = fold (build (MINUS_EXPR, index_type,
4370                                        convert (index_type, size),
4371                                        convert (index_type, size_one_node)));
4372
4373                   /* If that overflowed, the array is too big.
4374                      ??? While a size of INT_MAX+1 technically shouldn't
4375                      cause an overflow (because we subtract 1), the overflow
4376                      is recorded during the conversion to index_type, before
4377                      the subtraction.  Handling this case seems like an
4378                      unnecessary complication.  */
4379                   if (TREE_OVERFLOW (itype))
4380                     {
4381                       error ("size of array `%s' is too large", name);
4382                       type = error_mark_node;
4383                       continue;
4384                     }
4385
4386                   if (size_varies)
4387                     itype = variable_size (itype);
4388                   itype = build_index_type (itype);
4389                 }
4390             }
4391           else if (decl_context == FIELD)
4392             {
4393               /* ??? Need to check somewhere that this is a structure
4394                  and not a union, that this field is last, and that
4395                  this structure has at least one other named member.  */
4396
4397               if (pedantic && !flag_isoc99 && !in_system_header)
4398                 pedwarn ("ISO C89 does not support flexible array members");
4399
4400               /* ISO C99 Flexible array members are effectively identical
4401                  to GCC's zero-length array extension.  */
4402               itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4403             }
4404
4405           /* If pedantic, complain about arrays of incomplete types.  */
4406
4407           if (pedantic && !COMPLETE_TYPE_P (type))
4408             pedwarn ("array type has incomplete element type");
4409
4410 #if 0
4411           /* We shouldn't have a function type here at all!
4412              Functions aren't allowed as array elements.  */
4413           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4414               && (constp || volatilep))
4415             pedwarn ("ANSI C forbids const or volatile function types");
4416 #endif
4417
4418           /* Build the array type itself, then merge any constancy or
4419              volatility into the target type.  We must do it in this order
4420              to ensure that the TYPE_MAIN_VARIANT field of the array type
4421              is set correctly.  */
4422
4423           type = build_array_type (type, itype);
4424           if (type_quals)
4425             type = c_build_qualified_type (type, type_quals);
4426
4427           if (size_varies)
4428             C_TYPE_VARIABLE_SIZE (type) = 1;
4429
4430           /* The GCC extension for zero-length arrays differs from
4431              ISO flexible array members in that sizeof yields zero.  */
4432           if (size && integer_zerop (size))
4433             {
4434               layout_type (type);
4435               TYPE_SIZE (type) = bitsize_zero_node;
4436               TYPE_SIZE_UNIT (type) = size_zero_node;
4437             }
4438         }
4439       else if (TREE_CODE (declarator) == CALL_EXPR)
4440         {
4441           tree arg_types;
4442
4443           /* Declaring a function type.
4444              Make sure we have a valid type for the function to return.  */
4445           if (type == error_mark_node)
4446             continue;
4447
4448           size_varies = 0;
4449
4450           /* Warn about some types functions can't return.  */
4451
4452           if (TREE_CODE (type) == FUNCTION_TYPE)
4453             {
4454               error ("`%s' declared as function returning a function", name);
4455               type = integer_type_node;
4456             }
4457           if (TREE_CODE (type) == ARRAY_TYPE)
4458             {
4459               error ("`%s' declared as function returning an array", name);
4460               type = integer_type_node;
4461             }
4462
4463 #ifndef TRADITIONAL_RETURN_FLOAT
4464           /* Traditionally, declaring return type float means double.  */
4465
4466           if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4467             type = double_type_node;
4468 #endif /* TRADITIONAL_RETURN_FLOAT */
4469
4470           /* Construct the function type and go to the next
4471              inner layer of declarator.  */
4472
4473           arg_types = grokparms (TREE_OPERAND (declarator, 1),
4474                                  funcdef_flag
4475                                  /* Say it's a definition
4476                                     only for the CALL_EXPR
4477                                     closest to the identifier.  */
4478                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4479           /* Type qualifiers before the return type of the function
4480              qualify the return type, not the function type.  */
4481           if (type_quals)
4482             {
4483               /* Type qualifiers on a function return type are normally
4484                  permitted by the standard but have no effect, so give a
4485                  warning at -W.  Qualifiers on a void return type have
4486                  meaning as a GNU extension, and are banned on function
4487                  definitions in ISO C.  FIXME: strictly we shouldn't
4488                  pedwarn for qualified void return types except on function
4489                  definitions, but not doing so could lead to the undesirable
4490                  state of a "volatile void" function return type not being
4491                  warned about, and a use of the function being compiled
4492                  with GNU semantics, with no diagnostics under -pedantic.  */
4493               if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4494                 pedwarn ("ISO C forbids qualified void function return type");
4495               else if (extra_warnings
4496                        && !(VOID_TYPE_P (type)
4497                             && type_quals == TYPE_QUAL_VOLATILE))
4498                 warning ("type qualifiers ignored on function return type");
4499
4500               type = c_build_qualified_type (type, type_quals);
4501             }
4502           type_quals = TYPE_UNQUALIFIED;
4503
4504           type = build_function_type (type, arg_types);
4505           declarator = TREE_OPERAND (declarator, 0);
4506
4507           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4508              the formal parameter list of this FUNCTION_TYPE to point to
4509              the FUNCTION_TYPE node itself.  */
4510
4511           {
4512             register tree link;
4513
4514             for (link = last_function_parm_tags;
4515                  link;
4516                  link = TREE_CHAIN (link))
4517               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4518           }
4519         }
4520       else if (TREE_CODE (declarator) == INDIRECT_REF)
4521         {
4522           /* Merge any constancy or volatility into the target type
4523              for the pointer.  */
4524
4525           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4526               && type_quals)
4527             pedwarn ("ISO C forbids qualified function types");
4528           if (type_quals)
4529             type = c_build_qualified_type (type, type_quals);
4530           type_quals = TYPE_UNQUALIFIED;
4531           size_varies = 0;
4532
4533           type = build_pointer_type (type);
4534
4535           /* Process a list of type modifier keywords
4536              (such as const or volatile) that were given inside the `*'.  */
4537
4538           if (TREE_TYPE (declarator))
4539             {
4540               register tree typemodlist;
4541               int erred = 0;
4542
4543               constp = 0;
4544               volatilep = 0;
4545               restrictp = 0;
4546               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4547                    typemodlist = TREE_CHAIN (typemodlist))
4548                 {
4549                   tree qualifier = TREE_VALUE (typemodlist);
4550
4551                   if (C_IS_RESERVED_WORD (qualifier))
4552                     {
4553                       if (C_RID_CODE (qualifier) == RID_CONST)
4554                         constp++;
4555                       else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4556                         volatilep++;
4557                       else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4558                         restrictp++;
4559                       else
4560                         erred++;
4561                     }
4562                   else
4563                     erred++;
4564                 }
4565
4566               if (erred)
4567                 error ("invalid type modifier within pointer declarator");
4568               if (constp > 1 && ! flag_isoc99)
4569                 pedwarn ("duplicate `const'");
4570               if (volatilep > 1 && ! flag_isoc99)
4571                 pedwarn ("duplicate `volatile'");
4572               if (restrictp > 1 && ! flag_isoc99)
4573                 pedwarn ("duplicate `restrict'");
4574
4575               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4576                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4577                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4578             }
4579
4580           declarator = TREE_OPERAND (declarator, 0);
4581         }
4582       else
4583         abort ();
4584
4585     }
4586
4587   /* Now TYPE has the actual type.  */
4588
4589   /* Did array size calculations overflow?  */
4590
4591   if (TREE_CODE (type) == ARRAY_TYPE
4592       && COMPLETE_TYPE_P (type)
4593       && TREE_OVERFLOW (TYPE_SIZE (type)))
4594     {
4595       error ("size of array `%s' is too large", name);
4596       /* If we proceed with the array type as it is, we'll eventully
4597          crash in tree_low_cst().  */
4598       type = error_mark_node;
4599     }
4600
4601   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4602
4603   if (specbits & (1 << (int) RID_TYPEDEF))
4604     {
4605       tree decl;
4606       /* Note that the grammar rejects storage classes
4607          in typenames, fields or parameters */
4608       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4609           && type_quals)
4610         pedwarn ("ISO C forbids qualified function types");
4611       if (type_quals)
4612         type = c_build_qualified_type (type, type_quals);
4613       decl = build_decl (TYPE_DECL, declarator, type);
4614       if ((specbits & (1 << (int) RID_SIGNED))
4615           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4616         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4617       return decl;
4618     }
4619
4620   /* Detect the case of an array type of unspecified size
4621      which came, as such, direct from a typedef name.
4622      We must copy the type, so that each identifier gets
4623      a distinct type, so that each identifier's size can be
4624      controlled separately by its own initializer.  */
4625
4626   if (type != 0 && typedef_type != 0
4627       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4628       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4629     {
4630       type = build_array_type (TREE_TYPE (type), 0);
4631       if (size_varies)
4632         C_TYPE_VARIABLE_SIZE (type) = 1;
4633     }
4634
4635   /* If this is a type name (such as, in a cast or sizeof),
4636      compute the type and return it now.  */
4637
4638   if (decl_context == TYPENAME)
4639     {
4640       /* Note that the grammar rejects storage classes
4641          in typenames, fields or parameters */
4642       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4643           && type_quals)
4644         pedwarn ("ISO C forbids const or volatile function types");
4645       if (type_quals)
4646         type = c_build_qualified_type (type, type_quals);
4647       return type;
4648     }
4649
4650   /* Aside from typedefs and type names (handle above),
4651      `void' at top level (not within pointer)
4652      is allowed only in public variables.
4653      We don't complain about parms either, but that is because
4654      a better error message can be made later.  */
4655
4656   if (VOID_TYPE_P (type) && decl_context != PARM
4657       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4658             && ((specbits & (1 << (int) RID_EXTERN))
4659                 || (current_binding_level == global_binding_level
4660                     && !(specbits
4661                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4662     {
4663       error ("variable or field `%s' declared void", name);
4664       type = integer_type_node;
4665     }
4666
4667   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4668      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4669
4670   {
4671     register tree decl;
4672
4673     if (decl_context == PARM)
4674       {
4675         tree type_as_written = type;
4676         tree promoted_type;
4677
4678         /* A parameter declared as an array of T is really a pointer to T.
4679            One declared as a function is really a pointer to a function.  */
4680
4681         if (TREE_CODE (type) == ARRAY_TYPE)
4682           {
4683             /* Transfer const-ness of array into that of type pointed to.  */
4684             type = TREE_TYPE (type);
4685             if (type_quals)
4686               type = c_build_qualified_type (type, type_quals);
4687             type = build_pointer_type (type);
4688             type_quals = TYPE_UNQUALIFIED;
4689             size_varies = 0;
4690           }
4691         else if (TREE_CODE (type) == FUNCTION_TYPE)
4692           {
4693             if (pedantic && type_quals)
4694               pedwarn ("ISO C forbids qualified function types");
4695             if (type_quals)
4696               type = c_build_qualified_type (type, type_quals);
4697             type = build_pointer_type (type);
4698             type_quals = TYPE_UNQUALIFIED;
4699           }
4700
4701         decl = build_decl (PARM_DECL, declarator, type);
4702         if (size_varies)
4703           C_DECL_VARIABLE_SIZE (decl) = 1;
4704
4705         /* Compute the type actually passed in the parmlist,
4706            for the case where there is no prototype.
4707            (For example, shorts and chars are passed as ints.)
4708            When there is a prototype, this is overridden later.  */
4709
4710         if (type == error_mark_node)
4711           promoted_type = type;
4712         else
4713           {
4714             promoted_type = simple_type_promotes_to (type);
4715             if (! promoted_type)
4716               promoted_type = type;
4717           }
4718
4719         DECL_ARG_TYPE (decl) = promoted_type;
4720         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4721       }
4722     else if (decl_context == FIELD)
4723       {
4724         /* Structure field.  It may not be a function.  */
4725
4726         if (TREE_CODE (type) == FUNCTION_TYPE)
4727           {
4728             error ("field `%s' declared as a function", name);
4729             type = build_pointer_type (type);
4730           }
4731         else if (TREE_CODE (type) != ERROR_MARK
4732                  && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4733           {
4734             error ("field `%s' has incomplete type", name);
4735             type = error_mark_node;
4736           }
4737         /* Move type qualifiers down to element of an array.  */
4738         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4739           {
4740             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4741                                                              type_quals),
4742                                      TYPE_DOMAIN (type));
4743 #if 0
4744             /* Leave the field const or volatile as well.  */
4745             type_quals = TYPE_UNQUALIFIED;
4746 #endif
4747           }
4748         decl = build_decl (FIELD_DECL, declarator, type);
4749         DECL_NONADDRESSABLE_P (decl) = bitfield;
4750
4751         if (size_varies)
4752           C_DECL_VARIABLE_SIZE (decl) = 1;
4753       }
4754     else if (TREE_CODE (type) == FUNCTION_TYPE)
4755       {
4756         /* Every function declaration is "external"
4757            except for those which are inside a function body
4758            in which `auto' is used.
4759            That is a case not specified by ANSI C,
4760            and we use it for forward declarations for nested functions.  */
4761         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4762                           || current_binding_level == global_binding_level);
4763
4764         if (specbits & (1 << (int) RID_AUTO)
4765             && (pedantic || current_binding_level == global_binding_level))
4766           pedwarn ("invalid storage class for function `%s'", name);
4767         if (specbits & (1 << (int) RID_REGISTER))
4768           error ("invalid storage class for function `%s'", name);
4769         /* Function declaration not at top level.
4770            Storage classes other than `extern' are not allowed
4771            and `extern' makes no difference.  */
4772         if (current_binding_level != global_binding_level
4773             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4774             && pedantic)
4775           pedwarn ("invalid storage class for function `%s'", name);
4776
4777         decl = build_decl (FUNCTION_DECL, declarator, type);
4778         decl = build_decl_attribute_variant (decl, decl_machine_attr);
4779
4780         if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4781           pedwarn ("ISO C forbids qualified function types");
4782
4783         /* GNU C interprets a `volatile void' return type to indicate
4784            that the function does not return.  */
4785         if ((type_quals & TYPE_QUAL_VOLATILE)
4786             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4787           warning ("`noreturn' function returns non-void value");
4788
4789         if (extern_ref)
4790           DECL_EXTERNAL (decl) = 1;
4791         /* Record absence of global scope for `static' or `auto'.  */
4792         TREE_PUBLIC (decl)
4793           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4794
4795         /* Record presence of `inline', if it is reasonable.  */
4796         if (inlinep)
4797           {
4798             if (MAIN_NAME_P (declarator))
4799               warning ("cannot inline function `main'");
4800             else
4801               /* Assume that otherwise the function can be inlined.  */
4802               DECL_INLINE (decl) = 1;
4803
4804             if (specbits & (1 << (int) RID_EXTERN))
4805               current_extern_inline = 1;
4806           }
4807       }
4808     else
4809       {
4810         /* It's a variable.  */
4811         /* An uninitialized decl with `extern' is a reference.  */
4812         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4813
4814         /* Move type qualifiers down to element of an array.  */
4815         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4816           {
4817             int saved_align = TYPE_ALIGN(type);
4818             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4819                                                              type_quals),
4820                                      TYPE_DOMAIN (type));
4821             TYPE_ALIGN (type) = saved_align;
4822 #if 0 /* Leave the variable const or volatile as well.  */
4823             type_quals = TYPE_UNQUALIFIED;
4824 #endif
4825           }
4826
4827         decl = build_decl (VAR_DECL, declarator, type);
4828         if (size_varies)
4829           C_DECL_VARIABLE_SIZE (decl) = 1;
4830
4831         if (inlinep)
4832           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4833
4834         DECL_EXTERNAL (decl) = extern_ref;
4835         /* At top level, the presence of a `static' or `register' storage
4836            class specifier, or the absence of all storage class specifiers
4837            makes this declaration a definition (perhaps tentative).  Also,
4838            the absence of both `static' and `register' makes it public.  */
4839         if (current_binding_level == global_binding_level)
4840           {
4841             TREE_PUBLIC (decl)
4842               = !(specbits
4843                   & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
4844             TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
4845           }
4846         /* Not at top level, only `static' makes a static definition.  */
4847         else
4848           {
4849             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4850             TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
4851           }
4852       }
4853
4854     /* Record `register' declaration for warnings on &
4855        and in case doing stupid register allocation.  */
4856
4857     if (specbits & (1 << (int) RID_REGISTER))
4858       DECL_REGISTER (decl) = 1;
4859
4860     /* Record constancy and volatility.  */
4861     c_apply_type_quals_to_decl (type_quals, decl);
4862
4863     /* If a type has volatile components, it should be stored in memory.
4864        Otherwise, the fact that those components are volatile
4865        will be ignored, and would even crash the compiler.  */
4866     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4867       mark_addressable (decl);
4868
4869     return decl;
4870   }
4871 }
4872 \f
4873 /* Decode the parameter-list info for a function type or function definition.
4874    The argument is the value returned by `get_parm_info' (or made in parse.y
4875    if there is an identifier list instead of a parameter decl list).
4876    These two functions are separate because when a function returns
4877    or receives functions then each is called multiple times but the order
4878    of calls is different.  The last call to `grokparms' is always the one
4879    that contains the formal parameter names of a function definition.
4880
4881    Store in `last_function_parms' a chain of the decls of parms.
4882    Also store in `last_function_parm_tags' a chain of the struct, union,
4883    and enum tags declared among the parms.
4884
4885    Return a list of arg types to use in the FUNCTION_TYPE for this function.
4886
4887    FUNCDEF_FLAG is nonzero for a function definition, 0 for
4888    a mere declaration.  A nonempty identifier-list gets an error message
4889    when FUNCDEF_FLAG is zero.  */
4890
4891 static tree
4892 grokparms (parms_info, funcdef_flag)
4893      tree parms_info;
4894      int funcdef_flag;
4895 {
4896   tree first_parm = TREE_CHAIN (parms_info);
4897
4898   last_function_parms = TREE_PURPOSE (parms_info);
4899   last_function_parm_tags = TREE_VALUE (parms_info);
4900
4901   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
4902       && !in_system_header)
4903     warning ("function declaration isn't a prototype");
4904
4905   if (first_parm != 0
4906       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4907     {
4908       if (! funcdef_flag)
4909         pedwarn ("parameter names (without types) in function declaration");
4910
4911       last_function_parms = first_parm;
4912       return 0;
4913     }
4914   else
4915     {
4916       tree parm;
4917       tree typelt;
4918       /* We no longer test FUNCDEF_FLAG.
4919          If the arg types are incomplete in a declaration,
4920          they must include undefined tags.
4921          These tags can never be defined in the scope of the declaration,
4922          so the types can never be completed,
4923          and no call can be compiled successfully.  */
4924 #if 0
4925       /* In a fcn definition, arg types must be complete.  */
4926       if (funcdef_flag)
4927 #endif
4928         for (parm = last_function_parms, typelt = first_parm;
4929              parm;
4930              parm = TREE_CHAIN (parm))
4931           /* Skip over any enumeration constants declared here.  */
4932           if (TREE_CODE (parm) == PARM_DECL)
4933             {
4934               /* Barf if the parameter itself has an incomplete type.  */
4935               tree type = TREE_VALUE (typelt);
4936               if (type == error_mark_node)
4937                 continue;
4938               if (!COMPLETE_TYPE_P (type))
4939                 {
4940                   if (funcdef_flag && DECL_NAME (parm) != 0)
4941                     error ("parameter `%s' has incomplete type",
4942                            IDENTIFIER_POINTER (DECL_NAME (parm)));
4943                   else
4944                     warning ("parameter has incomplete type");
4945                   if (funcdef_flag)
4946                     {
4947                       TREE_VALUE (typelt) = error_mark_node;
4948                       TREE_TYPE (parm) = error_mark_node;
4949                     }
4950                 }
4951 #if 0
4952               /* This has been replaced by parm_tags_warning, which
4953                  uses a more accurate criterion for what to warn
4954                  about.  */
4955               else
4956                 {
4957                   /* Now warn if is a pointer to an incomplete type.  */
4958                   while (TREE_CODE (type) == POINTER_TYPE
4959                          || TREE_CODE (type) == REFERENCE_TYPE)
4960                     type = TREE_TYPE (type);
4961                   type = TYPE_MAIN_VARIANT (type);
4962                   if (!COMPLETE_TYPE_P (type))
4963                     {
4964                       if (DECL_NAME (parm) != 0)
4965                         warning ("parameter `%s' points to incomplete type",
4966                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
4967                       else
4968                         warning ("parameter points to incomplete type");
4969                     }
4970                 }
4971 #endif
4972               typelt = TREE_CHAIN (typelt);
4973             }
4974
4975       return first_parm;
4976     }
4977 }
4978
4979 /* Return a tree_list node with info on a parameter list just parsed.
4980    The TREE_PURPOSE is a chain of decls of those parms.
4981    The TREE_VALUE is a list of structure, union and enum tags defined.
4982    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4983    This tree_list node is later fed to `grokparms'.
4984
4985    VOID_AT_END nonzero means append `void' to the end of the type-list.
4986    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
4987
4988 tree
4989 get_parm_info (void_at_end)
4990      int void_at_end;
4991 {
4992   register tree decl, t;
4993   register tree types = 0;
4994   int erred = 0;
4995   tree tags = gettags ();
4996   tree parms = getdecls ();
4997   tree new_parms = 0;
4998   tree order = current_binding_level->parm_order;
4999
5000   /* Just `void' (and no ellipsis) is special.  There are really no parms.
5001      But if the `void' is qualified (by `const' or `volatile') or has a
5002      storage class specifier (`register'), then the behavior is undefined;
5003      by not counting it as the special case of `void' we will cause an
5004      error later.  Typedefs for `void' are OK (see DR#157).  */
5005   if (void_at_end && parms != 0
5006       && TREE_CHAIN (parms) == 0
5007       && VOID_TYPE_P (TREE_TYPE (parms))
5008       && ! TREE_THIS_VOLATILE (parms)
5009       && ! TREE_READONLY (parms)
5010       && ! DECL_REGISTER (parms)
5011       && DECL_NAME (parms) == 0)
5012     {
5013       parms = NULL_TREE;
5014       storedecls (NULL_TREE);
5015       return tree_cons (NULL_TREE, NULL_TREE,
5016                         tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5017     }
5018
5019   /* Extract enumerator values and other non-parms declared with the parms.
5020      Likewise any forward parm decls that didn't have real parm decls.  */
5021   for (decl = parms; decl;)
5022     {
5023       tree next = TREE_CHAIN (decl);
5024
5025       if (TREE_CODE (decl) != PARM_DECL)
5026         {
5027           TREE_CHAIN (decl) = new_parms;
5028           new_parms = decl;
5029         }
5030       else if (TREE_ASM_WRITTEN (decl))
5031         {
5032           error_with_decl (decl,
5033                            "parameter `%s' has just a forward declaration");
5034           TREE_CHAIN (decl) = new_parms;
5035           new_parms = decl;
5036         }
5037       decl = next;
5038     }
5039
5040   /* Put the parm decls back in the order they were in in the parm list.  */
5041   for (t = order; t; t = TREE_CHAIN (t))
5042     {
5043       if (TREE_CHAIN (t))
5044         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5045       else
5046         TREE_CHAIN (TREE_VALUE (t)) = 0;
5047     }
5048
5049   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5050                        new_parms);
5051
5052   /* Store the parmlist in the binding level since the old one
5053      is no longer a valid list.  (We have changed the chain pointers.)  */
5054   storedecls (new_parms);
5055
5056   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5057     /* There may also be declarations for enumerators if an enumeration
5058        type is declared among the parms.  Ignore them here.  */
5059     if (TREE_CODE (decl) == PARM_DECL)
5060       {
5061         /* Since there is a prototype,
5062            args are passed in their declared types.  */
5063         tree type = TREE_TYPE (decl);
5064         DECL_ARG_TYPE (decl) = type;
5065         if (PROMOTE_PROTOTYPES
5066             && (TREE_CODE (type) == INTEGER_TYPE
5067                 || TREE_CODE (type) == ENUMERAL_TYPE)
5068             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5069           DECL_ARG_TYPE (decl) = integer_type_node;
5070
5071         types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5072         if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
5073             && DECL_NAME (decl) == 0)
5074           {
5075             error ("`void' in parameter list must be the entire list");
5076             erred = 1;
5077           }
5078       }
5079
5080   if (void_at_end)
5081     return tree_cons (new_parms, tags,
5082                       nreverse (tree_cons (NULL_TREE, void_type_node, types)));
5083
5084   return tree_cons (new_parms, tags, nreverse (types));
5085 }
5086
5087 /* At end of parameter list, warn about any struct, union or enum tags
5088    defined within.  Do so because these types cannot ever become complete.  */
5089
5090 void
5091 parmlist_tags_warning ()
5092 {
5093   tree elt;
5094   static int already;
5095
5096   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5097     {
5098       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5099       /* An anonymous union parm type is meaningful as a GNU extension.
5100          So don't warn for that.  */
5101       if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
5102         continue;
5103       if (TREE_PURPOSE (elt) != 0)
5104         warning ("`%s %s' declared inside parameter list",
5105                  (code == RECORD_TYPE ? "struct"
5106                   : code == UNION_TYPE ? "union"
5107                   : "enum"),
5108                  IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5109       else
5110         {
5111           /* For translation these need to be seperate warnings */
5112           if (code == RECORD_TYPE)
5113             warning ("anonymous struct declared inside parameter list");
5114           else if (code == UNION_TYPE)
5115             warning ("anonymous union declared inside parameter list");
5116           else
5117             warning ("anonymous enum declared inside parameter list");
5118         }
5119       if (! already)
5120         {
5121           warning ("its scope is only this definition or declaration, which is probably not what you want.");
5122           already = 1;
5123         }
5124     }
5125 }
5126 \f
5127 /* Get the struct, enum or union (CODE says which) with tag NAME.
5128    Define the tag as a forward-reference if it is not defined.  */
5129
5130 tree
5131 xref_tag (code, name)
5132      enum tree_code code;
5133      tree name;
5134 {
5135   /* If a cross reference is requested, look up the type
5136      already defined for this tag and return it.  */
5137
5138   register tree ref = lookup_tag (code, name, current_binding_level, 0);
5139   /* Even if this is the wrong type of tag, return what we found.
5140      There will be an error message anyway, from pending_xref_error.
5141      If we create an empty xref just for an invalid use of the type,
5142      the main result is to create lots of superfluous error messages.  */
5143   if (ref)
5144     return ref;
5145
5146   /* If no such tag is yet defined, create a forward-reference node
5147      and record it as the "definition".
5148      When a real declaration of this type is found,
5149      the forward-reference will be altered into a real type.  */
5150
5151   ref = make_node (code);
5152   if (code == ENUMERAL_TYPE)
5153     {
5154       /* Give the type a default layout like unsigned int
5155          to avoid crashing if it does not get defined.  */
5156       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5157       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5158       TYPE_USER_ALIGN (ref) = 0;
5159       TREE_UNSIGNED (ref) = 1;
5160       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5161       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5162       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5163     }
5164
5165   pushtag (name, ref);
5166
5167   return ref;
5168 }
5169 \f
5170 /* Make sure that the tag NAME is defined *in the current binding level*
5171    at least as a forward reference.
5172    CODE says which kind of tag NAME ought to be.  */
5173
5174 tree
5175 start_struct (code, name)
5176      enum tree_code code;
5177      tree name;
5178 {
5179   /* If there is already a tag defined at this binding level
5180      (as a forward reference), just return it.  */
5181
5182   register tree ref = 0;
5183
5184   if (name != 0)
5185     ref = lookup_tag (code, name, current_binding_level, 1);
5186   if (ref && TREE_CODE (ref) == code)
5187     {
5188       C_TYPE_BEING_DEFINED (ref) = 1;
5189       TYPE_PACKED (ref) = flag_pack_struct;
5190       if (TYPE_FIELDS (ref))
5191         error ("redefinition of `%s %s'",
5192                code == UNION_TYPE ? "union" : "struct",
5193                IDENTIFIER_POINTER (name));
5194
5195       return ref;
5196     }
5197
5198   /* Otherwise create a forward-reference just so the tag is in scope.  */
5199
5200   ref = make_node (code);
5201   pushtag (name, ref);
5202   C_TYPE_BEING_DEFINED (ref) = 1;
5203   TYPE_PACKED (ref) = flag_pack_struct;
5204   return ref;
5205 }
5206
5207 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5208    of a structure component, returning a FIELD_DECL node.
5209    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5210
5211    This is done during the parsing of the struct declaration.
5212    The FIELD_DECL nodes are chained together and the lot of them
5213    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5214
5215 tree
5216 grokfield (filename, line, declarator, declspecs, width)
5217      const char *filename ATTRIBUTE_UNUSED;
5218      int line ATTRIBUTE_UNUSED;
5219      tree declarator, declspecs, width;
5220 {
5221   tree value;
5222
5223   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5224
5225   finish_decl (value, NULL_TREE, NULL_TREE);
5226   DECL_INITIAL (value) = width;
5227
5228   maybe_objc_check_decl (value);
5229   return value;
5230 }
5231 \f
5232 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5233    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5234    ATTRIBUTES are attributes to be applied to the structure.  */
5235
5236 tree
5237 finish_struct (t, fieldlist, attributes)
5238      tree t;
5239      tree fieldlist;
5240      tree attributes;
5241 {
5242   register tree x;
5243   int toplevel = global_binding_level == current_binding_level;
5244   int saw_named_field;
5245
5246   /* If this type was previously laid out as a forward reference,
5247      make sure we lay it out again.  */
5248
5249   TYPE_SIZE (t) = 0;
5250
5251   decl_attributes (t, attributes, NULL_TREE);
5252
5253   /* Nameless union parm types are useful as GCC extension.  */
5254   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5255     /* Otherwise, warn about any struct or union def. in parmlist.  */
5256     if (in_parm_level_p ())
5257       {
5258         if (pedantic)
5259           pedwarn ("%s defined inside parms",
5260                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5261         else if (! flag_traditional)
5262           warning ("%s defined inside parms",
5263                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5264       }
5265
5266   if (pedantic)
5267     {
5268       for (x = fieldlist; x; x = TREE_CHAIN (x))
5269         if (DECL_NAME (x) != 0)
5270           break;
5271
5272       if (x == 0)
5273         pedwarn ("%s has no %s",
5274                  TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
5275                  fieldlist ? _("named members") : _("members"));
5276     }
5277
5278   /* Install struct as DECL_CONTEXT of each field decl.
5279      Also process specified field sizes,m which is found in the DECL_INITIAL.
5280      Store 0 there, except for ": 0" fields (so we can find them
5281      and delete them, below).  */
5282
5283   saw_named_field = 0;
5284   for (x = fieldlist; x; x = TREE_CHAIN (x))
5285     {
5286       DECL_CONTEXT (x) = t;
5287       DECL_PACKED (x) |= TYPE_PACKED (t);
5288
5289       /* If any field is const, the structure type is pseudo-const.  */
5290       if (TREE_READONLY (x))
5291         C_TYPE_FIELDS_READONLY (t) = 1;
5292       else
5293         {
5294           /* A field that is pseudo-const makes the structure likewise.  */
5295           tree t1 = TREE_TYPE (x);
5296           while (TREE_CODE (t1) == ARRAY_TYPE)
5297             t1 = TREE_TYPE (t1);
5298           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5299               && C_TYPE_FIELDS_READONLY (t1))
5300             C_TYPE_FIELDS_READONLY (t) = 1;
5301         }
5302
5303       /* Any field that is volatile means variables of this type must be
5304          treated in some ways as volatile.  */
5305       if (TREE_THIS_VOLATILE (x))
5306         C_TYPE_FIELDS_VOLATILE (t) = 1;
5307
5308       /* Any field of nominal variable size implies structure is too.  */
5309       if (C_DECL_VARIABLE_SIZE (x))
5310         C_TYPE_VARIABLE_SIZE (t) = 1;
5311
5312       /* Detect invalid nested redefinition.  */
5313       if (TREE_TYPE (x) == t)
5314         error ("nested redefinition of `%s'",
5315                IDENTIFIER_POINTER (TYPE_NAME (t)));
5316
5317       /* Detect invalid bit-field size.  */
5318       if (DECL_INITIAL (x))
5319         STRIP_NOPS (DECL_INITIAL (x));
5320       if (DECL_INITIAL (x))
5321         {
5322           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5323             constant_expression_warning (DECL_INITIAL (x));
5324           else
5325             {
5326               error_with_decl (x,
5327                                "bit-field `%s' width not an integer constant");
5328               DECL_INITIAL (x) = NULL;
5329             }
5330         }
5331
5332       /* Detect invalid bit-field type.  */
5333       if (DECL_INITIAL (x)
5334           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5335           && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE
5336           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5337         {
5338           error_with_decl (x, "bit-field `%s' has invalid type");
5339           DECL_INITIAL (x) = NULL;
5340         }
5341
5342       if (DECL_INITIAL (x) && pedantic
5343           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5344           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5345           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != c_bool_type_node
5346           /* Accept an enum that's equivalent to int or unsigned int.  */
5347           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5348                && (TYPE_PRECISION (TREE_TYPE (x))
5349                    == TYPE_PRECISION (integer_type_node))))
5350         pedwarn_with_decl (x, "bit-field `%s' type invalid in ISO C");
5351
5352       /* Detect and ignore out of range field width and process valid
5353          field widths.  */
5354       if (DECL_INITIAL (x))
5355         {
5356           int max_width;
5357           if (TYPE_MAIN_VARIANT (TREE_TYPE (x)) == c_bool_type_node)
5358             max_width = CHAR_TYPE_SIZE;
5359           else
5360             max_width = TYPE_PRECISION (TREE_TYPE (x));
5361           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5362             error_with_decl (x, "negative width in bit-field `%s'");
5363           else if (0 < compare_tree_int (DECL_INITIAL (x), max_width))
5364             pedwarn_with_decl (x, "width of `%s' exceeds its type");
5365           else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5366             error_with_decl (x, "zero width for bit-field `%s'");
5367           else
5368             {
5369               /* The test above has assured us that TREE_INT_CST_HIGH is 0.  */
5370               unsigned HOST_WIDE_INT width
5371                 = TREE_INT_CST_LOW (DECL_INITIAL (x));
5372
5373               if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5374                   && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5375                                              TREE_UNSIGNED (TREE_TYPE (x)))
5376                       || (width
5377                           < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5378                                            TREE_UNSIGNED (TREE_TYPE (x))))))
5379                 warning_with_decl (x,
5380                                    "`%s' is narrower than values of its type");
5381
5382               DECL_SIZE (x) = bitsize_int (width);
5383               DECL_BIT_FIELD (x) = 1;
5384               SET_DECL_C_BIT_FIELD (x);
5385
5386               if (width == 0)
5387                 {
5388                   /* field size 0 => force desired amount of alignment.  */
5389 #ifdef EMPTY_FIELD_BOUNDARY
5390                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5391 #endif
5392 #ifdef PCC_BITFIELD_TYPE_MATTERS
5393                   if (PCC_BITFIELD_TYPE_MATTERS)
5394                     {
5395                       DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5396                                             TYPE_ALIGN (TREE_TYPE (x)));
5397                       DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5398                     }
5399 #endif
5400                 }
5401             }
5402         }
5403
5404       else if (TREE_TYPE (x) != error_mark_node)
5405         {
5406           unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5407                                     : TYPE_ALIGN (TREE_TYPE (x)));
5408
5409           /* Non-bit-fields are aligned for their type, except packed
5410              fields which require only BITS_PER_UNIT alignment.  */
5411           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5412           if (! DECL_PACKED (x))
5413             DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5414         }
5415
5416       DECL_INITIAL (x) = 0;
5417
5418       /* Detect flexible array member in an invalid context.  */
5419       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5420           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5421           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5422           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5423         {
5424           if (TREE_CODE (t) == UNION_TYPE)
5425             error_with_decl (x, "flexible array member in union");
5426           else if (TREE_CHAIN (x) != NULL_TREE)
5427             error_with_decl (x, "flexible array member not at end of struct");
5428           else if (! saw_named_field)
5429             error_with_decl (x, "flexible array member in otherwise empty struct");
5430         }
5431       if (DECL_NAME (x))
5432         saw_named_field = 1;
5433     }
5434
5435   /* Delete all duplicate fields from the fieldlist */
5436   for (x = fieldlist; x && TREE_CHAIN (x);)
5437     /* Anonymous fields aren't duplicates.  */
5438     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5439       x = TREE_CHAIN (x);
5440     else
5441       {
5442         register tree y = fieldlist;
5443
5444         while (1)
5445           {
5446             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5447               break;
5448             if (y == x)
5449               break;
5450             y = TREE_CHAIN (y);
5451           }
5452         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5453           {
5454             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5455             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5456           }
5457         else
5458           x = TREE_CHAIN (x);
5459       }
5460
5461   /* Now we have the nearly final fieldlist.  Record it,
5462      then lay out the structure or union (including the fields).  */
5463
5464   TYPE_FIELDS (t) = fieldlist;
5465
5466   layout_type (t);
5467
5468   /* Delete all zero-width bit-fields from the fieldlist */
5469   {
5470     tree *fieldlistp = &fieldlist;
5471     while (*fieldlistp)
5472       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5473         *fieldlistp = TREE_CHAIN (*fieldlistp);
5474       else
5475         fieldlistp = &TREE_CHAIN (*fieldlistp);
5476   }
5477
5478   /* Now we have the truly final field list.
5479      Store it in this type and in the variants.  */
5480
5481   TYPE_FIELDS (t) = fieldlist;
5482
5483   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5484     {
5485       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5486       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5487       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5488       TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5489     }
5490
5491   /* If this was supposed to be a transparent union, but we can't
5492      make it one, warn and turn off the flag.  */
5493   if (TREE_CODE (t) == UNION_TYPE
5494       && TYPE_TRANSPARENT_UNION (t)
5495       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5496     {
5497       TYPE_TRANSPARENT_UNION (t) = 0;
5498       warning ("union cannot be made transparent");
5499     }
5500
5501   /* If this structure or union completes the type of any previous
5502      variable declaration, lay it out and output its rtl.  */
5503
5504   if (current_binding_level->n_incomplete != 0)
5505     {
5506       tree decl;
5507       for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5508         {
5509           if (TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TYPE_MAIN_VARIANT (t)
5510               && TREE_CODE (decl) != TYPE_DECL)
5511             {
5512               layout_decl (decl, 0);
5513               /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
5514               maybe_objc_check_decl (decl);
5515               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
5516               if (! toplevel)
5517                 expand_decl (decl);
5518               --current_binding_level->n_incomplete;
5519             }
5520           else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5521                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5522             {
5523               tree element = TREE_TYPE (decl);
5524               while (TREE_CODE (element) == ARRAY_TYPE)
5525                 element = TREE_TYPE (element);
5526               if (element == t)
5527                 layout_array_type (TREE_TYPE (decl));
5528             }
5529         }
5530     }
5531
5532   /* Finish debugging output for this type.  */
5533   rest_of_type_compilation (t, toplevel);
5534
5535   return t;
5536 }
5537
5538 /* Lay out the type T, and its element type, and so on.  */
5539
5540 static void
5541 layout_array_type (t)
5542      tree t;
5543 {
5544   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5545     layout_array_type (TREE_TYPE (t));
5546   layout_type (t);
5547 }
5548 \f
5549 /* Begin compiling the definition of an enumeration type.
5550    NAME is its name (or null if anonymous).
5551    Returns the type object, as yet incomplete.
5552    Also records info about it so that build_enumerator
5553    may be used to declare the individual values as they are read.  */
5554
5555 tree
5556 start_enum (name)
5557      tree name;
5558 {
5559   register tree enumtype = 0;
5560
5561   /* If this is the real definition for a previous forward reference,
5562      fill in the contents in the same object that used to be the
5563      forward reference.  */
5564
5565   if (name != 0)
5566     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5567
5568   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5569     {
5570       enumtype = make_node (ENUMERAL_TYPE);
5571       pushtag (name, enumtype);
5572     }
5573
5574   C_TYPE_BEING_DEFINED (enumtype) = 1;
5575
5576   if (TYPE_VALUES (enumtype) != 0)
5577     {
5578       /* This enum is a named one that has been declared already.  */
5579       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5580
5581       /* Completely replace its old definition.
5582          The old enumerators remain defined, however.  */
5583       TYPE_VALUES (enumtype) = 0;
5584     }
5585
5586   enum_next_value = integer_zero_node;
5587   enum_overflow = 0;
5588
5589   if (flag_short_enums)
5590     TYPE_PACKED (enumtype) = 1;
5591
5592   return enumtype;
5593 }
5594
5595 /* After processing and defining all the values of an enumeration type,
5596    install their decls in the enumeration type and finish it off.
5597    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5598    and ATTRIBUTES are the specified attributes.
5599    Returns ENUMTYPE.  */
5600
5601 tree
5602 finish_enum (enumtype, values, attributes)
5603      tree enumtype;
5604      tree values;
5605      tree attributes;
5606 {
5607   register tree pair, tem;
5608   tree minnode = 0, maxnode = 0, enum_value_type;
5609   int precision, unsign;
5610   int toplevel = (global_binding_level == current_binding_level);
5611
5612   if (in_parm_level_p ())
5613     warning ("enum defined inside parms");
5614
5615   decl_attributes (enumtype, attributes, NULL_TREE);
5616
5617   /* Calculate the maximum value of any enumerator in this type.  */
5618
5619   if (values == error_mark_node)
5620     minnode = maxnode = integer_zero_node;
5621   else
5622     {
5623       minnode = maxnode = TREE_VALUE (values);
5624       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5625         {
5626           tree value = TREE_VALUE (pair);
5627           if (tree_int_cst_lt (maxnode, value))
5628             maxnode = value;
5629           if (tree_int_cst_lt (value, minnode))
5630             minnode = value;
5631         }
5632     }
5633
5634   /* Construct the final type of this enumeration.  It is the same
5635      as one of the integral types - the narrowest one that fits, except
5636      that normally we only go as narrow as int - and signed iff any of
5637      the values are negative.  */
5638   unsign = (tree_int_cst_sgn (minnode) >= 0);
5639   precision = MAX (min_precision (minnode, unsign),
5640                    min_precision (maxnode, unsign));
5641   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5642     {
5643       tree narrowest = type_for_size (precision, unsign);
5644       if (narrowest == 0)
5645         {
5646           warning ("enumeration values exceed range of largest integer");
5647           narrowest = long_long_integer_type_node;
5648         }
5649
5650       precision = TYPE_PRECISION (narrowest);
5651     }
5652   else
5653     precision = TYPE_PRECISION (integer_type_node);
5654
5655   if (precision == TYPE_PRECISION (integer_type_node))
5656     enum_value_type = type_for_size (precision, 0);
5657   else
5658     enum_value_type = enumtype;
5659
5660   TYPE_MIN_VALUE (enumtype) = minnode;
5661   TYPE_MAX_VALUE (enumtype) = maxnode;
5662   TYPE_PRECISION (enumtype) = precision;
5663   TREE_UNSIGNED (enumtype) = unsign;
5664   TYPE_SIZE (enumtype) = 0;
5665   layout_type (enumtype);
5666
5667   if (values != error_mark_node)
5668     {
5669       /* Change the type of the enumerators to be the enum type.  We
5670          need to do this irrespective of the size of the enum, for
5671          proper type checking.  Replace the DECL_INITIALs of the
5672          enumerators, and the value slots of the list, with copies
5673          that have the enum type; they cannot be modified in place
5674          because they may be shared (e.g.  integer_zero_node) Finally,
5675          change the purpose slots to point to the names of the decls.  */
5676       for (pair = values; pair; pair = TREE_CHAIN (pair))
5677         {
5678           tree enu = TREE_PURPOSE (pair);
5679
5680           TREE_TYPE (enu) = enumtype;
5681           DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5682           DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5683           DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5684           DECL_USER_ALIGN (enu) = TYPE_USER_ALIGN (enumtype);
5685           DECL_MODE (enu) = TYPE_MODE (enumtype);
5686
5687           /* The ISO C Standard mandates enumerators to have type int,
5688              even though the underlying type of an enum type is
5689              unspecified.  Here we convert any enumerators that fit in
5690              an int to type int, to avoid promotions to unsigned types
5691              when comparing integers with enumerators that fit in the
5692              int range.  When -pedantic is given, build_enumerator()
5693              would have already taken care of those that don't fit.  */
5694           if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5695             DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5696           else
5697             DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5698
5699           TREE_PURPOSE (pair) = DECL_NAME (enu);
5700           TREE_VALUE (pair) = DECL_INITIAL (enu);
5701         }
5702
5703       TYPE_VALUES (enumtype) = values;
5704     }
5705
5706   /* Fix up all variant types of this enum type.  */
5707   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5708     {
5709       if (tem == enumtype)
5710         continue;
5711       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5712       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5713       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5714       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5715       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5716       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5717       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5718       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5719       TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5720       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5721     }
5722
5723   /* Finish debugging output for this type.  */
5724   rest_of_type_compilation (enumtype, toplevel);
5725
5726   return enumtype;
5727 }
5728
5729 /* Build and install a CONST_DECL for one value of the
5730    current enumeration type (one that was begun with start_enum).
5731    Return a tree-list containing the CONST_DECL and its value.
5732    Assignment of sequential values by default is handled here.  */
5733
5734 tree
5735 build_enumerator (name, value)
5736      tree name, value;
5737 {
5738   register tree decl, type;
5739
5740   /* Validate and default VALUE.  */
5741
5742   /* Remove no-op casts from the value.  */
5743   if (value)
5744     STRIP_TYPE_NOPS (value);
5745
5746   if (value != 0)
5747     {
5748       if (TREE_CODE (value) == INTEGER_CST)
5749         {
5750           value = default_conversion (value);
5751           constant_expression_warning (value);
5752         }
5753       else
5754         {
5755           error ("enumerator value for `%s' not integer constant",
5756                  IDENTIFIER_POINTER (name));
5757           value = 0;
5758         }
5759     }
5760
5761   /* Default based on previous value.  */
5762   /* It should no longer be possible to have NON_LVALUE_EXPR
5763      in the default.  */
5764   if (value == 0)
5765     {
5766       value = enum_next_value;
5767       if (enum_overflow)
5768         error ("overflow in enumeration values");
5769     }
5770
5771   if (pedantic && ! int_fits_type_p (value, integer_type_node))
5772     {
5773       pedwarn ("ISO C restricts enumerator values to range of `int'");
5774       value = convert (integer_type_node, value);
5775     }
5776
5777   /* Set basis for default for next value.  */
5778   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5779   enum_overflow = tree_int_cst_lt (enum_next_value, value);
5780
5781   /* Now create a declaration for the enum value name.  */
5782
5783   type = TREE_TYPE (value);
5784   type = type_for_size (MAX (TYPE_PRECISION (type),
5785                              TYPE_PRECISION (integer_type_node)),
5786                         ((flag_traditional
5787                           || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
5788                          && TREE_UNSIGNED (type)));
5789
5790   decl = build_decl (CONST_DECL, name, type);
5791   DECL_INITIAL (decl) = convert (type, value);
5792   pushdecl (decl);
5793
5794   return tree_cons (decl, value, NULL_TREE);
5795 }
5796
5797 \f
5798 /* Create the FUNCTION_DECL for a function definition.
5799    DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of
5800    the declaration; they describe the function's name and the type it returns,
5801    but twisted together in a fashion that parallels the syntax of C.
5802
5803    This function creates a binding context for the function body
5804    as well as setting up the FUNCTION_DECL in current_function_decl.
5805
5806    Returns 1 on success.  If the DECLARATOR is not suitable for a function
5807    (it defines a datum instead), we return 0, which tells
5808    yyparse to report a parse error.  */
5809
5810 int
5811 start_function (declspecs, declarator, prefix_attributes, attributes)
5812      tree declarator, declspecs, prefix_attributes, attributes;
5813 {
5814   tree decl1, old_decl;
5815   tree restype;
5816   int old_immediate_size_expand = immediate_size_expand;
5817
5818   current_function_returns_value = 0;  /* Assume, until we see it does.  */
5819   current_function_returns_null = 0;
5820   warn_about_return_type = 0;
5821   current_extern_inline = 0;
5822   c_function_varargs = 0;
5823   named_labels = 0;
5824   shadowed_labels = 0;
5825
5826   /* Don't expand any sizes in the return type of the function.  */
5827   immediate_size_expand = 0;
5828
5829   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5830
5831   /* If the declarator is not suitable for a function definition,
5832      cause a syntax error.  */
5833   if (decl1 == 0)
5834     {
5835       immediate_size_expand = old_immediate_size_expand;
5836       return 0;
5837     }
5838
5839   decl_attributes (decl1, prefix_attributes, attributes);
5840
5841   announce_function (decl1);
5842
5843   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
5844     {
5845       error ("return type is an incomplete type");
5846       /* Make it return void instead.  */
5847       TREE_TYPE (decl1)
5848         = build_function_type (void_type_node,
5849                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5850     }
5851
5852   if (warn_about_return_type)
5853     pedwarn_c99 ("return type defaults to `int'");
5854
5855   /* Save the parm names or decls from this function's declarator
5856      where store_parm_decls will find them.  */
5857   current_function_parms = last_function_parms;
5858   current_function_parm_tags = last_function_parm_tags;
5859
5860   /* Make the init_value nonzero so pushdecl knows this is not tentative.
5861      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
5862   DECL_INITIAL (decl1) = error_mark_node;
5863
5864   /* If this definition isn't a prototype and we had a prototype declaration
5865      before, copy the arg type info from that prototype.
5866      But not if what we had before was a builtin function.  */
5867   old_decl = lookup_name_current_level (DECL_NAME (decl1));
5868   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5869       && !DECL_BUILT_IN (old_decl)
5870       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5871           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5872       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5873     {
5874       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5875       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
5876       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
5877     }
5878
5879   /* If there is no explicit declaration, look for any out-of-scope implicit
5880      declarations.  */
5881   if (old_decl == 0)
5882     old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
5883
5884   /* Optionally warn of old-fashioned def with no previous prototype.  */
5885   if (warn_strict_prototypes
5886       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5887       && !(old_decl != 0
5888            && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
5889                || (DECL_BUILT_IN (old_decl)
5890                    && ! C_DECL_ANTICIPATED (old_decl)))))
5891     warning ("function declaration isn't a prototype");
5892   /* Optionally warn of any global def with no previous prototype.  */
5893   else if (warn_missing_prototypes
5894            && TREE_PUBLIC (decl1)
5895            && !(old_decl != 0
5896                 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
5897                     || (DECL_BUILT_IN (old_decl)
5898                         && ! C_DECL_ANTICIPATED (old_decl))))
5899            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5900     warning_with_decl (decl1, "no previous prototype for `%s'");
5901   /* Optionally warn of any def with no previous prototype
5902      if the function has already been used.  */
5903   else if (warn_missing_prototypes
5904            && old_decl != 0 && TREE_USED (old_decl)
5905            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
5906     warning_with_decl (decl1,
5907                        "`%s' was used with no prototype before its definition");
5908   /* Optionally warn of any global def with no previous declaration.  */
5909   else if (warn_missing_declarations
5910            && TREE_PUBLIC (decl1)
5911            && old_decl == 0
5912            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5913     warning_with_decl (decl1, "no previous declaration for `%s'");
5914   /* Optionally warn of any def with no previous declaration
5915      if the function has already been used.  */
5916   else if (warn_missing_declarations
5917            && old_decl != 0 && TREE_USED (old_decl)
5918            && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
5919     warning_with_decl (decl1,
5920                        "`%s' was used with no declaration before its definition");
5921
5922   /* This is a definition, not a reference.
5923      So normally clear DECL_EXTERNAL.
5924      However, `extern inline' acts like a declaration
5925      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
5926   DECL_EXTERNAL (decl1) = current_extern_inline;
5927
5928 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
5929   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attributes);
5930 #endif
5931
5932   /* This function exists in static storage.
5933      (This does not mean `static' in the C sense!)  */
5934   TREE_STATIC (decl1) = 1;
5935
5936   /* A nested function is not global.  */
5937   if (current_function_decl != 0)
5938     TREE_PUBLIC (decl1) = 0;
5939
5940   /* Warn for unlikely, improbable, or stupid declarations of `main'.  */
5941   if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
5942     {
5943       tree args;
5944       int argct = 0;
5945
5946       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5947           != integer_type_node)
5948         pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
5949
5950       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
5951            args = TREE_CHAIN (args))
5952         {
5953           tree type = args ? TREE_VALUE (args) : 0;
5954
5955           if (type == void_type_node)
5956             break;
5957
5958           ++argct;
5959           switch (argct)
5960             {
5961             case 1:
5962               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
5963                 pedwarn_with_decl (decl1,
5964                                    "first argument of `%s' should be `int'");
5965               break;
5966
5967             case 2:
5968               if (TREE_CODE (type) != POINTER_TYPE
5969                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5970                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5971                       != char_type_node))
5972                 pedwarn_with_decl (decl1,
5973                                    "second argument of `%s' should be `char **'");
5974               break;
5975
5976             case 3:
5977               if (TREE_CODE (type) != POINTER_TYPE
5978                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5979                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5980                       != char_type_node))
5981                 pedwarn_with_decl (decl1,
5982                                    "third argument of `%s' should probably be `char **'");
5983               break;
5984             }
5985         }
5986
5987       /* It is intentional that this message does not mention the third
5988          argument because it's only mentioned in an appendix of the
5989          standard.  */
5990       if (argct > 0 && (argct < 2 || argct > 3))
5991         pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
5992
5993       if (! TREE_PUBLIC (decl1))
5994         pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
5995     }
5996
5997   /* Record the decl so that the function name is defined.
5998      If we already have a decl for this name, and it is a FUNCTION_DECL,
5999      use the old decl.  */
6000
6001   current_function_decl = pushdecl (decl1);
6002
6003   pushlevel (0);
6004   declare_parm_level (1);
6005   current_binding_level->subblocks_tag_transparent = 1;
6006
6007   make_decl_rtl (current_function_decl, NULL);
6008
6009   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6010   /* Promote the value to int before returning it.  */
6011   if (C_PROMOTING_INTEGER_TYPE_P (restype))
6012     {
6013       /* It retains unsignedness if traditional
6014          or if not really getting wider.  */
6015       if (TREE_UNSIGNED (restype)
6016           && (flag_traditional
6017               || (TYPE_PRECISION (restype)
6018                   == TYPE_PRECISION (integer_type_node))))
6019         restype = unsigned_type_node;
6020       else
6021         restype = integer_type_node;
6022     }
6023   DECL_RESULT (current_function_decl)
6024     = build_decl (RESULT_DECL, NULL_TREE, restype);
6025
6026   /* If this fcn was already referenced via a block-scope `extern' decl
6027      (or an implicit decl), propagate certain information about the usage.  */
6028   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6029     TREE_ADDRESSABLE (current_function_decl) = 1;
6030
6031   immediate_size_expand = old_immediate_size_expand;
6032
6033   return 1;
6034 }
6035
6036 /* Record that this function is going to be a varargs function.
6037    This is called before store_parm_decls, which is too early
6038    to call mark_varargs directly.  */
6039
6040 void
6041 c_mark_varargs ()
6042 {
6043   c_function_varargs = 1;
6044 }
6045 \f
6046 /* Store the parameter declarations into the current function declaration.
6047    This is called after parsing the parameter declarations, before
6048    digesting the body of the function.
6049
6050    For an old-style definition, modify the function's type
6051    to specify at least the number of arguments.  */
6052
6053 void
6054 store_parm_decls ()
6055 {
6056   register tree fndecl = current_function_decl;
6057   register tree parm;
6058
6059   /* This is either a chain of PARM_DECLs (if a prototype was used)
6060      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
6061   tree specparms = current_function_parms;
6062
6063   /* This is a list of types declared among parms in a prototype.  */
6064   tree parmtags = current_function_parm_tags;
6065
6066   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
6067   register tree parmdecls = getdecls ();
6068
6069   /* This is a chain of any other decls that came in among the parm
6070      declarations.  If a parm is declared with  enum {foo, bar} x;
6071      then CONST_DECLs for foo and bar are put here.  */
6072   tree nonparms = 0;
6073
6074   /* Nonzero if this definition is written with a prototype.  */
6075   int prototype = 0;
6076
6077   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6078     {
6079       /* This case is when the function was defined with an ANSI prototype.
6080          The parms already have decls, so we need not do anything here
6081          except record them as in effect
6082          and complain if any redundant old-style parm decls were written.  */
6083
6084       register tree next;
6085       tree others = 0;
6086
6087       prototype = 1;
6088
6089       if (parmdecls != 0)
6090         {
6091           tree decl, link;
6092
6093           error_with_decl (fndecl,
6094                            "parm types given both in parmlist and separately");
6095           /* Get rid of the erroneous decls; don't keep them on
6096              the list of parms, since they might not be PARM_DECLs.  */
6097           for (decl = current_binding_level->names;
6098                decl; decl = TREE_CHAIN (decl))
6099             if (DECL_NAME (decl))
6100               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6101           for (link = current_binding_level->shadowed;
6102                link; link = TREE_CHAIN (link))
6103             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6104           current_binding_level->names = 0;
6105           current_binding_level->shadowed = 0;
6106         }
6107
6108       specparms = nreverse (specparms);
6109       for (parm = specparms; parm; parm = next)
6110         {
6111           next = TREE_CHAIN (parm);
6112           if (TREE_CODE (parm) == PARM_DECL)
6113             {
6114               if (DECL_NAME (parm) == 0)
6115                 error_with_decl (parm, "parameter name omitted");
6116               else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
6117                        && VOID_TYPE_P (TREE_TYPE (parm)))
6118                 {
6119                   error_with_decl (parm, "parameter `%s' declared void");
6120                   /* Change the type to error_mark_node so this parameter
6121                      will be ignored by assign_parms.  */
6122                   TREE_TYPE (parm) = error_mark_node;
6123                 }
6124               pushdecl (parm);
6125             }
6126           else
6127             {
6128               /* If we find an enum constant or a type tag,
6129                  put it aside for the moment.  */
6130               TREE_CHAIN (parm) = 0;
6131               others = chainon (others, parm);
6132             }
6133         }
6134
6135       /* Get the decls in their original chain order
6136          and record in the function.  */
6137       DECL_ARGUMENTS (fndecl) = getdecls ();
6138
6139 #if 0
6140       /* If this function takes a variable number of arguments,
6141          add a phony parameter to the end of the parm list,
6142          to represent the position of the first unnamed argument.  */
6143       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6144           != void_type_node)
6145         {
6146           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6147           /* Let's hope the address of the unnamed parm
6148              won't depend on its type.  */
6149           TREE_TYPE (dummy) = integer_type_node;
6150           DECL_ARG_TYPE (dummy) = integer_type_node;
6151           DECL_ARGUMENTS (fndecl) = chainon (DECL_ARGUMENTS (fndecl), dummy);
6152         }
6153 #endif
6154
6155       /* Now pushdecl the enum constants.  */
6156       for (parm = others; parm; parm = next)
6157         {
6158           next = TREE_CHAIN (parm);
6159           if (DECL_NAME (parm) == 0)
6160             ;
6161           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6162             ;
6163           else if (TREE_CODE (parm) != PARM_DECL)
6164             pushdecl (parm);
6165         }
6166
6167       storetags (chainon (parmtags, gettags ()));
6168     }
6169   else
6170     {
6171       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6172          each with a parm name as the TREE_VALUE.
6173
6174          PARMDECLS is a chain of declarations for parameters.
6175          Warning! It can also contain CONST_DECLs which are not parameters
6176          but are names of enumerators of any enum types
6177          declared among the parameters.
6178
6179          First match each formal parameter name with its declaration.
6180          Associate decls with the names and store the decls
6181          into the TREE_PURPOSE slots.  */
6182
6183       /* We use DECL_WEAK as a flag to show which parameters have been
6184          seen already since it is not used on PARM_DECL or CONST_DECL.  */
6185       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6186         DECL_WEAK (parm) = 0;
6187
6188       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6189         {
6190           register tree tail, found = NULL;
6191
6192           if (TREE_VALUE (parm) == 0)
6193             {
6194               error_with_decl (fndecl,
6195                                "parameter name missing from parameter list");
6196               TREE_PURPOSE (parm) = 0;
6197               continue;
6198             }
6199
6200           /* See if any of the parmdecls specifies this parm by name.
6201              Ignore any enumerator decls.  */
6202           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6203             if (DECL_NAME (tail) == TREE_VALUE (parm)
6204                 && TREE_CODE (tail) == PARM_DECL)
6205               {
6206                 found = tail;
6207                 break;
6208               }
6209
6210           /* If declaration already marked, we have a duplicate name.
6211              Complain, and don't use this decl twice.   */
6212           if (found && DECL_WEAK (found))
6213             {
6214               error_with_decl (found, "multiple parameters named `%s'");
6215               found = 0;
6216             }
6217
6218           /* If the declaration says "void", complain and ignore it.  */
6219           if (found && VOID_TYPE_P (TREE_TYPE (found)))
6220             {
6221               error_with_decl (found, "parameter `%s' declared void");
6222               TREE_TYPE (found) = integer_type_node;
6223               DECL_ARG_TYPE (found) = integer_type_node;
6224               layout_decl (found, 0);
6225             }
6226
6227           /* Traditionally, a parm declared float is actually a double.  */
6228           if (found && flag_traditional
6229               && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6230             {
6231               TREE_TYPE (found) = double_type_node;
6232               DECL_ARG_TYPE (found) = double_type_node;
6233               layout_decl (found, 0);
6234             }
6235
6236           /* If no declaration found, default to int.  */
6237           if (!found)
6238             {
6239               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6240                                   integer_type_node);
6241               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6242               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6243               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6244               if (flag_isoc99)
6245                 pedwarn_with_decl (found, "type of `%s' defaults to `int'");
6246               else if (extra_warnings)
6247                 warning_with_decl (found, "type of `%s' defaults to `int'");
6248               pushdecl (found);
6249             }
6250
6251           TREE_PURPOSE (parm) = found;
6252
6253           /* Mark this decl as "already found".  */
6254           DECL_WEAK (found) = 1;
6255         }
6256
6257       /* Put anything which is on the parmdecls chain and which is
6258          not a PARM_DECL onto the list NONPARMS.  (The types of
6259          non-parm things which might appear on the list include
6260          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6261          any actual PARM_DECLs not matched with any names.  */
6262
6263       nonparms = 0;
6264       for (parm = parmdecls; parm;)
6265         {
6266           tree next = TREE_CHAIN (parm);
6267           TREE_CHAIN (parm) = 0;
6268
6269           if (TREE_CODE (parm) != PARM_DECL)
6270             nonparms = chainon (nonparms, parm);
6271           else
6272             {
6273               /* Complain about args with incomplete types.  */
6274               if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6275                 {
6276                   error_with_decl (parm, "parameter `%s' has incomplete type");
6277                   TREE_TYPE (parm) = error_mark_node;
6278                 }
6279
6280               if (! DECL_WEAK (parm))
6281                 {
6282                   error_with_decl (parm,
6283                                    "declaration for parameter `%s' but no such parameter");
6284                   /* Pretend the parameter was not missing.
6285                      This gets us to a standard state and minimizes
6286                      further error messages.  */
6287                   specparms
6288                     = chainon (specparms,
6289                                tree_cons (parm, NULL_TREE, NULL_TREE));
6290                 }
6291             }
6292
6293           parm = next;
6294         }
6295
6296       /* Chain the declarations together in the order of the list of
6297          names.  Store that chain in the function decl, replacing the
6298          list of names.  */
6299       parm = specparms;
6300       DECL_ARGUMENTS (fndecl) = 0;
6301       {
6302         register tree last;
6303         for (last = 0; parm; parm = TREE_CHAIN (parm))
6304           if (TREE_PURPOSE (parm))
6305             {
6306               if (last == 0)
6307                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6308               else
6309                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6310               last = TREE_PURPOSE (parm);
6311               TREE_CHAIN (last) = 0;
6312             }
6313       }
6314
6315       /* If there was a previous prototype,
6316          set the DECL_ARG_TYPE of each argument according to
6317          the type previously specified, and report any mismatches.  */
6318
6319       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6320         {
6321           register tree type;
6322           for (parm = DECL_ARGUMENTS (fndecl),
6323                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6324                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6325                                  != void_type_node));
6326                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6327             {
6328               if (parm == 0 || type == 0
6329                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6330                 {
6331                   error ("number of arguments doesn't match prototype");
6332                   error_with_file_and_line (current_function_prototype_file,
6333                                             current_function_prototype_line,
6334                                             "prototype declaration");
6335                   break;
6336                 }
6337               /* Type for passing arg must be consistent
6338                  with that declared for the arg.  */
6339               if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6340                 {
6341                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6342                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6343                     {
6344                       /* Adjust argument to match prototype.  E.g. a previous
6345                          `int foo(float);' prototype causes
6346                          `int foo(x) float x; {...}' to be treated like
6347                          `int foo(float x) {...}'.  This is particularly
6348                          useful for argument types like uid_t.  */
6349                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6350
6351                       if (PROMOTE_PROTOTYPES
6352                           && (TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6353                               || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6354                           && TYPE_PRECISION (TREE_TYPE (parm))
6355                           < TYPE_PRECISION (integer_type_node))
6356                         DECL_ARG_TYPE (parm) = integer_type_node;
6357
6358                       if (pedantic)
6359                         {
6360                           pedwarn ("promoted argument `%s' doesn't match prototype",
6361                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6362                           warning_with_file_and_line
6363                             (current_function_prototype_file,
6364                              current_function_prototype_line,
6365                              "prototype declaration");
6366                         }
6367                     }
6368                   /* If -traditional, allow `int' argument to match
6369                      `unsigned' prototype.  */
6370                   else if (! (flag_traditional
6371                               && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6372                               && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6373                     {
6374                       error ("argument `%s' doesn't match prototype",
6375                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6376                       error_with_file_and_line (current_function_prototype_file,
6377                                                 current_function_prototype_line,
6378                                                 "prototype declaration");
6379                     }
6380                 }
6381             }
6382           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6383         }
6384
6385       /* Otherwise, create a prototype that would match.  */
6386
6387       else
6388         {
6389           tree actual = 0, last = 0, type;
6390
6391           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6392             {
6393               type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6394               if (last)
6395                 TREE_CHAIN (last) = type;
6396               else
6397                 actual = type;
6398               last = type;
6399             }
6400           type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6401           if (last)
6402             TREE_CHAIN (last) = type;
6403           else
6404             actual = type;
6405
6406           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6407              of the type of this function, but we need to avoid having this
6408              affect the types of other similarly-typed functions, so we must
6409              first force the generation of an identical (but separate) type
6410              node for the relevant function type.  The new node we create
6411              will be a variant of the main variant of the original function
6412              type.  */
6413
6414           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6415
6416           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6417         }
6418
6419       /* Now store the final chain of decls for the arguments
6420          as the decl-chain of the current lexical scope.
6421          Put the enumerators in as well, at the front so that
6422          DECL_ARGUMENTS is not modified.  */
6423
6424       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6425     }
6426
6427   /* Make sure the binding level for the top of the function body
6428      gets a BLOCK if there are any in the function.
6429      Otherwise, the dbx output is wrong.  */
6430
6431   keep_next_if_subblocks = 1;
6432
6433   /* ??? This might be an improvement,
6434      but needs to be thought about some more.  */
6435 #if 0
6436   keep_next_level_flag = 1;
6437 #endif
6438
6439   /* Write a record describing this function definition to the prototypes
6440      file (if requested).  */
6441
6442   gen_aux_info_record (fndecl, 1, 0, prototype);
6443
6444   /* Initialize the RTL code for the function.  */
6445
6446   init_function_start (fndecl, input_filename, lineno);
6447
6448   /* Begin the statement tree for this function.  */
6449   DECL_LANG_SPECIFIC (current_function_decl)
6450     =((struct lang_decl *) ggc_alloc (sizeof (struct lang_decl)));
6451   begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6452
6453   /* This function is being processed in whole-function mode.  */
6454   cfun->x_whole_function_mode_p = 1;
6455
6456   /* Even though we're inside a function body, we still don't want to
6457      call expand_expr to calculate the size of a variable-sized array.
6458      We haven't necessarily assigned RTL to all variables yet, so it's
6459      not safe to try to expand expressions involving them.  */
6460   immediate_size_expand = 0;
6461   cfun->x_dont_save_pending_sizes_p = 1;
6462 }
6463 \f
6464 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6465    each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
6466    stands for an ellipsis in the identifier list.
6467
6468    PARMLIST is the data returned by get_parm_info for the
6469    parmlist that follows the semicolon.
6470
6471    We return a value of the same sort that get_parm_info returns,
6472    except that it describes the combination of identifiers and parmlist.  */
6473
6474 tree
6475 combine_parm_decls (specparms, parmlist, void_at_end)
6476      tree specparms, parmlist;
6477      int void_at_end;
6478 {
6479   register tree fndecl = current_function_decl;
6480   register tree parm;
6481
6482   tree parmdecls = TREE_PURPOSE (parmlist);
6483
6484   /* This is a chain of any other decls that came in among the parm
6485      declarations.  They were separated already by get_parm_info,
6486      so we just need to keep them separate.  */
6487   tree nonparms = TREE_VALUE (parmlist);
6488
6489   tree types = 0;
6490
6491   for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6492     DECL_WEAK (parm) = 0;
6493
6494   for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6495     {
6496       register tree tail, found = NULL;
6497
6498       /* See if any of the parmdecls specifies this parm by name.  */
6499       for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6500         if (DECL_NAME (tail) == TREE_VALUE (parm))
6501           {
6502             found = tail;
6503             break;
6504           }
6505
6506       /* If declaration already marked, we have a duplicate name.
6507          Complain, and don't use this decl twice.   */
6508       if (found && DECL_WEAK (found))
6509         {
6510           error_with_decl (found, "multiple parameters named `%s'");
6511           found = 0;
6512         }
6513
6514       /* If the declaration says "void", complain and ignore it.  */
6515       if (found && VOID_TYPE_P (TREE_TYPE (found)))
6516         {
6517           error_with_decl (found, "parameter `%s' declared void");
6518           TREE_TYPE (found) = integer_type_node;
6519           DECL_ARG_TYPE (found) = integer_type_node;
6520           layout_decl (found, 0);
6521         }
6522
6523       /* Traditionally, a parm declared float is actually a double.  */
6524       if (found && flag_traditional
6525           && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6526         {
6527           TREE_TYPE (found) = double_type_node;
6528           DECL_ARG_TYPE (found) = double_type_node;
6529           layout_decl (found, 0);
6530         }
6531
6532       /* If no declaration found, default to int.  */
6533       if (!found)
6534         {
6535           found = build_decl (PARM_DECL, TREE_VALUE (parm),
6536                               integer_type_node);
6537           DECL_ARG_TYPE (found) = TREE_TYPE (found);
6538           DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6539           DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6540           error_with_decl (found, "type of parameter `%s' is not declared");
6541           pushdecl (found);
6542         }
6543
6544       TREE_PURPOSE (parm) = found;
6545
6546       /* Mark this decl as "already found".  */
6547       DECL_WEAK (found) = 1;
6548     }
6549
6550   /* Complain about any actual PARM_DECLs not matched with any names.  */
6551
6552   for (parm = parmdecls; parm;)
6553     {
6554       tree next = TREE_CHAIN (parm);
6555       TREE_CHAIN (parm) = 0;
6556
6557       /* Complain about args with incomplete types.  */
6558       if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6559         {
6560           error_with_decl (parm, "parameter `%s' has incomplete type");
6561           TREE_TYPE (parm) = error_mark_node;
6562         }
6563
6564       if (! DECL_WEAK (parm))
6565         {
6566           error_with_decl (parm,
6567                            "declaration for parameter `%s' but no such parameter");
6568           /* Pretend the parameter was not missing.
6569              This gets us to a standard state and minimizes
6570              further error messages.  */
6571           specparms
6572             = chainon (specparms,
6573                        tree_cons (parm, NULL_TREE, NULL_TREE));
6574         }
6575
6576       parm = next;
6577     }
6578
6579   /* Chain the declarations together in the order of the list of names.
6580      At the same time, build up a list of their types, in reverse order.  */
6581
6582   parm = specparms;
6583   parmdecls = 0;
6584   {
6585     register tree last;
6586     for (last = 0; parm; parm = TREE_CHAIN (parm))
6587       if (TREE_PURPOSE (parm))
6588         {
6589           if (last == 0)
6590             parmdecls = TREE_PURPOSE (parm);
6591           else
6592             TREE_CHAIN (last) = TREE_PURPOSE (parm);
6593           last = TREE_PURPOSE (parm);
6594           TREE_CHAIN (last) = 0;
6595
6596           types = tree_cons (NULL_TREE, TREE_TYPE (parm), types);
6597         }
6598   }
6599
6600   if (void_at_end)
6601     return tree_cons (parmdecls, nonparms,
6602                       nreverse (tree_cons (NULL_TREE, void_type_node, types)));
6603
6604   return tree_cons (parmdecls, nonparms, nreverse (types));
6605 }
6606 \f
6607 /* Finish up a function declaration and compile that function
6608    all the way to assembler language output.  The free the storage
6609    for the function definition.
6610
6611    This is called after parsing the body of the function definition.
6612
6613    NESTED is nonzero if the function being finished is nested in another.  */
6614
6615 void
6616 finish_function (nested)
6617      int nested;
6618 {
6619   register tree fndecl = current_function_decl;
6620
6621 /*  TREE_READONLY (fndecl) = 1;
6622     This caused &foo to be of type ptr-to-const-function
6623     which then got a warning when stored in a ptr-to-function variable.  */
6624
6625   poplevel (1, 0, 1);
6626   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6627
6628   /* Must mark the RESULT_DECL as being in this function.  */
6629
6630   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6631
6632   /* Obey `register' declarations if `setjmp' is called in this fn.  */
6633   if (flag_traditional && current_function_calls_setjmp)
6634     {
6635       setjmp_protect (DECL_INITIAL (fndecl));
6636       setjmp_protect_args ();
6637     }
6638
6639   if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6640     {
6641       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6642           != integer_type_node)
6643         {
6644           /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6645              If warn_main is -1 (-Wno-main) we don't want to be warned.  */
6646           if (! warn_main)
6647             pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6648         }
6649       else
6650         {
6651 #ifdef DEFAULT_MAIN_RETURN
6652           /* Make it so that `main' always returns success by default.  */
6653           DEFAULT_MAIN_RETURN;
6654 #else
6655           if (flag_isoc99)
6656             c_expand_return (integer_zero_node);
6657 #endif
6658         }
6659     }
6660
6661   /* Tie off the statement tree for this function.  */
6662   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6663   /* Clear out memory we no longer need.  */
6664   free_after_parsing (cfun);
6665   /* Since we never call rest_of_compilation, we never clear
6666      CFUN.  Do so explicitly.  */
6667   free_after_compilation (cfun);
6668   cfun = NULL;
6669
6670   if (! nested)
6671     {
6672       /* Generate RTL for the body of this function.  */
6673       c_expand_body (fndecl, nested);
6674       /* Let the error reporting routines know that we're outside a
6675          function.  For a nested function, this value is used in
6676          pop_c_function_context and then reset via pop_function_context.  */
6677       current_function_decl = NULL;
6678       c_function_name_declared_p = 0;
6679     }
6680 }
6681
6682 /* Generate the RTL for the body of FNDECL.  If NESTED_P is non-zero,
6683    then we are already in the process of generating RTL for another
6684    function.  */
6685
6686 static void
6687 c_expand_body (fndecl, nested_p)
6688      tree fndecl;
6689      int nested_p;
6690 {
6691   /* There's no reason to do any of the work here if we're only doing
6692      semantic analysis; this code just generates RTL.  */
6693   if (flag_syntax_only)
6694     return;
6695
6696   /* Squirrel away our current state.  */
6697   if (nested_p)
6698     push_function_context ();
6699
6700   /* Initialize the RTL code for the function.  */
6701   current_function_decl = fndecl;
6702   init_function_start (fndecl, input_filename, DECL_SOURCE_LINE (fndecl));
6703
6704   /* This function is being processed in whole-function mode.  */
6705   cfun->x_whole_function_mode_p = 1;
6706
6707   /* Even though we're inside a function body, we still don't want to
6708      call expand_expr to calculate the size of a variable-sized array.
6709      We haven't necessarily assigned RTL to all variables yet, so it's
6710      not safe to try to expand expressions involving them.  */
6711   immediate_size_expand = 0;
6712   cfun->x_dont_save_pending_sizes_p = 1;
6713
6714   /* If this is a varargs function, inform function.c.  */
6715   if (c_function_varargs)
6716     mark_varargs ();
6717
6718   /* Set up parameters and prepare for return, for the function.  */
6719   expand_function_start (fndecl, 0);
6720
6721   /* If this function is `main', emit a call to `__main'
6722      to run global initializers, etc.  */
6723   if (DECL_NAME (fndecl)
6724       && MAIN_NAME_P (DECL_NAME (fndecl))
6725       && DECL_CONTEXT (fndecl) == NULL_TREE)
6726     expand_main_function ();
6727
6728   /* Generate the RTL for this function.  */
6729   expand_stmt (DECL_SAVED_TREE (fndecl));
6730   /* Allow the body of the function to be garbage collected.  */
6731   DECL_SAVED_TREE (fndecl) = NULL_TREE;
6732
6733   /* We hard-wired immediate_size_expand to zero in start_function.
6734      expand_function_end will decrement this variable.  So, we set the
6735      variable to one here, so that after the decrement it will remain
6736      zero.  */
6737   immediate_size_expand = 1;
6738
6739   /* Allow language dialects to perform special processing.  */
6740   if (lang_expand_function_end)
6741     (*lang_expand_function_end) ();
6742
6743   /* Generate rtl for function exit.  */
6744   expand_function_end (input_filename, lineno, 0);
6745
6746   /* If this is a nested function, protect the local variables in the stack
6747      above us from being collected while we're compiling this function.  */
6748   if (nested_p)
6749     ggc_push_context ();
6750
6751   /* Run the optimizers and output the assembler code for this function.  */
6752   rest_of_compilation (fndecl);
6753
6754   /* Undo the GC context switch.  */
6755   if (nested_p)
6756     ggc_pop_context ();
6757
6758   /* With just -W, complain only if function returns both with
6759      and without a value.  */
6760   if (extra_warnings
6761       && current_function_returns_value
6762       && current_function_returns_null)
6763     warning ("this function may return with or without a value");
6764
6765   /* If requested, warn about function definitions where the function will
6766      return a value (usually of some struct or union type) which itself will
6767      take up a lot of stack space.  */
6768
6769   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6770     {
6771       tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6772
6773       if (ret_type && TYPE_SIZE_UNIT (ret_type)
6774           && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
6775           && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
6776                                    larger_than_size))
6777         {
6778           unsigned int size_as_int
6779             = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
6780
6781           if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
6782             warning_with_decl (fndecl,
6783                                "size of return value of `%s' is %u bytes",
6784                                size_as_int);
6785           else
6786             warning_with_decl (fndecl,
6787                                "size of return value of `%s' is larger than %d bytes",
6788                                larger_than_size);
6789         }
6790     }
6791
6792   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p)
6793     {
6794       /* Stop pointing to the local nodes about to be freed.
6795          But DECL_INITIAL must remain nonzero so we know this
6796          was an actual function definition.
6797          For a nested function, this is done in pop_c_function_context.
6798          If rest_of_compilation set this to 0, leave it 0.  */
6799       if (DECL_INITIAL (fndecl) != 0)
6800         DECL_INITIAL (fndecl) = error_mark_node;
6801
6802       DECL_ARGUMENTS (fndecl) = 0;
6803     }
6804
6805   if (DECL_STATIC_CONSTRUCTOR (fndecl))
6806     {
6807 #ifndef ASM_OUTPUT_CONSTRUCTOR
6808       if (! flag_gnu_linker)
6809         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6810       else
6811 #endif
6812         assemble_constructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
6813
6814     }
6815   if (DECL_STATIC_DESTRUCTOR (fndecl))
6816     {
6817 #ifndef ASM_OUTPUT_DESTRUCTOR
6818       if (! flag_gnu_linker)
6819         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6820       else
6821 #endif
6822         assemble_destructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
6823     }
6824
6825   if (nested_p)
6826     {
6827       /* Return to the enclosing function.  */
6828       pop_function_context ();
6829       /* If the nested function was inline, write it out if that is
6830          necessary.  */
6831       if (!TREE_ASM_WRITTEN (fndecl) && TREE_ADDRESSABLE (fndecl))
6832         {
6833           push_function_context ();
6834           output_inline_function (fndecl);
6835           pop_function_context ();
6836         }
6837     }
6838
6839 }
6840 \f
6841 /* Check the declarations given in a for-loop for satisfying the C99
6842    constraints.  */
6843 void
6844 check_for_loop_decls ()
6845 {
6846   tree t;
6847
6848   if (!flag_isoc99)
6849     {
6850       /* If we get here, declarations have been used in a for loop without
6851          the C99 for loop scope.  This doesn't make much sense, so don't
6852          allow it.  */
6853       error ("`for' loop initial declaration used outside C99 mode");
6854       return;
6855     }
6856   /* C99 subclause 6.8.5 paragraph 3:
6857
6858        [#3]  The  declaration  part  of  a for statement shall only
6859        declare identifiers for objects having storage class auto or
6860        register.
6861
6862      It isn't clear whether, in this sentence, "identifiers" binds to
6863      "shall only declare" or to "objects" - that is, whether all identifiers
6864      declared must be identifiers for objects, or whether the restriction
6865      only applies to those that are.  (A question on this in comp.std.c
6866      in November 2000 received no answer.)  We implement the strictest
6867      interpretation, to avoid creating an extension which later causes
6868      problems.  */
6869
6870   for (t = gettags (); t; t = TREE_CHAIN (t))
6871     {
6872       if (TREE_PURPOSE (t) != 0)
6873         error ("`%s %s' declared in `for' loop initial declaration",
6874                (TREE_CODE (TREE_VALUE (t)) == RECORD_TYPE ? "struct"
6875                 : TREE_CODE (TREE_VALUE (t)) == UNION_TYPE ? "union"
6876                 : "enum"),
6877                IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6878     }
6879   for (t = getdecls (); t; t = TREE_CHAIN (t))
6880     {
6881       if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
6882         error_with_decl (t, "declaration of non-variable `%s' in `for' loop initial declaration");
6883       else if (TREE_STATIC (t))
6884         error_with_decl (t, "declaration of static variable `%s' in `for' loop initial declaration");
6885       else if (DECL_EXTERNAL (t))
6886         error_with_decl (t, "declaration of `extern' variable `%s' in `for' loop initial declaration");
6887     }
6888 }
6889 \f
6890 /* Save and restore the variables in this file and elsewhere
6891    that keep track of the progress of compilation of the current function.
6892    Used for nested functions.  */
6893
6894 struct c_language_function
6895 {
6896   struct language_function base;
6897   tree named_labels;
6898   tree shadowed_labels;
6899   int returns_value;
6900   int returns_null;
6901   int warn_about_return_type;
6902   int extern_inline;
6903   struct binding_level *binding_level;
6904 };
6905
6906 /* Save and reinitialize the variables
6907    used during compilation of a C function.  */
6908
6909 void
6910 push_c_function_context (f)
6911      struct function *f;
6912 {
6913   struct c_language_function *p;
6914   p = ((struct c_language_function *)
6915        xmalloc (sizeof (struct c_language_function)));
6916   f->language = (struct language_function *) p;
6917
6918   p->base.x_stmt_tree = c_stmt_tree;
6919   p->base.x_scope_stmt_stack = c_scope_stmt_stack;
6920   p->base.x_function_name_declared_p = c_function_name_declared_p;
6921   p->named_labels = named_labels;
6922   p->shadowed_labels = shadowed_labels;
6923   p->returns_value = current_function_returns_value;
6924   p->returns_null = current_function_returns_null;
6925   p->warn_about_return_type = warn_about_return_type;
6926   p->extern_inline = current_extern_inline;
6927   p->binding_level = current_binding_level;
6928 }
6929
6930 /* Restore the variables used during compilation of a C function.  */
6931
6932 void
6933 pop_c_function_context (f)
6934      struct function *f;
6935 {
6936   struct c_language_function *p
6937     = (struct c_language_function *) f->language;
6938   tree link;
6939
6940   /* Bring back all the labels that were shadowed.  */
6941   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
6942     if (DECL_NAME (TREE_VALUE (link)) != 0)
6943       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
6944         = TREE_VALUE (link);
6945
6946   if (DECL_SAVED_INSNS (current_function_decl) == 0
6947       && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6948     {
6949       /* Stop pointing to the local nodes about to be freed.  */
6950       /* But DECL_INITIAL must remain nonzero so we know this
6951          was an actual function definition.  */
6952       DECL_INITIAL (current_function_decl) = error_mark_node;
6953       DECL_ARGUMENTS (current_function_decl) = 0;
6954     }
6955
6956   c_stmt_tree = p->base.x_stmt_tree;
6957   c_scope_stmt_stack = p->base.x_scope_stmt_stack;
6958   c_function_name_declared_p = p->base.x_function_name_declared_p;
6959   named_labels = p->named_labels;
6960   shadowed_labels = p->shadowed_labels;
6961   current_function_returns_value = p->returns_value;
6962   current_function_returns_null = p->returns_null;
6963   warn_about_return_type = p->warn_about_return_type;
6964   current_extern_inline = p->extern_inline;
6965   current_binding_level = p->binding_level;
6966
6967   free (p);
6968   f->language = 0;
6969 }
6970
6971 /* Mark the language specific parts of F for GC.  */
6972
6973 void
6974 mark_c_function_context (f)
6975      struct function *f;
6976 {
6977   struct c_language_function *p
6978     = (struct c_language_function *) f->language;
6979
6980   if (p == 0)
6981     return;
6982
6983   mark_c_language_function (&p->base);
6984   ggc_mark_tree (p->shadowed_labels);
6985   ggc_mark_tree (p->named_labels);
6986   mark_binding_level (&p->binding_level);
6987 }
6988
6989 /* Copy the DECL_LANG_SEPECIFIC data associated with NODE.  */
6990
6991 void
6992 copy_lang_decl (decl)
6993      tree decl;
6994 {
6995   struct lang_decl *ld;
6996
6997   if (!DECL_LANG_SPECIFIC (decl))
6998     return;
6999
7000   ld = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl));
7001   memcpy ((char *) ld, (char *) DECL_LANG_SPECIFIC (decl),
7002           sizeof (struct lang_decl));
7003   DECL_LANG_SPECIFIC (decl) = ld;
7004 }
7005
7006 /* Mark the language specific bits in T for GC.  */
7007
7008 void
7009 lang_mark_tree (t)
7010      tree t;
7011 {
7012   if (TREE_CODE (t) == IDENTIFIER_NODE)
7013     {
7014       struct lang_identifier *i = (struct lang_identifier *) t;
7015       ggc_mark_tree (i->global_value);
7016       ggc_mark_tree (i->local_value);
7017       ggc_mark_tree (i->label_value);
7018       ggc_mark_tree (i->implicit_decl);
7019       ggc_mark_tree (i->error_locus);
7020       ggc_mark_tree (i->limbo_value);
7021     }
7022   else if (TYPE_P (t) && TYPE_LANG_SPECIFIC (t))
7023     ggc_mark (TYPE_LANG_SPECIFIC (t));
7024   else if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
7025     {
7026       ggc_mark (DECL_LANG_SPECIFIC (t));
7027       c_mark_lang_decl (&DECL_LANG_SPECIFIC (t)->base);
7028     }
7029 }
7030
7031 /* The functions below are required for functionality of doing
7032    function at once processing in the C front end. Currently these
7033    functions are not called from anywhere in the C front end, but as
7034    these changes continue, that will change.  */
7035
7036 /* Returns non-zero if the current statement is a full expression,
7037    i.e. temporaries created during that statement should be destroyed
7038    at the end of the statement.  */
7039
7040 int
7041 stmts_are_full_exprs_p ()
7042 {
7043   return 0;
7044 }
7045
7046 /* Returns the stmt_tree (if any) to which statements are currently
7047    being added.  If there is no active statement-tree, NULL is
7048    returned.  */
7049
7050 stmt_tree
7051 current_stmt_tree ()
7052 {
7053   return &c_stmt_tree;
7054 }
7055
7056 /* Returns the stack of SCOPE_STMTs for the current function.  */
7057
7058 tree *
7059 current_scope_stmt_stack ()
7060 {
7061   return &c_scope_stmt_stack;
7062 }
7063
7064 /* Nonzero if TYPE is an anonymous union or struct type.  Always 0 in
7065    C.  */
7066
7067 int
7068 anon_aggr_type_p (node)
7069      tree node ATTRIBUTE_UNUSED;
7070 {
7071   return 0;
7072 }
7073
7074 /* Dummy function in place of callback used by C++.  */
7075
7076 void
7077 extract_interface_info ()
7078 {
7079 }
7080
7081 /* Return a new COMPOUND_STMT, after adding it to the current
7082    statement tree.  */
7083
7084 tree
7085 c_begin_compound_stmt ()
7086 {
7087   tree stmt;
7088
7089   /* Create the COMPOUND_STMT.  */
7090   stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
7091   /* If we haven't already declared __FUNCTION__ and its ilk then this
7092      is the opening curly brace of the function.  Declare them now.  */
7093   if (!c_function_name_declared_p)
7094     {
7095       c_function_name_declared_p = 1;
7096       declare_function_name ();
7097     }
7098
7099   return stmt;
7100 }
7101
7102 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
7103    common code.  */
7104
7105 void
7106 c_expand_decl_stmt (t)
7107      tree t;
7108 {
7109   tree decl = DECL_STMT_DECL (t);
7110
7111   /* Expand nested functions.  */
7112   if (TREE_CODE (decl) == FUNCTION_DECL
7113       && DECL_CONTEXT (decl) == current_function_decl
7114       && DECL_SAVED_TREE (decl))
7115     c_expand_body (decl, /*nested_p=*/1);
7116 }
7117
7118 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
7119    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
7120
7121 tree
7122 identifier_global_value (t)
7123      tree t;
7124 {
7125   return IDENTIFIER_GLOBAL_VALUE (t);
7126 }
7127
7128 /* Record a builtin type for C.  If NAME is non-NULL, it is the name used;
7129    otherwise the name is found in ridpointers from RID_INDEX.  */
7130
7131 void
7132 record_builtin_type (rid_index, name, type)
7133      enum rid rid_index;
7134      const char *name;
7135      tree type;
7136 {
7137   tree id;
7138   if (name == 0)
7139     id = ridpointers[(int) rid_index];
7140   else
7141     id = get_identifier (name);
7142   pushdecl (build_decl (TYPE_DECL, id, type));
7143 }
7144
7145 /* Build the void_list_node (void_type_node having been created).  */
7146 tree
7147 build_void_list_node ()
7148 {
7149   tree t = build_tree_list (NULL_TREE, void_type_node);
7150   return t;
7151 }