Subversion Repositories openrisc_me

/* Process declarations and variables for C compiler.

   Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010

   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

/* Process declarations and symbol lookup for C front end.

   Also constructs types; the standard scalar types at initialization,

   and structure, union, array and enum types when they are declared.  */

/* ??? not all decl nodes are given the most useful possible

   line numbers.  For example, the CONST_DECLs for enum values.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "input.h"

#include "tm.h"

#include "intl.h"

#include "tree.h"

#include "tree-inline.h"

#include "rtl.h"

#include "flags.h"

#include "function.h"

#include "output.h"

#include "expr.h"

#include "c-tree.h"

#include "toplev.h"

#include "ggc.h"

#include "tm_p.h"

#include "cpplib.h"

#include "target.h"

#include "debug.h"

#include "opts.h"

#include "timevar.h"

#include "c-common.h"

#include "c-pragma.h"

#include "c-lang.h"

#include "langhooks.h"

#include "tree-mudflap.h"

#include "gimple.h"

#include "tree-iterator.h"

#include "diagnostic.h"

#include "tree-dump.h"

#include "cgraph.h"

#include "hashtab.h"

#include "libfuncs.h"

#include "except.h"

#include "langhooks-def.h"

#include "pointer-set.h"

#include "gimple.h"

#include "plugin.h"

/* In grokdeclarator, distinguish syntactic contexts of declarators.  */

enum decl_context

{ NORMAL,                       /* Ordinary declaration */

  FUNCDEF,                      /* Function definition */

  PARM,                         /* Declaration of parm before function body */

  FIELD,                        /* Declaration inside struct or union */

  TYPENAME};                    /* Typename (inside cast or sizeof)  */

/* States indicating how grokdeclarator() should handle declspecs marked

   with __attribute__((deprecated)).  An object declared as

   __attribute__((deprecated)) suppresses warnings of uses of other

   deprecated items.  */

enum deprecated_states {

  DEPRECATED_NORMAL,

  DEPRECATED_SUPPRESS

};

/* Nonzero if we have seen an invalid cross reference

   to a struct, union, or enum, but not yet printed the message.  */

tree pending_invalid_xref;

/* File and line to appear in the eventual error message.  */

location_t pending_invalid_xref_location;

/* The file and line that the prototype came from if this is an

   old-style definition; used for diagnostics in

   store_parm_decls_oldstyle.  */

static location_t current_function_prototype_locus;

/* Whether this prototype was built-in.  */

static bool current_function_prototype_built_in;

/* The argument type information of this prototype.  */

static tree current_function_prototype_arg_types;

/* The argument information structure for the function currently being

   defined.  */

static struct c_arg_info *current_function_arg_info;

/* The obstack on which parser and related data structures, which are

   not live beyond their top-level declaration or definition, are

   allocated.  */

struct obstack parser_obstack;

/* The current statement tree.  */

static GTY(()) struct stmt_tree_s c_stmt_tree;

/* State saving variables.  */

tree c_break_label;

tree c_cont_label;

/* Linked list of TRANSLATION_UNIT_DECLS for the translation units

   included in this invocation.  Note that the current translation

   unit is not included in this list.  */

static GTY(()) tree all_translation_units;

/* A list of decls to be made automatically visible in each file scope.  */

static GTY(()) tree visible_builtins;

/* Set to 0 at beginning of a function definition, set to 1 if

   a return statement that specifies a return value is seen.  */

int current_function_returns_value;

/* Set to 0 at beginning of a function definition, set to 1 if

   a return statement with no argument is seen.  */

int current_function_returns_null;

/* Set to 0 at beginning of a function definition, set to 1 if

   a call to a noreturn function is seen.  */

int current_function_returns_abnormally;

/* Set to nonzero by `grokdeclarator' for a function

   whose return type is defaulted, if warnings for this are desired.  */

static int warn_about_return_type;

