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