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