/* Nonzero when the current toplevel function contains a declaration

   of a nested function which is never defined.  */

static bool undef_nested_function;

/* True means global_bindings_p should return false even if the scope stack

   says we are in file scope.  */

bool c_override_global_bindings_to_false;

/* Each c_binding structure describes one binding of an identifier to

   a decl.  All the decls in a scope - irrespective of namespace - are

   chained together by the ->prev field, which (as the name implies)

   runs in reverse order.  All the decls in a given namespace bound to

   a given identifier are chained by the ->shadowed field, which runs

   from inner to outer scopes.

   The ->decl field usually points to a DECL node, but there are two

   exceptions.  In the namespace of type tags, the bound entity is a

   RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node.  If an undeclared

   identifier is encountered, it is bound to error_mark_node to

   suppress further errors about that identifier in the current

   function.

   The ->u.type field stores the type of the declaration in this scope;

   if NULL, the type is the type of the ->decl field.  This is only of

   relevance for objects with external or internal linkage which may

   be redeclared in inner scopes, forming composite types that only

   persist for the duration of those scopes.  In the external scope,

   this stores the composite of all the types declared for this

   object, visible or not.  The ->inner_comp field (used only at file

   scope) stores whether an incomplete array type at file scope was

   completed at an inner scope to an array size other than 1.

   The ->u.label field is used for labels.  It points to a structure

   which stores additional information used for warnings.

   The depth field is copied from the scope structure that holds this

   decl.  It is used to preserve the proper ordering of the ->shadowed

   field (see bind()) and also for a handful of special-case checks.

   Finally, the invisible bit is true for a decl which should be

   ignored for purposes of normal name lookup, and the nested bit is

   true for a decl that's been bound a second time in an inner scope;

   in all such cases, the binding in the outer scope will have its

   invisible bit true.  */

struct GTY((chain_next ("%h.prev"))) c_binding {

  union GTY(()) {               /* first so GTY desc can use decl */

    tree GTY((tag ("0"))) type; /* the type in this scope */

    struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */

  } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;

  tree decl;                    /* the decl bound */

  tree id;                      /* the identifier it's bound to */

  struct c_binding *prev;       /* the previous decl in this scope */

  struct c_binding *shadowed;   /* the innermost decl shadowed by this one */

  unsigned int depth : 28;      /* depth of this scope */

  BOOL_BITFIELD invisible : 1;  /* normal lookup should ignore this binding */

  BOOL_BITFIELD nested : 1;     /* do not set DECL_CONTEXT when popping */

  BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */

  BOOL_BITFIELD in_struct : 1;  /* currently defined as struct field */

  location_t locus;             /* location for nested bindings */

};

#define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)

#define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)

#define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)

#define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)

#define I_SYMBOL_BINDING(node) \

  (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)

#define I_SYMBOL_DECL(node) \

 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)

#define I_TAG_BINDING(node) \

  (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)

#define I_TAG_DECL(node) \

 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)

#define I_LABEL_BINDING(node) \

  (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)

#define I_LABEL_DECL(node) \

 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)

/* Each C symbol points to three linked lists of c_binding structures.

   These describe the values of the identifier in the three different

   namespaces defined by the language.  */

struct GTY(()) lang_identifier {

  struct c_common_identifier common_id;

  struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */

  struct c_binding *tag_binding;    /* struct/union/enum tags */

  struct c_binding *label_binding;  /* labels */

};

/* Validate c-lang.c's assumptions.  */

extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate

[(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];

/* The resulting tree type.  */

union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),

       chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))")))  lang_tree_node

 {

  union tree_node GTY ((tag ("0"),

                        desc ("tree_node_structure (&%h)")))

    generic;

  struct lang_identifier GTY ((tag ("1"))) identifier;

};

/* Track bindings and other things that matter for goto warnings.  For

   efficiency, we do not gather all the decls at the point of

   definition.  Instead, we point into the bindings structure.  As

   scopes are popped, we update these structures and gather the decls

   that matter at that time.  */

