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