gcc/c-decl.c

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