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