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                           | (1 << (int) RID_COMPLEX))))
4083           /* Don't warn about typedef foo = bar.  */
4084           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
4085           && ! in_system_header)
4086         {
4087           /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
4088              and this is a function, or if -Wimplicit; prefer the former
4089              warning since it is more explicit.  */
4090           if ((warn_implicit_int || warn_return_type) && funcdef_flag)
4091             warn_about_return_type = 1;
4092           else if (warn_implicit_int || flag_isoc99)
4093             pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
4094                          name);
4095         }
4096
4097       defaulted_int = 1;
4098       type = integer_type_node;
4099     }
4100
4101   /* Now process the modifiers that were specified
4102      and check for invalid combinations.  */
4103
4104   /* Long double is a special combination.  */
4105
4106   if ((specbits & 1 << (int) RID_LONG) && ! longlong
4107       && TYPE_MAIN_VARIANT (type) == double_type_node)
4108     {
4109       specbits &= ~(1 << (int) RID_LONG);
4110       type = long_double_type_node;
4111     }
4112
4113   /* Check all other uses of type modifiers.  */
4114
4115   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4116                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4117     {
4118       int ok = 0;
4119
4120       if ((specbits & 1 << (int) RID_LONG)
4121           && (specbits & 1 << (int) RID_SHORT))
4122         error ("both long and short specified for `%s'", name);
4123       else if (((specbits & 1 << (int) RID_LONG)
4124                 || (specbits & 1 << (int) RID_SHORT))
4125                && explicit_char)
4126         error ("long or short specified with char for `%s'", name);
4127       else if (((specbits & 1 << (int) RID_LONG)
4128                 || (specbits & 1 << (int) RID_SHORT))
4129                && TREE_CODE (type) == REAL_TYPE)
4130         {
4131           static int already = 0;
4132
4133           error ("long or short specified with floating type for `%s'", name);
4134           if (! already && ! pedantic)
4135             {
4136               error ("the only valid combination is `long double'");
4137               already = 1;
4138             }
4139         }
4140       else if ((specbits & 1 << (int) RID_SIGNED)
4141                && (specbits & 1 << (int) RID_UNSIGNED))
4142         error ("both signed and unsigned specified for `%s'", name);
4143       else if (TREE_CODE (type) != INTEGER_TYPE)
4144         error ("long, short, signed or unsigned invalid for `%s'", name);
4145       else
4146         {
4147           ok = 1;
4148           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4149             {
4150               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4151                        name);
4152               if (flag_pedantic_errors)
4153                 ok = 0;
4154             }
4155         }
4156
4157       /* Discard the type modifiers if they are invalid.  */
4158       if (! ok)
4159         {
4160           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4161                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4162           longlong = 0;
4163         }
4164     }
4165
4166   if ((specbits & (1 << (int) RID_COMPLEX))
4167       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4168     {
4169       error ("complex invalid for `%s'", name);
4170       specbits &= ~(1 << (int) RID_COMPLEX);
4171     }
4172
4173   /* Decide whether an integer type is signed or not.
4174      Optionally treat bitfields as signed by default.  */
4175   if (specbits & 1 << (int) RID_UNSIGNED
4176       /* Traditionally, all bitfields are unsigned.  */
4177       || (bitfield && flag_traditional
4178           && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
4179       || (bitfield && ! flag_signed_bitfields
4180           && (explicit_int || defaulted_int || explicit_char
4181               /* A typedef for plain `int' without `signed'
4182                  can be controlled just like plain `int'.  */
4183               || ! (typedef_decl != 0
4184                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4185           && TREE_CODE (type) != ENUMERAL_TYPE
4186           && !(specbits & 1 << (int) RID_SIGNED)))
4187     {
4188       if (longlong)
4189         type = long_long_unsigned_type_node;
4190       else if (specbits & 1 << (int) RID_LONG)
4191         type = long_unsigned_type_node;
4192       else if (specbits & 1 << (int) RID_SHORT)
4193         type = short_unsigned_type_node;
4194       else if (type == char_type_node)
4195         type = unsigned_char_type_node;
4196       else if (typedef_decl)
4197         type = unsigned_type (type);
4198       else
4199         type = unsigned_type_node;
4200     }
4201   else if ((specbits & 1 << (int) RID_SIGNED)
4202            && type == char_type_node)
4203     type = signed_char_type_node;
4204   else if (longlong)
4205     type = long_long_integer_type_node;
4206   else if (specbits & 1 << (int) RID_LONG)
4207     type = long_integer_type_node;
4208   else if (specbits & 1 << (int) RID_SHORT)
4209     type = short_integer_type_node;
4210
4211   if (specbits & 1 << (int) RID_COMPLEX)
4212     {
4213       if (pedantic && !flag_isoc99)
4214         pedwarn ("ISO C89 does not support complex types");
4215       /* If we just have "complex", it is equivalent to
4216          "complex double", but if any modifiers at all are specified it is
4217          the complex form of TYPE.  E.g, "complex short" is
4218          "complex short int".  */
4219
4220       if (defaulted_int && ! longlong
4221           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4222                             | (1 << (int) RID_SIGNED)
4223                             | (1 << (int) RID_UNSIGNED))))
4224         {
4225           if (pedantic)
4226             pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
4227           type = complex_double_type_node;
4228         }
4229       else if (type == integer_type_node)
4230         {
4231           if (pedantic)
4232             pedwarn ("ISO C does not support complex integer types");
4233           type = complex_integer_type_node;
4234         }
4235       else if (type == float_type_node)
4236         type = complex_float_type_node;
4237       else if (type == double_type_node)
4238         type = complex_double_type_node;
4239       else if (type == long_double_type_node)
4240         type = complex_long_double_type_node;
4241       else
4242         {
4243           if (pedantic)
4244             pedwarn ("ISO C does not support complex integer types");
4245           type = build_complex_type (type);
4246         }
4247     }
4248
4249   /* Figure out the type qualifiers for the declaration.  There are
4250      two ways a declaration can become qualified.  One is something
4251      like `const int i' where the `const' is explicit.  Another is
4252      something like `typedef const int CI; CI i' where the type of the
4253      declaration contains the `const'.  */
4254   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4255   restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
4256   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4257   inlinep = !! (specbits & (1 << (int) RID_INLINE));
4258   if (constp > 1 && ! flag_isoc99)
4259     pedwarn ("duplicate `const'");
4260   if (restrictp > 1 && ! flag_isoc99)
4261     pedwarn ("duplicate `restrict'");
4262   if (volatilep > 1 && ! flag_isoc99)
4263     pedwarn ("duplicate `volatile'");
4264   if (! flag_gen_aux_info && (TYPE_QUALS (type)))
4265     type = TYPE_MAIN_VARIANT (type);
4266   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4267                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4268                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4269
4270   /* Warn if two storage classes are given. Default to `auto'.  */
4271
4272   {
4273     int nclasses = 0;
4274
4275     if (specbits & 1 << (int) RID_AUTO) nclasses++;
4276     if (specbits & 1 << (int) RID_STATIC) nclasses++;
4277     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4278     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4279     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4280
4281     /* Warn about storage classes that are invalid for certain
4282        kinds of declarations (parameters, typenames, etc.).  */
4283
4284     if (nclasses > 1)
4285       error ("multiple storage classes in declaration of `%s'", name);
4286     else if (funcdef_flag
4287              && (specbits
4288                  & ((1 << (int) RID_REGISTER)
4289                     | (1 << (int) RID_AUTO)
4290                     | (1 << (int) RID_TYPEDEF))))
4291       {
4292         if (specbits & 1 << (int) RID_AUTO
4293             && (pedantic || current_binding_level == global_binding_level))
4294           pedwarn ("function definition declared `auto'");
4295         if (specbits & 1 << (int) RID_REGISTER)
4296           error ("function definition declared `register'");
4297         if (specbits & 1 << (int) RID_TYPEDEF)
4298           error ("function definition declared `typedef'");
4299         specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4300                       | (1 << (int) RID_AUTO));
4301       }
4302     else if (decl_context != NORMAL && nclasses > 0)
4303       {
4304         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4305           ;
4306         else
4307           {
4308             switch (decl_context)
4309               {
4310               case FIELD:
4311                 error ("storage class specified for structure field `%s'",
4312                        name);
4313                 break;
4314               case PARM:
4315                 error ("storage class specified for parameter `%s'", name);
4316                 break;
4317               default:
4318                 error ("storage class specified for typename");
4319                 break;
4320               }
4321             specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4322                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4323                           | (1 << (int) RID_EXTERN));
4324           }
4325       }
4326     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4327       {
4328         /* `extern' with initialization is invalid if not at top level.  */
4329         if (current_binding_level == global_binding_level)
4330           warning ("`%s' initialized and declared `extern'", name);
4331         else
4332           error ("`%s' has both `extern' and initializer", name);
4333       }
4334     else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4335              && current_binding_level != global_binding_level)
4336       error ("nested function `%s' declared `extern'", name);
4337     else if (current_binding_level == global_binding_level
4338              && specbits & (1 << (int) RID_AUTO))
4339       error ("top-level declaration of `%s' specifies `auto'", name);
4340   }
4341
4342   /* Now figure out the structure of the declarator proper.
4343      Descend through it, creating more complex types, until we reach
4344      the declared identifier (or NULL_TREE, in an absolute declarator).  */
4345
4346   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4347     {
4348       if (type == error_mark_node)
4349         {
4350           declarator = TREE_OPERAND (declarator, 0);
4351           continue;
4352         }
4353
4354       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4355          an INDIRECT_REF (for *...),
4356          a CALL_EXPR (for ...(...)),
4357          an identifier (for the name being declared)
4358          or a null pointer (for the place in an absolute declarator
4359          where the name was omitted).
4360          For the last two cases, we have just exited the loop.
4361
4362          At this point, TYPE is the type of elements of an array,
4363          or for a function to return, or for a pointer to point to.
4364          After this sequence of ifs, TYPE is the type of the
4365          array or function or pointer, and DECLARATOR has had its
4366          outermost layer removed.  */
4367
4368       if (TREE_CODE (declarator) == ARRAY_REF)
4369         {
4370           register tree itype = NULL_TREE;
4371           register tree size = TREE_OPERAND (declarator, 1);
4372           /* The index is a signed object `sizetype' bits wide.  */
4373           tree index_type = signed_type (sizetype);
4374
4375           declarator = TREE_OPERAND (declarator, 0);
4376
4377           /* Check for some types that there cannot be arrays of.  */
4378
4379           if (VOID_TYPE_P (type))
4380             {
4381               error ("declaration of `%s' as array of voids", name);
4382               type = error_mark_node;
4383             }
4384
4385           if (TREE_CODE (type) == FUNCTION_TYPE)
4386             {
4387               error ("declaration of `%s' as array of functions", name);
4388               type = error_mark_node;
4389             }
4390
4391           if (size == error_mark_node)
4392             type = error_mark_node;
4393
4394           if (type == error_mark_node)
4395             continue;
4396
4397           /* If size was specified, set ITYPE to a range-type for that size.
4398              Otherwise, ITYPE remains null.  finish_decl may figure it out
4399              from an initial value.  */
4400
4401           if (size)
4402             {
4403               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4404               STRIP_TYPE_NOPS (size);
4405
4406               if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
4407                   && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
4408                 {
4409                   error ("size of array `%s' has non-integer type", name);
4410                   size = integer_one_node;
4411                 }
4412
4413               if (pedantic && integer_zerop (size))
4414                 pedwarn ("ISO C forbids zero-size array `%s'", name);
4415
4416               if (TREE_CODE (size) == INTEGER_CST)
4417                 {
4418                   constant_expression_warning (size);
4419                   if (tree_int_cst_sgn (size) < 0)
4420                     {
4421                       error ("size of array `%s' is negative", name);
4422                       size = integer_one_node;
4423                     }
4424                 }
4425               else
4426                 {
4427                   /* Make sure the array size remains visibly nonconstant
4428                      even if it is (eg) a const variable with known value.  */
4429                   size_varies = 1;
4430
4431                   if (pedantic)
4432                     {
4433                       if (TREE_CONSTANT (size))
4434                         pedwarn ("ISO C89 forbids array `%s' whose size can't be evaluated",
4435                                  name);
4436                       else
4437                         pedwarn ("ISO C89 forbids variable-size array `%s'",
4438                                  name);
4439                     }
4440                 }
4441
4442               /* Convert size to index_type, so that if it is a variable
4443                  the computations will be done in the proper mode.  */
4444               itype = fold (build (MINUS_EXPR, index_type,
4445                                    convert (index_type, size),
4446                                    convert (index_type, size_one_node)));
4447
4448               /* If that overflowed, the array is too big.
4449                  ??? While a size of INT_MAX+1 technically shouldn't cause
4450                  an overflow (because we subtract 1), the overflow is recorded
4451                  during the conversion to index_type, before the subtraction.
4452                  Handling this case seems like an unnecessary complication.  */
4453               if (TREE_OVERFLOW (itype))
4454                 {
4455                   error ("size of array `%s' is too large", name);
4456                   type = error_mark_node;
4457                   continue;
4458                 }
4459
4460               if (size_varies)
4461                 itype = variable_size (itype);
4462               itype = build_index_type (itype);
4463             }
4464
4465 #if 0
4466           /* This had bad results for pointers to arrays, as in
4467              union incomplete (*foo)[4];  */
4468           /* Complain about arrays of incomplete types, except in typedefs.  */
4469
4470           if (!COMPLETE_TYPE_P (type)
4471               /* Avoid multiple warnings for nested array types.  */
4472               && TREE_CODE (type) != ARRAY_TYPE
4473               && !(specbits & (1 << (int) RID_TYPEDEF))
4474               && !C_TYPE_BEING_DEFINED (type))
4475             warning ("array type has incomplete element type");
4476 #endif
4477
4478 #if 0
4479           /* We shouldn't have a function type here at all!
4480              Functions aren't allowed as array elements.  */
4481           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4482               && (constp || volatilep))
4483             pedwarn ("ANSI C forbids const or volatile function types");
4484 #endif
4485
4486           /* Build the array type itself, then merge any constancy or
4487              volatility into the target type.  We must do it in this order
4488              to ensure that the TYPE_MAIN_VARIANT field of the array type
4489              is set correctly.  */
4490
4491           type = build_array_type (type, itype);
4492           if (type_quals)
4493             type = c_build_qualified_type (type, type_quals);
4494
4495 #if 0
4496           /* Don't clear these; leave them set so that the array type
4497              or the variable is itself const or volatile.  */
4498           type_quals = TYPE_UNQUALIFIED;
4499 #endif
4500
4501           if (size_varies)
4502             C_TYPE_VARIABLE_SIZE (type) = 1;
4503         }
4504       else if (TREE_CODE (declarator) == CALL_EXPR)
4505         {
4506           tree arg_types;
4507
4508           /* Declaring a function type.
4509              Make sure we have a valid type for the function to return.  */
4510           if (type == error_mark_node)
4511             continue;
4512
4513           size_varies = 0;
4514
4515           /* Warn about some types functions can't return.  */
4516
4517           if (TREE_CODE (type) == FUNCTION_TYPE)
4518             {
4519               error ("`%s' declared as function returning a function", name);
4520               type = integer_type_node;
4521             }
4522           if (TREE_CODE (type) == ARRAY_TYPE)
4523             {
4524               error ("`%s' declared as function returning an array", name);
4525               type = integer_type_node;
4526             }
4527
4528 #ifndef TRADITIONAL_RETURN_FLOAT
4529           /* Traditionally, declaring return type float means double.  */
4530
4531           if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4532             type = double_type_node;
4533 #endif /* TRADITIONAL_RETURN_FLOAT */
4534
4535           /* Construct the function type and go to the next
4536              inner layer of declarator.  */
4537
4538           arg_types = grokparms (TREE_OPERAND (declarator, 1),
4539                                  funcdef_flag
4540                                  /* Say it's a definition
4541                                     only for the CALL_EXPR
4542                                     closest to the identifier.  */
4543                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4544           /* Type qualifiers before the return type of the function
4545              qualify the return type, not the function type.  */
4546           if (type_quals)
4547             type = c_build_qualified_type (type, type_quals);
4548           type_quals = TYPE_UNQUALIFIED;
4549
4550           type = build_function_type (type, arg_types);
4551           declarator = TREE_OPERAND (declarator, 0);
4552
4553           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4554              the formal parameter list of this FUNCTION_TYPE to point to
4555              the FUNCTION_TYPE node itself.  */
4556
4557           {
4558             register tree link;
4559
4560             for (link = last_function_parm_tags;
4561                  link;
4562                  link = TREE_CHAIN (link))
4563               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4564           }
4565         }
4566       else if (TREE_CODE (declarator) == INDIRECT_REF)
4567         {
4568           /* Merge any constancy or volatility into the target type
4569              for the pointer.  */
4570
4571           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4572               && type_quals)
4573             pedwarn ("ISO C forbids qualified function types");
4574           if (type_quals)
4575             type = c_build_qualified_type (type, type_quals);
4576           type_quals = TYPE_UNQUALIFIED;
4577           size_varies = 0;
4578
4579           type = build_pointer_type (type);
4580
4581           /* Process a list of type modifier keywords
4582              (such as const or volatile) that were given inside the `*'.  */
4583
4584           if (TREE_TYPE (declarator))
4585             {
4586               register tree typemodlist;
4587               int erred = 0;
4588
4589               constp = 0;
4590               volatilep = 0;
4591               restrictp = 0;
4592               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4593                    typemodlist = TREE_CHAIN (typemodlist))
4594                 {
4595                   tree qualifier = TREE_VALUE (typemodlist);
4596
4597                   if (C_IS_RESERVED_WORD (qualifier))
4598                     {
4599                       if (C_RID_CODE (qualifier) == RID_CONST)
4600                         constp++;
4601                       else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4602                         volatilep++;
4603                       else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4604                         restrictp++;
4605                       else
4606                         erred++;
4607                     }
4608                   else
4609                     erred++;
4610                 }
4611
4612               if (erred)
4613                 error ("invalid type modifier within pointer declarator");
4614               if (constp > 1 && ! flag_isoc99)
4615                 pedwarn ("duplicate `const'");
4616               if (volatilep > 1 && ! flag_isoc99)
4617                 pedwarn ("duplicate `volatile'");
4618               if (restrictp > 1 && ! flag_isoc99)
4619                 pedwarn ("duplicate `restrict'");
4620
4621               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4622                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4623                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4624             }
4625
4626           declarator = TREE_OPERAND (declarator, 0);
4627         }
4628       else
4629         abort ();
4630
4631     }
4632
4633   /* Now TYPE has the actual type.  */
4634
4635   /* Did array size calculations overflow?  */
4636
4637   if (TREE_CODE (type) == ARRAY_TYPE
4638       && COMPLETE_TYPE_P (type)
4639       && TREE_OVERFLOW (TYPE_SIZE (type)))
4640     error ("size of array `%s' is too large", name);
4641
4642   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4643
4644   if (specbits & (1 << (int) RID_TYPEDEF))
4645     {
4646       tree decl;
4647       /* Note that the grammar rejects storage classes
4648          in typenames, fields or parameters */
4649       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4650           && type_quals)
4651         pedwarn ("ISO C forbids qualified function types");
4652       if (type_quals)
4653         type = c_build_qualified_type (type, type_quals);
4654       decl = build_decl (TYPE_DECL, declarator, type);
4655       if ((specbits & (1 << (int) RID_SIGNED))
4656           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4657         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4658       return decl;
4659     }
4660
4661   /* Detect the case of an array type of unspecified size
4662      which came, as such, direct from a typedef name.
4663      We must copy the type, so that each identifier gets
4664      a distinct type, so that each identifier's size can be
4665      controlled separately by its own initializer.  */
4666
4667   if (type != 0 && typedef_type != 0
4668       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4669       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4670     {
4671       type = build_array_type (TREE_TYPE (type), 0);
4672       if (size_varies)
4673         C_TYPE_VARIABLE_SIZE (type) = 1;
4674     }
4675
4676   /* If this is a type name (such as, in a cast or sizeof),
4677      compute the type and return it now.  */
4678
4679   if (decl_context == TYPENAME)
4680     {
4681       /* Note that the grammar rejects storage classes
4682          in typenames, fields or parameters */
4683       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4684           && type_quals)
4685         pedwarn ("ISO C forbids const or volatile function types");
4686       if (type_quals)
4687         type = c_build_qualified_type (type, type_quals);
4688       return type;
4689     }
4690
4691   /* Aside from typedefs and type names (handle above),
4692      `void' at top level (not within pointer)
4693      is allowed only in public variables.
4694      We don't complain about parms either, but that is because
4695      a better error message can be made later.  */
4696
4697   if (VOID_TYPE_P (type) && decl_context != PARM
4698       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4699             && ((specbits & (1 << (int) RID_EXTERN))
4700                 || (current_binding_level == global_binding_level
4701                     && !(specbits
4702                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4703     {
4704       error ("variable or field `%s' declared void", name);
4705       type = integer_type_node;
4706     }
4707
4708   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4709      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4710
4711   {
4712     register tree decl;
4713
4714     if (decl_context == PARM)
4715       {
4716         tree type_as_written = type;
4717         tree promoted_type;
4718
4719         /* A parameter declared as an array of T is really a pointer to T.
4720            One declared as a function is really a pointer to a function.  */
4721
4722         if (TREE_CODE (type) == ARRAY_TYPE)
4723           {
4724             /* Transfer const-ness of array into that of type pointed to.  */
4725             type = TREE_TYPE (type);
4726             if (type_quals)
4727               type = c_build_qualified_type (type, type_quals);
4728             type = build_pointer_type (type);
4729             type_quals = TYPE_UNQUALIFIED;
4730             size_varies = 0;
4731           }
4732         else if (TREE_CODE (type) == FUNCTION_TYPE)
4733           {
4734             if (pedantic && type_quals)
4735               pedwarn ("ISO C forbids qualified function types");
4736             if (type_quals)
4737               type = c_build_qualified_type (type, type_quals);
4738             type = build_pointer_type (type);
4739             type_quals = TYPE_UNQUALIFIED;
4740           }
4741
4742         decl = build_decl (PARM_DECL, declarator, type);
4743         if (size_varies)
4744           C_DECL_VARIABLE_SIZE (decl) = 1;
4745
4746         /* Compute the type actually passed in the parmlist,
4747            for the case where there is no prototype.
4748            (For example, shorts and chars are passed as ints.)
4749            When there is a prototype, this is overridden later.  */
4750
4751         if (type == error_mark_node)
4752           promoted_type = type;
4753         else
4754           {
4755             promoted_type = simple_type_promotes_to (type);
4756             if (! promoted_type)
4757               promoted_type = type;
4758           }
4759
4760         DECL_ARG_TYPE (decl) = promoted_type;
4761         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4762       }
4763     else if (decl_context == FIELD)
4764       {
4765         /* Structure field.  It may not be a function.  */
4766
4767         if (TREE_CODE (type) == FUNCTION_TYPE)
4768           {
4769             error ("field `%s' declared as a function", name);
4770             type = build_pointer_type (type);
4771           }
4772         else if (TREE_CODE (type) != ERROR_MARK
4773                  && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4774           {
4775             error ("field `%s' has incomplete type", name);
4776             type = error_mark_node;
4777           }
4778         /* Move type qualifiers down to element of an array.  */
4779         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4780           {
4781             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4782                                                              type_quals),
4783                                      TYPE_DOMAIN (type));
4784 #if 0
4785             /* Leave the field const or volatile as well.  */
4786             type_quals = TYPE_UNQUALIFIED;
4787 #endif
4788           }
4789         decl = build_decl (FIELD_DECL, declarator, type);
4790         DECL_NONADDRESSABLE_P (decl) = bitfield;
4791
4792         if (size_varies)
4793           C_DECL_VARIABLE_SIZE (decl) = 1;
4794       }
4795     else if (TREE_CODE (type) == FUNCTION_TYPE)
4796       {
4797         /* Every function declaration is "external"
4798            except for those which are inside a function body
4799            in which `auto' is used.
4800            That is a case not specified by ANSI C,
4801            and we use it for forward declarations for nested functions.  */
4802         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4803                           || current_binding_level == global_binding_level);
4804
4805         if (specbits & (1 << (int) RID_AUTO)
4806             && (pedantic || current_binding_level == global_binding_level))
4807           pedwarn ("invalid storage class for function `%s'", name);
4808         if (specbits & (1 << (int) RID_REGISTER))
4809           error ("invalid storage class for function `%s'", name);
4810         /* Function declaration not at top level.
4811            Storage classes other than `extern' are not allowed
4812            and `extern' makes no difference.  */
4813         if (current_binding_level != global_binding_level
4814             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4815             && pedantic)
4816           pedwarn ("invalid storage class for function `%s'", name);
4817
4818         decl = build_decl (FUNCTION_DECL, declarator, type);
4819         decl = build_decl_attribute_variant (decl, decl_machine_attr);
4820
4821         if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4822           pedwarn ("ISO C forbids qualified function types");
4823
4824         if (pedantic
4825             && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl)))
4826             && TYPE_QUALS (TREE_TYPE (TREE_TYPE (decl)))
4827             && ! DECL_IN_SYSTEM_HEADER (decl))
4828           pedwarn ("ISO C forbids qualified void function return type");
4829
4830         /* GNU C interprets a `volatile void' return type to indicate
4831            that the function does not return.  */
4832         if ((type_quals & TYPE_QUAL_VOLATILE)
4833             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4834           warning ("`noreturn' function returns non-void value");
4835
4836         if (extern_ref)
4837           DECL_EXTERNAL (decl) = 1;
4838         /* Record absence of global scope for `static' or `auto'.  */
4839         TREE_PUBLIC (decl)
4840           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4841
4842         /* Record presence of `inline', if it is reasonable.  */
4843         if (inlinep)
4844           {
4845             if (MAIN_NAME_P (declarator))
4846               warning ("cannot inline function `main'");
4847             else
4848               /* Assume that otherwise the function can be inlined.  */
4849               DECL_INLINE (decl) = 1;
4850
4851             if (specbits & (1 << (int) RID_EXTERN))
4852               current_extern_inline = 1;
4853           }
4854       }
4855     else
4856       {
4857         /* It's a variable.  */
4858         /* An uninitialized decl with `extern' is a reference.  */
4859         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4860
4861         /* Move type qualifiers down to element of an array.  */
4862         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4863           {
4864             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4865                                                              type_quals),
4866                                      TYPE_DOMAIN (type));
4867 #if 0 /* Leave the variable const or volatile as well.  */
4868             type_quals = TYPE_UNQUALIFIED;
4869 #endif
4870           }
4871
4872         decl = build_decl (VAR_DECL, declarator, type);
4873         if (size_varies)
4874           C_DECL_VARIABLE_SIZE (decl) = 1;
4875
4876         if (inlinep)
4877           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4878
4879         DECL_EXTERNAL (decl) = extern_ref;
4880         /* At top level, the presence of a `static' or `register' storage
4881            class specifier, or the absence of all storage class specifiers
4882            makes this declaration a definition (perhaps tentative).  Also,
4883            the absence of both `static' and `register' makes it public.  */
4884         if (current_binding_level == global_binding_level)
4885           {
4886             TREE_PUBLIC (decl)
4887               = !(specbits
4888                   & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
4889             TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
4890           }
4891         /* Not at top level, only `static' makes a static definition.  */
4892         else
4893           {
4894             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4895             TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
4896           }
4897       }
4898
4899     /* Record `register' declaration for warnings on &
4900        and in case doing stupid register allocation.  */
4901
4902     if (specbits & (1 << (int) RID_REGISTER))
4903       DECL_REGISTER (decl) = 1;
4904
4905     /* Record constancy and volatility.  */
4906     c_apply_type_quals_to_decl (type_quals, decl);
4907
4908     /* If a type has volatile components, it should be stored in memory.
4909        Otherwise, the fact that those components are volatile
4910        will be ignored, and would even crash the compiler.  */
4911     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4912       mark_addressable (decl);
4913
4914     return decl;
4915   }
4916 }
4917 \f
4918 /* Decode the parameter-list info for a function type or function definition.
4919    The argument is the value returned by `get_parm_info' (or made in parse.y
4920    if there is an identifier list instead of a parameter decl list).
4921    These two functions are separate because when a function returns
4922    or receives functions then each is called multiple times but the order
4923    of calls is different.  The last call to `grokparms' is always the one
4924    that contains the formal parameter names of a function definition.
4925
4926    Store in `last_function_parms' a chain of the decls of parms.
4927    Also store in `last_function_parm_tags' a chain of the struct, union,
4928    and enum tags declared among the parms.
4929
4930    Return a list of arg types to use in the FUNCTION_TYPE for this function.
4931
4932    FUNCDEF_FLAG is nonzero for a function definition, 0 for
4933    a mere declaration.  A nonempty identifier-list gets an error message
4934    when FUNCDEF_FLAG is zero.  */
4935
4936 static tree
4937 grokparms (parms_info, funcdef_flag)
4938      tree parms_info;
4939      int funcdef_flag;
4940 {
4941   tree first_parm = TREE_CHAIN (parms_info);
4942
4943   last_function_parms = TREE_PURPOSE (parms_info);
4944   last_function_parm_tags = TREE_VALUE (parms_info);
4945
4946   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
4947       && !in_system_header)
4948     warning ("function declaration isn't a prototype");
4949
4950   if (first_parm != 0
4951       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4952     {
4953       if (! funcdef_flag)
4954         pedwarn ("parameter names (without types) in function declaration");
4955
4956       last_function_parms = first_parm;
4957       return 0;
4958     }
4959   else
4960     {
4961       tree parm;
4962       tree typelt;
4963       /* We no longer test FUNCDEF_FLAG.
4964          If the arg types are incomplete in a declaration,
4965          they must include undefined tags.
4966          These tags can never be defined in the scope of the declaration,
4967          so the types can never be completed,
4968          and no call can be compiled successfully.  */
4969 #if 0
4970       /* In a fcn definition, arg types must be complete.  */
4971       if (funcdef_flag)
4972 #endif
4973         for (parm = last_function_parms, typelt = first_parm;
4974              parm;
4975              parm = TREE_CHAIN (parm))
4976           /* Skip over any enumeration constants declared here.  */
4977           if (TREE_CODE (parm) == PARM_DECL)
4978             {
4979               /* Barf if the parameter itself has an incomplete type.  */
4980               tree type = TREE_VALUE (typelt);
4981               if (!COMPLETE_TYPE_P (type))
4982                 {
4983                   if (funcdef_flag && DECL_NAME (parm) != 0)
4984                     error ("parameter `%s' has incomplete type",
4985                            IDENTIFIER_POINTER (DECL_NAME (parm)));
4986                   else
4987                     warning ("parameter has incomplete type");
4988                   if (funcdef_flag)
4989                     {
4990                       TREE_VALUE (typelt) = error_mark_node;
4991                       TREE_TYPE (parm) = error_mark_node;
4992                     }
4993                 }
4994 #if 0
4995               /* This has been replaced by parm_tags_warning, which
4996                  uses a more accurate criterion for what to warn
4997                  about.  */
4998               else
4999                 {
5000                   /* Now warn if is a pointer to an incomplete type.  */
5001                   while (TREE_CODE (type) == POINTER_TYPE
5002                          || TREE_CODE (type) == REFERENCE_TYPE)
5003                     type = TREE_TYPE (type);
5004                   type = TYPE_MAIN_VARIANT (type);
5005                   if (!COMPLETE_TYPE_P (type))
5006                     {
5007                       if (DECL_NAME (parm) != 0)
5008                         warning ("parameter `%s' points to incomplete type",
5009                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
5010                       else
5011                         warning ("parameter points to incomplete type");
5012                     }
5013                 }
5014 #endif
5015               typelt = TREE_CHAIN (typelt);
5016             }
5017
5018       return first_parm;
5019     }
5020 }
5021
5022 /* Return a tree_list node with info on a parameter list just parsed.
5023    The TREE_PURPOSE is a chain of decls of those parms.
5024    The TREE_VALUE is a list of structure, union and enum tags defined.
5025    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5026    This tree_list node is later fed to `grokparms'.
5027
5028    VOID_AT_END nonzero means append `void' to the end of the type-list.
5029    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
5030
5031 tree
5032 get_parm_info (void_at_end)
5033      int void_at_end;
5034 {
5035   register tree decl, t;
5036   register tree types = 0;
5037   int erred = 0;
5038   tree tags = gettags ();
5039   tree parms = getdecls ();
5040   tree new_parms = 0;
5041   tree order = current_binding_level->parm_order;
5042
5043   /* Just `void' (and no ellipsis) is special.  There are really no parms.
5044      But if the `void' is qualified (by `const' or `volatile') or has a
5045      storage class specifier (`register'), then the behavior is undefined;
5046      by not counting it as the special case of `void' we will cause an
5047      error later.  Typedefs for `void' are OK (see DR#157).  */
5048   if (void_at_end && parms != 0
5049       && TREE_CHAIN (parms) == 0
5050       && VOID_TYPE_P (TREE_TYPE (parms))
5051       && ! TREE_THIS_VOLATILE (parms)
5052       && ! TREE_READONLY (parms)
5053       && ! DECL_REGISTER (parms)
5054       && DECL_NAME (parms) == 0)
5055     {
5056       parms = NULL_TREE;
5057       storedecls (NULL_TREE);
5058       return tree_cons (NULL_TREE, NULL_TREE,
5059                         tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5060     }
5061
5062   /* Extract enumerator values and other non-parms declared with the parms.
5063      Likewise any forward parm decls that didn't have real parm decls.  */
5064   for (decl = parms; decl;)
5065     {
5066       tree next = TREE_CHAIN (decl);
5067
5068       if (TREE_CODE (decl) != PARM_DECL)
5069         {
5070           TREE_CHAIN (decl) = new_parms;
5071           new_parms = decl;
5072         }
5073       else if (TREE_ASM_WRITTEN (decl))
5074         {
5075           error_with_decl (decl,
5076                            "parameter `%s' has just a forward declaration");
5077           TREE_CHAIN (decl) = new_parms;
5078           new_parms = decl;
5079         }
5080       decl = next;
5081     }
5082
5083   /* Put the parm decls back in the order they were in in the parm list.  */
5084   for (t = order; t; t = TREE_CHAIN (t))
5085     {
5086       if (TREE_CHAIN (t))
5087         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5088       else
5089         TREE_CHAIN (TREE_VALUE (t)) = 0;
5090     }
5091
5092   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5093                        new_parms);
5094
5095   /* Store the parmlist in the binding level since the old one
5096      is no longer a valid list.  (We have changed the chain pointers.)  */
5097   storedecls (new_parms);
5098
5099   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5100     /* There may also be declarations for enumerators if an enumeration
5101        type is declared among the parms.  Ignore them here.  */
5102     if (TREE_CODE (decl) == PARM_DECL)
5103       {
5104         /* Since there is a prototype,
5105            args are passed in their declared types.  */
5106         tree type = TREE_TYPE (decl);
5107         DECL_ARG_TYPE (decl) = type;
5108         if (PROMOTE_PROTOTYPES
5109             && (TREE_CODE (type) == INTEGER_TYPE
5110                 || TREE_CODE (type) == ENUMERAL_TYPE)
5111             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5112           DECL_ARG_TYPE (decl) = integer_type_node;
5113
5114         types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5115         if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
5116             && DECL_NAME (decl) == 0)
5117           {
5118             error ("`void' in parameter list must be the entire list");
5119             erred = 1;
5120           }
5121       }
5122
5123   if (void_at_end)
5124     return tree_cons (new_parms, tags,
5125                       nreverse (tree_cons (NULL_TREE, void_type_node, types)));
5126
5127   return tree_cons (new_parms, tags, nreverse (types));
5128 }
5129
5130 /* At end of parameter list, warn about any struct, union or enum tags
5131    defined within.  Do so because these types cannot ever become complete.  */
5132
5133 void
5134 parmlist_tags_warning ()
5135 {
5136   tree elt;
5137   static int already;
5138
5139   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5140     {
5141       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5142       /* An anonymous union parm type is meaningful as a GNU extension.
5143          So don't warn for that.  */
5144       if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
5145         continue;
5146       if (TREE_PURPOSE (elt) != 0)
5147         warning ("`%s %s' declared inside parameter list",
5148                  (code == RECORD_TYPE ? "struct"
5149                   : code == UNION_TYPE ? "union"
5150                   : "enum"),
5151                  IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5152       else
5153         {
5154           /* For translation these need to be seperate warnings */
5155           if (code == RECORD_TYPE)
5156             warning ("anonymous struct declared inside parameter list");
5157           else if (code == UNION_TYPE)
5158             warning ("anonymous union declared inside parameter list");
5159           else
5160             warning ("anonymous enum declared inside parameter list");
5161         }
5162       if (! already)
5163         {
5164           warning ("its scope is only this definition or declaration, which is probably not what you want.");
5165           already = 1;
5166         }
5167     }
5168 }
5169 \f
5170 /* Get the struct, enum or union (CODE says which) with tag NAME.
5171    Define the tag as a forward-reference if it is not defined.  */
5172
5173 tree
5174 xref_tag (code, name)
5175      enum tree_code code;
5176      tree name;
5177 {
5178   /* If a cross reference is requested, look up the type
5179      already defined for this tag and return it.  */
5180
5181   register tree ref = lookup_tag (code, name, current_binding_level, 0);
5182   /* Even if this is the wrong type of tag, return what we found.
5183      There will be an error message anyway, from pending_xref_error.
5184      If we create an empty xref just for an invalid use of the type,
5185      the main result is to create lots of superfluous error messages.  */
5186   if (ref)
5187     return ref;
5188
5189   /* If no such tag is yet defined, create a forward-reference node
5190      and record it as the "definition".
5191      When a real declaration of this type is found,
5192      the forward-reference will be altered into a real type.  */
5193
5194   ref = make_node (code);
5195   if (code == ENUMERAL_TYPE)
5196     {
5197       /* (In ANSI, Enums can be referred to only if already defined.)  */
5198       if (pedantic)
5199         pedwarn ("ISO C forbids forward references to `enum' types");
5200       /* Give the type a default layout like unsigned int
5201          to avoid crashing if it does not get defined.  */
5202       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5203       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5204       TYPE_USER_ALIGN (ref) = 0;
5205       TREE_UNSIGNED (ref) = 1;
5206       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5207       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5208       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5209     }
5210
5211   pushtag (name, ref);
5212
5213   return ref;
5214 }
5215 \f
5216 /* Make sure that the tag NAME is defined *in the current binding level*
5217    at least as a forward reference.
5218    CODE says which kind of tag NAME ought to be.  */
5219
5220 tree
5221 start_struct (code, name)
5222      enum tree_code code;
5223      tree name;
5224 {
5225   /* If there is already a tag defined at this binding level
5226      (as a forward reference), just return it.  */
5227
5228   register tree ref = 0;
5229
5230   if (name != 0)
5231     ref = lookup_tag (code, name, current_binding_level, 1);
5232   if (ref && TREE_CODE (ref) == code)
5233     {
5234       C_TYPE_BEING_DEFINED (ref) = 1;
5235       TYPE_PACKED (ref) = flag_pack_struct;
5236       if (TYPE_FIELDS (ref))
5237         error ("redefinition of `%s %s'",
5238                code == UNION_TYPE ? "union" : "struct",
5239                IDENTIFIER_POINTER (name));
5240
5241       return ref;
5242     }
5243
5244   /* Otherwise create a forward-reference just so the tag is in scope.  */
5245
5246   ref = make_node (code);
5247   pushtag (name, ref);
5248   C_TYPE_BEING_DEFINED (ref) = 1;
5249   TYPE_PACKED (ref) = flag_pack_struct;
5250   return ref;
5251 }
5252
5253 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5254    of a structure component, returning a FIELD_DECL node.
5255    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5256
5257    This is done during the parsing of the struct declaration.
5258    The FIELD_DECL nodes are chained together and the lot of them
5259    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5260
5261 tree
5262 grokfield (filename, line, declarator, declspecs, width)
5263      const char *filename ATTRIBUTE_UNUSED;
5264      int line ATTRIBUTE_UNUSED;
5265      tree declarator, declspecs, width;
5266 {
5267   tree value;
5268
5269   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5270
5271   finish_decl (value, NULL_TREE, NULL_TREE);
5272   DECL_INITIAL (value) = width;
5273
5274   maybe_objc_check_decl (value);
5275   return value;
5276 }
5277 \f
5278 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5279    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5280    ATTRIBUTES are attributes to be applied to the structure.  */
5281
5282 tree
5283 finish_struct (t, fieldlist, attributes)
5284      tree t;
5285      tree fieldlist;
5286      tree attributes;
5287 {
5288   register tree x;
5289   int toplevel = global_binding_level == current_binding_level;
5290
5291   /* If this type was previously laid out as a forward reference,
5292      make sure we lay it out again.  */
5293
5294   TYPE_SIZE (t) = 0;
5295
5296   decl_attributes (t, attributes, NULL_TREE);
5297
5298   /* Nameless union parm types are useful as GCC extension.  */
5299   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5300     /* Otherwise, warn about any struct or union def. in parmlist.  */
5301     if (in_parm_level_p ())
5302       {
5303         if (pedantic)
5304           pedwarn ("%s defined inside parms",
5305                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5306         else if (! flag_traditional)
5307           warning ("%s defined inside parms",
5308                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5309       }
5310
5311   if (pedantic)
5312     {
5313       for (x = fieldlist; x; x = TREE_CHAIN (x))
5314         if (DECL_NAME (x) != 0)
5315           break;
5316
5317       if (x == 0)
5318         pedwarn ("%s has no %s",
5319                  TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
5320                  fieldlist ? _("named members") : _("members"));
5321     }
5322
5323   /* Install struct as DECL_CONTEXT of each field decl.
5324      Also process specified field sizes,m which is found in the DECL_INITIAL.
5325      Store 0 there, except for ": 0" fields (so we can find them
5326      and delete them, below).  */
5327
5328   for (x = fieldlist; x; x = TREE_CHAIN (x))
5329     {
5330       DECL_CONTEXT (x) = t;
5331       DECL_PACKED (x) |= TYPE_PACKED (t);
5332
5333       /* If any field is const, the structure type is pseudo-const.  */
5334       if (TREE_READONLY (x))
5335         C_TYPE_FIELDS_READONLY (t) = 1;
5336       else
5337         {
5338           /* A field that is pseudo-const makes the structure likewise.  */
5339           tree t1 = TREE_TYPE (x);
5340           while (TREE_CODE (t1) == ARRAY_TYPE)
5341             t1 = TREE_TYPE (t1);
5342           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5343               && C_TYPE_FIELDS_READONLY (t1))
5344             C_TYPE_FIELDS_READONLY (t) = 1;
5345         }
5346
5347       /* Any field that is volatile means variables of this type must be
5348          treated in some ways as volatile.  */
5349       if (TREE_THIS_VOLATILE (x))
5350         C_TYPE_FIELDS_VOLATILE (t) = 1;
5351
5352       /* Any field of nominal variable size implies structure is too.  */
5353       if (C_DECL_VARIABLE_SIZE (x))
5354         C_TYPE_VARIABLE_SIZE (t) = 1;
5355
5356       /* Detect invalid nested redefinition.  */
5357       if (TREE_TYPE (x) == t)
5358         error ("nested redefinition of `%s'",
5359                IDENTIFIER_POINTER (TYPE_NAME (t)));
5360
5361       /* Detect invalid bit-field size.  */
5362       if (DECL_INITIAL (x))
5363         STRIP_NOPS (DECL_INITIAL (x));
5364       if (DECL_INITIAL (x))
5365         {
5366           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5367             constant_expression_warning (DECL_INITIAL (x));
5368           else
5369             {
5370               error_with_decl (x,
5371                                "bit-field `%s' width not an integer constant");
5372               DECL_INITIAL (x) = NULL;
5373             }
5374         }
5375
5376       /* Detect invalid bit-field type.  */
5377       if (DECL_INITIAL (x)
5378           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5379           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5380         {
5381           error_with_decl (x, "bit-field `%s' has invalid type");
5382           DECL_INITIAL (x) = NULL;
5383         }
5384
5385       if (DECL_INITIAL (x) && pedantic
5386           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5387           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5388           /* Accept an enum that's equivalent to int or unsigned int.  */
5389           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5390                && (TYPE_PRECISION (TREE_TYPE (x))
5391                    == TYPE_PRECISION (integer_type_node))))
5392         pedwarn_with_decl (x, "bit-field `%s' type invalid in ISO C");
5393
5394       /* Detect and ignore out of range field width and process valid
5395          field widths.  */
5396       if (DECL_INITIAL (x))
5397         {
5398           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5399             error_with_decl (x, "negative width in bit-field `%s'");
5400           else if (0 < compare_tree_int (DECL_INITIAL (x),
5401                                          TYPE_PRECISION (TREE_TYPE (x))))
5402             pedwarn_with_decl (x, "width of `%s' exceeds its type");
5403           else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5404             error_with_decl (x, "zero width for bit-field `%s'");
5405           else
5406             {
5407               /* The test above has assured us that TREE_INT_CST_HIGH is 0.  */
5408               unsigned HOST_WIDE_INT width
5409                 = TREE_INT_CST_LOW (DECL_INITIAL (x));
5410
5411               if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5412                   && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5413                                              TREE_UNSIGNED (TREE_TYPE (x)))
5414                       || (width
5415                           < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5416                                            TREE_UNSIGNED (TREE_TYPE (x))))))
5417                 warning_with_decl (x,
5418                                    "`%s' is narrower than values of its type");
5419
5420               DECL_SIZE (x) = bitsize_int (width);
5421               DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
5422
5423               if (width == 0)
5424                 {
5425                   /* field size 0 => force desired amount of alignment.  */
5426 #ifdef EMPTY_FIELD_BOUNDARY
5427                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5428 #endif
5429 #ifdef PCC_BITFIELD_TYPE_MATTERS
5430                   if (PCC_BITFIELD_TYPE_MATTERS)
5431                     {
5432                       DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5433                                             TYPE_ALIGN (TREE_TYPE (x)));
5434                       DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5435                     }
5436 #endif
5437                 }
5438             }
5439         }
5440
5441       else if (TREE_TYPE (x) != error_mark_node)
5442         {
5443           unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5444                                     : TYPE_ALIGN (TREE_TYPE (x)));
5445
5446           /* Non-bit-fields are aligned for their type, except packed
5447              fields which require only BITS_PER_UNIT alignment.  */
5448           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5449           if (! DECL_PACKED (x))
5450             DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5451         }
5452
5453       DECL_INITIAL (x) = 0;
5454     }
5455
5456   /* Delete all duplicate fields from the fieldlist */
5457   for (x = fieldlist; x && TREE_CHAIN (x);)
5458     /* Anonymous fields aren't duplicates.  */
5459     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5460       x = TREE_CHAIN (x);
5461     else
5462       {
5463         register tree y = fieldlist;
5464
5465         while (1)
5466           {
5467             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5468               break;
5469             if (y == x)
5470               break;
5471             y = TREE_CHAIN (y);
5472           }
5473         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5474           {
5475             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5476             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5477           }
5478         else
5479           x = TREE_CHAIN (x);
5480       }
5481
5482   /* Now we have the nearly final fieldlist.  Record it,
5483      then lay out the structure or union (including the fields).  */
5484
5485   TYPE_FIELDS (t) = fieldlist;
5486
5487   layout_type (t);
5488
5489   /* Delete all zero-width bit-fields from the fieldlist */
5490   {
5491     tree *fieldlistp = &fieldlist;
5492     while (*fieldlistp)
5493       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5494         *fieldlistp = TREE_CHAIN (*fieldlistp);
5495       else
5496         fieldlistp = &TREE_CHAIN (*fieldlistp);
5497   }
5498
5499   /*  Now we have the truly final field list.
5500       Store it in this type and in the variants.  */
5501
5502   TYPE_FIELDS (t) = fieldlist;
5503
5504   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5505     {
5506       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5507       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5508       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5509       TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5510     }
5511
5512   /* If this was supposed to be a transparent union, but we can't
5513      make it one, warn and turn off the flag.  */
5514   if (TREE_CODE (t) == UNION_TYPE
5515       && TYPE_TRANSPARENT_UNION (t)
5516       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5517     {
5518       TYPE_TRANSPARENT_UNION (t) = 0;
5519       warning ("union cannot be made transparent");
5520     }
5521
5522   /* If this structure or union completes the type of any previous
5523      variable declaration, lay it out and output its rtl.  */
5524
5525   if (current_binding_level->n_incomplete != 0)
5526     {
5527       tree decl;
5528       for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5529         {
5530           if (TREE_TYPE (decl) == t
5531               && TREE_CODE (decl) != TYPE_DECL)
5532             {
5533               layout_decl (decl, 0);
5534               /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
5535               maybe_objc_check_decl (decl);
5536               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
5537               if (! toplevel)
5538                 expand_decl (decl);
5539               --current_binding_level->n_incomplete;
5540             }
5541           else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5542                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5543             {
5544               tree element = TREE_TYPE (decl);
5545               while (TREE_CODE (element) == ARRAY_TYPE)
5546                 element = TREE_TYPE (element);
5547               if (element == t)
5548                 layout_array_type (TREE_TYPE (decl));
5549             }
5550         }
5551     }
5552
5553   /* Finish debugging output for this type.  */
5554   rest_of_type_compilation (t, toplevel);
5555
5556   return t;
5557 }
5558
5559 /* Lay out the type T, and its element type, and so on.  */
5560
5561 static void
5562 layout_array_type (t)
5563      tree t;
5564 {
5565   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5566     layout_array_type (TREE_TYPE (t));
5567   layout_type (t);
5568 }
5569 \f
5570 /* Begin compiling the definition of an enumeration type.
5571    NAME is its name (or null if anonymous).
5572    Returns the type object, as yet incomplete.
5573    Also records info about it so that build_enumerator
5574    may be used to declare the individual values as they are read.  */
5575
5576 tree
5577 start_enum (name)
5578      tree name;
5579 {
5580   register tree enumtype = 0;
5581
5582   /* If this is the real definition for a previous forward reference,
5583      fill in the contents in the same object that used to be the
5584      forward reference.  */
5585
5586   if (name != 0)
5587     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5588
5589   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5590     {
5591       enumtype = make_node (ENUMERAL_TYPE);
5592       pushtag (name, enumtype);
5593     }
5594
5595   C_TYPE_BEING_DEFINED (enumtype) = 1;
5596
5597   if (TYPE_VALUES (enumtype) != 0)
5598     {
5599       /* This enum is a named one that has been declared already.  */
5600       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5601
5602       /* Completely replace its old definition.
5603          The old enumerators remain defined, however.  */
5604       TYPE_VALUES (enumtype) = 0;
5605     }
5606
5607   enum_next_value = integer_zero_node;
5608   enum_overflow = 0;
5609
5610   if (flag_short_enums)
5611     TYPE_PACKED (enumtype) = 1;
5612
5613   return enumtype;
5614 }
5615
5616 /* After processing and defining all the values of an enumeration type,
5617    install their decls in the enumeration type and finish it off.
5618    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5619    and ATTRIBUTES are the specified attributes.
5620    Returns ENUMTYPE.  */
5621
5622 tree
5623 finish_enum (enumtype, values, attributes)
5624      tree enumtype;
5625      tree values;
5626      tree attributes;
5627 {
5628   register tree pair, tem;
5629   tree minnode = 0, maxnode = 0, enum_value_type;
5630   int precision, unsign;
5631   int toplevel = (global_binding_level == current_binding_level);
5632
5633   if (in_parm_level_p ())
5634     warning ("enum defined inside parms");
5635
5636   decl_attributes (enumtype, attributes, NULL_TREE);
5637
5638   /* Calculate the maximum value of any enumerator in this type.  */
5639
5640   if (values == error_mark_node)
5641     minnode = maxnode = integer_zero_node;
5642   else
5643     {
5644       minnode = maxnode = TREE_VALUE (values);
5645       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5646         {
5647           tree value = TREE_VALUE (pair);
5648           if (tree_int_cst_lt (maxnode, value))
5649             maxnode = value;
5650           if (tree_int_cst_lt (value, minnode))
5651             minnode = value;
5652         }
5653     }
5654
5655   /* Construct the final type of this enumeration.  It is the same
5656      as one of the integral types - the narrowest one that fits, except
5657      that normally we only go as narrow as int - and signed iff any of
5658      the values are negative.  */
5659   unsign = (tree_int_cst_sgn (minnode) >= 0);
5660   precision = MAX (min_precision (minnode, unsign),
5661                    min_precision (maxnode, unsign));
5662   if (!TYPE_PACKED (enumtype))
5663     precision = MAX (precision, TYPE_PRECISION (integer_type_node));
5664   if (type_for_size (precision, unsign) == 0)
5665     {
5666       warning ("enumeration values exceed range of largest integer");
5667       precision = TYPE_PRECISION (long_long_integer_type_node);
5668     }
5669
5670   if (precision == TYPE_PRECISION (integer_type_node))
5671     enum_value_type = type_for_size (precision, 0);
5672   else
5673     enum_value_type = enumtype;
5674
5675   TYPE_MIN_VALUE (enumtype) = minnode;
5676   TYPE_MAX_VALUE (enumtype) = maxnode;
5677   TYPE_PRECISION (enumtype) = precision;
5678   TREE_UNSIGNED (enumtype) = unsign;
5679   TYPE_SIZE (enumtype) = 0;
5680   layout_type (enumtype);
5681
5682   if (values != error_mark_node)
5683     {
5684       /* Change the type of the enumerators to be the enum type.  We
5685          need to do this irrespective of the size of the enum, for
5686          proper type checking.  Replace the DECL_INITIALs of the
5687          enumerators, and the value slots of the list, with copies
5688          that have the enum type; they cannot be modified in place
5689          because they may be shared (e.g.  integer_zero_node) Finally,
5690          change the purpose slots to point to the names of the decls.  */
5691       for (pair = values; pair; pair = TREE_CHAIN (pair))
5692         {
5693           tree enu = TREE_PURPOSE (pair);
5694
5695           TREE_TYPE (enu) = enumtype;
5696           DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5697           DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5698           DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5699           DECL_USER_ALIGN (enu) = TYPE_USER_ALIGN (enumtype);
5700           DECL_MODE (enu) = TYPE_MODE (enumtype);
5701
5702           /* The ISO C Standard mandates enumerators to have type int,
5703              even though the underlying type of an enum type is
5704              unspecified.  Here we convert any enumerators that fit in
5705              an int to type int, to avoid promotions to unsigned types
5706              when comparing integers with enumerators that fit in the
5707              int range.  When -pedantic is given, build_enumerator()
5708              would have already taken care of those that don't fit.  */
5709           if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5710             DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5711           else
5712             DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5713
5714           TREE_PURPOSE (pair) = DECL_NAME (enu);
5715           TREE_VALUE (pair) = DECL_INITIAL (enu);
5716         }
5717
5718       TYPE_VALUES (enumtype) = values;
5719     }
5720
5721   /* Fix up all variant types of this enum type.  */
5722   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5723     {
5724       if (tem == enumtype)
5725         continue;
5726       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5727       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5728       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5729       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5730       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5731       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5732       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5733       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5734       TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5735       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5736     }
5737
5738   /* Finish debugging output for this type.  */
5739   rest_of_type_compilation (enumtype, toplevel);
5740
5741   return enumtype;
5742 }
5743
5744 /* Build and install a CONST_DECL for one value of the
5745    current enumeration type (one that was begun with start_enum).
5746    Return a tree-list containing the CONST_DECL and its value.
5747    Assignment of sequential values by default is handled here.  */
5748
5749 tree
5750 build_enumerator (name, value)
5751      tree name, value;
5752 {
5753   register tree decl, type;
5754
5755   /* Validate and default VALUE.  */
5756
5757   /* Remove no-op casts from the value.  */
5758   if (value)
5759     STRIP_TYPE_NOPS (value);
5760
5761   if (value != 0)
5762     {
5763       if (TREE_CODE (value) == INTEGER_CST)
5764         {
5765           value = default_conversion (value);
5766           constant_expression_warning (value);
5767         }
5768       else
5769         {
5770           error ("enumerator value for `%s' not integer constant",
5771                  IDENTIFIER_POINTER (name));
5772           value = 0;
5773         }
5774     }
5775
5776   /* Default based on previous value.  */
5777   /* It should no longer be possible to have NON_LVALUE_EXPR
5778      in the default.  */
5779   if (value == 0)
5780     {
5781       value = enum_next_value;
5782       if (enum_overflow)
5783         error ("overflow in enumeration values");
5784     }
5785
5786   if (pedantic && ! int_fits_type_p (value, integer_type_node))
5787     {
5788       pedwarn ("ISO C restricts enumerator values to range of `int'");
5789       value = convert (integer_type_node, value);
5790     }
5791
5792   /* Set basis for default for next value.  */
5793   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5794   enum_overflow = tree_int_cst_lt (enum_next_value, value);
5795
5796   /* Now create a declaration for the enum value name.  */
5797
5798   type = TREE_TYPE (value);
5799   type = type_for_size (MAX (TYPE_PRECISION (type),
5800                              TYPE_PRECISION (integer_type_node)),
5801                         ((flag_traditional
5802                           || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
5803                          && TREE_UNSIGNED (type)));
5804
5805   decl = build_decl (CONST_DECL, name, type);
5806   DECL_INITIAL (decl) = convert (type, value);
5807   pushdecl (decl);
5808
5809   return tree_cons (decl, value, NULL_TREE);
5810 }
5811
5812 \f
5813 /* Create the FUNCTION_DECL for a function definition.
5814    DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of
5815    the declaration; they describe the function's name and the type it returns,
5816    but twisted together in a fashion that parallels the syntax of C.
5817
5818    This function creates a binding context for the function body
5819    as well as setting up the FUNCTION_DECL in current_function_decl.
5820
5821    Returns 1 on success.  If the DECLARATOR is not suitable for a function
5822    (it defines a datum instead), we return 0, which tells
5823    yyparse to report a parse error.  */
5824
5825 int
5826 start_function (declspecs, declarator, prefix_attributes, attributes)
5827      tree declarator, declspecs, prefix_attributes, attributes;
5828 {
5829   tree decl1, old_decl;
5830   tree restype;
5831   int old_immediate_size_expand = immediate_size_expand;
5832
5833   current_function_returns_value = 0;  /* Assume, until we see it does.  */
5834   current_function_returns_null = 0;
5835   warn_about_return_type = 0;
5836   current_extern_inline = 0;
5837   c_function_varargs = 0;
5838   named_labels = 0;
5839   shadowed_labels = 0;
5840
5841   /* Don't expand any sizes in the return type of the function.  */
5842   immediate_size_expand = 0;
5843
5844   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5845
5846   /* If the declarator is not suitable for a function definition,
5847      cause a syntax error.  */
5848   if (decl1 == 0)
5849     {
5850       immediate_size_expand = old_immediate_size_expand;
5851       return 0;
5852     }
5853
5854   decl_attributes (decl1, prefix_attributes, attributes);
5855
5856   announce_function (decl1);
5857
5858   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
5859     {
5860       error ("return type is an incomplete type");
5861       /* Make it return void instead.  */
5862       TREE_TYPE (decl1)
5863         = build_function_type (void_type_node,
5864                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5865     }
5866
5867   if (warn_about_return_type)
5868     pedwarn_c99 ("return type defaults to `int'");
5869
5870   /* Save the parm names or decls from this function's declarator
5871      where store_parm_decls will find them.  */
5872   current_function_parms = last_function_parms;
5873   current_function_parm_tags = last_function_parm_tags;
5874
5875   /* Make the init_value nonzero so pushdecl knows this is not tentative.
5876      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
5877   DECL_INITIAL (decl1) = error_mark_node;
5878
5879   /* If this definition isn't a prototype and we had a prototype declaration
5880      before, copy the arg type info from that prototype.
5881      But not if what we had before was a builtin function.  */
5882   old_decl = lookup_name_current_level (DECL_NAME (decl1));
5883   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5884       && !DECL_BUILT_IN (old_decl)
5885       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5886           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5887       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5888     {
5889       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5890       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
5891       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
5892     }
5893
5894   /* If there is no explicit declaration, look for any out-of-scope implicit
5895      declarations.  */
5896   if (old_decl == 0)
5897     old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
5898
5899   /* Optionally warn of old-fashioned def with no previous prototype.  */
5900   if (warn_strict_prototypes
5901       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5902       && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
5903     warning ("function declaration isn't a prototype");
5904   /* Optionally warn of any global def with no previous prototype.  */
5905   else if (warn_missing_prototypes
5906            && TREE_PUBLIC (decl1)
5907            && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
5908            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5909     warning_with_decl (decl1, "no previous prototype for `%s'");
5910   /* Optionally warn of any def with no previous prototype
5911      if the function has already been used.  */
5912   else if (warn_missing_prototypes
5913            && old_decl != 0 && TREE_USED (old_decl)
5914            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
5915     warning_with_decl (decl1,
5916                        "`%s' was used with no prototype before its definition");
5917   /* Optionally warn of any global def with no previous declaration.  */
5918   else if (warn_missing_declarations
5919            && TREE_PUBLIC (decl1)
5920            && old_decl == 0
5921            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5922     warning_with_decl (decl1, "no previous declaration for `%s'");
5923   /* Optionally warn of any def with no previous declaration
5924      if the function has already been used.  */
5925   else if (warn_missing_declarations
5926            && old_decl != 0 && TREE_USED (old_decl)
5927            && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
5928     warning_with_decl (decl1,
5929                        "`%s' was used with no declaration before its definition");
5930
5931   /* This is a definition, not a reference.
5932      So normally clear DECL_EXTERNAL.
5933      However, `extern inline' acts like a declaration
5934      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
5935   DECL_EXTERNAL (decl1) = current_extern_inline;
5936
5937 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
5938   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attributes);
5939 #endif
5940
5941   /* This function exists in static storage.
5942      (This does not mean `static' in the C sense!)  */
5943   TREE_STATIC (decl1) = 1;
5944
5945   /* A nested function is not global.  */
5946   if (current_function_decl != 0)
5947     TREE_PUBLIC (decl1) = 0;
5948
5949   /* Warn for unlikely, improbable, or stupid declarations of `main'.  */
5950   if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
5951     {
5952       tree args;
5953       int argct = 0;
5954
5955       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5956           != integer_type_node)
5957         pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
5958
5959       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
5960            args = TREE_CHAIN (args))
5961         {
5962           tree type = args ? TREE_VALUE (args) : 0;
5963
5964           if (type == void_type_node)
5965             break;
5966
5967           ++argct;
5968           switch (argct)
5969             {
5970             case 1:
5971               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
5972                 pedwarn_with_decl (decl1,
5973                                    "first argument of `%s' should be `int'");
5974               break;
5975
5976             case 2:
5977               if (TREE_CODE (type) != POINTER_TYPE
5978                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5979                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5980                       != char_type_node))
5981                 pedwarn_with_decl (decl1,
5982                                    "second argument of `%s' should be `char **'");
5983               break;
5984
5985             case 3:
5986               if (TREE_CODE (type) != POINTER_TYPE
5987                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5988                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5989                       != char_type_node))
5990                 pedwarn_with_decl (decl1,
5991                                    "third argument of `%s' should probably be `char **'");
5992               break;
5993             }
5994         }
5995
5996       /* It is intentional that this message does not mention the third
5997          argument, which is warned for only pedantically, because it's
5998          blessed by mention in an appendix of the standard.  */
5999       if (argct > 0 && (argct < 2 || argct > 3))
6000         pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6001
6002       if (argct == 3 && pedantic)
6003         pedwarn_with_decl (decl1, "third argument of `%s' is deprecated");
6004
6005       if (! TREE_PUBLIC (decl1))
6006         pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6007     }
6008
6009   /* Record the decl so that the function name is defined.
6010      If we already have a decl for this name, and it is a FUNCTION_DECL,
6011      use the old decl.  */
6012
6013   current_function_decl = pushdecl (decl1);
6014
6015   pushlevel (0);
6016   declare_parm_level (1);
6017   current_binding_level->subblocks_tag_transparent = 1;
6018
6019   make_function_rtl (current_function_decl);
6020
6021   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6022   /* Promote the value to int before returning it.  */
6023   if (C_PROMOTING_INTEGER_TYPE_P (restype))
6024     {
6025       /* It retains unsignedness if traditional
6026          or if not really getting wider.  */
6027       if (TREE_UNSIGNED (restype)
6028           && (flag_traditional
6029               || (TYPE_PRECISION (restype)
6030                   == TYPE_PRECISION (integer_type_node))))
6031         restype = unsigned_type_node;
6032       else
6033         restype = integer_type_node;
6034     }
6035   DECL_RESULT (current_function_decl)
6036     = build_decl (RESULT_DECL, NULL_TREE, restype);
6037
6038   /* If this fcn was already referenced via a block-scope `extern' decl
6039      (or an implicit decl), propagate certain information about the usage.  */
6040   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6041     TREE_ADDRESSABLE (current_function_decl) = 1;
6042
6043   immediate_size_expand = old_immediate_size_expand;
6044
6045   return 1;
6046 }
6047
6048 /* Record that this function is going to be a varargs function.
6049    This is called before store_parm_decls, which is too early
6050    to call mark_varargs directly.  */
6051
6052 void
6053 c_mark_varargs ()
6054 {
6055   c_function_varargs = 1;
6056 }
6057 \f
6058 /* Store the parameter declarations into the current function declaration.
6059    This is called after parsing the parameter declarations, before
6060    digesting the body of the function.
6061
6062    For an old-style definition, modify the function's type
6063    to specify at least the number of arguments.  */
6064
6065 void
6066 store_parm_decls ()
6067 {
6068   register tree fndecl = current_function_decl;
6069   register tree parm;
6070
6071   /* This is either a chain of PARM_DECLs (if a prototype was used)
6072      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
6073   tree specparms = current_function_parms;
6074
6075   /* This is a list of types declared among parms in a prototype.  */
6076   tree parmtags = current_function_parm_tags;
6077
6078   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
6079   register tree parmdecls = getdecls ();
6080
6081   /* This is a chain of any other decls that came in among the parm
6082      declarations.  If a parm is declared with  enum {foo, bar} x;
6083      then CONST_DECLs for foo and bar are put here.  */
6084   tree nonparms = 0;
6085
6086   /* Nonzero if this definition is written with a prototype.  */
6087   int prototype = 0;
6088
6089   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6090     {
6091       /* This case is when the function was defined with an ANSI prototype.
6092          The parms already have decls, so we need not do anything here
6093          except record them as in effect
6094          and complain if any redundant old-style parm decls were written.  */
6095
6096       register tree next;
6097       tree others = 0;
6098
6099       prototype = 1;
6100
6101       if (parmdecls != 0)
6102         {
6103           tree decl, link;
6104
6105           error_with_decl (fndecl,
6106                            "parm types given both in parmlist and separately");
6107           /* Get rid of the erroneous decls; don't keep them on
6108              the list of parms, since they might not be PARM_DECLs.  */
6109           for (decl = current_binding_level->names;
6110                decl; decl = TREE_CHAIN (decl))
6111             if (DECL_NAME (decl))
6112               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6113           for (link = current_binding_level->shadowed;
6114                link; link = TREE_CHAIN (link))
6115             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6116           current_binding_level->names = 0;
6117           current_binding_level->shadowed = 0;
6118         }
6119
6120       specparms = nreverse (specparms);
6121       for (parm = specparms; parm; parm = next)
6122         {
6123           next = TREE_CHAIN (parm);
6124           if (TREE_CODE (parm) == PARM_DECL)
6125             {
6126               if (DECL_NAME (parm) == 0)
6127                 error_with_decl (parm, "parameter name omitted");
6128               else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
6129                        && VOID_TYPE_P (TREE_TYPE (parm)))
6130                 {
6131                   error_with_decl (parm, "parameter `%s' declared void");
6132                   /* Change the type to error_mark_node so this parameter
6133                      will be ignored by assign_parms.  */
6134                   TREE_TYPE (parm) = error_mark_node;
6135                 }
6136               pushdecl (parm);
6137             }
6138           else
6139             {
6140               /* If we find an enum constant or a type tag,
6141                  put it aside for the moment.  */
6142               TREE_CHAIN (parm) = 0;
6143               others = chainon (others, parm);
6144             }
6145         }
6146
6147       /* Get the decls in their original chain order
6148          and record in the function.  */
6149       DECL_ARGUMENTS (fndecl) = getdecls ();
6150
6151 #if 0
6152       /* If this function takes a variable number of arguments,
6153          add a phony parameter to the end of the parm list,
6154          to represent the position of the first unnamed argument.  */
6155       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6156           != void_type_node)
6157         {
6158           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6159           /* Let's hope the address of the unnamed parm
6160              won't depend on its type.  */
6161           TREE_TYPE (dummy) = integer_type_node;
6162           DECL_ARG_TYPE (dummy) = integer_type_node;
6163           DECL_ARGUMENTS (fndecl) = chainon (DECL_ARGUMENTS (fndecl), dummy);
6164         }
6165 #endif
6166
6167       /* Now pushdecl the enum constants.  */
6168       for (parm = others; parm; parm = next)
6169         {
6170           next = TREE_CHAIN (parm);
6171           if (DECL_NAME (parm) == 0)
6172             ;
6173           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6174             ;
6175           else if (TREE_CODE (parm) != PARM_DECL)
6176             pushdecl (parm);
6177         }
6178
6179       storetags (chainon (parmtags, gettags ()));
6180     }
6181   else
6182     {
6183       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6184          each with a parm name as the TREE_VALUE.
6185
6186          PARMDECLS is a chain of declarations for parameters.
6187          Warning! It can also contain CONST_DECLs which are not parameters
6188          but are names of enumerators of any enum types
6189          declared among the parameters.
6190
6191          First match each formal parameter name with its declaration.
6192          Associate decls with the names and store the decls
6193          into the TREE_PURPOSE slots.  */
6194
6195       /* We use DECL_WEAK as a flag to show which parameters have been
6196          seen already since it is not used on PARM_DECL or CONST_DECL.  */
6197       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6198         DECL_WEAK (parm) = 0;
6199
6200       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6201         {
6202           register tree tail, found = NULL;
6203
6204           if (TREE_VALUE (parm) == 0)
6205             {
6206               error_with_decl (fndecl,
6207                                "parameter name missing from parameter list");
6208               TREE_PURPOSE (parm) = 0;
6209               continue;
6210             }
6211
6212           /* See if any of the parmdecls specifies this parm by name.
6213              Ignore any enumerator decls.  */
6214           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6215             if (DECL_NAME (tail) == TREE_VALUE (parm)
6216                 && TREE_CODE (tail) == PARM_DECL)
6217               {
6218                 found = tail;
6219                 break;
6220               }
6221
6222           /* If declaration already marked, we have a duplicate name.
6223              Complain, and don't use this decl twice.   */
6224           if (found && DECL_WEAK (found))
6225             {
6226               error_with_decl (found, "multiple parameters named `%s'");
6227               found = 0;
6228             }
6229
6230           /* If the declaration says "void", complain and ignore it.  */
6231           if (found && VOID_TYPE_P (TREE_TYPE (found)))
6232             {
6233               error_with_decl (found, "parameter `%s' declared void");
6234               TREE_TYPE (found) = integer_type_node;
6235               DECL_ARG_TYPE (found) = integer_type_node;
6236               layout_decl (found, 0);
6237             }
6238
6239           /* Traditionally, a parm declared float is actually a double.  */
6240           if (found && flag_traditional
6241               && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6242             {
6243               TREE_TYPE (found) = double_type_node;
6244               DECL_ARG_TYPE (found) = double_type_node;
6245               layout_decl (found, 0);
6246             }
6247
6248           /* If no declaration found, default to int.  */
6249           if (!found)
6250             {
6251               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6252                                   integer_type_node);
6253               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6254               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6255               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6256               if (flag_isoc99)
6257                 pedwarn_with_decl (found, "type of `%s' defaults to `int'");
6258               else if (extra_warnings)
6259                 warning_with_decl (found, "type of `%s' defaults to `int'");
6260               pushdecl (found);
6261             }
6262
6263           TREE_PURPOSE (parm) = found;
6264
6265           /* Mark this decl as "already found".  */
6266           DECL_WEAK (found) = 1;
6267         }
6268
6269       /* Put anything which is on the parmdecls chain and which is
6270          not a PARM_DECL onto the list NONPARMS.  (The types of
6271          non-parm things which might appear on the list include
6272          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6273          any actual PARM_DECLs not matched with any names.  */
6274
6275       nonparms = 0;
6276       for (parm = parmdecls; parm;)
6277         {
6278           tree next = TREE_CHAIN (parm);
6279           TREE_CHAIN (parm) = 0;
6280
6281           if (TREE_CODE (parm) != PARM_DECL)
6282             nonparms = chainon (nonparms, parm);
6283           else
6284             {
6285               /* Complain about args with incomplete types.  */
6286               if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6287                 {
6288                   error_with_decl (parm, "parameter `%s' has incomplete type");
6289                   TREE_TYPE (parm) = error_mark_node;
6290                 }
6291
6292               if (! DECL_WEAK (parm))
6293                 {
6294                   error_with_decl (parm,
6295                                    "declaration for parameter `%s' but no such parameter");
6296                   /* Pretend the parameter was not missing.
6297                      This gets us to a standard state and minimizes
6298                      further error messages.  */
6299                   specparms
6300                     = chainon (specparms,
6301                                tree_cons (parm, NULL_TREE, NULL_TREE));
6302                 }
6303             }
6304
6305           parm = next;
6306         }
6307
6308       /* Chain the declarations together in the order of the list of
6309          names.  Store that chain in the function decl, replacing the
6310          list of names.  */
6311       parm = specparms;
6312       DECL_ARGUMENTS (fndecl) = 0;
6313       {
6314         register tree last;
6315         for (last = 0; parm; parm = TREE_CHAIN (parm))
6316           if (TREE_PURPOSE (parm))
6317             {
6318               if (last == 0)
6319                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6320               else
6321                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6322               last = TREE_PURPOSE (parm);
6323               TREE_CHAIN (last) = 0;
6324             }
6325       }
6326
6327       /* If there was a previous prototype,
6328          set the DECL_ARG_TYPE of each argument according to
6329          the type previously specified, and report any mismatches.  */
6330
6331       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6332         {
6333           register tree type;
6334           for (parm = DECL_ARGUMENTS (fndecl),
6335                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6336                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6337                                  != void_type_node));
6338                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6339             {
6340               if (parm == 0 || type == 0
6341                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6342                 {
6343                   error ("number of arguments doesn't match prototype");
6344                   error_with_file_and_line (current_function_prototype_file,
6345                                             current_function_prototype_line,
6346                                             "prototype declaration");
6347                   break;
6348                 }
6349               /* Type for passing arg must be consistent
6350                  with that declared for the arg.  */
6351               if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6352                 {
6353                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6354                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6355                     {
6356                       /* Adjust argument to match prototype.  E.g. a previous
6357                          `int foo(float);' prototype causes
6358                          `int foo(x) float x; {...}' to be treated like
6359                          `int foo(float x) {...}'.  This is particularly
6360                          useful for argument types like uid_t.  */
6361                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6362
6363                       if (PROMOTE_PROTOTYPES
6364                           && (TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6365                               || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6366                           && TYPE_PRECISION (TREE_TYPE (parm))
6367                           < TYPE_PRECISION (integer_type_node))
6368                         DECL_ARG_TYPE (parm) = integer_type_node;
6369
6370                       if (pedantic)
6371                         {
6372                           pedwarn ("promoted argument `%s' doesn't match prototype",
6373                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6374                           warning_with_file_and_line
6375                             (current_function_prototype_file,
6376                              current_function_prototype_line,
6377                              "prototype declaration");
6378                         }
6379                     }
6380                   /* If -traditional, allow `int' argument to match
6381                      `unsigned' prototype.  */
6382                   else if (! (flag_traditional
6383                               && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6384                               && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6385                     {
6386                       error ("argument `%s' doesn't match prototype",
6387                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6388                       error_with_file_and_line (current_function_prototype_file,
6389                                                 current_function_prototype_line,
6390                                                 "prototype declaration");
6391                     }
6392                 }
6393             }
6394           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6395         }
6396
6397       /* Otherwise, create a prototype that would match.  */
6398
6399       else
6400         {
6401           tree actual = 0, last = 0, type;
6402
6403           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6404             {
6405               type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6406               if (last)
6407                 TREE_CHAIN (last) = type;
6408               else
6409                 actual = type;
6410               last = type;
6411             }
6412           type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6413           if (last)
6414             TREE_CHAIN (last) = type;
6415           else
6416             actual = type;
6417
6418           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6419              of the type of this function, but we need to avoid having this
6420              affect the types of other similarly-typed functions, so we must
6421              first force the generation of an identical (but separate) type
6422              node for the relevant function type.  The new node we create
6423              will be a variant of the main variant of the original function
6424              type.  */
6425
6426           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6427
6428           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6429         }
6430
6431       /* Now store the final chain of decls for the arguments
6432          as the decl-chain of the current lexical scope.
6433          Put the enumerators in as well, at the front so that
6434          DECL_ARGUMENTS is not modified.  */
6435
6436       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6437     }
6438
6439   /* Make sure the binding level for the top of the function body
6440      gets a BLOCK if there are any in the function.
6441      Otherwise, the dbx output is wrong.  */
6442
6443   keep_next_if_subblocks = 1;
6444
6445   /* ??? This might be an improvement,
6446      but needs to be thought about some more.  */
6447 #if 0
6448   keep_next_level_flag = 1;
6449 #endif
6450
6451   /* Write a record describing this function definition to the prototypes
6452      file (if requested).  */
6453
6454   gen_aux_info_record (fndecl, 1, 0, prototype);
6455
6456   /* Initialize the RTL code for the function.  */
6457
6458   init_function_start (fndecl, input_filename, lineno);
6459
6460   /* Begin the statement tree for this function.  */
6461   DECL_LANG_SPECIFIC (current_function_decl)
6462     =((struct lang_decl *) ggc_alloc (sizeof (struct lang_decl)));
6463   begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6464
6465   /* This function is being processed in whole-function mode.  */
6466   cfun->x_whole_function_mode_p = 1;
6467
6468   /* Even though we're inside a function body, we still don't want to
6469      call expand_expr to calculate the size of a variable-sized array.
6470      We haven't necessarily assigned RTL to all variables yet, so it's
6471      not safe to try to expand expressions involving them.  */
6472   immediate_size_expand = 0;
6473   cfun->x_dont_save_pending_sizes_p = 1;
6474 }
6475 \f
6476 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6477    each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
6478    stands for an ellipsis in the identifier list.
6479
6480    PARMLIST is the data returned by get_parm_info for the
6481    parmlist that follows the semicolon.
6482
6483    We return a value of the same sort that get_parm_info returns,
6484    except that it describes the combination of identifiers and parmlist.  */
6485
6486 tree
6487 combine_parm_decls (specparms, parmlist, void_at_end)
6488      tree specparms, parmlist;
6489      int void_at_end;
6490 {
6491   register tree fndecl = current_function_decl;
6492   register tree parm;
6493
6494   tree parmdecls = TREE_PURPOSE (parmlist);
6495
6496   /* This is a chain of any other decls that came in among the parm
6497      declarations.  They were separated already by get_parm_info,
6498      so we just need to keep them separate.  */
6499   tree nonparms = TREE_VALUE (parmlist);
6500
6501   tree types = 0;
6502
6503   for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6504     DECL_WEAK (parm) = 0;
6505
6506   for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6507     {
6508       register tree tail, found = NULL;
6509
6510       /* See if any of the parmdecls specifies this parm by name.  */
6511       for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6512         if (DECL_NAME (tail) == TREE_VALUE (parm))
6513           {
6514             found = tail;
6515             break;
6516           }
6517
6518       /* If declaration already marked, we have a duplicate name.
6519          Complain, and don't use this decl twice.   */
6520       if (found && DECL_WEAK (found))
6521         {
6522           error_with_decl (found, "multiple parameters named `%s'");
6523           found = 0;
6524         }
6525
6526       /* If the declaration says "void", complain and ignore it.  */
6527       if (found && VOID_TYPE_P (TREE_TYPE (found)))
6528         {
6529           error_with_decl (found, "parameter `%s' declared void");
6530           TREE_TYPE (found) = integer_type_node;
6531           DECL_ARG_TYPE (found) = integer_type_node;
6532           layout_decl (found, 0);
6533         }
6534
6535       /* Traditionally, a parm declared float is actually a double.  */
6536       if (found && flag_traditional
6537           && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6538         {
6539           TREE_TYPE (found) = double_type_node;
6540           DECL_ARG_TYPE (found) = double_type_node;
6541           layout_decl (found, 0);
6542         }
6543
6544       /* If no declaration found, default to int.  */
6545       if (!found)
6546         {
6547           found = build_decl (PARM_DECL, TREE_VALUE (parm),
6548                               integer_type_node);
6549           DECL_ARG_TYPE (found) = TREE_TYPE (found);
6550           DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6551           DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6552           error_with_decl (found, "type of parameter `%s' is not declared");
6553           pushdecl (found);
6554         }
6555
6556       TREE_PURPOSE (parm) = found;
6557
6558       /* Mark this decl as "already found".  */
6559       DECL_WEAK (found) = 1;
6560     }
6561
6562   /* Complain about any actual PARM_DECLs not matched with any names.  */
6563
6564   for (parm = parmdecls; parm;)
6565     {
6566       tree next = TREE_CHAIN (parm);
6567       TREE_CHAIN (parm) = 0;
6568
6569       /* Complain about args with incomplete types.  */
6570       if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6571         {
6572           error_with_decl (parm, "parameter `%s' has incomplete type");
6573           TREE_TYPE (parm) = error_mark_node;
6574         }
6575
6576       if (! DECL_WEAK (parm))
6577         {
6578           error_with_decl (parm,
6579                            "declaration for parameter `%s' but no such parameter");
6580           /* Pretend the parameter was not missing.
6581              This gets us to a standard state and minimizes
6582              further error messages.  */
6583           specparms
6584             = chainon (specparms,
6585                        tree_cons (parm, NULL_TREE, NULL_TREE));
6586         }
6587
6588       parm = next;
6589     }
6590
6591   /* Chain the declarations together in the order of the list of names.
6592      At the same time, build up a list of their types, in reverse order.  */
6593
6594   parm = specparms;
6595   parmdecls = 0;
6596   {
6597     register tree last;
6598     for (last = 0; parm; parm = TREE_CHAIN (parm))
6599       if (TREE_PURPOSE (parm))
6600         {
6601           if (last == 0)
6602             parmdecls = TREE_PURPOSE (parm);
6603           else
6604             TREE_CHAIN (last) = TREE_PURPOSE (parm);
6605           last = TREE_PURPOSE (parm);
6606           TREE_CHAIN (last) = 0;
6607
6608           types = tree_cons (NULL_TREE, TREE_TYPE (parm), types);
6609         }
6610   }
6611
6612   if (void_at_end)
6613     return tree_cons (parmdecls, nonparms,
6614                       nreverse (tree_cons (NULL_TREE, void_type_node, types)));
6615
6616   return tree_cons (parmdecls, nonparms, nreverse (types));
6617 }
6618 \f
6619 /* Finish up a function declaration and compile that function
6620    all the way to assembler language output.  The free the storage
6621    for the function definition.
6622
6623    This is called after parsing the body of the function definition.
6624
6625    NESTED is nonzero if the function being finished is nested in another.  */
6626
6627 void
6628 finish_function (nested)
6629      int nested;
6630 {
6631   register tree fndecl = current_function_decl;
6632
6633 /*  TREE_READONLY (fndecl) = 1;
6634     This caused &foo to be of type ptr-to-const-function
6635     which then got a warning when stored in a ptr-to-function variable.  */
6636
6637   poplevel (1, 0, 1);
6638   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6639
6640   /* Must mark the RESULT_DECL as being in this function.  */
6641
6642   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6643
6644   /* Obey `register' declarations if `setjmp' is called in this fn.  */
6645   if (flag_traditional && current_function_calls_setjmp)
6646     {
6647       setjmp_protect (DECL_INITIAL (fndecl));
6648       setjmp_protect_args ();
6649     }
6650
6651   if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6652     {
6653       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6654           != integer_type_node)
6655         {
6656           /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6657              If warn_main is -1 (-Wno-main) we don't want to be warned.  */
6658           if (! warn_main)
6659             pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6660         }
6661       else
6662         {
6663 #ifdef DEFAULT_MAIN_RETURN
6664           /* Make it so that `main' always returns success by default.  */
6665           DEFAULT_MAIN_RETURN;
6666 #else
6667           if (flag_isoc99)
6668             c_expand_return (integer_zero_node);
6669 #endif
6670         }
6671     }
6672
6673   /* Tie off the statement tree for this function.  */
6674   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6675   /* Clear out memory we no longer need.  */
6676   free_after_parsing (cfun);
6677   /* Since we never call rest_of_compilation, we never clear
6678      CFUN.  Do so explicitly.  */
6679   free_after_compilation (cfun);
6680   cfun = NULL;
6681
6682   if (! nested)
6683     {
6684       /* Generate RTL for the body of this function.  */
6685       c_expand_body (fndecl, nested);
6686       /* Let the error reporting routines know that we're outside a
6687          function.  For a nested function, this value is used in
6688          pop_c_function_context and then reset via pop_function_context.  */
6689       current_function_decl = NULL;
6690     }
6691 }
6692
6693 /* Generate the RTL for the body of FNDECL.  If NESTED_P is non-zero,
6694    then we are already in the process of generating RTL for another
6695    function.  */
6696
6697 static void
6698 c_expand_body (fndecl, nested_p)
6699      tree fndecl;
6700      int nested_p;
6701 {
6702   /* Squirrel away our current state.  */
6703   if (nested_p)
6704     push_function_context ();
6705
6706   /* Initialize the RTL code for the function.  */
6707   current_function_decl = fndecl;
6708   init_function_start (fndecl, input_filename, lineno);
6709
6710   /* This function is being processed in whole-function mode.  */
6711   cfun->x_whole_function_mode_p = 1;
6712
6713   /* Even though we're inside a function body, we still don't want to
6714      call expand_expr to calculate the size of a variable-sized array.
6715      We haven't necessarily assigned RTL to all variables yet, so it's
6716      not safe to try to expand expressions involving them.  */
6717   immediate_size_expand = 0;
6718   cfun->x_dont_save_pending_sizes_p = 1;
6719
6720   /* Set up parameters and prepare for return, for the function.  */
6721   expand_function_start (fndecl, 0);
6722
6723   /* If this function is `main', emit a call to `__main'
6724      to run global initializers, etc.  */
6725   if (DECL_NAME (fndecl)
6726       && MAIN_NAME_P (DECL_NAME (fndecl))
6727       && DECL_CONTEXT (fndecl) == NULL_TREE)
6728     expand_main_function ();
6729
6730   /* If this is a varargs function, inform function.c.  */
6731   if (c_function_varargs)
6732     mark_varargs ();
6733
6734   /* Generate the RTL for this function.  */
6735   expand_stmt (DECL_SAVED_TREE (fndecl));
6736   /* Allow the body of the function to be garbage collected.  */
6737   DECL_SAVED_TREE (fndecl) = NULL_TREE;
6738
6739   /* We hard-wired immediate_size_expand to zero in start_function.
6740      expand_function_end will decrement this variable.  So, we set the
6741      variable to one here, so that after the decrement it will remain
6742      zero.  */
6743   immediate_size_expand = 1;
6744
6745   /* Allow language dialects to perform special processing.  */
6746   if (lang_expand_function_end)
6747     (*lang_expand_function_end) ();
6748
6749   /* Generate rtl for function exit.  */
6750   expand_function_end (input_filename, lineno, 0);
6751
6752   /* So we can tell if jump_optimize sets it to 1.  */
6753   can_reach_end = 0;
6754
6755   /* If this is a nested function, protect the local variables in the stack
6756      above us from being collected while we're compiling this function.  */
6757   if (nested_p)
6758     ggc_push_context ();
6759
6760   /* Run the optimizers and output the assembler code for this function.  */
6761   rest_of_compilation (fndecl);
6762
6763   /* Undo the GC context switch.  */
6764   if (nested_p)
6765     ggc_pop_context ();
6766
6767   current_function_returns_null |= can_reach_end;
6768
6769   if (warn_missing_noreturn
6770       && !TREE_THIS_VOLATILE (fndecl)
6771       && !current_function_returns_null
6772       && !current_function_returns_value)
6773     warning ("function might be possible candidate for attribute `noreturn'");
6774
6775   if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
6776     warning ("`noreturn' function does return");
6777   else if (warn_return_type && can_reach_end
6778            && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl))))
6779     /* If this function returns non-void and control can drop through,
6780        complain.  */
6781     warning ("control reaches end of non-void function");
6782   /* With just -W, complain only if function returns both with
6783      and without a value.  */
6784   else if (extra_warnings
6785            && current_function_returns_value && current_function_returns_null)
6786     warning ("this function may return with or without a value");
6787
6788   /* If requested, warn about function definitions where the function will
6789      return a value (usually of some struct or union type) which itself will
6790      take up a lot of stack space.  */
6791
6792   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6793     {
6794       tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6795
6796       if (ret_type && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
6797           && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
6798                                    larger_than_size))
6799         {
6800           unsigned int size_as_int
6801             = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
6802
6803           if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
6804             warning_with_decl (fndecl,
6805                                "size of return value of `%s' is %u bytes",
6806                                size_as_int);
6807           else
6808             warning_with_decl (fndecl,
6809                                "size of return value of `%s' is larger than %d bytes",
6810                                larger_than_size);
6811         }
6812     }
6813
6814   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p)
6815     {
6816       /* Stop pointing to the local nodes about to be freed.
6817          But DECL_INITIAL must remain nonzero so we know this
6818          was an actual function definition.
6819          For a nested function, this is done in pop_c_function_context.
6820          If rest_of_compilation set this to 0, leave it 0.  */
6821       if (DECL_INITIAL (fndecl) != 0)
6822         DECL_INITIAL (fndecl) = error_mark_node;
6823
6824       DECL_ARGUMENTS (fndecl) = 0;
6825     }
6826
6827   if (DECL_STATIC_CONSTRUCTOR (fndecl))
6828     {
6829 #ifndef ASM_OUTPUT_CONSTRUCTOR
6830       if (! flag_gnu_linker)
6831         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6832       else
6833 #endif
6834         assemble_constructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
6835
6836     }
6837   if (DECL_STATIC_DESTRUCTOR (fndecl))
6838     {
6839 #ifndef ASM_OUTPUT_DESTRUCTOR
6840       if (! flag_gnu_linker)
6841         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6842       else
6843 #endif
6844         assemble_destructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
6845     }
6846
6847   if (nested_p)
6848     {
6849       /* Return to the enclosing function.  */
6850       pop_function_context ();
6851       /* If the nested function was inline, write it out if that is
6852          necessary.  */
6853       if (!TREE_ASM_WRITTEN (fndecl) && TREE_ADDRESSABLE (fndecl))
6854         {
6855           push_function_context ();
6856           output_inline_function (fndecl);
6857           pop_function_context ();
6858         }
6859     }
6860
6861 }
6862 \f
6863 /* Save and restore the variables in this file and elsewhere
6864    that keep track of the progress of compilation of the current function.
6865    Used for nested functions.  */
6866
6867 struct c_language_function
6868 {
6869   struct language_function base;
6870   tree named_labels;
6871   tree shadowed_labels;
6872   int returns_value;
6873   int returns_null;
6874   int warn_about_return_type;
6875   int extern_inline;
6876   struct binding_level *binding_level;
6877 };
6878
6879 /* Save and reinitialize the variables
6880    used during compilation of a C function.  */
6881
6882 void
6883 push_c_function_context (f)
6884      struct function *f;
6885 {
6886   struct c_language_function *p;
6887   p = ((struct c_language_function *)
6888        xmalloc (sizeof (struct c_language_function)));
6889   f->language = (struct language_function *) p;
6890
6891   p->base.x_stmt_tree = c_stmt_tree;
6892   p->base.x_scope_stmt_stack = c_scope_stmt_stack;
6893   p->base.x_function_name_declared_p = c_function_name_declared_p;
6894   p->named_labels = named_labels;
6895   p->shadowed_labels = shadowed_labels;
6896   p->returns_value = current_function_returns_value;
6897   p->returns_null = current_function_returns_null;
6898   p->warn_about_return_type = warn_about_return_type;
6899   p->extern_inline = current_extern_inline;
6900   p->binding_level = current_binding_level;
6901 }
6902
6903 /* Restore the variables used during compilation of a C function.  */
6904
6905 void
6906 pop_c_function_context (f)
6907      struct function *f;
6908 {
6909   struct c_language_function *p
6910     = (struct c_language_function *) f->language;
6911   tree link;
6912
6913   /* Bring back all the labels that were shadowed.  */
6914   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
6915     if (DECL_NAME (TREE_VALUE (link)) != 0)
6916       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
6917         = TREE_VALUE (link);
6918
6919   if (DECL_SAVED_INSNS (current_function_decl) == 0
6920       && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6921     {
6922       /* Stop pointing to the local nodes about to be freed.  */
6923       /* But DECL_INITIAL must remain nonzero so we know this
6924          was an actual function definition.  */
6925       DECL_INITIAL (current_function_decl) = error_mark_node;
6926       DECL_ARGUMENTS (current_function_decl) = 0;
6927     }
6928
6929   c_stmt_tree = p->base.x_stmt_tree;
6930   c_scope_stmt_stack = p->base.x_scope_stmt_stack;
6931   c_function_name_declared_p = p->base.x_function_name_declared_p;
6932   named_labels = p->named_labels;
6933   shadowed_labels = p->shadowed_labels;
6934   current_function_returns_value = p->returns_value;
6935   current_function_returns_null = p->returns_null;
6936   warn_about_return_type = p->warn_about_return_type;
6937   current_extern_inline = p->extern_inline;
6938   current_binding_level = p->binding_level;
6939
6940   free (p);
6941   f->language = 0;
6942 }
6943
6944 /* Mark the language specific parts of F for GC.  */
6945
6946 void
6947 mark_c_function_context (f)
6948      struct function *f;
6949 {
6950   struct c_language_function *p
6951     = (struct c_language_function *) f->language;
6952
6953   if (p == 0)
6954     return;
6955
6956   mark_c_language_function (&p->base);
6957   ggc_mark_tree (p->shadowed_labels);
6958   ggc_mark_tree (p->named_labels);
6959   mark_binding_level (&p->binding_level);
6960 }
6961
6962 /* Copy the DECL_LANG_SEPECIFIC data associated with NODE.  */
6963
6964 void
6965 copy_lang_decl (decl)
6966      tree decl;
6967 {
6968   struct lang_decl *ld;
6969
6970   if (!DECL_LANG_SPECIFIC (decl))
6971     return;
6972
6973   ld = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl));
6974   bcopy ((char *)DECL_LANG_SPECIFIC (decl), (char *)ld,
6975          sizeof (struct lang_decl));
6976   DECL_LANG_SPECIFIC (decl) = ld;
6977 }
6978
6979 /* Mark ARG for GC.  */
6980
6981 void
6982 lang_mark_false_label_stack (arg)
6983      struct label_node *arg;
6984 {
6985   /* C doesn't use false_label_stack.  It better be NULL.  */
6986   if (arg != NULL)
6987     abort ();
6988 }
6989
6990 /* Mark the language specific bits in T for GC.  */
6991
6992 void
6993 lang_mark_tree (t)
6994      tree t;
6995 {
6996   if (TREE_CODE (t) == IDENTIFIER_NODE)
6997     {
6998       struct lang_identifier *i = (struct lang_identifier *) t;
6999       ggc_mark_tree (i->global_value);
7000       ggc_mark_tree (i->local_value);
7001       ggc_mark_tree (i->label_value);
7002       ggc_mark_tree (i->implicit_decl);
7003       ggc_mark_tree (i->error_locus);
7004       ggc_mark_tree (i->limbo_value);
7005     }
7006   else if (TYPE_P (t) && TYPE_LANG_SPECIFIC (t))
7007     ggc_mark (TYPE_LANG_SPECIFIC (t));
7008   else if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
7009     {
7010       ggc_mark (DECL_LANG_SPECIFIC (t));
7011       c_mark_lang_decl (&DECL_LANG_SPECIFIC (t)->base);
7012     }
7013 }
7014
7015 /* The functions below are required for functionality of doing
7016    function at once processing in the C front end. Currently these
7017    functions are not called from anywhere in the C front end, but as
7018    these changes continue, that will change.  */
7019
7020 /* Returns non-zero if the current statement is a full expression,
7021    i.e. temporaries created during that statement should be destroyed
7022    at the end of the statement.  */
7023
7024 int
7025 stmts_are_full_exprs_p ()
7026 {
7027   return 0;
7028 }
7029
7030 /* Returns the stmt_tree (if any) to which statements are currently
7031    being added.  If there is no active statement-tree, NULL is
7032    returned.  */
7033
7034 stmt_tree
7035 current_stmt_tree ()
7036 {
7037   return &c_stmt_tree;
7038 }
7039
7040 /* Returns the stack of SCOPE_STMTs for the current function.  */
7041
7042 tree *
7043 current_scope_stmt_stack ()
7044 {
7045   return &c_scope_stmt_stack;
7046 }
7047
7048 /* Nonzero if TYPE is an anonymous union or struct type.  Always 0 in
7049    C.  */
7050
7051 int
7052 anon_aggr_type_p (node)
7053      tree node ATTRIBUTE_UNUSED;
7054 {
7055   return 0;
7056 }
7057
7058 /* Dummy function in place of callback used by C++.  */
7059
7060 void
7061 extract_interface_info ()
7062 {
7063 }
7064
7065 /* Return a new COMPOUND_STMT, after adding it to the current
7066    statement tree.  */
7067
7068 tree
7069 c_begin_compound_stmt ()
7070 {
7071   tree stmt;
7072
7073   /* Create the COMPOUND_STMT.  */
7074   stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
7075   /* If we haven't already declared __FUNCTION__ and its ilk then this
7076      is the opening curly brace of the function.  Declare them now.  */
7077   if (!c_function_name_declared_p)
7078     {
7079       c_function_name_declared_p = 1;
7080       declare_function_name ();
7081     }
7082
7083   return stmt;
7084 }
7085
7086 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
7087    common code.  */
7088
7089 void
7090 c_expand_decl_stmt (t)
7091      tree t;
7092 {
7093   tree decl = DECL_STMT_DECL (t);
7094
7095   /* Expand nested functions.  */
7096   if (TREE_CODE (decl) == FUNCTION_DECL
7097       && DECL_CONTEXT (decl) == current_function_decl
7098       && DECL_SAVED_TREE (decl))
7099     c_expand_body (decl, /*nested_p=*/1);
7100 }