gcc/c-decl.c

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