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