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 < ARRAY_SIZE (warn_options); 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.  If
2965    ATTRS is nonzero, use that for the function's attribute list.  */
2966
2967 tree
2968 builtin_function (name, type, function_code, class, library_name, attrs)
2969      const char *name;
2970      tree type;
2971      int function_code;
2972      enum built_in_class class;
2973      const char *library_name;
2974      tree attrs;
2975 {
2976   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
2977   DECL_EXTERNAL (decl) = 1;
2978   TREE_PUBLIC (decl) = 1;
2979   if (library_name)
2980     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2981   make_decl_rtl (decl, NULL);
2982   pushdecl (decl);
2983   DECL_BUILT_IN_CLASS (decl) = class;
2984   DECL_FUNCTION_CODE (decl) = function_code;
2985
2986   /* The return builtins leave the current function.  */
2987   if (function_code == BUILT_IN_RETURN || function_code == BUILT_IN_EH_RETURN)
2988     TREE_THIS_VOLATILE (decl) = 1;
2989
2990   /* Warn if a function in the namespace for users
2991      is used without an occasion to consider it declared.  */
2992   if (name[0] != '_' || name[1] != '_')
2993     C_DECL_ANTICIPATED (decl) = 1;
2994
2995   /* Possibly apply some default attributes to this built-in function.  */
2996   if (attrs)
2997     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2998   else
2999     decl_attributes (&decl, NULL_TREE, 0);
3000
3001   return decl;
3002 }
3003
3004 /* Apply default attributes to a function, if a system function with default
3005    attributes.  */
3006
3007 void
3008 c_insert_default_attributes (decl)
3009      tree decl;
3010 {
3011   if (!TREE_PUBLIC (decl))
3012     return;
3013   c_common_insert_default_attributes (decl);
3014 }
3015 \f
3016 /* Called when a declaration is seen that contains no names to declare.
3017    If its type is a reference to a structure, union or enum inherited
3018    from a containing scope, shadow that tag name for the current scope
3019    with a forward reference.
3020    If its type defines a new named structure or union
3021    or defines an enum, it is valid but we need not do anything here.
3022    Otherwise, it is an error.  */
3023
3024 void
3025 shadow_tag (declspecs)
3026      tree declspecs;
3027 {
3028   shadow_tag_warned (declspecs, 0);
3029 }
3030
3031 void
3032 shadow_tag_warned (declspecs, warned)
3033      tree declspecs;
3034      int warned;
3035      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
3036         no pedwarn.  */
3037 {
3038   int found_tag = 0;
3039   tree link;
3040   tree specs, attrs;
3041
3042   pending_invalid_xref = 0;
3043
3044   /* Remove the attributes from declspecs, since they will confuse the
3045      following code.  */
3046   split_specs_attrs (declspecs, &specs, &attrs);
3047
3048   for (link = specs; link; link = TREE_CHAIN (link))
3049     {
3050       tree value = TREE_VALUE (link);
3051       enum tree_code code = TREE_CODE (value);
3052
3053       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3054         /* Used to test also that TYPE_SIZE (value) != 0.
3055            That caused warning for `struct foo;' at top level in the file.  */
3056         {
3057           tree name = lookup_tag_reverse (value);
3058           tree t;
3059
3060           found_tag++;
3061
3062           if (name == 0)
3063             {
3064               if (warned != 1 && code != ENUMERAL_TYPE)
3065                 /* Empty unnamed enum OK */
3066                 {
3067                   pedwarn ("unnamed struct/union that defines no instances");
3068                   warned = 1;
3069                 }
3070             }
3071           else
3072             {
3073               t = lookup_tag (code, name, current_binding_level, 1);
3074
3075               if (t == 0)
3076                 {
3077                   t = make_node (code);
3078                   pushtag (name, t);
3079                 }
3080             }
3081         }
3082       else
3083         {
3084           if (!warned && ! in_system_header)
3085             {
3086               warning ("useless keyword or type name in empty declaration");
3087               warned = 2;
3088             }
3089         }
3090     }
3091
3092   if (found_tag > 1)
3093     error ("two types specified in one empty declaration");
3094
3095   if (warned != 1)
3096     {
3097       if (found_tag == 0)
3098         pedwarn ("empty declaration");
3099     }
3100 }
3101 \f
3102 /* Construct an array declarator.  EXPR is the expression inside [], or
3103    NULL_TREE.  QUALS are the type qualifiers inside the [] (to be applied
3104    to the pointer to which a parameter array is converted).  STATIC_P is
3105    non-zero if "static" is inside the [], zero otherwise.  VLA_UNSPEC_P
3106    is non-zero is the array is [*], a VLA of unspecified length which is
3107    nevertheless a complete type (not currently implemented by GCC),
3108    zero otherwise.  The declarator is constructed as an ARRAY_REF
3109    (to be decoded by grokdeclarator), whose operand 0 is what's on the
3110    left of the [] (filled by in set_array_declarator_type) and operand 1
3111    is the expression inside; whose TREE_TYPE is the type qualifiers and
3112    which has TREE_STATIC set if "static" is used.  */
3113
3114 tree
3115 build_array_declarator (expr, quals, static_p, vla_unspec_p)
3116      tree expr;
3117      tree quals;
3118      int static_p;
3119      int vla_unspec_p;
3120 {
3121   tree decl;
3122   decl = build_nt (ARRAY_REF, NULL_TREE, expr);
3123   TREE_TYPE (decl) = quals;
3124   TREE_STATIC (decl) = (static_p ? 1 : 0);
3125   if (pedantic && !flag_isoc99)
3126     {
3127       if (static_p || quals != NULL_TREE)
3128         pedwarn ("ISO C89 does not support `static' or type qualifiers in parameter array declarators");
3129       if (vla_unspec_p)
3130         pedwarn ("ISO C89 does not support `[*]' array declarators");
3131     }
3132   if (vla_unspec_p)
3133     warning ("GCC does not yet properly implement `[*]' array declarators");
3134   return decl;
3135 }
3136
3137 /* Set the type of an array declarator.  DECL is the declarator, as
3138    constructed by build_array_declarator; TYPE is what appears on the left
3139    of the [] and goes in operand 0.  ABSTRACT_P is non-zero if it is an
3140    abstract declarator, zero otherwise; this is used to reject static and
3141    type qualifiers in abstract declarators, where they are not in the
3142    C99 grammar.  */
3143
3144 tree
3145 set_array_declarator_type (decl, type, abstract_p)
3146      tree decl;
3147      tree type;
3148      int abstract_p;
3149 {
3150   TREE_OPERAND (decl, 0) = type;
3151   if (abstract_p && (TREE_TYPE (decl) != NULL_TREE || TREE_STATIC (decl)))
3152     error ("static or type qualifiers in abstract declarator");
3153   return decl;
3154 }
3155 \f
3156 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3157
3158 tree
3159 groktypename (typename)
3160      tree typename;
3161 {
3162   tree specs, attrs;
3163
3164   if (TREE_CODE (typename) != TREE_LIST)
3165     return typename;
3166
3167   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
3168
3169   typename = grokdeclarator (TREE_VALUE (typename), specs, TYPENAME, 0);
3170
3171   /* Apply attributes.  */
3172   decl_attributes (&typename, attrs, 0);
3173
3174   return typename;
3175 }
3176
3177 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
3178
3179 tree
3180 groktypename_in_parm_context (typename)
3181      tree typename;
3182 {
3183   if (TREE_CODE (typename) != TREE_LIST)
3184     return typename;
3185   return grokdeclarator (TREE_VALUE (typename),
3186                          TREE_PURPOSE (typename),
3187                          PARM, 0);
3188 }
3189
3190 /* Decode a declarator in an ordinary declaration or data definition.
3191    This is called as soon as the type information and variable name
3192    have been parsed, before parsing the initializer if any.
3193    Here we create the ..._DECL node, fill in its type,
3194    and put it on the list of decls for the current context.
3195    The ..._DECL node is returned as the value.
3196
3197    Exception: for arrays where the length is not specified,
3198    the type is left null, to be filled in by `finish_decl'.
3199
3200    Function definitions do not come here; they go to start_function
3201    instead.  However, external and forward declarations of functions
3202    do go through here.  Structure field declarations are done by
3203    grokfield and not through here.  */
3204
3205 tree
3206 start_decl (declarator, declspecs, initialized, attributes)
3207      tree declarator, declspecs;
3208      int initialized;
3209      tree attributes;
3210 {
3211   tree decl;
3212   tree tem;
3213
3214   /* An object declared as __attribute__((deprecated)) suppresses
3215      warnings of uses of other deprecated items.  */
3216   if (lookup_attribute ("deprecated", attributes))
3217     deprecated_state = DEPRECATED_SUPPRESS;
3218
3219   decl = grokdeclarator (declarator, declspecs,
3220                          NORMAL, initialized);
3221
3222   deprecated_state = DEPRECATED_NORMAL;
3223
3224   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3225       && MAIN_NAME_P (DECL_NAME (decl)))
3226     warning_with_decl (decl, "`%s' is usually a function");
3227
3228   if (initialized)
3229     /* Is it valid for this decl to have an initializer at all?
3230        If not, set INITIALIZED to zero, which will indirectly
3231        tell `finish_decl' to ignore the initializer once it is parsed.  */
3232     switch (TREE_CODE (decl))
3233       {
3234       case TYPE_DECL:
3235         /* typedef foo = bar  means give foo the same type as bar.
3236            We haven't parsed bar yet, so `finish_decl' will fix that up.
3237            Any other case of an initialization in a TYPE_DECL is an error.  */
3238         if (pedantic || list_length (declspecs) > 1)
3239           {
3240             error ("typedef `%s' is initialized",
3241                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3242             initialized = 0;
3243           }
3244         break;
3245
3246       case FUNCTION_DECL:
3247         error ("function `%s' is initialized like a variable",
3248                IDENTIFIER_POINTER (DECL_NAME (decl)));
3249         initialized = 0;
3250         break;
3251
3252       case PARM_DECL:
3253         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
3254         error ("parameter `%s' is initialized",
3255                IDENTIFIER_POINTER (DECL_NAME (decl)));
3256         initialized = 0;
3257         break;
3258
3259       default:
3260         /* Don't allow initializations for incomplete types
3261            except for arrays which might be completed by the initialization.  */
3262
3263         /* This can happen if the array size is an undefined macro.  We already
3264            gave a warning, so we don't need another one.  */
3265         if (TREE_TYPE (decl) == error_mark_node)
3266           initialized = 0;
3267         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3268           {
3269             /* A complete type is ok if size is fixed.  */
3270
3271             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3272                 || C_DECL_VARIABLE_SIZE (decl))
3273               {
3274                 error ("variable-sized object may not be initialized");
3275                 initialized = 0;
3276               }
3277           }
3278         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3279           {
3280             error ("variable `%s' has initializer but incomplete type",
3281                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3282             initialized = 0;
3283           }
3284         else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
3285           {
3286             error ("elements of array `%s' have incomplete type",
3287                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3288             initialized = 0;
3289           }
3290       }
3291
3292   if (initialized)
3293     {
3294 #if 0
3295       /* Seems redundant with grokdeclarator.  */
3296       if (current_binding_level != global_binding_level
3297           && DECL_EXTERNAL (decl)
3298           && TREE_CODE (decl) != FUNCTION_DECL)
3299         warning ("declaration of `%s' has `extern' and is initialized",
3300                  IDENTIFIER_POINTER (DECL_NAME (decl)));
3301 #endif
3302       DECL_EXTERNAL (decl) = 0;
3303       if (current_binding_level == global_binding_level)
3304         TREE_STATIC (decl) = 1;
3305
3306       /* Tell `pushdecl' this is an initialized decl
3307          even though we don't yet have the initializer expression.
3308          Also tell `finish_decl' it may store the real initializer.  */
3309       DECL_INITIAL (decl) = error_mark_node;
3310     }
3311
3312   /* If this is a function declaration, write a record describing it to the
3313      prototypes file (if requested).  */
3314
3315   if (TREE_CODE (decl) == FUNCTION_DECL)
3316     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3317
3318   /* ANSI specifies that a tentative definition which is not merged with
3319      a non-tentative definition behaves exactly like a definition with an
3320      initializer equal to zero.  (Section 3.7.2)
3321
3322      -fno-common gives strict ANSI behavior, though this tends to break
3323      a large body of code that grew up without this rule.
3324
3325      Thread-local variables are never common, since there's no entrenched
3326      body of code to break, and it allows more efficient variable references
3327      in the presense of dynamic linking.  */
3328
3329   if (TREE_CODE (decl) == VAR_DECL
3330       && !initialized
3331       && TREE_PUBLIC (decl)
3332       && !DECL_THREAD_LOCAL (decl)
3333       && !flag_no_common)
3334     DECL_COMMON (decl) = 1;
3335
3336   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3337   decl_attributes (&decl, attributes, 0);
3338
3339   /* If #pragma weak was used, mark the decl weak now.  */
3340   if (current_binding_level == global_binding_level)
3341     maybe_apply_pragma_weak (decl);
3342
3343   if (TREE_CODE (decl) == FUNCTION_DECL
3344       && DECL_DECLARED_INLINE_P (decl)
3345       && DECL_UNINLINABLE (decl)
3346       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3347     warning_with_decl (decl,
3348                        "inline function `%s' given attribute noinline");
3349
3350   /* Add this decl to the current binding level.
3351      TEM may equal DECL or it may be a previous decl of the same name.  */
3352   tem = pushdecl (decl);
3353
3354   /* For a local variable, define the RTL now.  */
3355   if (current_binding_level != global_binding_level
3356       /* But not if this is a duplicate decl
3357          and we preserved the rtl from the previous one
3358          (which may or may not happen).  */
3359       && !DECL_RTL_SET_P (tem)
3360       && !DECL_CONTEXT (tem))
3361     {
3362       if (TREE_TYPE (tem) != error_mark_node
3363           && COMPLETE_TYPE_P (TREE_TYPE (tem)))
3364         expand_decl (tem);
3365       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3366                && DECL_INITIAL (tem) != 0)
3367         expand_decl (tem);
3368     }
3369
3370   return tem;
3371 }
3372
3373 /* Finish processing of a declaration;
3374    install its initial value.
3375    If the length of an array type is not known before,
3376    it must be determined now, from the initial value, or it is an error.  */
3377
3378 void
3379 finish_decl (decl, init, asmspec_tree)
3380      tree decl, init;
3381      tree asmspec_tree;
3382 {
3383   tree type = TREE_TYPE (decl);
3384   int was_incomplete = (DECL_SIZE (decl) == 0);
3385   const char *asmspec = 0;
3386
3387   /* If a name was specified, get the string.  */
3388   if (current_binding_level == global_binding_level)
3389     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
3390   if (asmspec_tree)
3391     asmspec = TREE_STRING_POINTER (asmspec_tree);
3392
3393   /* If `start_decl' didn't like having an initialization, ignore it now.  */
3394   if (init != 0 && DECL_INITIAL (decl) == 0)
3395     init = 0;
3396
3397   /* Don't crash if parm is initialized.  */
3398   if (TREE_CODE (decl) == PARM_DECL)
3399     init = 0;
3400
3401   if (init)
3402     {
3403       if (TREE_CODE (decl) != TYPE_DECL)
3404         store_init_value (decl, init);
3405       else
3406         {
3407           /* typedef foo = bar; store the type of bar as the type of foo.  */
3408           TREE_TYPE (decl) = TREE_TYPE (init);
3409           DECL_INITIAL (decl) = init = 0;
3410         }
3411     }
3412
3413   /* Deduce size of array from initialization, if not already known */
3414   if (TREE_CODE (type) == ARRAY_TYPE
3415       && TYPE_DOMAIN (type) == 0
3416       && TREE_CODE (decl) != TYPE_DECL)
3417     {
3418       int do_default
3419         = (TREE_STATIC (decl)
3420            /* Even if pedantic, an external linkage array
3421               may have incomplete type at first.  */
3422            ? pedantic && !TREE_PUBLIC (decl)
3423            : !DECL_EXTERNAL (decl));
3424       int failure
3425         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3426
3427       /* Get the completed type made by complete_array_type.  */
3428       type = TREE_TYPE (decl);
3429
3430       if (failure == 1)
3431         error_with_decl (decl, "initializer fails to determine size of `%s'");
3432
3433       else if (failure == 2)
3434         {
3435           if (do_default)
3436             error_with_decl (decl, "array size missing in `%s'");
3437           /* If a `static' var's size isn't known,
3438              make it extern as well as static, so it does not get
3439              allocated.
3440              If it is not `static', then do not mark extern;
3441              finish_incomplete_decl will give it a default size
3442              and it will get allocated.  */
3443           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3444             DECL_EXTERNAL (decl) = 1;
3445         }
3446
3447       /* TYPE_MAX_VALUE is always one less than the number of elements
3448          in the array, because we start counting at zero.  Therefore,
3449          warn only if the value is less than zero.  */
3450       else if (pedantic && TYPE_DOMAIN (type) != 0
3451               && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3452         error_with_decl (decl, "zero or negative size array `%s'");
3453
3454       layout_decl (decl, 0);
3455     }
3456
3457   if (TREE_CODE (decl) == VAR_DECL)
3458     {
3459       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3460           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3461         layout_decl (decl, 0);
3462
3463       if (DECL_SIZE (decl) == 0
3464           /* Don't give an error if we already gave one earlier.  */
3465           && TREE_TYPE (decl) != error_mark_node
3466           && (TREE_STATIC (decl)
3467               ?
3468                 /* A static variable with an incomplete type
3469                    is an error if it is initialized.
3470                    Also if it is not file scope.
3471                    Otherwise, let it through, but if it is not `extern'
3472                    then it may cause an error message later.  */
3473                 (DECL_INITIAL (decl) != 0
3474                  || DECL_CONTEXT (decl) != 0)
3475               :
3476                 /* An automatic variable with an incomplete type
3477                    is an error.  */
3478                 !DECL_EXTERNAL (decl)))
3479         {
3480           error_with_decl (decl, "storage size of `%s' isn't known");
3481           TREE_TYPE (decl) = error_mark_node;
3482         }
3483
3484       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3485           && DECL_SIZE (decl) != 0)
3486         {
3487           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3488             constant_expression_warning (DECL_SIZE (decl));
3489           else
3490             error_with_decl (decl, "storage size of `%s' isn't constant");
3491         }
3492
3493       if (TREE_USED (type))
3494         TREE_USED (decl) = 1;
3495     }
3496
3497   /* If this is a function and an assembler name is specified, it isn't
3498      builtin any more.  Also reset DECL_RTL so we can give it its new
3499      name.  */
3500   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3501     {
3502       DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3503       SET_DECL_RTL (decl, NULL_RTX);
3504       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3505     }
3506
3507   /* Output the assembler code and/or RTL code for variables and functions,
3508      unless the type is an undefined structure or union.
3509      If not, it will get done when the type is completed.  */
3510
3511   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3512     {
3513       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
3514       maybe_objc_check_decl (decl);
3515
3516       if (!DECL_CONTEXT (decl))
3517         {
3518           if (DECL_INITIAL (decl) == NULL_TREE
3519               || DECL_INITIAL (decl) == error_mark_node)
3520             /* Don't output anything
3521                when a tentative file-scope definition is seen.
3522                But at end of compilation, do output code for them.  */
3523             DECL_DEFER_OUTPUT (decl) = 1;
3524           rest_of_decl_compilation (decl, asmspec,
3525                                     (DECL_CONTEXT (decl) == 0
3526                                      || TREE_ASM_WRITTEN (decl)), 0);
3527         }
3528       else
3529         {
3530           /* This is a local variable.  If there is an ASMSPEC, the
3531              user has requested that we handle it specially.  */
3532           if (asmspec)
3533             {
3534               /* In conjunction with an ASMSPEC, the `register'
3535                  keyword indicates that we should place the variable
3536                  in a particular register.  */
3537               if (DECL_REGISTER (decl))
3538                 DECL_C_HARD_REGISTER (decl) = 1;
3539
3540               /* If this is not a static variable, issue a warning.
3541                  It doesn't make any sense to give an ASMSPEC for an
3542                  ordinary, non-register local variable.  Historically,
3543                  GCC has accepted -- but ignored -- the ASMSPEC in
3544                  this case.  */
3545               if (TREE_CODE (decl) == VAR_DECL
3546                   && !DECL_REGISTER (decl)
3547                   && !TREE_STATIC (decl))
3548                 warning_with_decl (decl,
3549                                    "ignoring asm-specifier for non-static local variable `%s'");
3550               else
3551                 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3552             }
3553
3554           if (TREE_CODE (decl) != FUNCTION_DECL)
3555             add_decl_stmt (decl);
3556         }
3557
3558       if (DECL_CONTEXT (decl) != 0)
3559         {
3560           /* Recompute the RTL of a local array now
3561              if it used to be an incomplete type.  */
3562           if (was_incomplete
3563               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3564             {
3565               /* If we used it already as memory, it must stay in memory.  */
3566               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3567               /* If it's still incomplete now, no init will save it.  */
3568               if (DECL_SIZE (decl) == 0)
3569                 DECL_INITIAL (decl) = 0;
3570             }
3571         }
3572     }
3573
3574   if (TREE_CODE (decl) == TYPE_DECL)
3575     {
3576       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
3577       maybe_objc_check_decl (decl);
3578       rest_of_decl_compilation (decl, NULL, DECL_CONTEXT (decl) == 0, 0);
3579     }
3580
3581   /* At the end of a declaration, throw away any variable type sizes
3582      of types defined inside that declaration.  There is no use
3583      computing them in the following function definition.  */
3584   if (current_binding_level == global_binding_level)
3585     get_pending_sizes ();
3586 }
3587
3588 /* Given a parsed parameter declaration,
3589    decode it into a PARM_DECL and push that on the current binding level.
3590    Also, for the sake of forward parm decls,
3591    record the given order of parms in `parm_order'.  */
3592
3593 void
3594 push_parm_decl (parm)
3595      tree parm;
3596 {
3597   tree decl;
3598   int old_immediate_size_expand = immediate_size_expand;
3599   /* Don't try computing parm sizes now -- wait till fn is called.  */
3600   immediate_size_expand = 0;
3601
3602   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3603                          TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3604   decl_attributes (&decl, TREE_VALUE (parm), 0);
3605
3606 #if 0
3607   if (DECL_NAME (decl))
3608     {
3609       tree olddecl;
3610       olddecl = lookup_name (DECL_NAME (decl));
3611       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3612         pedwarn_with_decl (decl,
3613                            "ISO C forbids parameter `%s' shadowing typedef");
3614     }
3615 #endif
3616
3617   decl = pushdecl (decl);
3618
3619   immediate_size_expand = old_immediate_size_expand;
3620
3621   current_binding_level->parm_order
3622     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3623
3624   /* Add this decl to the current binding level.  */
3625   finish_decl (decl, NULL_TREE, NULL_TREE);
3626 }
3627
3628 /* Clear the given order of parms in `parm_order'.
3629    Used at start of parm list,
3630    and also at semicolon terminating forward decls.  */
3631
3632 void
3633 clear_parm_order ()
3634 {
3635   current_binding_level->parm_order = NULL_TREE;
3636 }
3637 \f
3638 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
3639    literal, which may be an incomplete array type completed by the
3640    initializer; INIT is a CONSTRUCTOR that initializes the compound
3641    literal.  */
3642
3643 tree
3644 build_compound_literal (type, init)
3645      tree type;
3646      tree init;
3647 {
3648   /* We do not use start_decl here because we have a type, not a declarator;
3649      and do not use finish_decl because the decl should be stored inside
3650      the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT.  */
3651   tree decl = build_decl (VAR_DECL, NULL_TREE, type);
3652   tree complit;
3653   tree stmt;
3654   DECL_EXTERNAL (decl) = 0;
3655   TREE_PUBLIC (decl) = 0;
3656   TREE_STATIC (decl) = (current_binding_level == global_binding_level);
3657   DECL_CONTEXT (decl) = current_function_decl;
3658   TREE_USED (decl) = 1;
3659   TREE_TYPE (decl) = type;
3660   store_init_value (decl, init);
3661
3662   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3663     {
3664       int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3665       if (failure)
3666         abort ();
3667     }
3668
3669   type = TREE_TYPE (decl);
3670   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3671     return error_mark_node;
3672
3673   stmt = build_stmt (DECL_STMT, decl);
3674   complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3675   TREE_SIDE_EFFECTS (complit) = 1;
3676
3677   layout_decl (decl, 0);
3678
3679   if (TREE_STATIC (decl))
3680     {
3681       /* This decl needs a name for the assembler output.  We also need
3682          a unique suffix to be added to the name, for which DECL_CONTEXT
3683          must be set.  */
3684       DECL_NAME (decl) = get_identifier ("__compound_literal");
3685       DECL_CONTEXT (decl) = complit;
3686       rest_of_decl_compilation (decl, NULL, 1, 0);
3687       DECL_CONTEXT (decl) = NULL_TREE;
3688     }
3689
3690   return complit;
3691 }
3692 \f
3693 /* Make TYPE a complete type based on INITIAL_VALUE.
3694    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3695    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3696
3697 int
3698 complete_array_type (type, initial_value, do_default)
3699      tree type;
3700      tree initial_value;
3701      int do_default;
3702 {
3703   tree maxindex = NULL_TREE;
3704   int value = 0;
3705
3706   if (initial_value)
3707     {
3708       /* Note MAXINDEX  is really the maximum index,
3709          one less than the size.  */
3710       if (TREE_CODE (initial_value) == STRING_CST)
3711         {
3712           int eltsize
3713             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3714           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3715                                    / eltsize) - 1, 0);
3716         }
3717       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3718         {
3719           tree elts = CONSTRUCTOR_ELTS (initial_value);
3720           maxindex = build_int_2 (-1, -1);
3721           for (; elts; elts = TREE_CHAIN (elts))
3722             {
3723               if (TREE_PURPOSE (elts))
3724                 maxindex = TREE_PURPOSE (elts);
3725               else
3726                 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3727                                         maxindex, integer_one_node));
3728             }
3729           maxindex = copy_node (maxindex);
3730         }
3731       else
3732         {
3733           /* Make an error message unless that happened already.  */
3734           if (initial_value != error_mark_node)
3735             value = 1;
3736
3737           /* Prevent further error messages.  */
3738           maxindex = build_int_2 (0, 0);
3739         }
3740     }
3741
3742   if (!maxindex)
3743     {
3744       if (do_default)
3745         maxindex = build_int_2 (0, 0);
3746       value = 2;
3747     }
3748
3749   if (maxindex)
3750     {
3751       TYPE_DOMAIN (type) = build_index_type (maxindex);
3752       if (!TREE_TYPE (maxindex))
3753         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3754     }
3755
3756   /* Lay out the type now that we can get the real answer.  */
3757
3758   layout_type (type);
3759
3760   return value;
3761 }
3762 \f
3763 /* Given declspecs and a declarator,
3764    determine the name and type of the object declared
3765    and construct a ..._DECL node for it.
3766    (In one case we can return a ..._TYPE node instead.
3767     For invalid input we sometimes return 0.)
3768
3769    DECLSPECS is a chain of tree_list nodes whose value fields
3770     are the storage classes and type specifiers.
3771
3772    DECL_CONTEXT says which syntactic context this declaration is in:
3773      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3774      FUNCDEF for a function definition.  Like NORMAL but a few different
3775       error messages in each case.  Return value may be zero meaning
3776       this definition is too screwy to try to parse.
3777      PARM for a parameter declaration (either within a function prototype
3778       or before a function body).  Make a PARM_DECL, or return void_type_node.
3779      TYPENAME if for a typename (in a cast or sizeof).
3780       Don't make a DECL node; just return the ..._TYPE node.
3781      FIELD for a struct or union field; make a FIELD_DECL.
3782      BITFIELD for a field with specified width.
3783    INITIALIZED is 1 if the decl has an initializer.
3784
3785    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3786    It may also be so in the PARM case, for a prototype where the
3787    argument type is specified but not the name.
3788
3789    This function is where the complicated C meanings of `static'
3790    and `extern' are interpreted.  */
3791
3792 static tree
3793 grokdeclarator (declarator, declspecs, decl_context, initialized)
3794      tree declspecs;
3795      tree declarator;
3796      enum decl_context decl_context;
3797      int initialized;
3798 {
3799   int specbits = 0;
3800   tree spec;
3801   tree type = NULL_TREE;
3802   int longlong = 0;
3803   int constp;
3804   int restrictp;
3805   int volatilep;
3806   int type_quals = TYPE_UNQUALIFIED;
3807   int inlinep;
3808   int explicit_int = 0;
3809   int explicit_char = 0;
3810   int defaulted_int = 0;
3811   tree typedef_decl = 0;
3812   const char *name;
3813   tree typedef_type = 0;
3814   int funcdef_flag = 0;
3815   enum tree_code innermost_code = ERROR_MARK;
3816   int bitfield = 0;
3817   int size_varies = 0;
3818   tree decl_attr = NULL_TREE;
3819   tree array_ptr_quals = NULL_TREE;
3820   int array_parm_static = 0;
3821   tree returned_attrs = NULL_TREE;
3822
3823   if (decl_context == BITFIELD)
3824     bitfield = 1, decl_context = FIELD;
3825
3826   if (decl_context == FUNCDEF)
3827     funcdef_flag = 1, decl_context = NORMAL;
3828
3829   /* Look inside a declarator for the name being declared
3830      and get it as a string, for an error message.  */
3831   {
3832     tree decl = declarator;
3833     name = 0;
3834
3835     while (decl)
3836       switch (TREE_CODE (decl))
3837         {
3838         case ARRAY_REF:
3839         case INDIRECT_REF:
3840         case CALL_EXPR:
3841           innermost_code = TREE_CODE (decl);
3842           decl = TREE_OPERAND (decl, 0);
3843           break;
3844
3845         case TREE_LIST:
3846           decl = TREE_VALUE (decl);
3847           break;
3848
3849         case IDENTIFIER_NODE:
3850           name = IDENTIFIER_POINTER (decl);
3851           decl = 0;
3852           break;
3853
3854         default:
3855           abort ();
3856         }
3857     if (name == 0)
3858       name = "type name";
3859   }
3860
3861   /* A function definition's declarator must have the form of
3862      a function declarator.  */
3863
3864   if (funcdef_flag && innermost_code != CALL_EXPR)
3865     return 0;
3866
3867   /* Anything declared one level down from the top level
3868      must be one of the parameters of a function
3869      (because the body is at least two levels down).  */
3870
3871   /* If this looks like a function definition, make it one,
3872      even if it occurs where parms are expected.
3873      Then store_parm_decls will reject it and not use it as a parm.  */
3874   if (decl_context == NORMAL && !funcdef_flag
3875       && current_binding_level->parm_flag)
3876     decl_context = PARM;
3877
3878   /* Look through the decl specs and record which ones appear.
3879      Some typespecs are defined as built-in typenames.
3880      Others, the ones that are modifiers of other types,
3881      are represented by bits in SPECBITS: set the bits for
3882      the modifiers that appear.  Storage class keywords are also in SPECBITS.
3883
3884      If there is a typedef name or a type, store the type in TYPE.
3885      This includes builtin typedefs such as `int'.
3886
3887      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3888      and did not come from a user typedef.
3889
3890      Set LONGLONG if `long' is mentioned twice.  */
3891
3892   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3893     {
3894       tree id = TREE_VALUE (spec);
3895
3896       /* If the entire declaration is itself tagged as deprecated then
3897          suppress reports of deprecated items.  */
3898       if (id && TREE_DEPRECATED (id))
3899         {
3900           if (deprecated_state != DEPRECATED_SUPPRESS)
3901             warn_deprecated_use (id);
3902         }
3903
3904       if (id == ridpointers[(int) RID_INT])
3905         explicit_int = 1;
3906       if (id == ridpointers[(int) RID_CHAR])
3907         explicit_char = 1;
3908
3909       if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3910         {
3911           enum rid i = C_RID_CODE (id);
3912           if ((int) i <= (int) RID_LAST_MODIFIER)
3913             {
3914               if (i == RID_LONG && (specbits & (1 << (int) RID_LONG)))
3915                 {
3916                   if (longlong)
3917                     error ("`long long long' is too long for GCC");
3918                   else
3919                     {
3920                       if (pedantic && !flag_isoc99 && ! in_system_header
3921                           && warn_long_long)
3922                         pedwarn ("ISO C89 does not support `long long'");
3923                       longlong = 1;
3924                     }
3925                 }
3926               else if (specbits & (1 << (int) i))
3927                 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3928
3929               /* Diagnose "__thread extern".  Recall that this list
3930                  is in the reverse order seen in the text.  */
3931               if (i == RID_THREAD
3932                   && (specbits & (1 << (int) RID_EXTERN
3933                                   | 1 << (int) RID_STATIC)))
3934                 {
3935                   if (specbits & 1 << (int) RID_EXTERN)
3936                     error ("`__thread' before `extern'");
3937                   else
3938                     error ("`__thread' before `static'");
3939                 }
3940
3941               specbits |= 1 << (int) i;
3942               goto found;
3943             }
3944         }
3945       if (type)
3946         error ("two or more data types in declaration of `%s'", name);
3947       /* Actual typedefs come to us as TYPE_DECL nodes.  */
3948       else if (TREE_CODE (id) == TYPE_DECL)
3949         {
3950           if (TREE_TYPE (id) == error_mark_node)
3951             ; /* Allow the type to default to int to avoid cascading errors.  */
3952           else
3953             {
3954               type = TREE_TYPE (id);
3955               decl_attr = DECL_ATTRIBUTES (id);
3956               typedef_decl = id;
3957             }
3958         }
3959       /* Built-in types come as identifiers.  */
3960       else if (TREE_CODE (id) == IDENTIFIER_NODE)
3961         {
3962           tree t = lookup_name (id);
3963           if (TREE_TYPE (t) == error_mark_node)
3964             ;
3965           else if (!t || TREE_CODE (t) != TYPE_DECL)
3966             error ("`%s' fails to be a typedef or built in type",
3967                    IDENTIFIER_POINTER (id));
3968           else
3969             {
3970               type = TREE_TYPE (t);
3971               typedef_decl = t;
3972             }
3973         }
3974       else if (TREE_CODE (id) != ERROR_MARK)
3975         type = id;
3976
3977     found:
3978       ;
3979     }
3980
3981   typedef_type = type;
3982   if (type)
3983     size_varies = C_TYPE_VARIABLE_SIZE (type);
3984
3985   /* No type at all: default to `int', and set DEFAULTED_INT
3986      because it was not a user-defined typedef.  */
3987
3988   if (type == 0)
3989     {
3990       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3991                           | (1 << (int) RID_SIGNED)
3992                           | (1 << (int) RID_UNSIGNED)
3993                           | (1 << (int) RID_COMPLEX))))
3994           /* Don't warn about typedef foo = bar.  */
3995           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3996           && ! in_system_header)
3997         {
3998           /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3999              and this is a function, or if -Wimplicit; prefer the former
4000              warning since it is more explicit.  */
4001           if ((warn_implicit_int || warn_return_type || flag_isoc99)
4002               && funcdef_flag)
4003             warn_about_return_type = 1;
4004           else if (warn_implicit_int || flag_isoc99)
4005             pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
4006                          name);
4007         }
4008
4009       defaulted_int = 1;
4010       type = integer_type_node;
4011     }
4012
4013   /* Now process the modifiers that were specified
4014      and check for invalid combinations.  */
4015
4016   /* Long double is a special combination.  */
4017
4018   if ((specbits & 1 << (int) RID_LONG) && ! longlong
4019       && TYPE_MAIN_VARIANT (type) == double_type_node)
4020     {
4021       specbits &= ~(1 << (int) RID_LONG);
4022       type = long_double_type_node;
4023     }
4024
4025   /* Check all other uses of type modifiers.  */
4026
4027   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4028                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4029     {
4030       int ok = 0;
4031
4032       if ((specbits & 1 << (int) RID_LONG)
4033           && (specbits & 1 << (int) RID_SHORT))
4034         error ("both long and short specified for `%s'", name);
4035       else if (((specbits & 1 << (int) RID_LONG)
4036                 || (specbits & 1 << (int) RID_SHORT))
4037                && explicit_char)
4038         error ("long or short specified with char for `%s'", name);
4039       else if (((specbits & 1 << (int) RID_LONG)
4040                 || (specbits & 1 << (int) RID_SHORT))
4041                && TREE_CODE (type) == REAL_TYPE)
4042         {
4043           static int already = 0;
4044
4045           error ("long or short specified with floating type for `%s'", name);
4046           if (! already && ! pedantic)
4047             {
4048               error ("the only valid combination is `long double'");
4049               already = 1;
4050             }
4051         }
4052       else if ((specbits & 1 << (int) RID_SIGNED)
4053                && (specbits & 1 << (int) RID_UNSIGNED))
4054         error ("both signed and unsigned specified for `%s'", name);
4055       else if (TREE_CODE (type) != INTEGER_TYPE)
4056         error ("long, short, signed or unsigned invalid for `%s'", name);
4057       else
4058         {
4059           ok = 1;
4060           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4061             {
4062               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4063                        name);
4064               if (flag_pedantic_errors)
4065                 ok = 0;
4066             }
4067         }
4068
4069       /* Discard the type modifiers if they are invalid.  */
4070       if (! ok)
4071         {
4072           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4073                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4074           longlong = 0;
4075         }
4076     }
4077
4078   if ((specbits & (1 << (int) RID_COMPLEX))
4079       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4080     {
4081       error ("complex invalid for `%s'", name);
4082       specbits &= ~(1 << (int) RID_COMPLEX);
4083     }
4084
4085   /* Decide whether an integer type is signed or not.
4086      Optionally treat bitfields as signed by default.  */
4087   if (specbits & 1 << (int) RID_UNSIGNED
4088       || (bitfield && ! flag_signed_bitfields
4089           && (explicit_int || defaulted_int || explicit_char
4090               /* A typedef for plain `int' without `signed'
4091                  can be controlled just like plain `int'.  */
4092               || ! (typedef_decl != 0
4093                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4094           && TREE_CODE (type) != ENUMERAL_TYPE
4095           && !(specbits & 1 << (int) RID_SIGNED)))
4096     {
4097       if (longlong)
4098         type = long_long_unsigned_type_node;
4099       else if (specbits & 1 << (int) RID_LONG)
4100         type = long_unsigned_type_node;
4101       else if (specbits & 1 << (int) RID_SHORT)
4102         type = short_unsigned_type_node;
4103       else if (type == char_type_node)
4104         type = unsigned_char_type_node;
4105       else if (typedef_decl)
4106         type = c_common_unsigned_type (type);
4107       else
4108         type = unsigned_type_node;
4109     }
4110   else if ((specbits & 1 << (int) RID_SIGNED)
4111            && type == char_type_node)
4112     type = signed_char_type_node;
4113   else if (longlong)
4114     type = long_long_integer_type_node;
4115   else if (specbits & 1 << (int) RID_LONG)
4116     type = long_integer_type_node;
4117   else if (specbits & 1 << (int) RID_SHORT)
4118     type = short_integer_type_node;
4119
4120   if (specbits & 1 << (int) RID_COMPLEX)
4121     {
4122       if (pedantic && !flag_isoc99)
4123         pedwarn ("ISO C89 does not support complex types");
4124       /* If we just have "complex", it is equivalent to
4125          "complex double", but if any modifiers at all are specified it is
4126          the complex form of TYPE.  E.g, "complex short" is
4127          "complex short int".  */
4128
4129       if (defaulted_int && ! longlong
4130           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4131                             | (1 << (int) RID_SIGNED)
4132                             | (1 << (int) RID_UNSIGNED))))
4133         {
4134           if (pedantic)
4135             pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
4136           type = complex_double_type_node;
4137         }
4138       else if (type == integer_type_node)
4139         {
4140           if (pedantic)
4141             pedwarn ("ISO C does not support complex integer types");
4142           type = complex_integer_type_node;
4143         }
4144       else if (type == float_type_node)
4145         type = complex_float_type_node;
4146       else if (type == double_type_node)
4147         type = complex_double_type_node;
4148       else if (type == long_double_type_node)
4149         type = complex_long_double_type_node;
4150       else
4151         {
4152           if (pedantic)
4153             pedwarn ("ISO C does not support complex integer types");
4154           type = build_complex_type (type);
4155         }
4156     }
4157
4158   /* Figure out the type qualifiers for the declaration.  There are
4159      two ways a declaration can become qualified.  One is something
4160      like `const int i' where the `const' is explicit.  Another is
4161      something like `typedef const int CI; CI i' where the type of the
4162      declaration contains the `const'.  */
4163   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4164   restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
4165   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4166   inlinep = !! (specbits & (1 << (int) RID_INLINE));
4167   if (constp > 1 && ! flag_isoc99)
4168     pedwarn ("duplicate `const'");
4169   if (restrictp > 1 && ! flag_isoc99)
4170     pedwarn ("duplicate `restrict'");
4171   if (volatilep > 1 && ! flag_isoc99)
4172     pedwarn ("duplicate `volatile'");
4173   if (! flag_gen_aux_info && (TYPE_QUALS (type)))
4174     type = TYPE_MAIN_VARIANT (type);
4175   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4176                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4177                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4178
4179   /* Warn if two storage classes are given. Default to `auto'.  */
4180
4181   {
4182     int nclasses = 0;
4183
4184     if (specbits & 1 << (int) RID_AUTO) nclasses++;
4185     if (specbits & 1 << (int) RID_STATIC) nclasses++;
4186     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4187     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4188     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4189
4190     /* "static __thread" and "extern __thread" are allowed.  */
4191     if ((specbits & (1 << (int) RID_THREAD
4192                      | 1 << (int) RID_STATIC
4193                      | 1 << (int) RID_EXTERN)) == (1 << (int) RID_THREAD))
4194       nclasses++;
4195
4196     /* Warn about storage classes that are invalid for certain
4197        kinds of declarations (parameters, typenames, etc.).  */
4198
4199     if (nclasses > 1)
4200       error ("multiple storage classes in declaration of `%s'", name);
4201     else if (funcdef_flag
4202              && (specbits
4203                  & ((1 << (int) RID_REGISTER)
4204                     | (1 << (int) RID_AUTO)
4205                     | (1 << (int) RID_TYPEDEF)
4206                     | (1 << (int) RID_THREAD))))
4207       {
4208         if (specbits & 1 << (int) RID_AUTO
4209             && (pedantic || current_binding_level == global_binding_level))
4210           pedwarn ("function definition declared `auto'");
4211         if (specbits & 1 << (int) RID_REGISTER)
4212           error ("function definition declared `register'");
4213         if (specbits & 1 << (int) RID_TYPEDEF)
4214           error ("function definition declared `typedef'");
4215         if (specbits & 1 << (int) RID_THREAD)
4216           error ("function definition declared `__thread'");
4217         specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4218                       | (1 << (int) RID_AUTO) | (1 << (int) RID_THREAD));
4219       }
4220     else if (decl_context != NORMAL && nclasses > 0)
4221       {
4222         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4223           ;
4224         else
4225           {
4226             switch (decl_context)
4227               {
4228               case FIELD:
4229                 error ("storage class specified for structure field `%s'",
4230                        name);
4231                 break;
4232               case PARM:
4233                 error ("storage class specified for parameter `%s'", name);
4234                 break;
4235               default:
4236                 error ("storage class specified for typename");
4237                 break;
4238               }
4239             specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4240                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4241                           | (1 << (int) RID_EXTERN) | (1 << (int) RID_THREAD));
4242           }
4243       }
4244     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4245       {
4246         /* `extern' with initialization is invalid if not at top level.  */
4247         if (current_binding_level == global_binding_level)
4248           warning ("`%s' initialized and declared `extern'", name);
4249         else
4250           error ("`%s' has both `extern' and initializer", name);
4251       }
4252     else if (current_binding_level == global_binding_level)
4253       {
4254         if (specbits & 1 << (int) RID_AUTO)
4255           error ("top-level declaration of `%s' specifies `auto'", name);
4256       }
4257     else
4258       {
4259         if (specbits & 1 << (int) RID_EXTERN && funcdef_flag)
4260           error ("nested function `%s' declared `extern'", name);
4261         else if ((specbits & (1 << (int) RID_THREAD
4262                                | 1 << (int) RID_EXTERN
4263                                | 1 << (int) RID_STATIC))
4264                  == (1 << (int) RID_THREAD))
4265           {
4266             error ("function-scope `%s' implicitly auto and declared `__thread'",
4267                    name);
4268             specbits &= ~(1 << (int) RID_THREAD);
4269           }
4270       }
4271   }
4272
4273   /* Now figure out the structure of the declarator proper.
4274      Descend through it, creating more complex types, until we reach
4275      the declared identifier (or NULL_TREE, in an absolute declarator).  */
4276
4277   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4278     {
4279       if (type == error_mark_node)
4280         {
4281           declarator = TREE_OPERAND (declarator, 0);
4282           continue;
4283         }
4284
4285       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4286          an INDIRECT_REF (for *...),
4287          a CALL_EXPR (for ...(...)),
4288          a TREE_LIST (for nested attributes),
4289          an identifier (for the name being declared)
4290          or a null pointer (for the place in an absolute declarator
4291          where the name was omitted).
4292          For the last two cases, we have just exited the loop.
4293
4294          At this point, TYPE is the type of elements of an array,
4295          or for a function to return, or for a pointer to point to.
4296          After this sequence of ifs, TYPE is the type of the
4297          array or function or pointer, and DECLARATOR has had its
4298          outermost layer removed.  */
4299
4300       if (array_ptr_quals != NULL_TREE || array_parm_static)
4301         {
4302           /* Only the innermost declarator (making a parameter be of
4303              array type which is converted to pointer type)
4304              may have static or type qualifiers.  */
4305           error ("static or type qualifiers in non-parameter array declarator");
4306           array_ptr_quals = NULL_TREE;
4307           array_parm_static = 0;
4308         }
4309
4310       if (TREE_CODE (declarator) == TREE_LIST)
4311         {
4312           /* We encode a declarator with embedded attributes using
4313              a TREE_LIST.  */
4314           tree attrs = TREE_PURPOSE (declarator);
4315           tree inner_decl;
4316           int attr_flags = 0;
4317           declarator = TREE_VALUE (declarator);
4318           inner_decl = declarator;
4319           while (inner_decl != NULL_TREE
4320                  && TREE_CODE (inner_decl) == TREE_LIST)
4321             inner_decl = TREE_VALUE (inner_decl);
4322           if (inner_decl == NULL_TREE
4323               || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
4324             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
4325           else if (TREE_CODE (inner_decl) == CALL_EXPR)
4326             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
4327           else if (TREE_CODE (inner_decl) == ARRAY_REF)
4328             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
4329           returned_attrs = decl_attributes (&type,
4330                                             chainon (returned_attrs, attrs),
4331                                             attr_flags);
4332         }
4333       else if (TREE_CODE (declarator) == ARRAY_REF)
4334         {
4335           tree itype = NULL_TREE;
4336           tree size = TREE_OPERAND (declarator, 1);
4337           /* The index is a signed object `sizetype' bits wide.  */
4338           tree index_type = c_common_signed_type (sizetype);
4339
4340           array_ptr_quals = TREE_TYPE (declarator);
4341           array_parm_static = TREE_STATIC (declarator);
4342
4343           declarator = TREE_OPERAND (declarator, 0);
4344
4345           /* Check for some types that there cannot be arrays of.  */
4346
4347           if (VOID_TYPE_P (type))
4348             {
4349               error ("declaration of `%s' as array of voids", name);
4350               type = error_mark_node;
4351             }
4352
4353           if (TREE_CODE (type) == FUNCTION_TYPE)
4354             {
4355               error ("declaration of `%s' as array of functions", name);
4356               type = error_mark_node;
4357             }
4358
4359           if (size == error_mark_node)
4360             type = error_mark_node;
4361
4362           if (type == error_mark_node)
4363             continue;
4364
4365           /* If size was specified, set ITYPE to a range-type for that size.
4366              Otherwise, ITYPE remains null.  finish_decl may figure it out
4367              from an initial value.  */
4368
4369           if (size)
4370             {
4371               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4372               STRIP_TYPE_NOPS (size);
4373
4374               if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
4375                 {
4376                   error ("size of array `%s' has non-integer type", name);
4377                   size = integer_one_node;
4378                 }
4379
4380               if (pedantic && integer_zerop (size))
4381                 pedwarn ("ISO C forbids zero-size array `%s'", name);
4382
4383               if (TREE_CODE (size) == INTEGER_CST)
4384                 {
4385                   constant_expression_warning (size);
4386                   if (tree_int_cst_sgn (size) < 0)
4387                     {
4388                       error ("size of array `%s' is negative", name);
4389                       size = integer_one_node;
4390                     }
4391                 }
4392               else
4393                 {
4394                   /* Make sure the array size remains visibly nonconstant
4395                      even if it is (eg) a const variable with known value.  */
4396                   size_varies = 1;
4397
4398                   if (!flag_isoc99 && pedantic)
4399                     {
4400                       if (TREE_CONSTANT (size))
4401                         pedwarn ("ISO C89 forbids array `%s' whose size can't be evaluated",
4402                                  name);
4403                       else
4404                         pedwarn ("ISO C89 forbids variable-size array `%s'",
4405                                  name);
4406                     }
4407                 }
4408
4409               if (integer_zerop (size))
4410                 {
4411                   /* A zero-length array cannot be represented with an
4412                      unsigned index type, which is what we'll get with
4413                      build_index_type.  Create an open-ended range instead.  */
4414                   itype = build_range_type (sizetype, size, NULL_TREE);
4415                 }
4416               else
4417                 {
4418                   /* Compute the maximum valid index, that is, size - 1.
4419                      Do the calculation in index_type, so that if it is
4420                      a variable the computations will be done in the
4421                      proper mode.  */
4422                   itype = fold (build (MINUS_EXPR, index_type,
4423                                        convert (index_type, size),
4424                                        convert (index_type, size_one_node)));
4425
4426                   /* If that overflowed, the array is too big.
4427                      ??? While a size of INT_MAX+1 technically shouldn't
4428                      cause an overflow (because we subtract 1), the overflow
4429                      is recorded during the conversion to index_type, before
4430                      the subtraction.  Handling this case seems like an
4431                      unnecessary complication.  */
4432                   if (TREE_OVERFLOW (itype))
4433                     {
4434                       error ("size of array `%s' is too large", name);
4435                       type = error_mark_node;
4436                       continue;
4437                     }
4438
4439                   if (size_varies)
4440                     itype = variable_size (itype);
4441                   itype = build_index_type (itype);
4442                 }
4443             }
4444           else if (decl_context == FIELD)
4445             {
4446               if (pedantic && !flag_isoc99 && !in_system_header)
4447                 pedwarn ("ISO C89 does not support flexible array members");
4448
4449               /* ISO C99 Flexible array members are effectively identical
4450                  to GCC's zero-length array extension.  */
4451               itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4452             }
4453
4454           /* If pedantic, complain about arrays of incomplete types.  */
4455
4456           if (pedantic && !COMPLETE_TYPE_P (type))
4457             pedwarn ("array type has incomplete element type");
4458
4459 #if 0
4460           /* We shouldn't have a function type here at all!
4461              Functions aren't allowed as array elements.  */
4462           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4463               && (constp || volatilep))
4464             pedwarn ("ISO C forbids const or volatile function types");
4465 #endif
4466
4467           /* Build the array type itself, then merge any constancy or
4468              volatility into the target type.  We must do it in this order
4469              to ensure that the TYPE_MAIN_VARIANT field of the array type
4470              is set correctly.  */
4471
4472           type = build_array_type (type, itype);
4473           if (type_quals)
4474             type = c_build_qualified_type (type, type_quals);
4475
4476           if (size_varies)
4477             C_TYPE_VARIABLE_SIZE (type) = 1;
4478
4479           /* The GCC extension for zero-length arrays differs from
4480              ISO flexible array members in that sizeof yields zero.  */
4481           if (size && integer_zerop (size))
4482             {
4483               layout_type (type);
4484               TYPE_SIZE (type) = bitsize_zero_node;
4485               TYPE_SIZE_UNIT (type) = size_zero_node;
4486             }
4487           if (decl_context != PARM
4488               && (array_ptr_quals != NULL_TREE || array_parm_static))
4489             {
4490               error ("static or type qualifiers in non-parameter array declarator");
4491               array_ptr_quals = NULL_TREE;
4492               array_parm_static = 0;
4493             }
4494         }
4495       else if (TREE_CODE (declarator) == CALL_EXPR)
4496         {
4497           tree arg_types;
4498
4499           /* Declaring a function type.
4500              Make sure we have a valid type for the function to return.  */
4501           if (type == error_mark_node)
4502             continue;
4503
4504           size_varies = 0;
4505
4506           /* Warn about some types functions can't return.  */
4507
4508           if (TREE_CODE (type) == FUNCTION_TYPE)
4509             {
4510               error ("`%s' declared as function returning a function", name);
4511               type = integer_type_node;
4512             }
4513           if (TREE_CODE (type) == ARRAY_TYPE)
4514             {
4515               error ("`%s' declared as function returning an array", name);
4516               type = integer_type_node;
4517             }
4518
4519           /* Construct the function type and go to the next
4520              inner layer of declarator.  */
4521
4522           arg_types = grokparms (TREE_OPERAND (declarator, 1),
4523                                  funcdef_flag
4524                                  /* Say it's a definition
4525                                     only for the CALL_EXPR
4526                                     closest to the identifier.  */
4527                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4528           /* Type qualifiers before the return type of the function
4529              qualify the return type, not the function type.  */
4530           if (type_quals)
4531             {
4532               /* Type qualifiers on a function return type are normally
4533                  permitted by the standard but have no effect, so give a
4534                  warning at -W.  Qualifiers on a void return type have
4535                  meaning as a GNU extension, and are banned on function
4536                  definitions in ISO C.  FIXME: strictly we shouldn't
4537                  pedwarn for qualified void return types except on function
4538                  definitions, but not doing so could lead to the undesirable
4539                  state of a "volatile void" function return type not being
4540                  warned about, and a use of the function being compiled
4541                  with GNU semantics, with no diagnostics under -pedantic.  */
4542               if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4543                 pedwarn ("ISO C forbids qualified void function return type");
4544               else if (extra_warnings
4545                        && !(VOID_TYPE_P (type)
4546                             && type_quals == TYPE_QUAL_VOLATILE))
4547                 warning ("type qualifiers ignored on function return type");
4548
4549               type = c_build_qualified_type (type, type_quals);
4550             }
4551           type_quals = TYPE_UNQUALIFIED;
4552
4553           type = build_function_type (type, arg_types);
4554           declarator = TREE_OPERAND (declarator, 0);
4555
4556           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4557              the formal parameter list of this FUNCTION_TYPE to point to
4558              the FUNCTION_TYPE node itself.  */
4559
4560           {
4561             tree link;
4562
4563             for (link = last_function_parm_tags;
4564                  link;
4565                  link = TREE_CHAIN (link))
4566               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4567           }
4568         }
4569       else if (TREE_CODE (declarator) == INDIRECT_REF)
4570         {
4571           /* Merge any constancy or volatility into the target type
4572              for the pointer.  */
4573
4574           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4575               && type_quals)
4576             pedwarn ("ISO C forbids qualified function types");
4577           if (type_quals)
4578             type = c_build_qualified_type (type, type_quals);
4579           type_quals = TYPE_UNQUALIFIED;
4580           size_varies = 0;
4581
4582           type = build_pointer_type (type);
4583
4584           /* Process a list of type modifier keywords
4585              (such as const or volatile) that were given inside the `*'.  */
4586
4587           if (TREE_TYPE (declarator))
4588             {
4589               tree typemodlist;
4590               int erred = 0;
4591
4592               constp = 0;
4593               volatilep = 0;
4594               restrictp = 0;
4595               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4596                    typemodlist = TREE_CHAIN (typemodlist))
4597                 {
4598                   tree qualifier = TREE_VALUE (typemodlist);
4599
4600                   if (C_IS_RESERVED_WORD (qualifier))
4601                     {
4602                       if (C_RID_CODE (qualifier) == RID_CONST)
4603                         constp++;
4604                       else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4605                         volatilep++;
4606                       else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4607                         restrictp++;
4608                       else
4609                         erred++;
4610                     }
4611                   else
4612                     erred++;
4613                 }
4614
4615               if (erred)
4616                 error ("invalid type modifier within pointer declarator");
4617               if (constp > 1 && ! flag_isoc99)
4618                 pedwarn ("duplicate `const'");
4619               if (volatilep > 1 && ! flag_isoc99)
4620                 pedwarn ("duplicate `volatile'");
4621               if (restrictp > 1 && ! flag_isoc99)
4622                 pedwarn ("duplicate `restrict'");
4623
4624               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4625                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4626                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4627             }
4628
4629           declarator = TREE_OPERAND (declarator, 0);
4630         }
4631       else
4632         abort ();
4633
4634     }
4635
4636   /* Now TYPE has the actual type.  */
4637
4638   /* Did array size calculations overflow?  */
4639
4640   if (TREE_CODE (type) == ARRAY_TYPE
4641       && COMPLETE_TYPE_P (type)
4642       && TREE_OVERFLOW (TYPE_SIZE (type)))
4643     {
4644       error ("size of array `%s' is too large", name);
4645       /* If we proceed with the array type as it is, we'll eventually
4646          crash in tree_low_cst().  */
4647       type = error_mark_node;
4648     }
4649
4650   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4651
4652   if (specbits & (1 << (int) RID_TYPEDEF))
4653     {
4654       tree decl;
4655       /* Note that the grammar rejects storage classes
4656          in typenames, fields or parameters */
4657       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4658           && type_quals)
4659         pedwarn ("ISO C forbids qualified function types");
4660       if (type_quals)
4661         type = c_build_qualified_type (type, type_quals);
4662       decl = build_decl (TYPE_DECL, declarator, type);
4663       if ((specbits & (1 << (int) RID_SIGNED))
4664           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4665         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4666       decl_attributes (&decl, returned_attrs, 0);
4667       return decl;
4668     }
4669
4670   /* Detect the case of an array type of unspecified size
4671      which came, as such, direct from a typedef name.
4672      We must copy the type, so that each identifier gets
4673      a distinct type, so that each identifier's size can be
4674      controlled separately by its own initializer.  */
4675
4676   if (type != 0 && typedef_type != 0
4677       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4678       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4679     {
4680       type = build_array_type (TREE_TYPE (type), 0);
4681       if (size_varies)
4682         C_TYPE_VARIABLE_SIZE (type) = 1;
4683     }
4684
4685   /* If this is a type name (such as, in a cast or sizeof),
4686      compute the type and return it now.  */
4687
4688   if (decl_context == TYPENAME)
4689     {
4690       /* Note that the grammar rejects storage classes
4691          in typenames, fields or parameters */
4692       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4693           && type_quals)
4694         pedwarn ("ISO C forbids const or volatile function types");
4695       if (type_quals)
4696         type = c_build_qualified_type (type, type_quals);
4697       decl_attributes (&type, returned_attrs, 0);
4698       return type;
4699     }
4700
4701   /* Aside from typedefs and type names (handle above),
4702      `void' at top level (not within pointer)
4703      is allowed only in public variables.
4704      We don't complain about parms either, but that is because
4705      a better error message can be made later.  */
4706
4707   if (VOID_TYPE_P (type) && decl_context != PARM
4708       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4709             && ((specbits & (1 << (int) RID_EXTERN))
4710                 || (current_binding_level == global_binding_level
4711                     && !(specbits
4712                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4713     {
4714       error ("variable or field `%s' declared void", name);
4715       type = integer_type_node;
4716     }
4717
4718   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4719      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4720
4721   {
4722     tree decl;
4723
4724     if (decl_context == PARM)
4725       {
4726         tree type_as_written;
4727         tree promoted_type;
4728
4729         /* A parameter declared as an array of T is really a pointer to T.
4730            One declared as a function is really a pointer to a function.  */
4731
4732         if (TREE_CODE (type) == ARRAY_TYPE)
4733           {
4734             /* Transfer const-ness of array into that of type pointed to.  */
4735             type = TREE_TYPE (type);
4736             if (type_quals)
4737               type = c_build_qualified_type (type, type_quals);
4738             type = build_pointer_type (type);
4739             type_quals = TYPE_UNQUALIFIED;
4740             if (array_ptr_quals)
4741               {
4742                 tree new_ptr_quals, new_ptr_attrs;
4743                 int erred = 0;
4744                 split_specs_attrs (array_ptr_quals, &new_ptr_quals, &new_ptr_attrs);
4745                 /* We don't yet implement attributes in this context.  */
4746                 if (new_ptr_attrs != NULL_TREE)
4747                   warning ("attributes in parameter array declarator ignored");
4748
4749                 constp = 0;
4750                 volatilep = 0;
4751                 restrictp = 0;
4752                 for (; new_ptr_quals; new_ptr_quals = TREE_CHAIN (new_ptr_quals))
4753                   {
4754                     tree qualifier = TREE_VALUE (new_ptr_quals);
4755
4756                     if (C_IS_RESERVED_WORD (qualifier))
4757                       {
4758                         if (C_RID_CODE (qualifier) == RID_CONST)
4759                           constp++;
4760                         else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4761                           volatilep++;
4762                         else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4763                           restrictp++;
4764                         else
4765                           erred++;
4766                       }
4767                     else
4768                       erred++;
4769                   }
4770
4771                 if (erred)
4772                   error ("invalid type modifier within array declarator");
4773
4774                 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4775                               | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4776                               | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4777               }
4778             size_varies = 0;
4779           }
4780         else if (TREE_CODE (type) == FUNCTION_TYPE)
4781           {
4782             if (pedantic && type_quals)
4783               pedwarn ("ISO C forbids qualified function types");
4784             if (type_quals)
4785               type = c_build_qualified_type (type, type_quals);
4786             type = build_pointer_type (type);
4787             type_quals = TYPE_UNQUALIFIED;
4788           }
4789         else if (type_quals)
4790           type = c_build_qualified_type (type, type_quals);
4791
4792         type_as_written = type;
4793
4794         decl = build_decl (PARM_DECL, declarator, type);
4795         if (size_varies)
4796           C_DECL_VARIABLE_SIZE (decl) = 1;
4797
4798         /* Compute the type actually passed in the parmlist,
4799            for the case where there is no prototype.
4800            (For example, shorts and chars are passed as ints.)
4801            When there is a prototype, this is overridden later.  */
4802
4803         if (type == error_mark_node)
4804           promoted_type = type;
4805         else
4806           promoted_type = c_type_promotes_to (type);
4807
4808         DECL_ARG_TYPE (decl) = promoted_type;
4809         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4810       }
4811     else if (decl_context == FIELD)
4812       {
4813         /* Structure field.  It may not be a function.  */
4814
4815         if (TREE_CODE (type) == FUNCTION_TYPE)
4816           {
4817             error ("field `%s' declared as a function", name);
4818             type = build_pointer_type (type);
4819           }
4820         else if (TREE_CODE (type) != ERROR_MARK
4821                  && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4822           {
4823             error ("field `%s' has incomplete type", name);
4824             type = error_mark_node;
4825           }
4826         /* Move type qualifiers down to element of an array.  */
4827         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4828           {
4829             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4830                                                              type_quals),
4831                                      TYPE_DOMAIN (type));
4832 #if 0
4833             /* Leave the field const or volatile as well.  */
4834             type_quals = TYPE_UNQUALIFIED;
4835 #endif
4836           }
4837         decl = build_decl (FIELD_DECL, declarator, type);
4838         DECL_NONADDRESSABLE_P (decl) = bitfield;
4839
4840         if (size_varies)
4841           C_DECL_VARIABLE_SIZE (decl) = 1;
4842       }
4843     else if (TREE_CODE (type) == FUNCTION_TYPE)
4844       {
4845         /* Every function declaration is "external"
4846            except for those which are inside a function body
4847            in which `auto' is used.
4848            That is a case not specified by ANSI C,
4849            and we use it for forward declarations for nested functions.  */
4850         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4851                           || current_binding_level == global_binding_level);
4852
4853         if (specbits & (1 << (int) RID_AUTO)
4854             && (pedantic || current_binding_level == global_binding_level))
4855           pedwarn ("invalid storage class for function `%s'", name);
4856         if (specbits & (1 << (int) RID_REGISTER))
4857           error ("invalid storage class for function `%s'", name);
4858         if (specbits & (1 << (int) RID_THREAD))
4859           error ("invalid storage class for function `%s'", name);
4860         /* Function declaration not at top level.
4861            Storage classes other than `extern' are not allowed
4862            and `extern' makes no difference.  */
4863         if (current_binding_level != global_binding_level
4864             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4865             && pedantic)
4866           pedwarn ("invalid storage class for function `%s'", name);
4867
4868         decl = build_decl (FUNCTION_DECL, declarator, type);
4869         decl = build_decl_attribute_variant (decl, decl_attr);
4870
4871         DECL_LANG_SPECIFIC (decl) = (struct lang_decl *)
4872           ggc_alloc_cleared (sizeof (struct lang_decl));
4873
4874         if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4875           pedwarn ("ISO C forbids qualified function types");
4876
4877         /* GNU C interprets a `volatile void' return type to indicate
4878            that the function does not return.  */
4879         if ((type_quals & TYPE_QUAL_VOLATILE)
4880             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4881           warning ("`noreturn' function returns non-void value");
4882
4883         if (extern_ref)
4884           DECL_EXTERNAL (decl) = 1;
4885         /* Record absence of global scope for `static' or `auto'.  */
4886         TREE_PUBLIC (decl)
4887           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4888
4889         if (defaulted_int)
4890           C_FUNCTION_IMPLICIT_INT (decl) = 1;
4891
4892         /* Record presence of `inline', if it is reasonable.  */
4893         if (MAIN_NAME_P (declarator))
4894           {
4895             if (inlinep)
4896               warning ("cannot inline function `main'");
4897           }
4898         else if (inlinep)
4899           {
4900             /* Assume that otherwise the function can be inlined.  */
4901             DECL_DECLARED_INLINE_P (decl) = 1;
4902
4903             /* Do not mark bare declarations as DECL_INLINE.  Doing so
4904                in the presence of multiple declarations can result in
4905                the abstract origin pointing between the declarations,
4906                which will confuse dwarf2out.  */
4907             if (initialized)
4908               {
4909                 DECL_INLINE (decl) = 1;
4910                 if (specbits & (1 << (int) RID_EXTERN))
4911                   current_extern_inline = 1;
4912               }
4913           }
4914         /* If -finline-functions, assume it can be inlined.  This does
4915            two things: let the function be deferred until it is actually
4916            needed, and let dwarf2 know that the function is inlinable.  */
4917         else if (flag_inline_trees == 2 && initialized)
4918           {
4919             DECL_INLINE (decl) = 1;
4920             DECL_DECLARED_INLINE_P (decl) = 0;
4921           }
4922       }
4923     else
4924       {
4925         /* It's a variable.  */
4926         /* An uninitialized decl with `extern' is a reference.  */
4927         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4928
4929         /* Move type qualifiers down to element of an array.  */
4930         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4931           {
4932             int saved_align = TYPE_ALIGN(type);
4933             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4934                                                              type_quals),
4935                                      TYPE_DOMAIN (type));
4936             TYPE_ALIGN (type) = saved_align;
4937 #if 0 /* Leave the variable const or volatile as well.  */
4938             type_quals = TYPE_UNQUALIFIED;
4939 #endif
4940           }
4941         else if (type_quals)
4942           type = c_build_qualified_type (type, type_quals);
4943
4944         decl = build_decl (VAR_DECL, declarator, type);
4945         if (size_varies)
4946           C_DECL_VARIABLE_SIZE (decl) = 1;
4947
4948         if (inlinep)
4949           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4950
4951         DECL_EXTERNAL (decl) = extern_ref;
4952
4953         /* At top level, the presence of a `static' or `register' storage
4954            class specifier, or the absence of all storage class specifiers
4955            makes this declaration a definition (perhaps tentative).  Also,
4956            the absence of both `static' and `register' makes it public.  */
4957         if (current_binding_level == global_binding_level)
4958           {
4959             TREE_PUBLIC (decl) = !(specbits & ((1 << (int) RID_STATIC)
4960                                                | (1 << (int) RID_REGISTER)));
4961             TREE_STATIC (decl) = !extern_ref;
4962           }
4963         /* Not at top level, only `static' makes a static definition.  */
4964         else
4965           {
4966             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4967             TREE_PUBLIC (decl) = extern_ref;
4968           }
4969
4970         if (specbits & 1 << (int) RID_THREAD)
4971           {
4972             if (targetm.have_tls)
4973               DECL_THREAD_LOCAL (decl) = 1;
4974             else
4975               /* A mere warning is sure to result in improper semantics
4976                  at runtime.  Don't bother to allow this to compile.  */
4977               error ("thread-local storage not supported for this target");
4978           }
4979       }
4980
4981     /* Record `register' declaration for warnings on &
4982        and in case doing stupid register allocation.  */
4983
4984     if (specbits & (1 << (int) RID_REGISTER))
4985       DECL_REGISTER (decl) = 1;
4986
4987     /* Record constancy and volatility.  */
4988     c_apply_type_quals_to_decl (type_quals, decl);
4989
4990     /* If a type has volatile components, it should be stored in memory.
4991        Otherwise, the fact that those components are volatile
4992        will be ignored, and would even crash the compiler.  */
4993     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4994       c_mark_addressable (decl);
4995
4996     decl_attributes (&decl, returned_attrs, 0);
4997
4998     return decl;
4999   }
5000 }
5001 \f
5002 /* Decode the parameter-list info for a function type or function definition.
5003    The argument is the value returned by `get_parm_info' (or made in parse.y
5004    if there is an identifier list instead of a parameter decl list).
5005    These two functions are separate because when a function returns
5006    or receives functions then each is called multiple times but the order
5007    of calls is different.  The last call to `grokparms' is always the one
5008    that contains the formal parameter names of a function definition.
5009
5010    Store in `last_function_parms' a chain of the decls of parms.
5011    Also store in `last_function_parm_tags' a chain of the struct, union,
5012    and enum tags declared among the parms.
5013
5014    Return a list of arg types to use in the FUNCTION_TYPE for this function.
5015
5016    FUNCDEF_FLAG is nonzero for a function definition, 0 for
5017    a mere declaration.  A nonempty identifier-list gets an error message
5018    when FUNCDEF_FLAG is zero.  */
5019
5020 static tree
5021 grokparms (parms_info, funcdef_flag)
5022      tree parms_info;
5023      int funcdef_flag;
5024 {
5025   tree first_parm = TREE_CHAIN (parms_info);
5026
5027   last_function_parms = TREE_PURPOSE (parms_info);
5028   last_function_parm_tags = TREE_VALUE (parms_info);
5029
5030   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
5031       && !in_system_header)
5032     warning ("function declaration isn't a prototype");
5033
5034   if (first_parm != 0
5035       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
5036     {
5037       if (! funcdef_flag)
5038         pedwarn ("parameter names (without types) in function declaration");
5039
5040       last_function_parms = first_parm;
5041       return 0;
5042     }
5043   else
5044     {
5045       tree parm;
5046       tree typelt;
5047       /* We no longer test FUNCDEF_FLAG.
5048          If the arg types are incomplete in a declaration,
5049          they must include undefined tags.
5050          These tags can never be defined in the scope of the declaration,
5051          so the types can never be completed,
5052          and no call can be compiled successfully.  */
5053 #if 0
5054       /* In a fcn definition, arg types must be complete.  */
5055       if (funcdef_flag)
5056 #endif
5057         for (parm = last_function_parms, typelt = first_parm;
5058              parm;
5059              parm = TREE_CHAIN (parm))
5060           /* Skip over any enumeration constants declared here.  */
5061           if (TREE_CODE (parm) == PARM_DECL)
5062             {
5063               /* Barf if the parameter itself has an incomplete type.  */
5064               tree type = TREE_VALUE (typelt);
5065               if (type == error_mark_node)
5066                 continue;
5067               if (!COMPLETE_TYPE_P (type))
5068                 {
5069                   if (funcdef_flag && DECL_NAME (parm) != 0)
5070                     error ("parameter `%s' has incomplete type",
5071                            IDENTIFIER_POINTER (DECL_NAME (parm)));
5072                   else
5073                     warning ("parameter has incomplete type");
5074                   if (funcdef_flag)
5075                     {
5076                       TREE_VALUE (typelt) = error_mark_node;
5077                       TREE_TYPE (parm) = error_mark_node;
5078                     }
5079                 }
5080 #if 0
5081               /* This has been replaced by parm_tags_warning, which
5082                  uses a more accurate criterion for what to warn
5083                  about.  */
5084               else
5085                 {
5086                   /* Now warn if is a pointer to an incomplete type.  */
5087                   while (TREE_CODE (type) == POINTER_TYPE
5088                          || TREE_CODE (type) == REFERENCE_TYPE)
5089                     type = TREE_TYPE (type);
5090                   type = TYPE_MAIN_VARIANT (type);
5091                   if (!COMPLETE_TYPE_P (type))
5092                     {
5093                       if (DECL_NAME (parm) != 0)
5094                         warning ("parameter `%s' points to incomplete type",
5095                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
5096                       else
5097                         warning ("parameter points to incomplete type");
5098                     }
5099                 }
5100 #endif
5101               typelt = TREE_CHAIN (typelt);
5102             }
5103
5104       return first_parm;
5105     }
5106 }
5107
5108 /* Return a tree_list node with info on a parameter list just parsed.
5109    The TREE_PURPOSE is a chain of decls of those parms.
5110    The TREE_VALUE is a list of structure, union and enum tags defined.
5111    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5112    This tree_list node is later fed to `grokparms'.
5113
5114    VOID_AT_END nonzero means append `void' to the end of the type-list.
5115    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
5116
5117 tree
5118 get_parm_info (void_at_end)
5119      int void_at_end;
5120 {
5121   tree decl, t;
5122   tree types = 0;
5123   int erred = 0;
5124   tree tags = gettags ();
5125   tree parms = getdecls ();
5126   tree new_parms = 0;
5127   tree order = current_binding_level->parm_order;
5128
5129   /* Just `void' (and no ellipsis) is special.  There are really no parms.
5130      But if the `void' is qualified (by `const' or `volatile') or has a
5131      storage class specifier (`register'), then the behavior is undefined;
5132      by not counting it as the special case of `void' we will cause an
5133      error later.  Typedefs for `void' are OK (see DR#157).  */
5134   if (void_at_end && parms != 0
5135       && TREE_CHAIN (parms) == 0
5136       && VOID_TYPE_P (TREE_TYPE (parms))
5137       && ! TREE_THIS_VOLATILE (parms)
5138       && ! TREE_READONLY (parms)
5139       && ! DECL_REGISTER (parms)
5140       && DECL_NAME (parms) == 0)
5141     {
5142       parms = NULL_TREE;
5143       storedecls (NULL_TREE);
5144       return tree_cons (NULL_TREE, NULL_TREE,
5145                         tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5146     }
5147
5148   /* Extract enumerator values and other non-parms declared with the parms.
5149      Likewise any forward parm decls that didn't have real parm decls.  */
5150   for (decl = parms; decl;)
5151     {
5152       tree next = TREE_CHAIN (decl);
5153
5154       if (TREE_CODE (decl) != PARM_DECL)
5155         {
5156           TREE_CHAIN (decl) = new_parms;
5157           new_parms = decl;
5158         }
5159       else if (TREE_ASM_WRITTEN (decl))
5160         {
5161           error_with_decl (decl,
5162                            "parameter `%s' has just a forward declaration");
5163           TREE_CHAIN (decl) = new_parms;
5164           new_parms = decl;
5165         }
5166       decl = next;
5167     }
5168
5169   /* Put the parm decls back in the order they were in in the parm list.  */
5170   for (t = order; t; t = TREE_CHAIN (t))
5171     {
5172       if (TREE_CHAIN (t))
5173         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5174       else
5175         TREE_CHAIN (TREE_VALUE (t)) = 0;
5176     }
5177
5178   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5179                        new_parms);
5180
5181   /* Store the parmlist in the binding level since the old one
5182      is no longer a valid list.  (We have changed the chain pointers.)  */
5183   storedecls (new_parms);
5184
5185   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5186     /* There may also be declarations for enumerators if an enumeration
5187        type is declared among the parms.  Ignore them here.  */
5188     if (TREE_CODE (decl) == PARM_DECL)
5189       {
5190         /* Since there is a prototype,
5191            args are passed in their declared types.  */
5192         tree type = TREE_TYPE (decl);
5193         DECL_ARG_TYPE (decl) = type;
5194         if (PROMOTE_PROTOTYPES
5195             && INTEGRAL_TYPE_P (type)
5196             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5197           DECL_ARG_TYPE (decl) = integer_type_node;
5198
5199         types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5200         if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
5201             && DECL_NAME (decl) == 0)
5202           {
5203             error ("`void' in parameter list must be the entire list");
5204             erred = 1;
5205           }
5206       }
5207
5208   if (void_at_end)
5209     return tree_cons (new_parms, tags,
5210                       nreverse (tree_cons (NULL_TREE, void_type_node, types)));
5211
5212   return tree_cons (new_parms, tags, nreverse (types));
5213 }
5214
5215 /* At end of parameter list, warn about any struct, union or enum tags
5216    defined within.  Do so because these types cannot ever become complete.  */
5217
5218 void
5219 parmlist_tags_warning ()
5220 {
5221   tree elt;
5222   static int already;
5223
5224   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5225     {
5226       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5227       /* An anonymous union parm type is meaningful as a GNU extension.
5228          So don't warn for that.  */
5229       if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
5230         continue;
5231       if (TREE_PURPOSE (elt) != 0)
5232         {
5233           if (code == RECORD_TYPE)
5234             warning ("`struct %s' declared inside parameter list",
5235                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5236           else if (code == UNION_TYPE)
5237             warning ("`union %s' declared inside parameter list",
5238                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5239           else
5240             warning ("`enum %s' declared inside parameter list",
5241                      IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5242         }
5243       else
5244         {
5245           /* For translation these need to be separate warnings */
5246           if (code == RECORD_TYPE)
5247             warning ("anonymous struct declared inside parameter list");
5248           else if (code == UNION_TYPE)
5249             warning ("anonymous union declared inside parameter list");
5250           else
5251             warning ("anonymous enum declared inside parameter list");
5252         }
5253       if (! already)
5254         {
5255           warning ("its scope is only this definition or declaration, which is probably not what you want");
5256           already = 1;
5257         }
5258     }
5259 }
5260 \f
5261 /* Get the struct, enum or union (CODE says which) with tag NAME.
5262    Define the tag as a forward-reference if it is not defined.  */
5263
5264 tree
5265 xref_tag (code, name)
5266      enum tree_code code;
5267      tree name;
5268 {
5269   /* If a cross reference is requested, look up the type
5270      already defined for this tag and return it.  */
5271
5272   tree ref = lookup_tag (code, name, current_binding_level, 0);
5273   /* If this is the right type of tag, return what we found.
5274      (This reference will be shadowed by shadow_tag later if appropriate.)
5275      If this is the wrong type of tag, do not return it.  If it was the
5276      wrong type in the same binding level, we will have had an error
5277      message already; if in a different binding level and declaring
5278      a name, pending_xref_error will give an error message; but if in a
5279      different binding level and not declaring a name, this tag should
5280      shadow the previous declaration of a different type of tag, and
5281      this would not work properly if we return the reference found.
5282      (For example, with "struct foo" in an outer scope, "union foo;"
5283      must shadow that tag with a new one of union type.)  */
5284   if (ref && TREE_CODE (ref) == code)
5285     return ref;
5286
5287   /* If no such tag is yet defined, create a forward-reference node
5288      and record it as the "definition".
5289      When a real declaration of this type is found,
5290      the forward-reference will be altered into a real type.  */
5291
5292   ref = make_node (code);
5293   if (code == ENUMERAL_TYPE)
5294     {
5295       /* Give the type a default layout like unsigned int
5296          to avoid crashing if it does not get defined.  */
5297       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5298       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5299       TYPE_USER_ALIGN (ref) = 0;
5300       TREE_UNSIGNED (ref) = 1;
5301       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5302       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5303       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5304     }
5305
5306   pushtag (name, ref);
5307
5308   return ref;
5309 }
5310 \f
5311 /* Make sure that the tag NAME is defined *in the current binding level*
5312    at least as a forward reference.
5313    CODE says which kind of tag NAME ought to be.  */
5314
5315 tree
5316 start_struct (code, name)
5317      enum tree_code code;
5318      tree name;
5319 {
5320   /* If there is already a tag defined at this binding level
5321      (as a forward reference), just return it.  */
5322
5323   tree ref = 0;
5324
5325   if (name != 0)
5326     ref = lookup_tag (code, name, current_binding_level, 1);
5327   if (ref && TREE_CODE (ref) == code)
5328     {
5329       C_TYPE_BEING_DEFINED (ref) = 1;
5330       TYPE_PACKED (ref) = flag_pack_struct;
5331       if (TYPE_FIELDS (ref))
5332         {
5333           if (code == UNION_TYPE)
5334             error ("redefinition of `union %s'",
5335                    IDENTIFIER_POINTER (name));
5336           else
5337             error ("redefinition of `struct %s'",
5338                    IDENTIFIER_POINTER (name));
5339         }
5340
5341       return ref;
5342     }
5343
5344   /* Otherwise create a forward-reference just so the tag is in scope.  */
5345
5346   ref = make_node (code);
5347   pushtag (name, ref);
5348   C_TYPE_BEING_DEFINED (ref) = 1;
5349   TYPE_PACKED (ref) = flag_pack_struct;
5350   return ref;
5351 }
5352
5353 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5354    of a structure component, returning a FIELD_DECL node.
5355    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5356
5357    This is done during the parsing of the struct declaration.
5358    The FIELD_DECL nodes are chained together and the lot of them
5359    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5360
5361 tree
5362 grokfield (filename, line, declarator, declspecs, width)
5363      const char *filename ATTRIBUTE_UNUSED;
5364      int line ATTRIBUTE_UNUSED;
5365      tree declarator, declspecs, width;
5366 {
5367   tree value;
5368
5369   if (declarator == NULL_TREE && width == NULL_TREE)
5370     {
5371       /* This is an unnamed decl.
5372
5373          If we have something of the form "union { list } ;" then this
5374          is the anonymous union extension.  Similarly for struct.
5375
5376          If this is something of the form "struct foo;", then
5377            If MS extensions are enabled, this is handled as an
5378              anonymous struct.
5379            Otherwise this is a forward declaration of a structure tag.
5380
5381          If this is something of the form "foo;" and foo is a TYPE_DECL, then
5382            If MS extensions are enabled and foo names a structure, then
5383              again this is an anonymous struct.
5384            Otherwise this is an error.
5385
5386          Oh what a horrid tangled web we weave.  I wonder if MS consiously
5387          took this from Plan 9 or if it was an accident of implementation
5388          that took root before someone noticed the bug...  */
5389
5390       tree type = TREE_VALUE (declspecs);
5391
5392       if (flag_ms_extensions && TREE_CODE (type) == TYPE_DECL)
5393         type = TREE_TYPE (type);
5394       if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE)
5395         {
5396           if (flag_ms_extensions)
5397             ; /* ok */
5398           else if (flag_iso)
5399             goto warn_unnamed_field;
5400           else if (TYPE_NAME (type) == NULL)
5401             ; /* ok */
5402           else
5403             goto warn_unnamed_field;
5404         }
5405       else
5406         {
5407         warn_unnamed_field:
5408           warning ("declaration does not declare anything");
5409           return NULL_TREE;
5410         }
5411     }
5412
5413   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5414
5415   finish_decl (value, NULL_TREE, NULL_TREE);
5416   DECL_INITIAL (value) = width;
5417
5418   maybe_objc_check_decl (value);
5419   return value;
5420 }
5421 \f
5422 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5423    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5424    ATTRIBUTES are attributes to be applied to the structure.  */
5425
5426 tree
5427 finish_struct (t, fieldlist, attributes)
5428      tree t;
5429      tree fieldlist;
5430      tree attributes;
5431 {
5432   tree x;
5433   int toplevel = global_binding_level == current_binding_level;
5434   int saw_named_field;
5435
5436   /* If this type was previously laid out as a forward reference,
5437      make sure we lay it out again.  */
5438
5439   TYPE_SIZE (t) = 0;
5440
5441   decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5442
5443   /* Nameless union parm types are useful as GCC extension.  */
5444   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5445     /* Otherwise, warn about any struct or union def. in parmlist.  */
5446     if (in_parm_level_p ())
5447       {
5448         if (pedantic)
5449           pedwarn ("%s defined inside parms",
5450                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5451         else
5452           warning ("%s defined inside parms",
5453                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5454       }
5455
5456   if (pedantic)
5457     {
5458       for (x = fieldlist; x; x = TREE_CHAIN (x))
5459         if (DECL_NAME (x) != 0)
5460           break;
5461
5462       if (x == 0)
5463         pedwarn ("%s has no %s",
5464                  TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
5465                  fieldlist ? _("named members") : _("members"));
5466     }
5467
5468   /* Install struct as DECL_CONTEXT of each field decl.
5469      Also process specified field sizes,m which is found in the DECL_INITIAL.
5470      Store 0 there, except for ": 0" fields (so we can find them
5471      and delete them, below).  */
5472
5473   saw_named_field = 0;
5474   for (x = fieldlist; x; x = TREE_CHAIN (x))
5475     {
5476       DECL_CONTEXT (x) = t;
5477       DECL_PACKED (x) |= TYPE_PACKED (t);
5478
5479       /* If any field is const, the structure type is pseudo-const.  */
5480       if (TREE_READONLY (x))
5481         C_TYPE_FIELDS_READONLY (t) = 1;
5482       else
5483         {
5484           /* A field that is pseudo-const makes the structure likewise.  */
5485           tree t1 = TREE_TYPE (x);
5486           while (TREE_CODE (t1) == ARRAY_TYPE)
5487             t1 = TREE_TYPE (t1);
5488           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5489               && C_TYPE_FIELDS_READONLY (t1))
5490             C_TYPE_FIELDS_READONLY (t) = 1;
5491         }
5492
5493       /* Any field that is volatile means variables of this type must be
5494          treated in some ways as volatile.  */
5495       if (TREE_THIS_VOLATILE (x))
5496         C_TYPE_FIELDS_VOLATILE (t) = 1;
5497
5498       /* Any field of nominal variable size implies structure is too.  */
5499       if (C_DECL_VARIABLE_SIZE (x))
5500         C_TYPE_VARIABLE_SIZE (t) = 1;
5501
5502       /* Detect invalid nested redefinition.  */
5503       if (TREE_TYPE (x) == t)
5504         error ("nested redefinition of `%s'",
5505                IDENTIFIER_POINTER (TYPE_NAME (t)));
5506
5507       /* Detect invalid bit-field size.  */
5508       if (DECL_INITIAL (x))
5509         STRIP_NOPS (DECL_INITIAL (x));
5510       if (DECL_INITIAL (x))
5511         {
5512           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5513             constant_expression_warning (DECL_INITIAL (x));
5514           else
5515             {
5516               error_with_decl (x,
5517                                "bit-field `%s' width not an integer constant");
5518               DECL_INITIAL (x) = NULL;
5519             }
5520         }
5521
5522       /* Detect invalid bit-field type.  */
5523       if (DECL_INITIAL (x)
5524           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5525           && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE
5526           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5527         {
5528           error_with_decl (x, "bit-field `%s' has invalid type");
5529           DECL_INITIAL (x) = NULL;
5530         }
5531
5532       if (DECL_INITIAL (x) && pedantic
5533           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5534           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5535           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != c_bool_type_node
5536           /* Accept an enum that's equivalent to int or unsigned int.  */
5537           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5538                && (TYPE_PRECISION (TREE_TYPE (x))
5539                    == TYPE_PRECISION (integer_type_node))))
5540         pedwarn_with_decl (x, "bit-field `%s' type invalid in ISO C");
5541
5542       /* Detect and ignore out of range field width and process valid
5543          field widths.  */
5544       if (DECL_INITIAL (x))
5545         {
5546           int max_width
5547             = (TYPE_MAIN_VARIANT (TREE_TYPE (x)) == c_bool_type_node
5548                ? CHAR_TYPE_SIZE : TYPE_PRECISION (TREE_TYPE (x)));
5549
5550           if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5551             error_with_decl (x, "negative width in bit-field `%s'");
5552           else if (0 < compare_tree_int (DECL_INITIAL (x), max_width))
5553             pedwarn_with_decl (x, "width of `%s' exceeds its type");
5554           else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5555             error_with_decl (x, "zero width for bit-field `%s'");
5556           else
5557             {
5558               /* The test above has assured us that TREE_INT_CST_HIGH is 0.  */
5559               unsigned HOST_WIDE_INT width
5560                 = tree_low_cst (DECL_INITIAL (x), 1);
5561
5562               if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5563                   && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5564                                              TREE_UNSIGNED (TREE_TYPE (x)))
5565                       || (width
5566                           < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5567                                            TREE_UNSIGNED (TREE_TYPE (x))))))
5568                 warning_with_decl (x,
5569                                    "`%s' is narrower than values of its type");
5570
5571               DECL_SIZE (x) = bitsize_int (width);
5572               DECL_BIT_FIELD (x) = 1;
5573               SET_DECL_C_BIT_FIELD (x);
5574
5575               if (width == 0
5576                   && ! (* targetm.ms_bitfield_layout_p) (t))
5577                 {
5578                   /* field size 0 => force desired amount of alignment.  */
5579 #ifdef EMPTY_FIELD_BOUNDARY
5580                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5581 #endif
5582 #ifdef PCC_BITFIELD_TYPE_MATTERS
5583                   if (PCC_BITFIELD_TYPE_MATTERS)
5584                     {
5585                       DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5586                                             TYPE_ALIGN (TREE_TYPE (x)));
5587                       DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5588                     }
5589 #endif
5590                 }
5591             }
5592         }
5593
5594       else if (TREE_TYPE (x) != error_mark_node)
5595         {
5596           unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5597                                     : TYPE_ALIGN (TREE_TYPE (x)));
5598
5599           /* Non-bit-fields are aligned for their type, except packed
5600              fields which require only BITS_PER_UNIT alignment.  */
5601           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5602           if (! DECL_PACKED (x))
5603             DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5604         }
5605
5606       DECL_INITIAL (x) = 0;
5607
5608       /* Detect flexible array member in an invalid context.  */
5609       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5610           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5611           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5612           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5613         {
5614           if (TREE_CODE (t) == UNION_TYPE)
5615             error_with_decl (x, "flexible array member in union");
5616           else if (TREE_CHAIN (x) != NULL_TREE)
5617             error_with_decl (x, "flexible array member not at end of struct");
5618           else if (! saw_named_field)
5619             error_with_decl (x, "flexible array member in otherwise empty struct");
5620         }
5621       if (DECL_NAME (x))
5622         saw_named_field = 1;
5623     }
5624
5625   /* Delete all duplicate fields from the fieldlist */
5626   for (x = fieldlist; x && TREE_CHAIN (x);)
5627     /* Anonymous fields aren't duplicates.  */
5628     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5629       x = TREE_CHAIN (x);
5630     else
5631       {
5632         tree y = fieldlist;
5633
5634         while (1)
5635           {
5636             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5637               break;
5638             if (y == x)
5639               break;
5640             y = TREE_CHAIN (y);
5641           }
5642         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5643           {
5644             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5645             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5646           }
5647         else
5648           x = TREE_CHAIN (x);
5649       }
5650
5651   /* Now we have the nearly final fieldlist.  Record it,
5652      then lay out the structure or union (including the fields).  */
5653
5654   TYPE_FIELDS (t) = fieldlist;
5655
5656   layout_type (t);
5657
5658   /* Delete all zero-width bit-fields from the fieldlist */
5659   {
5660     tree *fieldlistp = &fieldlist;
5661     while (*fieldlistp)
5662       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5663         *fieldlistp = TREE_CHAIN (*fieldlistp);
5664       else
5665         fieldlistp = &TREE_CHAIN (*fieldlistp);
5666   }
5667
5668   /* Now we have the truly final field list.
5669      Store it in this type and in the variants.  */
5670
5671   TYPE_FIELDS (t) = fieldlist;
5672
5673   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5674     {
5675       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5676       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5677       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5678       TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5679     }
5680
5681   /* If this was supposed to be a transparent union, but we can't
5682      make it one, warn and turn off the flag.  */
5683   if (TREE_CODE (t) == UNION_TYPE
5684       && TYPE_TRANSPARENT_UNION (t)
5685       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5686     {
5687       TYPE_TRANSPARENT_UNION (t) = 0;
5688       warning ("union cannot be made transparent");
5689     }
5690
5691   /* If this structure or union completes the type of any previous
5692      variable declaration, lay it out and output its rtl.  */
5693
5694   if (current_binding_level->incomplete_list != NULL_TREE)
5695     {
5696       tree prev = NULL_TREE;
5697
5698       for (x = current_binding_level->incomplete_list; x; x = TREE_CHAIN (x))
5699         {
5700           tree decl = TREE_VALUE (x);
5701
5702           if (TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TYPE_MAIN_VARIANT (t)
5703               && TREE_CODE (decl) != TYPE_DECL)
5704             {
5705               layout_decl (decl, 0);
5706               /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
5707               maybe_objc_check_decl (decl);
5708               rest_of_decl_compilation (decl, NULL, toplevel, 0);
5709               if (! toplevel)
5710                 expand_decl (decl);
5711               /* Unlink X from the incomplete list.  */
5712               if (prev)
5713                 TREE_CHAIN (prev) = TREE_CHAIN (x);
5714               else
5715                 current_binding_level->incomplete_list = TREE_CHAIN (x);
5716             }
5717           else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5718                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5719             {
5720               tree element = TREE_TYPE (decl);
5721               while (TREE_CODE (element) == ARRAY_TYPE)
5722                 element = TREE_TYPE (element);
5723               if (element == t)
5724                 {
5725                   layout_array_type (TREE_TYPE (decl));
5726                   if (TREE_CODE (decl) != TYPE_DECL)
5727                     {
5728                       layout_decl (decl, 0);
5729                       maybe_objc_check_decl (decl);
5730                       rest_of_decl_compilation (decl, NULL, toplevel, 0);
5731                       if (! toplevel)
5732                         expand_decl (decl);
5733                     }
5734                   /* Unlink X from the incomplete list.  */
5735                   if (prev)
5736                     TREE_CHAIN (prev) = TREE_CHAIN (x);
5737                   else
5738                     current_binding_level->incomplete_list = TREE_CHAIN (x);
5739                 }
5740             }
5741         }
5742     }
5743
5744   /* Finish debugging output for this type.  */
5745   rest_of_type_compilation (t, toplevel);
5746
5747   return t;
5748 }
5749
5750 /* Lay out the type T, and its element type, and so on.  */
5751
5752 static void
5753 layout_array_type (t)
5754      tree t;
5755 {
5756   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5757     layout_array_type (TREE_TYPE (t));
5758   layout_type (t);
5759 }
5760 \f
5761 /* Begin compiling the definition of an enumeration type.
5762    NAME is its name (or null if anonymous).
5763    Returns the type object, as yet incomplete.
5764    Also records info about it so that build_enumerator
5765    may be used to declare the individual values as they are read.  */
5766
5767 tree
5768 start_enum (name)
5769      tree name;
5770 {
5771   tree enumtype = 0;
5772
5773   /* If this is the real definition for a previous forward reference,
5774      fill in the contents in the same object that used to be the
5775      forward reference.  */
5776
5777   if (name != 0)
5778     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5779
5780   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5781     {
5782       enumtype = make_node (ENUMERAL_TYPE);
5783       pushtag (name, enumtype);
5784     }
5785
5786   C_TYPE_BEING_DEFINED (enumtype) = 1;
5787
5788   if (TYPE_VALUES (enumtype) != 0)
5789     {
5790       /* This enum is a named one that has been declared already.  */
5791       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5792
5793       /* Completely replace its old definition.
5794          The old enumerators remain defined, however.  */
5795       TYPE_VALUES (enumtype) = 0;
5796     }
5797
5798   enum_next_value = integer_zero_node;
5799   enum_overflow = 0;
5800
5801   if (flag_short_enums)
5802     TYPE_PACKED (enumtype) = 1;
5803
5804   return enumtype;
5805 }
5806
5807 /* After processing and defining all the values of an enumeration type,
5808    install their decls in the enumeration type and finish it off.
5809    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5810    and ATTRIBUTES are the specified attributes.
5811    Returns ENUMTYPE.  */
5812
5813 tree
5814 finish_enum (enumtype, values, attributes)
5815      tree enumtype;
5816      tree values;
5817      tree attributes;
5818 {
5819   tree pair, tem;
5820   tree minnode = 0, maxnode = 0, enum_value_type;
5821   int precision, unsign;
5822   int toplevel = (global_binding_level == current_binding_level);
5823
5824   if (in_parm_level_p ())
5825     warning ("enum defined inside parms");
5826
5827   decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5828
5829   /* Calculate the maximum value of any enumerator in this type.  */
5830
5831   if (values == error_mark_node)
5832     minnode = maxnode = integer_zero_node;
5833   else
5834     {
5835       minnode = maxnode = TREE_VALUE (values);
5836       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5837         {
5838           tree value = TREE_VALUE (pair);
5839           if (tree_int_cst_lt (maxnode, value))
5840             maxnode = value;
5841           if (tree_int_cst_lt (value, minnode))
5842             minnode = value;
5843         }
5844     }
5845
5846   /* Construct the final type of this enumeration.  It is the same
5847      as one of the integral types - the narrowest one that fits, except
5848      that normally we only go as narrow as int - and signed iff any of
5849      the values are negative.  */
5850   unsign = (tree_int_cst_sgn (minnode) >= 0);
5851   precision = MAX (min_precision (minnode, unsign),
5852                    min_precision (maxnode, unsign));
5853   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5854     {
5855       tree narrowest = c_common_type_for_size (precision, unsign);
5856       if (narrowest == 0)
5857         {
5858           warning ("enumeration values exceed range of largest integer");
5859           narrowest = long_long_integer_type_node;
5860         }
5861
5862       precision = TYPE_PRECISION (narrowest);
5863     }
5864   else
5865     precision = TYPE_PRECISION (integer_type_node);
5866
5867   if (precision == TYPE_PRECISION (integer_type_node))
5868     enum_value_type = c_common_type_for_size (precision, 0);
5869   else
5870     enum_value_type = enumtype;
5871
5872   TYPE_MIN_VALUE (enumtype) = minnode;
5873   TYPE_MAX_VALUE (enumtype) = maxnode;
5874   TYPE_PRECISION (enumtype) = precision;
5875   TREE_UNSIGNED (enumtype) = unsign;
5876   TYPE_SIZE (enumtype) = 0;
5877   layout_type (enumtype);
5878
5879   if (values != error_mark_node)
5880     {
5881       /* Change the type of the enumerators to be the enum type.  We
5882          need to do this irrespective of the size of the enum, for
5883          proper type checking.  Replace the DECL_INITIALs of the
5884          enumerators, and the value slots of the list, with copies
5885          that have the enum type; they cannot be modified in place
5886          because they may be shared (e.g.  integer_zero_node) Finally,
5887          change the purpose slots to point to the names of the decls.  */
5888       for (pair = values; pair; pair = TREE_CHAIN (pair))
5889         {
5890           tree enu = TREE_PURPOSE (pair);
5891
5892           TREE_TYPE (enu) = enumtype;
5893           DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5894           DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5895           DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5896           DECL_USER_ALIGN (enu) = TYPE_USER_ALIGN (enumtype);
5897           DECL_MODE (enu) = TYPE_MODE (enumtype);
5898
5899           /* The ISO C Standard mandates enumerators to have type int,
5900              even though the underlying type of an enum type is
5901              unspecified.  Here we convert any enumerators that fit in
5902              an int to type int, to avoid promotions to unsigned types
5903              when comparing integers with enumerators that fit in the
5904              int range.  When -pedantic is given, build_enumerator()
5905              would have already taken care of those that don't fit.  */
5906           if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5907             DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5908           else
5909             DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5910
5911           TREE_PURPOSE (pair) = DECL_NAME (enu);
5912           TREE_VALUE (pair) = DECL_INITIAL (enu);
5913         }
5914
5915       TYPE_VALUES (enumtype) = values;
5916     }
5917
5918   /* Fix up all variant types of this enum type.  */
5919   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5920     {
5921       if (tem == enumtype)
5922         continue;
5923       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5924       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5925       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5926       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5927       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5928       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5929       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5930       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5931       TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5932       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5933     }
5934
5935   /* Finish debugging output for this type.  */
5936   rest_of_type_compilation (enumtype, toplevel);
5937
5938   return enumtype;
5939 }
5940
5941 /* Build and install a CONST_DECL for one value of the
5942    current enumeration type (one that was begun with start_enum).
5943    Return a tree-list containing the CONST_DECL and its value.
5944    Assignment of sequential values by default is handled here.  */
5945
5946 tree
5947 build_enumerator (name, value)
5948      tree name, value;
5949 {
5950   tree decl, type;
5951
5952   /* Validate and default VALUE.  */
5953
5954   /* Remove no-op casts from the value.  */
5955   if (value)
5956     STRIP_TYPE_NOPS (value);
5957
5958   if (value != 0)
5959     {
5960       if (TREE_CODE (value) == INTEGER_CST)
5961         {
5962           value = default_conversion (value);
5963           constant_expression_warning (value);
5964         }
5965       else
5966         {
5967           error ("enumerator value for `%s' not integer constant",
5968                  IDENTIFIER_POINTER (name));
5969           value = 0;
5970         }
5971     }
5972
5973   /* Default based on previous value.  */
5974   /* It should no longer be possible to have NON_LVALUE_EXPR
5975      in the default.  */
5976   if (value == 0)
5977     {
5978       value = enum_next_value;
5979       if (enum_overflow)
5980         error ("overflow in enumeration values");
5981     }
5982
5983   if (pedantic && ! int_fits_type_p (value, integer_type_node))
5984     {
5985       pedwarn ("ISO C restricts enumerator values to range of `int'");
5986       value = convert (integer_type_node, value);
5987     }
5988
5989   /* Set basis for default for next value.  */
5990   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5991   enum_overflow = tree_int_cst_lt (enum_next_value, value);
5992
5993   /* Now create a declaration for the enum value name.  */
5994
5995   type = TREE_TYPE (value);
5996   type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5997                                       TYPE_PRECISION (integer_type_node)),
5998                                  (TYPE_PRECISION (type)
5999                                   >= TYPE_PRECISION (integer_type_node)
6000                                   && TREE_UNSIGNED (type)));
6001
6002   decl = build_decl (CONST_DECL, name, type);
6003   DECL_INITIAL (decl) = convert (type, value);
6004   pushdecl (decl);
6005
6006   return tree_cons (decl, value, NULL_TREE);
6007 }
6008
6009 \f
6010 /* Create the FUNCTION_DECL for a function definition.
6011    DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
6012    the declaration; they describe the function's name and the type it returns,
6013    but twisted together in a fashion that parallels the syntax of C.
6014
6015    This function creates a binding context for the function body
6016    as well as setting up the FUNCTION_DECL in current_function_decl.
6017
6018    Returns 1 on success.  If the DECLARATOR is not suitable for a function
6019    (it defines a datum instead), we return 0, which tells
6020    yyparse to report a parse error.  */
6021
6022 int
6023 start_function (declspecs, declarator, attributes)
6024      tree declarator, declspecs, attributes;
6025 {
6026   tree decl1, old_decl;
6027   tree restype;
6028   int old_immediate_size_expand = immediate_size_expand;
6029
6030   current_function_returns_value = 0;  /* Assume, until we see it does.  */
6031   current_function_returns_null = 0;
6032   current_function_returns_abnormally = 0;
6033   warn_about_return_type = 0;
6034   current_extern_inline = 0;
6035   c_function_varargs = 0;
6036   named_labels = 0;
6037   shadowed_labels = 0;
6038
6039   /* Don't expand any sizes in the return type of the function.  */
6040   immediate_size_expand = 0;
6041
6042   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
6043
6044   /* If the declarator is not suitable for a function definition,
6045      cause a syntax error.  */
6046   if (decl1 == 0)
6047     {
6048       immediate_size_expand = old_immediate_size_expand;
6049       return 0;
6050     }
6051
6052   decl_attributes (&decl1, attributes, 0);
6053
6054   /* If #pragma weak was used, mark the decl weak now.  */
6055   if (current_binding_level == global_binding_level)
6056     maybe_apply_pragma_weak (decl1);
6057
6058   if (DECL_DECLARED_INLINE_P (decl1)
6059       && DECL_UNINLINABLE (decl1)
6060       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
6061     warning_with_decl (decl1,
6062                        "inline function `%s' given attribute noinline");
6063
6064   announce_function (decl1);
6065
6066   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
6067     {
6068       error ("return type is an incomplete type");
6069       /* Make it return void instead.  */
6070       TREE_TYPE (decl1)
6071         = build_function_type (void_type_node,
6072                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6073     }
6074
6075   if (warn_about_return_type)
6076     pedwarn_c99 ("return type defaults to `int'");
6077
6078   /* Save the parm names or decls from this function's declarator
6079      where store_parm_decls will find them.  */
6080   current_function_parms = last_function_parms;
6081   current_function_parm_tags = last_function_parm_tags;
6082
6083   /* Make the init_value nonzero so pushdecl knows this is not tentative.
6084      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
6085   DECL_INITIAL (decl1) = error_mark_node;
6086
6087   /* If this definition isn't a prototype and we had a prototype declaration
6088      before, copy the arg type info from that prototype.
6089      But not if what we had before was a builtin function.  */
6090   old_decl = lookup_name_current_level (DECL_NAME (decl1));
6091   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6092       && !DECL_BUILT_IN (old_decl)
6093       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6094           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
6095       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6096     {
6097       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
6098       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
6099       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
6100     }
6101
6102   /* If there is no explicit declaration, look for any out-of-scope implicit
6103      declarations.  */
6104   if (old_decl == 0)
6105     old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
6106
6107   /* Optionally warn of old-fashioned def with no previous prototype.  */
6108   if (warn_strict_prototypes
6109       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6110       && !(old_decl != 0
6111            && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
6112                || (DECL_BUILT_IN (old_decl)
6113                    && ! C_DECL_ANTICIPATED (old_decl)))))
6114     warning ("function declaration isn't a prototype");
6115   /* Optionally warn of any global def with no previous prototype.  */
6116   else if (warn_missing_prototypes
6117            && TREE_PUBLIC (decl1)
6118            && !(old_decl != 0
6119                 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
6120                     || (DECL_BUILT_IN (old_decl)
6121                         && ! C_DECL_ANTICIPATED (old_decl))))
6122            && ! MAIN_NAME_P (DECL_NAME (decl1)))
6123     warning_with_decl (decl1, "no previous prototype for `%s'");
6124   /* Optionally warn of any def with no previous prototype
6125      if the function has already been used.  */
6126   else if (warn_missing_prototypes
6127            && old_decl != 0 && TREE_USED (old_decl)
6128            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6129     warning_with_decl (decl1,
6130                        "`%s' was used with no prototype before its definition");
6131   /* Optionally warn of any global def with no previous declaration.  */
6132   else if (warn_missing_declarations
6133            && TREE_PUBLIC (decl1)
6134            && old_decl == 0
6135            && ! MAIN_NAME_P (DECL_NAME (decl1)))
6136     warning_with_decl (decl1, "no previous declaration for `%s'");
6137   /* Optionally warn of any def with no previous declaration
6138      if the function has already been used.  */
6139   else if (warn_missing_declarations
6140            && old_decl != 0 && TREE_USED (old_decl)
6141            && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
6142     warning_with_decl (decl1,
6143                        "`%s' was used with no declaration before its definition");
6144
6145   /* This is a definition, not a reference.
6146      So normally clear DECL_EXTERNAL.
6147      However, `extern inline' acts like a declaration
6148      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
6149   DECL_EXTERNAL (decl1) = current_extern_inline;
6150
6151   /* This function exists in static storage.
6152      (This does not mean `static' in the C sense!)  */
6153   TREE_STATIC (decl1) = 1;
6154
6155   /* A nested function is not global.  */
6156   if (current_function_decl != 0)
6157     TREE_PUBLIC (decl1) = 0;
6158
6159   /* Warn for unlikely, improbable, or stupid declarations of `main'.  */
6160   if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
6161     {
6162       tree args;
6163       int argct = 0;
6164
6165       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6166           != integer_type_node)
6167         pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
6168
6169       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6170            args = TREE_CHAIN (args))
6171         {
6172           tree type = args ? TREE_VALUE (args) : 0;
6173
6174           if (type == void_type_node)
6175             break;
6176
6177           ++argct;
6178           switch (argct)
6179             {
6180             case 1:
6181               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6182                 pedwarn_with_decl (decl1,
6183                                    "first argument of `%s' should be `int'");
6184               break;
6185
6186             case 2:
6187               if (TREE_CODE (type) != POINTER_TYPE
6188                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6189                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6190                       != char_type_node))
6191                 pedwarn_with_decl (decl1,
6192                                    "second argument of `%s' should be `char **'");
6193               break;
6194
6195             case 3:
6196               if (TREE_CODE (type) != POINTER_TYPE
6197                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6198                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6199                       != char_type_node))
6200                 pedwarn_with_decl (decl1,
6201                                    "third argument of `%s' should probably be `char **'");
6202               break;
6203             }
6204         }
6205
6206       /* It is intentional that this message does not mention the third
6207          argument because it's only mentioned in an appendix of the
6208          standard.  */
6209       if (argct > 0 && (argct < 2 || argct > 3))
6210         pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6211
6212       if (! TREE_PUBLIC (decl1))
6213         pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6214     }
6215
6216   /* Record the decl so that the function name is defined.
6217      If we already have a decl for this name, and it is a FUNCTION_DECL,
6218      use the old decl.  */
6219
6220   current_function_decl = pushdecl (decl1);
6221
6222   pushlevel (0);
6223   declare_parm_level (1);
6224   current_binding_level->subblocks_tag_transparent = 1;
6225
6226   make_decl_rtl (current_function_decl, NULL);
6227
6228   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6229   /* Promote the value to int before returning it.  */
6230   if (c_promoting_integer_type_p (restype))
6231     {
6232       /* It retains unsignedness if not really getting wider.  */
6233       if (TREE_UNSIGNED (restype)
6234           && (TYPE_PRECISION (restype)
6235                   == TYPE_PRECISION (integer_type_node)))
6236         restype = unsigned_type_node;
6237       else
6238         restype = integer_type_node;
6239     }
6240   DECL_RESULT (current_function_decl)
6241     = build_decl (RESULT_DECL, NULL_TREE, restype);
6242
6243   /* If this fcn was already referenced via a block-scope `extern' decl
6244      (or an implicit decl), propagate certain information about the usage.  */
6245   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6246     TREE_ADDRESSABLE (current_function_decl) = 1;
6247
6248   immediate_size_expand = old_immediate_size_expand;
6249
6250   start_fname_decls ();
6251
6252   return 1;
6253 }
6254
6255 /* Record that this function is going to be a varargs function.
6256    This is called before store_parm_decls, which is too early
6257    to call mark_varargs directly.  */
6258
6259 void
6260 c_mark_varargs ()
6261 {
6262   c_function_varargs = 1;
6263 }
6264 \f
6265 /* Store the parameter declarations into the current function declaration.
6266    This is called after parsing the parameter declarations, before
6267    digesting the body of the function.
6268
6269    For an old-style definition, modify the function's type
6270    to specify at least the number of arguments.  */
6271
6272 void
6273 store_parm_decls ()
6274 {
6275   tree fndecl = current_function_decl;
6276   tree parm;
6277
6278   /* This is either a chain of PARM_DECLs (if a prototype was used)
6279      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
6280   tree specparms = current_function_parms;
6281
6282   /* This is a list of types declared among parms in a prototype.  */
6283   tree parmtags = current_function_parm_tags;
6284
6285   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
6286   tree parmdecls = getdecls ();
6287
6288   /* This is a chain of any other decls that came in among the parm
6289      declarations.  If a parm is declared with  enum {foo, bar} x;
6290      then CONST_DECLs for foo and bar are put here.  */
6291   tree nonparms = 0;
6292
6293   /* The function containing FNDECL, if any.  */
6294   tree context = decl_function_context (fndecl);
6295
6296   /* Nonzero if this definition is written with a prototype.  */
6297   int prototype = 0;
6298
6299   int saved_warn_shadow = warn_shadow;
6300
6301   /* Don't re-emit shadow warnings.  */
6302   warn_shadow = 0;
6303
6304   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6305     {
6306       /* This case is when the function was defined with an ANSI prototype.
6307          The parms already have decls, so we need not do anything here
6308          except record them as in effect
6309          and complain if any redundant old-style parm decls were written.  */
6310
6311       tree next;
6312       tree others = 0;
6313
6314       prototype = 1;
6315
6316       if (parmdecls != 0)
6317         {
6318           tree decl, link;
6319
6320           error_with_decl (fndecl,
6321                            "parm types given both in parmlist and separately");
6322           /* Get rid of the erroneous decls; don't keep them on
6323              the list of parms, since they might not be PARM_DECLs.  */
6324           for (decl = current_binding_level->names;
6325                decl; decl = TREE_CHAIN (decl))
6326             if (DECL_NAME (decl))
6327               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6328           for (link = current_binding_level->shadowed;
6329                link; link = TREE_CHAIN (link))
6330             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6331           current_binding_level->names = 0;
6332           current_binding_level->shadowed = 0;
6333         }
6334
6335       specparms = nreverse (specparms);
6336       for (parm = specparms; parm; parm = next)
6337         {
6338           next = TREE_CHAIN (parm);
6339           if (TREE_CODE (parm) == PARM_DECL)
6340             {
6341               if (DECL_NAME (parm) == 0)
6342                 error_with_decl (parm, "parameter name omitted");
6343               else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
6344                        && VOID_TYPE_P (TREE_TYPE (parm)))
6345                 {
6346                   error_with_decl (parm, "parameter `%s' declared void");
6347                   /* Change the type to error_mark_node so this parameter
6348                      will be ignored by assign_parms.  */
6349                   TREE_TYPE (parm) = error_mark_node;
6350                 }
6351               pushdecl (parm);
6352             }
6353           else
6354             {
6355               /* If we find an enum constant or a type tag,
6356                  put it aside for the moment.  */
6357               TREE_CHAIN (parm) = 0;
6358               others = chainon (others, parm);
6359             }
6360         }
6361
6362       /* Get the decls in their original chain order
6363          and record in the function.  */
6364       DECL_ARGUMENTS (fndecl) = getdecls ();
6365
6366 #if 0
6367       /* If this function takes a variable number of arguments,
6368          add a phony parameter to the end of the parm list,
6369          to represent the position of the first unnamed argument.  */
6370       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6371           != void_type_node)
6372         {
6373           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6374           /* Let's hope the address of the unnamed parm
6375              won't depend on its type.  */
6376           TREE_TYPE (dummy) = integer_type_node;
6377           DECL_ARG_TYPE (dummy) = integer_type_node;
6378           DECL_ARGUMENTS (fndecl) = chainon (DECL_ARGUMENTS (fndecl), dummy);
6379         }
6380 #endif
6381
6382       /* Now pushdecl the enum constants.  */
6383       for (parm = others; parm; parm = next)
6384         {
6385           next = TREE_CHAIN (parm);
6386           if (DECL_NAME (parm) == 0)
6387             ;
6388           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6389             ;
6390           else if (TREE_CODE (parm) != PARM_DECL)
6391             pushdecl (parm);
6392         }
6393
6394       storetags (chainon (parmtags, gettags ()));
6395     }
6396   else
6397     {
6398       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6399          each with a parm name as the TREE_VALUE.
6400
6401          PARMDECLS is a chain of declarations for parameters.
6402          Warning! It can also contain CONST_DECLs which are not parameters
6403          but are names of enumerators of any enum types
6404          declared among the parameters.
6405
6406          First match each formal parameter name with its declaration.
6407          Associate decls with the names and store the decls
6408          into the TREE_PURPOSE slots.  */
6409
6410       /* We use DECL_WEAK as a flag to show which parameters have been
6411          seen already since it is not used on PARM_DECL or CONST_DECL.  */
6412       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6413         DECL_WEAK (parm) = 0;
6414
6415       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6416         {
6417           tree tail, found = NULL;
6418
6419           if (TREE_VALUE (parm) == 0)
6420             {
6421               error_with_decl (fndecl,
6422                                "parameter name missing from parameter list");
6423               TREE_PURPOSE (parm) = 0;
6424               continue;
6425             }
6426
6427           /* See if any of the parmdecls specifies this parm by name.
6428              Ignore any enumerator decls.  */
6429           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6430             if (DECL_NAME (tail) == TREE_VALUE (parm)
6431                 && TREE_CODE (tail) == PARM_DECL)
6432               {
6433                 found = tail;
6434                 break;
6435               }
6436
6437           /* If declaration already marked, we have a duplicate name.
6438              Complain, and don't use this decl twice.  */
6439           if (found && DECL_WEAK (found))
6440             {
6441               error_with_decl (found, "multiple parameters named `%s'");
6442               found = 0;
6443             }
6444
6445           /* If the declaration says "void", complain and ignore it.  */
6446           if (found && VOID_TYPE_P (TREE_TYPE (found)))
6447             {
6448               error_with_decl (found, "parameter `%s' declared void");
6449               TREE_TYPE (found) = integer_type_node;
6450               DECL_ARG_TYPE (found) = integer_type_node;
6451               layout_decl (found, 0);
6452             }
6453
6454           /* If no declaration found, default to int.  */
6455           if (!found)
6456             {
6457               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6458                                   integer_type_node);
6459               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6460               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6461               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6462               if (flag_isoc99)
6463                 pedwarn_with_decl (found, "type of `%s' defaults to `int'");
6464               else if (extra_warnings)
6465                 warning_with_decl (found, "type of `%s' defaults to `int'");
6466               pushdecl (found);
6467             }
6468
6469           TREE_PURPOSE (parm) = found;
6470
6471           /* Mark this decl as "already found".  */
6472           DECL_WEAK (found) = 1;
6473         }
6474
6475       /* Put anything which is on the parmdecls chain and which is
6476          not a PARM_DECL onto the list NONPARMS.  (The types of
6477          non-parm things which might appear on the list include
6478          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6479          any actual PARM_DECLs not matched with any names.  */
6480
6481       nonparms = 0;
6482       for (parm = parmdecls; parm;)
6483         {
6484           tree next = TREE_CHAIN (parm);
6485           TREE_CHAIN (parm) = 0;
6486
6487           if (TREE_CODE (parm) != PARM_DECL)
6488             nonparms = chainon (nonparms, parm);
6489           else
6490             {
6491               /* Complain about args with incomplete types.  */
6492               if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6493                 {
6494                   error_with_decl (parm, "parameter `%s' has incomplete type");
6495                   TREE_TYPE (parm) = error_mark_node;
6496                 }
6497
6498               if (! DECL_WEAK (parm))
6499                 {
6500                   error_with_decl (parm,
6501                                    "declaration for parameter `%s' but no such parameter");
6502                   /* Pretend the parameter was not missing.
6503                      This gets us to a standard state and minimizes
6504                      further error messages.  */
6505                   specparms
6506                     = chainon (specparms,
6507                                tree_cons (parm, NULL_TREE, NULL_TREE));
6508                 }
6509             }
6510
6511           parm = next;
6512         }
6513
6514       /* Chain the declarations together in the order of the list of
6515          names.  Store that chain in the function decl, replacing the
6516          list of names.  */
6517       parm = specparms;
6518       DECL_ARGUMENTS (fndecl) = 0;
6519       {
6520         tree last;
6521         for (last = 0; parm; parm = TREE_CHAIN (parm))
6522           if (TREE_PURPOSE (parm))
6523             {
6524               if (last == 0)
6525                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6526               else
6527                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6528               last = TREE_PURPOSE (parm);
6529               TREE_CHAIN (last) = 0;
6530             }
6531       }
6532
6533       /* If there was a previous prototype,
6534          set the DECL_ARG_TYPE of each argument according to
6535          the type previously specified, and report any mismatches.  */
6536
6537       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6538         {
6539           tree type;
6540           for (parm = DECL_ARGUMENTS (fndecl),
6541                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6542                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6543                                  != void_type_node));
6544                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6545             {
6546               if (parm == 0 || type == 0
6547                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6548                 {
6549                   error ("number of arguments doesn't match prototype");
6550                   error_with_file_and_line (current_function_prototype_file,
6551                                             current_function_prototype_line,
6552                                             "prototype declaration");
6553                   break;
6554                 }
6555               /* Type for passing arg must be consistent with that
6556                  declared for the arg.  ISO C says we take the unqualified
6557                  type for parameters declared with qualified type.  */
6558               if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6559                                TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6560                 {
6561                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6562                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6563                     {
6564                       /* Adjust argument to match prototype.  E.g. a previous
6565                          `int foo(float);' prototype causes
6566                          `int foo(x) float x; {...}' to be treated like
6567                          `int foo(float x) {...}'.  This is particularly
6568                          useful for argument types like uid_t.  */
6569                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6570
6571                       if (PROMOTE_PROTOTYPES
6572                           && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6573                           && TYPE_PRECISION (TREE_TYPE (parm))
6574                           < TYPE_PRECISION (integer_type_node))
6575                         DECL_ARG_TYPE (parm) = integer_type_node;
6576
6577                       if (pedantic)
6578                         {
6579                           pedwarn ("promoted argument `%s' doesn't match prototype",
6580                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6581                           warning_with_file_and_line
6582                             (current_function_prototype_file,
6583                              current_function_prototype_line,
6584                              "prototype declaration");
6585                         }
6586                     }
6587                   else
6588                     {
6589                       error ("argument `%s' doesn't match prototype",
6590                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6591                       error_with_file_and_line (current_function_prototype_file,
6592                                                 current_function_prototype_line,
6593                                                 "prototype declaration");
6594                     }
6595                 }
6596             }
6597           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6598         }
6599
6600       /* Otherwise, create a prototype that would match.  */
6601
6602       else
6603         {
6604           tree actual = 0, last = 0, type;
6605
6606           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6607             {
6608               type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6609               if (last)
6610                 TREE_CHAIN (last) = type;
6611               else
6612                 actual = type;
6613               last = type;
6614             }
6615           type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6616           if (last)
6617             TREE_CHAIN (last) = type;
6618           else
6619             actual = type;
6620
6621           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6622              of the type of this function, but we need to avoid having this
6623              affect the types of other similarly-typed functions, so we must
6624              first force the generation of an identical (but separate) type
6625              node for the relevant function type.  The new node we create
6626              will be a variant of the main variant of the original function
6627              type.  */
6628
6629           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6630
6631           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6632         }
6633
6634       /* Now store the final chain of decls for the arguments
6635          as the decl-chain of the current lexical scope.
6636          Put the enumerators in as well, at the front so that
6637          DECL_ARGUMENTS is not modified.  */
6638
6639       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6640     }
6641
6642   /* Make sure the binding level for the top of the function body
6643      gets a BLOCK if there are any in the function.
6644      Otherwise, the dbx output is wrong.  */
6645
6646   keep_next_if_subblocks = 1;
6647
6648   /* ??? This might be an improvement,
6649      but needs to be thought about some more.  */
6650 #if 0
6651   keep_next_level_flag = 1;
6652 #endif
6653
6654   /* Write a record describing this function definition to the prototypes
6655      file (if requested).  */
6656
6657   gen_aux_info_record (fndecl, 1, 0, prototype);
6658
6659   /* Initialize the RTL code for the function.  */
6660   init_function_start (fndecl, input_filename, lineno);
6661
6662   /* Begin the statement tree for this function.  */
6663   begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6664
6665   /* If this is a nested function, save away the sizes of any
6666      variable-size types so that we can expand them when generating
6667      RTL.  */
6668   if (context)
6669     {
6670       tree t;
6671
6672       DECL_LANG_SPECIFIC (fndecl)->pending_sizes
6673         = nreverse (get_pending_sizes ());
6674       for (t = DECL_LANG_SPECIFIC (fndecl)->pending_sizes;
6675            t;
6676            t = TREE_CHAIN (t))
6677         SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = context;
6678     }
6679
6680   /* This function is being processed in whole-function mode.  */
6681   cfun->x_whole_function_mode_p = 1;
6682
6683   /* Even though we're inside a function body, we still don't want to
6684      call expand_expr to calculate the size of a variable-sized array.
6685      We haven't necessarily assigned RTL to all variables yet, so it's
6686      not safe to try to expand expressions involving them.  */
6687   immediate_size_expand = 0;
6688   cfun->x_dont_save_pending_sizes_p = 1;
6689
6690   warn_shadow = saved_warn_shadow;
6691 }
6692 \f
6693 /* Finish up a function declaration and compile that function
6694    all the way to assembler language output.  The free the storage
6695    for the function definition.
6696
6697    This is called after parsing the body of the function definition.
6698
6699    NESTED is nonzero if the function being finished is nested in another.
6700    CAN_DEFER_P is nonzero if the function may be deferred.  */
6701
6702 void
6703 finish_function (nested, can_defer_p)
6704      int nested;
6705      int can_defer_p;
6706 {
6707   tree fndecl = current_function_decl;
6708
6709 #if 0
6710   /* This caused &foo to be of type ptr-to-const-function which then
6711      got a warning when stored in a ptr-to-function variable.  */
6712   TREE_READONLY (fndecl) = 1;
6713 #endif
6714
6715   poplevel (1, 0, 1);
6716   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6717
6718   /* Must mark the RESULT_DECL as being in this function.  */
6719
6720   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6721
6722   if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6723     {
6724       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6725           != integer_type_node)
6726         {
6727           /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6728              If warn_main is -1 (-Wno-main) we don't want to be warned.  */
6729           if (! warn_main)
6730             pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6731         }
6732       else
6733         {
6734 #ifdef DEFAULT_MAIN_RETURN
6735           /* Make it so that `main' always returns success by default.  */
6736           DEFAULT_MAIN_RETURN;
6737 #else
6738           if (flag_isoc99)
6739             c_expand_return (integer_zero_node);
6740 #endif
6741         }
6742     }
6743
6744   finish_fname_decls ();
6745
6746   /* Tie off the statement tree for this function.  */
6747   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6748
6749   /* Complain if there's just no return statement.  */
6750   if (warn_return_type
6751       && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6752       && !current_function_returns_value && !current_function_returns_null
6753       /* Don't complain if we abort.  */
6754       && !current_function_returns_abnormally
6755       /* Don't warn for main().  */
6756       && !MAIN_NAME_P (DECL_NAME (fndecl))
6757       /* Or if they didn't actually specify a return type.  */
6758       && !C_FUNCTION_IMPLICIT_INT (fndecl)
6759       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
6760          inline function, as we might never be compiled separately.  */
6761       && DECL_INLINE (fndecl))
6762     warning ("no return statement in function returning non-void");
6763
6764   /* Clear out memory we no longer need.  */
6765   free_after_parsing (cfun);
6766   /* Since we never call rest_of_compilation, we never clear
6767      CFUN.  Do so explicitly.  */
6768   free_after_compilation (cfun);
6769   cfun = NULL;
6770
6771   if (! nested)
6772     {
6773       /* Generate RTL for the body of this function.  */
6774       c_expand_body (fndecl, nested, can_defer_p);
6775
6776       /* Let the error reporting routines know that we're outside a
6777          function.  For a nested function, this value is used in
6778          c_pop_function_context and then reset via pop_function_context.  */
6779       current_function_decl = NULL;
6780     }
6781 }
6782
6783 /* Generate the RTL for a deferred function FNDECL.  */
6784
6785 void
6786 c_expand_deferred_function (fndecl)
6787      tree fndecl;
6788 {
6789   /* DECL_INLINE or DECL_RESULT might got cleared after the inline
6790      function was deferred, e.g. in duplicate_decls.  */
6791   if (DECL_INLINE (fndecl) && DECL_RESULT (fndecl))
6792     {
6793       c_expand_body (fndecl, 0, 0);
6794       current_function_decl = NULL;
6795     }
6796 }
6797
6798 /* Generate the RTL for the body of FNDECL.  If NESTED_P is non-zero,
6799    then we are already in the process of generating RTL for another
6800    function.  If can_defer_p is zero, we won't attempt to defer the
6801    generation of RTL.  */
6802
6803 static void
6804 c_expand_body (fndecl, nested_p, can_defer_p)
6805      tree fndecl;
6806      int nested_p, can_defer_p;
6807 {
6808   int uninlinable = 1;
6809
6810   /* There's no reason to do any of the work here if we're only doing
6811      semantic analysis; this code just generates RTL.  */
6812   if (flag_syntax_only)
6813     return;
6814
6815   if (flag_inline_trees)
6816     {
6817       /* First, cache whether the current function is inlinable.  Some
6818          predicates depend on cfun and current_function_decl to
6819          function completely.  */
6820       timevar_push (TV_INTEGRATION);
6821       uninlinable = ! tree_inlinable_function_p (fndecl);
6822
6823       if (! uninlinable && can_defer_p
6824           /* Save function tree for inlining.  Should return 0 if the
6825              language does not support function deferring or the
6826              function could not be deferred.  */
6827           && defer_fn (fndecl))
6828         {
6829           /* Let the back-end know that this function exists.  */
6830           (*debug_hooks->deferred_inline_function) (fndecl);
6831           timevar_pop (TV_INTEGRATION);
6832           return;
6833         }
6834
6835       /* Then, inline any functions called in it.  */
6836       optimize_inline_calls (fndecl);
6837       timevar_pop (TV_INTEGRATION);
6838     }
6839
6840   timevar_push (TV_EXPAND);
6841
6842   if (nested_p)
6843     {
6844       /* Make sure that we will evaluate variable-sized types involved
6845          in our function's type.  */
6846       expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl)->pending_sizes);
6847       /* Squirrel away our current state.  */
6848       push_function_context ();
6849     }
6850
6851   /* Initialize the RTL code for the function.  */
6852   current_function_decl = fndecl;
6853   input_filename = DECL_SOURCE_FILE (fndecl);
6854   init_function_start (fndecl, input_filename, DECL_SOURCE_LINE (fndecl));
6855
6856   /* This function is being processed in whole-function mode.  */
6857   cfun->x_whole_function_mode_p = 1;
6858
6859   /* Even though we're inside a function body, we still don't want to
6860      call expand_expr to calculate the size of a variable-sized array.
6861      We haven't necessarily assigned RTL to all variables yet, so it's
6862      not safe to try to expand expressions involving them.  */
6863   immediate_size_expand = 0;
6864   cfun->x_dont_save_pending_sizes_p = 1;
6865
6866   /* If this is a varargs function, inform function.c.  */
6867   if (c_function_varargs)
6868     mark_varargs ();
6869
6870   /* Set up parameters and prepare for return, for the function.  */
6871   expand_function_start (fndecl, 0);
6872
6873   /* If this function is `main', emit a call to `__main'
6874      to run global initializers, etc.  */
6875   if (DECL_NAME (fndecl)
6876       && MAIN_NAME_P (DECL_NAME (fndecl))
6877       && DECL_CONTEXT (fndecl) == NULL_TREE)
6878     expand_main_function ();
6879
6880   /* Generate the RTL for this function.  */
6881   expand_stmt (DECL_SAVED_TREE (fndecl));
6882   if (uninlinable)
6883     {
6884       /* Allow the body of the function to be garbage collected.  */
6885       DECL_SAVED_TREE (fndecl) = NULL_TREE;
6886     }
6887
6888   /* We hard-wired immediate_size_expand to zero above.
6889      expand_function_end will decrement this variable.  So, we set the
6890      variable to one here, so that after the decrement it will remain
6891      zero.  */
6892   immediate_size_expand = 1;
6893
6894   /* Allow language dialects to perform special processing.  */
6895   if (lang_expand_function_end)
6896     (*lang_expand_function_end) ();
6897
6898   /* Generate rtl for function exit.  */
6899   expand_function_end (input_filename, lineno, 0);
6900
6901   /* If this is a nested function, protect the local variables in the stack
6902      above us from being collected while we're compiling this function.  */
6903   if (nested_p)
6904     ggc_push_context ();
6905
6906   /* Run the optimizers and output the assembler code for this function.  */
6907   rest_of_compilation (fndecl);
6908
6909   /* Undo the GC context switch.  */
6910   if (nested_p)
6911     ggc_pop_context ();
6912
6913   /* With just -W, complain only if function returns both with
6914      and without a value.  */
6915   if (extra_warnings
6916       && current_function_returns_value
6917       && current_function_returns_null)
6918     warning ("this function may return with or without a value");
6919
6920   /* If requested, warn about function definitions where the function will
6921      return a value (usually of some struct or union type) which itself will
6922      take up a lot of stack space.  */
6923
6924   if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6925     {
6926       tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6927
6928       if (ret_type && TYPE_SIZE_UNIT (ret_type)
6929           && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
6930           && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
6931                                    larger_than_size))
6932         {
6933           unsigned int size_as_int
6934             = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
6935
6936           if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
6937             warning_with_decl (fndecl,
6938                                "size of return value of `%s' is %u bytes",
6939                                size_as_int);
6940           else
6941             warning_with_decl (fndecl,
6942                                "size of return value of `%s' is larger than %d bytes",
6943                                larger_than_size);
6944         }
6945     }
6946
6947   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p
6948       && ! flag_inline_trees)
6949     {
6950       /* Stop pointing to the local nodes about to be freed.
6951          But DECL_INITIAL must remain nonzero so we know this
6952          was an actual function definition.
6953          For a nested function, this is done in c_pop_function_context.
6954          If rest_of_compilation set this to 0, leave it 0.  */
6955       if (DECL_INITIAL (fndecl) != 0)
6956         DECL_INITIAL (fndecl) = error_mark_node;
6957
6958       DECL_ARGUMENTS (fndecl) = 0;
6959     }
6960
6961   if (DECL_STATIC_CONSTRUCTOR (fndecl))
6962     {
6963       if (targetm.have_ctors_dtors)
6964         (* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
6965                                          DEFAULT_INIT_PRIORITY);
6966       else
6967         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6968     }
6969
6970   if (DECL_STATIC_DESTRUCTOR (fndecl))
6971     {
6972       if (targetm.have_ctors_dtors)
6973         (* targetm.asm_out.destructor) (XEXP (DECL_RTL (fndecl), 0),
6974                                         DEFAULT_INIT_PRIORITY);
6975       else
6976         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6977     }
6978
6979   if (nested_p)
6980     /* Return to the enclosing function.  */
6981     pop_function_context ();
6982   timevar_pop (TV_EXPAND);
6983 }
6984 \f
6985 /* Check the declarations given in a for-loop for satisfying the C99
6986    constraints.  */
6987 void
6988 check_for_loop_decls ()
6989 {
6990   tree t;
6991
6992   if (!flag_isoc99)
6993     {
6994       /* If we get here, declarations have been used in a for loop without
6995          the C99 for loop scope.  This doesn't make much sense, so don't
6996          allow it.  */
6997       error ("`for' loop initial declaration used outside C99 mode");
6998       return;
6999     }
7000   /* C99 subclause 6.8.5 paragraph 3:
7001
7002        [#3]  The  declaration  part  of  a for statement shall only
7003        declare identifiers for objects having storage class auto or
7004        register.
7005
7006      It isn't clear whether, in this sentence, "identifiers" binds to
7007      "shall only declare" or to "objects" - that is, whether all identifiers
7008      declared must be identifiers for objects, or whether the restriction
7009      only applies to those that are.  (A question on this in comp.std.c
7010      in November 2000 received no answer.)  We implement the strictest
7011      interpretation, to avoid creating an extension which later causes
7012      problems.  */
7013
7014   for (t = gettags (); t; t = TREE_CHAIN (t))
7015     {
7016       if (TREE_PURPOSE (t) != 0)
7017         {
7018           enum tree_code code = TREE_CODE (TREE_VALUE (t));
7019
7020           if (code == RECORD_TYPE)
7021             error ("`struct %s' declared in `for' loop initial declaration",
7022                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
7023           else if (code == UNION_TYPE)
7024             error ("`union %s' declared in `for' loop initial declaration",
7025                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
7026           else
7027             error ("`enum %s' declared in `for' loop initial declaration",
7028                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
7029         }
7030     }
7031
7032   for (t = getdecls (); t; t = TREE_CHAIN (t))
7033     {
7034       if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
7035         error_with_decl (t, "declaration of non-variable `%s' in `for' loop initial declaration");
7036       else if (TREE_STATIC (t))
7037         error_with_decl (t, "declaration of static variable `%s' in `for' loop initial declaration");
7038       else if (DECL_EXTERNAL (t))
7039         error_with_decl (t, "declaration of `extern' variable `%s' in `for' loop initial declaration");
7040     }
7041 }
7042 \f
7043 /* Save and restore the variables in this file and elsewhere
7044    that keep track of the progress of compilation of the current function.
7045    Used for nested functions.  */
7046
7047 struct language_function GTY(())
7048 {
7049   struct c_language_function base;
7050   tree named_labels;
7051   tree shadowed_labels;
7052   int returns_value;
7053   int returns_null;
7054   int returns_abnormally;
7055   int warn_about_return_type;
7056   int extern_inline;
7057   struct binding_level *binding_level;
7058 };
7059
7060 /* Save and reinitialize the variables
7061    used during compilation of a C function.  */
7062
7063 void
7064 c_push_function_context (f)
7065      struct function *f;
7066 {
7067   struct language_function *p;
7068   p = ((struct language_function *)
7069        ggc_alloc (sizeof (struct language_function)));
7070   f->language = p;
7071
7072   p->base.x_stmt_tree = c_stmt_tree;
7073   p->base.x_scope_stmt_stack = c_scope_stmt_stack;
7074   p->named_labels = named_labels;
7075   p->shadowed_labels = shadowed_labels;
7076   p->returns_value = current_function_returns_value;
7077   p->returns_null = current_function_returns_null;
7078   p->returns_abnormally = current_function_returns_abnormally;
7079   p->warn_about_return_type = warn_about_return_type;
7080   p->extern_inline = current_extern_inline;
7081   p->binding_level = current_binding_level;
7082 }
7083
7084 /* Restore the variables used during compilation of a C function.  */
7085
7086 void
7087 c_pop_function_context (f)
7088      struct function *f;
7089 {
7090   struct language_function *p = f->language;
7091   tree link;
7092
7093   /* Bring back all the labels that were shadowed.  */
7094   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
7095     if (DECL_NAME (TREE_VALUE (link)) != 0)
7096       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
7097         = TREE_VALUE (link);
7098
7099   if (DECL_SAVED_INSNS (current_function_decl) == 0
7100       && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
7101     {
7102       /* Stop pointing to the local nodes about to be freed.  */
7103       /* But DECL_INITIAL must remain nonzero so we know this
7104          was an actual function definition.  */
7105       DECL_INITIAL (current_function_decl) = error_mark_node;
7106       DECL_ARGUMENTS (current_function_decl) = 0;
7107     }
7108
7109   c_stmt_tree = p->base.x_stmt_tree;
7110   c_scope_stmt_stack = p->base.x_scope_stmt_stack;
7111   named_labels = p->named_labels;
7112   shadowed_labels = p->shadowed_labels;
7113   current_function_returns_value = p->returns_value;
7114   current_function_returns_null = p->returns_null;
7115   current_function_returns_abnormally = p->returns_abnormally;
7116   warn_about_return_type = p->warn_about_return_type;
7117   current_extern_inline = p->extern_inline;
7118   current_binding_level = p->binding_level;
7119
7120   f->language = NULL;
7121 }
7122
7123 /* Copy the DECL_LANG_SPECIFIC data associated with DECL.  */
7124
7125 void
7126 c_dup_lang_specific_decl (decl)
7127      tree decl;
7128 {
7129   struct lang_decl *ld;
7130
7131   if (!DECL_LANG_SPECIFIC (decl))
7132     return;
7133
7134   ld = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl));
7135   memcpy ((char *) ld, (char *) DECL_LANG_SPECIFIC (decl),
7136           sizeof (struct lang_decl));
7137   DECL_LANG_SPECIFIC (decl) = ld;
7138 }
7139
7140 /* The functions below are required for functionality of doing
7141    function at once processing in the C front end. Currently these
7142    functions are not called from anywhere in the C front end, but as
7143    these changes continue, that will change.  */
7144
7145 /* Returns non-zero if the current statement is a full expression,
7146    i.e. temporaries created during that statement should be destroyed
7147    at the end of the statement.  */
7148
7149 int
7150 stmts_are_full_exprs_p ()
7151 {
7152   return 0;
7153 }
7154
7155 /* Returns the stmt_tree (if any) to which statements are currently
7156    being added.  If there is no active statement-tree, NULL is
7157    returned.  */
7158
7159 stmt_tree
7160 current_stmt_tree ()
7161 {
7162   return &c_stmt_tree;
7163 }
7164
7165 /* Returns the stack of SCOPE_STMTs for the current function.  */
7166
7167 tree *
7168 current_scope_stmt_stack ()
7169 {
7170   return &c_scope_stmt_stack;
7171 }
7172
7173 /* Nonzero if TYPE is an anonymous union or struct type.  Always 0 in
7174    C.  */
7175
7176 int
7177 anon_aggr_type_p (node)
7178      tree node ATTRIBUTE_UNUSED;
7179 {
7180   return 0;
7181 }
7182
7183 /* Dummy function in place of callback used by C++.  */
7184
7185 void
7186 extract_interface_info ()
7187 {
7188 }
7189
7190 /* Return a new COMPOUND_STMT, after adding it to the current
7191    statement tree.  */
7192
7193 tree
7194 c_begin_compound_stmt ()
7195 {
7196   tree stmt;
7197
7198   /* Create the COMPOUND_STMT.  */
7199   stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
7200
7201   return stmt;
7202 }
7203
7204 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
7205    common code.  */
7206
7207 void
7208 c_expand_decl_stmt (t)
7209      tree t;
7210 {
7211   tree decl = DECL_STMT_DECL (t);
7212
7213   /* Expand nested functions.  */
7214   if (TREE_CODE (decl) == FUNCTION_DECL
7215       && DECL_CONTEXT (decl) == current_function_decl
7216       && DECL_SAVED_TREE (decl))
7217     c_expand_body (decl, /*nested_p=*/1, /*can_defer_p=*/0);
7218 }
7219
7220 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
7221    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
7222
7223 tree
7224 identifier_global_value (t)
7225      tree t;
7226 {
7227   return IDENTIFIER_GLOBAL_VALUE (t);
7228 }
7229
7230 /* Record a builtin type for C.  If NAME is non-NULL, it is the name used;
7231    otherwise the name is found in ridpointers from RID_INDEX.  */
7232
7233 void
7234 record_builtin_type (rid_index, name, type)
7235      enum rid rid_index;
7236      const char *name;
7237      tree type;
7238 {
7239   tree id;
7240   if (name == 0)
7241     id = ridpointers[(int) rid_index];
7242   else
7243     id = get_identifier (name);
7244   pushdecl (build_decl (TYPE_DECL, id, type));
7245 }
7246
7247 /* Build the void_list_node (void_type_node having been created).  */
7248 tree
7249 build_void_list_node ()
7250 {
7251   tree t = build_tree_list (NULL_TREE, void_type_node);
7252   return t;
7253 }
7254
7255 /* Return something to represent absolute declarators containing a *.
7256    TARGET is the absolute declarator that the * contains.
7257    TYPE_QUALS_ATTRS is a list of modifiers such as const or volatile
7258    to apply to the pointer type, represented as identifiers, possible mixed
7259    with attributes.
7260
7261    We return an INDIRECT_REF whose "contents" are TARGET (inside a TREE_LIST,
7262    if attributes are present) and whose type is the modifier list.  */
7263
7264 tree
7265 make_pointer_declarator (type_quals_attrs, target)
7266      tree type_quals_attrs, target;
7267 {
7268   tree quals, attrs;
7269   tree itarget = target;
7270   split_specs_attrs (type_quals_attrs, &quals, &attrs);
7271   if (attrs != NULL_TREE)
7272     itarget = tree_cons (attrs, target, NULL_TREE);
7273   return build1 (INDIRECT_REF, quals, itarget);
7274 }
7275
7276 #include "gt-c-decl.h"