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