gcc/c-decl.c

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