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