gcc/c-decl.c

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