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