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