struct GTY(()) c_spot_bindings {

  /* The currently open scope which holds bindings defined when the

     label was defined or the goto statement was found.  */

  struct c_scope *scope;

  /* The bindings in the scope field which were defined at the point

     of the label or goto.  This lets us look at older or newer

     bindings in the scope, as appropriate.  */

  struct c_binding *bindings_in_scope;

  /* The number of statement expressions that have started since this

     label or goto statement was defined.  This is zero if we are at

     the same statement expression level.  It is positive if we are in

     a statement expression started since this spot.  It is negative

     if this spot was in a statement expression and we have left

     it.  */

  int stmt_exprs;

  /* Whether we started in a statement expression but are no longer in

     it.  This is set to true if stmt_exprs ever goes negative.  */

  bool left_stmt_expr;

};

/* This structure is used to keep track of bindings seen when a goto

   statement is defined.  This is only used if we see the goto

   statement before we see the label.  */

struct GTY(()) c_goto_bindings {

  /* The location of the goto statement.  */

  location_t loc;

  /* The bindings of the goto statement.  */

  struct c_spot_bindings goto_bindings;

};

typedef struct c_goto_bindings *c_goto_bindings_p;

DEF_VEC_P(c_goto_bindings_p);

DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);

/* The additional information we keep track of for a label binding.

   These fields are updated as scopes are popped.  */

struct GTY(()) c_label_vars {

  /* The shadowed c_label_vars, when one label shadows another (which

     can only happen using a __label__ declaration).  */

  struct c_label_vars *shadowed;

  /* The bindings when the label was defined.  */

  struct c_spot_bindings label_bindings;

  /* A list of decls that we care about: decls about which we should

     warn if a goto branches to this label from later in the function.

     Decls are added to this list as scopes are popped.  We only add

     the decls that matter.  */

  VEC(tree,gc) *decls_in_scope;

  /* A list of goto statements to this label.  This is only used for

     goto statements seen before the label was defined, so that we can

     issue appropriate warnings for them.  */

  VEC(c_goto_bindings_p,gc) *gotos;

};

/* Each c_scope structure describes the complete contents of one

   scope.  Four scopes are distinguished specially: the innermost or

   current scope, the innermost function scope, the file scope (always

   the second to outermost) and the outermost or external scope.

   Most declarations are recorded in the current scope.

   All normal label declarations are recorded in the innermost

   function scope, as are bindings of undeclared identifiers to

   error_mark_node.  (GCC permits nested functions as an extension,

   hence the 'innermost' qualifier.)  Explicitly declared labels

   (using the __label__ extension) appear in the current scope.

   Being in the file scope (current_scope == file_scope) causes

   special behavior in several places below.  Also, under some

   conditions the Objective-C front end records declarations in the

   file scope even though that isn't the current scope.

   All declarations with external linkage are recorded in the external

   scope, even if they aren't visible there; this models the fact that

   such declarations are visible to the entire program, and (with a

   bit of cleverness, see pushdecl) allows diagnosis of some violations

   of C99 6.2.2p7 and 6.2.7p2:

     If, within the same translation unit, the same identifier appears

     with both internal and external linkage, the behavior is

     undefined.

     All declarations that refer to the same object or function shall

     have compatible type; otherwise, the behavior is undefined.

   Initially only the built-in declarations, which describe compiler

   intrinsic functions plus a subset of the standard library, are in

   this scope.

   The order of the blocks list matters, and it is frequently appended

   to.  To avoid having to walk all the way to the end of the list on

   each insertion, or reverse the list later, we maintain a pointer to

   the last list entry.  (FIXME: It should be feasible to use a reversed

   list here.)

   The bindings list is strictly in reverse order of declarations;

   pop_scope relies on this.  */

struct GTY((chain_next ("%h.outer"))) c_scope {

