gcc/c-decl.c

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