gcc/c-decl.c

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