gcc/c-decl.c

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