  /* The scope containing this one.  */

  struct c_scope *outer;

  /* The next outermost function scope.  */

  struct c_scope *outer_function;

  /* All bindings in this scope.  */

  struct c_binding *bindings;

  /* For each scope (except the global one), a chain of BLOCK nodes

     for all the scopes that were entered and exited one level down.  */

  tree blocks;

  tree blocks_last;

  /* The depth of this scope.  Used to keep the ->shadowed chain of

     bindings sorted innermost to outermost.  */

  unsigned int depth : 28;

  /* True if we are currently filling this scope with parameter

     declarations.  */

  BOOL_BITFIELD parm_flag : 1;

  /* True if we saw [*] in this scope.  Used to give an error messages

     if these appears in a function definition.  */

  BOOL_BITFIELD had_vla_unspec : 1;

  /* True if we already complained about forward parameter decls

     in this scope.  This prevents double warnings on

     foo (int a; int b; ...)  */

  BOOL_BITFIELD warned_forward_parm_decls : 1;

  /* True if this is the outermost block scope of a function body.

     This scope contains the parameters, the local variables declared

     in the outermost block, and all the labels (except those in

     nested functions, or declared at block scope with __label__).  */

  BOOL_BITFIELD function_body : 1;

  /* True means make a BLOCK for this scope no matter what.  */

  BOOL_BITFIELD keep : 1;

  /* True means that an unsuffixed float constant is _Decimal64.  */

  BOOL_BITFIELD float_const_decimal64 : 1;

  /* True if this scope has any label bindings.  This is used to speed

     up searching for labels when popping scopes, particularly since

     labels are normally only found at function scope.  */

  BOOL_BITFIELD has_label_bindings : 1;

};

/* The scope currently in effect.  */

static GTY(()) struct c_scope *current_scope;

/* The innermost function scope.  Ordinary (not explicitly declared)

   labels, bindings to error_mark_node, and the lazily-created

   bindings of __func__ and its friends get this scope.  */

static GTY(()) struct c_scope *current_function_scope;

/* The C file scope.  This is reset for each input translation unit.  */

static GTY(()) struct c_scope *file_scope;

/* The outermost scope.  This is used for all declarations with

   external linkage, and only these, hence the name.  */

static GTY(()) struct c_scope *external_scope;

/* A chain of c_scope structures awaiting reuse.  */

static GTY((deletable)) struct c_scope *scope_freelist;

/* A chain of c_binding structures awaiting reuse.  */

static GTY((deletable)) struct c_binding *binding_freelist;

/* Append VAR to LIST in scope SCOPE.  */

