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