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, 2007 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 "langhooks.h"

#include "tree-mudflap.h"

#include "tree-gimple.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"

/* 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)  */

/* 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;

/* True means we've initialized exception handling.  */

bool c_eh_initialized_p;

/* While defining an enum type, this is 1 plus the last enumerator

   constant value.  Note that will do not have to save this or `enum_overflow'

   around nested function definition since such a definition could only

   occur in an enum value expression and we don't use these variables in

   that case.  */

static tree enum_next_value;

/* Nonzero means that there was overflow computing enum_next_value.  */

static int enum_overflow;

/* 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 starting a function declared `extern inline'.  */

static int current_extern_inline;

/* 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 ->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 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 c_binding GTY((chain_next ("%h.prev")))

{

  tree decl;                    /* the decl bound */

  tree type;                    /* the type in this scope */

  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 */

  /* one free bit */

};

#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 lang_identifier GTY(())

{

  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 lang_tree_node

  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)")))

{

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

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

    generic;

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

};

/* 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 c_scope GTY((chain_next ("%h.outer")))

{

  /* 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;

};

/* 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)                                  \

    TREE_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)                                            \

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

  else                                                          \

    t_->to = f_->from;                                          \

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

} while (0)

/* 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;

/* Functions called automatically at the beginning and end of execution.  */

static GTY(()) tree static_ctors;

static GTY(()) tree static_dtors;

/* Forward declarations.  */

static tree lookup_name_in_scope (tree, struct c_scope *);

static tree c_make_fname_decl (tree, int);

static tree grokdeclarator (const struct c_declarator *,

                            struct c_declspecs *,

                            enum decl_context, bool, tree *);

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 (EXPR_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;

}

/* 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

};

static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;

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))

    {

      tree rid = ridpointers[C_RID_CODE (node)];

      indent_to (file, indent + 4);

      fprintf (file, "rid %p \"%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)

{

  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->type = 0;

  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;

}

/* 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 (0, "array %q+D assumed to have one element", decl);

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

          layout_decl (decl, 0);

        }

    }

}

/* The Objective-C front-end often needs to determine the current scope.  */

void *

objc_get_current_scope (void)

{

  return current_scope;

}

/* The following function is used only by Objective-C.  It needs to live here

   because it accesses the innards of c_scope.  */

void

objc_mark_locals_volatile (void *enclosing_blk)

{

  struct c_scope *scope;

  struct c_binding *b;

  for (scope = current_scope;

       scope && scope != enclosing_blk;

       scope = scope->outer)

    {

      for (b = scope->bindings; b; b = b->prev)

        objc_volatilize_decl (b->decl);

      /* Do not climb up past the current function.  */

      if (scope->function_body)

        break;

    }

}

/* Nonzero if we are currently in file scope.  */

int

global_bindings_p (void)

{

  return current_scope == file_scope && !c_override_global_bindings_to_false;

}

void

keep_next_level (void)

{

  keep_next_level_flag = true;

}

/* Identify this scope as currently being filled with parameters.  */

void

declare_parm_level (void)

{

  current_scope->parm_flag = true;

}

void

push_scope (void)

{

  if (next_is_function_body)

    {

      /* This is the transition from the parameters to the top level

         of the function body.  These are the same scope

         (C99 6.2.1p4,6) so we do not push another scope structure.

         next_is_function_body is set only by store_parm_decls, which

         in turn is called when and only when we are about to

         encounter the opening curly brace for the function body.

         The outermost block of a function always gets a BLOCK node,

         because the debugging output routines expect that each

         function has at least one BLOCK.  */

      current_scope->parm_flag         = false;

      current_scope->function_body     = true;

      current_scope->keep              = true;

      current_scope->outer_function    = current_function_scope;

      current_function_scope           = current_scope;

      keep_next_level_flag = false;

      next_is_function_body = false;

    }

  else

    {

      struct c_scope *scope;

      if (scope_freelist)

        {

          scope = scope_freelist;

          scope_freelist = scope->outer;

        }

      else

        scope = GGC_CNEW (struct c_scope);

      scope->keep          = keep_next_level_flag;

      scope->outer         = current_scope;

      scope->depth         = current_scope ? (current_scope->depth + 1) : 0;

      /* Check for scope depth overflow.  Unlikely (2^28 == 268,435,456) but

         possible.  */

      if (current_scope && scope->depth == 0)

        {

          scope->depth--;

          sorry ("GCC supports only %u nested scopes", scope->depth);

        }

      current_scope        = scope;

      keep_next_level_flag = false;

    }

}

/* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT.  */

static void

set_type_context (tree type, tree context)

{

  for (type = TYPE_MAIN_VARIANT (type); type;

       type = TYPE_NEXT_VARIANT (type))

    TYPE_CONTEXT (type) = context;

}

/* Exit a scope.  Restore the state of the identifier-decl mappings

   that were in effect when this scope was entered.  Return a BLOCK

   node containing all the DECLs in this scope that are of interest

   to debug info generation.  */

tree

pop_scope (void)

{

  struct c_scope *scope = current_scope;

  tree block, context, p;

  struct c_binding *b;

  bool functionbody = scope->function_body;

  bool keep = functionbody || scope->keep || scope->bindings;

  c_end_vm_scope (scope->depth);

  /* If appropriate, create a BLOCK to record the decls for the life

     of this function.  */

  block = 0;

  if (keep)

    {

      block = make_node (BLOCK);

      BLOCK_SUBBLOCKS (block) = scope->blocks;

      TREE_USED (block) = 1;

      /* In each subblock, record that this is its superior.  */

      for (p = scope->blocks; p; p = TREE_CHAIN (p))

        BLOCK_SUPERCONTEXT (p) = block;

      BLOCK_VARS (block) = 0;

    }

  /* The TYPE_CONTEXTs for all of the tagged types belonging to this

     scope must be set so that they point to the appropriate

     construct, i.e.  either to the current FUNCTION_DECL node, or

     else to the BLOCK node we just constructed.

     Note that for tagged types whose scope is just the formal

     parameter list for some function type specification, we can't

     properly set their TYPE_CONTEXTs here, because we don't have a

     pointer to the appropriate FUNCTION_TYPE node readily available

     to us.  For those cases, the TYPE_CONTEXTs of the relevant tagged

     type nodes get set in `grokdeclarator' as soon as we have created

     the FUNCTION_TYPE node which will represent the "scope" for these

     "parameter list local" tagged types.  */

  if (scope->function_body)

    context = current_function_decl;

  else if (scope == file_scope)

    {

      tree file_decl = build_decl (TRANSLATION_UNIT_DECL, 0, 0);

      TREE_CHAIN (file_decl) = all_translation_units;

      all_translation_units = file_decl;

      context = file_decl;

    }

  else

    context = block;

  /* Clear all bindings in this scope.  */

  for (b = scope->bindings; b; b = free_binding_and_advance (b))

    {

      p = b->decl;

      switch (TREE_CODE (p))

        {

        case LABEL_DECL:

          /* Warnings for unused labels, errors for undefined labels.  */

          if (TREE_USED (p) && !DECL_INITIAL (p))