gcc/c-decl.c

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