gcc/c-decl.c

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