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