#define SCOPE_LIST_APPEND(scope, list, decl) do {       \

  struct c_scope *s_ = (scope);                         \

  tree d_ = (decl);                                     \

  if (s_->list##_last)                                  \

    BLOCK_CHAIN (s_->list##_last) = d_;                 \

  else                                                  \

    s_->list = d_;                                      \

  s_->list##_last = d_;                                 \

} while (0)

/* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE.  */

#define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {        \

  struct c_scope *t_ = (tscope);                                \

  struct c_scope *f_ = (fscope);                                \

  if (t_->to##_last)                                            \

    BLOCK_CHAIN (t_->to##_last) = f_->from;                     \

  else                                                          \

    t_->to = f_->from;                                          \

  t_->to##_last = f_->from##_last;                              \

} while (0)

/* A c_inline_static structure stores details of a static identifier

   referenced in a definition of a function that may be an inline

   definition if no subsequent declaration of that function uses

   "extern" or does not use "inline".  */

struct GTY((chain_next ("%h.next"))) c_inline_static {

  /* The location for a diagnostic.  */

  location_t location;

  /* The function that may be an inline definition.  */

  tree function;

  /* The object or function referenced.  */

  tree static_decl;

  /* What sort of reference this is.  */

  enum c_inline_static_type type;

  /* The next such structure or NULL.  */

  struct c_inline_static *next;

};

/* List of static identifiers used or referenced in functions that may

   be inline definitions.  */

static GTY(()) struct c_inline_static *c_inline_statics;

/* True means unconditionally make a BLOCK for the next scope pushed.  */

static bool keep_next_level_flag;

/* True means the next call to push_scope will be the outermost scope

   of a function body, so do not push a new scope, merely cease

   expecting parameter decls.  */

static bool next_is_function_body;

/* A VEC of pointers to c_binding structures.  */

typedef struct c_binding *c_binding_ptr;

DEF_VEC_P(c_binding_ptr);

DEF_VEC_ALLOC_P(c_binding_ptr,heap);

/* Information that we keep for a struct or union while it is being

   parsed.  */

struct c_struct_parse_info

{

  /* If warn_cxx_compat, a list of types defined within this

     struct.  */

  VEC(tree,heap) *struct_types;

  /* If warn_cxx_compat, a list of field names which have bindings,

     and which are defined in this struct, but which are not defined

     in any enclosing struct.  This is used to clear the in_struct

     field of the c_bindings structure.  */

  VEC(c_binding_ptr,heap) *fields;

  /* If warn_cxx_compat, a list of typedef names used when defining

     fields in this struct.  */

  VEC(tree,heap) *typedefs_seen;

};

/* Information for the struct or union currently being parsed, or

   NULL if not parsing a struct or union.  */

static struct c_struct_parse_info *struct_parse_info;

/* Forward declarations.  */

static tree lookup_name_in_scope (tree, struct c_scope *);

static tree c_make_fname_decl (location_t, tree, int);

static tree grokdeclarator (const struct c_declarator *,

                            struct c_declspecs *,

                            enum decl_context, bool, tree *, tree *, tree *,

                            bool *, enum deprecated_states);

static tree grokparms (struct c_arg_info *, bool);

static void layout_array_type (tree);

/* T is a statement.  Add it to the statement-tree.  This is the

   C/ObjC version--C++ has a slightly different version of this

   function.  */

tree

add_stmt (tree t)

{

  enum tree_code code = TREE_CODE (t);

  if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)

    {

      if (!EXPR_HAS_LOCATION (t))

        SET_EXPR_LOCATION (t, input_location);

    }

  if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)

    STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;

  /* Add T to the statement-tree.  Non-side-effect statements need to be

     recorded during statement expressions.  */

  append_to_statement_list_force (t, &cur_stmt_list);

  return t;

}

void

c_print_identifier (FILE *file, tree node, int indent)

{

  print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);

  print_node (file, "tag", I_TAG_DECL (node), indent + 4);

  print_node (file, "label", I_LABEL_DECL (node), indent + 4);

  if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)

    {

      tree rid = ridpointers[C_RID_CODE (node)];

      indent_to (file, indent + 4);

      fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",

               (void *) rid, IDENTIFIER_POINTER (rid));

    }

}

/* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,

   which may be any of several kinds of DECL or TYPE or error_mark_node,

   in the scope SCOPE.  */

static void

bind (tree name, tree decl, struct c_scope *scope, bool invisible,

      bool nested, location_t locus)

