gcc/c-decl.c

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