gcc/c-decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /* Process declarations and symbol lookup for C front end.
  23    Also constructs types; the standard scalar types at initialization,
  24    and structure, union, array and enum types when they are declared.  */
  25
  26 /* ??? not all decl nodes are given the most useful possible
  27    line numbers.  For example, the CONST_DECLs for enum values.  */
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include "intl.h"
  34 #include "tree.h"
  35 #include "tree-inline.h"
  36 #include "rtl.h"
  37 #include "flags.h"
  38 #include "function.h"
  39 #include "output.h"
  40 #include "expr.h"
  41 #include "c-tree.h"
  42 #include "toplev.h"
  43 #include "ggc.h"
  44 #include "tm_p.h"
  45 #include "cpplib.h"
  46 #include "target.h"
  47 #include "debug.h"
  48 #include "opts.h"
  49 #include "timevar.h"
  50 #include "c-common.h"
  51 #include "c-pragma.h"
  52 #include "cgraph.h"
  53 #include "hashtab.h"
  54 #include "libfuncs.h"
  55 #include "except.h"
  56 #include "langhooks-def.h"
  57
  58 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
  59 enum decl_context
  60 { NORMAL,                       /* Ordinary declaration */
  61   FUNCDEF,                      /* Function definition */
  62   PARM,                         /* Declaration of parm before function body */
  63   FIELD,                        /* Declaration inside struct or union */
  64   TYPENAME};                    /* Typename (inside cast or sizeof)  */
  65
  66 \f
  67 /* Nonzero if we have seen an invalid cross reference
  68    to a struct, union, or enum, but not yet printed the message.  */
  69
  70 tree pending_invalid_xref;
  71 /* File and line to appear in the eventual error message.  */
  72 location_t pending_invalid_xref_location;
  73
  74 /* While defining an enum type, this is 1 plus the last enumerator
  75    constant value.  Note that will do not have to save this or `enum_overflow'
  76    around nested function definition since such a definition could only
  77    occur in an enum value expression and we don't use these variables in
  78    that case.  */
  79
  80 static tree enum_next_value;
  81
  82 /* Nonzero means that there was overflow computing enum_next_value.  */
  83
  84 static int enum_overflow;
  85
  86 /* These #defines are for clarity in working with the information block
  87    returned by get_parm_info.  */
  88 #define ARG_INFO_PARMS(args)  TREE_PURPOSE(args)
  89 #define ARG_INFO_TAGS(args)   TREE_VALUE(args)
  90 #define ARG_INFO_TYPES(args)  TREE_CHAIN(args)
  91 #define ARG_INFO_OTHERS(args) TREE_TYPE(args)
  92
  93 /* The file and line that the prototype came from if this is an
  94    old-style definition; used for diagnostics in
  95    store_parm_decls_oldstyle.  */
  96
  97 static location_t current_function_prototype_locus;
  98
  99 /* The current statement tree.  */
 100
 101 static GTY(()) struct stmt_tree_s c_stmt_tree;
 102
 103 /* The current scope statement stack.  */
 104
 105 static GTY(()) tree c_scope_stmt_stack;
 106
 107 /* State saving variables.  */
 108 int c_in_iteration_stmt;
 109 int c_in_case_stmt;
 110
 111 /* A list of external DECLs that appeared at block scope when there was
 112    some other global meaning for that identifier.  */
 113 static GTY(()) tree truly_local_externals;
 114
 115 /* All the builtins; this is a subset of the entries of global_scope.  */
 116
 117 static GTY(()) tree first_builtin_decl;
 118 static GTY(()) tree last_builtin_decl;
 119
 120 /* A DECL for the current file-scope context.  */
 121
 122 static GTY(()) tree current_file_decl;
 123
 124 /* Set to 0 at beginning of a function definition, set to 1 if
 125    a return statement that specifies a return value is seen.  */
 126
 127 int current_function_returns_value;
 128
 129 /* Set to 0 at beginning of a function definition, set to 1 if
 130    a return statement with no argument is seen.  */
 131
 132 int current_function_returns_null;
 133
 134 /* Set to 0 at beginning of a function definition, set to 1 if
 135    a call to a noreturn function is seen.  */
 136
 137 int current_function_returns_abnormally;
 138
 139 /* Set to nonzero by `grokdeclarator' for a function
 140    whose return type is defaulted, if warnings for this are desired.  */
 141
 142 static int warn_about_return_type;
 143
 144 /* Nonzero when starting a function declared `extern inline'.  */
 145
 146 static int current_extern_inline;
 147 \f
 148 /* Each c_scope structure describes the complete contents of one scope.
 149    Three scopes are distinguished specially: the innermost or current
 150    scope, the innermost function scope, and the outermost or file scope.
 151
 152    Most declarations are recorded in the current scope.
 153
 154    All normal label declarations are recorded in the innermost
 155    function scope, as are bindings of undeclared identifiers to
 156    error_mark_node.  (GCC permits nested functions as an extension,
 157    hence the 'innermost' qualifier.)  Explicitly declared labels
 158    (using the __label__ extension) appear in the current scope.
 159
 160    Being in the global scope (current_scope == global_scope) causes
 161    special behavior in several places below.  Also, under some
 162    conditions the Objective-C front end records declarations in the
 163    global scope even though that isn't the current scope.
 164
 165    The order of the names, parms, and blocks lists matters, and they
 166    are frequently appended to.  To avoid having to walk all the way to
 167    the end of the list on each insertion, or reverse the lists later,
 168    we maintain a pointer to the last list entry for each of the lists.
 169
 170    The order of the tags, shadowed, and shadowed_tags
 171    lists does not matter, so we just prepend to these lists.  */
 172
 173 struct c_scope GTY(())
 174 {
 175   /* The scope containing this one.  */
 176   struct c_scope *outer;
 177
 178   /* The next outermost function scope.  */
 179   struct c_scope *outer_function;
 180
 181   /* All variables, constants, functions, labels, and typedef names.  */
 182   tree names;
 183   tree names_last;
 184
 185   /* All parameter declarations.  Used only in the outermost scope of
 186      a function.  */
 187   tree parms;
 188   tree parms_last;
 189
 190   /* All structure, union, and enum type tags.  */
 191   tree tags;
 192
 193   /* For each scope, a list of shadowed outer-scope definitions
 194      to be restored when this scope is popped.
 195      Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 196      whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
 197   tree shadowed;
 198
 199   /* For each scope, a list of shadowed outer-scope tag definitions
 200      to be restored when this scope is popped.
 201      Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 202      whose TREE_VALUE is its old definition (a kind of ..._TYPE node).  */
 203   tree shadowed_tags;
 204
 205   /* For each scope (except the global one), a chain of BLOCK nodes
 206      for all the scopes that were entered and exited one level down.  */
 207   tree blocks;
 208   tree blocks_last;
 209
 210   /* True if we are currently filling this scope with parameter
 211      declarations.  */
 212   BOOL_BITFIELD parm_flag : 1;
 213
 214   /* True if we already complained about forward parameter decls
 215      in this scope.  This prevents double warnings on
 216      foo (int a; int b; ...)  */
 217   BOOL_BITFIELD warned_forward_parm_decls : 1;
 218
 219   /* True if this is the outermost block scope of a function body.
 220      This scope contains the parameters, the local variables declared
 221      in the outermost block, and all the labels (except those in
 222      nested functions, or declared at block scope with __label__).  */
 223   BOOL_BITFIELD function_body : 1;
 224
 225   /* True means make a BLOCK for this scope no matter what.  */
 226   BOOL_BITFIELD keep : 1;
 227 };
 228
 229 /* The scope currently in effect.  */
 230
 231 static GTY(()) struct c_scope *current_scope;
 232
 233 /* A chain of c_scope structures awaiting reuse.  */
 234
 235 static GTY((deletable (""))) struct c_scope *scope_freelist;
 236
 237 /* The innermost function scope.  Ordinary (not explicitly declared)
 238    labels, bindings to error_mark_node, and the lazily-created
 239    bindings of __func__ and its friends get this scope.  */
 240
 241 static GTY(()) struct c_scope *current_function_scope;
 242
 243 /* The outermost scope, corresponding to the C "file scope".  This is
 244    created when the compiler is started and exists through the entire run.  */
 245
 246 static GTY(()) struct c_scope *global_scope;
 247
 248 /* Append VAR to LIST in scope SCOPE.  */
 249 #define SCOPE_LIST_APPEND(scope, list, decl) do {       \
 250   struct c_scope *s_ = (scope);                         \
 251   tree d_ = (decl);                                     \
 252   if (s_->list##_last)                                  \
 253     TREE_CHAIN (s_->list##_last) = d_;                  \
 254   else                                                  \
 255     s_->list = d_;                                      \
 256   s_->list##_last = d_;                                 \
 257 } while (0)
 258
 259 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE.  */
 260 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {        \
 261   struct c_scope *t_ = (tscope);                                \
 262   struct c_scope *f_ = (fscope);                                \
 263   if (t_->to##_last)                                            \
 264     TREE_CHAIN (t_->to##_last) = f_->from;                      \
 265   else                                                          \
 266     t_->to = f_->from;                                          \
 267   t_->to##_last = f_->from##_last;                              \
 268 } while (0)
 269
 270 /* True means unconditionally make a BLOCK for the next scope pushed.  */
 271
 272 static bool keep_next_level_flag;
 273
 274 /* True means the next call to pushlevel will be the outermost scope
 275    of a function body, so do not push a new scope, merely cease
 276    expecting parameter decls.  */
 277
 278 static bool next_is_function_body;
 279
 280 /* Functions called automatically at the beginning and end of execution.  */
 281
 282 tree static_ctors, static_dtors;
 283
 284 /* Forward declarations.  */
 285
 286 static struct c_scope *make_scope (void);
 287 static void pop_scope (void);
 288 static tree make_label (tree, location_t);
 289 static void bind_label (tree, tree, struct c_scope *);
 290 static void implicit_decl_warning (tree);
 291 static tree lookup_tag (enum tree_code, tree, int);
 292 static tree lookup_name_current_level (tree);
 293 static tree grokdeclarator (tree, tree, enum decl_context, int, tree *);
 294 static tree grokparms (tree, int);
 295 static void layout_array_type (tree);
 296 static tree c_make_fname_decl (tree, int);
 297 static void c_expand_body_1 (tree, int);
 298 static tree any_external_decl (tree);
 299 static void record_external_decl (tree);
 300 static void warn_if_shadowing (tree, tree);
 301 static void check_bitfield_type_and_width (tree *, tree *, const char *);
 302 static void clone_underlying_type (tree);
 303 static bool flexible_array_type_p (tree);
 304 static hashval_t link_hash_hash (const void *);
 305 static int link_hash_eq (const void *, const void *);
 306 \f
 307 /* States indicating how grokdeclarator() should handle declspecs marked
 308    with __attribute__((deprecated)).  An object declared as
 309    __attribute__((deprecated)) suppresses warnings of uses of other
 310    deprecated items.  */
 311
 312 enum deprecated_states {
 313   DEPRECATED_NORMAL,
 314   DEPRECATED_SUPPRESS
 315 };
 316
 317 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 318
 319 void
 320 c_print_identifier (FILE *file, tree node, int indent)
 321 {
 322   print_node (file, "symbol", IDENTIFIER_SYMBOL_VALUE (node), indent + 4);
 323   print_node (file, "tag", IDENTIFIER_TAG_VALUE (node), indent + 4);
 324   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
 325   if (C_IS_RESERVED_WORD (node))
 326     {
 327       tree rid = ridpointers[C_RID_CODE (node)];
 328       indent_to (file, indent + 4);
 329       fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
 330                (void *) rid, IDENTIFIER_POINTER (rid));
 331     }
 332 }
 333 \f
 334 /* Hook called at end of compilation to assume 1 elt
 335    for a file-scope tentative array defn that wasn't complete before.  */
 336
 337 void
 338 c_finish_incomplete_decl (tree decl)
 339 {
 340   if (TREE_CODE (decl) == VAR_DECL)
 341     {
 342       tree type = TREE_TYPE (decl);
 343       if (type != error_mark_node
 344           && TREE_CODE (type) == ARRAY_TYPE
 345           && ! DECL_EXTERNAL (decl)
 346           && TYPE_DOMAIN (type) == 0)
 347         {
 348           warning ("%Jarray '%D' assumed to have one element", decl, decl);
 349
 350           complete_array_type (type, NULL_TREE, 1);
 351
 352           layout_decl (decl, 0);
 353         }
 354     }
 355 }
 356 \f
 357 /* Reuse or create a struct for this scope.  */
 358
 359 static struct c_scope *
 360 make_scope (void)
 361 {
 362   struct c_scope *result;
 363   if (scope_freelist)
 364     {
 365       result = scope_freelist;
 366       scope_freelist = result->outer;
 367     }
 368   else
 369     result = ggc_alloc_cleared (sizeof (struct c_scope));
 370
 371   return result;
 372 }
 373
 374 /* Remove the topmost scope from the stack and add it to the
 375    free list, updating current_function_scope if necessary.  */
 376
 377 static void
 378 pop_scope (void)
 379 {
 380   struct c_scope *scope = current_scope;
 381
 382   current_scope = scope->outer;
 383   if (scope->function_body)
 384     current_function_scope = scope->outer_function;
 385
 386   memset (scope, 0, sizeof (struct c_scope));
 387   scope->outer = scope_freelist;
 388   scope_freelist = scope;
 389 }
 390
 391 /* The Objective-C front-end often needs to determine the current scope.  */
 392
 393 void *
 394 get_current_scope (void)
 395 {
 396   return current_scope;
 397 }
 398
 399 /* The following function is used only by Objective-C.  It needs to live here
 400    because it accesses the innards of c_scope.  */
 401
 402 void
 403 objc_mark_locals_volatile (void *enclosing_blk)
 404 {
 405   struct c_scope *scope;
 406
 407   for (scope = current_scope;
 408        scope && scope != enclosing_blk;
 409        scope = scope->outer)
 410     {
 411       tree decl;
 412
 413       for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
 414         {
 415           DECL_REGISTER (decl) = 0;
 416           TREE_THIS_VOLATILE (decl) = 1;
 417         }
 418       /* Do not climb up past the current function.  */
 419       if (scope->function_body)
 420         break;
 421     }
 422 }
 423
 424 /* Nonzero if we are currently in the global scope.  */
 425
 426 int
 427 global_bindings_p (void)
 428 {
 429   return current_scope == global_scope;
 430 }
 431
 432 void
 433 keep_next_level (void)
 434 {
 435   keep_next_level_flag = true;
 436 }
 437
 438 /* Identify this scope as currently being filled with parameters.  */
 439
 440 void
 441 declare_parm_level (void)
 442 {
 443   current_scope->parm_flag = true;
 444 }
 445
 446 /* Nonzero if currently making parm declarations.  */
 447
 448 int
 449 in_parm_level_p (void)
 450 {
 451   return current_scope->parm_flag;
 452 }
 453
 454 /* Enter a new scope.  The dummy parameter is for signature
 455    compatibility with lang_hooks.decls.pushlevel.  */
 456
 457 void
 458 pushlevel (int dummy ATTRIBUTE_UNUSED)
 459 {
 460   if (next_is_function_body)
 461     {
 462       /* This is the transition from the parameters to the top level
 463          of the function body.  These are the same scope
 464          (C99 6.2.1p4,6) so we do not push another scope structure.
 465          next_is_function_body is set only by store_parm_decls, which
 466          in turn is called when and only when we are about to
 467          encounter the opening curly brace for the function body.
 468
 469          The outermost block of a function always gets a BLOCK node,
 470          because the debugging output routines expect that each
 471          function has at least one BLOCK.  */
 472       current_scope->parm_flag         = false;
 473       current_scope->function_body     = true;
 474       current_scope->keep              = true;
 475       current_scope->outer_function    = current_function_scope;
 476       current_function_scope           = current_scope;
 477
 478       keep_next_level_flag = false;
 479       next_is_function_body = false;
 480     }
 481   else
 482     {
 483       struct c_scope *scope = make_scope ();
 484
 485       scope->keep          = keep_next_level_flag;
 486       scope->outer         = current_scope;
 487       current_scope        = scope;
 488       keep_next_level_flag = false;
 489     }
 490 }
 491
 492 /* Exit a scope.  Restore the state of the identifier-decl mappings
 493    that were in effect when this scope was entered.
 494
 495    If KEEP is KEEP_YES (1), this scope had explicit declarations, so
 496    create a BLOCK node to record its declarations and subblocks for
 497    debugging output.  If KEEP is KEEP_MAYBE, do so only if the names
 498    or tags lists are nonempty.
 499
 500    The second parameter is ignored; it is present only for
 501    signature compatibility with lang_hooks.decls.poplevel.
 502
 503    If FUNCTIONBODY is nonzero, this level is the body of a function,
 504    even if current_scope->function_body is not set.  This is used
 505    by language-independent code that generates synthetic functions,
 506    and cannot set current_scope->function_body.
 507
 508    FIXME: Eliminate the need for all arguments.  */
 509
 510 tree
 511 poplevel (int keep, int dummy ATTRIBUTE_UNUSED, int functionbody)
 512 {
 513   struct c_scope *scope = current_scope;
 514   tree block;
 515   tree decl;
 516   tree p;
 517
 518   /* The following line does not use |= due to a bug in HP's C compiler.  */
 519   scope->function_body = scope->function_body | functionbody;
 520
 521   if (keep == KEEP_MAYBE)
 522     keep = (scope->names || scope->tags);
 523
 524   keep |= scope->keep;
 525   keep |= scope->function_body;
 526
 527   /* If appropriate, create a BLOCK to record the decls for the life
 528      of this function.  */
 529   block = 0;
 530   if (keep)
 531     {
 532       block = make_node (BLOCK);
 533       BLOCK_VARS (block) = scope->names;
 534       BLOCK_SUBBLOCKS (block) = scope->blocks;
 535       TREE_USED (block) = 1;
 536     }
 537
 538   /* In each subblock, record that this is its superior.  */
 539   for (p = scope->blocks; p; p = TREE_CHAIN (p))
 540     BLOCK_SUPERCONTEXT (p) = block;
 541
 542   /* Clear out the variable bindings in this scope.
 543
 544      Propagate TREE_ADDRESSABLE from nested functions to their
 545      containing functions.
 546
 547      Issue warnings for unused variables and labels, and errors for
 548      undefined labels, if there are any.  */
 549
 550   for (p = scope->names; p; p = TREE_CHAIN (p))
 551     {
 552       switch (TREE_CODE (p))
 553         {
 554         case LABEL_DECL:
 555           if (TREE_USED (p) && !DECL_INITIAL (p))
 556             {
 557               error ("%Jlabel `%D' used but not defined", p, p);
 558               DECL_INITIAL (p) = error_mark_node;
 559             }
 560           else if (!TREE_USED (p) && warn_unused_label)
 561             {
 562               if (DECL_INITIAL (p))
 563                 warning ("%Jlabel `%D' defined but not used", p, p);
 564               else
 565                 warning ("%Jlabel `%D' declared but not defined", p, p);
 566             }
 567
 568           IDENTIFIER_LABEL_VALUE (DECL_NAME (p)) = 0;
 569           break;
 570
 571         case FUNCTION_DECL:
 572           if (! TREE_ASM_WRITTEN (p)
 573               && DECL_INITIAL (p) != 0
 574               && TREE_ADDRESSABLE (p)
 575               && DECL_ABSTRACT_ORIGIN (p) != 0
 576               && DECL_ABSTRACT_ORIGIN (p) != p)
 577             TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
 578           goto normal;
 579
 580         case VAR_DECL:
 581           /* Keep this in sync with stmt.c:warn_about_unused_variables.
 582              No warnings when the global scope is popped because the
 583              global scope isn't popped for the last translation unit,
 584              so the warnings are done in c_write_global_declaration.  */
 585           if (warn_unused_variable && scope != global_scope
 586               && !TREE_USED (p)
 587               && !DECL_IN_SYSTEM_HEADER (p)
 588               && DECL_NAME (p)
 589               && !DECL_ARTIFICIAL (p))
 590             warning ("%Junused variable `%D'", p, p);
 591           /* Fall through.  */
 592
 593         default:
 594         normal:
 595           if (DECL_NAME (p))
 596             {
 597               if (DECL_EXTERNAL (p) && scope != global_scope)
 598                 /* External decls stay in the symbol-value slot but are
 599                    inaccessible.  */
 600                 C_DECL_INVISIBLE (p) = 1;
 601               else
 602                 IDENTIFIER_SYMBOL_VALUE (DECL_NAME (p)) = 0;
 603             }
 604           break;
 605         }
 606     }
 607
 608   /* Clear out the parameter bindings in this scope, if any.
 609      Unused-parameter warnings are handled by function.c.  */
 610   for (p = scope->parms; p; p = TREE_CHAIN (p))
 611     if (DECL_NAME (p))
 612       IDENTIFIER_SYMBOL_VALUE (DECL_NAME (p)) = 0;
 613
 614   /* Clear out the tag-meanings declared in this scope.
 615
 616      Set the TYPE_CONTEXTs for all of the tagged types belonging to
 617      this scope so that they point to the appropriate construct, i.e.
 618      either to the current FUNCTION_DECL node, or else to the BLOCK
 619      node we just constructed.
 620
 621      Note that for tagged types whose scope is just the formal
 622      parameter list for some function type specification, we can't
 623      properly set their TYPE_CONTEXTs here, because we don't have a
 624      pointer to the appropriate FUNCTION_TYPE node readily available
 625      to us.  For those cases, the TYPE_CONTEXTs of the relevant tagged
 626      type nodes get set in `grokdeclarator' as soon as we have created
 627      the FUNCTION_TYPE node which will represent the "scope" for these
 628      "parameter list local" tagged types.  */
 629
 630   decl = scope->function_body ? current_function_decl : block;
 631   for (p = scope->tags; p; p = TREE_CHAIN (p))
 632     {
 633       if (TREE_PURPOSE (p))
 634         IDENTIFIER_TAG_VALUE (TREE_PURPOSE (p)) = 0;
 635       if (decl)
 636         TYPE_CONTEXT (TREE_VALUE (p)) = decl;
 637     }
 638
 639   /* Restore all name- and label-meanings from outer scopes that were
 640      shadowed by this scope.  */
 641   for (p = scope->shadowed; p; p = TREE_CHAIN (p))
 642     if (TREE_VALUE (p) && TREE_CODE (TREE_VALUE (p)) == LABEL_DECL)
 643       IDENTIFIER_LABEL_VALUE (TREE_PURPOSE (p)) = TREE_VALUE (p);
 644     else
 645       IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (p)) = TREE_VALUE (p);
 646
 647   /* Restore all tag-meanings from outer scopes that were shadowed by
 648      this scope.  */
 649   for (p = scope->shadowed_tags; p; p = TREE_CHAIN (p))
 650     IDENTIFIER_TAG_VALUE (TREE_PURPOSE (p)) = TREE_VALUE (p);
 651
 652   /* Dispose of the block that we just made inside some higher level.  */
 653   if (scope->function_body && current_function_decl)
 654     DECL_INITIAL (current_function_decl) = block;
 655   else if (scope->outer)
 656     {
 657       if (block)
 658         SCOPE_LIST_APPEND (scope->outer, blocks, block);
 659       /* If we did not make a block for the scope just exited, any
 660          blocks made for inner scopes must be carried forward so they
 661          will later become subblocks of something else.  */
 662       else if (scope->blocks)
 663         SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
 664     }
 665
 666   /* Pop the current scope, and free the structure for reuse.  */
 667   pop_scope ();
 668
 669   return block;
 670 }
 671
 672 /* Insert BLOCK at the end of the list of subblocks of the current
 673    scope.  This is used when a BIND_EXPR is expanded, to handle the
 674    BLOCK node inside the BIND_EXPR.  */
 675
 676 void
 677 insert_block (tree block)
 678 {
 679   TREE_USED (block) = 1;
 680   SCOPE_LIST_APPEND (current_scope, blocks, block);
 681 }
 682
 683 /* Set the BLOCK node for the innermost scope (the one we are
 684    currently in).  The RTL expansion machinery requires us to provide
 685    this hook, but it is not useful in function-at-a-time mode.  */
 686
 687 void
 688 set_block (tree block ATTRIBUTE_UNUSED)
 689 {
 690 }
 691 \f
 692 /* Push a definition or a declaration of struct, union or enum tag "name".
 693    "type" should be the type node.
 694    We assume that the tag "name" is not already defined.
 695
 696    Note that the definition may really be just a forward reference.
 697    In that case, the TYPE_SIZE will be zero.  */
 698
 699 void
 700 pushtag (tree name, tree type)
 701 {
 702   struct c_scope *b = current_scope;
 703
 704   /* Record the identifier as the type's name if it has none.  */
 705   if (name)
 706     {
 707       if (TYPE_NAME (type) == 0)
 708         TYPE_NAME (type) = name;
 709
 710       if (IDENTIFIER_TAG_VALUE (name))
 711         b->shadowed_tags = tree_cons (name, IDENTIFIER_TAG_VALUE (name),
 712                                       b->shadowed_tags);
 713       IDENTIFIER_TAG_VALUE (name) = type;
 714     }
 715
 716   b->tags = tree_cons (name, type, b->tags);
 717
 718   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
 719      tagged type we just added to the current scope.  This fake
 720      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
 721      to output a representation of a tagged type, and it also gives
 722      us a convenient place to record the "scope start" address for the
 723      tagged type.  */
 724
 725   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
 726
 727   /* An approximation for now, so we can tell this is a function-scope tag.
 728      This will be updated in poplevel.  */
 729   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
 730 }
 731 \f
 732 /* Subroutine of compare_decls.  Allow harmless mismatches in return
 733    and argument types provided that the type modes match.  This function
 734    return a unified type given a suitable match, and 0 otherwise.  */
 735
 736 static tree
 737 match_builtin_function_types (tree newtype, tree oldtype)
 738 {
 739   tree newrettype, oldrettype;
 740   tree newargs, oldargs;
 741   tree trytype, tryargs;
 742
 743   /* Accept the return type of the new declaration if same modes.  */
 744   oldrettype = TREE_TYPE (oldtype);
 745   newrettype = TREE_TYPE (newtype);
 746
 747   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
 748     return 0;
 749
 750   oldargs = TYPE_ARG_TYPES (oldtype);
 751   newargs = TYPE_ARG_TYPES (newtype);
 752   tryargs = newargs;
 753
 754   while (oldargs || newargs)
 755     {
 756       if (! oldargs
 757           || ! newargs
 758           || ! TREE_VALUE (oldargs)
 759           || ! TREE_VALUE (newargs)
 760           || TYPE_MODE (TREE_VALUE (oldargs))
 761              != TYPE_MODE (TREE_VALUE (newargs)))
 762         return 0;
 763
 764       oldargs = TREE_CHAIN (oldargs);
 765       newargs = TREE_CHAIN (newargs);
 766     }
 767
 768   trytype = build_function_type (newrettype, tryargs);
 769   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
 770 }
 771
 772 /* Subroutine of diagnose_mismatched_decls.  Check for function type
 773    mismatch involving an empty arglist vs a nonempty one and give clearer
 774    diagnostics.  */
 775 static void
 776 diagnose_arglist_conflict (tree newdecl, tree olddecl,
 777                            tree newtype, tree oldtype)
 778 {
 779   tree t;
 780
 781   if (TREE_CODE (olddecl) != FUNCTION_DECL
 782       || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype), COMPARE_STRICT)
 783       || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
 784            ||
 785            (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
 786     return;
 787
 788   t = TYPE_ARG_TYPES (oldtype);
 789   if (t == 0)
 790     t = TYPE_ARG_TYPES (newtype);
 791   for (; t; t = TREE_CHAIN (t))
 792     {
 793       tree type = TREE_VALUE (t);
 794
 795       if (TREE_CHAIN (t) == 0
 796           && TYPE_MAIN_VARIANT (type) != void_type_node)
 797         {
 798           inform ("a parameter list with an ellipsis can't match "
 799                   "an empty parameter name list declaration");
 800           break;
 801         }
 802
 803       if (c_type_promotes_to (type) != type)
 804         {
 805           inform ("an argument type that has a default promotion can't match "
 806                   "an empty parameter name list declaration");
 807           break;
 808         }
 809     }
 810 }
 811
 812 /* Another subroutine of diagnose_mismatched_decls.  OLDDECL is an
 813    old-style function definition, NEWDECL is a prototype declaration.
 814    Diagnose inconsistencies in the argument list.  Returns TRUE if
 815    the prototype is compatible, FALSE if not.  */
 816 static bool
 817 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
 818 {
 819   tree newargs, oldargs;
 820   int i;
 821
 822   /* ??? Elsewhere TYPE_MAIN_VARIANT is not used in this context.  */
 823 #define END_OF_ARGLIST(t) (TYPE_MAIN_VARIANT (t) == void_type_node)
 824
 825   oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
 826   newargs = TYPE_ARG_TYPES (newtype);
 827   i = 1;
 828
 829   for (;;)
 830     {
 831       tree oldargtype = TREE_VALUE (oldargs);
 832       tree newargtype = TREE_VALUE (newargs);
 833
 834       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
 835         break;
 836
 837       /* Reaching the end of just one list means the two decls don't
 838          agree on the number of arguments.  */
 839       if (END_OF_ARGLIST (oldargtype))
 840         {
 841           error ("%Jprototype for '%D' declares more arguments "
 842                  "than previous old-style definition", newdecl, newdecl);
 843           return false;
 844         }
 845       else if (END_OF_ARGLIST (newargtype))
 846         {
 847           error ("%Jprototype for '%D' declares fewer arguments "
 848                  "than previous old-style definition", newdecl, newdecl);
 849           return false;
 850         }
 851
 852       /* Type for passing arg must be consistent with that declared
 853          for the arg.  */
 854       else if (! comptypes (oldargtype, newargtype, COMPARE_STRICT))
 855         {
 856           error ("%Jprototype for '%D' declares arg %d with incompatible type",
 857                  newdecl, newdecl, i);
 858           return false;
 859         }
 860
 861       oldargs = TREE_CHAIN (oldargs);
 862       newargs = TREE_CHAIN (newargs);
 863       i++;
 864     }
 865
 866   /* If we get here, no errors were found, but do issue a warning
 867      for this poor-style construct.  */
 868   warning ("%Jprototype for '%D' follows non-prototype definition",
 869            newdecl, newdecl);
 870   return true;
 871 #undef END_OF_ARGLIST
 872 }
 873
 874 /* Subroutine of diagnose_mismatched_decls.  Report the location of DECL,
 875    first in a pair of mismatched declarations, using the diagnostic
 876    function DIAG.  */
 877 static void
 878 locate_old_decl (tree decl, void (*diag)(const char *, ...))
 879 {
 880   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
 881     ;
 882   else if (DECL_INITIAL (decl))
 883     diag (N_("%Jprevious definition of '%D' was here"), decl, decl);
 884   else if (C_DECL_IMPLICIT (decl))
 885     diag (N_("%Jprevious implicit declaration of '%D' was here"), decl, decl);
 886   else
 887     diag (N_("%Jprevious declaration of '%D' was here"), decl, decl);
 888 }
 889
 890 /* Subroutine of duplicate_decls.  Compare NEWDECL to OLDDECL.
 891    Returns true if the caller should proceed to merge the two, false
 892    if OLDDECL should simply be discarded.  As a side effect, issues
 893    all necessary diagnostics for invalid or poor-style combinations.
 894    If it returns true, writes the types of NEWDECL and OLDDECL to
 895    *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
 896    TREE_TYPE (NEWDECL, OLDDECL) respectively.  */
 897
 898 static bool
 899 diagnose_mismatched_decls (tree newdecl, tree olddecl,
 900                            tree *newtypep, tree *oldtypep)
 901 {
 902   tree newtype, oldtype;
 903   bool pedwarned = false;
 904   bool warned = false;
 905
 906   /* If we have error_mark_node for either decl or type, just discard
 907      the previous decl - we're in an error cascade already.  */
 908   if (olddecl == error_mark_node || newdecl == error_mark_node)
 909     return false;
 910   *oldtypep = oldtype = TREE_TYPE (olddecl);
 911   *newtypep = newtype = TREE_TYPE (newdecl);
 912   if (oldtype == error_mark_node || newtype == error_mark_node)
 913     return false;
 914
 915   /* Two different categories of symbol altogether.  This is an error
 916      unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
 917   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
 918     {
 919       if (TREE_CODE (olddecl) != FUNCTION_DECL
 920           || !DECL_BUILT_IN (olddecl) || !C_DECL_INVISIBLE (olddecl))
 921         {
 922           error ("%J'%D' redeclared as different kind of symbol",
 923                  newdecl, newdecl);
 924           locate_old_decl (olddecl, error);
 925         }
 926       else if (TREE_PUBLIC (newdecl))
 927         warning ("%Jbuilt-in function '%D' declared as non-function",
 928                  newdecl, newdecl);
 929       else if (warn_shadow)
 930         warning ("%Jshadowing built-in function '%D'",
 931                  newdecl, newdecl);
 932       return false;
 933     }
 934
 935   if (!comptypes (oldtype, newtype, COMPARE_STRICT))
 936     {
 937       if (TREE_CODE (olddecl) == FUNCTION_DECL
 938           && DECL_BUILT_IN (olddecl) && C_DECL_INVISIBLE (olddecl))
 939         {
 940           /* Accept harmless mismatch in function types.
 941              This is for the ffs and fprintf builtins.  */
 942           tree trytype = match_builtin_function_types (newtype, oldtype);
 943
 944           if (trytype && comptypes (newtype, trytype, COMPARE_STRICT))
 945             *oldtypep = oldtype = trytype;
 946           else
 947             {
 948               /* If types don't match for a built-in, throw away the
 949                  built-in.  No point in calling locate_old_decl here, it
 950                  won't print anything.  */
 951               warning ("%Jconflicting types for built-in function '%D'",
 952                        newdecl, newdecl);
 953               return false;
 954             }
 955         }
 956       else if (TREE_CODE (olddecl) == FUNCTION_DECL
 957                && DECL_SOURCE_LINE (olddecl) == 0)
 958         {
 959           /* A conflicting function declaration for a predeclared
 960              function that isn't actually built in.  Objective C uses
 961              these.  The new declaration silently overrides everything
 962              but the volatility (i.e. noreturn) indication.  See also
 963              below.  FIXME: Make Objective C use normal builtins.  */
 964           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
 965           return false;
 966         }
 967       /* Permit void foo (...) to match int foo (...) if the latter is
 968          the definition and implicit int was used.  See
 969          c-torture/compile/920625-2.c.  */
 970       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
 971                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
 972                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
 973                && C_FUNCTION_IMPLICIT_INT (newdecl))
 974         {
 975           pedwarn ("%Jconflicting types for '%D'", newdecl, newdecl);
 976           /* Make sure we keep void as the return type.  */
 977           TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
 978           C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
 979           pedwarned = true;
 980         }
 981       else
 982         {
 983           error ("%Jconflicting types for '%D'", newdecl, newdecl);
 984           diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
 985           locate_old_decl (olddecl, error);
 986           return false;
 987         }
 988     }
 989
 990   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
 991      but silently ignore the redeclaration if either is in a system
 992      header.  (Conflicting redeclarations were handled above.)  */
 993   if (TREE_CODE (newdecl) == TYPE_DECL)
 994     {
 995       if (DECL_IN_SYSTEM_HEADER (newdecl) || DECL_IN_SYSTEM_HEADER (olddecl))
 996         return true;  /* Allow OLDDECL to continue in use.  */
 997
 998       error ("%Jredefinition of typedef '%D'", newdecl, newdecl);
 999       locate_old_decl (olddecl, error);
1000       return false;
1001     }
1002
1003   /* Function declarations can either be 'static' or 'extern' (no
1004      qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1005      can never conflict with each other on account of linkage (6.2.2p4).
1006      Multiple definitions are not allowed (6.9p3,5) but GCC permits
1007      two definitions if one is 'extern inline' and one is not.  The non-
1008      extern-inline definition supersedes the extern-inline definition.  */
1009   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1010     {
1011       /* If you declare a built-in function name as static, or
1012          define the built-in with an old-style definition (so we
1013          can't validate the argument list) the built-in definition is
1014          overridden, but optionally warn this was a bad choice of name.  */
1015       if (DECL_BUILT_IN (olddecl)
1016           && C_DECL_INVISIBLE (olddecl)
1017           && (!TREE_PUBLIC (newdecl)
1018               || (DECL_INITIAL (newdecl)
1019                   && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1020         {
1021           if (warn_shadow)
1022             warning ("%Jshadowing built-in function '%D'", newdecl, newdecl);
1023           /* Discard the old built-in function.  */
1024           return false;
1025         }
1026
1027       if (DECL_INITIAL (newdecl))
1028         {
1029           if (DECL_INITIAL (olddecl)
1030               && !(DECL_DECLARED_INLINE_P (olddecl)
1031                    && DECL_EXTERNAL (olddecl)
1032                    && !(DECL_DECLARED_INLINE_P (newdecl)
1033                         && DECL_EXTERNAL (newdecl))))
1034             {
1035               error ("%Jredefinition of '%D'", newdecl, newdecl);
1036               locate_old_decl (olddecl, error);
1037               return false;
1038             }
1039         }
1040       /* If we have a prototype after an old-style function definition,
1041          the argument types must be checked specially.  */
1042       else if (DECL_INITIAL (olddecl)
1043                && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1044                && TYPE_ACTUAL_ARG_TYPES (oldtype)
1045                && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1046         {
1047           locate_old_decl (olddecl, error);
1048           return false;
1049         }
1050       /* Mismatched non-static and static is considered poor style.
1051          We only diagnose static then non-static if -Wtraditional,
1052          because it is the most convenient way to get some effects
1053          (see e.g.  what unwind-dw2-fde-glibc.c does to the definition
1054          of _Unwind_Find_FDE in unwind-dw2-fde.c).  Revisit?  */
1055       if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1056         {
1057           /* A static function declaration for a predeclared function
1058              that isn't actually built in, silently overrides the
1059              default.  Objective C uses these.  See also above.
1060              FIXME: Make Objective C use normal builtins.  */
1061           if (TREE_CODE (olddecl) == FUNCTION_DECL
1062               && DECL_SOURCE_LINE (olddecl) == 0)
1063             return false;
1064           else
1065             {
1066               warning ("%Jstatic declaration of '%D' follows "
1067                        "non-static declaration", newdecl, newdecl);
1068               warned = true;
1069             }
1070         }
1071       else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl)
1072                && warn_traditional)
1073         {
1074           warning ("%Jnon-static declaration of '%D' follows "
1075                    "static declaration", newdecl, newdecl);
1076           warned = true;
1077         }
1078     }
1079   else if (TREE_CODE (newdecl) == VAR_DECL)
1080     {
1081       /* Only variables can be thread-local, and all declarations must
1082          agree on this property.  */
1083       if (DECL_THREAD_LOCAL (newdecl) != DECL_THREAD_LOCAL (olddecl))
1084         {
1085           if (DECL_THREAD_LOCAL (newdecl))
1086             error ("%Jthread-local declaration of '%D' follows "
1087                    "non-thread-local declaration", newdecl, newdecl);
1088           else
1089             error ("%Jnon-thread-local declaration of '%D' follows "
1090                    "thread-local declaration", newdecl, newdecl);
1091
1092           locate_old_decl (olddecl, error);
1093           return false;
1094         }
1095
1096       /* Multiple initialized definitions are not allowed (6.9p3,5).  */
1097       if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1098         {
1099           error ("%Jredefinition of '%D'", newdecl, newdecl);
1100           locate_old_decl (olddecl, error);
1101           return false;
1102         }
1103
1104       /* Objects declared at file scope: if at least one is 'extern',
1105          it's fine (6.2.2p4); otherwise the linkage must agree (6.2.2p7).  */
1106       if (DECL_FILE_SCOPE_P (newdecl))
1107         {
1108           if (!DECL_EXTERNAL (newdecl)
1109               && !DECL_EXTERNAL (olddecl)
1110               && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1111             {
1112               if (TREE_PUBLIC (newdecl))
1113                 error ("%Jnon-static declaration of '%D' follows "
1114                        "static declaration", newdecl, newdecl);
1115               else
1116                 error ("%Jstatic declaration of '%D' follows "
1117                        "non-static declaration", newdecl, newdecl);
1118
1119               locate_old_decl (olddecl, error);
1120               return false;
1121             }
1122         }
1123       /* Two objects with the same name declared at the same block
1124          scope must both be external references (6.7p3).  */
1125       else if (DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl)
1126                && (!DECL_EXTERNAL (newdecl) || !DECL_EXTERNAL (olddecl)))
1127         {
1128           if (DECL_EXTERNAL (newdecl))
1129             error ("%Jextern declaration of '%D' follows "
1130                    "declaration with no linkage", newdecl, newdecl);
1131           else if (DECL_EXTERNAL (olddecl))
1132             error ("%Jdeclaration of '%D' with no linkage follows "
1133                    "extern declaration", newdecl, newdecl);
1134           else
1135             error ("%Jredeclaration of '%D' with no linkage",
1136                    newdecl, newdecl);
1137
1138           locate_old_decl (olddecl, error);
1139           return false;
1140         }
1141     }
1142
1143   /* warnings */
1144   /* All decls must agree on a non-default visibility.  */
1145   if (DECL_VISIBILITY (newdecl) != VISIBILITY_DEFAULT
1146       && DECL_VISIBILITY (olddecl) != VISIBILITY_DEFAULT
1147       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1148     {
1149       warning ("%Jredeclaration of '%D' with different visibility "
1150                "(old visibility preserved)", newdecl, newdecl);
1151       warned = true;
1152     }
1153
1154   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1155     {
1156       /* Diagnose inline __attribute__ ((noinline)) which is silly.  */
1157       if (DECL_DECLARED_INLINE_P (newdecl)
1158           && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1159         {
1160           warning ("%Jinline declaration of '%D' follows "
1161                    "declaration with attribute noinline", newdecl, newdecl);
1162           warned = true;
1163         }
1164       else if (DECL_DECLARED_INLINE_P (olddecl)
1165                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1166         {
1167           warning ("%Jdeclaration of '%D' with attribute noinline follows "
1168                    "inline declaration ", newdecl, newdecl);
1169           warned = true;
1170         }
1171
1172       /* Inline declaration after use or definition.
1173          ??? Should we still warn about this now we have unit-at-a-time
1174          mode and can get it right?  */
1175       if (DECL_DECLARED_INLINE_P (newdecl) && !DECL_DECLARED_INLINE_P (olddecl))
1176         {
1177           if (TREE_USED (olddecl))
1178             {
1179               warning ("%J'%D' declared inline after being called",
1180                        olddecl, olddecl);
1181               warned = true;
1182             }
1183           else if (DECL_INITIAL (olddecl))
1184             {
1185               warning ("%J'%D' declared inline after its definition",
1186                        olddecl, olddecl);
1187               warned = true;
1188             }
1189         }
1190     }
1191   else /* PARM_DECL, VAR_DECL */
1192     {
1193       /* Redeclaration of a PARM_DECL is invalid unless this is the
1194          real position of a forward-declared parameter (GCC extension).  */
1195       if (TREE_CODE (newdecl) == PARM_DECL
1196           && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
1197         {
1198           error ("%Jredefinition of parameter '%D'", newdecl, newdecl);
1199           locate_old_decl (olddecl, error);
1200           return false;
1201         }
1202
1203       /* These bits are only type qualifiers when applied to objects.  */
1204       if (TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl))
1205         {
1206           if (TREE_THIS_VOLATILE (newdecl))
1207             pedwarn ("%Jvolatile declaration of '%D' follows "
1208                      "non-volatile declaration", newdecl, newdecl);
1209           else
1210             pedwarn ("%Jnon-volatile declaration of '%D' follows "
1211                      "volatile declaration", newdecl, newdecl);
1212           pedwarned = true;
1213         }
1214       if (TREE_READONLY (newdecl) != TREE_READONLY (olddecl))
1215         {
1216           if (TREE_READONLY (newdecl))
1217             pedwarn ("%Jconst declaration of '%D' follows "
1218                      "non-const declaration", newdecl, newdecl);
1219           else
1220             pedwarn ("%Jnon-const declaration of '%D' follows "
1221                      "const declaration", newdecl, newdecl);
1222           pedwarned = true;
1223         }
1224     }
1225
1226   /* Optional warning for completely redundant decls.  */
1227   if (!warned && !pedwarned
1228       && warn_redundant_decls
1229       /* Don't warn about a function declaration followed by a
1230          definition.  */
1231       && !(TREE_CODE (newdecl) == FUNCTION_DECL
1232            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
1233       /* Don't warn about an extern followed by a definition.  */
1234       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
1235       /* Don't warn about forward parameter decls.  */
1236       && !(TREE_CODE (newdecl) == PARM_DECL
1237            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)))
1238     {
1239       warning ("%Jredundant redeclaration of '%D'", newdecl, newdecl);
1240       warned = true;
1241     }
1242
1243   /* Report location of previous decl/defn in a consistent manner.  */
1244   if (warned || pedwarned)
1245     locate_old_decl (olddecl, pedwarned ? pedwarn : warning);
1246
1247   return true;
1248 }
1249
1250 /* Subroutine of duplicate_decls.  NEWDECL has been found to be
1251    consistent with OLDDECL, but carries new information.  Merge the
1252    new information into OLDDECL.  This function issues no
1253    diagnostics.  */
1254
1255 static void
1256 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
1257 {
1258   int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1259                            && DECL_INITIAL (newdecl) != 0);
1260
1261   /* For real parm decl following a forward decl, return 1 so old decl
1262      will be reused.  Only allow this to happen once.  */
1263   if (TREE_CODE (newdecl) == PARM_DECL
1264       && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
1265     {
1266       TREE_ASM_WRITTEN (olddecl) = 0;
1267       return;
1268     }
1269
1270   DECL_ATTRIBUTES (newdecl)
1271     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1272
1273   /* Merge the data types specified in the two decls.  */
1274   TREE_TYPE (newdecl)
1275     = TREE_TYPE (olddecl)
1276     = common_type (newtype, oldtype);
1277
1278   /* Lay the type out, unless already done.  */
1279   if (oldtype != TREE_TYPE (newdecl))
1280     {
1281       if (TREE_TYPE (newdecl) != error_mark_node)
1282         layout_type (TREE_TYPE (newdecl));
1283       if (TREE_CODE (newdecl) != FUNCTION_DECL
1284           && TREE_CODE (newdecl) != TYPE_DECL
1285           && TREE_CODE (newdecl) != CONST_DECL)
1286         layout_decl (newdecl, 0);
1287     }
1288   else
1289     {
1290       /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
1291       DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1292       DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1293       DECL_MODE (newdecl) = DECL_MODE (olddecl);
1294       if (TREE_CODE (olddecl) != FUNCTION_DECL)
1295         if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1296           {
1297             DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1298             DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1299           }
1300     }
1301
1302   /* Keep the old rtl since we can safely use it.  */
1303   COPY_DECL_RTL (olddecl, newdecl);
1304
1305   /* Merge the type qualifiers.  */
1306   if (TREE_READONLY (newdecl))
1307     TREE_READONLY (olddecl) = 1;
1308
1309   if (TREE_THIS_VOLATILE (newdecl))
1310     {
1311       TREE_THIS_VOLATILE (olddecl) = 1;
1312       if (TREE_CODE (newdecl) == VAR_DECL)
1313         make_var_volatile (newdecl);
1314     }
1315
1316   /* Keep source location of definition rather than declaration.  */
1317   if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
1318     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1319
1320   /* Merge the unused-warning information.  */
1321   if (DECL_IN_SYSTEM_HEADER (olddecl))
1322     DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1323   else if (DECL_IN_SYSTEM_HEADER (newdecl))
1324     DECL_IN_SYSTEM_HEADER (olddecl) = 1;
1325
1326   /* Merge the initialization information.  */
1327    if (DECL_INITIAL (newdecl) == 0)
1328     DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1329
1330   /* Merge the section attribute.
1331      We want to issue an error if the sections conflict but that must be
1332      done later in decl_attributes since we are called before attributes
1333      are assigned.  */
1334   if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1335     DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1336
1337   /* Copy the assembler name.
1338      Currently, it can only be defined in the prototype.  */
1339   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1340
1341   /* If either declaration has a nondefault visibility, use it.  */
1342   if (DECL_VISIBILITY (olddecl) != VISIBILITY_DEFAULT)
1343     DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1344
1345   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1346     {
1347       DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1348       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1349       DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1350       DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1351         |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1352       TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1353       TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1354       DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1355       DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1356     }
1357
1358   /* Merge the storage class information.  */
1359   merge_weak (newdecl, olddecl);
1360
1361   /* For functions, static overrides non-static.  */
1362   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1363     {
1364       TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1365       /* This is since we don't automatically
1366          copy the attributes of NEWDECL into OLDDECL.  */
1367       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1368       /* If this clears `static', clear it in the identifier too.  */
1369       if (! TREE_PUBLIC (olddecl))
1370         TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1371     }
1372   if (DECL_EXTERNAL (newdecl))
1373     {
1374       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1375       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1376
1377       /* An extern decl does not override previous storage class.  */
1378       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1379       if (! DECL_EXTERNAL (newdecl))
1380         {
1381           DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1382           DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1383         }
1384     }
1385   else
1386     {
1387       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1388       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1389     }
1390
1391   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1392     {
1393       /* If we're redefining a function previously defined as extern
1394          inline, make sure we emit debug info for the inline before we
1395          throw it away, in case it was inlined into a function that hasn't
1396          been written out yet.  */
1397       if (new_is_definition && DECL_INITIAL (olddecl))
1398         {
1399           if (TREE_USED (olddecl)
1400               /* In unit-at-a-time mode we never inline re-defined extern
1401                  inline functions.  */
1402               && !flag_unit_at_a_time
1403               && cgraph_function_possibly_inlined_p (olddecl))
1404             (*debug_hooks->outlining_inline_function) (olddecl);
1405
1406           /* The new defn must not be inline.  */
1407           DECL_INLINE (newdecl) = 0;
1408           DECL_UNINLINABLE (newdecl) = 1;
1409         }
1410       else
1411         {
1412           /* If either decl says `inline', this fn is inline,
1413              unless its definition was passed already.  */
1414           if (DECL_DECLARED_INLINE_P (newdecl)
1415               || DECL_DECLARED_INLINE_P (olddecl))
1416             DECL_DECLARED_INLINE_P (newdecl) = 1;
1417
1418           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1419             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1420         }
1421
1422       if (DECL_BUILT_IN (olddecl))
1423         {
1424           /* If redeclaring a builtin function, it stays built in.  */
1425           DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1426           DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1427         }
1428
1429       /* Also preserve various other info from the definition.  */
1430       if (! new_is_definition)
1431         {
1432           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1433           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1434           DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1435           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1436           DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1437
1438           /* Set DECL_INLINE on the declaration if we've got a body
1439              from which to instantiate.  */
1440           if (DECL_INLINE (olddecl) && ! DECL_UNINLINABLE (newdecl))
1441             {
1442               DECL_INLINE (newdecl) = 1;
1443               DECL_ABSTRACT_ORIGIN (newdecl)
1444                 = DECL_ABSTRACT_ORIGIN (olddecl);
1445             }
1446         }
1447       else
1448         {
1449           /* If a previous declaration said inline, mark the
1450              definition as inlinable.  */
1451           if (DECL_DECLARED_INLINE_P (newdecl)
1452               && ! DECL_UNINLINABLE (newdecl))
1453             DECL_INLINE (newdecl) = 1;
1454         }
1455     }
1456
1457   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1458      But preserve OLDDECL's DECL_UID.  */
1459   {
1460     unsigned olddecl_uid = DECL_UID (olddecl);
1461
1462     memcpy ((char *) olddecl + sizeof (struct tree_common),
1463             (char *) newdecl + sizeof (struct tree_common),
1464             sizeof (struct tree_decl) - sizeof (struct tree_common));
1465     DECL_UID (olddecl) = olddecl_uid;
1466   }
1467
1468   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1469      so that encode_section_info has a chance to look at the new decl
1470      flags and attributes.  */
1471   if (DECL_RTL_SET_P (olddecl)
1472       && (TREE_CODE (olddecl) == FUNCTION_DECL
1473           || (TREE_CODE (olddecl) == VAR_DECL
1474               && TREE_STATIC (olddecl))))
1475     make_decl_rtl (olddecl, NULL);
1476 }
1477
1478 /* Handle when a new declaration NEWDECL has the same name as an old
1479    one OLDDECL in the same binding contour.  Prints an error message
1480    if appropriate.
1481
1482    If safely possible, alter OLDDECL to look like NEWDECL, and return
1483    true.  Otherwise, return false.  */
1484
1485 static bool
1486 duplicate_decls (tree newdecl, tree olddecl)
1487 {
1488   tree newtype, oldtype;
1489
1490   if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
1491     return false;
1492
1493   merge_decls (newdecl, olddecl, newtype, oldtype);
1494   return true;
1495 }
1496
1497 \f
1498 /* Return any external DECL associated with ID, whether or not it is
1499    currently in scope.  */
1500
1501 static tree
1502 any_external_decl (tree id)
1503 {
1504   tree decl = IDENTIFIER_SYMBOL_VALUE (id);
1505   tree t;
1506
1507   if (decl == 0 || TREE_CODE (decl) == ERROR_MARK)
1508     return 0;
1509   else if (TREE_CODE (decl) != TYPE_DECL && DECL_EXTERNAL (decl))
1510     return decl;
1511
1512   t = purpose_member (id, truly_local_externals);
1513   if (t)
1514     return TREE_VALUE (t);
1515
1516   return 0;
1517 }
1518
1519 /* Record an external decl DECL.  This only does something if a
1520    shadowing decl already exists.  */
1521 static void
1522 record_external_decl (tree decl)
1523 {
1524   tree name = DECL_NAME (decl);
1525   if (!IDENTIFIER_SYMBOL_VALUE (name))
1526     return;
1527
1528   truly_local_externals = tree_cons (name, decl, truly_local_externals);
1529 }
1530
1531 /* Check whether decl-node X shadows an existing declaration.
1532    OLD is the old IDENTIFIER_SYMBOL_VALUE of the DECL_NAME of X,
1533    which might be a NULL_TREE.  */
1534 static void
1535 warn_if_shadowing (tree x, tree old)
1536 {
1537   /* Nothing to shadow?  */
1538   if (old == 0
1539       /* Shadow warnings not wanted?  */
1540       || !warn_shadow
1541       /* No shadow warnings for internally generated vars.  */
1542       || DECL_SOURCE_LINE (x) == 0
1543       /* No shadow warnings for vars made for inlining.  */
1544       || DECL_FROM_INLINE (x)
1545       /* Don't warn about the parm names in function declarator
1546          within a function declarator.
1547          It would be nice to avoid warning in any function
1548          declarator in a declaration, as opposed to a definition,
1549          but there is no way to tell it's not a definition.  */
1550       || (TREE_CODE (x) == PARM_DECL && current_scope->outer->parm_flag))
1551     return;
1552
1553   if (TREE_CODE (old) == PARM_DECL)
1554     warning ("%Jdeclaration of '%D' shadows a parameter", x, x);
1555   else if (DECL_FILE_SCOPE_P (old))
1556     warning ("%Jdeclaration of '%D' shadows a global declaration", x, x);
1557   else
1558     warning ("%Jdeclaration of '%D' shadows a previous local", x, x);
1559
1560   warning ("%Jshadowed declaration is here", old);
1561 }
1562
1563
1564 /* Subroutine of pushdecl.
1565
1566    X is a TYPE_DECL for a typedef statement.  Create a brand new
1567    ..._TYPE node (which will be just a variant of the existing
1568    ..._TYPE node with identical properties) and then install X
1569    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1570
1571    The whole point here is to end up with a situation where each
1572    and every ..._TYPE node the compiler creates will be uniquely
1573    associated with AT MOST one node representing a typedef name.
1574    This way, even though the compiler substitutes corresponding
1575    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1576    early on, later parts of the compiler can always do the reverse
1577    translation and get back the corresponding typedef name.  For
1578    example, given:
1579
1580         typedef struct S MY_TYPE;
1581         MY_TYPE object;
1582
1583    Later parts of the compiler might only know that `object' was of
1584    type `struct S' if it were not for code just below.  With this
1585    code however, later parts of the compiler see something like:
1586
1587         struct S' == struct S
1588         typedef struct S' MY_TYPE;
1589         struct S' object;
1590
1591     And they can then deduce (from the node for type struct S') that
1592     the original object declaration was:
1593
1594                 MY_TYPE object;
1595
1596     Being able to do this is important for proper support of protoize,
1597     and also for generating precise symbolic debugging information
1598     which takes full account of the programmer's (typedef) vocabulary.
1599
1600     Obviously, we don't want to generate a duplicate ..._TYPE node if
1601     the TYPE_DECL node that we are now processing really represents a
1602     standard built-in type.
1603
1604     Since all standard types are effectively declared at line zero
1605     in the source file, we can easily check to see if we are working
1606     on a standard type by checking the current value of lineno.  */
1607
1608 static void
1609 clone_underlying_type (tree x)
1610 {
1611   if (DECL_SOURCE_LINE (x) == 0)
1612     {
1613       if (TYPE_NAME (TREE_TYPE (x)) == 0)
1614         TYPE_NAME (TREE_TYPE (x)) = x;
1615     }
1616   else if (TREE_TYPE (x) != error_mark_node
1617            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
1618     {
1619       tree tt = TREE_TYPE (x);
1620       DECL_ORIGINAL_TYPE (x) = tt;
1621       tt = build_type_copy (tt);
1622       TYPE_NAME (tt) = x;
1623       TREE_USED (tt) = TREE_USED (x);
1624       TREE_TYPE (x) = tt;
1625     }
1626 }
1627
1628 /* Record a decl-node X as belonging to the current lexical scope.
1629    Check for errors (such as an incompatible declaration for the same
1630    name already seen in the same scope).
1631
1632    Returns either X or an old decl for the same name.
1633    If an old decl is returned, it may have been smashed
1634    to agree with what X says.  */
1635
1636 tree
1637 pushdecl (tree x)
1638 {
1639   tree name = DECL_NAME (x);
1640   struct c_scope *scope = current_scope;
1641
1642 #ifdef ENABLE_CHECKING
1643   if (error_mark_node == 0)
1644     /* Called too early.  */
1645     abort ();
1646 #endif
1647
1648   /* Functions need the lang_decl data.  */
1649   if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
1650     DECL_LANG_SPECIFIC (x) = ggc_alloc_cleared (sizeof (struct lang_decl));
1651
1652   /* A local extern declaration for a function doesn't constitute nesting.
1653      A local auto declaration does, since it's a forward decl
1654      for a nested function coming later.  */
1655   if (current_function_decl == NULL
1656       || ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
1657           && DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x)))
1658     DECL_CONTEXT (x) = current_file_decl;
1659   else
1660     DECL_CONTEXT (x) = current_function_decl;
1661
1662   if (name)
1663     {
1664       tree old;
1665
1666       if (warn_nested_externs
1667           && scope != global_scope
1668           && DECL_EXTERNAL (x)
1669           && !DECL_IN_SYSTEM_HEADER (x))
1670         warning ("nested extern declaration of `%s'",
1671                  IDENTIFIER_POINTER (name));
1672
1673       old = lookup_name_current_level (name);
1674       if (old && duplicate_decls (x, old))
1675         {
1676           /* For PARM_DECLs, old may be a forward declaration.
1677              If so, we want to remove it from its old location
1678              (in the variables chain) and rechain it in the
1679              location given by the new declaration.  */
1680           if (TREE_CODE (x) == PARM_DECL)
1681             {
1682               tree *p;
1683               for (p = &scope->names; *p; p = &TREE_CHAIN (*p))
1684                 if (*p == old)
1685                   {
1686                     *p = TREE_CHAIN (old);
1687                     SCOPE_LIST_APPEND (scope, parms, old);
1688                     break;
1689                   }
1690             }
1691           return old;
1692         }
1693       if (DECL_EXTERNAL (x) || scope == global_scope)
1694         {
1695           /* Find and check against a previous, not-in-scope, external
1696              decl for this identifier.  (C99 6.2.7p2: All declarations
1697              that refer to the same object or function shall have
1698              compatible type; otherwise, the behavior is undefined.)  */
1699           tree ext = any_external_decl (name);
1700           if (ext)
1701             {
1702               if (duplicate_decls (x, ext))
1703                 {
1704                   /* XXX This copy_node call violates the basic
1705                      assumption that there is only one DECL for any
1706                      given object.  This causes all sorts of problems
1707                      elsewhere.  To correct it we must stop chaining
1708                      DECLs directly within the scope structure (work
1709                      in progress).  -zw 2004-03-05  */
1710                   x = copy_node (ext);
1711
1712                   /* Kludge around one of the worst consequences of
1713                      the above copy_node call, viz. that the arg_info
1714                      block created by get_parm_info can survive in a
1715                      copied FUNCTION_DECL after store_parm_decls is
1716                      done with it, and confuse the debug info
1717                      generators.  */
1718                   if (TREE_CODE (ext) == FUNCTION_DECL
1719                       && DECL_ARGUMENTS (ext)
1720                       && TREE_CODE (DECL_ARGUMENTS (ext)) == TREE_LIST)
1721                     DECL_ARGUMENTS (ext) = 0;
1722                 }
1723             }
1724           else
1725             record_external_decl (x);
1726         }
1727
1728       if (TREE_CODE (x) == TYPE_DECL)
1729         clone_underlying_type (x);
1730
1731       /* If storing a local value, there may already be one
1732          (inherited).  If so, record it for restoration when this
1733          scope ends.  Take care not to do this if we are replacing an
1734          older decl in the same scope (i.e.  duplicate_decls returned
1735          false, above).  */
1736       if (scope != global_scope
1737           && IDENTIFIER_SYMBOL_VALUE (name)
1738           && IDENTIFIER_SYMBOL_VALUE (name) != old)
1739         {
1740           warn_if_shadowing (x, IDENTIFIER_SYMBOL_VALUE (name));
1741           scope->shadowed = tree_cons (name, IDENTIFIER_SYMBOL_VALUE (name),
1742                                        scope->shadowed);
1743         }
1744
1745       /* Install the new declaration in the requested scope.  */
1746       IDENTIFIER_SYMBOL_VALUE (name) = x;
1747       C_DECL_INVISIBLE (x) = 0;
1748
1749       /* If x's type is incomplete because it's based on a
1750          structure or union which has not yet been fully declared,
1751          attach it to that structure or union type, so we can go
1752          back and complete the variable declaration later, if the
1753          structure or union gets fully declared.
1754
1755          If the input is erroneous, we can have error_mark in the type
1756          slot (e.g. "f(void a, ...)") - that doesn't count as an
1757          incomplete type.  */
1758       if (TREE_TYPE (x) != error_mark_node
1759           && !COMPLETE_TYPE_P (TREE_TYPE (x)))
1760         {
1761           tree element = TREE_TYPE (x);
1762
1763           while (TREE_CODE (element) == ARRAY_TYPE)
1764             element = TREE_TYPE (element);
1765           element = TYPE_MAIN_VARIANT (element);
1766
1767           if ((TREE_CODE (element) == RECORD_TYPE
1768                || TREE_CODE (element) == UNION_TYPE)
1769               && (TREE_CODE (x) != TYPE_DECL
1770                   || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
1771               && !COMPLETE_TYPE_P (element))
1772             C_TYPE_INCOMPLETE_VARS (element)
1773               = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
1774         }
1775     }
1776
1777   if (TREE_CODE (x) == PARM_DECL)
1778     SCOPE_LIST_APPEND (scope, parms, x);
1779   else
1780     SCOPE_LIST_APPEND (scope, names, x);
1781
1782   return x;
1783 }
1784
1785 /* Record X as belonging to the global scope (C99 "file scope").
1786    This is used only internally by the Objective-C front end,
1787    and is limited to its needs.  duplicate_decls is not called;
1788    if there is any preexisting decl for this identifier, it is an ICE.  */
1789
1790 tree
1791 pushdecl_top_level (tree x)
1792 {
1793   tree name;
1794
1795   if (TREE_CODE (x) != VAR_DECL)
1796     abort ();
1797
1798   name = DECL_NAME (x);
1799
1800   if (IDENTIFIER_SYMBOL_VALUE (name))
1801     abort ();
1802
1803   DECL_CONTEXT (x) = current_file_decl;
1804   IDENTIFIER_SYMBOL_VALUE (name) = x;
1805
1806   SCOPE_LIST_APPEND (global_scope, names, x);
1807   return x;
1808 }
1809 \f
1810 /* Generate an implicit declaration for identifier FUNCTIONID as a
1811    function of type int ().  */
1812
1813 tree
1814 implicitly_declare (tree functionid)
1815 {
1816   tree decl = any_external_decl (functionid);
1817
1818   if (decl)
1819     {
1820       /* Implicit declaration of a function already declared
1821          (somehow) in a different scope, or as a built-in.
1822          If this is the first time this has happened, warn;
1823          then recycle the old declaration.  */
1824       if (!C_DECL_IMPLICIT (decl))
1825         {
1826           implicit_decl_warning (DECL_NAME (decl));
1827           if (! DECL_FILE_SCOPE_P (decl))
1828             warning ("%Jprevious declaration of '%D'", decl, decl);
1829           C_DECL_IMPLICIT (decl) = 1;
1830         }
1831       /* If this function is global, then it must already be in the
1832          global scope, so there's no need to push it again.  */
1833       if (current_scope == global_scope)
1834         return decl;
1835       /* If this is a local declaration, make a copy; we can't have
1836          the same DECL listed in two different scopes.  */
1837       return pushdecl (copy_node (decl));
1838     }
1839
1840   /* Not seen before.  */
1841   decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
1842   DECL_EXTERNAL (decl) = 1;
1843   TREE_PUBLIC (decl) = 1;
1844   C_DECL_IMPLICIT (decl) = 1;
1845   implicit_decl_warning (functionid);
1846
1847   /* C89 says implicit declarations are in the innermost block.
1848      So we record the decl in the standard fashion.  */
1849   decl = pushdecl (decl);
1850
1851   /* No need to call objc_check_decl here - it's a function type.  */
1852   rest_of_decl_compilation (decl, NULL, 0, 0);
1853
1854   /* Write a record describing this implicit function declaration
1855      to the prototypes file (if requested).  */
1856   gen_aux_info_record (decl, 0, 1, 0);
1857
1858   /* Possibly apply some default attributes to this implicit declaration.  */
1859   decl_attributes (&decl, NULL_TREE, 0);
1860
1861   return decl;
1862 }
1863
1864 static void
1865 implicit_decl_warning (tree id)
1866 {
1867   const char *name = IDENTIFIER_POINTER (id);
1868   if (mesg_implicit_function_declaration == 2)
1869     error ("implicit declaration of function `%s'", name);
1870   else if (mesg_implicit_function_declaration == 1)
1871     warning ("implicit declaration of function `%s'", name);
1872 }
1873
1874 /* Issue an error message for a reference to an undeclared variable
1875    ID, including a reference to a builtin outside of function-call
1876    context.  Establish a binding of the identifier to error_mark_node
1877    in an appropriate scope, which will suppress further errors for the
1878    same identifier.  */
1879 void
1880 undeclared_variable (tree id)
1881 {
1882   static bool already = false;
1883   struct c_scope *scope;
1884
1885   if (current_function_decl == 0)
1886     {
1887       error ("`%s' undeclared here (not in a function)",
1888              IDENTIFIER_POINTER (id));
1889       scope = current_scope;
1890     }
1891   else
1892     {
1893       error ("`%s' undeclared (first use in this function)",
1894              IDENTIFIER_POINTER (id));
1895
1896       if (! already)
1897         {
1898           error ("(Each undeclared identifier is reported only once");
1899           error ("for each function it appears in.)");
1900           already = true;
1901         }
1902
1903       scope = current_function_scope;
1904     }
1905
1906   scope->shadowed = tree_cons (id, IDENTIFIER_SYMBOL_VALUE (id),
1907                                scope->shadowed);
1908   IDENTIFIER_SYMBOL_VALUE (id) = error_mark_node;
1909 }
1910 \f
1911 /* Subroutine of lookup_label, declare_label, define_label: construct a
1912    LABEL_DECL with all the proper frills.  */
1913
1914 static tree
1915 make_label (tree name, location_t location)
1916 {
1917   tree label = build_decl (LABEL_DECL, name, void_type_node);
1918
1919   DECL_CONTEXT (label) = current_function_decl;
1920   DECL_MODE (label) = VOIDmode;
1921   DECL_SOURCE_LOCATION (label) = location;
1922
1923   return label;
1924 }
1925
1926 /* Another subroutine of lookup_label, declare_label, define_label:
1927    set up the binding of name to LABEL_DECL in the given SCOPE.  */
1928
1929 static void
1930 bind_label (tree name, tree label, struct c_scope *scope)
1931 {
1932   if (IDENTIFIER_LABEL_VALUE (name))
1933     scope->shadowed = tree_cons (name, IDENTIFIER_LABEL_VALUE (name),
1934                                  scope->shadowed);
1935   IDENTIFIER_LABEL_VALUE (name) = label;
1936
1937   SCOPE_LIST_APPEND (scope, names, label);
1938 }
1939
1940 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
1941    Create one if none exists so far for the current function.
1942    This is called when a label is used in a goto expression or
1943    has its address taken.  */
1944
1945 tree
1946 lookup_label (tree name)
1947 {
1948   tree label;
1949
1950   if (current_function_decl == 0)
1951     {
1952       error ("label %s referenced outside of any function",
1953              IDENTIFIER_POINTER (name));
1954       return 0;
1955     }
1956
1957   /* Use a label already defined or ref'd with this name, but not if
1958      it is inherited from a containing function and wasn't declared
1959      using __label__.  */
1960   label = IDENTIFIER_LABEL_VALUE (name);
1961   if (label && (DECL_CONTEXT (label) == current_function_decl
1962                 || C_DECLARED_LABEL_FLAG (label)))
1963     {
1964       /* If the label has only been declared, update its apparent
1965          location to point here, for better diagnostics if it
1966          turns out not to have been defined.  */
1967       if (!TREE_USED (label))
1968         DECL_SOURCE_LOCATION (label) = input_location;
1969       return label;
1970     }
1971
1972   /* No label binding for that identifier; make one.  */
1973   label = make_label (name, input_location);
1974
1975   /* Ordinary labels go in the current function scope.  */
1976   bind_label (name, label, current_function_scope);
1977   return label;
1978 }
1979
1980 /* Make a label named NAME in the current function, shadowing silently
1981    any that may be inherited from containing functions or containing
1982    scopes.  This is called for __label__ declarations.  */
1983
1984 /* Note that valid use, if the label being shadowed comes from another
1985    scope in the same function, requires calling declare_nonlocal_label
1986    right away.  (Is this still true?  -zw 2003-07-17)  */
1987
1988 tree
1989 declare_label (tree name)
1990 {
1991   tree label = IDENTIFIER_LABEL_VALUE (name);
1992   tree dup;
1993
1994   /* Check to make sure that the label hasn't already been declared
1995      at this scope */
1996   for (dup = current_scope->names; dup; dup = TREE_CHAIN (dup))
1997     if (dup == label)
1998       {
1999         error ("duplicate label declaration `%s'", IDENTIFIER_POINTER (name));
2000         error ("%Jthis is a previous declaration", dup);
2001
2002         /* Just use the previous declaration.  */
2003         return dup;
2004       }
2005
2006   label = make_label (name, input_location);
2007   C_DECLARED_LABEL_FLAG (label) = 1;
2008
2009   /* Declared labels go in the current scope.  */
2010   bind_label (name, label, current_scope);
2011   return label;
2012 }
2013
2014 /* Define a label, specifying the location in the source file.
2015    Return the LABEL_DECL node for the label, if the definition is valid.
2016    Otherwise return 0.  */
2017
2018 tree
2019 define_label (location_t location, tree name)
2020 {
2021   tree label;
2022
2023   /* Find any preexisting label with this name.  It is an error
2024      if that label has already been defined in this function, or
2025      if there is a containing function with a declared label with
2026      the same name.  */
2027   label = IDENTIFIER_LABEL_VALUE (name);
2028
2029   if (label
2030       && ((DECL_CONTEXT (label) == current_function_decl
2031            && DECL_INITIAL (label) != 0)
2032           || (DECL_CONTEXT (label) != current_function_decl
2033               && C_DECLARED_LABEL_FLAG (label))))
2034     {
2035       error ("%Hduplicate label `%D'", &location, label);
2036       if (DECL_INITIAL (label))
2037         error ("%J`%D' previously defined here", label, label);
2038       else
2039         error ("%J`%D' previously declared here", label, label);
2040       return 0;
2041     }
2042   else if (label && DECL_CONTEXT (label) == current_function_decl)
2043     {
2044       /* The label has been used or declared already in this function,
2045          but not defined.  Update its location to point to this
2046          definition.  */
2047       DECL_SOURCE_LOCATION (label) = location;
2048     }
2049   else
2050     {
2051       /* No label binding for that identifier; make one.  */
2052       label = make_label (name, location);
2053
2054       /* Ordinary labels go in the current function scope.  */
2055       bind_label (name, label, current_function_scope);
2056     }
2057
2058   if (warn_traditional && !in_system_header && lookup_name (name))
2059     warning ("%Htraditional C lacks a separate namespace for labels, "
2060              "identifier `%s' conflicts", &location,
2061              IDENTIFIER_POINTER (name));
2062
2063   /* Mark label as having been defined.  */
2064   DECL_INITIAL (label) = error_mark_node;
2065   return label;
2066 }
2067 \f
2068 /* Return the list of declarations of the current scope.
2069    This hook is optional and not implemented for C.  */
2070
2071 tree
2072 getdecls (void)
2073 {
2074   return 0;
2075 }
2076
2077 \f
2078 /* Given NAME, an IDENTIFIER_NODE,
2079    return the structure (or union or enum) definition for that name.
2080    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
2081    CODE says which kind of type the caller wants;
2082    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2083    If the wrong kind of type is found, an error is reported.  */
2084
2085 static tree
2086 lookup_tag (enum tree_code code, tree name, int thislevel_only)
2087 {
2088   tree tag = IDENTIFIER_TAG_VALUE (name);
2089   int thislevel = 0;
2090
2091   if (!tag)
2092     return 0;
2093
2094   /* We only care about whether it's in this level if
2095      thislevel_only was set or it might be a type clash.  */
2096   if (thislevel_only || TREE_CODE (tag) != code)
2097     {
2098       if (current_scope == global_scope
2099           || purpose_member (name, current_scope->tags))
2100         thislevel = 1;
2101     }
2102
2103   if (thislevel_only && !thislevel)
2104     return 0;
2105
2106   if (TREE_CODE (tag) != code)
2107     {
2108       /* Definition isn't the kind we were looking for.  */
2109       pending_invalid_xref = name;
2110       pending_invalid_xref_location = input_location;
2111
2112       /* If in the same binding level as a declaration as a tag
2113          of a different type, this must not be allowed to
2114          shadow that tag, so give the error immediately.
2115          (For example, "struct foo; union foo;" is invalid.)  */
2116       if (thislevel)
2117         pending_xref_error ();
2118     }
2119   return tag;
2120 }
2121
2122 /* Print an error message now
2123    for a recent invalid struct, union or enum cross reference.
2124    We don't print them immediately because they are not invalid
2125    when used in the `struct foo;' construct for shadowing.  */
2126
2127 void
2128 pending_xref_error (void)
2129 {
2130   if (pending_invalid_xref != 0)
2131     error ("%H`%s' defined as wrong kind of tag",
2132            &pending_invalid_xref_location,
2133            IDENTIFIER_POINTER (pending_invalid_xref));
2134   pending_invalid_xref = 0;
2135 }
2136
2137 \f
2138 /* Look up NAME in the current scope and its superiors
2139    in the namespace of variables, functions and typedefs.
2140    Return a ..._DECL node of some kind representing its definition,
2141    or return 0 if it is undefined.  */
2142
2143 tree
2144 lookup_name (tree name)
2145 {
2146   tree decl = IDENTIFIER_SYMBOL_VALUE (name);
2147   if (decl == 0 || decl == error_mark_node)
2148     return decl;
2149   if (C_DECL_INVISIBLE (decl))
2150     return 0;
2151   return decl;
2152 }
2153
2154 /* Similar to `lookup_name' but look only at the current scope.  */
2155
2156 static tree
2157 lookup_name_current_level (tree name)
2158 {
2159   tree decl = IDENTIFIER_SYMBOL_VALUE (name);
2160
2161   if (decl == 0 || decl == error_mark_node || C_DECL_INVISIBLE (decl))
2162     return 0;
2163
2164   if (current_scope == global_scope)
2165     return decl;
2166
2167   /* Scan the current scope for a decl with name NAME.
2168      For PARM_DECLs, we have to look at both ->parms and ->names, since
2169      forward parameter declarations wind up on the ->names list.  */
2170   if (TREE_CODE (decl) == PARM_DECL
2171       && chain_member (decl, current_scope->parms))
2172     return decl;
2173   if (chain_member (decl, current_scope->names))
2174     return decl;
2175
2176   return 0;
2177 }
2178 \f
2179 /* Create the predefined scalar types of C,
2180    and some nodes representing standard constants (0, 1, (void *) 0).
2181    Initialize the global scope.
2182    Make definitions for built-in primitive functions.  */
2183
2184 void
2185 c_init_decl_processing (void)
2186 {
2187   tree endlink;
2188   tree ptr_ftype_void, ptr_ftype_ptr;
2189   location_t save_loc = input_location;
2190
2191   /* Adds some ggc roots, and reserved words for c-parse.in.  */
2192   c_parse_init ();
2193
2194   current_function_decl = 0;
2195
2196   /* Make the c_scope structure for global names.  */
2197   pushlevel (0);
2198   global_scope = current_scope;
2199
2200   /* Declarations from c_common_nodes_and_builtins must not be associated
2201      with this input file, lest we get differences between using and not
2202      using preprocessed headers.  */
2203   input_location.file = "<internal>";
2204   input_location.line = 0;
2205
2206   /* Make the DECL for the toplevel file scope.  */
2207   current_file_decl = build_decl (TRANSLATION_UNIT_DECL, NULL, NULL);
2208
2209   build_common_tree_nodes (flag_signed_char);
2210
2211   c_common_nodes_and_builtins ();
2212
2213   /* In C, comparisons and TRUTH_* expressions have type int.  */
2214   truthvalue_type_node = integer_type_node;
2215   truthvalue_true_node = integer_one_node;
2216   truthvalue_false_node = integer_zero_node;
2217
2218   /* Even in C99, which has a real boolean type.  */
2219   pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2220                         boolean_type_node));
2221
2222   endlink = void_list_node;
2223   ptr_ftype_void = build_function_type (ptr_type_node, endlink);
2224   ptr_ftype_ptr
2225     = build_function_type (ptr_type_node,
2226                            tree_cons (NULL_TREE, ptr_type_node, endlink));
2227
2228   input_location = save_loc;
2229
2230   pedantic_lvalues = true;
2231
2232   make_fname_decl = c_make_fname_decl;
2233   start_fname_decls ();
2234
2235   first_builtin_decl = global_scope->names;
2236   last_builtin_decl = global_scope->names_last;
2237 }
2238
2239 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2240    decl, NAME is the initialization string and TYPE_DEP indicates whether
2241    NAME depended on the type of the function.  As we don't yet implement
2242    delayed emission of static data, we mark the decl as emitted
2243    so it is not placed in the output.  Anything using it must therefore pull
2244    out the STRING_CST initializer directly.  FIXME.  */
2245
2246 static tree
2247 c_make_fname_decl (tree id, int type_dep)
2248 {
2249   const char *name = fname_as_string (type_dep);
2250   tree decl, type, init;
2251   size_t length = strlen (name);
2252
2253   type =  build_array_type
2254           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
2255            build_index_type (size_int (length)));
2256
2257   decl = build_decl (VAR_DECL, id, type);
2258
2259   TREE_STATIC (decl) = 1;
2260   TREE_READONLY (decl) = 1;
2261   DECL_ARTIFICIAL (decl) = 1;
2262
2263   init = build_string (length + 1, name);
2264   TREE_TYPE (init) = type;
2265   DECL_INITIAL (decl) = init;
2266
2267   TREE_USED (decl) = 1;
2268
2269   if (current_function_decl)
2270     {
2271       DECL_CONTEXT (decl) = current_function_decl;
2272       IDENTIFIER_SYMBOL_VALUE (id) = decl;
2273       SCOPE_LIST_APPEND (current_function_scope, names, decl);
2274     }
2275
2276   finish_decl (decl, init, NULL_TREE);
2277
2278   return decl;
2279 }
2280
2281 /* Return a definition for a builtin function named NAME and whose data type
2282    is TYPE.  TYPE should be a function type with argument types.
2283    FUNCTION_CODE tells later passes how to compile calls to this function.
2284    See tree.h for its possible values.
2285
2286    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2287    the name to be called if we can't opencode the function.  If
2288    ATTRS is nonzero, use that for the function's attribute list.  */
2289
2290 tree
2291 builtin_function (const char *name, tree type, int function_code,
2292                   enum built_in_class class, const char *library_name,
2293                   tree attrs)
2294 {
2295   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
2296   DECL_EXTERNAL (decl) = 1;
2297   TREE_PUBLIC (decl) = 1;
2298   if (library_name)
2299     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2300   make_decl_rtl (decl, NULL);
2301   pushdecl (decl);
2302   DECL_BUILT_IN_CLASS (decl) = class;
2303   DECL_FUNCTION_CODE (decl) = function_code;
2304
2305   /* Warn if a function in the namespace for users
2306      is used without an occasion to consider it declared.  */
2307   if (name[0] != '_' || name[1] != '_')
2308     C_DECL_INVISIBLE (decl) = 1;
2309
2310   /* Possibly apply some default attributes to this built-in function.  */
2311   if (attrs)
2312     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2313   else
2314     decl_attributes (&decl, NULL_TREE, 0);
2315
2316   return decl;
2317 }
2318 \f
2319 /* Called when a declaration is seen that contains no names to declare.
2320    If its type is a reference to a structure, union or enum inherited
2321    from a containing scope, shadow that tag name for the current scope
2322    with a forward reference.
2323    If its type defines a new named structure or union
2324    or defines an enum, it is valid but we need not do anything here.
2325    Otherwise, it is an error.  */
2326
2327 void
2328 shadow_tag (tree declspecs)
2329 {
2330   shadow_tag_warned (declspecs, 0);
2331 }
2332
2333 void
2334 shadow_tag_warned (tree declspecs, int warned)
2335
2336
2337      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
2338         no pedwarn.  */
2339 {
2340   int found_tag = 0;
2341   tree link;
2342   tree specs, attrs;
2343
2344   pending_invalid_xref = 0;
2345
2346   /* Remove the attributes from declspecs, since they will confuse the
2347      following code.  */
2348   split_specs_attrs (declspecs, &specs, &attrs);
2349
2350   for (link = specs; link; link = TREE_CHAIN (link))
2351     {
2352       tree value = TREE_VALUE (link);
2353       enum tree_code code = TREE_CODE (value);
2354
2355       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2356         /* Used to test also that TYPE_SIZE (value) != 0.
2357            That caused warning for `struct foo;' at top level in the file.  */
2358         {
2359           tree name = TYPE_NAME (value);
2360           tree t;
2361
2362           found_tag++;
2363
2364           if (name == 0)
2365             {
2366               if (warned != 1 && code != ENUMERAL_TYPE)
2367                 /* Empty unnamed enum OK */
2368                 {
2369                   pedwarn ("unnamed struct/union that defines no instances");
2370                   warned = 1;
2371                 }
2372             }
2373           else
2374             {
2375               t = lookup_tag (code, name, 1);
2376
2377               if (t == 0)
2378                 {
2379                   t = make_node (code);
2380                   pushtag (name, t);
2381                 }
2382             }
2383         }
2384       else
2385         {
2386           if (!warned && ! in_system_header)
2387             {
2388               warning ("useless keyword or type name in empty declaration");
2389               warned = 2;
2390             }
2391         }
2392     }
2393
2394   if (found_tag > 1)
2395     error ("two types specified in one empty declaration");
2396
2397   if (warned != 1)
2398     {
2399       if (found_tag == 0)
2400         pedwarn ("empty declaration");
2401     }
2402 }
2403 \f
2404 /* Construct an array declarator.  EXPR is the expression inside [], or
2405    NULL_TREE.  QUALS are the type qualifiers inside the [] (to be applied
2406    to the pointer to which a parameter array is converted).  STATIC_P is
2407    nonzero if "static" is inside the [], zero otherwise.  VLA_UNSPEC_P
2408    is nonzero is the array is [*], a VLA of unspecified length which is
2409    nevertheless a complete type (not currently implemented by GCC),
2410    zero otherwise.  The declarator is constructed as an ARRAY_REF
2411    (to be decoded by grokdeclarator), whose operand 0 is what's on the
2412    left of the [] (filled by in set_array_declarator_type) and operand 1
2413    is the expression inside; whose TREE_TYPE is the type qualifiers and
2414    which has TREE_STATIC set if "static" is used.  */
2415
2416 tree
2417 build_array_declarator (tree expr, tree quals, int static_p, int vla_unspec_p)
2418 {
2419   tree decl;
2420   decl = build_nt (ARRAY_REF, NULL_TREE, expr);
2421   TREE_TYPE (decl) = quals;
2422   TREE_STATIC (decl) = (static_p ? 1 : 0);
2423   if (pedantic && !flag_isoc99)
2424     {
2425       if (static_p || quals != NULL_TREE)
2426         pedwarn ("ISO C90 does not support `static' or type qualifiers in parameter array declarators");
2427       if (vla_unspec_p)
2428         pedwarn ("ISO C90 does not support `[*]' array declarators");
2429     }
2430   if (vla_unspec_p)
2431     warning ("GCC does not yet properly implement `[*]' array declarators");
2432   return decl;
2433 }
2434
2435 /* Set the type of an array declarator.  DECL is the declarator, as
2436    constructed by build_array_declarator; TYPE is what appears on the left
2437    of the [] and goes in operand 0.  ABSTRACT_P is nonzero if it is an
2438    abstract declarator, zero otherwise; this is used to reject static and
2439    type qualifiers in abstract declarators, where they are not in the
2440    C99 grammar.  */
2441
2442 tree
2443 set_array_declarator_type (tree decl, tree type, int abstract_p)
2444 {
2445   TREE_OPERAND (decl, 0) = type;
2446   if (abstract_p && (TREE_TYPE (decl) != NULL_TREE || TREE_STATIC (decl)))
2447     error ("static or type qualifiers in abstract declarator");
2448   return decl;
2449 }
2450 \f
2451 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
2452
2453 tree
2454 groktypename (tree typename)
2455 {
2456   tree specs, attrs;
2457
2458   if (TREE_CODE (typename) != TREE_LIST)
2459     return typename;
2460
2461   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
2462
2463   typename = grokdeclarator (TREE_VALUE (typename), specs, TYPENAME, 0,
2464                              NULL);
2465
2466   /* Apply attributes.  */
2467   decl_attributes (&typename, attrs, 0);
2468
2469   return typename;
2470 }
2471
2472 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
2473
2474 tree
2475 groktypename_in_parm_context (tree typename)
2476 {
2477   if (TREE_CODE (typename) != TREE_LIST)
2478     return typename;
2479   return grokdeclarator (TREE_VALUE (typename),
2480                          TREE_PURPOSE (typename),
2481                          PARM, 0, NULL);
2482 }
2483
2484 /* Decode a declarator in an ordinary declaration or data definition.
2485    This is called as soon as the type information and variable name
2486    have been parsed, before parsing the initializer if any.
2487    Here we create the ..._DECL node, fill in its type,
2488    and put it on the list of decls for the current context.
2489    The ..._DECL node is returned as the value.
2490
2491    Exception: for arrays where the length is not specified,
2492    the type is left null, to be filled in by `finish_decl'.
2493
2494    Function definitions do not come here; they go to start_function
2495    instead.  However, external and forward declarations of functions
2496    do go through here.  Structure field declarations are done by
2497    grokfield and not through here.  */
2498
2499 tree
2500 start_decl (tree declarator, tree declspecs, int initialized, tree attributes)
2501 {
2502   tree decl;
2503   tree tem;
2504
2505   /* An object declared as __attribute__((deprecated)) suppresses
2506      warnings of uses of other deprecated items.  */
2507   if (lookup_attribute ("deprecated", attributes))
2508     deprecated_state = DEPRECATED_SUPPRESS;
2509
2510   decl = grokdeclarator (declarator, declspecs,
2511                          NORMAL, initialized, NULL);
2512
2513   deprecated_state = DEPRECATED_NORMAL;
2514
2515   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
2516       && MAIN_NAME_P (DECL_NAME (decl)))
2517     warning ("%J'%D' is usually a function", decl, decl);
2518
2519   if (initialized)
2520     /* Is it valid for this decl to have an initializer at all?
2521        If not, set INITIALIZED to zero, which will indirectly
2522        tell `finish_decl' to ignore the initializer once it is parsed.  */
2523     switch (TREE_CODE (decl))
2524       {
2525       case TYPE_DECL:
2526         error ("typedef `%s' is initialized (use __typeof__ instead)",
2527                IDENTIFIER_POINTER (DECL_NAME (decl)));
2528         initialized = 0;
2529         break;
2530
2531       case FUNCTION_DECL:
2532         error ("function `%s' is initialized like a variable",
2533                IDENTIFIER_POINTER (DECL_NAME (decl)));
2534         initialized = 0;
2535         break;
2536
2537       case PARM_DECL:
2538         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
2539         error ("parameter `%s' is initialized",
2540                IDENTIFIER_POINTER (DECL_NAME (decl)));
2541         initialized = 0;
2542         break;
2543
2544       default:
2545         /* Don't allow initializations for incomplete types
2546            except for arrays which might be completed by the initialization.  */
2547
2548         /* This can happen if the array size is an undefined macro.  We already
2549            gave a warning, so we don't need another one.  */
2550         if (TREE_TYPE (decl) == error_mark_node)
2551           initialized = 0;
2552         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
2553           {
2554             /* A complete type is ok if size is fixed.  */
2555
2556             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
2557                 || C_DECL_VARIABLE_SIZE (decl))
2558               {
2559                 error ("variable-sized object may not be initialized");
2560                 initialized = 0;
2561               }
2562           }
2563         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
2564           {
2565             error ("variable `%s' has initializer but incomplete type",
2566                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2567             initialized = 0;
2568           }
2569         else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
2570           {
2571             error ("elements of array `%s' have incomplete type",
2572                    IDENTIFIER_POINTER (DECL_NAME (decl)));
2573             initialized = 0;
2574           }
2575       }
2576
2577   if (initialized)
2578     {
2579       DECL_EXTERNAL (decl) = 0;
2580       if (current_scope == global_scope)
2581         TREE_STATIC (decl) = 1;
2582
2583       /* Tell `pushdecl' this is an initialized decl
2584          even though we don't yet have the initializer expression.
2585          Also tell `finish_decl' it may store the real initializer.  */
2586       DECL_INITIAL (decl) = error_mark_node;
2587     }
2588
2589   /* If this is a function declaration, write a record describing it to the
2590      prototypes file (if requested).  */
2591
2592   if (TREE_CODE (decl) == FUNCTION_DECL)
2593     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
2594
2595   /* ANSI specifies that a tentative definition which is not merged with
2596      a non-tentative definition behaves exactly like a definition with an
2597      initializer equal to zero.  (Section 3.7.2)
2598
2599      -fno-common gives strict ANSI behavior, though this tends to break
2600      a large body of code that grew up without this rule.
2601
2602      Thread-local variables are never common, since there's no entrenched
2603      body of code to break, and it allows more efficient variable references
2604      in the presence of dynamic linking.  */
2605
2606   if (TREE_CODE (decl) == VAR_DECL
2607       && !initialized
2608       && TREE_PUBLIC (decl)
2609       && !DECL_THREAD_LOCAL (decl)
2610       && !flag_no_common)
2611     DECL_COMMON (decl) = 1;
2612
2613   /* Set attributes here so if duplicate decl, will have proper attributes.  */
2614   decl_attributes (&decl, attributes, 0);
2615
2616   if (TREE_CODE (decl) == FUNCTION_DECL
2617       && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
2618     {
2619       tree ce = declarator;
2620
2621       if (TREE_CODE (ce) == INDIRECT_REF)
2622         ce = TREE_OPERAND (declarator, 0);
2623       if (TREE_CODE (ce) == CALL_EXPR)
2624         {
2625           tree args = TREE_PURPOSE (TREE_OPERAND (ce, 1));
2626           for (; args; args = TREE_CHAIN (args))
2627             {
2628               tree type = TREE_TYPE (args);
2629               if (INTEGRAL_TYPE_P (type)
2630                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
2631                 DECL_ARG_TYPE (args) = integer_type_node;
2632             }
2633         }
2634     }
2635
2636   if (TREE_CODE (decl) == FUNCTION_DECL
2637       && DECL_DECLARED_INLINE_P (decl)
2638       && DECL_UNINLINABLE (decl)
2639       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
2640     warning ("%Jinline function '%D' given attribute noinline", decl, decl);
2641
2642   /* Add this decl to the current scope.
2643      TEM may equal DECL or it may be a previous decl of the same name.  */
2644   tem = pushdecl (decl);
2645
2646   /* For a local variable, define the RTL now.  */
2647   if (current_scope != global_scope
2648       /* But not if this is a duplicate decl
2649          and we preserved the rtl from the previous one
2650          (which may or may not happen).  */
2651       && !DECL_RTL_SET_P (tem)
2652       && DECL_FILE_SCOPE_P (tem))
2653     {
2654       if (TREE_TYPE (tem) != error_mark_node
2655           && (COMPLETE_TYPE_P (TREE_TYPE (tem))
2656               || (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
2657                   && DECL_INITIAL (tem) != 0)))
2658         expand_decl (tem);
2659     }
2660
2661   return tem;
2662 }
2663
2664 /* Finish processing of a declaration;
2665    install its initial value.
2666    If the length of an array type is not known before,
2667    it must be determined now, from the initial value, or it is an error.  */
2668
2669 void
2670 finish_decl (tree decl, tree init, tree asmspec_tree)
2671 {
2672   tree type = TREE_TYPE (decl);
2673   int was_incomplete = (DECL_SIZE (decl) == 0);
2674   const char *asmspec = 0;
2675
2676   /* If a name was specified, get the string.  */
2677   if (current_scope == global_scope)
2678     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
2679   if (asmspec_tree)
2680     asmspec = TREE_STRING_POINTER (asmspec_tree);
2681
2682   /* If `start_decl' didn't like having an initialization, ignore it now.  */
2683   if (init != 0 && DECL_INITIAL (decl) == 0)
2684     init = 0;
2685
2686   /* Don't crash if parm is initialized.  */
2687   if (TREE_CODE (decl) == PARM_DECL)
2688     init = 0;
2689
2690   if (init)
2691     store_init_value (decl, init);
2692
2693   if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
2694                     || TREE_CODE (decl) == FUNCTION_DECL
2695                     || TREE_CODE (decl) == FIELD_DECL))
2696     objc_check_decl (decl);
2697
2698   /* Deduce size of array from initialization, if not already known.  */
2699   if (TREE_CODE (type) == ARRAY_TYPE
2700       && TYPE_DOMAIN (type) == 0
2701       && TREE_CODE (decl) != TYPE_DECL)
2702     {
2703       int do_default
2704         = (TREE_STATIC (decl)
2705            /* Even if pedantic, an external linkage array
2706               may have incomplete type at first.  */
2707            ? pedantic && !TREE_PUBLIC (decl)
2708            : !DECL_EXTERNAL (decl));
2709       int failure
2710         = complete_array_type (type, DECL_INITIAL (decl), do_default);
2711
2712       /* Get the completed type made by complete_array_type.  */
2713       type = TREE_TYPE (decl);
2714
2715       if (failure == 1)
2716         error ("%Jinitializer fails to determine size of '%D'", decl, decl);
2717
2718       else if (failure == 2)
2719         {
2720           if (do_default)
2721             error ("%Jarray size missing in '%D'", decl, decl);
2722           /* If a `static' var's size isn't known,
2723              make it extern as well as static, so it does not get
2724              allocated.
2725              If it is not `static', then do not mark extern;
2726              finish_incomplete_decl will give it a default size
2727              and it will get allocated.  */
2728           else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
2729             DECL_EXTERNAL (decl) = 1;
2730         }
2731
2732       /* TYPE_MAX_VALUE is always one less than the number of elements
2733          in the array, because we start counting at zero.  Therefore,
2734          warn only if the value is less than zero.  */
2735       else if (pedantic && TYPE_DOMAIN (type) != 0
2736               && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
2737         error ("%Jzero or negative size array '%D'", decl, decl);
2738
2739       layout_decl (decl, 0);
2740     }
2741
2742   if (TREE_CODE (decl) == VAR_DECL)
2743     {
2744       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
2745           && COMPLETE_TYPE_P (TREE_TYPE (decl)))
2746         layout_decl (decl, 0);
2747
2748       if (DECL_SIZE (decl) == 0
2749           /* Don't give an error if we already gave one earlier.  */
2750           && TREE_TYPE (decl) != error_mark_node
2751           && (TREE_STATIC (decl)
2752               ?
2753                 /* A static variable with an incomplete type
2754                    is an error if it is initialized.
2755                    Also if it is not file scope.
2756                    Otherwise, let it through, but if it is not `extern'
2757                    then it may cause an error message later.  */
2758                 (DECL_INITIAL (decl) != 0
2759                  || !DECL_FILE_SCOPE_P (decl))
2760               :
2761                 /* An automatic variable with an incomplete type
2762                    is an error.  */
2763                 !DECL_EXTERNAL (decl)))
2764         {
2765           error ("%Jstorage size of '%D' isn't known", decl, decl);
2766           TREE_TYPE (decl) = error_mark_node;
2767         }
2768
2769       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
2770           && DECL_SIZE (decl) != 0)
2771         {
2772           if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
2773             constant_expression_warning (DECL_SIZE (decl));
2774           else
2775             error ("%Jstorage size of '%D' isn't constant", decl, decl);
2776         }
2777
2778       if (TREE_USED (type))
2779         TREE_USED (decl) = 1;
2780     }
2781
2782   /* If this is a function and an assembler name is specified, reset DECL_RTL
2783      so we can give it its new name.  Also, update built_in_decls if it
2784      was a normal built-in.  */
2785   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
2786     {
2787       /* ASMSPEC is given, and not the name of a register.  Mark the
2788       name with a star so assemble_name won't munge it.  */
2789       char *starred = alloca (strlen (asmspec) + 2);
2790       starred[0] = '*';
2791       strcpy (starred + 1, asmspec);
2792
2793       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2794         {
2795           tree builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
2796           SET_DECL_RTL (builtin, NULL_RTX);
2797           SET_DECL_ASSEMBLER_NAME (builtin, get_identifier (starred));
2798 #ifdef TARGET_MEM_FUNCTIONS
2799           if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
2800             init_block_move_fn (starred);
2801           else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
2802             init_block_clear_fn (starred);
2803 #else
2804           if (DECL_FUNCTION_CODE (decl) == BUILT_IN_BCOPY)
2805             init_block_move_fn (starred);
2806           else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_BZERO)
2807             init_block_clear_fn (starred);
2808 #endif
2809         }
2810       SET_DECL_RTL (decl, NULL_RTX);
2811       change_decl_assembler_name (decl, get_identifier (starred));
2812     }
2813
2814   /* If #pragma weak was used, mark the decl weak now.  */
2815   if (current_scope == global_scope)
2816     maybe_apply_pragma_weak (decl);
2817
2818   /* Output the assembler code and/or RTL code for variables and functions,
2819      unless the type is an undefined structure or union.
2820      If not, it will get done when the type is completed.  */
2821
2822   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2823     {
2824       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
2825       if (c_dialect_objc ())
2826         objc_check_decl (decl);
2827
2828       if (DECL_FILE_SCOPE_P (decl))
2829         {
2830           if (DECL_INITIAL (decl) == NULL_TREE
2831               || DECL_INITIAL (decl) == error_mark_node)
2832             /* Don't output anything
2833                when a tentative file-scope definition is seen.
2834                But at end of compilation, do output code for them.  */
2835             DECL_DEFER_OUTPUT (decl) = 1;
2836           rest_of_decl_compilation (decl, asmspec, true, 0);
2837         }
2838       else
2839         {
2840           /* This is a local variable.  If there is an ASMSPEC, the
2841              user has requested that we handle it specially.  */
2842           if (asmspec)
2843             {
2844               /* In conjunction with an ASMSPEC, the `register'
2845                  keyword indicates that we should place the variable
2846                  in a particular register.  */
2847               if (DECL_REGISTER (decl))
2848                 DECL_C_HARD_REGISTER (decl) = 1;
2849
2850               /* If this is not a static variable, issue a warning.
2851                  It doesn't make any sense to give an ASMSPEC for an
2852                  ordinary, non-register local variable.  Historically,
2853                  GCC has accepted -- but ignored -- the ASMSPEC in
2854                  this case.  */
2855               if (TREE_CODE (decl) == VAR_DECL
2856                   && !DECL_REGISTER (decl)
2857                   && !TREE_STATIC (decl))
2858                 warning ("%Jignoring asm-specifier for non-static local "
2859                          "variable '%D'", decl, decl);
2860               else
2861                 change_decl_assembler_name (decl, get_identifier (asmspec));
2862             }
2863
2864           if (TREE_CODE (decl) != FUNCTION_DECL)
2865             add_decl_stmt (decl);
2866         }
2867
2868       if (!DECL_FILE_SCOPE_P (decl))
2869         {
2870           /* Recompute the RTL of a local array now
2871              if it used to be an incomplete type.  */
2872           if (was_incomplete
2873               && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
2874             {
2875               /* If we used it already as memory, it must stay in memory.  */
2876               TREE_ADDRESSABLE (decl) = TREE_USED (decl);
2877               /* If it's still incomplete now, no init will save it.  */
2878               if (DECL_SIZE (decl) == 0)
2879                 DECL_INITIAL (decl) = 0;
2880             }
2881         }
2882     }
2883
2884   /* If this was marked 'used', be sure it will be output.  */
2885   if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
2886     mark_referenced (DECL_ASSEMBLER_NAME (decl));
2887
2888   if (TREE_CODE (decl) == TYPE_DECL)
2889     rest_of_decl_compilation (decl, NULL, DECL_FILE_SCOPE_P (decl), 0);
2890
2891   /* At the end of a declaration, throw away any variable type sizes
2892      of types defined inside that declaration.  There is no use
2893      computing them in the following function definition.  */
2894   if (current_scope == global_scope)
2895     get_pending_sizes ();
2896
2897   /* Install a cleanup (aka destructor) if one was given.  */
2898   if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
2899     {
2900       tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
2901       if (attr)
2902         {
2903           static bool eh_initialized_p;
2904
2905           tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
2906           tree cleanup_decl = lookup_name (cleanup_id);
2907           tree cleanup;
2908
2909           /* Build "cleanup(&decl)" for the destructor.  */
2910           cleanup = build_unary_op (ADDR_EXPR, decl, 0);
2911           cleanup = build_tree_list (NULL_TREE, cleanup);
2912           cleanup = build_function_call (cleanup_decl, cleanup);
2913
2914           /* Don't warn about decl unused; the cleanup uses it.  */
2915           TREE_USED (decl) = 1;
2916
2917           /* Initialize EH, if we've been told to do so.  */
2918           if (flag_exceptions && !eh_initialized_p)
2919             {
2920               eh_initialized_p = true;
2921               eh_personality_libfunc
2922                 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
2923                                     ? "__gcc_personality_sj0"
2924                                     : "__gcc_personality_v0");
2925               using_eh_for_cleanups ();
2926             }
2927
2928           add_stmt (build_stmt (CLEANUP_STMT, decl, cleanup));
2929         }
2930     }
2931 }
2932
2933 /* Given a parsed parameter declaration, decode it into a PARM_DECL
2934    and push that on the current scope.  */
2935
2936 void
2937 push_parm_decl (tree parm)
2938 {
2939   tree decl;
2940
2941   /* Don't attempt to expand sizes while parsing this decl.
2942      (We can get here with i_s_e 1 somehow from Objective-C.)  */
2943   int save_immediate_size_expand = immediate_size_expand;
2944   immediate_size_expand = 0;
2945
2946   decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
2947                          TREE_PURPOSE (TREE_PURPOSE (parm)),
2948                          PARM, 0, NULL);
2949   decl_attributes (&decl, TREE_VALUE (parm), 0);
2950
2951   decl = pushdecl (decl);
2952
2953   finish_decl (decl, NULL_TREE, NULL_TREE);
2954
2955   immediate_size_expand = save_immediate_size_expand;
2956 }
2957
2958 /* Mark all the parameter declarations to date as forward decls,
2959    shift them to the variables list, and reset the parameters list.
2960    Also diagnose use of this extension.  */
2961
2962 void
2963 mark_forward_parm_decls (void)
2964 {
2965   tree parm;
2966
2967   if (pedantic && !current_scope->warned_forward_parm_decls)
2968     {
2969       pedwarn ("ISO C forbids forward parameter declarations");
2970       current_scope->warned_forward_parm_decls = true;
2971     }
2972
2973   for (parm = current_scope->parms; parm; parm = TREE_CHAIN (parm))
2974     TREE_ASM_WRITTEN (parm) = 1;
2975
2976   SCOPE_LIST_CONCAT (current_scope, names, current_scope, parms);
2977   current_scope->parms = 0;
2978   current_scope->parms_last = 0;
2979 }
2980 \f
2981 static GTY(()) int compound_literal_number;
2982
2983 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
2984    literal, which may be an incomplete array type completed by the
2985    initializer; INIT is a CONSTRUCTOR that initializes the compound
2986    literal.  */
2987
2988 tree
2989 build_compound_literal (tree type, tree init)
2990 {
2991   /* We do not use start_decl here because we have a type, not a declarator;
2992      and do not use finish_decl because the decl should be stored inside
2993      the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT.  */
2994   tree decl = build_decl (VAR_DECL, NULL_TREE, type);
2995   tree complit;
2996   tree stmt;
2997   DECL_EXTERNAL (decl) = 0;
2998   TREE_PUBLIC (decl) = 0;
2999   TREE_STATIC (decl) = (current_scope == global_scope);
3000   DECL_CONTEXT (decl) = current_function_decl;
3001   TREE_USED (decl) = 1;
3002   TREE_TYPE (decl) = type;
3003   TREE_READONLY (decl) = TREE_READONLY (type);
3004   store_init_value (decl, init);
3005
3006   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3007     {
3008       int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3009       if (failure)
3010         abort ();
3011     }
3012
3013   type = TREE_TYPE (decl);
3014   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3015     return error_mark_node;
3016
3017   stmt = build_stmt (DECL_STMT, decl);
3018   complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3019   TREE_SIDE_EFFECTS (complit) = 1;
3020
3021   layout_decl (decl, 0);
3022
3023   if (TREE_STATIC (decl))
3024     {
3025       /* This decl needs a name for the assembler output.  We also need
3026          a unique suffix to be added to the name.  */
3027       char *name;
3028
3029       ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3030                                compound_literal_number);
3031       compound_literal_number++;
3032       DECL_NAME (decl) = get_identifier (name);
3033       DECL_DEFER_OUTPUT (decl) = 1;
3034       DECL_COMDAT (decl) = 1;
3035       DECL_ARTIFICIAL (decl) = 1;
3036       pushdecl (decl);
3037       rest_of_decl_compilation (decl, NULL, 1, 0);
3038     }
3039
3040   return complit;
3041 }
3042 \f
3043 /* Make TYPE a complete type based on INITIAL_VALUE.
3044    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3045    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
3046
3047 int
3048 complete_array_type (tree type, tree initial_value, int do_default)
3049 {
3050   tree maxindex = NULL_TREE;
3051   int value = 0;
3052
3053   if (initial_value)
3054     {
3055       /* Note MAXINDEX  is really the maximum index,
3056          one less than the size.  */
3057       if (TREE_CODE (initial_value) == STRING_CST)
3058         {
3059           int eltsize
3060             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3061           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3062                                    / eltsize) - 1, 0);
3063         }
3064       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3065         {
3066           tree elts = CONSTRUCTOR_ELTS (initial_value);
3067           maxindex = build_int_2 (-1, -1);
3068           for (; elts; elts = TREE_CHAIN (elts))
3069             {
3070               if (TREE_PURPOSE (elts))
3071                 maxindex = TREE_PURPOSE (elts);
3072               else
3073                 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3074                                         maxindex, integer_one_node));
3075             }
3076           maxindex = copy_node (maxindex);
3077         }
3078       else
3079         {
3080           /* Make an error message unless that happened already.  */
3081           if (initial_value != error_mark_node)
3082             value = 1;
3083
3084           /* Prevent further error messages.  */
3085           maxindex = build_int_2 (0, 0);
3086         }
3087     }
3088
3089   if (!maxindex)
3090     {
3091       if (do_default)
3092         maxindex = build_int_2 (0, 0);
3093       value = 2;
3094     }
3095
3096   if (maxindex)
3097     {
3098       TYPE_DOMAIN (type) = build_index_type (maxindex);
3099       if (!TREE_TYPE (maxindex))
3100         TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3101     }
3102
3103   /* Lay out the type now that we can get the real answer.  */
3104
3105   layout_type (type);
3106
3107   return value;
3108 }
3109 \f
3110 /* Determine whether TYPE is a structure with a flexible array member,
3111    or a union containing such a structure (possibly recursively).  */
3112
3113 static bool
3114 flexible_array_type_p (tree type)
3115 {
3116   tree x;
3117   switch (TREE_CODE (type))
3118     {
3119     case RECORD_TYPE:
3120       x = TYPE_FIELDS (type);
3121       if (x == NULL_TREE)
3122         return false;
3123       while (TREE_CHAIN (x) != NULL_TREE)
3124         x = TREE_CHAIN (x);
3125       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3126           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3127           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3128           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3129         return true;
3130       return false;
3131     case UNION_TYPE:
3132       for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3133         {
3134           if (flexible_array_type_p (TREE_TYPE (x)))
3135             return true;
3136         }
3137       return false;
3138     default:
3139     return false;
3140   }
3141 }
3142 \f
3143 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
3144    replacing with appropriate values if they are invalid.  */
3145 static void
3146 check_bitfield_type_and_width (tree *type, tree *width, const char *orig_name)
3147 {
3148   tree type_mv;
3149   unsigned int max_width;
3150   unsigned HOST_WIDE_INT w;
3151   const char *name = orig_name ? orig_name: _("<anonymous>");
3152
3153   /* Necessary?  */
3154   STRIP_NOPS (*width);
3155
3156   /* Detect and ignore out of range field width and process valid
3157      field widths.  */
3158   if (TREE_CODE (*width) != INTEGER_CST)
3159     {
3160       error ("bit-field `%s' width not an integer constant", name);
3161       *width = integer_one_node;
3162     }
3163   else
3164     {
3165       constant_expression_warning (*width);
3166       if (tree_int_cst_sgn (*width) < 0)
3167         {
3168           error ("negative width in bit-field `%s'", name);
3169           *width = integer_one_node;
3170         }
3171       else if (integer_zerop (*width) && orig_name)
3172         {
3173           error ("zero width for bit-field `%s'", name);
3174           *width = integer_one_node;
3175         }
3176     }
3177
3178   /* Detect invalid bit-field type.  */
3179   if (TREE_CODE (*type) != INTEGER_TYPE
3180       && TREE_CODE (*type) != BOOLEAN_TYPE
3181       && TREE_CODE (*type) != ENUMERAL_TYPE)
3182     {
3183       error ("bit-field `%s' has invalid type", name);
3184       *type = unsigned_type_node;
3185     }
3186
3187   type_mv = TYPE_MAIN_VARIANT (*type);
3188   if (pedantic
3189       && type_mv != integer_type_node
3190       && type_mv != unsigned_type_node
3191       && type_mv != boolean_type_node)
3192     pedwarn ("type of bit-field `%s' is a GCC extension", name);
3193
3194   if (type_mv == boolean_type_node)
3195     max_width = CHAR_TYPE_SIZE;
3196   else
3197     max_width = TYPE_PRECISION (*type);
3198
3199   if (0 < compare_tree_int (*width, max_width))
3200     {
3201       error ("width of `%s' exceeds its type", name);
3202       w = max_width;
3203       *width = build_int_2 (w, 0);
3204     }
3205   else
3206     w = tree_low_cst (*width, 1);
3207
3208   if (TREE_CODE (*type) == ENUMERAL_TYPE
3209       && (w < min_precision (TYPE_MIN_VALUE (*type), TREE_UNSIGNED (*type))
3210           || w < min_precision (TYPE_MAX_VALUE (*type), TREE_UNSIGNED (*type))))
3211     warning ("`%s' is narrower than values of its type", name);
3212 }
3213 \f
3214 /* Given declspecs and a declarator,
3215    determine the name and type of the object declared
3216    and construct a ..._DECL node for it.
3217    (In one case we can return a ..._TYPE node instead.
3218     For invalid input we sometimes return 0.)
3219
3220    DECLSPECS is a chain of tree_list nodes whose value fields
3221     are the storage classes and type specifiers.
3222
3223    DECL_CONTEXT says which syntactic context this declaration is in:
3224      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3225      FUNCDEF for a function definition.  Like NORMAL but a few different
3226       error messages in each case.  Return value may be zero meaning
3227       this definition is too screwy to try to parse.
3228      PARM for a parameter declaration (either within a function prototype
3229       or before a function body).  Make a PARM_DECL, or return void_type_node.
3230      TYPENAME if for a typename (in a cast or sizeof).
3231       Don't make a DECL node; just return the ..._TYPE node.
3232      FIELD for a struct or union field; make a FIELD_DECL.
3233    INITIALIZED is 1 if the decl has an initializer.
3234    WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
3235    representing the width of the bit-field.
3236
3237    In the TYPENAME case, DECLARATOR is really an absolute declarator.
3238    It may also be so in the PARM case, for a prototype where the
3239    argument type is specified but not the name.
3240
3241    This function is where the complicated C meanings of `static'
3242    and `extern' are interpreted.  */
3243
3244 static tree
3245 grokdeclarator (tree declarator, tree declspecs,
3246                 enum decl_context decl_context, int initialized, tree *width)
3247 {
3248   int specbits = 0;
3249   tree spec;
3250   tree type = NULL_TREE;
3251   int longlong = 0;
3252   int constp;
3253   int restrictp;
3254   int volatilep;
3255   int type_quals = TYPE_UNQUALIFIED;
3256   int inlinep;
3257   int explicit_int = 0;
3258   int explicit_char = 0;
3259   int defaulted_int = 0;
3260   tree typedef_decl = 0;
3261   const char *name, *orig_name;
3262   tree typedef_type = 0;
3263   int funcdef_flag = 0;
3264   enum tree_code innermost_code = ERROR_MARK;
3265   int size_varies = 0;
3266   tree decl_attr = NULL_TREE;
3267   tree array_ptr_quals = NULL_TREE;
3268   int array_parm_static = 0;
3269   tree returned_attrs = NULL_TREE;
3270   bool bitfield = width != NULL;
3271   tree element_type;
3272   tree arg_info = NULL_TREE;
3273
3274   if (decl_context == FUNCDEF)
3275     funcdef_flag = 1, decl_context = NORMAL;
3276
3277   /* Look inside a declarator for the name being declared
3278      and get it as a string, for an error message.  */
3279   {
3280     tree decl = declarator;
3281     name = 0;
3282
3283     while (decl)
3284       switch (TREE_CODE (decl))
3285         {
3286         case ARRAY_REF:
3287         case INDIRECT_REF:
3288         case CALL_EXPR:
3289           innermost_code = TREE_CODE (decl);
3290           decl = TREE_OPERAND (decl, 0);
3291           break;
3292
3293         case TREE_LIST:
3294           decl = TREE_VALUE (decl);
3295           break;
3296
3297         case IDENTIFIER_NODE:
3298           name = IDENTIFIER_POINTER (decl);
3299           decl = 0;
3300           break;
3301
3302         default:
3303           abort ();
3304         }
3305     orig_name = name;
3306     if (name == 0)
3307       name = "type name";
3308   }
3309
3310   /* A function definition's declarator must have the form of
3311      a function declarator.  */
3312
3313   if (funcdef_flag && innermost_code != CALL_EXPR)
3314     return 0;
3315
3316   /* If this looks like a function definition, make it one,
3317      even if it occurs where parms are expected.
3318      Then store_parm_decls will reject it and not use it as a parm.  */
3319   if (decl_context == NORMAL && !funcdef_flag
3320       && current_scope->parm_flag)
3321     decl_context = PARM;
3322
3323   /* Look through the decl specs and record which ones appear.
3324      Some typespecs are defined as built-in typenames.
3325      Others, the ones that are modifiers of other types,
3326      are represented by bits in SPECBITS: set the bits for
3327      the modifiers that appear.  Storage class keywords are also in SPECBITS.
3328
3329      If there is a typedef name or a type, store the type in TYPE.
3330      This includes builtin typedefs such as `int'.
3331
3332      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3333      and did not come from a user typedef.
3334
3335      Set LONGLONG if `long' is mentioned twice.  */
3336
3337   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3338     {
3339       tree id = TREE_VALUE (spec);
3340
3341       /* If the entire declaration is itself tagged as deprecated then
3342          suppress reports of deprecated items.  */
3343       if (id && TREE_DEPRECATED (id))
3344         {
3345           if (deprecated_state != DEPRECATED_SUPPRESS)
3346             warn_deprecated_use (id);
3347         }
3348
3349       if (id == ridpointers[(int) RID_INT])
3350         explicit_int = 1;
3351       if (id == ridpointers[(int) RID_CHAR])
3352         explicit_char = 1;
3353
3354       if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3355         {
3356           enum rid i = C_RID_CODE (id);
3357           if ((int) i <= (int) RID_LAST_MODIFIER)
3358             {
3359               if (i == RID_LONG && (specbits & (1 << (int) RID_LONG)))
3360                 {
3361                   if (longlong)
3362                     error ("`long long long' is too long for GCC");
3363                   else
3364                     {
3365                       if (pedantic && !flag_isoc99 && ! in_system_header
3366                           && warn_long_long)
3367                         pedwarn ("ISO C90 does not support `long long'");
3368                       longlong = 1;
3369                     }
3370                 }
3371               else if (specbits & (1 << (int) i))
3372                 {
3373                   if (i == RID_CONST || i == RID_VOLATILE || i == RID_RESTRICT)
3374                     {
3375                       if (!flag_isoc99)
3376                         pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3377                     }
3378                   else
3379                     error ("duplicate `%s'", IDENTIFIER_POINTER (id));
3380                 }
3381
3382               /* Diagnose "__thread extern".  Recall that this list
3383                  is in the reverse order seen in the text.  */
3384               if (i == RID_THREAD
3385                   && (specbits & (1 << (int) RID_EXTERN
3386                                   | 1 << (int) RID_STATIC)))
3387                 {
3388                   if (specbits & 1 << (int) RID_EXTERN)
3389                     error ("`__thread' before `extern'");
3390                   else
3391                     error ("`__thread' before `static'");
3392                 }
3393
3394               specbits |= 1 << (int) i;
3395               goto found;
3396             }
3397         }
3398       if (type)
3399         error ("two or more data types in declaration of `%s'", name);
3400       /* Actual typedefs come to us as TYPE_DECL nodes.  */
3401       else if (TREE_CODE (id) == TYPE_DECL)
3402         {
3403           if (TREE_TYPE (id) == error_mark_node)
3404             ; /* Allow the type to default to int to avoid cascading errors.  */
3405           else
3406             {
3407               type = TREE_TYPE (id);
3408               decl_attr = DECL_ATTRIBUTES (id);
3409               typedef_decl = id;
3410             }
3411         }
3412       /* Built-in types come as identifiers.  */
3413       else if (TREE_CODE (id) == IDENTIFIER_NODE)
3414         {
3415           tree t = lookup_name (id);
3416           if (TREE_TYPE (t) == error_mark_node)
3417             ;
3418           else if (!t || TREE_CODE (t) != TYPE_DECL)
3419             error ("`%s' fails to be a typedef or built in type",
3420                    IDENTIFIER_POINTER (id));
3421           else
3422             {
3423               type = TREE_TYPE (t);
3424               typedef_decl = t;
3425             }
3426         }
3427       else if (TREE_CODE (id) != ERROR_MARK)
3428         type = id;
3429
3430     found:
3431       ;
3432     }
3433
3434   typedef_type = type;
3435   if (type)
3436     size_varies = C_TYPE_VARIABLE_SIZE (type);
3437
3438   /* No type at all: default to `int', and set DEFAULTED_INT
3439      because it was not a user-defined typedef.  */
3440
3441   if (type == 0)
3442     {
3443       if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3444                           | (1 << (int) RID_SIGNED)
3445                           | (1 << (int) RID_UNSIGNED)
3446                           | (1 << (int) RID_COMPLEX))))
3447           /* Don't warn about typedef foo = bar.  */
3448           && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3449           && ! in_system_header)
3450         {
3451           /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3452              and this is a function, or if -Wimplicit; prefer the former
3453              warning since it is more explicit.  */
3454           if ((warn_implicit_int || warn_return_type || flag_isoc99)
3455               && funcdef_flag)
3456             warn_about_return_type = 1;
3457           else if (warn_implicit_int || flag_isoc99)
3458             pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
3459                          name);
3460         }
3461
3462       defaulted_int = 1;
3463       type = integer_type_node;
3464     }
3465
3466   /* Now process the modifiers that were specified
3467      and check for invalid combinations.  */
3468
3469   /* Long double is a special combination.  */
3470
3471   if ((specbits & 1 << (int) RID_LONG) && ! longlong
3472       && TYPE_MAIN_VARIANT (type) == double_type_node)
3473     {
3474       specbits &= ~(1 << (int) RID_LONG);
3475       type = long_double_type_node;
3476     }
3477
3478   /* Check all other uses of type modifiers.  */
3479
3480   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3481                   | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3482     {
3483       int ok = 0;
3484
3485       if ((specbits & 1 << (int) RID_LONG)
3486           && (specbits & 1 << (int) RID_SHORT))
3487         error ("both long and short specified for `%s'", name);
3488       else if (((specbits & 1 << (int) RID_LONG)
3489                 || (specbits & 1 << (int) RID_SHORT))
3490                && explicit_char)
3491         error ("long or short specified with char for `%s'", name);
3492       else if (((specbits & 1 << (int) RID_LONG)
3493                 || (specbits & 1 << (int) RID_SHORT))
3494                && TREE_CODE (type) == REAL_TYPE)
3495         {
3496           static int already = 0;
3497
3498           error ("long or short specified with floating type for `%s'", name);
3499           if (! already && ! pedantic)
3500             {
3501               error ("the only valid combination is `long double'");
3502               already = 1;
3503             }
3504         }
3505       else if ((specbits & 1 << (int) RID_SIGNED)
3506                && (specbits & 1 << (int) RID_UNSIGNED))
3507         error ("both signed and unsigned specified for `%s'", name);
3508       else if (TREE_CODE (type) != INTEGER_TYPE)
3509         error ("long, short, signed or unsigned invalid for `%s'", name);
3510       else
3511         {
3512           ok = 1;
3513           if (!explicit_int && !defaulted_int && !explicit_char)
3514             {
3515               error ("long, short, signed or unsigned used invalidly for `%s'",
3516                      name);
3517               ok = 0;
3518             }
3519         }
3520
3521       /* Discard the type modifiers if they are invalid.  */
3522       if (! ok)
3523         {
3524           specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3525                         | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3526           longlong = 0;
3527         }
3528     }
3529
3530   if ((specbits & (1 << (int) RID_COMPLEX))
3531       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
3532     {
3533       error ("complex invalid for `%s'", name);
3534       specbits &= ~(1 << (int) RID_COMPLEX);
3535     }
3536
3537   /* Decide whether an integer type is signed or not.
3538      Optionally treat bit-fields as signed by default.  */
3539   if (specbits & 1 << (int) RID_UNSIGNED
3540       || (bitfield && ! flag_signed_bitfields
3541           && (explicit_int || defaulted_int || explicit_char
3542               /* A typedef for plain `int' without `signed'
3543                  can be controlled just like plain `int'.  */
3544               || ! (typedef_decl != 0
3545                     && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3546           && TREE_CODE (type) != ENUMERAL_TYPE
3547           && !(specbits & 1 << (int) RID_SIGNED)))
3548     {
3549       if (longlong)
3550         type = long_long_unsigned_type_node;
3551       else if (specbits & 1 << (int) RID_LONG)
3552         type = long_unsigned_type_node;
3553       else if (specbits & 1 << (int) RID_SHORT)
3554         type = short_unsigned_type_node;
3555       else if (type == char_type_node)
3556         type = unsigned_char_type_node;
3557       else if (typedef_decl)
3558         type = c_common_unsigned_type (type);
3559       else
3560         type = unsigned_type_node;
3561     }
3562   else if ((specbits & 1 << (int) RID_SIGNED)
3563            && type == char_type_node)
3564     type = signed_char_type_node;
3565   else if (longlong)
3566     type = long_long_integer_type_node;
3567   else if (specbits & 1 << (int) RID_LONG)
3568     type = long_integer_type_node;
3569   else if (specbits & 1 << (int) RID_SHORT)
3570     type = short_integer_type_node;
3571
3572   if (specbits & 1 << (int) RID_COMPLEX)
3573     {
3574       if (pedantic && !flag_isoc99)
3575         pedwarn ("ISO C90 does not support complex types");
3576       /* If we just have "complex", it is equivalent to
3577          "complex double", but if any modifiers at all are specified it is
3578          the complex form of TYPE.  E.g, "complex short" is
3579          "complex short int".  */
3580
3581       if (defaulted_int && ! longlong
3582           && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3583                             | (1 << (int) RID_SIGNED)
3584                             | (1 << (int) RID_UNSIGNED))))
3585         {
3586           if (pedantic)
3587             pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
3588           type = complex_double_type_node;
3589         }
3590       else if (type == integer_type_node)
3591         {
3592           if (pedantic)
3593             pedwarn ("ISO C does not support complex integer types");
3594           type = complex_integer_type_node;
3595         }
3596       else if (type == float_type_node)
3597         type = complex_float_type_node;
3598       else if (type == double_type_node)
3599         type = complex_double_type_node;
3600       else if (type == long_double_type_node)
3601         type = complex_long_double_type_node;
3602       else
3603         {
3604           if (pedantic)
3605             pedwarn ("ISO C does not support complex integer types");
3606           type = build_complex_type (type);
3607         }
3608     }
3609
3610   /* Check the type and width of a bit-field.  */
3611   if (bitfield)
3612     check_bitfield_type_and_width (&type, width, orig_name);
3613
3614   /* Figure out the type qualifiers for the declaration.  There are
3615      two ways a declaration can become qualified.  One is something
3616      like `const int i' where the `const' is explicit.  Another is
3617      something like `typedef const int CI; CI i' where the type of the
3618      declaration contains the `const'.  A third possibility is that
3619      there is a type qualifier on the element type of a typedefed
3620      array type, in which case we should extract that qualifier so
3621      that c_apply_type_quals_to_decls receives the full list of
3622      qualifiers to work with (C90 is not entirely clear about whether
3623      duplicate qualifiers should be diagnosed in this case, but it
3624      seems most appropriate to do so).  */
3625   element_type = strip_array_types (type);
3626   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (element_type);
3627   restrictp
3628     = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (element_type);
3629   volatilep
3630     = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (element_type);
3631   inlinep = !! (specbits & (1 << (int) RID_INLINE));
3632   if (constp > 1 && ! flag_isoc99)
3633     pedwarn ("duplicate `const'");
3634   if (restrictp > 1 && ! flag_isoc99)
3635     pedwarn ("duplicate `restrict'");
3636   if (volatilep > 1 && ! flag_isoc99)
3637     pedwarn ("duplicate `volatile'");
3638   if (! flag_gen_aux_info && (TYPE_QUALS (type)))
3639     type = TYPE_MAIN_VARIANT (type);
3640   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
3641                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
3642                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
3643
3644   /* Warn if two storage classes are given. Default to `auto'.  */
3645
3646   {
3647     int nclasses = 0;
3648
3649     if (specbits & 1 << (int) RID_AUTO) nclasses++;
3650     if (specbits & 1 << (int) RID_STATIC) nclasses++;
3651     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
3652     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
3653     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
3654
3655     /* "static __thread" and "extern __thread" are allowed.  */
3656     if ((specbits & (1 << (int) RID_THREAD
3657                      | 1 << (int) RID_STATIC
3658                      | 1 << (int) RID_EXTERN)) == (1 << (int) RID_THREAD))
3659       nclasses++;
3660
3661     /* Warn about storage classes that are invalid for certain
3662        kinds of declarations (parameters, typenames, etc.).  */
3663
3664     if (nclasses > 1)
3665       error ("multiple storage classes in declaration of `%s'", name);
3666     else if (funcdef_flag
3667              && (specbits
3668                  & ((1 << (int) RID_REGISTER)
3669                     | (1 << (int) RID_AUTO)
3670                     | (1 << (int) RID_TYPEDEF)
3671                     | (1 << (int) RID_THREAD))))
3672       {
3673         if (specbits & 1 << (int) RID_AUTO
3674             && (pedantic || current_scope == global_scope))
3675           pedwarn ("function definition declared `auto'");
3676         if (specbits & 1 << (int) RID_REGISTER)
3677           error ("function definition declared `register'");
3678         if (specbits & 1 << (int) RID_TYPEDEF)
3679           error ("function definition declared `typedef'");
3680         if (specbits & 1 << (int) RID_THREAD)
3681           error ("function definition declared `__thread'");
3682         specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3683                       | (1 << (int) RID_AUTO) | (1 << (int) RID_THREAD));
3684       }
3685     else if (decl_context != NORMAL && nclasses > 0)
3686       {
3687         if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
3688           ;
3689         else
3690           {
3691             switch (decl_context)
3692               {
3693               case FIELD:
3694                 error ("storage class specified for structure field `%s'",
3695                        name);
3696                 break;
3697               case PARM:
3698                 error ("storage class specified for parameter `%s'", name);
3699                 break;
3700               default:
3701                 error ("storage class specified for typename");
3702                 break;
3703               }
3704             specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3705                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
3706                           | (1 << (int) RID_EXTERN) | (1 << (int) RID_THREAD));
3707           }
3708       }
3709     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
3710       {
3711         /* `extern' with initialization is invalid if not at file scope.  */
3712         if (current_scope == global_scope)
3713           warning ("`%s' initialized and declared `extern'", name);
3714         else
3715           error ("`%s' has both `extern' and initializer", name);
3716       }
3717     else if (current_scope == global_scope)
3718       {
3719         if (specbits & 1 << (int) RID_AUTO)
3720           error ("file-scope declaration of `%s' specifies `auto'", name);
3721       }
3722     else
3723       {
3724         if (specbits & 1 << (int) RID_EXTERN && funcdef_flag)
3725           error ("nested function `%s' declared `extern'", name);
3726         else if ((specbits & (1 << (int) RID_THREAD
3727                                | 1 << (int) RID_EXTERN
3728                                | 1 << (int) RID_STATIC))
3729                  == (1 << (int) RID_THREAD))
3730           {
3731             error ("function-scope `%s' implicitly auto and declared `__thread'",
3732                    name);
3733             specbits &= ~(1 << (int) RID_THREAD);
3734           }
3735       }
3736   }
3737
3738   /* Now figure out the structure of the declarator proper.
3739      Descend through it, creating more complex types, until we reach
3740      the declared identifier (or NULL_TREE, in an absolute declarator).  */
3741
3742   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
3743     {
3744       if (type == error_mark_node)
3745         {
3746           declarator = TREE_OPERAND (declarator, 0);
3747           continue;
3748         }
3749
3750       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3751          an INDIRECT_REF (for *...),
3752          a CALL_EXPR (for ...(...)),
3753          a TREE_LIST (for nested attributes),
3754          an identifier (for the name being declared)
3755          or a null pointer (for the place in an absolute declarator
3756          where the name was omitted).
3757          For the last two cases, we have just exited the loop.
3758
3759          At this point, TYPE is the type of elements of an array,
3760          or for a function to return, or for a pointer to point to.
3761          After this sequence of ifs, TYPE is the type of the
3762          array or function or pointer, and DECLARATOR has had its
3763          outermost layer removed.  */
3764
3765       if (array_ptr_quals != NULL_TREE || array_parm_static)
3766         {
3767           /* Only the innermost declarator (making a parameter be of
3768              array type which is converted to pointer type)
3769              may have static or type qualifiers.  */
3770           error ("static or type qualifiers in non-parameter array declarator");
3771           array_ptr_quals = NULL_TREE;
3772           array_parm_static = 0;
3773         }
3774
3775       if (TREE_CODE (declarator) == TREE_LIST)
3776         {
3777           /* We encode a declarator with embedded attributes using
3778              a TREE_LIST.  */
3779           tree attrs = TREE_PURPOSE (declarator);
3780           tree inner_decl;
3781           int attr_flags = 0;
3782           declarator = TREE_VALUE (declarator);
3783           inner_decl = declarator;
3784           while (inner_decl != NULL_TREE
3785                  && TREE_CODE (inner_decl) == TREE_LIST)
3786             inner_decl = TREE_VALUE (inner_decl);
3787           if (inner_decl == NULL_TREE
3788               || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
3789             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
3790           else if (TREE_CODE (inner_decl) == CALL_EXPR)
3791             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
3792           else if (TREE_CODE (inner_decl) == ARRAY_REF)
3793             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
3794           returned_attrs = decl_attributes (&type,
3795                                             chainon (returned_attrs, attrs),
3796                                             attr_flags);
3797         }
3798       else if (TREE_CODE (declarator) == ARRAY_REF)
3799         {
3800           tree itype = NULL_TREE;
3801           tree size = TREE_OPERAND (declarator, 1);
3802           /* The index is a signed object `sizetype' bits wide.  */
3803           tree index_type = c_common_signed_type (sizetype);
3804
3805           array_ptr_quals = TREE_TYPE (declarator);
3806           array_parm_static = TREE_STATIC (declarator);
3807
3808           declarator = TREE_OPERAND (declarator, 0);
3809
3810           /* Check for some types that there cannot be arrays of.  */
3811
3812           if (VOID_TYPE_P (type))
3813             {
3814               error ("declaration of `%s' as array of voids", name);
3815               type = error_mark_node;
3816             }
3817
3818           if (TREE_CODE (type) == FUNCTION_TYPE)
3819             {
3820               error ("declaration of `%s' as array of functions", name);
3821               type = error_mark_node;
3822             }
3823
3824           if (pedantic && flexible_array_type_p (type))
3825             pedwarn ("invalid use of structure with flexible array member");
3826
3827           if (size == error_mark_node)
3828             type = error_mark_node;
3829
3830           if (type == error_mark_node)
3831             continue;
3832
3833           /* If size was specified, set ITYPE to a range-type for that size.
3834              Otherwise, ITYPE remains null.  finish_decl may figure it out
3835              from an initial value.  */
3836
3837           if (size)
3838             {
3839               /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3840               STRIP_TYPE_NOPS (size);
3841
3842               if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
3843                 {
3844                   error ("size of array `%s' has non-integer type", name);
3845                   size = integer_one_node;
3846                 }
3847
3848               if (pedantic && integer_zerop (size))
3849                 pedwarn ("ISO C forbids zero-size array `%s'", name);
3850
3851               if (TREE_CODE (size) == INTEGER_CST)
3852                 {
3853                   constant_expression_warning (size);
3854                   if (tree_int_cst_sgn (size) < 0)
3855                     {
3856                       error ("size of array `%s' is negative", name);
3857                       size = integer_one_node;
3858                     }
3859                 }
3860               else
3861                 {
3862                   /* Make sure the array size remains visibly nonconstant
3863                      even if it is (eg) a const variable with known value.  */
3864                   size_varies = 1;
3865
3866                   if (!flag_isoc99 && pedantic)
3867                     {
3868                       if (TREE_CONSTANT (size))
3869                         pedwarn ("ISO C90 forbids array `%s' whose size can't be evaluated",
3870                                  name);
3871                       else
3872                         pedwarn ("ISO C90 forbids variable-size array `%s'",
3873                                  name);
3874                     }
3875                 }
3876
3877               if (integer_zerop (size))
3878                 {
3879                   /* A zero-length array cannot be represented with an
3880                      unsigned index type, which is what we'll get with
3881                      build_index_type.  Create an open-ended range instead.  */
3882                   itype = build_range_type (sizetype, size, NULL_TREE);
3883                 }
3884               else
3885                 {
3886                   /* Compute the maximum valid index, that is, size - 1.
3887                      Do the calculation in index_type, so that if it is
3888                      a variable the computations will be done in the
3889                      proper mode.  */
3890                   itype = fold (build (MINUS_EXPR, index_type,
3891                                        convert (index_type, size),
3892                                        convert (index_type, size_one_node)));
3893
3894                   /* If that overflowed, the array is too big.
3895                      ??? While a size of INT_MAX+1 technically shouldn't
3896                      cause an overflow (because we subtract 1), the overflow
3897                      is recorded during the conversion to index_type, before
3898                      the subtraction.  Handling this case seems like an
3899                      unnecessary complication.  */
3900                   if (TREE_OVERFLOW (itype))
3901                     {
3902                       error ("size of array `%s' is too large", name);
3903                       type = error_mark_node;
3904                       continue;
3905                     }
3906
3907                   if (size_varies)
3908                     {
3909                       /* We must be able to distinguish the
3910                          SAVE_EXPR_CONTEXT for the variably-sized type
3911                          so that we can set it correctly in
3912                          set_save_expr_context.  The convention is
3913                          that all SAVE_EXPRs that need to be reset
3914                          have NULL_TREE for their SAVE_EXPR_CONTEXT.  */
3915                       tree cfd = current_function_decl;
3916                       if (decl_context == PARM)
3917                         current_function_decl = NULL_TREE;
3918                       itype = variable_size (itype);
3919                       if (decl_context == PARM)
3920                         current_function_decl = cfd;
3921                     }
3922                   itype = build_index_type (itype);
3923                 }
3924             }
3925           else if (decl_context == FIELD)
3926             {
3927               if (pedantic && !flag_isoc99 && !in_system_header)
3928                 pedwarn ("ISO C90 does not support flexible array members");
3929
3930               /* ISO C99 Flexible array members are effectively identical
3931                  to GCC's zero-length array extension.  */
3932               itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
3933             }
3934
3935           /* If pedantic, complain about arrays of incomplete types.  */
3936
3937           if (pedantic && !COMPLETE_TYPE_P (type))
3938             pedwarn ("array type has incomplete element type");
3939
3940           /* Build the array type itself, then merge any constancy or
3941              volatility into the target type.  We must do it in this order
3942              to ensure that the TYPE_MAIN_VARIANT field of the array type
3943              is set correctly.  */
3944
3945           type = build_array_type (type, itype);
3946           if (type_quals)
3947             type = c_build_qualified_type (type, type_quals);
3948
3949           if (size_varies)
3950             C_TYPE_VARIABLE_SIZE (type) = 1;
3951
3952           /* The GCC extension for zero-length arrays differs from
3953              ISO flexible array members in that sizeof yields zero.  */
3954           if (size && integer_zerop (size))
3955             {
3956               layout_type (type);
3957               TYPE_SIZE (type) = bitsize_zero_node;
3958               TYPE_SIZE_UNIT (type) = size_zero_node;
3959             }
3960           if (decl_context != PARM
3961               && (array_ptr_quals != NULL_TREE || array_parm_static))
3962             {
3963               error ("static or type qualifiers in non-parameter array declarator");
3964               array_ptr_quals = NULL_TREE;
3965               array_parm_static = 0;
3966             }
3967         }
3968       else if (TREE_CODE (declarator) == CALL_EXPR)
3969         {
3970           /* Declaring a function type.  Say it's a definition only
3971            for the CALL_EXPR closest to the identifier.  */
3972           bool really_funcdef = (funcdef_flag
3973                                  && (TREE_CODE (TREE_OPERAND (declarator, 0))
3974                                      == IDENTIFIER_NODE));
3975           tree arg_types;
3976
3977           /* Make sure we have a valid type for the function to return.  */
3978           if (type == error_mark_node)
3979             continue;
3980
3981           size_varies = 0;
3982
3983           /* Warn about some types functions can't return.  */
3984
3985           if (TREE_CODE (type) == FUNCTION_TYPE)
3986             {
3987               error ("`%s' declared as function returning a function", name);
3988               type = integer_type_node;
3989             }
3990           if (TREE_CODE (type) == ARRAY_TYPE)
3991             {
3992               error ("`%s' declared as function returning an array", name);
3993               type = integer_type_node;
3994             }
3995
3996           /* Construct the function type and go to the next
3997              inner layer of declarator.  */
3998           arg_info = TREE_OPERAND (declarator, 1);
3999           arg_types = grokparms (arg_info, really_funcdef);
4000
4001           /* Type qualifiers before the return type of the function
4002              qualify the return type, not the function type.  */
4003           if (type_quals)
4004             {
4005               /* Type qualifiers on a function return type are normally
4006                  permitted by the standard but have no effect, so give a
4007                  warning at -Wextra.  Qualifiers on a void return type have
4008                  meaning as a GNU extension, and are banned on function
4009                  definitions in ISO C.  FIXME: strictly we shouldn't
4010                  pedwarn for qualified void return types except on function
4011                  definitions, but not doing so could lead to the undesirable
4012                  state of a "volatile void" function return type not being
4013                  warned about, and a use of the function being compiled
4014                  with GNU semantics, with no diagnostics under -pedantic.  */
4015               if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4016                 pedwarn ("ISO C forbids qualified void function return type");
4017               else if (extra_warnings
4018                        && !(VOID_TYPE_P (type)
4019                             && type_quals == TYPE_QUAL_VOLATILE))
4020                 warning ("type qualifiers ignored on function return type");
4021
4022               type = c_build_qualified_type (type, type_quals);
4023             }
4024           type_quals = TYPE_UNQUALIFIED;
4025
4026           type = build_function_type (type, arg_types);
4027           declarator = TREE_OPERAND (declarator, 0);
4028
4029           /* Set the TYPE_CONTEXTs for each tagged type which is local to
4030              the formal parameter list of this FUNCTION_TYPE to point to
4031              the FUNCTION_TYPE node itself.  */
4032
4033           {
4034             tree link;
4035
4036             for (link = ARG_INFO_TAGS (arg_info);
4037                  link;
4038                  link = TREE_CHAIN (link))
4039               TYPE_CONTEXT (TREE_VALUE (link)) = type;
4040           }
4041         }
4042       else if (TREE_CODE (declarator) == INDIRECT_REF)
4043         {
4044           /* Merge any constancy or volatility into the target type
4045              for the pointer.  */
4046
4047           if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4048               && type_quals)
4049             pedwarn ("ISO C forbids qualified function types");
4050           if (type_quals)
4051             type = c_build_qualified_type (type, type_quals);
4052           type_quals = TYPE_UNQUALIFIED;
4053           size_varies = 0;
4054
4055           type = build_pointer_type (type);
4056
4057           /* Process a list of type modifier keywords
4058              (such as const or volatile) that were given inside the `*'.  */
4059
4060           if (TREE_TYPE (declarator))
4061             {
4062               tree typemodlist;
4063               int erred = 0;
4064
4065               constp = 0;
4066               volatilep = 0;
4067               restrictp = 0;
4068               for (typemodlist = TREE_TYPE (declarator); typemodlist;
4069                    typemodlist = TREE_CHAIN (typemodlist))
4070                 {
4071                   tree qualifier = TREE_VALUE (typemodlist);
4072
4073                   if (C_IS_RESERVED_WORD (qualifier))
4074                     {
4075                       if (C_RID_CODE (qualifier) == RID_CONST)
4076                         constp++;
4077                       else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4078                         volatilep++;
4079                       else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4080                         restrictp++;
4081                       else
4082                         erred++;
4083                     }
4084                   else
4085                     erred++;
4086                 }
4087
4088               if (erred)
4089                 error ("invalid type modifier within pointer declarator");
4090               if (constp > 1 && ! flag_isoc99)
4091                 pedwarn ("duplicate `const'");
4092               if (volatilep > 1 && ! flag_isoc99)
4093                 pedwarn ("duplicate `volatile'");
4094               if (restrictp > 1 && ! flag_isoc99)
4095                 pedwarn ("duplicate `restrict'");
4096
4097               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4098                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4099                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4100             }
4101
4102           declarator = TREE_OPERAND (declarator, 0);
4103         }
4104       else
4105         abort ();
4106
4107     }
4108
4109   /* Now TYPE has the actual type.  */
4110
4111   /* Did array size calculations overflow?  */
4112
4113   if (TREE_CODE (type) == ARRAY_TYPE
4114       && COMPLETE_TYPE_P (type)
4115       && TREE_OVERFLOW (TYPE_SIZE (type)))
4116     {
4117       error ("size of array `%s' is too large", name);
4118       /* If we proceed with the array type as it is, we'll eventually
4119          crash in tree_low_cst().  */
4120       type = error_mark_node;
4121     }
4122
4123   /* If this is declaring a typedef name, return a TYPE_DECL.  */
4124
4125   if (specbits & (1 << (int) RID_TYPEDEF))
4126     {
4127       tree decl;
4128       /* Note that the grammar rejects storage classes
4129          in typenames, fields or parameters */
4130       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4131           && type_quals)
4132         pedwarn ("ISO C forbids qualified function types");
4133       if (type_quals)
4134         type = c_build_qualified_type (type, type_quals);
4135       decl = build_decl (TYPE_DECL, declarator, type);
4136       if ((specbits & (1 << (int) RID_SIGNED))
4137           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4138         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4139       decl_attributes (&decl, returned_attrs, 0);
4140       return decl;
4141     }
4142
4143   /* Detect the case of an array type of unspecified size
4144      which came, as such, direct from a typedef name.
4145      We must copy the type, so that each identifier gets
4146      a distinct type, so that each identifier's size can be
4147      controlled separately by its own initializer.  */
4148
4149   if (type != 0 && typedef_type != 0
4150       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4151       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4152     {
4153       type = build_array_type (TREE_TYPE (type), 0);
4154       if (size_varies)
4155         C_TYPE_VARIABLE_SIZE (type) = 1;
4156     }
4157
4158   /* If this is a type name (such as, in a cast or sizeof),
4159      compute the type and return it now.  */
4160
4161   if (decl_context == TYPENAME)
4162     {
4163       /* Note that the grammar rejects storage classes
4164          in typenames, fields or parameters */
4165       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4166           && type_quals)
4167         pedwarn ("ISO C forbids const or volatile function types");
4168       if (type_quals)
4169         type = c_build_qualified_type (type, type_quals);
4170       decl_attributes (&type, returned_attrs, 0);
4171       return type;
4172     }
4173
4174   /* Aside from typedefs and type names (handle above),
4175      `void' at top level (not within pointer)
4176      is allowed only in public variables.
4177      We don't complain about parms either, but that is because
4178      a better error message can be made later.  */
4179
4180   if (VOID_TYPE_P (type) && decl_context != PARM
4181       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4182             && ((specbits & (1 << (int) RID_EXTERN))
4183                 || (current_scope == global_scope
4184                     && !(specbits
4185                          & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4186     {
4187       error ("variable or field `%s' declared void", name);
4188       type = integer_type_node;
4189     }
4190
4191   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4192      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
4193
4194   {
4195     tree decl;
4196
4197     if (decl_context == PARM)
4198       {
4199         tree type_as_written;
4200         tree promoted_type;
4201
4202         /* A parameter declared as an array of T is really a pointer to T.
4203            One declared as a function is really a pointer to a function.  */
4204
4205         if (TREE_CODE (type) == ARRAY_TYPE)
4206           {
4207             /* Transfer const-ness of array into that of type pointed to.  */
4208             type = TREE_TYPE (type);
4209             if (type_quals)
4210               type = c_build_qualified_type (type, type_quals);
4211             type = build_pointer_type (type);
4212             type_quals = TYPE_UNQUALIFIED;
4213             if (array_ptr_quals)
4214               {
4215                 tree new_ptr_quals, new_ptr_attrs;
4216                 int erred = 0;
4217                 split_specs_attrs (array_ptr_quals, &new_ptr_quals, &new_ptr_attrs);
4218                 /* We don't yet implement attributes in this context.  */
4219                 if (new_ptr_attrs != NULL_TREE)
4220                   warning ("attributes in parameter array declarator ignored");
4221
4222                 constp = 0;
4223                 volatilep = 0;
4224                 restrictp = 0;
4225                 for (; new_ptr_quals; new_ptr_quals = TREE_CHAIN (new_ptr_quals))
4226                   {
4227                     tree qualifier = TREE_VALUE (new_ptr_quals);
4228
4229                     if (C_IS_RESERVED_WORD (qualifier))
4230                       {
4231                         if (C_RID_CODE (qualifier) == RID_CONST)
4232                           constp++;
4233                         else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4234                           volatilep++;
4235                         else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4236                           restrictp++;
4237                         else
4238                           erred++;
4239                       }
4240                     else
4241                       erred++;
4242                   }
4243
4244                 if (erred)
4245                   error ("invalid type modifier within array declarator");
4246
4247                 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4248                               | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4249                               | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4250               }
4251             size_varies = 0;
4252           }
4253         else if (TREE_CODE (type) == FUNCTION_TYPE)
4254           {
4255             if (pedantic && type_quals)
4256               pedwarn ("ISO C forbids qualified function types");
4257             if (type_quals)
4258               type = c_build_qualified_type (type, type_quals);
4259             type = build_pointer_type (type);
4260             type_quals = TYPE_UNQUALIFIED;
4261           }
4262         else if (type_quals)
4263           type = c_build_qualified_type (type, type_quals);
4264
4265         type_as_written = type;
4266
4267         decl = build_decl (PARM_DECL, declarator, type);
4268         if (size_varies)
4269           C_DECL_VARIABLE_SIZE (decl) = 1;
4270
4271         /* Compute the type actually passed in the parmlist,
4272            for the case where there is no prototype.
4273            (For example, shorts and chars are passed as ints.)
4274            When there is a prototype, this is overridden later.  */
4275
4276         if (type == error_mark_node)
4277           promoted_type = type;
4278         else
4279           promoted_type = c_type_promotes_to (type);
4280
4281         DECL_ARG_TYPE (decl) = promoted_type;
4282         DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4283       }
4284     else if (decl_context == FIELD)
4285       {
4286         /* Structure field.  It may not be a function.  */
4287
4288         if (TREE_CODE (type) == FUNCTION_TYPE)
4289           {
4290             error ("field `%s' declared as a function", name);
4291             type = build_pointer_type (type);
4292           }
4293         else if (TREE_CODE (type) != ERROR_MARK
4294                  && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4295           {
4296             error ("field `%s' has incomplete type", name);
4297             type = error_mark_node;
4298           }
4299         /* Move type qualifiers down to element of an array.  */
4300         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4301           type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4302                                                            type_quals),
4303                                    TYPE_DOMAIN (type));
4304         decl = build_decl (FIELD_DECL, declarator, type);
4305         DECL_NONADDRESSABLE_P (decl) = bitfield;
4306
4307         if (size_varies)
4308           C_DECL_VARIABLE_SIZE (decl) = 1;
4309       }
4310     else if (TREE_CODE (type) == FUNCTION_TYPE)
4311       {
4312         /* Every function declaration is "external"
4313            except for those which are inside a function body
4314            in which `auto' is used.
4315            That is a case not specified by ANSI C,
4316            and we use it for forward declarations for nested functions.  */
4317         int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4318                           || current_scope == global_scope);
4319
4320         if (specbits & (1 << (int) RID_AUTO)
4321             && (pedantic || current_scope == global_scope))
4322           pedwarn ("invalid storage class for function `%s'", name);
4323         if (specbits & (1 << (int) RID_REGISTER))
4324           error ("invalid storage class for function `%s'", name);
4325         if (specbits & (1 << (int) RID_THREAD))
4326           error ("invalid storage class for function `%s'", name);
4327         /* Function declaration not at file scope.
4328            Storage classes other than `extern' are not allowed
4329            and `extern' makes no difference.  */
4330         if (current_scope != global_scope
4331             && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4332             && pedantic)
4333           pedwarn ("invalid storage class for function `%s'", name);
4334
4335         decl = build_decl (FUNCTION_DECL, declarator, type);
4336         decl = build_decl_attribute_variant (decl, decl_attr);
4337
4338         DECL_LANG_SPECIFIC (decl)
4339           = ggc_alloc_cleared (sizeof (struct lang_decl));
4340
4341         if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4342           pedwarn ("ISO C forbids qualified function types");
4343
4344         /* GNU C interprets a `volatile void' return type to indicate
4345            that the function does not return.  */
4346         if ((type_quals & TYPE_QUAL_VOLATILE)
4347             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4348           warning ("`noreturn' function returns non-void value");
4349
4350         if (extern_ref)
4351           DECL_EXTERNAL (decl) = 1;
4352         /* Record absence of global scope for `static' or `auto'.  */
4353         TREE_PUBLIC (decl)
4354           = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4355
4356         /* For a function definition, record the argument information
4357            block in DECL_ARGUMENTS where store_parm_decls will look
4358            for it.  */
4359         if (funcdef_flag)
4360           DECL_ARGUMENTS (decl) = arg_info;
4361
4362         if (defaulted_int)
4363           C_FUNCTION_IMPLICIT_INT (decl) = 1;
4364
4365         /* Record presence of `inline', if it is reasonable.  */
4366         if (MAIN_NAME_P (declarator))
4367           {
4368             if (inlinep)
4369               warning ("cannot inline function `main'");
4370           }
4371         else if (inlinep)
4372           {
4373             /* Record that the function is declared `inline'.  */
4374             DECL_DECLARED_INLINE_P (decl) = 1;
4375
4376             /* Do not mark bare declarations as DECL_INLINE.  Doing so
4377                in the presence of multiple declarations can result in
4378                the abstract origin pointing between the declarations,
4379                which will confuse dwarf2out.  */
4380             if (initialized)
4381               {
4382                 DECL_INLINE (decl) = 1;
4383                 if (specbits & (1 << (int) RID_EXTERN))
4384                   current_extern_inline = 1;
4385               }
4386           }
4387         /* If -finline-functions, assume it can be inlined.  This does
4388            two things: let the function be deferred until it is actually
4389            needed, and let dwarf2 know that the function is inlinable.  */
4390         else if (flag_inline_trees == 2 && initialized)
4391           DECL_INLINE (decl) = 1;
4392       }
4393     else
4394       {
4395         /* It's a variable.  */
4396         /* An uninitialized decl with `extern' is a reference.  */
4397         int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4398
4399         /* Move type qualifiers down to element of an array.  */
4400         if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4401           {
4402             int saved_align = TYPE_ALIGN(type);
4403             type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4404                                                              type_quals),
4405                                      TYPE_DOMAIN (type));
4406             TYPE_ALIGN (type) = saved_align;
4407           }
4408         else if (type_quals)
4409           type = c_build_qualified_type (type, type_quals);
4410
4411         /* It is invalid to create an `extern' declaration for a
4412            variable if there is a global declaration that is
4413            `static'.  */
4414         if (extern_ref && current_scope != global_scope)
4415           {
4416             tree global_decl;
4417
4418             global_decl = identifier_global_value (declarator);
4419             if (global_decl
4420                 && TREE_CODE (global_decl) == VAR_DECL
4421                 && !TREE_PUBLIC (global_decl))
4422               error ("variable previously declared `static' redeclared "
4423                      "`extern'");
4424           }
4425
4426         decl = build_decl (VAR_DECL, declarator, type);
4427         if (size_varies)
4428           C_DECL_VARIABLE_SIZE (decl) = 1;
4429
4430         if (inlinep)
4431           pedwarn ("%Jvariable '%D' declared `inline'", decl, decl);
4432
4433         DECL_EXTERNAL (decl) = extern_ref;
4434
4435         /* At file scope, the presence of a `static' or `register' storage
4436            class specifier, or the absence of all storage class specifiers
4437            makes this declaration a definition (perhaps tentative).  Also,
4438            the absence of both `static' and `register' makes it public.  */
4439         if (current_scope == global_scope)
4440           {
4441             TREE_PUBLIC (decl) = !(specbits & ((1 << (int) RID_STATIC)
4442                                                | (1 << (int) RID_REGISTER)));
4443             TREE_STATIC (decl) = !extern_ref;
4444           }
4445         /* Not at file scope, only `static' makes a static definition.  */
4446         else
4447           {
4448             TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4449             TREE_PUBLIC (decl) = extern_ref;
4450           }
4451
4452         if (specbits & 1 << (int) RID_THREAD)
4453           {
4454             if (targetm.have_tls)
4455               DECL_THREAD_LOCAL (decl) = 1;
4456             else
4457               /* A mere warning is sure to result in improper semantics
4458                  at runtime.  Don't bother to allow this to compile.  */
4459               error ("thread-local storage not supported for this target");
4460           }
4461       }
4462
4463     /* Record `register' declaration for warnings on &
4464        and in case doing stupid register allocation.  */
4465
4466     if (specbits & (1 << (int) RID_REGISTER))
4467       DECL_REGISTER (decl) = 1;
4468
4469     /* Record constancy and volatility.  */
4470     c_apply_type_quals_to_decl (type_quals, decl);
4471
4472     /* If a type has volatile components, it should be stored in memory.
4473        Otherwise, the fact that those components are volatile
4474        will be ignored, and would even crash the compiler.  */
4475     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4476       c_mark_addressable (decl);
4477
4478 #ifdef ENABLE_CHECKING
4479   /* This is the earliest point at which we might know the assembler
4480      name of a variable.  Thus, if it's known before this, die horribly.  */
4481   if (DECL_ASSEMBLER_NAME_SET_P (decl))
4482     abort ();
4483 #endif
4484
4485     decl_attributes (&decl, returned_attrs, 0);
4486
4487     return decl;
4488   }
4489 }
4490 \f
4491 /* Decode the parameter-list info for a function type or function definition.
4492    The argument is the value returned by `get_parm_info' (or made in parse.y
4493    if there is an identifier list instead of a parameter decl list).
4494    These two functions are separate because when a function returns
4495    or receives functions then each is called multiple times but the order
4496    of calls is different.  The last call to `grokparms' is always the one
4497    that contains the formal parameter names of a function definition.
4498
4499    Return a list of arg types to use in the FUNCTION_TYPE for this function.
4500
4501    FUNCDEF_FLAG is nonzero for a function definition, 0 for
4502    a mere declaration.  A nonempty identifier-list gets an error message
4503    when FUNCDEF_FLAG is zero.  */
4504
4505 static tree
4506 grokparms (tree arg_info, int funcdef_flag)
4507 {
4508   tree arg_types = ARG_INFO_TYPES (arg_info);
4509
4510   if (warn_strict_prototypes && arg_types == 0 && !funcdef_flag
4511       && !in_system_header)
4512     warning ("function declaration isn't a prototype");
4513
4514   if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
4515     {
4516       if (! funcdef_flag)
4517         pedwarn ("parameter names (without types) in function declaration");
4518
4519       ARG_INFO_PARMS (arg_info) = ARG_INFO_TYPES (arg_info);
4520       ARG_INFO_TYPES (arg_info) = 0;
4521       return 0;
4522     }
4523   else
4524     {
4525       tree parm, type, typelt;
4526       unsigned int parmno;
4527
4528       /* If the arg types are incomplete in a declaration, they must
4529          include undefined tags.  These tags can never be defined in
4530          the scope of the declaration, so the types can never be
4531          completed, and no call can be compiled successfully.  */
4532
4533       for (parm = ARG_INFO_PARMS (arg_info), typelt = arg_types, parmno = 1;
4534            parm;
4535            parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
4536         {
4537           type = TREE_VALUE (typelt);
4538           if (type == error_mark_node)
4539             continue;
4540
4541           if (!COMPLETE_TYPE_P (type))
4542             {
4543               if (funcdef_flag)
4544                 {
4545                   if (DECL_NAME (parm))
4546                     error ("%Jparameter %u ('%D') has incomplete type",
4547                            parm, parmno, parm);
4548                   else
4549                     error ("%Jparameter %u has incomplete type",
4550                            parm, parmno);
4551
4552                   TREE_VALUE (typelt) = error_mark_node;
4553                   TREE_TYPE (parm) = error_mark_node;
4554                 }
4555               else
4556                 {
4557                   if (DECL_NAME (parm))
4558                     warning ("%Jparameter %u ('%D') has incomplete type",
4559                              parm, parmno, parm);
4560                   else
4561                     warning ("%Jparameter %u has incomplete type",
4562                              parm, parmno);
4563                 }
4564             }
4565         }
4566       return arg_types;
4567     }
4568 }
4569
4570 /* Return a tree_list node with info on a parameter list just parsed.
4571    This tree_list node should be examined using the ARG_INFO_* macros,
4572    defined above:
4573      ARG_INFO_PARMS:  a list of parameter decls.
4574      ARG_INFO_TAGS:   a list of structure, union and enum tags defined.
4575      ARG_INFO_TYPES:  a list of argument types to go in the FUNCTION_TYPE.
4576      ARG_INFO_OTHERS: a list of non-parameter decls (notably enumeration
4577                       constants) defined with the parameters.
4578
4579    This tree_list node is later fed to 'grokparms' and 'store_parm_decls'.
4580
4581    VOID_AT_END nonzero means append `void' to the end of the type-list.
4582    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
4583
4584 tree
4585 get_parm_info (int void_at_end)
4586 {
4587   tree decl, type, list;
4588   tree types = 0;
4589   tree *last_type = &types;
4590   tree tags = current_scope->tags;
4591   tree parms = current_scope->parms;
4592   tree others = current_scope->names;
4593   static bool explained_incomplete_types = false;
4594   bool gave_void_only_once_err = false;
4595
4596   /* Just 'void' (and no ellipsis) is special.  There are really no parms.
4597      But if the 'void' is qualified (by 'const' or 'volatile'), or has a
4598      storage class specifier ('register'), then the behavior is undefined;
4599      issue an error.  Typedefs for 'void' are OK (see DR#157).  */
4600   if (void_at_end && parms != 0
4601       && TREE_CHAIN (parms) == 0
4602       && VOID_TYPE_P (TREE_TYPE (parms))
4603       && !DECL_NAME (parms))
4604     {
4605       if (TREE_THIS_VOLATILE (parms)
4606           || TREE_READONLY (parms)
4607           || DECL_REGISTER (parms))
4608         error ("'void' as only parameter may not be qualified");
4609
4610       list = make_node (TREE_LIST);
4611       ARG_INFO_TYPES (list) = build_tree_list (0, void_type_node);
4612       return list;
4613     }
4614
4615   /* Sanity check all of the parameter declarations.  */
4616   for (decl = parms; decl; decl = TREE_CHAIN (decl))
4617     {
4618 #ifdef ENABLE_CHECKING
4619       if (TREE_CODE (decl) != PARM_DECL)
4620         abort ();
4621       if (TREE_ASM_WRITTEN (decl))
4622         abort ();
4623 #endif
4624
4625       /* Since there is a prototype, args are passed in their
4626          declared types.  The back end may override this.  */
4627       type = TREE_TYPE (decl);
4628       DECL_ARG_TYPE (decl) = type;
4629
4630       /* Check for (..., void, ...) and issue an error.  */
4631       if (VOID_TYPE_P (type) && !DECL_NAME (decl) && !gave_void_only_once_err)
4632         {
4633           error ("'void' must be the only parameter");
4634           gave_void_only_once_err = true;
4635         }
4636
4637       type = build_tree_list (0, type);
4638       *last_type = type;
4639       last_type = &TREE_CHAIN (type);
4640     }
4641
4642   /* Check the list of non-parameter decls for any forward parm decls
4643      that never got real decls.  */
4644   for (decl = others; decl; decl = TREE_CHAIN (decl))
4645     if (TREE_CODE (decl) == PARM_DECL)
4646       {
4647         if (!TREE_ASM_WRITTEN (decl))
4648           abort ();
4649
4650           error ("%Jparameter '%D' has just a forward declaration",
4651                  decl, decl);
4652       }
4653
4654   /* Warn about any struct, union or enum tags defined within this
4655      list.  The scope of such types is limited to this declaration,
4656      which is rarely if ever desirable (it's impossible to call such
4657      a function with type-correct arguments).  */
4658   for (decl = tags; decl; decl = TREE_CHAIN (decl))
4659     {
4660       enum tree_code code = TREE_CODE (TREE_VALUE (decl));
4661       const char *keyword;
4662       /* An anonymous union parm type is meaningful as a GNU extension.
4663          So don't warn for that.  */
4664       if (code == UNION_TYPE && TREE_PURPOSE (decl) == 0 && !pedantic)
4665         continue;
4666
4667       /* The keyword should not be translated.  */
4668       switch (code)
4669         {
4670         case RECORD_TYPE:   keyword = "struct"; break;
4671         case UNION_TYPE:    keyword = "union";  break;
4672         case ENUMERAL_TYPE: keyword = "enum";   break;
4673         default: abort ();
4674         }
4675
4676       if (TREE_PURPOSE (decl))
4677         /* The %s will be one of 'struct', 'union', or 'enum'.  */
4678         warning ("'%s %E' declared inside parameter list",
4679                  keyword, TREE_PURPOSE (decl));
4680       else
4681         /* The %s will be one of 'struct', 'union', or 'enum'.  */
4682         warning ("anonymous %s declared inside parameter list", keyword);
4683
4684       if (! explained_incomplete_types)
4685         {
4686           warning ("its scope is only this definition or declaration,"
4687                    " which is probably not what you want");
4688           explained_incomplete_types = true;
4689         }
4690     }
4691
4692
4693   if (void_at_end)
4694     {
4695       type = build_tree_list (0, void_type_node);
4696       *last_type = type;
4697     }
4698
4699   list = make_node (TREE_LIST);
4700   ARG_INFO_PARMS  (list) = parms;
4701   ARG_INFO_TAGS   (list) = tags;
4702   ARG_INFO_TYPES  (list) = types;
4703   ARG_INFO_OTHERS (list) = others;
4704   return list;
4705 }
4706 \f
4707 /* Get the struct, enum or union (CODE says which) with tag NAME.
4708    Define the tag as a forward-reference if it is not defined.  */
4709
4710 tree
4711 xref_tag (enum tree_code code, tree name)
4712 {
4713   /* If a cross reference is requested, look up the type
4714      already defined for this tag and return it.  */
4715
4716   tree ref = lookup_tag (code, name, 0);
4717   /* If this is the right type of tag, return what we found.
4718      (This reference will be shadowed by shadow_tag later if appropriate.)
4719      If this is the wrong type of tag, do not return it.  If it was the
4720      wrong type in the same scope, we will have had an error
4721      message already; if in a different scope and declaring
4722      a name, pending_xref_error will give an error message; but if in a
4723      different scope and not declaring a name, this tag should
4724      shadow the previous declaration of a different type of tag, and
4725      this would not work properly if we return the reference found.
4726      (For example, with "struct foo" in an outer scope, "union foo;"
4727      must shadow that tag with a new one of union type.)  */
4728   if (ref && TREE_CODE (ref) == code)
4729     return ref;
4730
4731   /* If no such tag is yet defined, create a forward-reference node
4732      and record it as the "definition".
4733      When a real declaration of this type is found,
4734      the forward-reference will be altered into a real type.  */
4735
4736   ref = make_node (code);
4737   if (code == ENUMERAL_TYPE)
4738     {
4739       /* Give the type a default layout like unsigned int
4740          to avoid crashing if it does not get defined.  */
4741       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
4742       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
4743       TYPE_USER_ALIGN (ref) = 0;
4744       TREE_UNSIGNED (ref) = 1;
4745       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
4746       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
4747       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
4748     }
4749
4750   pushtag (name, ref);
4751
4752   return ref;
4753 }
4754 \f
4755 /* Make sure that the tag NAME is defined *in the current scope*
4756    at least as a forward reference.
4757    CODE says which kind of tag NAME ought to be.  */
4758
4759 tree
4760 start_struct (enum tree_code code, tree name)
4761 {
4762   /* If there is already a tag defined at this scope
4763      (as a forward reference), just return it.  */
4764
4765   tree ref = 0;
4766
4767   if (name != 0)
4768     ref = lookup_tag (code, name, 1);
4769   if (ref && TREE_CODE (ref) == code)
4770     {
4771       if (TYPE_FIELDS (ref))
4772         {
4773           if (code == UNION_TYPE)
4774             error ("redefinition of `union %s'", IDENTIFIER_POINTER (name));
4775           else
4776             error ("redefinition of `struct %s'", IDENTIFIER_POINTER (name));
4777         }
4778     }
4779   else
4780     {
4781       /* Otherwise create a forward-reference just so the tag is in scope.  */
4782
4783       ref = make_node (code);
4784       pushtag (name, ref);
4785     }
4786
4787   C_TYPE_BEING_DEFINED (ref) = 1;
4788   TYPE_PACKED (ref) = flag_pack_struct;
4789   return ref;
4790 }
4791
4792 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
4793    of a structure component, returning a FIELD_DECL node.
4794    WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
4795
4796    This is done during the parsing of the struct declaration.
4797    The FIELD_DECL nodes are chained together and the lot of them
4798    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
4799
4800 tree
4801 grokfield (tree declarator, tree declspecs, tree width)
4802 {
4803   tree value;
4804
4805   if (declarator == NULL_TREE && width == NULL_TREE)
4806     {
4807       /* This is an unnamed decl.
4808
4809          If we have something of the form "union { list } ;" then this
4810          is the anonymous union extension.  Similarly for struct.
4811
4812          If this is something of the form "struct foo;", then
4813            If MS extensions are enabled, this is handled as an
4814              anonymous struct.
4815            Otherwise this is a forward declaration of a structure tag.
4816
4817          If this is something of the form "foo;" and foo is a TYPE_DECL, then
4818            If MS extensions are enabled and foo names a structure, then
4819              again this is an anonymous struct.
4820            Otherwise this is an error.
4821
4822          Oh what a horrid tangled web we weave.  I wonder if MS consciously
4823          took this from Plan 9 or if it was an accident of implementation
4824          that took root before someone noticed the bug...  */
4825
4826       tree type = TREE_VALUE (declspecs);
4827
4828       if (flag_ms_extensions && TREE_CODE (type) == TYPE_DECL)
4829         type = TREE_TYPE (type);
4830       if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE)
4831         {
4832           if (flag_ms_extensions)
4833             ; /* ok */
4834           else if (flag_iso)
4835             goto warn_unnamed_field;
4836           else if (TYPE_NAME (type) == NULL)
4837             ; /* ok */
4838           else
4839             goto warn_unnamed_field;
4840         }
4841       else
4842         {
4843         warn_unnamed_field:
4844           warning ("declaration does not declare anything");
4845           return NULL_TREE;
4846         }
4847     }
4848
4849   value = grokdeclarator (declarator, declspecs, FIELD, 0,
4850                           width ? &width : NULL);
4851
4852   finish_decl (value, NULL_TREE, NULL_TREE);
4853   DECL_INITIAL (value) = width;
4854
4855   return value;
4856 }
4857 \f
4858 /* Generate an error for any duplicate field names in FIELDLIST.  Munge
4859    the list such that this does not present a problem later.  */
4860
4861 static void
4862 detect_field_duplicates (tree fieldlist)
4863 {
4864   tree x, y;
4865   int timeout = 10;
4866
4867   /* First, see if there are more than "a few" fields.
4868      This is trivially true if there are zero or one fields.  */
4869   if (!fieldlist)
4870     return;
4871   x = TREE_CHAIN (fieldlist);
4872   if (!x)
4873     return;
4874   do {
4875     timeout--;
4876     x = TREE_CHAIN (x);
4877   } while (timeout > 0 && x);
4878
4879   /* If there were "few" fields, avoid the overhead of allocating
4880      a hash table.  Instead just do the nested traversal thing.  */
4881   if (timeout > 0)
4882     {
4883       for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
4884         if (DECL_NAME (x))
4885           {
4886             for (y = fieldlist; y != x; y = TREE_CHAIN (y))
4887               if (DECL_NAME (y) == DECL_NAME (x))
4888                 {
4889                   error ("%Jduplicate member '%D'", x, x);
4890                   DECL_NAME (x) = NULL_TREE;
4891                 }
4892           }
4893     }
4894   else
4895     {
4896       htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
4897       void **slot;
4898
4899       for (x = fieldlist; x ; x = TREE_CHAIN (x))
4900         if ((y = DECL_NAME (x)) != 0)
4901           {
4902             slot = htab_find_slot (htab, y, INSERT);
4903             if (*slot)
4904               {
4905                 error ("%Jduplicate member '%D'", x, x);
4906                 DECL_NAME (x) = NULL_TREE;
4907               }
4908             *slot = y;
4909           }
4910
4911       htab_delete (htab);
4912     }
4913 }
4914
4915 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
4916    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
4917    ATTRIBUTES are attributes to be applied to the structure.  */
4918
4919 tree
4920 finish_struct (tree t, tree fieldlist, tree attributes)
4921 {
4922   tree x;
4923   int toplevel = global_scope == current_scope;
4924   int saw_named_field;
4925
4926   /* If this type was previously laid out as a forward reference,
4927      make sure we lay it out again.  */
4928
4929   TYPE_SIZE (t) = 0;
4930
4931   decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
4932
4933   /* Nameless union parm types are useful as GCC extension.  */
4934   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
4935     /* Otherwise, warn about any struct or union def. in parmlist.  */
4936     if (in_parm_level_p ())
4937       {
4938         if (pedantic)
4939           pedwarn ("%s defined inside parms",
4940                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
4941         else
4942           warning ("%s defined inside parms",
4943                    TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
4944       }
4945
4946   if (pedantic)
4947     {
4948       for (x = fieldlist; x; x = TREE_CHAIN (x))
4949         if (DECL_NAME (x) != 0)
4950           break;
4951
4952       if (x == 0)
4953         pedwarn ("%s has no %s",
4954                  TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
4955                  fieldlist ? _("named members") : _("members"));
4956     }
4957
4958   /* Install struct as DECL_CONTEXT of each field decl.
4959      Also process specified field sizes,m which is found in the DECL_INITIAL.
4960      Store 0 there, except for ": 0" fields (so we can find them
4961      and delete them, below).  */
4962
4963   saw_named_field = 0;
4964   for (x = fieldlist; x; x = TREE_CHAIN (x))
4965     {
4966       DECL_CONTEXT (x) = t;
4967       DECL_PACKED (x) |= TYPE_PACKED (t);
4968
4969       /* If any field is const, the structure type is pseudo-const.  */
4970       if (TREE_READONLY (x))
4971         C_TYPE_FIELDS_READONLY (t) = 1;
4972       else
4973         {
4974           /* A field that is pseudo-const makes the structure likewise.  */
4975           tree t1 = TREE_TYPE (x);
4976           while (TREE_CODE (t1) == ARRAY_TYPE)
4977             t1 = TREE_TYPE (t1);
4978           if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
4979               && C_TYPE_FIELDS_READONLY (t1))
4980             C_TYPE_FIELDS_READONLY (t) = 1;
4981         }
4982
4983       /* Any field that is volatile means variables of this type must be
4984          treated in some ways as volatile.  */
4985       if (TREE_THIS_VOLATILE (x))
4986         C_TYPE_FIELDS_VOLATILE (t) = 1;
4987
4988       /* Any field of nominal variable size implies structure is too.  */
4989       if (C_DECL_VARIABLE_SIZE (x))
4990         C_TYPE_VARIABLE_SIZE (t) = 1;
4991
4992       /* Detect invalid nested redefinition.  */
4993       if (TREE_TYPE (x) == t)
4994         error ("nested redefinition of `%s'",
4995                IDENTIFIER_POINTER (TYPE_NAME (t)));
4996
4997       if (DECL_INITIAL (x))
4998         {
4999           unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
5000           DECL_SIZE (x) = bitsize_int (width);
5001           DECL_BIT_FIELD (x) = 1;
5002           SET_DECL_C_BIT_FIELD (x);
5003         }
5004
5005       DECL_INITIAL (x) = 0;
5006
5007       /* Detect flexible array member in an invalid context.  */
5008       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5009           && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5010           && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5011           && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5012         {
5013           if (TREE_CODE (t) == UNION_TYPE)
5014             error ("%Jflexible array member in union", x);
5015           else if (TREE_CHAIN (x) != NULL_TREE)
5016             error ("%Jflexible array member not at end of struct", x);
5017           else if (! saw_named_field)
5018             error ("%Jflexible array member in otherwise empty struct", x);
5019         }
5020
5021       if (pedantic && TREE_CODE (t) == RECORD_TYPE
5022           && flexible_array_type_p (TREE_TYPE (x)))
5023         pedwarn ("%Jinvalid use of structure with flexible array member", x);
5024
5025       if (DECL_NAME (x))
5026         saw_named_field = 1;
5027     }
5028
5029   detect_field_duplicates (fieldlist);
5030
5031   /* Now we have the nearly final fieldlist.  Record it,
5032      then lay out the structure or union (including the fields).  */
5033
5034   TYPE_FIELDS (t) = fieldlist;
5035
5036   layout_type (t);
5037
5038   /* Delete all zero-width bit-fields from the fieldlist.  */
5039   {
5040     tree *fieldlistp = &fieldlist;
5041     while (*fieldlistp)
5042       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5043         *fieldlistp = TREE_CHAIN (*fieldlistp);
5044       else
5045         fieldlistp = &TREE_CHAIN (*fieldlistp);
5046   }
5047
5048   /* Now we have the truly final field list.
5049      Store it in this type and in the variants.  */
5050
5051   TYPE_FIELDS (t) = fieldlist;
5052
5053   /* If there are lots of fields, sort so we can look through them fast.
5054      We arbitrarily consider 16 or more elts to be "a lot".  */
5055
5056   {
5057     int len = 0;
5058
5059     for (x = fieldlist; x; x = TREE_CHAIN (x))
5060       {
5061         if (len > 15 || DECL_NAME (x) == NULL)
5062           break;
5063         len += 1;
5064       }
5065
5066     if (len > 15)
5067       {
5068         tree *field_array;
5069         struct lang_type *space;
5070         struct sorted_fields_type *space2;
5071
5072         len += list_length (x);
5073
5074         /* Use the same allocation policy here that make_node uses, to
5075           ensure that this lives as long as the rest of the struct decl.
5076           All decls in an inline function need to be saved.  */
5077
5078         space = ggc_alloc (sizeof (struct lang_type));
5079         space2 = ggc_alloc (sizeof (struct sorted_fields_type) + len * sizeof (tree));
5080
5081         len = 0;
5082         space->s = space2;
5083         field_array = &space2->elts[0];
5084         for (x = fieldlist; x; x = TREE_CHAIN (x))
5085           {
5086             field_array[len++] = x;
5087
5088             /* If there is anonymous struct or union, break out of the loop.  */
5089             if (DECL_NAME (x) == NULL)
5090               break;
5091           }
5092         /* Found no anonymous struct/union.  Add the TYPE_LANG_SPECIFIC.  */
5093         if (x == NULL)
5094           {
5095             TYPE_LANG_SPECIFIC (t) = space;
5096             TYPE_LANG_SPECIFIC (t)->s->len = len;
5097             field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
5098             qsort (field_array, len, sizeof (tree), field_decl_cmp);
5099           }
5100       }
5101   }
5102
5103   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5104     {
5105       TYPE_FIELDS (x) = TYPE_FIELDS (t);
5106       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5107       TYPE_ALIGN (x) = TYPE_ALIGN (t);
5108       TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5109     }
5110
5111   /* If this was supposed to be a transparent union, but we can't
5112      make it one, warn and turn off the flag.  */
5113   if (TREE_CODE (t) == UNION_TYPE
5114       && TYPE_TRANSPARENT_UNION (t)
5115       && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5116     {
5117       TYPE_TRANSPARENT_UNION (t) = 0;
5118       warning ("union cannot be made transparent");
5119     }
5120
5121   /* If this structure or union completes the type of any previous
5122      variable declaration, lay it out and output its rtl.  */
5123   for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
5124        x;
5125        x = TREE_CHAIN (x))
5126     {
5127       tree decl = TREE_VALUE (x);
5128       if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5129         layout_array_type (TREE_TYPE (decl));
5130       if (TREE_CODE (decl) != TYPE_DECL)
5131         {
5132           layout_decl (decl, 0);
5133           if (c_dialect_objc ())
5134             objc_check_decl (decl);
5135           rest_of_decl_compilation (decl, NULL, toplevel, 0);
5136           if (! toplevel)
5137             expand_decl (decl);
5138         }
5139     }
5140   C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
5141
5142   /* Finish debugging output for this type.  */
5143   rest_of_type_compilation (t, toplevel);
5144
5145   return t;
5146 }
5147
5148 /* Lay out the type T, and its element type, and so on.  */
5149
5150 static void
5151 layout_array_type (tree t)
5152 {
5153   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5154     layout_array_type (TREE_TYPE (t));
5155   layout_type (t);
5156 }
5157 \f
5158 /* Begin compiling the definition of an enumeration type.
5159    NAME is its name (or null if anonymous).
5160    Returns the type object, as yet incomplete.
5161    Also records info about it so that build_enumerator
5162    may be used to declare the individual values as they are read.  */
5163
5164 tree
5165 start_enum (tree name)
5166 {
5167   tree enumtype = 0;
5168
5169   /* If this is the real definition for a previous forward reference,
5170      fill in the contents in the same object that used to be the
5171      forward reference.  */
5172
5173   if (name != 0)
5174     enumtype = lookup_tag (ENUMERAL_TYPE, name, 1);
5175
5176   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5177     {
5178       enumtype = make_node (ENUMERAL_TYPE);
5179       pushtag (name, enumtype);
5180     }
5181
5182   C_TYPE_BEING_DEFINED (enumtype) = 1;
5183
5184   if (TYPE_VALUES (enumtype) != 0)
5185     {
5186       /* This enum is a named one that has been declared already.  */
5187       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5188
5189       /* Completely replace its old definition.
5190          The old enumerators remain defined, however.  */
5191       TYPE_VALUES (enumtype) = 0;
5192     }
5193
5194   enum_next_value = integer_zero_node;
5195   enum_overflow = 0;
5196
5197   if (flag_short_enums)
5198     TYPE_PACKED (enumtype) = 1;
5199
5200   return enumtype;
5201 }
5202
5203 /* After processing and defining all the values of an enumeration type,
5204    install their decls in the enumeration type and finish it off.
5205    ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5206    and ATTRIBUTES are the specified attributes.
5207    Returns ENUMTYPE.  */
5208
5209 tree
5210 finish_enum (tree enumtype, tree values, tree attributes)
5211 {
5212   tree pair, tem;
5213   tree minnode = 0, maxnode = 0, enum_value_type;
5214   int precision, unsign;
5215   int toplevel = (global_scope == current_scope);
5216
5217   if (in_parm_level_p ())
5218     warning ("enum defined inside parms");
5219
5220   decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5221
5222   /* Calculate the maximum value of any enumerator in this type.  */
5223
5224   if (values == error_mark_node)
5225     minnode = maxnode = integer_zero_node;
5226   else
5227     {
5228       minnode = maxnode = TREE_VALUE (values);
5229       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5230         {
5231           tree value = TREE_VALUE (pair);
5232           if (tree_int_cst_lt (maxnode, value))
5233             maxnode = value;
5234           if (tree_int_cst_lt (value, minnode))
5235             minnode = value;
5236         }
5237     }
5238
5239   /* Construct the final type of this enumeration.  It is the same
5240      as one of the integral types - the narrowest one that fits, except
5241      that normally we only go as narrow as int - and signed iff any of
5242      the values are negative.  */
5243   unsign = (tree_int_cst_sgn (minnode) >= 0);
5244   precision = MAX (min_precision (minnode, unsign),
5245                    min_precision (maxnode, unsign));
5246   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5247     {
5248       tree narrowest = c_common_type_for_size (precision, unsign);
5249       if (narrowest == 0)
5250         {
5251           warning ("enumeration values exceed range of largest integer");
5252           narrowest = long_long_integer_type_node;
5253         }
5254
5255       precision = TYPE_PRECISION (narrowest);
5256     }
5257   else
5258     precision = TYPE_PRECISION (integer_type_node);
5259
5260   if (precision == TYPE_PRECISION (integer_type_node))
5261     enum_value_type = c_common_type_for_size (precision, 0);
5262   else
5263     enum_value_type = enumtype;
5264
5265   TYPE_MIN_VALUE (enumtype) = minnode;
5266   TYPE_MAX_VALUE (enumtype) = maxnode;
5267   TYPE_PRECISION (enumtype) = precision;
5268   TREE_UNSIGNED (enumtype) = unsign;
5269   TYPE_SIZE (enumtype) = 0;
5270   layout_type (enumtype);
5271
5272   if (values != error_mark_node)
5273     {
5274       /* Change the type of the enumerators to be the enum type.  We
5275          need to do this irrespective of the size of the enum, for
5276          proper type checking.  Replace the DECL_INITIALs of the
5277          enumerators, and the value slots of the list, with copies
5278          that have the enum type; they cannot be modified in place
5279          because they may be shared (e.g.  integer_zero_node) Finally,
5280          change the purpose slots to point to the names of the decls.  */
5281       for (pair = values; pair; pair = TREE_CHAIN (pair))
5282         {
5283           tree enu = TREE_PURPOSE (pair);
5284
5285           TREE_TYPE (enu) = enumtype;
5286
5287           /* The ISO C Standard mandates enumerators to have type int,
5288              even though the underlying type of an enum type is
5289              unspecified.  Here we convert any enumerators that fit in
5290              an int to type int, to avoid promotions to unsigned types
5291              when comparing integers with enumerators that fit in the
5292              int range.  When -pedantic is given, build_enumerator()
5293              would have already taken care of those that don't fit.  */
5294           if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5295             DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5296           else
5297             DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5298
5299           TREE_PURPOSE (pair) = DECL_NAME (enu);
5300           TREE_VALUE (pair) = DECL_INITIAL (enu);
5301         }
5302
5303       TYPE_VALUES (enumtype) = values;
5304     }
5305
5306   /* Fix up all variant types of this enum type.  */
5307   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5308     {
5309       if (tem == enumtype)
5310         continue;
5311       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5312       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5313       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5314       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5315       TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5316       TYPE_MODE (tem) = TYPE_MODE (enumtype);
5317       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5318       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5319       TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5320       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5321     }
5322
5323   /* Finish debugging output for this type.  */
5324   rest_of_type_compilation (enumtype, toplevel);
5325
5326   return enumtype;
5327 }
5328
5329 /* Build and install a CONST_DECL for one value of the
5330    current enumeration type (one that was begun with start_enum).
5331    Return a tree-list containing the CONST_DECL and its value.
5332    Assignment of sequential values by default is handled here.  */
5333
5334 tree
5335 build_enumerator (tree name, tree value)
5336 {
5337   tree decl, type;
5338
5339   /* Validate and default VALUE.  */
5340
5341   /* Remove no-op casts from the value.  */
5342   if (value)
5343     STRIP_TYPE_NOPS (value);
5344
5345   if (value != 0)
5346     {
5347       if (TREE_CODE (value) == INTEGER_CST)
5348         {
5349           value = default_conversion (value);
5350           constant_expression_warning (value);
5351         }
5352       else
5353         {
5354           error ("enumerator value for `%s' not integer constant",
5355                  IDENTIFIER_POINTER (name));
5356           value = 0;
5357         }
5358     }
5359
5360   /* Default based on previous value.  */
5361   /* It should no longer be possible to have NON_LVALUE_EXPR
5362      in the default.  */
5363   if (value == 0)
5364     {
5365       value = enum_next_value;
5366       if (enum_overflow)
5367         error ("overflow in enumeration values");
5368     }
5369
5370   if (pedantic && ! int_fits_type_p (value, integer_type_node))
5371     {
5372       pedwarn ("ISO C restricts enumerator values to range of `int'");
5373       value = convert (integer_type_node, value);
5374     }
5375
5376   /* Set basis for default for next value.  */
5377   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5378   enum_overflow = tree_int_cst_lt (enum_next_value, value);
5379
5380   /* Now create a declaration for the enum value name.  */
5381
5382   type = TREE_TYPE (value);
5383   type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5384                                       TYPE_PRECISION (integer_type_node)),
5385                                  (TYPE_PRECISION (type)
5386                                   >= TYPE_PRECISION (integer_type_node)
5387                                   && TREE_UNSIGNED (type)));
5388
5389   decl = build_decl (CONST_DECL, name, type);
5390   DECL_INITIAL (decl) = convert (type, value);
5391   pushdecl (decl);
5392
5393   return tree_cons (decl, value, NULL_TREE);
5394 }
5395
5396 \f
5397 /* Create the FUNCTION_DECL for a function definition.
5398    DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5399    the declaration; they describe the function's name and the type it returns,
5400    but twisted together in a fashion that parallels the syntax of C.
5401
5402    This function creates a binding context for the function body
5403    as well as setting up the FUNCTION_DECL in current_function_decl.
5404
5405    Returns 1 on success.  If the DECLARATOR is not suitable for a function
5406    (it defines a datum instead), we return 0, which tells
5407    yyparse to report a parse error.  */
5408
5409 int
5410 start_function (tree declspecs, tree declarator, tree attributes)
5411 {
5412   tree decl1, old_decl;
5413   tree restype;
5414   int old_immediate_size_expand = immediate_size_expand;
5415
5416   current_function_returns_value = 0;  /* Assume, until we see it does.  */
5417   current_function_returns_null = 0;
5418   current_function_returns_abnormally = 0;
5419   warn_about_return_type = 0;
5420   current_extern_inline = 0;
5421   c_in_iteration_stmt = 0;
5422   c_in_case_stmt = 0;
5423
5424   /* Don't expand any sizes in the return type of the function.  */
5425   immediate_size_expand = 0;
5426
5427   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
5428
5429   /* If the declarator is not suitable for a function definition,
5430      cause a syntax error.  */
5431   if (decl1 == 0)
5432     {
5433       immediate_size_expand = old_immediate_size_expand;
5434       return 0;
5435     }
5436
5437   decl_attributes (&decl1, attributes, 0);
5438
5439   if (DECL_DECLARED_INLINE_P (decl1)
5440       && DECL_UNINLINABLE (decl1)
5441       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
5442     warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
5443
5444   announce_function (decl1);
5445
5446   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
5447     {
5448       error ("return type is an incomplete type");
5449       /* Make it return void instead.  */
5450       TREE_TYPE (decl1)
5451         = build_function_type (void_type_node,
5452                                TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5453     }
5454
5455   if (warn_about_return_type)
5456     pedwarn_c99 ("return type defaults to `int'");
5457
5458   /* Make the init_value nonzero so pushdecl knows this is not tentative.
5459      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
5460   DECL_INITIAL (decl1) = error_mark_node;
5461
5462   /* If this definition isn't a prototype and we had a prototype declaration
5463      before, copy the arg type info from that prototype.
5464      But not if what we had before was a builtin function.  */
5465   old_decl = lookup_name_current_level (DECL_NAME (decl1));
5466   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5467       && !DECL_BUILT_IN (old_decl)
5468       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5469           == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5470       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5471     {
5472       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5473       current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
5474     }
5475
5476   /* Optionally warn of old-fashioned def with no previous prototype.  */
5477   if (warn_strict_prototypes
5478       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5479       && C_DECL_ISNT_PROTOTYPE (old_decl))
5480     warning ("function declaration isn't a prototype");
5481   /* Optionally warn of any global def with no previous prototype.  */
5482   else if (warn_missing_prototypes
5483            && TREE_PUBLIC (decl1)
5484            && ! MAIN_NAME_P (DECL_NAME (decl1))
5485            && C_DECL_ISNT_PROTOTYPE (old_decl))
5486     warning ("%Jno previous prototype for '%D'", decl1, decl1);
5487   /* Optionally warn of any def with no previous prototype
5488      if the function has already been used.  */
5489   else if (warn_missing_prototypes
5490            && old_decl != 0 && TREE_USED (old_decl)
5491            && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
5492     warning ("%J'%D' was used with no prototype before its definition",
5493              decl1, decl1);
5494   /* Optionally warn of any global def with no previous declaration.  */
5495   else if (warn_missing_declarations
5496            && TREE_PUBLIC (decl1)
5497            && old_decl == 0
5498            && ! MAIN_NAME_P (DECL_NAME (decl1)))
5499     warning ("%Jno previous declaration for '%D'", decl1, decl1);
5500   /* Optionally warn of any def with no previous declaration
5501      if the function has already been used.  */
5502   else if (warn_missing_declarations
5503            && old_decl != 0 && TREE_USED (old_decl)
5504            && C_DECL_IMPLICIT (old_decl))
5505     warning ("%J`%D' was used with no declaration before its definition",
5506              decl1, decl1);
5507
5508   /* This is a definition, not a reference.
5509      So normally clear DECL_EXTERNAL.
5510      However, `extern inline' acts like a declaration
5511      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
5512   DECL_EXTERNAL (decl1) = current_extern_inline;
5513
5514   /* This function exists in static storage.
5515      (This does not mean `static' in the C sense!)  */
5516   TREE_STATIC (decl1) = 1;
5517
5518   /* A nested function is not global.  */
5519   if (current_function_decl != 0)
5520     TREE_PUBLIC (decl1) = 0;
5521
5522 #ifdef ENABLE_CHECKING
5523   /* This is the earliest point at which we might know the assembler
5524      name of the function.  Thus, if it's set before this, die horribly.  */
5525   if (DECL_ASSEMBLER_NAME_SET_P (decl1))
5526     abort ();
5527 #endif
5528
5529   /* If #pragma weak was used, mark the decl weak now.  */
5530   if (current_scope == global_scope)
5531     maybe_apply_pragma_weak (decl1);
5532
5533   /* Warn for unlikely, improbable, or stupid declarations of `main'.  */
5534   if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
5535     {
5536       tree args;
5537       int argct = 0;
5538
5539       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5540           != integer_type_node)
5541         pedwarn ("%Jreturn type of '%D' is not `int'", decl1, decl1);
5542
5543       for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
5544            args = TREE_CHAIN (args))
5545         {
5546           tree type = args ? TREE_VALUE (args) : 0;
5547
5548           if (type == void_type_node)
5549             break;
5550
5551           ++argct;
5552           switch (argct)
5553             {
5554             case 1:
5555               if (TYPE_MAIN_VARIANT (type) != integer_type_node)
5556                 pedwarn ("%Jfirst argument of '%D' should be `int'",
5557                          decl1, decl1);
5558               break;
5559
5560             case 2:
5561               if (TREE_CODE (type) != POINTER_TYPE
5562                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5563                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5564                       != char_type_node))
5565                 pedwarn ("%Jsecond argument of '%D' should be 'char **'",
5566                          decl1, decl1);
5567               break;
5568
5569             case 3:
5570               if (TREE_CODE (type) != POINTER_TYPE
5571                   || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5572                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5573                       != char_type_node))
5574                 pedwarn ("%Jthird argument of '%D' should probably be "
5575                          "'char **'", decl1, decl1);
5576               break;
5577             }
5578         }
5579
5580       /* It is intentional that this message does not mention the third
5581          argument because it's only mentioned in an appendix of the
5582          standard.  */
5583       if (argct > 0 && (argct < 2 || argct > 3))
5584         pedwarn ("%J'%D' takes only zero or two arguments", decl1, decl1);
5585
5586       if (! TREE_PUBLIC (decl1))
5587         pedwarn ("%J'%D' is normally a non-static function", decl1, decl1);
5588     }
5589
5590   /* Record the decl so that the function name is defined.
5591      If we already have a decl for this name, and it is a FUNCTION_DECL,
5592      use the old decl.  */
5593
5594   current_function_decl = pushdecl (decl1);
5595
5596   pushlevel (0);
5597   declare_parm_level ();
5598
5599   make_decl_rtl (current_function_decl, NULL);
5600
5601   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
5602   /* Promote the value to int before returning it.  */
5603   if (c_promoting_integer_type_p (restype))
5604     {
5605       /* It retains unsignedness if not really getting wider.  */
5606       if (TREE_UNSIGNED (restype)
5607           && (TYPE_PRECISION (restype)
5608                   == TYPE_PRECISION (integer_type_node)))
5609         restype = unsigned_type_node;
5610       else
5611         restype = integer_type_node;
5612     }
5613   DECL_RESULT (current_function_decl)
5614     = build_decl (RESULT_DECL, NULL_TREE, restype);
5615
5616   /* If this fcn was already referenced via a block-scope `extern' decl
5617      (or an implicit decl), propagate certain information about the usage.  */
5618   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
5619     TREE_ADDRESSABLE (current_function_decl) = 1;
5620
5621   immediate_size_expand = old_immediate_size_expand;
5622
5623   start_fname_decls ();
5624
5625   return 1;
5626 }
5627 \f
5628 /* Subroutine of store_parm_decls which handles new-style function
5629    definitions (prototype format). The parms already have decls, so we
5630    need only record them as in effect and complain if any redundant
5631    old-style parm decls were written.  */
5632 static void
5633 store_parm_decls_newstyle (tree fndecl, tree arg_info)
5634 {
5635   tree decl, last;
5636
5637   tree parms = ARG_INFO_PARMS (arg_info);
5638   tree tags = ARG_INFO_TAGS (arg_info);
5639   tree others = ARG_INFO_OTHERS (arg_info);
5640
5641   if (current_scope->parms || current_scope->names || current_scope->tags)
5642     {
5643       error ("%Jold-style parameter declarations in prototyped "
5644              "function definition", fndecl);
5645
5646       /* Get rid of the old-style declarations.  */
5647       poplevel (0, 0, 0);
5648       pushlevel (0);
5649     }
5650
5651   /* Now make all the parameter declarations visible in the function body.
5652      We can bypass most of the grunt work of pushdecl.  */
5653   for (last = 0, decl = parms; decl; last = decl, decl = TREE_CHAIN (decl))
5654     {
5655       DECL_CONTEXT (decl) = current_function_decl;
5656       if (DECL_NAME (decl) == 0)
5657         error ("%Jparameter name omitted", decl);
5658       else
5659         {
5660           if (IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)))
5661             current_scope->shadowed
5662               = tree_cons (DECL_NAME (decl),
5663                            IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)),
5664                            current_scope->shadowed);
5665           IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)) = decl;
5666         }
5667     }
5668   current_scope->parms = parms;
5669   current_scope->parms_last = last;
5670
5671   /* Record the parameter list in the function declaration.  */
5672   DECL_ARGUMENTS (fndecl) = parms;
5673
5674   /* Now make all the ancillary declarations visible, likewise.  */
5675   for (last = 0, decl = others; decl; last = decl, decl = TREE_CHAIN (decl))
5676     {
5677       DECL_CONTEXT (decl) = current_function_decl;
5678       if (DECL_NAME (decl)
5679           && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) != void_type_node)
5680         {
5681           if (IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)))
5682             current_scope->shadowed
5683               = tree_cons (DECL_NAME (decl),
5684                            IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)),
5685                            current_scope->shadowed);
5686           IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl)) = decl;
5687         }
5688     }
5689   current_scope->names = others;
5690   current_scope->names_last = last;
5691
5692   /* And all the tag declarations.  */
5693   for (decl = tags; decl; decl = TREE_CHAIN (decl))
5694     if (TREE_PURPOSE (decl))
5695       {
5696         if (IDENTIFIER_TAG_VALUE (TREE_PURPOSE (decl)))
5697           current_scope->shadowed_tags
5698             = tree_cons (TREE_PURPOSE (decl),
5699                          IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (decl)),
5700                          current_scope->shadowed_tags);
5701         IDENTIFIER_TAG_VALUE (TREE_PURPOSE (decl)) = TREE_VALUE (decl);
5702       }
5703   current_scope->tags = tags;
5704 }
5705
5706 /* Subroutine of store_parm_decls which handles old-style function
5707    definitions (separate parameter list and declarations).  */
5708
5709 static void
5710 store_parm_decls_oldstyle (tree fndecl, tree arg_info)
5711 {
5712   tree parm, decl, last;
5713
5714   /* This is the identifier list from the function declarator.  */
5715   tree parmids = ARG_INFO_PARMS (arg_info);
5716
5717   /* We use DECL_WEAK as a flag to show which parameters have been
5718      seen already, since it is not used on PARM_DECL.  */
5719 #ifdef ENABLE_CHECKING
5720   for (parm = current_scope->parms; parm; parm = TREE_CHAIN (parm))
5721     if (DECL_WEAK (parm))
5722       abort ();
5723 #endif
5724
5725   /* Match each formal parameter name with its declaration.  Save each
5726      decl in the appropriate TREE_PURPOSE slot of the parmids chain.  */
5727   for (parm = parmids; parm; parm = TREE_CHAIN (parm))
5728     {
5729       if (TREE_VALUE (parm) == 0)
5730         {
5731           error ("%Jparameter name missing from parameter list", fndecl);
5732           TREE_PURPOSE (parm) = 0;
5733           continue;
5734         }
5735
5736       decl = IDENTIFIER_SYMBOL_VALUE (TREE_VALUE (parm));
5737       if (decl && DECL_CONTEXT (decl) == fndecl)
5738         {
5739           /* If we got something other than a PARM_DECL it is an error.  */
5740           if (TREE_CODE (decl) != PARM_DECL)
5741             error ("%J\"%D\" declared as a non-parameter", decl, decl);
5742           /* If the declaration is already marked, we have a duplicate
5743              name.  Complain and ignore the duplicate.  */
5744           else if (DECL_WEAK (decl))
5745             {
5746               error ("%Jmultiple parameters named \"%D\"", decl, decl);
5747               TREE_PURPOSE (parm) = 0;
5748               continue;
5749             }
5750           /* If the declaration says "void", complain and turn it into
5751              an int.  */
5752           else if (VOID_TYPE_P (TREE_TYPE (decl)))
5753             {
5754               error ("%Jparameter \"%D\" declared void", decl, decl);
5755               TREE_TYPE (decl) = integer_type_node;
5756               DECL_ARG_TYPE (decl) = integer_type_node;
5757               layout_decl (decl, 0);
5758             }
5759         }
5760       /* If no declaration found, default to int.  */
5761       else
5762         {
5763           decl = build_decl (PARM_DECL, TREE_VALUE (parm), integer_type_node);
5764           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
5765           DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (fndecl);
5766           pushdecl (decl);
5767
5768           if (flag_isoc99)
5769             pedwarn ("%Jtype of \"%D\" defaults to \"int\"", decl, decl);
5770           else if (extra_warnings)
5771             warning ("%Jtype of \"%D\" defaults to \"int\"", decl, decl);
5772         }
5773
5774       TREE_PURPOSE (parm) = decl;
5775       DECL_WEAK (decl) = 1;
5776     }
5777
5778   /* Now examine the parms chain for incomplete declarations
5779      and declarations with no corresponding names.  */
5780
5781   for (parm = current_scope->parms; parm; parm = TREE_CHAIN (parm))
5782     {
5783       if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
5784         {
5785           error ("%Jparameter \"%D\" has incomplete type", parm, parm);
5786           TREE_TYPE (parm) = error_mark_node;
5787         }
5788
5789       if (! DECL_WEAK (parm))
5790         {
5791           error ("%Jdeclaration for parameter \"%D\" but no such parameter",
5792                  parm, parm);
5793
5794           /* Pretend the parameter was not missing.
5795              This gets us to a standard state and minimizes
5796              further error messages.  */
5797           parmids = chainon (parmids, tree_cons (parm, 0, 0));
5798         }
5799     }
5800
5801   /* Chain the declarations together in the order of the list of
5802      names.  Store that chain in the function decl, replacing the
5803      list of names.  Update the current scope to match.  */
5804   DECL_ARGUMENTS (fndecl) = 0;
5805
5806   for (parm = parmids; parm; parm = TREE_CHAIN (parm))
5807     if (TREE_PURPOSE (parm))
5808       break;
5809   if (parm && TREE_PURPOSE (parm))
5810     {
5811       last = TREE_PURPOSE (parm);
5812       DECL_ARGUMENTS (fndecl) = last;
5813       current_scope->parms = last;
5814       DECL_WEAK (last) = 0;
5815
5816       for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
5817         if (TREE_PURPOSE (parm))
5818           {
5819             TREE_CHAIN (last) = TREE_PURPOSE (parm);
5820             last = TREE_PURPOSE (parm);
5821             DECL_WEAK (last) = 0;
5822           }
5823       current_scope->parms_last = last;
5824       TREE_CHAIN (last) = 0;
5825     }
5826
5827   /* If there was a previous prototype,
5828      set the DECL_ARG_TYPE of each argument according to
5829      the type previously specified, and report any mismatches.  */
5830
5831   if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
5832     {
5833       tree type;
5834       for (parm = DECL_ARGUMENTS (fndecl),
5835              type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
5836            parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
5837                              != void_type_node));
5838            parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
5839         {
5840           if (parm == 0 || type == 0
5841               || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
5842             {
5843               error ("number of arguments doesn't match prototype");
5844               error ("%Hprototype declaration",
5845                      &current_function_prototype_locus);
5846               break;
5847             }
5848           /* Type for passing arg must be consistent with that
5849              declared for the arg.  ISO C says we take the unqualified
5850              type for parameters declared with qualified type.  */
5851           if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
5852                            TYPE_MAIN_VARIANT (TREE_VALUE (type)),
5853                            COMPARE_STRICT))
5854             {
5855               if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
5856                   == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
5857                 {
5858                   /* Adjust argument to match prototype.  E.g. a previous
5859                      `int foo(float);' prototype causes
5860                      `int foo(x) float x; {...}' to be treated like
5861                      `int foo(float x) {...}'.  This is particularly
5862                      useful for argument types like uid_t.  */
5863                   DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
5864
5865                   if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
5866                       && INTEGRAL_TYPE_P (TREE_TYPE (parm))
5867                       && TYPE_PRECISION (TREE_TYPE (parm))
5868                       < TYPE_PRECISION (integer_type_node))
5869                     DECL_ARG_TYPE (parm) = integer_type_node;
5870
5871                   if (pedantic)
5872                     {
5873                       pedwarn ("promoted argument \"%D\" "
5874                                "doesn't match prototype", parm);
5875                       pedwarn ("%Hprototype declaration",
5876                                &current_function_prototype_locus);
5877                     }
5878                 }
5879               else
5880                 {
5881                   error ("argument \"%D\" doesn't match prototype", parm);
5882                   error ("%Hprototype declaration",
5883                          &current_function_prototype_locus);
5884                 }
5885             }
5886         }
5887       TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
5888     }
5889
5890   /* Otherwise, create a prototype that would match.  */
5891
5892   else
5893     {
5894       tree actual = 0, last = 0, type;
5895
5896       for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
5897         {
5898           type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
5899           if (last)
5900             TREE_CHAIN (last) = type;
5901           else
5902             actual = type;
5903           last = type;
5904         }
5905       type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
5906       if (last)
5907         TREE_CHAIN (last) = type;
5908       else
5909         actual = type;
5910
5911       /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
5912          of the type of this function, but we need to avoid having this
5913          affect the types of other similarly-typed functions, so we must
5914          first force the generation of an identical (but separate) type
5915          node for the relevant function type.  The new node we create
5916          will be a variant of the main variant of the original function
5917          type.  */
5918
5919       TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
5920
5921       TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
5922     }
5923 }
5924
5925 /* Store the parameter declarations into the current function declaration.
5926    This is called after parsing the parameter declarations, before
5927    digesting the body of the function.
5928
5929    For an old-style definition, construct a prototype out of the old-style
5930    parameter declarations and inject it into the function's type.  */
5931
5932 void
5933 store_parm_decls (void)
5934 {
5935   tree fndecl = current_function_decl;
5936
5937   /* The function containing FNDECL, if any.  */
5938   tree context = decl_function_context (fndecl);
5939
5940   /* The argument information block for FNDECL.  */
5941   tree arg_info = DECL_ARGUMENTS (fndecl);
5942
5943   /* True if this definition is written with a prototype.  Since this
5944      is a function definition, we can treat a null parameter list
5945      (i.e. "foo()") as prototyped (C99 6.7.5.3p14) - this reduces
5946      overhead.  */
5947   bool prototype = (!ARG_INFO_PARMS (arg_info)
5948                     || TREE_CODE (ARG_INFO_PARMS (arg_info)) != TREE_LIST);
5949
5950   if (prototype)
5951     store_parm_decls_newstyle (fndecl, arg_info);
5952   else
5953     store_parm_decls_oldstyle (fndecl, arg_info);
5954
5955   /* The next call to pushlevel will be a function body.  */
5956
5957   next_is_function_body = true;
5958
5959   /* Write a record describing this function definition to the prototypes
5960      file (if requested).  */
5961
5962   gen_aux_info_record (fndecl, 1, 0, prototype);
5963
5964   /* Initialize the RTL code for the function.  */
5965   allocate_struct_function (fndecl);
5966
5967   /* Begin the statement tree for this function.  */
5968   begin_stmt_tree (&DECL_SAVED_TREE (fndecl));
5969
5970   /* If this is a nested function, save away the sizes of any
5971      variable-size types so that we can expand them when generating
5972      RTL.  */
5973   if (context)
5974     {
5975       tree t;
5976
5977       DECL_LANG_SPECIFIC (fndecl)->pending_sizes
5978         = nreverse (get_pending_sizes ());
5979       for (t = DECL_LANG_SPECIFIC (fndecl)->pending_sizes;
5980            t;
5981            t = TREE_CHAIN (t))
5982         SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = context;
5983     }
5984
5985   /* This function is being processed in whole-function mode.  */
5986   cfun->x_whole_function_mode_p = 1;
5987
5988   /* Even though we're inside a function body, we still don't want to
5989      call expand_expr to calculate the size of a variable-sized array.
5990      We haven't necessarily assigned RTL to all variables yet, so it's
5991      not safe to try to expand expressions involving them.  */
5992   immediate_size_expand = 0;
5993   cfun->x_dont_save_pending_sizes_p = 1;
5994 }
5995 \f
5996 /* Finish up a function declaration and compile that function
5997    all the way to assembler language output.  The free the storage
5998    for the function definition.
5999
6000    This is called after parsing the body of the function definition.  */
6001
6002 void
6003 finish_function (void)
6004 {
6005   tree fndecl = current_function_decl;
6006
6007   /* When a function declaration is totally empty, e.g.
6008         void foo(void) { }
6009      (the argument list is irrelevant) the compstmt rule will not
6010      bother calling pushlevel/poplevel, which means we get here with
6011      the scope stack out of sync.  Detect this situation by noticing
6012      that current_scope is still as store_parm_decls left it, and do
6013      a dummy push/pop to get back to consistency.
6014      Note that the call to pushlevel does not actually push another
6015      scope - see there for details.  */
6016
6017   if (current_scope->parm_flag && next_is_function_body)
6018     {
6019       pushlevel (0);
6020       poplevel (0, 0, 0);
6021     }
6022
6023   if (TREE_CODE (fndecl) == FUNCTION_DECL
6024       && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
6025     {
6026       tree args = DECL_ARGUMENTS (fndecl);
6027       for (; args; args = TREE_CHAIN (args))
6028         {
6029           tree type = TREE_TYPE (args);
6030           if (INTEGRAL_TYPE_P (type)
6031               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
6032             DECL_ARG_TYPE (args) = integer_type_node;
6033         }
6034     }
6035
6036   if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
6037     BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6038
6039   /* Must mark the RESULT_DECL as being in this function.  */
6040
6041   if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
6042     DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6043
6044   if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6045     {
6046       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6047           != integer_type_node)
6048         {
6049           /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6050              If warn_main is -1 (-Wno-main) we don't want to be warned.  */
6051           if (!warn_main)
6052             pedwarn ("%Jreturn type of '%D' is not `int'", fndecl, fndecl);
6053         }
6054       else
6055         {
6056 #ifdef DEFAULT_MAIN_RETURN
6057           /* Make it so that `main' always returns success by default.  */
6058           DEFAULT_MAIN_RETURN;
6059 #else
6060           if (flag_isoc99)
6061             c_expand_return (integer_zero_node);
6062 #endif
6063         }
6064     }
6065
6066   finish_fname_decls ();
6067
6068   /* Tie off the statement tree for this function.  */
6069   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6070
6071   /* Complain if there's just no return statement.  */
6072   if (warn_return_type
6073       && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6074       && !current_function_returns_value && !current_function_returns_null
6075       /* Don't complain if we abort.  */
6076       && !current_function_returns_abnormally
6077       /* Don't warn for main().  */
6078       && !MAIN_NAME_P (DECL_NAME (fndecl))
6079       /* Or if they didn't actually specify a return type.  */
6080       && !C_FUNCTION_IMPLICIT_INT (fndecl)
6081       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
6082          inline function, as we might never be compiled separately.  */
6083       && DECL_INLINE (fndecl))
6084     warning ("no return statement in function returning non-void");
6085
6086   /* With just -Wextra, complain only if function returns both with
6087      and without a value.  */
6088   if (extra_warnings
6089       && current_function_returns_value
6090       && current_function_returns_null)
6091     warning ("this function may return with or without a value");
6092
6093   /* We're leaving the context of this function, so zap cfun.
6094      It's still in DECL_STRUCT_FUNCTION , and we'll restore it in
6095      tree_rest_of_compilation.  */
6096   cfun = NULL;
6097
6098   /* ??? Objc emits functions after finalizing the compilation unit.
6099      This should be cleaned up later and this conditional removed.  */
6100   if (!cgraph_global_info_ready)
6101     cgraph_finalize_function (fndecl, false);
6102   else
6103     c_expand_body (fndecl);
6104   current_function_decl = NULL;
6105 }
6106
6107 /* Generate the RTL for the body of FNDECL.  If NESTED_P is nonzero,
6108    then we are already in the process of generating RTL for another
6109    function.  */
6110
6111 static void
6112 c_expand_body_1 (tree fndecl, int nested_p)
6113 {
6114   if (nested_p)
6115     {
6116       /* Make sure that we will evaluate variable-sized types involved
6117          in our function's type.  */
6118       expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl)->pending_sizes);
6119
6120       /* Squirrel away our current state.  */
6121       push_function_context ();
6122     }
6123
6124   tree_rest_of_compilation (fndecl, nested_p);
6125
6126   if (nested_p)
6127     /* Return to the enclosing function.  */
6128     pop_function_context ();
6129
6130   if (DECL_STATIC_CONSTRUCTOR (fndecl))
6131     {
6132       if (targetm.have_ctors_dtors)
6133         (* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
6134                                          DEFAULT_INIT_PRIORITY);
6135       else
6136         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6137     }
6138
6139   if (DECL_STATIC_DESTRUCTOR (fndecl))
6140     {
6141       if (targetm.have_ctors_dtors)
6142         (* targetm.asm_out.destructor) (XEXP (DECL_RTL (fndecl), 0),
6143                                         DEFAULT_INIT_PRIORITY);
6144       else
6145         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6146     }
6147 }
6148
6149 /* Like c_expand_body_1 but only for unnested functions.  */
6150
6151 void
6152 c_expand_body (tree fndecl)
6153 {
6154
6155   if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
6156     c_expand_body_1 (fndecl, 0);
6157 }
6158 \f
6159 /* Check the declarations given in a for-loop for satisfying the C99
6160    constraints.  */
6161 void
6162 check_for_loop_decls (void)
6163 {
6164   tree t;
6165
6166   if (!flag_isoc99)
6167     {
6168       /* If we get here, declarations have been used in a for loop without
6169          the C99 for loop scope.  This doesn't make much sense, so don't
6170          allow it.  */
6171       error ("'for' loop initial declaration used outside C99 mode");
6172       return;
6173     }
6174   /* C99 subclause 6.8.5 paragraph 3:
6175
6176        [#3]  The  declaration  part  of  a for statement shall only
6177        declare identifiers for objects having storage class auto or
6178        register.
6179
6180      It isn't clear whether, in this sentence, "identifiers" binds to
6181      "shall only declare" or to "objects" - that is, whether all identifiers
6182      declared must be identifiers for objects, or whether the restriction
6183      only applies to those that are.  (A question on this in comp.std.c
6184      in November 2000 received no answer.)  We implement the strictest
6185      interpretation, to avoid creating an extension which later causes
6186      problems.  */
6187
6188   for (t = current_scope->tags; t; t = TREE_CHAIN (t))
6189     {
6190       if (TREE_PURPOSE (t) != 0)
6191         {
6192           enum tree_code code = TREE_CODE (TREE_VALUE (t));
6193
6194           if (code == RECORD_TYPE)
6195             error ("'struct %s' declared in 'for' loop initial declaration",
6196                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6197           else if (code == UNION_TYPE)
6198             error ("'union %s' declared in 'for' loop initial declaration",
6199                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6200           else
6201             error ("'enum %s' declared in 'for' loop initial declaration",
6202                    IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6203         }
6204     }
6205
6206   for (t = current_scope->names; t; t = TREE_CHAIN (t))
6207     {
6208       if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
6209         error ("%Jdeclaration of non-variable '%D' in 'for' loop "
6210                "initial declaration", t, t);
6211       else if (TREE_STATIC (t))
6212         error ("%Jdeclaration of static variable '%D' in 'for' loop "
6213                "initial declaration", t, t);
6214       else if (DECL_EXTERNAL (t))
6215         error ("%Jdeclaration of 'extern' variable '%D' in 'for' loop "
6216                "initial declaration", t, t);
6217     }
6218 }
6219 \f
6220 /* Save and reinitialize the variables
6221    used during compilation of a C function.  */
6222
6223 void
6224 c_push_function_context (struct function *f)
6225 {
6226   struct language_function *p;
6227   p = ggc_alloc (sizeof (struct language_function));
6228   f->language = p;
6229
6230   p->base.x_stmt_tree = c_stmt_tree;
6231   p->base.x_scope_stmt_stack = c_scope_stmt_stack;
6232   p->x_in_iteration_stmt = c_in_iteration_stmt;
6233   p->x_in_case_stmt = c_in_case_stmt;
6234   p->returns_value = current_function_returns_value;
6235   p->returns_null = current_function_returns_null;
6236   p->returns_abnormally = current_function_returns_abnormally;
6237   p->warn_about_return_type = warn_about_return_type;
6238   p->extern_inline = current_extern_inline;
6239 }
6240
6241 /* Restore the variables used during compilation of a C function.  */
6242
6243 void
6244 c_pop_function_context (struct function *f)
6245 {
6246   struct language_function *p = f->language;
6247
6248   if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
6249       && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6250     {
6251       /* Stop pointing to the local nodes about to be freed.  */
6252       /* But DECL_INITIAL must remain nonzero so we know this
6253          was an actual function definition.  */
6254       DECL_INITIAL (current_function_decl) = error_mark_node;
6255       DECL_ARGUMENTS (current_function_decl) = 0;
6256     }
6257
6258   c_stmt_tree = p->base.x_stmt_tree;
6259   c_scope_stmt_stack = p->base.x_scope_stmt_stack;
6260   c_in_iteration_stmt = p->x_in_iteration_stmt;
6261   c_in_case_stmt = p->x_in_case_stmt;
6262   current_function_returns_value = p->returns_value;
6263   current_function_returns_null = p->returns_null;
6264   current_function_returns_abnormally = p->returns_abnormally;
6265   warn_about_return_type = p->warn_about_return_type;
6266   current_extern_inline = p->extern_inline;
6267
6268   f->language = NULL;
6269 }
6270
6271 /* Copy the DECL_LANG_SPECIFIC data associated with DECL.  */
6272
6273 void
6274 c_dup_lang_specific_decl (tree decl)
6275 {
6276   struct lang_decl *ld;
6277
6278   if (!DECL_LANG_SPECIFIC (decl))
6279     return;
6280
6281   ld = ggc_alloc (sizeof (struct lang_decl));
6282   memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
6283   DECL_LANG_SPECIFIC (decl) = ld;
6284 }
6285
6286 /* The functions below are required for functionality of doing
6287    function at once processing in the C front end. Currently these
6288    functions are not called from anywhere in the C front end, but as
6289    these changes continue, that will change.  */
6290
6291 /* Returns nonzero if the current statement is a full expression,
6292    i.e. temporaries created during that statement should be destroyed
6293    at the end of the statement.  */
6294
6295 int
6296 stmts_are_full_exprs_p (void)
6297 {
6298   return 0;
6299 }
6300
6301 /* Returns the stmt_tree (if any) to which statements are currently
6302    being added.  If there is no active statement-tree, NULL is
6303    returned.  */
6304
6305 stmt_tree
6306 current_stmt_tree (void)
6307 {
6308   return &c_stmt_tree;
6309 }
6310
6311 /* Returns the stack of SCOPE_STMTs for the current function.  */
6312
6313 tree *
6314 current_scope_stmt_stack (void)
6315 {
6316   return &c_scope_stmt_stack;
6317 }
6318
6319 /* Nonzero if TYPE is an anonymous union or struct type.  Always 0 in
6320    C.  */
6321
6322 int
6323 anon_aggr_type_p (tree node ATTRIBUTE_UNUSED)
6324 {
6325   return 0;
6326 }
6327
6328 /* Dummy function in place of callback used by C++.  */
6329
6330 void
6331 extract_interface_info (void)
6332 {
6333 }
6334
6335 /* Return a new COMPOUND_STMT, after adding it to the current
6336    statement tree.  */
6337
6338 tree
6339 c_begin_compound_stmt (void)
6340 {
6341   tree stmt;
6342
6343   /* Create the COMPOUND_STMT.  */
6344   stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
6345
6346   return stmt;
6347 }
6348
6349 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
6350    common code.  */
6351
6352 void
6353 c_expand_decl_stmt (tree t)
6354 {
6355   tree decl = DECL_STMT_DECL (t);
6356
6357   /* Expand nested functions.  */
6358   if (TREE_CODE (decl) == FUNCTION_DECL
6359       && DECL_CONTEXT (decl) == current_function_decl
6360       && DECL_SAVED_TREE (decl))
6361     c_expand_body_1 (decl, 1);
6362 }
6363
6364 /* Return the global value of T as a symbol.  */
6365
6366 tree
6367 identifier_global_value (tree t)
6368 {
6369   tree decl = IDENTIFIER_SYMBOL_VALUE (t);
6370   if (decl == 0 || DECL_FILE_SCOPE_P (decl))
6371     return decl;
6372
6373   /* Shadowed by something else; find the true global value.  */
6374   for (decl = global_scope->names; decl; decl = TREE_CHAIN (decl))
6375     if (DECL_NAME (decl) == t)
6376       return decl;
6377
6378   /* Only local values for this decl.  */
6379   return 0;
6380 }
6381
6382 /* Record a builtin type for C.  If NAME is non-NULL, it is the name used;
6383    otherwise the name is found in ridpointers from RID_INDEX.  */
6384
6385 void
6386 record_builtin_type (enum rid rid_index, const char *name, tree type)
6387 {
6388   tree id;
6389   tree tdecl;
6390   if (name == 0)
6391     id = ridpointers[(int) rid_index];
6392   else
6393     id = get_identifier (name);
6394   tdecl = build_decl (TYPE_DECL, id, type);
6395   pushdecl (tdecl);
6396   debug_hooks->type_decl (tdecl, 0);
6397 }
6398
6399 /* Build the void_list_node (void_type_node having been created).  */
6400 tree
6401 build_void_list_node (void)
6402 {
6403   tree t = build_tree_list (NULL_TREE, void_type_node);
6404   return t;
6405 }
6406
6407 /* Return something to represent absolute declarators containing a *.
6408    TARGET is the absolute declarator that the * contains.
6409    TYPE_QUALS_ATTRS is a list of modifiers such as const or volatile
6410    to apply to the pointer type, represented as identifiers, possible mixed
6411    with attributes.
6412
6413    We return an INDIRECT_REF whose "contents" are TARGET (inside a TREE_LIST,
6414    if attributes are present) and whose type is the modifier list.  */
6415
6416 tree
6417 make_pointer_declarator (tree type_quals_attrs, tree target)
6418 {
6419   tree quals, attrs;
6420   tree itarget = target;
6421   split_specs_attrs (type_quals_attrs, &quals, &attrs);
6422   if (attrs != NULL_TREE)
6423     itarget = tree_cons (attrs, target, NULL_TREE);
6424   return build1 (INDIRECT_REF, quals, itarget);
6425 }
6426
6427 /* A wrapper around lhd_set_decl_assembler_name that gives static
6428    variables their C names if they are at file scope and only one
6429    translation unit is being compiled, for backwards compatibility
6430    with certain bizarre assembler hacks (like crtstuff.c).  */
6431
6432 void
6433 c_static_assembler_name (tree decl)
6434 {
6435   if (num_in_fnames == 1
6436       && !TREE_PUBLIC (decl) && DECL_CONTEXT (decl)
6437       && TREE_CODE (DECL_CONTEXT (decl)) == TRANSLATION_UNIT_DECL)
6438     SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
6439   else
6440     lhd_set_decl_assembler_name (decl);
6441 }
6442
6443 /* Hash and equality functions for link_hash_table: key off
6444    DECL_ASSEMBLER_NAME.  */
6445
6446 static hashval_t
6447 link_hash_hash (const void *x_p)
6448 {
6449   tree x = (tree)x_p;
6450   return (hashval_t) (long)DECL_ASSEMBLER_NAME (x);
6451 }
6452
6453 static int
6454 link_hash_eq (const void *x1_p, const void *x2_p)
6455 {
6456   tree x1 = (tree)x1_p;
6457   tree x2 = (tree)x2_p;
6458   return DECL_ASSEMBLER_NAME (x1) == DECL_ASSEMBLER_NAME (x2);
6459 }
6460
6461 /* Propagate information between definitions and uses between multiple
6462    translation units in TU_LIST based on linkage rules.  */
6463
6464 void
6465 merge_translation_unit_decls (void)
6466 {
6467   const tree tu_list = current_file_decl;
6468   tree tu;
6469   tree decl;
6470   htab_t link_hash_table;
6471   tree block;
6472
6473   /* Create the BLOCK that poplevel would have created, but don't
6474      actually call poplevel since that's expensive.  */
6475   block = make_node (BLOCK);
6476   BLOCK_VARS (block) = current_scope->names;
6477   TREE_USED (block) = 1;
6478   DECL_INITIAL (current_file_decl) = block;
6479
6480   /* If only one translation unit seen, no copying necessary.  */
6481   if (TREE_CHAIN (tu_list) == NULL_TREE)
6482     return;
6483
6484   link_hash_table = htab_create (1021, link_hash_hash, link_hash_eq, NULL);
6485
6486   /* Enter any actual definitions into the hash table.  */
6487   for (tu = tu_list; tu; tu = TREE_CHAIN (tu))
6488     for (decl = BLOCK_VARS (DECL_INITIAL (tu)); decl; decl = TREE_CHAIN (decl))
6489       if (TREE_PUBLIC (decl) && ! DECL_EXTERNAL (decl))
6490         {
6491           PTR *slot;
6492           slot = htab_find_slot (link_hash_table, decl, INSERT);
6493
6494           /* If we've already got a definition, work out which one is
6495              the real one, put it into the hash table, and make the
6496              other one DECL_EXTERNAL.  This is important to avoid
6497              putting out two definitions of the same symbol in the
6498              assembly output.  */
6499           if (*slot != NULL)
6500             {
6501               tree old_decl = (tree) *slot;
6502
6503               /* If this is weak or common or whatever, suppress it
6504                  in favor of the other definition.  */
6505               if (DECL_WEAK (decl))
6506                 DECL_EXTERNAL (decl) = 1;
6507               else if (DECL_WEAK (old_decl) && ! DECL_WEAK (decl))
6508                 DECL_EXTERNAL (old_decl) = 1;
6509               else if (DECL_COMMON (decl) || DECL_ONE_ONLY (decl))
6510                 DECL_EXTERNAL (decl) = 1;
6511               else if (DECL_COMMON (old_decl) || DECL_ONE_ONLY (old_decl))
6512                 DECL_EXTERNAL (old_decl) = 1;
6513
6514               if (DECL_EXTERNAL (decl))
6515                 {
6516                   DECL_INITIAL (decl) = NULL_TREE;
6517                   DECL_COMMON (decl) = 0;
6518                   DECL_ONE_ONLY (decl) = 0;
6519                   DECL_WEAK (decl) = 0;
6520                 }
6521               else if (DECL_EXTERNAL (old_decl))
6522                 {
6523                   DECL_INITIAL (old_decl) = NULL_TREE;
6524                   DECL_COMMON (old_decl) = 0;
6525                   DECL_ONE_ONLY (old_decl) = 0;
6526                   DECL_WEAK (old_decl) = 0;
6527                   *slot = decl;
6528                 }
6529               else
6530                 {
6531                   error ("%Jredefinition of global '%D'", decl, decl);
6532                   error ("%J'%D' previously defined here", old_decl, old_decl);
6533                 }
6534             }
6535           else
6536             *slot = decl;
6537         }
6538
6539   /* Now insert the desired information from all the definitions
6540      into any plain declarations.  */
6541   for (tu = tu_list; tu; tu = TREE_CHAIN (tu))
6542     for (decl = BLOCK_VARS (DECL_INITIAL (tu)); decl; decl = TREE_CHAIN (decl))
6543       if (TREE_PUBLIC (decl) && DECL_EXTERNAL (decl))
6544         {
6545           tree global_decl;
6546           global_decl = htab_find (link_hash_table, decl);
6547
6548           if (! global_decl)
6549             continue;
6550
6551           /* Print any appropriate error messages, and partially merge
6552              the decls.  */
6553           (void) duplicate_decls (decl, global_decl);
6554         }
6555
6556   htab_delete (link_hash_table);
6557 }
6558
6559 /* Perform final processing on file-scope data.  */
6560
6561 void
6562 c_write_global_declarations(void)
6563 {
6564   tree link;
6565
6566   for (link = current_file_decl; link; link = TREE_CHAIN (link))
6567     {
6568       tree globals = BLOCK_VARS (DECL_INITIAL (link));
6569       int len = list_length (globals);
6570       tree *vec = xmalloc (sizeof (tree) * len);
6571       int i;
6572       tree decl;
6573
6574       /* Process the decls in the order they were written.  */
6575
6576       for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
6577         vec[i] = decl;
6578
6579       wrapup_global_declarations (vec, len);
6580
6581       check_global_declarations (vec, len);
6582
6583       /* Clean up.  */
6584       free (vec);
6585     }
6586 }
6587
6588 /* Reset the parser's state in preparation for a new file.  */
6589
6590 void
6591 c_reset_state (void)
6592 {
6593   tree link;
6594   tree file_scope_decl;
6595
6596   /* Pop the global scope.  */
6597   if (current_scope != global_scope)
6598       current_scope = global_scope;
6599   file_scope_decl = current_file_decl;
6600   DECL_INITIAL (file_scope_decl) = poplevel (1, 0, 0);
6601   BLOCK_SUPERCONTEXT (DECL_INITIAL (file_scope_decl)) = file_scope_decl;
6602   truly_local_externals = NULL_TREE;
6603
6604   /* Start a new global binding level.  */
6605   pushlevel (0);
6606   global_scope = current_scope;
6607   current_file_decl = build_decl (TRANSLATION_UNIT_DECL, NULL, NULL);
6608   TREE_CHAIN (current_file_decl) = file_scope_decl;
6609
6610   /* Reintroduce the builtin declarations.  */
6611   for (link = first_builtin_decl;
6612        link != TREE_CHAIN (last_builtin_decl);
6613        link = TREE_CHAIN (link))
6614     pushdecl (copy_node (link));
6615 }
6616
6617 #include "gt-c-decl.h"