{

  struct c_binding *b, **here;

  if (binding_freelist)

    {

      b = binding_freelist;

      binding_freelist = b->prev;

    }

  else

    b = GGC_NEW (struct c_binding);

  b->shadowed = 0;

  b->decl = decl;

  b->id = name;

  b->depth = scope->depth;

  b->invisible = invisible;

  b->nested = nested;

  b->inner_comp = 0;

  b->in_struct = 0;

  b->locus = locus;

  b->u.type = NULL;

  b->prev = scope->bindings;

  scope->bindings = b;

  if (!name)

    return;

  switch (TREE_CODE (decl))

    {

    case LABEL_DECL:     here = &I_LABEL_BINDING (name);   break;

    case ENUMERAL_TYPE:

    case UNION_TYPE:

    case RECORD_TYPE:    here = &I_TAG_BINDING (name);     break;

    case VAR_DECL:

    case FUNCTION_DECL:

    case TYPE_DECL:

    case CONST_DECL:

    case PARM_DECL:

    case ERROR_MARK:     here = &I_SYMBOL_BINDING (name);  break;

    default:

      gcc_unreachable ();

    }

  /* Locate the appropriate place in the chain of shadowed decls

     to insert this binding.  Normally, scope == current_scope and

     this does nothing.  */

  while (*here && (*here)->depth > scope->depth)

    here = &(*here)->shadowed;

  b->shadowed = *here;

  *here = b;

}

/* Clear the binding structure B, stick it on the binding_freelist,

   and return the former value of b->prev.  This is used by pop_scope

   and get_parm_info to iterate destructively over all the bindings

   from a given scope.  */

static struct c_binding *

free_binding_and_advance (struct c_binding *b)

{

  struct c_binding *prev = b->prev;

  memset (b, 0, sizeof (struct c_binding));

  b->prev = binding_freelist;

  binding_freelist = b;

  return prev;

}

/* Bind a label.  Like bind, but skip fields which aren't used for

   labels, and add the LABEL_VARS value.  */

static void

bind_label (tree name, tree label, struct c_scope *scope,

            struct c_label_vars *label_vars)

{

  struct c_binding *b;

  bind (name, label, scope, /*invisible=*/false, /*nested=*/false,

        UNKNOWN_LOCATION);

  scope->has_label_bindings = true;

  b = scope->bindings;

  gcc_assert (b->decl == label);

  label_vars->shadowed = b->u.label;

  b->u.label = label_vars;

}

/* Hook called at end of compilation to assume 1 elt

   for a file-scope tentative array defn that wasn't complete before.  */

void

c_finish_incomplete_decl (tree decl)

{

  if (TREE_CODE (decl) == VAR_DECL)

    {

      tree type = TREE_TYPE (decl);

      if (type != error_mark_node

          && TREE_CODE (type) == ARRAY_TYPE

          && !DECL_EXTERNAL (decl)

          && TYPE_DOMAIN (type) == 0)

        {

          warning_at (DECL_SOURCE_LOCATION (decl),

                      0, "array %q+D assumed to have one element", decl);

          complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);

          layout_decl (decl, 0);

        }

    }

}

/* Record that inline function FUNC contains a reference (location

   LOC) to static DECL (file-scope or function-local according to

   TYPE).  */

void

record_inline_static (location_t loc, tree func, tree decl,

                      enum c_inline_static_type type)

{

  struct c_inline_static *csi = GGC_NEW (struct c_inline_static);

  csi->location = loc;

  csi->function = func;

  csi->static_decl = decl;

  csi->type = type;

  csi->next = c_inline_statics;

  c_inline_statics = csi;

}

/* Check for references to static declarations in inline functions at

   the end of the translation unit and diagnose them if the functions

   are still inline definitions.  */

static void

check_inline_statics (void)

{

  struct c_inline_static *csi;

  for (csi = c_inline_statics; csi; csi = csi->next)

    {

      if (DECL_EXTERNAL (csi->function))

        switch (csi->type)

          {

          case csi_internal:

            pedwarn (csi->location, 0,

                     "%qD is static but used in inline function %qD "

                     "which is not static", csi->static_decl, csi->function);

            break;

          case csi_modifiable:

            pedwarn (csi->location, 0,

                     "%q+D is static but declared in inline function %qD "

                     "which is not static", csi->static_decl, csi->function);

            break;

          default:

            gcc_unreachable ();

          }

    }

  c_inline_statics = NULL;

}

/* Fill in a c_spot_bindings structure.  If DEFINING is true, set it

   for the current state, otherwise set it to uninitialized.  */

static void