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