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