gcc/c-decl.c

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