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 treat bitfields as signed unless they say `unsigned'.  */
 441
 442 int flag_signed_bitfields = 1;
 443 int explicit_flag_signed_bitfields = 0;
 444
 445 /* Nonzero means handle `#ident' directives.  0 means ignore them.  */
 446
 447 int flag_no_ident = 0;
 448
 449 /* Nonzero means warn about implicit declarations.  */
 450
 451 int warn_implicit;
 452
 453 /* Nonzero means give string constants the type `const char *'
 454    to get extra warnings from them.  These warnings will be too numerous
 455    to be useful, except in thoroughly ANSIfied programs.  */
 456
 457 int warn_write_strings;
 458
 459 /* Nonzero means warn about pointer casts that can drop a type qualifier
 460    from the pointer target type.  */
 461
 462 int warn_cast_qual;
 463
 464 /* Warn about traditional constructs whose meanings changed in ANSI C.  */
 465
 466 int warn_traditional;
 467
 468 /* Nonzero means warn about sizeof(function) or addition/subtraction
 469    of function pointers.  */
 470
 471 int warn_pointer_arith;
 472
 473 /* Nonzero means warn for non-prototype function decls
 474    or non-prototyped defs without previous prototype.  */
 475
 476 int warn_strict_prototypes;
 477
 478 /* Nonzero means warn for any global function def
 479    without separate previous prototype decl.  */
 480
 481 int warn_missing_prototypes;
 482
 483 /* Nonzero means warn about multiple (redundant) decls for the same single
 484    variable or function.  */
 485
 486 int warn_redundant_decls = 0;
 487
 488 /* Nonzero means warn about extern declarations of objects not at
 489    file-scope level and about *all* declarations of functions (whether
 490    extern or static) not at file-scope level.  Note that we exclude
 491    implicit function declarations.  To get warnings about those, use
 492    -Wimplicit.  */
 493
 494 int warn_nested_externs = 0;
 495
 496 /* Warn about *printf or *scanf format/argument anomalies. */
 497
 498 int warn_format;
 499
 500 /* Warn about a subscript that has type char.  */
 501
 502 int warn_char_subscripts = 0;
 503
 504 /* Warn if a type conversion is done that might have confusing results.  */
 505
 506 int warn_conversion;
 507
 508 /* Warn if adding () is suggested.  */
 509
 510 int warn_parentheses;
 511
 512 /* Warn if initializer is not completely bracketed.  */
 513
 514 int warn_missing_braces;
 515
 516 /* Nonzero means `$' can be in an identifier.
 517    See cccp.c for reasons why this breaks some obscure ANSI C programs.  */
 518
 519 #ifndef DOLLARS_IN_IDENTIFIERS
 520 #define DOLLARS_IN_IDENTIFIERS 1
 521 #endif
 522 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1;
 523
 524 /* Decode the string P as a language-specific option for C.
 525    Return 1 if it is recognized (and handle it);
 526    return 0 if not recognized.  */
 527
 528 int
 529 c_decode_option (p)
 530      char *p;
 531 {
 532   if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
 533     {
 534       flag_traditional = 1;
 535       flag_writable_strings = 1;
 536 #if DOLLARS_IN_IDENTIFIERS > 0
 537       dollars_in_ident = 1;
 538 #endif
 539     }
 540   else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional"))
 541     {
 542       flag_traditional = 0;
 543       flag_writable_strings = 0;
 544       dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1;
 545     }
 546   else if (!strcmp (p, "-fdollars-in-identifiers"))
 547     {
 548 #if DOLLARS_IN_IDENTIFIERS > 0
 549       dollars_in_ident = 1;
 550 #endif
 551     }
 552   else if (!strcmp (p, "-fnodollars-in-identifiers"))
 553     dollars_in_ident = 0;
 554   else if (!strcmp (p, "-fsigned-char"))
 555     flag_signed_char = 1;
 556   else if (!strcmp (p, "-funsigned-char"))
 557     flag_signed_char = 0;
 558   else if (!strcmp (p, "-fno-signed-char"))
 559     flag_signed_char = 0;
 560   else if (!strcmp (p, "-fno-unsigned-char"))
 561     flag_signed_char = 1;
 562   else if (!strcmp (p, "-fsigned-bitfields")
 563            || !strcmp (p, "-fno-unsigned-bitfields"))
 564     {
 565       flag_signed_bitfields = 1;
 566       explicit_flag_signed_bitfields = 1;
 567     }
 568   else if (!strcmp (p, "-funsigned-bitfields")
 569            || !strcmp (p, "-fno-signed-bitfields"))
 570     {
 571       flag_signed_bitfields = 0;
 572       explicit_flag_signed_bitfields = 1;
 573     }
 574   else if (!strcmp (p, "-fshort-enums"))
 575     flag_short_enums = 1;
 576   else if (!strcmp (p, "-fno-short-enums"))
 577     flag_short_enums = 0;
 578   else if (!strcmp (p, "-fcond-mismatch"))
 579     flag_cond_mismatch = 1;
 580   else if (!strcmp (p, "-fno-cond-mismatch"))
 581     flag_cond_mismatch = 0;
 582   else if (!strcmp (p, "-fshort-double"))
 583     flag_short_double = 1;
 584   else if (!strcmp (p, "-fno-short-double"))
 585     flag_short_double = 0;
 586   else if (!strcmp (p, "-fasm"))
 587     flag_no_asm = 0;
 588   else if (!strcmp (p, "-fno-asm"))
 589     flag_no_asm = 1;
 590   else if (!strcmp (p, "-fbuiltin"))
 591     flag_no_builtin = 0;
 592   else if (!strcmp (p, "-fno-builtin"))
 593     flag_no_builtin = 1;
 594   else if (!strcmp (p, "-fno-ident"))
 595     flag_no_ident = 1;
 596   else if (!strcmp (p, "-fident"))
 597     flag_no_ident = 0;
 598   else if (!strcmp (p, "-ansi"))
 599     flag_no_asm = 1, flag_no_nonansi_builtin = 1, dollars_in_ident = 0;
 600   else if (!strcmp (p, "-Wimplicit"))
 601     warn_implicit = 1;
 602   else if (!strcmp (p, "-Wno-implicit"))
 603     warn_implicit = 0;
 604   else if (!strcmp (p, "-Wwrite-strings"))
 605     warn_write_strings = 1;
 606   else if (!strcmp (p, "-Wno-write-strings"))
 607     warn_write_strings = 0;
 608   else if (!strcmp (p, "-Wcast-qual"))
 609     warn_cast_qual = 1;
 610   else if (!strcmp (p, "-Wno-cast-qual"))
 611     warn_cast_qual = 0;
 612   else if (!strcmp (p, "-Wpointer-arith"))
 613     warn_pointer_arith = 1;
 614   else if (!strcmp (p, "-Wno-pointer-arith"))
 615     warn_pointer_arith = 0;
 616   else if (!strcmp (p, "-Wstrict-prototypes"))
 617     warn_strict_prototypes = 1;
 618   else if (!strcmp (p, "-Wno-strict-prototypes"))
 619     warn_strict_prototypes = 0;
 620   else if (!strcmp (p, "-Wmissing-prototypes"))
 621     warn_missing_prototypes = 1;
 622   else if (!strcmp (p, "-Wno-missing-prototypes"))
 623     warn_missing_prototypes = 0;
 624   else if (!strcmp (p, "-Wredundant-decls"))
 625     warn_redundant_decls = 1;
 626   else if (!strcmp (p, "-Wno-redundant-decls"))
 627     warn_redundant_decls = 0;
 628   else if (!strcmp (p, "-Wnested-externs"))
 629     warn_nested_externs = 1;
 630   else if (!strcmp (p, "-Wno-nested-externs"))
 631     warn_nested_externs = 0;
 632   else if (!strcmp (p, "-Wtraditional"))
 633     warn_traditional = 1;
 634   else if (!strcmp (p, "-Wno-traditional"))
 635     warn_traditional = 0;
 636   else if (!strcmp (p, "-Wformat"))
 637     warn_format = 1;
 638   else if (!strcmp (p, "-Wno-format"))
 639     warn_format = 0;
 640   else if (!strcmp (p, "-Wchar-subscripts"))
 641     warn_char_subscripts = 1;
 642   else if (!strcmp (p, "-Wno-char-subscripts"))
 643     warn_char_subscripts = 0;
 644   else if (!strcmp (p, "-Wconversion"))
 645     warn_conversion = 1;
 646   else if (!strcmp (p, "-Wno-conversion"))
 647     warn_conversion = 0;
 648   else if (!strcmp (p, "-Wparentheses"))
 649     warn_parentheses = 1;
 650   else if (!strcmp (p, "-Wno-parentheses"))
 651     warn_parentheses = 0;
 652   else if (!strcmp (p, "-Wreturn-type"))
 653     warn_return_type = 1;
 654   else if (!strcmp (p, "-Wno-return-type"))
 655     warn_return_type = 0;
 656   else if (!strcmp (p, "-Wcomment"))
 657     ; /* cpp handles this one.  */
 658   else if (!strcmp (p, "-Wno-comment"))
 659     ; /* cpp handles this one.  */
 660   else if (!strcmp (p, "-Wcomments"))
 661     ; /* cpp handles this one.  */
 662   else if (!strcmp (p, "-Wno-comments"))
 663     ; /* cpp handles this one.  */
 664   else if (!strcmp (p, "-Wtrigraphs"))
 665     ; /* cpp handles this one.  */
 666   else if (!strcmp (p, "-Wno-trigraphs"))
 667     ; /* cpp handles this one.  */
 668   else if (!strcmp (p, "-Wimport"))
 669     ; /* cpp handles this one.  */
 670   else if (!strcmp (p, "-Wno-import"))
 671     ; /* cpp handles this one.  */
 672   else if (!strcmp (p, "-Wmissing-braces"))
 673     warn_missing_braces = 1;
 674   else if (!strcmp (p, "-Wno-missing-braces"))
 675     warn_missing_braces = 0;
 676   else if (!strcmp (p, "-Wall"))
 677     {
 678       extra_warnings = 1;
 679       /* We save the value of warn_uninitialized, since if they put
 680          -Wuninitialized on the command line, we need to generate a
 681          warning about not using it without also specifying -O.  */
 682       if (warn_uninitialized != 1)
 683         warn_uninitialized = 2;
 684       warn_implicit = 1;
 685       warn_return_type = 1;
 686       warn_unused = 1;
 687       warn_switch = 1;
 688       warn_format = 1;
 689       warn_char_subscripts = 1;
 690       warn_parentheses = 1;
 691       warn_missing_braces = 1;
 692     }
 693   else
 694     return 0;
 695
 696   return 1;
 697 }
 698
 699 /* Hooks for print_node.  */
 700
 701 void
 702 print_lang_decl (file, node, indent)
 703      FILE *file;
 704      tree node;
 705      int indent;
 706 {
 707 }
 708
 709 void
 710 print_lang_type (file, node, indent)
 711      FILE *file;
 712      tree node;
 713      int indent;
 714 {
 715 }
 716
 717 void
 718 print_lang_identifier (file, node, indent)
 719      FILE *file;
 720      tree node;
 721      int indent;
 722 {
 723   print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
 724   print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
 725   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
 726   print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
 727   print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
 728   print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
 729 }
 730 \f
 731 /* Hook called at end of compilation to assume 1 elt
 732    for a top-level array decl that wasn't complete before.  */
 733
 734 void
 735 finish_incomplete_decl (decl)
 736      tree decl;
 737 {
 738   if (TREE_CODE (decl) == VAR_DECL && TREE_TYPE (decl) != error_mark_node)
 739     {
 740       tree type = TREE_TYPE (decl);
 741       if (TREE_CODE (type) == ARRAY_TYPE
 742           && TYPE_DOMAIN (type) == 0
 743           && TREE_CODE (decl) != TYPE_DECL)
 744         {
 745           complete_array_type (type, NULL_TREE, 1);
 746
 747           layout_decl (decl, 0);
 748         }
 749     }
 750 }
 751 \f
 752 /* Create a new `struct binding_level'.  */
 753
 754 static
 755 struct binding_level *
 756 make_binding_level ()
 757 {
 758   /* NOSTRICT */
 759   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 760 }
 761
 762 /* Nonzero if we are currently in the global binding level.  */
 763
 764 int
 765 global_bindings_p ()
 766 {
 767   return current_binding_level == global_binding_level;
 768 }
 769
 770 void
 771 keep_next_level ()
 772 {
 773   keep_next_level_flag = 1;
 774 }
 775
 776 /* Nonzero if the current level needs to have a BLOCK made.  */
 777
 778 int
 779 kept_level_p ()
 780 {
 781   return ((current_binding_level->keep_if_subblocks
 782            && current_binding_level->blocks != 0)
 783           || current_binding_level->keep
 784           || current_binding_level->names != 0
 785           || (current_binding_level->tags != 0
 786               && !current_binding_level->tag_transparent));
 787 }
 788
 789 /* Identify this binding level as a level of parameters.
 790    DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
 791    But it turns out there is no way to pass the right value for
 792    DEFINITION_FLAG, so we ignore it.  */
 793
 794 void
 795 declare_parm_level (definition_flag)
 796      int definition_flag;
 797 {
 798   current_binding_level->parm_flag = 1;
 799 }
 800
 801 /* Nonzero if currently making parm declarations.  */
 802
 803 int
 804 in_parm_level_p ()
 805 {
 806   return current_binding_level->parm_flag;
 807 }
 808
 809 /* Enter a new binding level.
 810    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 811    not for that of tags.  */
 812
 813 void
 814 pushlevel (tag_transparent)
 815      int tag_transparent;
 816 {
 817   register struct binding_level *newlevel = NULL_BINDING_LEVEL;
 818
 819   /* If this is the top level of a function,
 820      just make sure that NAMED_LABELS is 0.  */
 821
 822   if (current_binding_level == global_binding_level)
 823     {
 824       named_labels = 0;
 825     }
 826
 827   /* Reuse or create a struct for this binding level.  */
 828
 829   if (free_binding_level)
 830     {
 831       newlevel = free_binding_level;
 832       free_binding_level = free_binding_level->level_chain;
 833     }
 834   else
 835     {
 836       newlevel = make_binding_level ();
 837     }
 838
 839   /* Add this level to the front of the chain (stack) of levels that
 840      are active.  */
 841
 842   *newlevel = clear_binding_level;
 843   newlevel->tag_transparent
 844     = (tag_transparent
 845        || (current_binding_level
 846            ? current_binding_level->subblocks_tag_transparent
 847            : 0));
 848   newlevel->level_chain = current_binding_level;
 849   current_binding_level = newlevel;
 850   newlevel->keep = keep_next_level_flag;
 851   keep_next_level_flag = 0;
 852   newlevel->keep_if_subblocks = keep_next_if_subblocks;
 853   keep_next_if_subblocks = 0;
 854 }
 855
 856 /* Exit a binding level.
 857    Pop the level off, and restore the state of the identifier-decl mappings
 858    that were in effect when this level was entered.
 859
 860    If KEEP is nonzero, this level had explicit declarations, so
 861    and create a "block" (a BLOCK node) for the level
 862    to record its declarations and subblocks for symbol table output.
 863
 864    If FUNCTIONBODY is nonzero, this level is the body of a function,
 865    so create a block as if KEEP were set and also clear out all
 866    label names.
 867
 868    If REVERSE is nonzero, reverse the order of decls before putting
 869    them into the BLOCK.  */
 870
 871 tree
 872 poplevel (keep, reverse, functionbody)
 873      int keep;
 874      int reverse;
 875      int functionbody;
 876 {
 877   register tree link;
 878   /* The chain of decls was accumulated in reverse order.
 879      Put it into forward order, just for cleanliness.  */
 880   tree decls;
 881   tree tags = current_binding_level->tags;
 882   tree subblocks = current_binding_level->blocks;
 883   tree block = 0;
 884   tree decl;
 885   int block_previously_created;
 886
 887   keep |= current_binding_level->keep;
 888
 889   /* This warning is turned off because it causes warnings for
 890      declarations like `extern struct foo *x'.  */
 891 #if 0
 892   /* Warn about incomplete structure types in this level.  */
 893   for (link = tags; link; link = TREE_CHAIN (link))
 894     if (TYPE_SIZE (TREE_VALUE (link)) == 0)
 895       {
 896         tree type = TREE_VALUE (link);
 897         char *errmsg;
 898         switch (TREE_CODE (type))
 899           {
 900           case RECORD_TYPE:
 901             errmsg = "`struct %s' incomplete in scope ending here";
 902             break;
 903           case UNION_TYPE:
 904             errmsg = "`union %s' incomplete in scope ending here";
 905             break;
 906           case ENUMERAL_TYPE:
 907             errmsg = "`enum %s' incomplete in scope ending here";
 908             break;
 909           }
 910         if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 911           error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
 912         else
 913           /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
 914           error (errmsg, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
 915       }
 916 #endif /* 0 */
 917
 918   /* Get the decls in the order they were written.
 919      Usually current_binding_level->names is in reverse order.
 920      But parameter decls were previously put in forward order.  */
 921
 922   if (reverse)
 923     current_binding_level->names
 924       = decls = nreverse (current_binding_level->names);
 925   else
 926     decls = current_binding_level->names;
 927
 928   /* Output any nested inline functions within this block
 929      if they weren't already output.  */
 930
 931   for (decl = decls; decl; decl = TREE_CHAIN (decl))
 932     if (TREE_CODE (decl) == FUNCTION_DECL
 933         && ! TREE_ASM_WRITTEN (decl)
 934         && DECL_INITIAL (decl) != 0
 935         && TREE_ADDRESSABLE (decl))
 936       {
 937         /* If this decl was copied from a file-scope decl
 938            on account of a block-scope extern decl,
 939            propagate TREE_ADDRESSABLE to the file-scope decl.  */
 940         if (DECL_ABSTRACT_ORIGIN (decl) != 0)
 941           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
 942         else
 943           {
 944             push_function_context ();
 945             output_inline_function (decl);
 946             pop_function_context ();
 947           }
 948       }
 949
 950   /* If there were any declarations or structure tags in that level,
 951      or if this level is a function body,
 952      create a BLOCK to record them for the life of this function.  */
 953
 954   block = 0;
 955   block_previously_created = (current_binding_level->this_block != 0);
 956   if (block_previously_created)
 957     block = current_binding_level->this_block;
 958   else if (keep || functionbody
 959            || (current_binding_level->keep_if_subblocks && subblocks != 0))
 960     block = make_node (BLOCK);
 961   if (block != 0)
 962     {
 963       BLOCK_VARS (block) = decls;
 964       BLOCK_TYPE_TAGS (block) = tags;
 965       BLOCK_SUBBLOCKS (block) = subblocks;
 966       remember_end_note (block);
 967     }
 968
 969   /* In each subblock, record that this is its superior.  */
 970
 971   for (link = subblocks; link; link = TREE_CHAIN (link))
 972     BLOCK_SUPERCONTEXT (link) = block;
 973
 974   /* Clear out the meanings of the local variables of this level.  */
 975
 976   for (link = decls; link; link = TREE_CHAIN (link))
 977     {
 978       if (DECL_NAME (link) != 0)
 979         {
 980           /* If the ident. was used or addressed via a local extern decl,
 981              don't forget that fact.  */
 982           if (DECL_EXTERNAL (link))
 983             {
 984               if (TREE_USED (link))
 985                 TREE_USED (DECL_NAME (link)) = 1;
 986               if (TREE_ADDRESSABLE (link))
 987                 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
 988             }
 989           IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
 990         }
 991     }
 992
 993   /* Restore all name-meanings of the outer levels
 994      that were shadowed by this level.  */
 995
 996   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
 997     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
 998
 999   /* If the level being exited is the top level of a function,
1000      check over all the labels, and clear out the current
1001      (function local) meanings of their names.  */
1002
1003   if (functionbody)
1004     {
1005       /* If this is the top level block of a function,
1006          the vars are the function's parameters.
1007          Don't leave them in the BLOCK because they are
1008          found in the FUNCTION_DECL instead.  */
1009
1010       BLOCK_VARS (block) = 0;
1011
1012       /* Clear out the definitions of all label names,
1013          since their scopes end here,
1014          and add them to BLOCK_VARS.  */
1015
1016       for (link = named_labels; link; link = TREE_CHAIN (link))
1017         {
1018           register tree label = TREE_VALUE (link);
1019
1020           if (DECL_INITIAL (label) == 0)
1021             {
1022               error_with_decl (label, "label `%s' used but not defined");
1023               /* Avoid crashing later.  */
1024               define_label (input_filename, lineno,
1025                             DECL_NAME (label));
1026             }
1027           else if (warn_unused && !TREE_USED (label))
1028             warning_with_decl (label, "label `%s' defined but not used");
1029           IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1030
1031           /* Put the labels into the "variables" of the
1032              top-level block, so debugger can see them.  */
1033           TREE_CHAIN (label) = BLOCK_VARS (block);
1034           BLOCK_VARS (block) = label;
1035         }
1036     }
1037
1038   /* Pop the current level, and free the structure for reuse.  */
1039
1040   {
1041     register struct binding_level *level = current_binding_level;
1042     current_binding_level = current_binding_level->level_chain;
1043
1044     level->level_chain = free_binding_level;
1045     free_binding_level = level;
1046   }
1047
1048   /* Dispose of the block that we just made inside some higher level.  */
1049   if (functionbody)
1050     DECL_INITIAL (current_function_decl) = block;
1051   else if (block)
1052     {
1053       if (!block_previously_created)
1054         current_binding_level->blocks
1055           = chainon (current_binding_level->blocks, block);
1056     }
1057   /* If we did not make a block for the level just exited,
1058      any blocks made for inner levels
1059      (since they cannot be recorded as subblocks in that level)
1060      must be carried forward so they will later become subblocks
1061      of something else.  */
1062   else if (subblocks)
1063     current_binding_level->blocks
1064       = chainon (current_binding_level->blocks, subblocks);
1065
1066   /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1067      binding contour so that they point to the appropriate construct, i.e.
1068      either to the current FUNCTION_DECL node, or else to the BLOCK node
1069      we just constructed.
1070
1071      Note that for tagged types whose scope is just the formal parameter
1072      list for some function type specification, we can't properly set
1073      their TYPE_CONTEXTs here, because we don't have a pointer to the
1074      appropriate FUNCTION_TYPE node readily available to us.  For those
1075      cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1076      in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1077      node which will represent the "scope" for these "parameter list local"
1078      tagged types.
1079   */
1080
1081   if (functionbody)
1082     for (link = tags; link; link = TREE_CHAIN (link))
1083       TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
1084   else if (block)
1085     for (link = tags; link; link = TREE_CHAIN (link))
1086       TYPE_CONTEXT (TREE_VALUE (link)) = block;
1087
1088   if (block)
1089     TREE_USED (block) = 1;
1090   return block;
1091 }
1092
1093 /* Delete the node BLOCK from the current binding level.
1094    This is used for the block inside a stmt expr ({...})
1095    so that the block can be reinserted where appropriate.  */
1096
1097 void
1098 delete_block (block)
1099      tree block;
1100 {
1101   tree t;
1102   if (current_binding_level->blocks == block)
1103     current_binding_level->blocks = TREE_CHAIN (block);
1104   for (t = current_binding_level->blocks; t;)
1105     {
1106       if (TREE_CHAIN (t) == block)
1107         TREE_CHAIN (t) = TREE_CHAIN (block);
1108       else
1109         t = TREE_CHAIN (t);
1110     }
1111   TREE_CHAIN (block) = NULL;
1112   /* Clear TREE_USED which is always set by poplevel.
1113      The flag is set again if insert_block is called.  */
1114   TREE_USED (block) = 0;
1115 }
1116
1117 /* Insert BLOCK at the end of the list of subblocks of the
1118    current binding level.  This is used when a BIND_EXPR is expanded,
1119    to handle the BLOCK node inside the BIND_EXPR.  */
1120
1121 void
1122 insert_block (block)
1123      tree block;
1124 {
1125   TREE_USED (block) = 1;
1126   current_binding_level->blocks
1127     = chainon (current_binding_level->blocks, block);
1128 }
1129
1130 /* Set the BLOCK node for the innermost scope
1131    (the one we are currently in).  */
1132
1133 void
1134 set_block (block)
1135      register tree block;
1136 {
1137   current_binding_level->this_block = block;
1138 }
1139 \f
1140 void
1141 push_label_level ()
1142 {
1143   register struct binding_level *newlevel;
1144
1145   /* Reuse or create a struct for this binding level.  */
1146
1147   if (free_binding_level)
1148     {
1149       newlevel = free_binding_level;
1150       free_binding_level = free_binding_level->level_chain;
1151     }
1152   else
1153     {
1154       newlevel = make_binding_level ();
1155     }
1156
1157   /* Add this level to the front of the chain (stack) of label levels.  */
1158
1159   newlevel->level_chain = label_level_chain;
1160   label_level_chain = newlevel;
1161
1162   newlevel->names = named_labels;
1163   newlevel->shadowed = shadowed_labels;
1164   named_labels = 0;
1165   shadowed_labels = 0;
1166 }
1167
1168 void
1169 pop_label_level ()
1170 {
1171   register struct binding_level *level = label_level_chain;
1172   tree link, prev;
1173
1174   /* Clear out the definitions of the declared labels in this level.
1175      Leave in the list any ordinary, non-declared labels.  */
1176   for (link = named_labels, prev = 0; link;)
1177     {
1178       if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
1179         {
1180           if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
1181             {
1182               error_with_decl (TREE_VALUE (link),
1183                                "label `%s' used but not defined");
1184               /* Avoid crashing later.  */
1185               define_label (input_filename, lineno,
1186                             DECL_NAME (TREE_VALUE (link)));
1187             }
1188           else if (warn_unused && !TREE_USED (TREE_VALUE (link)))
1189             warning_with_decl (TREE_VALUE (link),
1190                                "label `%s' defined but not used");
1191           IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
1192
1193           /* Delete this element from the list.  */
1194           link = TREE_CHAIN (link);
1195           if (prev)
1196             TREE_CHAIN (prev) = link;
1197           else
1198             named_labels = link;
1199         }
1200       else
1201         {
1202           prev = link;
1203           link = TREE_CHAIN (link);
1204         }
1205     }
1206
1207   /* Bring back all the labels that were shadowed.  */
1208   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
1209     if (DECL_NAME (TREE_VALUE (link)) != 0)
1210       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
1211         = TREE_VALUE (link);
1212
1213   named_labels = chainon (named_labels, level->names);
1214   shadowed_labels = level->shadowed;
1215
1216   /* Pop the current level, and free the structure for reuse.  */
1217   label_level_chain = label_level_chain->level_chain;
1218   level->level_chain = free_binding_level;
1219   free_binding_level = level;
1220 }
1221 \f
1222 /* Push a definition or a declaration of struct, union or enum tag "name".
1223    "type" should be the type node.
1224    We assume that the tag "name" is not already defined.
1225
1226    Note that the definition may really be just a forward reference.
1227    In that case, the TYPE_SIZE will be zero.  */
1228
1229 void
1230 pushtag (name, type)
1231      tree name, type;
1232 {
1233   register struct binding_level *b;
1234
1235   /* Find the proper binding level for this type tag.  */
1236
1237   for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
1238     continue;
1239
1240   if (name)
1241     {
1242       /* Record the identifier as the type's name if it has none.  */
1243
1244       if (TYPE_NAME (type) == 0)
1245         TYPE_NAME (type) = name;
1246     }
1247
1248   if (b == global_binding_level)
1249     b->tags = perm_tree_cons (name, type, b->tags);
1250   else
1251     b->tags = saveable_tree_cons (name, type, b->tags);
1252
1253   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1254      tagged type we just added to the current binding level.  This fake
1255      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1256      to output a representation of a tagged type, and it also gives
1257      us a convenient place to record the "scope start" address for the
1258      tagged type.  */
1259
1260   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
1261 }
1262 \f
1263 /* Handle when a new declaration NEWDECL
1264    has the same name as an old one OLDDECL
1265    in the same binding contour.
1266    Prints an error message if appropriate.
1267
1268    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1269    Otherwise, return 0.  */
1270
1271 static int
1272 duplicate_decls (newdecl, olddecl)
1273      register tree newdecl, olddecl;
1274 {
1275   int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1276   int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1277                            && DECL_INITIAL (newdecl) != 0);
1278   tree oldtype = TREE_TYPE (olddecl);
1279   tree newtype = TREE_TYPE (newdecl);
1280
1281   if (TREE_CODE (newtype) == ERROR_MARK
1282       || TREE_CODE (oldtype) == ERROR_MARK)
1283     types_match = 0;
1284
1285   /* New decl is completely inconsistent with the old one =>
1286      tell caller to replace the old one.
1287      This is always an error except in the case of shadowing a builtin.  */
1288   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1289     {
1290       if (TREE_CODE (olddecl) == FUNCTION_DECL
1291           && DECL_BUILT_IN (olddecl))
1292         {
1293           /* If you declare a built-in function name as static, the
1294              built-in definition is overridden,
1295              but optionally warn this was a bad choice of name.  */
1296           if (!TREE_PUBLIC (newdecl))
1297             {
1298               if (warn_shadow)
1299                 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1300             }
1301           /* Likewise, if the built-in is not ansi, then programs can
1302              override it even globally without an error.  */
1303           else if (DECL_BUILT_IN_NONANSI (olddecl))
1304             warning_with_decl (newdecl,
1305                                "built-in function `%s' declared as non-function");
1306           else
1307             error_with_decl (newdecl,
1308                              "built-in function `%s' declared as non-function");
1309         }
1310       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1311                && DECL_BUILT_IN_NONANSI (olddecl))
1312         {
1313           /* If overriding decl is static,
1314              optionally warn this was a bad choice of name.  */
1315           if (!TREE_PUBLIC (newdecl))
1316             {
1317               if (warn_shadow)
1318                 warning_with_decl (newdecl, "shadowing library function `%s'");
1319             }
1320           /* Otherwise, always warn.  */
1321           else
1322             warning_with_decl (newdecl,
1323                                "library 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 = type_for_size (wchar_type_size, 0);
2752   unsigned_wchar_type_node = type_for_size (wchar_type_size, 1);
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   init_format_info_table ();
3062
3063   init_iterators ();
3064
3065   incomplete_decl_finalize_hook = finish_incomplete_decl;
3066 }
3067
3068 /* Return a definition for a builtin function named NAME and whose data type
3069    is TYPE.  TYPE should be a function type with argument types.
3070    FUNCTION_CODE tells later passes how to compile calls to this function.
3071    See tree.h for its possible values.
3072
3073    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3074    the name to be called if we can't opencode the function.  */
3075
3076 tree
3077 builtin_function (name, type, function_code, library_name)
3078      char *name;
3079      tree type;
3080      enum built_in_function function_code;
3081      char *library_name;
3082 {
3083   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3084   DECL_EXTERNAL (decl) = 1;
3085   TREE_PUBLIC (decl) = 1;
3086   /* If -traditional, permit redefining a builtin function any way you like.
3087      (Though really, if the program redefines these functions,
3088      it probably won't work right unless compiled with -fno-builtin.)  */
3089   if (flag_traditional && name[0] != '_')
3090     DECL_BUILT_IN_NONANSI (decl) = 1;
3091   if (library_name)
3092     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
3093   make_decl_rtl (decl, NULL_PTR, 1);
3094   pushdecl (decl);
3095   if (function_code != NOT_BUILT_IN)
3096     {
3097       DECL_BUILT_IN (decl) = 1;
3098       DECL_SET_FUNCTION_CODE (decl, function_code);
3099     }
3100   /* Warn if a function in the namespace for users
3101      is used without an occasion to consider it declared.  */
3102   if (name[0] != '_' || name[1] != '_')
3103     C_DECL_ANTICIPATED (decl) = 1;
3104
3105   return decl;
3106 }
3107 \f
3108 /* Called when a declaration is seen that contains no names to declare.
3109    If its type is a reference to a structure, union or enum inherited
3110    from a containing scope, shadow that tag name for the current scope
3111    with a forward reference.
3112    If its type defines a new named structure or union
3113    or defines an enum, it is valid but we need not do anything here.
3114    Otherwise, it is an error.  */
3115
3116 void
3117 shadow_tag (declspecs)
3118      tree declspecs;
3119 {
3120   shadow_tag_warned (declspecs, 0);
3121 }
3122
3123 void
3124 shadow_tag_warned (declspecs, warned)
3125      tree declspecs;
3126      int warned;
3127      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
3128         no pedwarn.  */
3129 {
3130   int found_tag = 0;
3131   register tree link;
3132
3133   pending_invalid_xref = 0;
3134
3135   for (link = declspecs; link; link = TREE_CHAIN (link))
3136     {
3137       register tree value = TREE_VALUE (link);
3138       register enum tree_code code = TREE_CODE (value);
3139
3140       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3141         /* Used to test also that TYPE_SIZE (value) != 0.
3142            That caused warning for `struct foo;' at top level in the file.  */
3143         {
3144           register tree name = lookup_tag_reverse (value);
3145           register tree t;
3146
3147           found_tag++;
3148
3149           if (name == 0)
3150             {
3151               if (warned != 1 && code != ENUMERAL_TYPE)
3152                 /* Empty unnamed enum OK */
3153                 {
3154                   pedwarn ("unnamed struct/union that defines no instances");
3155                   warned = 1;
3156                 }
3157             }
3158           else
3159             {
3160               t = lookup_tag (code, name, current_binding_level, 1);
3161
3162               if (t == 0)
3163                 {
3164                   t = make_node (code);
3165                   pushtag (name, t);
3166                 }
3167             }
3168         }
3169       else
3170         {
3171           if (!warned)
3172             {
3173               warning ("useless keyword or type name in empty declaration");
3174               warned = 2;
3175             }
3176         }
3177     }
3178
3179   if (found_tag > 1)
3180     error ("two types specified in one empty declaration");
3181
3182   if (warned != 1)
3183     {
3184       if (found_tag == 0)
3185         pedwarn ("empty declaration");
3186     }
3187 }
3188 \f
3189 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3190
3191 tree
3192 groktypename (typename)
3193      tree typename;
3194 {
3195   if (TREE_CODE (typename) != TREE_LIST)
3196     return typename;
3197   return grokdeclarator (TREE_VALUE (typename),
3198                          TREE_PURPOSE (typename),
3199                          TYPENAME, 0);
3200 }
3201
3202 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
3203
3204 tree
3205 groktypename_in_parm_context (typename)
3206      tree typename;
3207 {
3208   if (TREE_CODE (typename) != TREE_LIST)
3209     return typename;
3210   return grokdeclarator (TREE_VALUE (typename),
3211                          TREE_PURPOSE (typename),
3212                          PARM, 0);
3213 }
3214
3215 /* Decode a declarator in an ordinary declaration or data definition.
3216    This is called as soon as the type information and variable name
3217    have been parsed, before parsing the initializer if any.
3218    Here we create the ..._DECL node, fill in its type,
3219    and put it on the list of decls for the current context.
3220    The ..._DECL node is returned as the value.
3221
3222    Exception: for arrays where the length is not specified,
3223    the type is left null, to be filled in by `finish_decl'.
3224
3225    Function definitions do not come here; they go to start_function
3226    instead.  However, external and forward declarations of functions
3227    do go through here.  Structure field declarations are done by
3228    grokfield and not through here.  */
3229
3230 /* Set this to zero to debug not using the temporary obstack
3231    to parse initializers.  */
3232 int debug_temp_inits = 1;
3233
3234 tree
3235 start_decl (declarator, declspecs, initialized)
3236      tree declarator, declspecs;
3237      int initialized;
3238 {
3239   register tree decl = grokdeclarator (declarator, declspecs,
3240                                        NORMAL, initialized);
3241   register tree tem;
3242   int init_written = initialized;
3243
3244   /* The corresponding pop_obstacks is in finish_decl.  */
3245   push_obstacks_nochange ();
3246
3247   if (initialized)
3248     /* Is it valid for this decl to have an initializer at all?
3249        If not, set INITIALIZED to zero, which will indirectly
3250        tell `finish_decl' to ignore the initializer once it is parsed.  */
3251     switch (TREE_CODE (decl))
3252       {
3253       case TYPE_DECL:
3254         /* typedef foo = bar  means give foo the same type as bar.
3255            We haven't parsed bar yet, so `finish_decl' will fix that up.
3256            Any other case of an initialization in a TYPE_DECL is an error.  */
3257         if (pedantic || list_length (declspecs) > 1)
3258           {
3259             error ("typedef `%s' is initialized",
3260                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3261             initialized = 0;
3262           }
3263         break;
3264
3265       case FUNCTION_DECL:
3266         error ("function `%s' is initialized like a variable",
3267                IDENTIFIER_POINTER (DECL_NAME (decl)));
3268         initialized = 0;
3269         break;
3270
3271       case PARM_DECL:
3272         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
3273         error ("parameter `%s' is initialized",
3274                IDENTIFIER_POINTER (DECL_NAME (decl)));
3275         initialized = 0;
3276         break;
3277
3278       default:
3279         /* Don't allow initializations for incomplete types
3280            except for arrays which might be completed by the initialization.  */
3281         if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
3282           {
3283             /* A complete type is ok if size is fixed.  */
3284
3285             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3286                 || C_DECL_VARIABLE_SIZE (decl))
3287               {
3288                 error ("variable-sized object may not be initialized");
3289                 initialized = 0;
3290               }
3291           }
3292         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3293           {
3294             error ("variable `%s' has initializer but incomplete type",
3295                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3296             initialized = 0;
3297           }
3298         else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
3299           {
3300             error ("elements of array `%s' have incomplete type",
3301                    IDENTIFIER_POINTER (DECL_NAME (decl)));
3302             initialized = 0;
3303           }
3304       }
3305
3306   if (initialized)
3307     {
3308 #if 0  /* Seems redundant with grokdeclarator.  */
3309       if (current_binding_level != global_binding_level
3310           && DECL_EXTERNAL (decl)
3311           && TREE_CODE (decl) != FUNCTION_DECL)
3312         warning ("declaration of `%s' has `extern' and is initialized",
3313                  IDENTIFIER_POINTER (DECL_NAME (decl)));
3314 #endif
3315       DECL_EXTERNAL (decl) = 0;
3316       if (current_binding_level == global_binding_level)
3317         TREE_STATIC (decl) = 1;
3318
3319       /* Tell `pushdecl' this is an initialized decl
3320          even though we don't yet have the initializer expression.
3321          Also tell `finish_decl' it may store the real initializer.  */
3322       DECL_INITIAL (decl) = error_mark_node;
3323     }
3324
3325   /* If this is a function declaration, write a record describing it to the
3326      prototypes file (if requested).  */
3327
3328   if (TREE_CODE (decl) == FUNCTION_DECL)
3329     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3330
3331   /* Add this decl to the current binding level.
3332      TEM may equal DECL or it may be a previous decl of the same name.  */
3333   tem = pushdecl (decl);
3334
3335   /* For a local variable, define the RTL now.  */
3336   if (current_binding_level != global_binding_level
3337       /* But not if this is a duplicate decl
3338          and we preserved the rtl from the previous one
3339          (which may or may not happen).  */
3340       && DECL_RTL (tem) == 0)
3341     {
3342       if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
3343         expand_decl (tem);
3344       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3345                && DECL_INITIAL (tem) != 0)
3346         expand_decl (tem);
3347     }
3348
3349   if (init_written)
3350     {
3351       /* When parsing and digesting the initializer,
3352          use temporary storage.  Do this even if we will ignore the value.  */
3353       if (current_binding_level == global_binding_level && debug_temp_inits)
3354         temporary_allocation ();
3355     }
3356
3357   return tem;
3358 }
3359
3360 /* Finish processing of a declaration;
3361    install its initial value.
3362    If the length of an array type is not known before,
3363    it must be determined now, from the initial value, or it is an error.  */
3364
3365 void
3366 finish_decl (decl, init, asmspec_tree)
3367      tree decl, init;
3368      tree asmspec_tree;
3369 {
3370   register tree type = TREE_TYPE (decl);
3371   int was_incomplete = (DECL_SIZE (decl) == 0);
3372   int temporary = allocation_temporary_p ();
3373   char *asmspec = 0;
3374
3375   if (asmspec_tree)
3376     asmspec = TREE_STRING_POINTER (asmspec_tree);
3377
3378   /* If `start_decl' didn't like having an initialization, ignore it now.  */
3379
3380   if (init != 0 && DECL_INITIAL (decl) == 0)
3381     init = 0;
3382   /* Don't crash if parm is initialized.  */
3383   if (TREE_CODE (decl) == PARM_DECL)
3384     init = 0;
3385
3386   if (ITERATOR_P (decl))
3387     {
3388       if (init == 0)
3389         error_with_decl (decl, "iterator has no initial value");
3390       else
3391         init = save_expr (init);
3392     }
3393
3394   if (init)
3395     {
3396       if (TREE_CODE (decl) != TYPE_DECL)
3397         store_init_value (decl, init);
3398       else
3399         {
3400           /* typedef foo = bar; store the type of bar as the type of foo.  */
3401           TREE_TYPE (decl) = TREE_TYPE (init);
3402           DECL_INITIAL (decl) = init = 0;
3403         }
3404     }
3405
3406   /* Pop back to the obstack that is current for this binding level.
3407      This is because MAXINDEX, rtl, etc. to be made below
3408      must go in the permanent obstack.  But don't discard the
3409      temporary data yet.  */
3410   pop_obstacks ();
3411 #if 0 /* pop_obstacks was near the end; this is what was here.  */
3412   if (current_binding_level == global_binding_level && temporary)
3413     end_temporary_allocation ();
3414 #endif
3415
3416   /* Deduce size of array from initialization, if not already known */
3417
3418   if (TREE_CODE (type) == ARRAY_TYPE
3419       && TYPE_DOMAIN (type) == 0
3420       && TREE_CODE (decl) != TYPE_DECL)
3421     {
3422       int do_default
3423         = (TREE_STATIC (decl)
3424            /* Even if pedantic, an external linkage array
3425               may have incomplete type at first.  */
3426            ? pedantic && !TREE_PUBLIC (decl)
3427            : !DECL_EXTERNAL (decl));
3428       int failure
3429         = complete_array_type (type, DECL_INITIAL (decl), do_default);
3430
3431       /* Get the completed type made by complete_array_type.  */
3432       type = TREE_TYPE (decl);
3433
3434       if (failure == 1)
3435         error_with_decl (decl, "initializer fails to determine size of `%s'");
3436
3437       if (failure == 2)
3438         {
3439           if (do_default)
3440             error_with_decl (decl, "array size missing in `%s'");
3441           /* If a `static' var's size isn't known,
3442              make it extern as well as static, so it does not get
3443              allocated.
3444              If it is not `static', then do not mark extern;
3445              finish_incomplete_decl will give it a default size
3446              and it will get allocated.  */
3447           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3448             DECL_EXTERNAL (decl) = 1;
3449         }
3450
3451       if (pedantic && TYPE_DOMAIN (type) != 0
3452           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
3453                               integer_zero_node))
3454         error_with_decl (decl, "zero-size array `%s'");
3455
3456       layout_decl (decl, 0);
3457     }
3458
3459   if (TREE_CODE (decl) == VAR_DECL)
3460     {
3461       if (DECL_SIZE (decl) == 0
3462           && TYPE_SIZE (TREE_TYPE (decl)) != 0)
3463         layout_decl (decl, 0);
3464
3465       if (DECL_SIZE (decl) == 0
3466           && (TREE_STATIC (decl)
3467               ?
3468                 /* A static variable with an incomplete type
3469                    is an error if it is initialized.
3470                    Otherwise, let it through, but if it is not `extern'
3471                    then it may cause an error message later.  */
3472                 DECL_INITIAL (decl) != 0
3473               :
3474                 /* An automatic variable with an incomplete type
3475                    is an error.  */
3476                 !DECL_EXTERNAL (decl)))
3477         {
3478           error_with_decl (decl, "storage size of `%s' isn't known");
3479           TREE_TYPE (decl) = error_mark_node;
3480         }
3481
3482       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3483           && DECL_SIZE (decl) != 0)
3484         {
3485           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3486             constant_expression_warning (DECL_SIZE (decl));
3487           else
3488             error_with_decl (decl, "storage size of `%s' isn't constant");
3489         }
3490     }
3491
3492   /* Output the assembler code and/or RTL code for variables and functions,
3493      unless the type is an undefined structure or union.
3494      If not, it will get done when the type is completed.  */
3495
3496   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3497     {
3498       if (flag_traditional && allocation_temporary_p ())
3499         {
3500           push_obstacks_nochange ();
3501           end_temporary_allocation ();
3502           /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
3503           maybe_objc_check_decl (decl);
3504           rest_of_decl_compilation (decl, asmspec,
3505                                     current_binding_level == global_binding_level,
3506                                     0);
3507           pop_obstacks ();
3508         }
3509       else
3510         {
3511           /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
3512           maybe_objc_check_decl (decl);
3513           rest_of_decl_compilation (decl, asmspec,
3514                                     current_binding_level == global_binding_level,
3515                                     0);
3516         }
3517       if (current_binding_level != global_binding_level)
3518         {
3519           /* Recompute the RTL of a local array now
3520              if it used to be an incomplete type.  */
3521           if (was_incomplete
3522               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3523             {
3524               /* If we used it already as memory, it must stay in memory.  */
3525               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3526               /* If it's still incomplete now, no init will save it.  */
3527               if (DECL_SIZE (decl) == 0)
3528                 DECL_INITIAL (decl) = 0;
3529               expand_decl (decl);
3530             }
3531           /* Compute and store the initial value.  */
3532           if (TREE_CODE (decl) != FUNCTION_DECL)
3533             expand_decl_init (decl);
3534         }
3535     }
3536
3537   if (TREE_CODE (decl) == TYPE_DECL)
3538     {
3539       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
3540       maybe_objc_check_decl (decl);
3541       rest_of_decl_compilation (decl, NULL_PTR,
3542                                 current_binding_level == global_binding_level,
3543                                 0);
3544     }
3545
3546   /* ??? After 2.3, test (init != 0) instead of TREE_CODE.  */
3547   if (!(TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
3548       && temporary && TREE_PERMANENT (decl)
3549       /* DECL_INITIAL is not defined in PARM_DECLs, since it shares
3550          space with DECL_ARG_TYPE.  */
3551       && TREE_CODE (decl) != PARM_DECL)
3552     {
3553       /* We need to remember that this array HAD an initialization,
3554          but discard the actual temporary nodes,
3555          since we can't have a permanent node keep pointing to them.  */
3556       /* We make an exception for inline functions, since it's
3557          normal for a local extern redeclaration of an inline function
3558          to have a copy of the top-level decl's DECL_INLINE.  */
3559       if (DECL_INITIAL (decl) != 0)
3560         {
3561           /* If this is a static const variable, then preserve the
3562              initializer instead of discarding it so that we can optimize
3563              references to it.  */
3564           if (TREE_STATIC (decl) && TREE_READONLY (decl))
3565             preserve_initializer ();
3566           else
3567             DECL_INITIAL (decl) = error_mark_node;
3568         }
3569     }
3570
3571 #if 0
3572   /* Resume permanent allocation, if not within a function.  */
3573   /* The corresponding push_obstacks_nochange is in start_decl,
3574      and in push_parm_decl and in grokfield.  */
3575   pop_obstacks ();
3576 #endif
3577
3578   /* If we have gone back from temporary to permanent allocation,
3579      actually free the temporary space that we no longer need.  */
3580   if (temporary && !allocation_temporary_p ())
3581     permanent_allocation ();
3582
3583   /* At the end of a declaration, throw away any variable type sizes
3584      of types defined inside that declaration.  There is no use
3585      computing them in the following function definition.  */
3586   if (current_binding_level == global_binding_level)
3587     get_pending_sizes ();
3588 }
3589
3590 /* If DECL has a cleanup, build and return that cleanup here.
3591    This is a callback called by expand_expr.  */
3592
3593 tree
3594 maybe_build_cleanup (decl)
3595      tree decl;
3596 {
3597   /* There are no cleanups in C.  */
3598   return NULL_TREE;
3599 }
3600
3601 /* Given a parsed parameter declaration,
3602    decode it into a PARM_DECL and push that on the current binding level.
3603    Also, for the sake of forward parm decls,
3604    record the given order of parms in `parm_order'.  */
3605
3606 void
3607 push_parm_decl (parm)
3608      tree parm;
3609 {
3610   tree decl, olddecl;
3611   int old_immediate_size_expand = immediate_size_expand;
3612   /* Don't try computing parm sizes now -- wait till fn is called.  */
3613   immediate_size_expand = 0;
3614
3615   /* The corresponding pop_obstacks is in finish_decl.  */
3616   push_obstacks_nochange ();
3617
3618   decl = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), PARM, 0);
3619
3620 #if 0
3621   if (DECL_NAME (decl))
3622     {
3623       olddecl = lookup_name (DECL_NAME (decl));
3624       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3625         pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef");
3626     }
3627 #endif
3628
3629   decl = pushdecl (decl);
3630
3631   immediate_size_expand = old_immediate_size_expand;
3632
3633   current_binding_level->parm_order
3634     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3635
3636   /* Add this decl to the current binding level.  */
3637   finish_decl (decl, NULL_TREE, NULL_TREE);
3638 }
3639
3640 /* Clear the given order of parms in `parm_order'.
3641    Used at start of parm list,
3642    and also at semicolon terminating forward decls.  */
3643
3644 void
3645 clear_parm_order ()
3646 {
3647   current_binding_level->parm_order = NULL_TREE;
3648 }
3649 \f
3650 /* Make TYPE a complete type based on INITIAL_VALUE.
3651    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3652    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3653
3654 int
3655 complete_array_type (type, initial_value, do_default)
3656      tree type;
3657      tree initial_value;
3658      int do_default;
3659 {
3660   register tree maxindex = NULL_TREE;
3661   int value = 0;
3662
3663   if (initial_value)
3664     {
3665       /* Note MAXINDEX  is really the maximum index,
3666          one less than the size.  */
3667       if (TREE_CODE (initial_value) == STRING_CST)
3668         {
3669           int eltsize
3670             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3671           maxindex = build_int_2 (TREE_STRING_LENGTH (initial_value) / eltsize - 1, 0);
3672         }
3673       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3674         {
3675           tree elts = CONSTRUCTOR_ELTS (initial_value);
3676           maxindex = integer_zero_node;
3677           for (; elts; elts = TREE_CHAIN (elts))
3678             {
3679               if (TREE_PURPOSE (elts))
3680                 maxindex = TREE_PURPOSE (elts);
3681               else
3682                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
3683             }
3684           maxindex = copy_node (maxindex);
3685         }
3686       else
3687         {
3688           /* Make an error message unless that happened already.  */
3689           if (initial_value != error_mark_node)
3690             value = 1;
3691
3692           /* Prevent further error messages.  */
3693           maxindex = build_int_2 (0, 0);
3694         }
3695     }
3696
3697   if (!maxindex)
3698     {
3699       if (do_default)
3700         maxindex = build_int_2 (0, 0);
3701       value = 2;
3702     }
3703
3704   if (maxindex)
3705     {
3706       TYPE_DOMAIN (type) = build_index_type (maxindex);
3707       if (!TREE_TYPE (maxindex))
3708         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3709 #if 0 /* I took out this change
3710          together with the change in build_array_type. --rms  */
3711       change_main_variant (type,
3712                            build_array_type (TREE_TYPE (type),
3713                                              TYPE_DOMAIN (type)));
3714 #endif
3715     }
3716
3717   /* Lay out the type now that we can get the real answer.  */
3718
3719   layout_type (type);
3720
3721   return value;
3722 }
3723 \f
3724 /* Given declspecs and a declarator,
3725    determine the name and type of the object declared
3726    and construct a ..._DECL node for it.
3727    (In one case we can return a ..._TYPE node instead.
3728     For invalid input we sometimes return 0.)
3729
3730    DECLSPECS is a chain of tree_list nodes whose value fields
3731     are the storage classes and type specifiers.
3732
3733    DECL_CONTEXT says which syntactic context this declaration is in:
3734      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3735      FUNCDEF for a function definition.  Like NORMAL but a few different
3736       error messages in each case.  Return value may be zero meaning
3737       this definition is too screwy to try to parse.
3738      PARM for a parameter declaration (either within a function prototype
3739       or before a function body).  Make a PARM_DECL, or return void_type_node.
3740      TYPENAME if for a typename (in a cast or sizeof).
3741       Don't make a DECL node; just return the ..._TYPE node.
3742      FIELD for a struct or union field; make a FIELD_DECL.
3743      BITFIELD for a field with specified width.
3744    INITIALIZED is 1 if the decl has an initializer.
3745
3746    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3747    It may also be so in the PARM case, for a prototype where the
3748    argument type is specified but not the name.
3749
3750    This function is where the complicated C meanings of `static'
3751    and `extern' are interpreted.  */
3752
3753 static tree
3754 grokdeclarator (declarator, declspecs, decl_context, initialized)
3755      tree declspecs;
3756      tree declarator;
3757      enum decl_context decl_context;
3758      int initialized;
3759 {
3760   int specbits = 0;
3761   tree spec;
3762   tree type = NULL_TREE;
3763   int longlong = 0;
3764   int constp;
3765   int volatilep;
3766   int inlinep;
3767   int explicit_int = 0;
3768   int explicit_char = 0;
3769   int defaulted_int = 0;
3770   tree typedef_decl = 0;
3771   char *name;
3772   tree typedef_type = 0;
3773   int funcdef_flag = 0;
3774   enum tree_code innermost_code = ERROR_MARK;
3775   int bitfield = 0;
3776   int size_varies = 0;
3777
3778   if (decl_context == BITFIELD)
3779     bitfield = 1, decl_context = FIELD;
3780
3781   if (decl_context == FUNCDEF)
3782     funcdef_flag = 1, decl_context = NORMAL;
3783
3784   push_obstacks_nochange ();
3785
3786   if (flag_traditional && allocation_temporary_p ())
3787     end_temporary_allocation ();
3788
3789   /* Look inside a declarator for the name being declared
3790      and get it as a string, for an error message.  */
3791   {
3792     register tree decl = declarator;
3793     name = 0;
3794
3795     while (decl)
3796       switch (TREE_CODE (decl))
3797         {
3798         case ARRAY_REF:
3799         case INDIRECT_REF:
3800         case CALL_EXPR:
3801           innermost_code = TREE_CODE (decl);
3802           decl = TREE_OPERAND (decl, 0);
3803           break;
3804
3805         case IDENTIFIER_NODE:
3806           name = IDENTIFIER_POINTER (decl);
3807           decl = 0;
3808           break;
3809
3810         default:
3811           abort ();
3812         }
3813     if (name == 0)
3814       name = "type name";
3815   }
3816
3817   /* A function definition's declarator must have the form of
3818      a function declarator.  */
3819
3820   if (funcdef_flag && innermost_code != CALL_EXPR)
3821     return 0;
3822
3823   /* Anything declared one level down from the top level
3824      must be one of the parameters of a function
3825      (because the body is at least two levels down).  */
3826
3827   /* If this looks like a function definition, make it one,
3828      even if it occurs where parms are expected.
3829      Then store_parm_decls will reject it and not use it as a parm.  */
3830   if (decl_context == NORMAL && !funcdef_flag
3831       && current_binding_level->level_chain == global_binding_level)
3832     decl_context = PARM;
3833
3834   /* Look through the decl specs and record which ones appear.
3835      Some typespecs are defined as built-in typenames.
3836      Others, the ones that are modifiers of other types,
3837      are represented by bits in SPECBITS: set the bits for
3838      the modifiers that appear.  Storage class keywords are also in SPECBITS.
3839
3840      If there is a typedef name or a type, store the type in TYPE.
3841      This includes builtin typedefs such as `int'.
3842
3843      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3844      and did not come from a user typedef.
3845
3846      Set LONGLONG if `long' is mentioned twice.  */
3847
3848   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3849     {
3850       register int i;
3851       register tree id = TREE_VALUE (spec);
3852
3853       if (id == ridpointers[(int) RID_INT])
3854         explicit_int = 1;
3855       if (id == ridpointers[(int) RID_CHAR])
3856         explicit_char = 1;
3857
3858       if (TREE_CODE (id) == IDENTIFIER_NODE)
3859         for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
3860           {
3861             if (ridpointers[i] == id)
3862               {
3863                 if (i == (int) RID_LONG && specbits & (1<<i))
3864                   {
3865                     if (longlong)
3866                       error ("`long long long' is too long for GCC");
3867                     else
3868                       {
3869                         if (pedantic)
3870                           pedwarn ("ANSI C does not support `long long'");
3871                         longlong = 1;
3872                       }
3873                   }
3874                 else if (specbits & (1 << i))
3875                   pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3876                 specbits |= 1 << i;
3877                 goto found;
3878               }
3879           }
3880       if (type)
3881         error ("two or more data types in declaration of `%s'", name);
3882       /* Actual typedefs come to us as TYPE_DECL nodes.  */
3883       else if (TREE_CODE (id) == TYPE_DECL)
3884         {
3885           type = TREE_TYPE (id);
3886           typedef_decl = id;
3887         }
3888       /* Built-in types come as identifiers.  */
3889       else if (TREE_CODE (id) == IDENTIFIER_NODE)
3890         {
3891           register tree t = lookup_name (id);
3892           if (TREE_TYPE (t) == error_mark_node)
3893             ;
3894           else if (!t || TREE_CODE (t) != TYPE_DECL)
3895             error ("`%s' fails to be a typedef or built in type",
3896                    IDENTIFIER_POINTER (id));
3897           else
3898             {
3899               type = TREE_TYPE (t);
3900               typedef_decl = t;
3901             }
3902         }
3903       else if (TREE_CODE (id) != ERROR_MARK)
3904         type = id;
3905
3906     found: {}
3907     }
3908
3909   typedef_type = type;
3910   if (type)
3911     size_varies = C_TYPE_VARIABLE_SIZE (type);
3912
3913   /* No type at all: default to `int', and set DEFAULTED_INT
3914      because it was not a user-defined typedef.  */
3915
3916   if (type == 0)
3917     {
3918       if (funcdef_flag && warn_return_type
3919           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3920                             | (1 << (int) RID_SIGNED) | (1 << (int) RID_UNSIGNED))))
3921         warn_about_return_type = 1;
3922       defaulted_int = 1;
3923       type = integer_type_node;
3924     }
3925
3926   /* Now process the modifiers that were specified
3927      and check for invalid combinations.  */
3928
3929   /* Long double is a special combination.  */
3930
3931   if ((specbits & 1 << (int) RID_LONG)
3932       && TYPE_MAIN_VARIANT (type) == double_type_node)
3933     {
3934       specbits &= ~ (1 << (int) RID_LONG);
3935       type = long_double_type_node;
3936     }
3937
3938   /* Check all other uses of type modifiers.  */
3939
3940   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3941                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3942     {
3943       int ok = 0;
3944
3945       if (TREE_CODE (type) != INTEGER_TYPE)
3946         error ("long, short, signed or unsigned invalid for `%s'", name);
3947       else if ((specbits & 1 << (int) RID_LONG)
3948                && (specbits & 1 << (int) RID_SHORT))
3949         error ("long and short specified together for `%s'", name);
3950       else if (((specbits & 1 << (int) RID_LONG)
3951                 || (specbits & 1 << (int) RID_SHORT))
3952                && explicit_char)
3953         error ("long or short specified with char for `%s'", name);
3954       else if (((specbits & 1 << (int) RID_LONG)
3955                 || (specbits & 1 << (int) RID_SHORT))
3956                && TREE_CODE (type) == REAL_TYPE)
3957         error ("long or short specified with floating type for `%s'", name);
3958       else if ((specbits & 1 << (int) RID_SIGNED)
3959                && (specbits & 1 << (int) RID_UNSIGNED))
3960         error ("signed and unsigned given together for `%s'", name);
3961       else
3962         {
3963           ok = 1;
3964           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
3965             {
3966               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
3967                        name);
3968               if (flag_pedantic_errors)
3969                 ok = 0;
3970             }
3971         }
3972
3973       /* Discard the type modifiers if they are invalid.  */
3974       if (! ok)
3975         {
3976           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3977                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3978           longlong = 0;
3979         }
3980     }
3981
3982   /* Decide whether an integer type is signed or not.
3983      Optionally treat bitfields as signed by default.  */
3984   if (specbits & 1 << (int) RID_UNSIGNED
3985       /* Traditionally, all bitfields are unsigned.  */
3986       || (bitfield && flag_traditional
3987           && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
3988       || (bitfield && ! flag_signed_bitfields
3989           && (explicit_int || defaulted_int || explicit_char
3990               /* A typedef for plain `int' without `signed'
3991                  can be controlled just like plain `int'.  */
3992               || ! (typedef_decl != 0
3993                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3994           && TREE_CODE (type) != ENUMERAL_TYPE
3995           && !(specbits & 1 << (int) RID_SIGNED)))
3996     {
3997       if (longlong)
3998         type = long_long_unsigned_type_node;
3999       else if (specbits & 1 << (int) RID_LONG)
4000         type = long_unsigned_type_node;
4001       else if (specbits & 1 << (int) RID_SHORT)
4002         type = short_unsigned_type_node;
4003       else if (type == char_type_node)
4004         type = unsigned_char_type_node;
4005       else if (typedef_decl)
4006         type = unsigned_type (type);
4007       else
4008         type = unsigned_type_node;
4009     }
4010   else if ((specbits & 1 << (int) RID_SIGNED)
4011            && type == char_type_node)
4012     type = signed_char_type_node;
4013   else if (longlong)
4014     type = long_long_integer_type_node;
4015   else if (specbits & 1 << (int) RID_LONG)
4016     type = long_integer_type_node;
4017   else if (specbits & 1 << (int) RID_SHORT)
4018     type = short_integer_type_node;
4019   else if (specbits & 1 << (int) RID_COMPLEX)
4020     {
4021       if (defaulted_int)
4022         type = complex_double_type_node;
4023       else if (type == integer_type_node)
4024         type = complex_integer_type_node;
4025       else if (type == float_type_node)
4026         type = complex_float_type_node;
4027       else if (type == double_type_node)
4028         type = complex_double_type_node;
4029       else if (type == long_double_type_node)
4030         type = complex_long_double_type_node;
4031       else
4032         error ("invalid complex type");
4033     }
4034
4035   /* Set CONSTP if this declaration is `const', whether by
4036      explicit specification or via a typedef.
4037      Likewise for VOLATILEP.  */
4038
4039   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4040   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4041   inlinep = !! (specbits & (1 << (int) RID_INLINE));
4042   if (constp > 1)
4043     pedwarn ("duplicate `const'");
4044   if (volatilep > 1)
4045     pedwarn ("duplicate `volatile'");
4046   if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
4047     type = TYPE_MAIN_VARIANT (type);
4048
4049   /* Warn if two storage classes are given. Default to `auto'.  */
4050
4051   {
4052     int nclasses = 0;
4053
4054     if (specbits & 1 << (int) RID_AUTO) nclasses++;
4055     if (specbits & 1 << (int) RID_STATIC) nclasses++;
4056     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4057     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4058     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4059     if (specbits & 1 << (int) RID_ITERATOR) nclasses++;
4060
4061     /* Warn about storage classes that are invalid for certain
4062        kinds of declarations (parameters, typenames, etc.).  */
4063
4064     if (nclasses > 1)
4065       error ("multiple storage classes in declaration of `%s'", name);
4066     else if (funcdef_flag
4067              && (specbits
4068                  & ((1 << (int) RID_REGISTER)
4069                     | (1 << (int) RID_AUTO)
4070                     | (1 << (int) RID_TYPEDEF))))
4071       {
4072         if (specbits & 1 << (int) RID_AUTO
4073             && (pedantic || current_binding_level == global_binding_level))
4074           pedwarn ("function definition declared `auto'");
4075         if (specbits & 1 << (int) RID_REGISTER)
4076           error ("function definition declared `register'");
4077         if (specbits & 1 << (int) RID_TYPEDEF)
4078           error ("function definition declared `typedef'");
4079         specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4080                        | (1 << (int) RID_AUTO));
4081       }
4082     else if (decl_context != NORMAL && nclasses > 0)
4083       {
4084         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4085           ;
4086         else
4087           {
4088             error ((decl_context == FIELD
4089                     ? "storage class specified for structure field `%s'"
4090                     : (decl_context == PARM
4091                        ? "storage class specified for parameter `%s'"
4092                        : "storage class specified for typename")),
4093                    name);
4094             specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4095                            | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4096                            | (1 << (int) RID_EXTERN));
4097           }
4098       }
4099     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4100       {
4101         /* `extern' with initialization is invalid if not at top level.  */
4102         if (current_binding_level == global_binding_level)
4103           warning ("`%s' initialized and declared `extern'", name);
4104         else
4105           error ("`%s' has both `extern' and initializer", name);
4106       }
4107     else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4108              && current_binding_level != global_binding_level)
4109       error ("nested function `%s' declared `extern'", name);
4110     else if (current_binding_level == global_binding_level
4111              && specbits & (1 << (int) RID_AUTO))
4112       error ("top-level declaration of `%s' specifies `auto'", name);
4113     else if ((specbits & 1 << (int) RID_ITERATOR)
4114              && TREE_CODE (declarator) != IDENTIFIER_NODE)
4115       {
4116         error ("iterator `%s' has derived type", name);
4117         type = error_mark_node;
4118       }
4119     else if ((specbits & 1 << (int) RID_ITERATOR)
4120              && TREE_CODE (type) != INTEGER_TYPE)
4121       {
4122         error ("iterator `%s' has noninteger type", name);
4123         type = error_mark_node;
4124       }
4125   }
4126
4127   /* Now figure out the structure of the declarator proper.
4128      Descend through it, creating more complex types, until we reach
4129      the declared identifier (or NULL_TREE, in an absolute declarator).  */
4130
4131   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4132     {
4133       if (type == error_mark_node)
4134         {
4135           declarator = TREE_OPERAND (declarator, 0);
4136           continue;
4137         }
4138
4139       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4140          an INDIRECT_REF (for *...),
4141          a CALL_EXPR (for ...(...)),
4142          an identifier (for the name being declared)
4143          or a null pointer (for the place in an absolute declarator
4144          where the name was omitted).
4145          For the last two cases, we have just exited the loop.
4146
4147          At this point, TYPE is the type of elements of an array,
4148          or for a function to return, or for a pointer to point to.
4149          After this sequence of ifs, TYPE is the type of the
4150          array or function or pointer, and DECLARATOR has had its
4151          outermost layer removed.  */
4152
4153       if (TREE_CODE (declarator) == ARRAY_REF)
4154         {
4155           register tree itype = NULL_TREE;
4156           register tree size = TREE_OPERAND (declarator, 1);
4157           /* An uninitialized decl with `extern' is a reference.  */
4158           int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4159
4160           declarator = TREE_OPERAND (declarator, 0);
4161
4162           /* Check for some types that there cannot be arrays of.  */
4163
4164           if (TYPE_MAIN_VARIANT (type) == void_type_node)
4165             {
4166               error ("declaration of `%s' as array of voids", name);
4167               type = error_mark_node;
4168             }
4169
4170           if (TREE_CODE (type) == FUNCTION_TYPE)
4171             {
4172               error ("declaration of `%s' as array of functions", name);
4173               type = error_mark_node;
4174             }
4175
4176           if (size == error_mark_node)
4177             type = error_mark_node;
4178
4179           if (type == error_mark_node)
4180             continue;
4181
4182           /* If this is a block level extern, it must live past the end
4183              of the function so that we can check it against other extern
4184              declarations (IDENTIFIER_LIMBO_VALUE).  */
4185           if (extern_ref && allocation_temporary_p ())
4186             end_temporary_allocation ();
4187
4188           /* If size was specified, set ITYPE to a range-type for that size.
4189              Otherwise, ITYPE remains null.  finish_decl may figure it out
4190              from an initial value.  */
4191
4192           if (size)
4193             {
4194               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4195               STRIP_TYPE_NOPS (size);
4196
4197               if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
4198                   && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
4199                 {
4200                   error ("size of array `%s' has non-integer type", name);
4201                   size = integer_one_node;
4202                 }
4203               if (pedantic && integer_zerop (size))
4204                 pedwarn ("ANSI C forbids zero-size array `%s'", name);
4205               if (TREE_CODE (size) == INTEGER_CST)
4206                 {
4207                   constant_expression_warning (size);
4208                   if (INT_CST_LT (size, integer_zero_node))
4209                     {
4210                       error ("size of array `%s' is negative", name);
4211                       size = integer_one_node;
4212                     }
4213                   itype = build_index_type (size_binop (MINUS_EXPR, size,
4214                                                         size_one_node));
4215                 }
4216               else
4217                 {
4218                   if (pedantic)
4219                     {
4220                       if (TREE_CONSTANT (size))
4221                         pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name);
4222                       else
4223                         pedwarn ("ANSI C forbids variable-size array `%s'", name);
4224                     }
4225                   itype = build_binary_op (MINUS_EXPR, size, integer_one_node,
4226                                            1);
4227                   /* Make sure the array size remains visibly nonconstant
4228                      even if it is (eg) a const variable with known value.  */
4229                   size_varies = 1;
4230                   itype = variable_size (itype);
4231                   itype = build_index_type (itype);
4232                 }
4233             }
4234
4235 #if 0 /* This had bad results for pointers to arrays, as in
4236          union incomplete (*foo)[4];  */
4237           /* Complain about arrays of incomplete types, except in typedefs.  */
4238
4239           if (TYPE_SIZE (type) == 0
4240               /* Avoid multiple warnings for nested array types.  */
4241               && TREE_CODE (type) != ARRAY_TYPE
4242               && !(specbits & (1 << (int) RID_TYPEDEF))
4243               && !C_TYPE_BEING_DEFINED (type))
4244             warning ("array type has incomplete element type");
4245 #endif
4246
4247 #if 0  /* We shouldn't have a function type here at all!
4248           Functions aren't allowed as array elements.  */
4249           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4250               && (constp || volatilep))
4251             pedwarn ("ANSI C forbids const or volatile function types");
4252 #endif
4253
4254           /* Build the array type itself, then merge any constancy or
4255              volatility into the target type.  We must do it in this order
4256              to ensure that the TYPE_MAIN_VARIANT field of the array type
4257              is set correctly.  */
4258
4259           type = build_array_type (type, itype);
4260           if (constp || volatilep)
4261             type = c_build_type_variant (type, constp, volatilep);
4262
4263 #if 0   /* don't clear these; leave them set so that the array type
4264            or the variable is itself const or volatile.  */
4265           constp = 0;
4266           volatilep = 0;
4267 #endif
4268
4269           if (size_varies)
4270             C_TYPE_VARIABLE_SIZE (type) = 1;
4271         }
4272       else if (TREE_CODE (declarator) == CALL_EXPR)
4273         {
4274           int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4275                             || current_binding_level == global_binding_level);
4276           tree arg_types;
4277
4278           /* Declaring a function type.
4279              Make sure we have a valid type for the function to return.  */
4280           if (type == error_mark_node)
4281             continue;
4282
4283           size_varies = 0;
4284
4285           /* Warn about some types functions can't return.  */
4286
4287           if (TREE_CODE (type) == FUNCTION_TYPE)
4288             {
4289               error ("`%s' declared as function returning a function", name);
4290               type = integer_type_node;
4291             }
4292           if (TREE_CODE (type) == ARRAY_TYPE)
4293             {
4294               error ("`%s' declared as function returning an array", name);
4295               type = integer_type_node;
4296             }
4297
4298 #ifndef TRADITIONAL_RETURN_FLOAT
4299           /* Traditionally, declaring return type float means double.  */
4300
4301           if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4302             type = double_type_node;
4303 #endif /* TRADITIONAL_RETURN_FLOAT */
4304
4305           /* If this is a block level extern, it must live past the end
4306              of the function so that we can check it against other extern
4307              declarations (IDENTIFIER_LIMBO_VALUE).  */
4308           if (extern_ref && allocation_temporary_p ())
4309             end_temporary_allocation ();
4310
4311           /* Construct the function type and go to the next
4312              inner layer of declarator.  */
4313
4314           arg_types = grokparms (TREE_OPERAND (declarator, 1),
4315                                  funcdef_flag
4316                                  /* Say it's a definition
4317                                     only for the CALL_EXPR
4318                                     closest to the identifier.  */
4319                                  && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4320 #if 0 /* This seems to be false.  We turn off temporary allocation
4321          above in this function if -traditional.
4322          And this code caused inconsistent results with prototypes:
4323          callers would ignore them, and pass arguments wrong.  */
4324
4325           /* Omit the arg types if -traditional, since the arg types
4326              and the list links might not be permanent.  */
4327           type = build_function_type (type,
4328                                       flag_traditional
4329                                       ? NULL_TREE : arg_types);
4330 #endif
4331           /* ANSI seems to say that `const int foo ();'
4332              does not make the function foo const.  */
4333           if (constp || volatilep)
4334             type = c_build_type_variant (type, constp, volatilep);
4335           constp = 0;
4336           volatilep = 0;
4337
4338           type = build_function_type (type, arg_types);
4339           declarator = TREE_OPERAND (declarator, 0);
4340
4341           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4342              the formal parameter list of this FUNCTION_TYPE to point to
4343              the FUNCTION_TYPE node itself.  */
4344
4345           {
4346             register tree link;
4347
4348             for (link = current_function_parm_tags;
4349                  link;
4350                  link = TREE_CHAIN (link))
4351               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4352           }
4353         }
4354       else if (TREE_CODE (declarator) == INDIRECT_REF)
4355         {
4356           /* Merge any constancy or volatility into the target type
4357              for the pointer.  */
4358
4359           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4360               && (constp || volatilep))
4361             pedwarn ("ANSI C forbids const or volatile function types");
4362           if (constp || volatilep)
4363             type = c_build_type_variant (type, constp, volatilep);
4364           constp = 0;
4365           volatilep = 0;
4366           size_varies = 0;
4367
4368           type = build_pointer_type (type);
4369
4370           /* Process a list of type modifier keywords
4371              (such as const or volatile) that were given inside the `*'.  */
4372
4373           if (TREE_TYPE (declarator))
4374             {
4375               register tree typemodlist;
4376               int erred = 0;
4377               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4378                    typemodlist = TREE_CHAIN (typemodlist))
4379                 {
4380                   if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
4381                     constp++;
4382                   else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
4383                     volatilep++;
4384                   else if (!erred)
4385                     {
4386                       erred = 1;
4387                       error ("invalid type modifier within pointer declarator");
4388                     }
4389                 }
4390               if (constp > 1)
4391                 pedwarn ("duplicate `const'");
4392               if (volatilep > 1)
4393                 pedwarn ("duplicate `volatile'");
4394             }
4395
4396           declarator = TREE_OPERAND (declarator, 0);
4397         }
4398       else
4399         abort ();
4400
4401     }
4402
4403   /* Now TYPE has the actual type.  */
4404
4405   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4406
4407   if (specbits & (1 << (int) RID_TYPEDEF))
4408     {
4409       tree decl;
4410       /* Note that the grammar rejects storage classes
4411          in typenames, fields or parameters */
4412       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4413           && (constp || volatilep))
4414         pedwarn ("ANSI C forbids const or volatile function types");
4415       if (constp || volatilep)
4416         type = c_build_type_variant (type, constp, volatilep);
4417       pop_obstacks ();
4418       decl = build_decl (TYPE_DECL, declarator, type);
4419       if ((specbits & (1 << (int) RID_SIGNED))
4420           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4421         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4422       return decl;
4423     }
4424
4425   /* Detect the case of an array type of unspecified size
4426      which came, as such, direct from a typedef name.
4427      We must copy the type, so that each identifier gets
4428      a distinct type, so that each identifier's size can be
4429      controlled separately by its own initializer.  */
4430
4431   if (type != 0 && typedef_type != 0
4432       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
4433       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
4434     {
4435       type = build_array_type (TREE_TYPE (type), 0);
4436       if (size_varies)
4437         C_TYPE_VARIABLE_SIZE (type) = 1;
4438     }
4439
4440   /* If this is a type name (such as, in a cast or sizeof),
4441      compute the type and return it now.  */
4442
4443   if (decl_context == TYPENAME)
4444     {
4445       /* Note that the grammar rejects storage classes
4446          in typenames, fields or parameters */
4447       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4448           && (constp || volatilep))
4449         pedwarn ("ANSI C forbids const or volatile function types");
4450       if (constp || volatilep)
4451         type = c_build_type_variant (type, constp, volatilep);
4452       pop_obstacks ();
4453       return type;
4454     }
4455
4456   /* Aside from typedefs and type names (handle above),
4457      `void' at top level (not within pointer)
4458      is allowed only in public variables.
4459      We don't complain about parms either, but that is because
4460      a better error message can be made later.  */
4461
4462   if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM
4463       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4464             && ((specbits & (1 << (int) RID_EXTERN))
4465                 || (current_binding_level == global_binding_level
4466                     && !(specbits
4467                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4468     {
4469       error ("variable or field `%s' declared void",
4470              IDENTIFIER_POINTER (declarator));
4471       type = integer_type_node;
4472     }
4473
4474   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4475      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4476
4477   {
4478     register tree decl;
4479
4480     if (decl_context == PARM)
4481       {
4482         tree type_as_written = type;
4483         tree main_type;
4484
4485         /* A parameter declared as an array of T is really a pointer to T.
4486            One declared as a function is really a pointer to a function.  */
4487
4488         if (TREE_CODE (type) == ARRAY_TYPE)
4489           {
4490             /* Transfer const-ness of array into that of type pointed to.  */
4491             type = TREE_TYPE (type);
4492             if (constp || volatilep)
4493               type = c_build_type_variant (type, constp, volatilep);
4494             type = build_pointer_type (type);
4495             volatilep = constp = 0;
4496             size_varies = 0;
4497           }
4498         else if (TREE_CODE (type) == FUNCTION_TYPE)
4499           {
4500             if (pedantic && (constp || volatilep))
4501               pedwarn ("ANSI C forbids const or volatile function types");
4502             if (constp || volatilep)
4503               type = c_build_type_variant (type, constp, volatilep);
4504             type = build_pointer_type (type);
4505             volatilep = constp = 0;
4506           }
4507
4508         decl = build_decl (PARM_DECL, declarator, type);
4509         if (size_varies)
4510           C_DECL_VARIABLE_SIZE (decl) = 1;
4511
4512         /* Compute the type actually passed in the parmlist,
4513            for the case where there is no prototype.
4514            (For example, shorts and chars are passed as ints.)
4515            When there is a prototype, this is overridden later.  */
4516
4517         DECL_ARG_TYPE (decl) = type;
4518         main_type = (type == error_mark_node
4519                      ? error_mark_node
4520                      : TYPE_MAIN_VARIANT (type));
4521         if (main_type == float_type_node)
4522           DECL_ARG_TYPE (decl) = double_type_node;
4523         /* Don't use TYPE_PRECISION to decide whether to promote,
4524            because we should convert short if it's the same size as int,
4525            but we should not convert long if it's the same size as int.  */
4526         else if (TREE_CODE (main_type) != ERROR_MARK
4527                  && C_PROMOTING_INTEGER_TYPE_P (main_type))
4528           {
4529             if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
4530                 && TREE_UNSIGNED (type))
4531               DECL_ARG_TYPE (decl) = unsigned_type_node;
4532             else
4533               DECL_ARG_TYPE (decl) = integer_type_node;
4534           }
4535
4536         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4537       }
4538     else if (decl_context == FIELD)
4539       {
4540         /* Structure field.  It may not be a function.  */
4541
4542         if (TREE_CODE (type) == FUNCTION_TYPE)
4543           {
4544             error ("field `%s' declared as a function",
4545                    IDENTIFIER_POINTER (declarator));
4546             type = build_pointer_type (type);
4547           }
4548         else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
4549           {
4550             error ("field `%s' has incomplete type",
4551                    IDENTIFIER_POINTER (declarator));
4552             type = error_mark_node;
4553           }
4554         /* Move type qualifiers down to element of an array.  */
4555         if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
4556           {
4557             type = build_array_type (c_build_type_variant (TREE_TYPE (type),
4558                                                            constp, volatilep),
4559                                      TYPE_DOMAIN (type));
4560 #if 0 /* Leave the field const or volatile as well.  */
4561             constp = volatilep = 0;
4562 #endif
4563           }
4564         decl = build_decl (FIELD_DECL, declarator, type);
4565         if (size_varies)
4566           C_DECL_VARIABLE_SIZE (decl) = 1;
4567       }
4568     else if (TREE_CODE (type) == FUNCTION_TYPE)
4569       {
4570         /* Every function declaration is "external"
4571            except for those which are inside a function body
4572            in which `auto' is used.
4573            That is a case not specified by ANSI C,
4574            and we use it for forward declarations for nested functions.  */
4575         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4576                           || current_binding_level == global_binding_level);
4577
4578         if (specbits & (1 << (int) RID_AUTO)
4579             && (pedantic || current_binding_level == global_binding_level))
4580           pedwarn ("invalid storage class for function `%s'",
4581                  IDENTIFIER_POINTER (declarator));
4582         if (specbits & (1 << (int) RID_REGISTER))
4583           error ("invalid storage class for function `%s'",
4584                  IDENTIFIER_POINTER (declarator));
4585         /* Function declaration not at top level.
4586            Storage classes other than `extern' are not allowed
4587            and `extern' makes no difference.  */
4588         if (current_binding_level != global_binding_level
4589             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4590             && pedantic)
4591           pedwarn ("invalid storage class for function `%s'",
4592                    IDENTIFIER_POINTER (declarator));
4593
4594         /* If this is a block level extern, it must live past the end
4595            of the function so that we can check it against other
4596            extern declarations (IDENTIFIER_LIMBO_VALUE).  */
4597         if (extern_ref && allocation_temporary_p ())
4598           end_temporary_allocation ();
4599
4600         decl = build_decl (FUNCTION_DECL, declarator, type);
4601
4602         if (pedantic && (constp || volatilep)
4603             && ! DECL_IN_SYSTEM_HEADER (decl))
4604           pedwarn ("ANSI C forbids const or volatile functions");
4605
4606         if (volatilep
4607             && TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
4608           warning ("volatile function returns non-void value");
4609
4610         if (extern_ref)
4611           DECL_EXTERNAL (decl) = 1;
4612         /* Record absence of global scope for `static' or `auto'.  */
4613         TREE_PUBLIC (decl)
4614           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4615         /* Record presence of `inline', if it is reasonable.  */
4616         if (inlinep)
4617           {
4618             tree last = tree_last (TYPE_ARG_TYPES (type));
4619
4620             if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
4621               warning ("cannot inline function `main'");
4622             else if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last))
4623                               != void_type_node))
4624               warning ("inline declaration ignored for function with `...'");
4625             else
4626               /* Assume that otherwise the function can be inlined.  */
4627               DECL_INLINE (decl) = 1;
4628
4629             if (specbits & (1 << (int) RID_EXTERN))
4630               current_extern_inline = 1;
4631           }
4632       }
4633     else
4634       {
4635         /* It's a variable.  */
4636         /* An uninitialized decl with `extern' is a reference.  */
4637         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4638
4639         /* Move type qualifiers down to element of an array.  */
4640         if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
4641           {
4642             type = build_array_type (c_build_type_variant (TREE_TYPE (type),
4643                                                            constp, volatilep),
4644                                      TYPE_DOMAIN (type));
4645 #if 0 /* Leave the variable const or volatile as well.  */
4646             constp = volatilep = 0;
4647 #endif
4648           }
4649
4650         /* If this is a block level extern, it must live past the end
4651            of the function so that we can check it against other
4652            extern declarations (IDENTIFIER_LIMBO_VALUE).  */
4653         if (extern_ref && allocation_temporary_p ())
4654           end_temporary_allocation ();
4655
4656         decl = build_decl (VAR_DECL, declarator, type);
4657         if (size_varies)
4658           C_DECL_VARIABLE_SIZE (decl) = 1;
4659
4660         if (inlinep)
4661           pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4662
4663         DECL_EXTERNAL (decl) = extern_ref;
4664         /* At top level, the presence of a `static' or `register' storage
4665            class specifier, or the absence of all storage class specifiers
4666            makes this declaration a definition (perhaps tentative).  Also,
4667            the absence of both `static' and `register' makes it public.  */
4668         if (current_binding_level == global_binding_level)
4669           {
4670             TREE_PUBLIC (decl)
4671               = !(specbits
4672                   & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
4673             TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
4674           }
4675         /* Not at top level, only `static' makes a static definition.  */
4676         else
4677           {
4678             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4679             TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
4680           }
4681
4682         if (specbits & 1 << (int) RID_ITERATOR)
4683           ITERATOR_P (decl) = 1;
4684       }
4685
4686     /* Record `register' declaration for warnings on &
4687        and in case doing stupid register allocation.  */
4688
4689     if (specbits & (1 << (int) RID_REGISTER))
4690       DECL_REGISTER (decl) = 1;
4691
4692     /* Record constancy and volatility.  */
4693
4694     if (constp)
4695       TREE_READONLY (decl) = 1;
4696     if (volatilep)
4697       {
4698         TREE_SIDE_EFFECTS (decl) = 1;
4699         TREE_THIS_VOLATILE (decl) = 1;
4700       }
4701     /* If a type has volatile components, it should be stored in memory.
4702        Otherwise, the fact that those components are volatile
4703        will be ignored, and would even crash the compiler.  */
4704     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4705       mark_addressable (decl);
4706
4707     pop_obstacks ();
4708
4709     return decl;
4710   }
4711 }
4712 \f
4713 /* Decode the parameter-list info for a function type or function definition.
4714    The argument is the value returned by `get_parm_info' (or made in parse.y
4715    if there is an identifier list instead of a parameter decl list).
4716    These two functions are separate because when a function returns
4717    or receives functions then each is called multiple times but the order
4718    of calls is different.  The last call to `grokparms' is always the one
4719    that contains the formal parameter names of a function definition.
4720
4721    Store in `last_function_parms' a chain of the decls of parms.
4722    Also store in `last_function_parm_tags' a chain of the struct, union,
4723    and enum tags declared among the parms.
4724
4725    Return a list of arg types to use in the FUNCTION_TYPE for this function.
4726
4727    FUNCDEF_FLAG is nonzero for a function definition, 0 for
4728    a mere declaration.  A nonempty identifier-list gets an error message
4729    when FUNCDEF_FLAG is zero.  */
4730
4731 static tree
4732 grokparms (parms_info, funcdef_flag)
4733      tree parms_info;
4734      int funcdef_flag;
4735 {
4736   tree first_parm = TREE_CHAIN (parms_info);
4737
4738   last_function_parms = TREE_PURPOSE (parms_info);
4739   last_function_parm_tags = TREE_VALUE (parms_info);
4740
4741   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
4742       && !in_system_header)
4743     warning ("function declaration isn't a prototype");
4744
4745   if (first_parm != 0
4746       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4747     {
4748       if (! funcdef_flag)
4749         pedwarn ("parameter names (without types) in function declaration");
4750
4751       last_function_parms = first_parm;
4752       return 0;
4753     }
4754   else
4755     {
4756       tree parm;
4757       tree typelt;
4758       /* We no longer test FUNCDEF_FLAG.
4759          If the arg types are incomplete in a declaration,
4760          they must include undefined tags.
4761          These tags can never be defined in the scope of the declaration,
4762          so the types can never be completed,
4763          and no call can be compiled successfully.  */
4764 #if 0
4765       /* In a fcn definition, arg types must be complete.  */
4766       if (funcdef_flag)
4767 #endif
4768         for (parm = last_function_parms, typelt = first_parm;
4769              parm;
4770              parm = TREE_CHAIN (parm))
4771           /* Skip over any enumeration constants declared here.  */
4772           if (TREE_CODE (parm) == PARM_DECL)
4773             {
4774               /* Barf if the parameter itself has an incomplete type.  */
4775               tree type = TREE_VALUE (typelt);
4776               if (TYPE_SIZE (type) == 0)
4777                 {
4778                   if (funcdef_flag && DECL_NAME (parm) != 0)
4779                     error ("parameter `%s' has incomplete type",
4780                            IDENTIFIER_POINTER (DECL_NAME (parm)));
4781                   else
4782                     warning ("parameter has incomplete type");
4783                   if (funcdef_flag)
4784                     {
4785                       TREE_VALUE (typelt) = error_mark_node;
4786                       TREE_TYPE (parm) = error_mark_node;
4787                     }
4788                 }
4789 #if 0  /* This has been replaced by parm_tags_warning
4790           which uses a more accurate criterion for what to warn about.  */
4791               else
4792                 {
4793                   /* Now warn if is a pointer to an incomplete type.  */
4794                   while (TREE_CODE (type) == POINTER_TYPE
4795                          || TREE_CODE (type) == REFERENCE_TYPE)
4796                     type = TREE_TYPE (type);
4797                   type = TYPE_MAIN_VARIANT (type);
4798                   if (TYPE_SIZE (type) == 0)
4799                     {
4800                       if (DECL_NAME (parm) != 0)
4801                         warning ("parameter `%s' points to incomplete type",
4802                                  IDENTIFIER_POINTER (DECL_NAME (parm)));
4803                       else
4804                         warning ("parameter points to incomplete type");
4805                     }
4806                 }
4807 #endif
4808               typelt = TREE_CHAIN (typelt);
4809             }
4810
4811       /* Allocate the list of types the way we allocate a type.  */
4812       if (first_parm && ! TREE_PERMANENT (first_parm))
4813         {
4814           /* Construct a copy of the list of types
4815              on the saveable obstack.  */
4816           tree result = NULL;
4817           for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt))
4818             result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt),
4819                                          result);
4820           return nreverse (result);
4821         }
4822       else
4823         /* The list we have is permanent already.  */
4824         return first_parm;
4825     }
4826 }
4827
4828
4829 /* Return a tree_list node with info on a parameter list just parsed.
4830    The TREE_PURPOSE is a chain of decls of those parms.
4831    The TREE_VALUE is a list of structure, union and enum tags defined.
4832    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4833    This tree_list node is later fed to `grokparms'.
4834
4835    VOID_AT_END nonzero means append `void' to the end of the type-list.
4836    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
4837
4838 tree
4839 get_parm_info (void_at_end)
4840      int void_at_end;
4841 {
4842   register tree decl, t;
4843   register tree types = 0;
4844   int erred = 0;
4845   tree tags = gettags ();
4846   tree parms = getdecls ();
4847   tree new_parms = 0;
4848   tree order = current_binding_level->parm_order;
4849
4850   /* Just `void' (and no ellipsis) is special.  There are really no parms.  */
4851   if (void_at_end && parms != 0
4852       && TREE_CHAIN (parms) == 0
4853       && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
4854       && DECL_NAME (parms) == 0)
4855     {
4856       parms = NULL_TREE;
4857       storedecls (NULL_TREE);
4858       return saveable_tree_cons (NULL_TREE, NULL_TREE,
4859                                  saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
4860     }
4861
4862   /* Extract enumerator values and other non-parms declared with the parms.
4863      Likewise any forward parm decls that didn't have real parm decls.  */
4864   for (decl = parms; decl; )
4865     {
4866       tree next = TREE_CHAIN (decl);
4867
4868       if (TREE_CODE (decl) != PARM_DECL)
4869         {
4870           TREE_CHAIN (decl) = new_parms;
4871           new_parms = decl;
4872         }
4873       else if (TREE_ASM_WRITTEN (decl))
4874         {
4875           error_with_decl (decl, "parameter `%s' has just a forward declaration");
4876           TREE_CHAIN (decl) = new_parms;
4877           new_parms = decl;
4878         }
4879       decl = next;
4880     }
4881
4882   /* Put the parm decls back in the order they were in in the parm list.  */
4883   for (t = order; t; t = TREE_CHAIN (t))
4884     {
4885       if (TREE_CHAIN (t))
4886         TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
4887       else
4888         TREE_CHAIN (TREE_VALUE (t)) = 0;
4889     }
4890
4891   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
4892                        new_parms);
4893
4894   /* Store the parmlist in the binding level since the old one
4895      is no longer a valid list.  (We have changed the chain pointers.)  */
4896   storedecls (new_parms);
4897
4898   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
4899     /* There may also be declarations for enumerators if an enumeration
4900        type is declared among the parms.  Ignore them here.  */
4901     if (TREE_CODE (decl) == PARM_DECL)
4902       {
4903         /* Since there is a prototype,
4904            args are passed in their declared types.  */
4905         tree type = TREE_TYPE (decl);
4906         DECL_ARG_TYPE (decl) = type;
4907 #ifdef PROMOTE_PROTOTYPES
4908         if ((TREE_CODE (type) == INTEGER_TYPE
4909              || TREE_CODE (type) == ENUMERAL_TYPE)
4910             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4911           DECL_ARG_TYPE (decl) = integer_type_node;
4912 #endif
4913
4914         types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
4915         if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
4916             && DECL_NAME (decl) == 0)
4917           {
4918             error ("`void' in parameter list must be the entire list");
4919             erred = 1;
4920           }
4921       }
4922
4923   if (void_at_end)
4924     return saveable_tree_cons (new_parms, tags,
4925                                nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
4926
4927   return saveable_tree_cons (new_parms, tags, nreverse (types));
4928 }
4929
4930 /* At end of parameter list, warn about any struct, union or enum tags
4931    defined within.  Do so because these types cannot ever become complete.  */
4932
4933 void
4934 parmlist_tags_warning ()
4935 {
4936   tree elt;
4937   static int already;
4938
4939   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
4940     {
4941       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
4942       /* An anonymous union parm type is meaningful as a GNU extension.
4943          So don't warn for that.  */
4944       if (code == UNION_TYPE && !pedantic)
4945         continue;
4946       if (TREE_PURPOSE (elt) != 0)
4947         warning ("`%s %s' declared inside parameter list",
4948                  (code == RECORD_TYPE ? "struct"
4949                   : code == UNION_TYPE ? "union"
4950                   : "enum"),
4951                  IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4952       else
4953         warning ("anonymous %s declared inside parameter list",
4954                  (code == RECORD_TYPE ? "struct"
4955                   : code == UNION_TYPE ? "union"
4956                   : "enum"));
4957
4958       if (! already)
4959         {
4960           warning ("its scope is only this definition or declaration,");
4961           warning ("which is probably not what you want.");
4962           already = 1;
4963         }
4964     }
4965 }
4966 \f
4967 /* Get the struct, enum or union (CODE says which) with tag NAME.
4968    Define the tag as a forward-reference if it is not defined.  */
4969
4970 tree
4971 xref_tag (code, name)
4972      enum tree_code code;
4973      tree name;
4974 {
4975   int temporary = allocation_temporary_p ();
4976
4977   /* If a cross reference is requested, look up the type
4978      already defined for this tag and return it.  */
4979
4980   register tree ref = lookup_tag (code, name, current_binding_level, 0);
4981   /* Even if this is the wrong type of tag, return what we found.
4982      There will be an error message anyway, from pending_xref_error.
4983      If we create an empty xref just for an invalid use of the type,
4984      the main result is to create lots of superfluous error messages.  */
4985   if (ref)
4986     return ref;
4987
4988   push_obstacks_nochange ();
4989
4990   if (current_binding_level == global_binding_level && temporary)
4991     end_temporary_allocation ();
4992
4993   /* If no such tag is yet defined, create a forward-reference node
4994      and record it as the "definition".
4995      When a real declaration of this type is found,
4996      the forward-reference will be altered into a real type.  */
4997
4998   ref = make_node (code);
4999   if (code == ENUMERAL_TYPE)
5000     {
5001       /* (In ANSI, Enums can be referred to only if already defined.)  */
5002       if (pedantic)
5003         pedwarn ("ANSI C forbids forward references to `enum' types");
5004       /* Give the type a default layout like unsigned int
5005          to avoid crashing if it does not get defined.  */
5006       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5007       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5008       TREE_UNSIGNED (ref) = 1;
5009       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5010       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5011       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5012     }
5013
5014   pushtag (name, ref);
5015
5016   pop_obstacks ();
5017
5018   return ref;
5019 }
5020 \f
5021 /* Make sure that the tag NAME is defined *in the current binding level*
5022    at least as a forward reference.
5023    CODE says which kind of tag NAME ought to be.
5024
5025    We also do a push_obstacks_nochange
5026    whose matching pop is in finish_struct.  */
5027
5028 tree
5029 start_struct (code, name)
5030      enum tree_code code;
5031      tree name;
5032 {
5033   /* If there is already a tag defined at this binding level
5034      (as a forward reference), just return it.  */
5035
5036   register tree ref = 0;
5037
5038   push_obstacks_nochange ();
5039   if (current_binding_level == global_binding_level)
5040     end_temporary_allocation ();
5041
5042   if (name != 0)
5043     ref = lookup_tag (code, name, current_binding_level, 1);
5044   if (ref && TREE_CODE (ref) == code)
5045     {
5046       C_TYPE_BEING_DEFINED (ref) = 1;
5047       if (TYPE_FIELDS (ref))
5048         error ((code == UNION_TYPE ? "redefinition of `union %s'"
5049                 : "redefinition of `struct %s'"),
5050                IDENTIFIER_POINTER (name));
5051
5052       return ref;
5053     }
5054
5055   /* Otherwise create a forward-reference just so the tag is in scope.  */
5056
5057   ref = make_node (code);
5058   pushtag (name, ref);
5059   C_TYPE_BEING_DEFINED (ref) = 1;
5060   return ref;
5061 }
5062
5063 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5064    of a structure component, returning a FIELD_DECL node.
5065    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5066
5067    This is done during the parsing of the struct declaration.
5068    The FIELD_DECL nodes are chained together and the lot of them
5069    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
5070
5071 tree
5072 grokfield (filename, line, declarator, declspecs, width)
5073      char *filename;
5074      int line;
5075      tree declarator, declspecs, width;
5076 {
5077   tree value;
5078
5079   /* The corresponding pop_obstacks is in finish_decl.  */
5080   push_obstacks_nochange ();
5081
5082   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5083
5084   finish_decl (value, NULL_TREE, NULL_TREE);
5085   DECL_INITIAL (value) = width;
5086
5087   maybe_objc_check_decl (value);
5088   return value;
5089 }
5090 \f
5091 /* Function to help qsort sort FIELD_DECLs by name order.  */
5092
5093 static int
5094 field_decl_cmp (x, y)
5095      tree *x, *y;
5096 {
5097   return (long)DECL_NAME (*x) - (long)DECL_NAME (*y);
5098 }
5099
5100 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5101    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5102
5103    We also do a pop_obstacks to match the push in start_struct.  */
5104
5105 tree
5106 finish_struct (t, fieldlist)
5107      register tree t, fieldlist;
5108 {
5109   register tree x;
5110   int old_momentary;
5111   int toplevel = global_binding_level == current_binding_level;
5112
5113   /* If this type was previously laid out as a forward reference,
5114      make sure we lay it out again.  */
5115
5116   TYPE_SIZE (t) = 0;
5117
5118   /* Nameless union parm types are useful as GCC extension.  */
5119   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5120     /* Otherwise, warn about any struct or union def. in parmlist.  */
5121     if (in_parm_level_p ())
5122       {
5123         if (pedantic)
5124           pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5125                     : "structure defined inside parms"));
5126         else if (! flag_traditional)
5127           warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5128                     : "structure defined inside parms"));
5129       }
5130
5131   old_momentary = suspend_momentary ();
5132
5133   if (fieldlist == 0 && pedantic)
5134     pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union has no members"
5135               : "structure has no members"));
5136
5137   /* Install struct as DECL_CONTEXT of each field decl.
5138      Also process specified field sizes.
5139      Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
5140      The specified size is found in the DECL_INITIAL.
5141      Store 0 there, except for ": 0" fields (so we can find them
5142      and delete them, below).  */
5143
5144   for (x = fieldlist; x; x = TREE_CHAIN (x))
5145     {
5146       DECL_CONTEXT (x) = t;
5147       DECL_FIELD_SIZE (x) = 0;
5148
5149       /* If any field is const, the structure type is pseudo-const.  */
5150       if (TREE_READONLY (x))
5151         C_TYPE_FIELDS_READONLY (t) = 1;
5152       else
5153         {
5154           /* A field that is pseudo-const makes the structure likewise.  */
5155           tree t1 = TREE_TYPE (x);
5156           while (TREE_CODE (t1) == ARRAY_TYPE)
5157             t1 = TREE_TYPE (t1);
5158           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5159               && C_TYPE_FIELDS_READONLY (t1))
5160             C_TYPE_FIELDS_READONLY (t) = 1;
5161         }
5162
5163       /* Any field that is volatile means variables of this type must be
5164          treated in some ways as volatile.  */
5165       if (TREE_THIS_VOLATILE (x))
5166         C_TYPE_FIELDS_VOLATILE (t) = 1;
5167
5168       /* Any field of nominal variable size implies structure is too.  */
5169       if (C_DECL_VARIABLE_SIZE (x))
5170         C_TYPE_VARIABLE_SIZE (t) = 1;
5171
5172       /* Detect invalid nested redefinition.  */
5173       if (TREE_TYPE (x) == t)
5174         error ("nested redefinition of `%s'",
5175                IDENTIFIER_POINTER (TYPE_NAME (t)));
5176
5177       /* Detect invalid bit-field size.  */
5178       if (DECL_INITIAL (x))
5179         STRIP_NOPS (DECL_INITIAL (x));
5180       if (DECL_INITIAL (x))
5181         {
5182           if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5183             constant_expression_warning (DECL_INITIAL (x));
5184           else
5185             {
5186               error_with_decl (x, "bit-field `%s' width not an integer constant");
5187               DECL_INITIAL (x) = NULL;
5188             }
5189         }
5190
5191       /* Detect invalid bit-field type.  */
5192       if (DECL_INITIAL (x)
5193           && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5194           && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5195         {
5196           error_with_decl (x, "bit-field `%s' has invalid type");
5197           DECL_INITIAL (x) = NULL;
5198         }
5199       if (DECL_INITIAL (x) && pedantic
5200           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5201           && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5202           /* Accept an enum that's equivalent to int or unsigned int.  */
5203           && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5204                && (TYPE_PRECISION (TREE_TYPE (x))
5205                    == TYPE_PRECISION (integer_type_node))))
5206         pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
5207
5208       /* Detect and ignore out of range field width.  */
5209       if (DECL_INITIAL (x))
5210         {
5211           unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5212
5213           if (tree_int_cst_lt (DECL_INITIAL (x), integer_zero_node))
5214             {
5215               DECL_INITIAL (x) = NULL;
5216               error_with_decl (x, "negative width in bit-field `%s'");
5217             }
5218           else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
5219                    || width > TYPE_PRECISION (TREE_TYPE (x)))
5220             {
5221               DECL_INITIAL (x) = NULL;
5222               pedwarn_with_decl (x, "width of `%s' exceeds its type");
5223             }
5224           else if (width == 0 && DECL_NAME (x) != 0)
5225             {
5226               error_with_decl (x, "zero width for bit-field `%s'");
5227               DECL_INITIAL (x) = NULL;
5228             }
5229         }
5230
5231       /* Process valid field width.  */
5232       if (DECL_INITIAL (x))
5233         {
5234           register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5235
5236           DECL_FIELD_SIZE (x) = width;
5237           DECL_BIT_FIELD (x) = 1;
5238           DECL_INITIAL (x) = NULL;
5239
5240           if (width == 0)
5241             {
5242               /* field size 0 => force desired amount of alignment.  */
5243 #ifdef EMPTY_FIELD_BOUNDARY
5244               DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5245 #endif
5246 #ifdef PCC_BITFIELD_TYPE_MATTERS
5247               DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5248                                     TYPE_ALIGN (TREE_TYPE (x)));
5249 #endif
5250             }
5251         }
5252       else
5253         {
5254           int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5255                            : TYPE_ALIGN (TREE_TYPE (x)));
5256           /* Non-bit-fields are aligned for their type, except packed
5257              fields which require only BITS_PER_UNIT alignment.  */
5258           DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5259         }
5260     }
5261
5262   /* Now DECL_INITIAL is null on all members.  */
5263
5264   /* Delete all duplicate fields from the fieldlist */
5265   for (x = fieldlist; x && TREE_CHAIN (x);)
5266     /* Anonymous fields aren't duplicates.  */
5267     if (DECL_NAME (TREE_CHAIN (x)) == 0)
5268       x = TREE_CHAIN (x);
5269     else
5270       {
5271         register tree y = fieldlist;
5272
5273         while (1)
5274           {
5275             if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5276               break;
5277             if (y == x)
5278               break;
5279             y = TREE_CHAIN (y);
5280           }
5281         if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5282           {
5283             error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5284             TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5285           }
5286         else x = TREE_CHAIN (x);
5287       }
5288
5289   /* Now we have the nearly final fieldlist.  Record it,
5290      then lay out the structure or union (including the fields).  */
5291
5292   TYPE_FIELDS (t) = fieldlist;
5293
5294   layout_type (t);
5295
5296   /* Delete all zero-width bit-fields from the front of the fieldlist */
5297   while (fieldlist
5298          && DECL_INITIAL (fieldlist))
5299     fieldlist = TREE_CHAIN (fieldlist);
5300   /* Delete all such members from the rest of the fieldlist */
5301   for (x = fieldlist; x;)
5302     {
5303       if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
5304         TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5305       else x = TREE_CHAIN (x);
5306     }
5307
5308   /*  Now we have the truly final field list.
5309       Store it in this type and in the variants.  */
5310
5311   TYPE_FIELDS (t) = fieldlist;
5312
5313   /* If there are lots of fields, sort so we can look through them fast.
5314      We arbitrarily consider 16 or more elts to be "a lot".  */
5315   {
5316     int len = 0;
5317
5318     for (x = fieldlist; x; x = TREE_CHAIN (x))
5319       {
5320         if (len > 15)
5321           break;
5322         len += 1;
5323       }
5324     if (len > 15)
5325       {
5326         tree *field_array;
5327         char *space;
5328
5329         len += list_length (x);
5330         /* Use the same allocation policy here that make_node uses, to
5331            ensure that this lives as long as the rest of the struct decl.
5332            All decls in an inline function need to be saved.  */
5333         if (allocation_temporary_p ())
5334           space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
5335         else
5336           space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
5337
5338         TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
5339         TYPE_LANG_SPECIFIC (t)->len = len;
5340
5341         field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
5342         len = 0;
5343         for (x = fieldlist; x; x = TREE_CHAIN (x))
5344           field_array[len++] = x;
5345
5346         qsort (field_array, len, sizeof (tree), field_decl_cmp);
5347       }
5348   }
5349
5350   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5351     {
5352       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5353       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5354       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5355     }
5356
5357   /* Promote each bit-field's type to int if it is narrower than that.  */
5358   for (x = fieldlist; x; x = TREE_CHAIN (x))
5359     if (DECL_BIT_FIELD (x)
5360         && (C_PROMOTING_INTEGER_TYPE_P (TREE_TYPE (x))
5361             || DECL_FIELD_SIZE (x) < TYPE_PRECISION (integer_type_node)))
5362       {
5363         tree type = TREE_TYPE (x);
5364
5365         /* Preserve unsignedness if traditional
5366            or if not really getting any wider.  */
5367         if (TREE_UNSIGNED (type)
5368             && (flag_traditional
5369                 ||
5370                 (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
5371                  &&
5372                  DECL_FIELD_SIZE (x) == TYPE_PRECISION (integer_type_node))))
5373           TREE_TYPE (x) = unsigned_type_node;
5374         else
5375           TREE_TYPE (x) = integer_type_node;
5376       }
5377
5378   /* If this structure or union completes the type of any previous
5379      variable declaration, lay it out and output its rtl.  */
5380
5381   if (current_binding_level->n_incomplete != 0)
5382     {
5383       tree decl;
5384       for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5385         {
5386           if (TREE_TYPE (decl) == t
5387               && TREE_CODE (decl) != TYPE_DECL)
5388             {
5389               layout_decl (decl, 0);
5390               /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
5391               maybe_objc_check_decl (decl);
5392               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
5393               if (! toplevel)
5394                 expand_decl (decl);
5395               --current_binding_level->n_incomplete;
5396             }
5397           else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
5398                    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5399             {
5400               tree element = TREE_TYPE (decl);
5401               while (TREE_CODE (element) == ARRAY_TYPE)
5402                 element = TREE_TYPE (element);
5403               if (element == t)
5404                 layout_array_type (TREE_TYPE (decl));
5405             }
5406         }
5407     }
5408
5409   resume_momentary (old_momentary);
5410
5411   /* Finish debugging output for this type.  */
5412   rest_of_type_compilation (t, toplevel);
5413
5414   /* The matching push is in start_struct.  */
5415   pop_obstacks ();
5416
5417   return t;
5418 }
5419
5420 /* Lay out the type T, and its element type, and so on.  */
5421
5422 static void
5423 layout_array_type (t)
5424      tree t;
5425 {
5426   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5427     layout_array_type (TREE_TYPE (t));
5428   layout_type (t);
5429 }
5430 \f
5431 /* Begin compiling the definition of an enumeration type.
5432    NAME is its name (or null if anonymous).
5433    Returns the type object, as yet incomplete.
5434    Also records info about it so that build_enumerator
5435    may be used to declare the individual values as they are read.  */
5436
5437 tree
5438 start_enum (name)
5439      tree name;
5440 {
5441   register tree enumtype = 0;
5442
5443   /* If this is the real definition for a previous forward reference,
5444      fill in the contents in the same object that used to be the
5445      forward reference.  */
5446
5447   if (name != 0)
5448     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5449
5450   /* The corresponding pop_obstacks is in finish_enum.  */
5451   push_obstacks_nochange ();
5452   /* If these symbols and types are global, make them permanent.  */
5453   if (current_binding_level == global_binding_level)
5454     end_temporary_allocation ();
5455
5456   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5457     {
5458       enumtype = make_node (ENUMERAL_TYPE);
5459       pushtag (name, enumtype);
5460     }
5461
5462   C_TYPE_BEING_DEFINED (enumtype) = 1;
5463
5464   if (TYPE_VALUES (enumtype) != 0)
5465     {
5466       /* This enum is a named one that has been declared already.  */
5467       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5468
5469       /* Completely replace its old definition.
5470          The old enumerators remain defined, however.  */
5471       TYPE_VALUES (enumtype) = 0;
5472     }
5473
5474   enum_next_value = integer_zero_node;
5475   enum_overflow = 0;
5476
5477   return enumtype;
5478 }
5479
5480 /* After processing and defining all the values of an enumeration type,
5481    install their decls in the enumeration type and finish it off.
5482    ENUMTYPE is the type object and VALUES a list of decl-value pairs.
5483    Returns ENUMTYPE.  */
5484
5485 tree
5486 finish_enum (enumtype, values)
5487      register tree enumtype, values;
5488 {
5489   register tree pair, tem;
5490   tree minnode = 0, maxnode = 0;
5491   register HOST_WIDE_INT maxvalue = 0;
5492   register HOST_WIDE_INT minvalue = 0;
5493   register int i;
5494   unsigned precision = 0;
5495   int toplevel = global_binding_level == current_binding_level;
5496   int temporary = allocation_temporary_p ();
5497
5498   if (in_parm_level_p ())
5499     warning ("enum defined inside parms");
5500
5501   /* Calculate the maximum value of any enumerator in this type.  */
5502
5503   for (pair = values; pair; pair = TREE_CHAIN (pair))
5504     {
5505       tree value = TREE_VALUE (pair);
5506       if (pair == values)
5507         minnode = maxnode = TREE_VALUE (pair);
5508       else
5509         {
5510           if (tree_int_cst_lt (maxnode, value))
5511             maxnode = value;
5512           if (tree_int_cst_lt (value, minnode))
5513             minnode = value;
5514         }
5515     }
5516
5517   TYPE_MIN_VALUE (enumtype) = minnode;
5518   TYPE_MAX_VALUE (enumtype) = maxnode;
5519
5520   /* Determine the precision this type needs.  */
5521
5522   if (TREE_INT_CST_HIGH (minnode) >= 0
5523       ? tree_int_cst_lt (TYPE_MAX_VALUE (unsigned_type_node), maxnode)
5524       : (tree_int_cst_lt (minnode, TYPE_MIN_VALUE (integer_type_node))
5525          || tree_int_cst_lt (TYPE_MAX_VALUE (integer_type_node), maxnode)))
5526     precision = TYPE_PRECISION (long_long_integer_type_node);
5527   else
5528     {
5529       maxvalue = TREE_INT_CST_LOW (maxnode);
5530       minvalue = TREE_INT_CST_LOW (minnode);
5531
5532       if (maxvalue > 0)
5533         precision = floor_log2 (maxvalue) + 1;
5534       if (minvalue < 0)
5535         {
5536           /* Compute number of bits to represent magnitude of a negative value.
5537              Add one to MINVALUE since range of negative numbers
5538              includes the power of two.  */
5539           unsigned negprecision = floor_log2 (-minvalue - 1) + 1;
5540           if (negprecision > precision)
5541             precision = negprecision;
5542           precision += 1;       /* room for sign bit */
5543         }
5544
5545       if (!precision)
5546         precision = 1;
5547     }
5548
5549   if (flag_short_enums || precision > TYPE_PRECISION (integer_type_node))
5550     /* Use the width of the narrowest normal C type which is wide enough.  */
5551     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1));
5552   else
5553     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
5554
5555   TYPE_SIZE (enumtype) = 0;
5556   layout_type (enumtype);
5557
5558   /* An enum can have some negative values; then it is signed.  */
5559   TREE_UNSIGNED (enumtype) = ! tree_int_cst_lt (minnode, integer_zero_node);
5560
5561   /* Change the type of the enumerators to be the enum type.
5562      Formerly this was done only for enums that fit in an int,
5563      but the comment said it was done only for enums wider than int.
5564      It seems necessary to do this for wide enums,
5565      and best not to change what's done for ordinary narrower ones.  */
5566   for (pair = values; pair; pair = TREE_CHAIN (pair))
5567     {
5568       TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
5569       DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
5570       if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL)
5571         DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
5572     }
5573
5574   /* Replace the decl nodes in VALUES with their names.  */
5575   for (pair = values; pair; pair = TREE_CHAIN (pair))
5576     TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
5577
5578   TYPE_VALUES (enumtype) = values;
5579
5580   /* Fix up all variant types of this enum type.  */
5581   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5582     {
5583       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5584       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5585       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5586       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5587       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5588       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5589       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5590       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5591     }
5592
5593   /* Finish debugging output for this type.  */
5594   rest_of_type_compilation (enumtype, toplevel);
5595
5596   /* This matches a push in start_enum.  */
5597   pop_obstacks ();
5598
5599   return enumtype;
5600 }
5601
5602 /* Build and install a CONST_DECL for one value of the
5603    current enumeration type (one that was begun with start_enum).
5604    Return a tree-list containing the CONST_DECL and its value.
5605    Assignment of sequential values by default is handled here.  */
5606
5607 tree
5608 build_enumerator (name, value)
5609      tree name, value;
5610 {
5611   register tree decl, type;
5612
5613   /* Validate and default VALUE.  */
5614
5615   /* Remove no-op casts from the value.  */
5616   if (value)
5617     STRIP_TYPE_NOPS (value);
5618
5619   if (value != 0)
5620     {
5621       if (TREE_CODE (value) == INTEGER_CST)
5622         {
5623           value = default_conversion (value);
5624           constant_expression_warning (value);
5625         }
5626       else
5627         {
5628           error ("enumerator value for `%s' not integer constant",
5629                  IDENTIFIER_POINTER (name));
5630           value = 0;
5631         }
5632     }
5633
5634   /* Default based on previous value.  */
5635   /* It should no longer be possible to have NON_LVALUE_EXPR
5636      in the default.  */
5637   if (value == 0)
5638     {
5639       value = enum_next_value;
5640       if (enum_overflow)
5641         error ("overflow in enumeration values");
5642     }
5643
5644   if (pedantic && ! int_fits_type_p (value, integer_type_node))
5645     {
5646       pedwarn ("ANSI C restricts enumerator values to range of `int'");
5647       value = integer_zero_node;
5648     }
5649
5650   /* Set basis for default for next value.  */
5651   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5652   enum_overflow = tree_int_cst_lt (enum_next_value, value);
5653
5654   /* Now create a declaration for the enum value name.  */
5655
5656   type = TREE_TYPE (value);
5657   type = type_for_size (MAX (TYPE_PRECISION (type),
5658                              TYPE_PRECISION (integer_type_node)),
5659                         ((flag_traditional
5660                           || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
5661                          && TREE_UNSIGNED (type)));
5662
5663   decl = build_decl (CONST_DECL, name, type);
5664   DECL_INITIAL (decl) = value;
5665   TREE_TYPE (value) = type;
5666   pushdecl (decl);
5667
5668   return saveable_tree_cons (decl, value, NULL_TREE);
5669 }
5670 \f
5671 /* Create the FUNCTION_DECL for a function definition.
5672    DECLSPECS and DECLARATOR are the parts of the declaration;
5673    they describe the function's name and the type it returns,
5674    but twisted together in a fashion that parallels the syntax of C.
5675
5676    This function creates a binding context for the function body
5677    as well as setting up the FUNCTION_DECL in current_function_decl.
5678
5679    Returns 1 on success.  If the DECLARATOR is not suitable for a function
5680    (it defines a datum instead), we return 0, which tells
5681    yyparse to report a parse error.
5682
5683    NESTED is nonzero for a function nested within another function.  */
5684
5685 int
5686 start_function (declspecs, declarator, nested)
5687      tree declarator, declspecs;
5688      int nested;
5689 {
5690   tree decl1, old_decl;
5691   tree restype;
5692
5693   current_function_returns_value = 0;  /* Assume, until we see it does. */
5694   current_function_returns_null = 0;
5695   warn_about_return_type = 0;
5696   current_extern_inline = 0;
5697   c_function_varargs = 0;
5698   named_labels = 0;
5699   shadowed_labels = 0;
5700
5701   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5702
5703   /* If the declarator is not suitable for a function definition,
5704      cause a syntax error.  */
5705   if (decl1 == 0)
5706     return 0;
5707
5708   announce_function (decl1);
5709
5710   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
5711     {
5712       error ("return-type is an incomplete type");
5713       /* Make it return void instead.  */
5714       TREE_TYPE (decl1)
5715         = build_function_type (void_type_node,
5716                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5717     }
5718
5719   if (warn_about_return_type)
5720     warning ("return-type defaults to `int'");
5721
5722   /* Save the parm names or decls from this function's declarator
5723      where store_parm_decls will find them.  */
5724   current_function_parms = last_function_parms;
5725   current_function_parm_tags = last_function_parm_tags;
5726
5727   /* Make the init_value nonzero so pushdecl knows this is not tentative.
5728      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
5729   DECL_INITIAL (decl1) = error_mark_node;
5730
5731   /* If this definition isn't a prototype and we had a prototype declaration
5732      before, copy the arg type info from that prototype.
5733      But not if what we had before was a builtin function.  */
5734   old_decl = lookup_name_current_level (DECL_NAME (decl1));
5735   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5736       && !DECL_BUILT_IN (old_decl)
5737       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5738           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5739       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5740     {
5741       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5742       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
5743       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
5744     }
5745
5746   /* Optionally warn of old-fashioned def with no previous prototype.  */
5747   if (warn_strict_prototypes
5748       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5749       && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
5750     warning ("function declaration isn't a prototype");
5751   /* Optionally warn of any global def with no previous prototype.  */
5752   else if (warn_missing_prototypes
5753            && TREE_PUBLIC (decl1)
5754            && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
5755            && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
5756     warning_with_decl (decl1, "no previous prototype for `%s'");
5757   /* Optionally warn of any def with no previous prototype
5758      if the function has already been used.  */
5759   else if (warn_missing_prototypes
5760            && old_decl != 0 && TREE_USED (old_decl)
5761            && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
5762     warning_with_decl (decl1, "`%s' was used with no prototype before its definition");
5763
5764   /* This is a definition, not a reference.
5765      So normally clear DECL_EXTERNAL.
5766      However, `extern inline' acts like a declaration
5767      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
5768   DECL_EXTERNAL (decl1) = current_extern_inline;
5769
5770   /* This function exists in static storage.
5771      (This does not mean `static' in the C sense!)  */
5772   TREE_STATIC (decl1) = 1;
5773
5774   /* A nested function is not global.  */
5775   if (current_function_decl != 0)
5776     TREE_PUBLIC (decl1) = 0;
5777
5778   /* Record the decl so that the function name is defined.
5779      If we already have a decl for this name, and it is a FUNCTION_DECL,
5780      use the old decl.  */
5781
5782   current_function_decl = pushdecl (decl1);
5783
5784   pushlevel (0);
5785   declare_parm_level (1);
5786   current_binding_level->subblocks_tag_transparent = 1;
5787
5788   make_function_rtl (current_function_decl);
5789
5790   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
5791   /* Promote the value to int before returning it.  */
5792   if (C_PROMOTING_INTEGER_TYPE_P (restype))
5793     {
5794       /* It retains unsignedness if traditional
5795          or if not really getting wider.  */
5796       if (TREE_UNSIGNED (restype)
5797           && (flag_traditional
5798               || (TYPE_PRECISION (restype)
5799                   == TYPE_PRECISION (integer_type_node))))
5800         restype = unsigned_type_node;
5801       else
5802         restype = integer_type_node;
5803     }
5804   DECL_RESULT (current_function_decl)
5805     = build_decl (RESULT_DECL, NULL_TREE, restype);
5806
5807   if (!nested)
5808     /* Allocate further tree nodes temporarily during compilation
5809        of this function only.  */
5810     temporary_allocation ();
5811
5812   /* If this fcn was already referenced via a block-scope `extern' decl
5813      (or an implicit decl), propagate certain information about the usage.  */
5814   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
5815     TREE_ADDRESSABLE (current_function_decl) = 1;
5816
5817   return 1;
5818 }
5819
5820 /* Record that this function is going to be a varargs function.
5821    This is called before store_parm_decls, which is too early
5822    to call mark_varargs directly.  */
5823
5824 void
5825 c_mark_varargs ()
5826 {
5827   c_function_varargs = 1;
5828 }
5829 \f
5830 /* Store the parameter declarations into the current function declaration.
5831    This is called after parsing the parameter declarations, before
5832    digesting the body of the function.
5833
5834    For an old-style definition, modify the function's type
5835    to specify at least the number of arguments.  */
5836
5837 void
5838 store_parm_decls ()
5839 {
5840   register tree fndecl = current_function_decl;
5841   register tree parm;
5842
5843   /* This is either a chain of PARM_DECLs (if a prototype was used)
5844      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
5845   tree specparms = current_function_parms;
5846
5847   /* This is a list of types declared among parms in a prototype.  */
5848   tree parmtags = current_function_parm_tags;
5849
5850   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
5851   register tree parmdecls = getdecls ();
5852
5853   /* This is a chain of any other decls that came in among the parm
5854      declarations.  If a parm is declared with  enum {foo, bar} x;
5855      then CONST_DECLs for foo and bar are put here.  */
5856   tree nonparms = 0;
5857
5858   /* Nonzero if this definition is written with a prototype.  */
5859   int prototype = 0;
5860
5861   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
5862     {
5863       /* This case is when the function was defined with an ANSI prototype.
5864          The parms already have decls, so we need not do anything here
5865          except record them as in effect
5866          and complain if any redundant old-style parm decls were written.  */
5867
5868       register tree next;
5869       tree others = 0;
5870
5871       prototype = 1;
5872
5873       if (parmdecls != 0)
5874         {
5875           tree decl, link;
5876
5877           error_with_decl (fndecl,
5878                            "parm types given both in parmlist and separately");
5879           /* Get rid of the erroneous decls; don't keep them on
5880              the list of parms, since they might not be PARM_DECLs.  */
5881           for (decl = current_binding_level->names;
5882                decl; decl = TREE_CHAIN (decl))
5883             if (DECL_NAME (decl))
5884               IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
5885           for (link = current_binding_level->shadowed;
5886                link; link = TREE_CHAIN (link))
5887             IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
5888           current_binding_level->names = 0;
5889           current_binding_level->shadowed = 0;
5890         }
5891
5892       specparms = nreverse (specparms);
5893       for (parm = specparms; parm; parm = next)
5894         {
5895           next = TREE_CHAIN (parm);
5896           if (TREE_CODE (parm) == PARM_DECL)
5897             {
5898               if (DECL_NAME (parm) == 0)
5899                 error_with_decl (parm, "parameter name omitted");
5900               else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
5901                 {
5902                   error_with_decl (parm, "parameter `%s' declared void");
5903                   /* Change the type to error_mark_node so this parameter
5904                      will be ignored by assign_parms.  */
5905                   TREE_TYPE (parm) = error_mark_node;
5906                 }
5907               pushdecl (parm);
5908             }
5909           else
5910             {
5911               /* If we find an enum constant or a type tag,
5912                  put it aside for the moment.  */
5913               TREE_CHAIN (parm) = 0;
5914               others = chainon (others, parm);
5915             }
5916         }
5917
5918       /* Get the decls in their original chain order
5919          and record in the function.  */
5920       DECL_ARGUMENTS (fndecl) = getdecls ();
5921
5922 #if 0
5923       /* If this function takes a variable number of arguments,
5924          add a phony parameter to the end of the parm list,
5925          to represent the position of the first unnamed argument.  */
5926       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
5927           != void_type_node)
5928         {
5929           tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
5930           /* Let's hope the address of the unnamed parm
5931              won't depend on its type.  */
5932           TREE_TYPE (dummy) = integer_type_node;
5933           DECL_ARG_TYPE (dummy) = integer_type_node;
5934           DECL_ARGUMENTS (fndecl)
5935             = chainon (DECL_ARGUMENTS (fndecl), dummy);
5936         }
5937 #endif
5938
5939       /* Now pushdecl the enum constants.  */
5940       for (parm = others; parm; parm = next)
5941         {
5942           next = TREE_CHAIN (parm);
5943           if (DECL_NAME (parm) == 0)
5944             ;
5945           else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
5946             ;
5947           else if (TREE_CODE (parm) != PARM_DECL)
5948             pushdecl (parm);
5949         }
5950
5951       storetags (chainon (parmtags, gettags ()));
5952     }
5953   else
5954     {
5955       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
5956          each with a parm name as the TREE_VALUE.
5957
5958          PARMDECLS is a chain of declarations for parameters.
5959          Warning! It can also contain CONST_DECLs which are not parameters
5960          but are names of enumerators of any enum types
5961          declared among the parameters.
5962
5963          First match each formal parameter name with its declaration.
5964          Associate decls with the names and store the decls
5965          into the TREE_PURPOSE slots.  */
5966
5967       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
5968         DECL_RESULT (parm) = 0;
5969
5970       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
5971         {
5972           register tree tail, found = NULL;
5973
5974           if (TREE_VALUE (parm) == 0)
5975             {
5976               error_with_decl (fndecl, "parameter name missing from parameter list");
5977               TREE_PURPOSE (parm) = 0;
5978               continue;
5979             }
5980
5981           /* See if any of the parmdecls specifies this parm by name.
5982              Ignore any enumerator decls.  */
5983           for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
5984             if (DECL_NAME (tail) == TREE_VALUE (parm)
5985                 && TREE_CODE (tail) == PARM_DECL)
5986               {
5987                 found = tail;
5988                 break;
5989               }
5990
5991           /* If declaration already marked, we have a duplicate name.
5992              Complain, and don't use this decl twice.   */
5993           if (found && DECL_RESULT (found) != 0)
5994             {
5995               error_with_decl (found, "multiple parameters named `%s'");
5996               found = 0;
5997             }
5998
5999           /* If the declaration says "void", complain and ignore it.  */
6000           if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6001             {
6002               error_with_decl (found, "parameter `%s' declared void");
6003               TREE_TYPE (found) = integer_type_node;
6004               DECL_ARG_TYPE (found) = integer_type_node;
6005               layout_decl (found, 0);
6006             }
6007
6008           /* Traditionally, a parm declared float is actually a double.  */
6009           if (found && flag_traditional
6010               && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6011             {
6012               TREE_TYPE (found) = double_type_node;
6013               DECL_ARG_TYPE (found) = double_type_node;
6014               layout_decl (found, 0);
6015             }
6016
6017           /* If no declaration found, default to int.  */
6018           if (!found)
6019             {
6020               found = build_decl (PARM_DECL, TREE_VALUE (parm),
6021                                   integer_type_node);
6022               DECL_ARG_TYPE (found) = TREE_TYPE (found);
6023               DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6024               DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6025               if (extra_warnings)
6026                 warning_with_decl (found, "type of `%s' defaults to `int'");
6027               pushdecl (found);
6028             }
6029
6030           TREE_PURPOSE (parm) = found;
6031
6032           /* Mark this decl as "already found" -- see test, above.
6033              It is safe to use DECL_RESULT for this
6034              since it is not used in PARM_DECLs or CONST_DECLs.  */
6035           DECL_RESULT (found) = error_mark_node;
6036         }
6037
6038       /* Put anything which is on the parmdecls chain and which is
6039          not a PARM_DECL onto the list NONPARMS.  (The types of
6040          non-parm things which might appear on the list include
6041          enumerators and NULL-named TYPE_DECL nodes.) Complain about
6042          any actual PARM_DECLs not matched with any names.  */
6043
6044       nonparms = 0;
6045       for (parm = parmdecls; parm; )
6046         {
6047           tree next = TREE_CHAIN (parm);
6048           TREE_CHAIN (parm) = 0;
6049
6050           if (TREE_CODE (parm) != PARM_DECL)
6051             nonparms = chainon (nonparms, parm);
6052           else
6053             {
6054               /* Complain about args with incomplete types.  */
6055               if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6056                 {
6057                   error_with_decl (parm, "parameter `%s' has incomplete type");
6058                   TREE_TYPE (parm) = error_mark_node;
6059                 }
6060
6061               if (DECL_RESULT (parm) == 0)
6062                 {
6063                   error_with_decl (parm,
6064                                    "declaration for parameter `%s' but no such parameter");
6065                   /* Pretend the parameter was not missing.
6066                      This gets us to a standard state and minimizes
6067                      further error messages.  */
6068                   specparms
6069                     = chainon (specparms,
6070                                tree_cons (parm, NULL_TREE, NULL_TREE));
6071                 }
6072             }
6073
6074           parm = next;
6075         }
6076
6077       /* Chain the declarations together in the order of the list of names.  */
6078       /* Store that chain in the function decl, replacing the list of names.  */
6079       parm = specparms;
6080       DECL_ARGUMENTS (fndecl) = 0;
6081       {
6082         register tree last;
6083         for (last = 0; parm; parm = TREE_CHAIN (parm))
6084           if (TREE_PURPOSE (parm))
6085             {
6086               if (last == 0)
6087                 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6088               else
6089                 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6090               last = TREE_PURPOSE (parm);
6091               TREE_CHAIN (last) = 0;
6092             }
6093       }
6094
6095       /* If there was a previous prototype,
6096          set the DECL_ARG_TYPE of each argument according to
6097          the type previously specified, and report any mismatches.  */
6098
6099       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6100         {
6101           register tree type;
6102           for (parm = DECL_ARGUMENTS (fndecl),
6103                type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6104                parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6105                                  != void_type_node));
6106                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6107             {
6108               if (parm == 0 || type == 0
6109                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6110                 {
6111                   error ("number of arguments doesn't match prototype");
6112                   error_with_file_and_line (current_function_prototype_file,
6113                                             current_function_prototype_line,
6114                                             "prototype declaration");
6115                   break;
6116                 }
6117               /* Type for passing arg must be consistent
6118                  with that declared for the arg.  */
6119               if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6120                 {
6121                   if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6122                       == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6123                     {
6124                       /* Adjust argument to match prototype.  E.g. a previous
6125                          `int foo(float);' prototype causes
6126                          `int foo(x) float x; {...}' to be treated like
6127                          `int foo(float x) {...}'.  This is particularly
6128                          useful for argument types like uid_t.  */
6129                       DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6130 #ifdef PROMOTE_PROTOTYPES
6131                       if ((TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6132                            || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6133                           && TYPE_PRECISION (TREE_TYPE (parm))
6134                           < TYPE_PRECISION (integer_type_node))
6135                         DECL_ARG_TYPE (parm) = integer_type_node;
6136 #endif
6137                       if (pedantic)
6138                         {
6139                           pedwarn ("promoted argument `%s' doesn't match prototype",
6140                                    IDENTIFIER_POINTER (DECL_NAME (parm)));
6141                           warning_with_file_and_line
6142                             (current_function_prototype_file,
6143                              current_function_prototype_line,
6144                              "prototype declaration");
6145                         }
6146                     }
6147                   /* If -traditional, allow `int' argument to match
6148                      `unsigned' prototype.  */
6149                   else if (! (flag_traditional
6150                               && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6151                               && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6152                     {
6153                       error ("argument `%s' doesn't match prototype",
6154                              IDENTIFIER_POINTER (DECL_NAME (parm)));
6155                       error_with_file_and_line (current_function_prototype_file,
6156                                                 current_function_prototype_line,
6157                                                 "prototype declaration");
6158                     }
6159                 }
6160             }
6161           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6162         }
6163
6164       /* Otherwise, create a prototype that would match.  */
6165
6166       else
6167         {
6168           register tree actual, type;
6169           register tree last = 0;
6170
6171           for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6172             {
6173               type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm),
6174                                      NULL_TREE);
6175               if (last)
6176                 TREE_CHAIN (last) = type;
6177               else
6178                 actual = type;
6179               last = type;
6180             }
6181           type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6182           if (last)
6183             TREE_CHAIN (last) = type;
6184           else
6185             actual = type;
6186
6187           /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6188              of the type of this function, but we need to avoid having this
6189              affect the types of other similarly-typed functions, so we must
6190              first force the generation of an identical (but separate) type
6191              node for the relevant function type.  The new node we create
6192              will be a variant of the main variant of the original function
6193              type.  */
6194
6195           TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6196
6197           TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6198         }
6199
6200       /* Now store the final chain of decls for the arguments
6201          as the decl-chain of the current lexical scope.
6202          Put the enumerators in as well, at the front so that
6203          DECL_ARGUMENTS is not modified.  */
6204
6205       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6206     }
6207
6208   /* Make sure the binding level for the top of the function body
6209      gets a BLOCK if there are any in the function.
6210      Otherwise, the dbx output is wrong.  */
6211
6212   keep_next_if_subblocks = 1;
6213
6214   /* ??? This might be an improvement,
6215      but needs to be thought about some more.  */
6216 #if 0
6217   keep_next_level_flag = 1;
6218 #endif
6219
6220   /* Write a record describing this function definition to the prototypes
6221      file (if requested).  */
6222
6223   gen_aux_info_record (fndecl, 1, 0, prototype);
6224
6225   /* Initialize the RTL code for the function.  */
6226
6227   init_function_start (fndecl, input_filename, lineno);
6228
6229   /* If this is a varargs function, inform function.c.  */
6230
6231   if (c_function_varargs)
6232     mark_varargs ();
6233
6234   /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
6235
6236   declare_function_name ();
6237
6238   /* Set up parameters and prepare for return, for the function.  */
6239
6240   expand_function_start (fndecl, 0);
6241
6242   /* If this function is `main', emit a call to `__main'
6243      to run global initializers, etc.  */
6244   if (DECL_NAME (fndecl)
6245       && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
6246       && DECL_CONTEXT (fndecl) == NULL_TREE)
6247     expand_main_function ();
6248 }
6249 \f
6250 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6251    each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
6252    stands for an ellipsis in the identifier list.
6253
6254    PARMLIST is the data returned by get_parm_info for the
6255    parmlist that follows the semicolon.
6256
6257    We return a value of the same sort that get_parm_info returns,
6258    except that it describes the combination of identifiers and parmlist.  */
6259
6260 tree
6261 combine_parm_decls (specparms, parmlist, void_at_end)
6262      tree specparms, parmlist;
6263      int void_at_end;
6264 {
6265   register tree fndecl = current_function_decl;
6266   register tree parm;
6267
6268   tree parmdecls = TREE_PURPOSE (parmlist);
6269
6270   /* This is a chain of any other decls that came in among the parm
6271      declarations.  They were separated already by get_parm_info,
6272      so we just need to keep them separate.  */
6273   tree nonparms = TREE_VALUE (parmlist);
6274
6275   tree types = 0;
6276
6277   for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6278     DECL_RESULT (parm) = 0;
6279
6280   for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6281     {
6282       register tree tail, found = NULL;
6283
6284       /* See if any of the parmdecls specifies this parm by name.  */
6285       for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6286         if (DECL_NAME (tail) == TREE_VALUE (parm))
6287           {
6288             found = tail;
6289             break;
6290           }
6291
6292       /* If declaration already marked, we have a duplicate name.
6293          Complain, and don't use this decl twice.   */
6294       if (found && DECL_RESULT (found) != 0)
6295         {
6296           error_with_decl (found, "multiple parameters named `%s'");
6297           found = 0;
6298         }
6299
6300       /* If the declaration says "void", complain and ignore it.  */
6301       if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6302         {
6303           error_with_decl (found, "parameter `%s' declared void");
6304           TREE_TYPE (found) = integer_type_node;
6305           DECL_ARG_TYPE (found) = integer_type_node;
6306           layout_decl (found, 0);
6307         }
6308
6309       /* Traditionally, a parm declared float is actually a double.  */
6310       if (found && flag_traditional
6311           && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6312         {
6313           TREE_TYPE (found) = double_type_node;
6314           DECL_ARG_TYPE (found) = double_type_node;
6315           layout_decl (found, 0);
6316         }
6317
6318       /* If no declaration found, default to int.  */
6319       if (!found)
6320         {
6321           found = build_decl (PARM_DECL, TREE_VALUE (parm),
6322                               integer_type_node);
6323           DECL_ARG_TYPE (found) = TREE_TYPE (found);
6324           DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6325           DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6326           error_with_decl (found, "type of parameter `%s' is not declared");
6327           pushdecl (found);
6328         }
6329
6330       TREE_PURPOSE (parm) = found;
6331
6332       /* Mark this decl as "already found" -- see test, above.
6333          It is safe to use DECL_RESULT for this
6334          since it is not used in PARM_DECLs or CONST_DECLs.  */
6335       DECL_RESULT (found) = error_mark_node;
6336     }
6337
6338   /* Complain about any actual PARM_DECLs not matched with any names.  */
6339
6340   for (parm = parmdecls; parm; )
6341     {
6342       tree next = TREE_CHAIN (parm);
6343       TREE_CHAIN (parm) = 0;
6344
6345       /* Complain about args with incomplete types.  */
6346       if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6347         {
6348           error_with_decl (parm, "parameter `%s' has incomplete type");
6349           TREE_TYPE (parm) = error_mark_node;
6350         }
6351
6352       if (DECL_RESULT (parm) == 0)
6353         {
6354           error_with_decl (parm,
6355                            "declaration for parameter `%s' but no such parameter");
6356           /* Pretend the parameter was not missing.
6357              This gets us to a standard state and minimizes
6358              further error messages.  */
6359           specparms
6360             = chainon (specparms,
6361                        tree_cons (parm, NULL_TREE, NULL_TREE));
6362         }
6363
6364       parm = next;
6365     }
6366
6367   /* Chain the declarations together in the order of the list of names.
6368      At the same time, build up a list of their types, in reverse order.  */
6369
6370   parm = specparms;
6371   parmdecls = 0;
6372   {
6373     register tree last;
6374     for (last = 0; parm; parm = TREE_CHAIN (parm))
6375       if (TREE_PURPOSE (parm))
6376         {
6377           if (last == 0)
6378             parmdecls = TREE_PURPOSE (parm);
6379           else
6380             TREE_CHAIN (last) = TREE_PURPOSE (parm);
6381           last = TREE_PURPOSE (parm);
6382           TREE_CHAIN (last) = 0;
6383
6384           types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
6385         }
6386   }
6387
6388   if (void_at_end)
6389     return saveable_tree_cons (parmdecls, nonparms,
6390                                nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
6391
6392   return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
6393 }
6394 \f
6395 /* Finish up a function declaration and compile that function
6396    all the way to assembler language output.  The free the storage
6397    for the function definition.
6398
6399    This is called after parsing the body of the function definition.
6400
6401    NESTED is nonzero if the function being finished is nested in another.  */
6402
6403 void
6404 finish_function (nested)
6405      int nested;
6406 {
6407   register tree fndecl = current_function_decl;
6408
6409 /*  TREE_READONLY (fndecl) = 1;
6410     This caused &foo to be of type ptr-to-const-function
6411     which then got a warning when stored in a ptr-to-function variable.  */
6412
6413   poplevel (1, 0, 1);
6414   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6415
6416   /* Must mark the RESULT_DECL as being in this function.  */
6417
6418   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6419
6420   /* Obey `register' declarations if `setjmp' is called in this fn.  */
6421   if (flag_traditional && current_function_calls_setjmp)
6422     {
6423       setjmp_protect (DECL_INITIAL (fndecl));
6424       setjmp_protect_args ();
6425     }
6426
6427 #ifdef DEFAULT_MAIN_RETURN
6428   if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
6429     {
6430       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6431           != integer_type_node)
6432         warning_with_decl (fndecl, "return type of `%s' is not `int'");
6433       else
6434         {
6435           /* Make it so that `main' always returns success by default.  */
6436           DEFAULT_MAIN_RETURN;
6437         }
6438     }
6439 #endif
6440
6441   /* Generate rtl for function exit.  */
6442   expand_function_end (input_filename, lineno);
6443
6444   /* So we can tell if jump_optimize sets it to 1.  */
6445   can_reach_end = 0;
6446
6447   /* Run the optimizers and output the assembler code for this function.  */
6448   rest_of_compilation (fndecl);
6449
6450   current_function_returns_null |= can_reach_end;
6451
6452   if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
6453     warning ("`volatile' function does return");
6454   else if (warn_return_type && can_reach_end
6455            && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
6456     /* If this function returns non-void and control can drop through,
6457        complain.  */
6458     warning ("control reaches end of non-void function");
6459   /* With just -W, complain only if function returns both with
6460      and without a value.  */
6461   else if (extra_warnings
6462            && current_function_returns_value && current_function_returns_null)
6463     warning ("this function may return with or without a value");
6464
6465   /* Free all the tree nodes making up this function.  */
6466   /* Switch back to allocating nodes permanently
6467      until we start another function.  */
6468   if (! nested)
6469     permanent_allocation ();
6470
6471   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
6472     {
6473       /* Stop pointing to the local nodes about to be freed.  */
6474       /* But DECL_INITIAL must remain nonzero so we know this
6475          was an actual function definition.  */
6476       /* For a nested function, this is done in pop_c_function_context.  */
6477       DECL_INITIAL (fndecl) = error_mark_node;
6478       DECL_ARGUMENTS (fndecl) = 0;
6479     }
6480
6481   if (! nested)
6482     {
6483       /* Let the error reporting routines know that we're outside a
6484          function.  For a nested function, this value is used in
6485          pop_c_function_context and then reset via pop_function_context.  */
6486       current_function_decl = NULL;
6487     }
6488 }
6489 \f
6490 /* Save and restore the variables in this file and elsewhere
6491    that keep track of the progress of compilation of the current function.
6492    Used for nested functions.  */
6493
6494 struct c_function
6495 {
6496   struct c_function *next;
6497   tree named_labels;
6498   tree shadowed_labels;
6499   int returns_value;
6500   int returns_null;
6501   int warn_about_return_type;
6502   int extern_inline;
6503   struct binding_level *binding_level;
6504 };
6505
6506 struct c_function *c_function_chain;
6507
6508 /* Save and reinitialize the variables
6509    used during compilation of a C function.  */
6510
6511 void
6512 push_c_function_context ()
6513 {
6514   struct c_function *p
6515     = (struct c_function *) xmalloc (sizeof (struct c_function));
6516
6517   if (pedantic)
6518     pedwarn ("ANSI C forbids nested functions");
6519
6520   push_function_context ();
6521
6522   p->next = c_function_chain;
6523   c_function_chain = p;
6524
6525   p->named_labels = named_labels;
6526   p->shadowed_labels = shadowed_labels;
6527   p->returns_value = current_function_returns_value;
6528   p->returns_null = current_function_returns_null;
6529   p->warn_about_return_type = warn_about_return_type;
6530   p->extern_inline = current_extern_inline;
6531   p->binding_level = current_binding_level;
6532 }
6533
6534 /* Restore the variables used during compilation of a C function.  */
6535
6536 void
6537 pop_c_function_context ()
6538 {
6539   struct c_function *p = c_function_chain;
6540   tree link;
6541
6542   /* Bring back all the labels that were shadowed.  */
6543   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
6544     if (DECL_NAME (TREE_VALUE (link)) != 0)
6545       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
6546         = TREE_VALUE (link);
6547
6548   if (DECL_SAVED_INSNS (current_function_decl) == 0)
6549     {
6550       /* Stop pointing to the local nodes about to be freed.  */
6551       /* But DECL_INITIAL must remain nonzero so we know this
6552          was an actual function definition.  */
6553       DECL_INITIAL (current_function_decl) = error_mark_node;
6554       DECL_ARGUMENTS (current_function_decl) = 0;
6555     }
6556
6557   pop_function_context ();
6558
6559   c_function_chain = p->next;
6560
6561   named_labels = p->named_labels;
6562   shadowed_labels = p->shadowed_labels;
6563   current_function_returns_value = p->returns_value;
6564   current_function_returns_null = p->returns_null;
6565   warn_about_return_type = p->warn_about_return_type;
6566   current_extern_inline = p->extern_inline;
6567   current_binding_level = p->binding_level;
6568
6569   free (p);
6570 }