gcc/c-decl.c

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