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