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