gcc/c-decl.c

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