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