gcc/c-decl.c

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