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