Subversion Repositories openrisc

/* RunTime Type Identification

   Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,

   2005, 2006, 2007, 2008, 2009

   Free Software Foundation, Inc.

   Mostly written by Jason Merrill (jason@cygnus.com).

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

#include "config.h"

#include "system.h"

#include "intl.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "cp-tree.h"

#include "flags.h"

#include "output.h"

#include "assert.h"

#include "toplev.h"

#include "convert.h"

#include "target.h"

#include "c-pragma.h"

/* C++ returns type information to the user in struct type_info

   objects. We also use type information to implement dynamic_cast and

   exception handlers. Type information for a particular type is

   indicated with an ABI defined structure derived from type_info.

   This would all be very straight forward, but for the fact that the

   runtime library provides the definitions of the type_info structure

   and the ABI defined derived classes. We cannot build declarations

   of them directly in the compiler, but we need to layout objects of

   their type.  Somewhere we have to lie.

   We define layout compatible POD-structs with compiler-defined names

   and generate the appropriate initializations for them (complete

   with explicit mention of their vtable). When we have to provide a

   type_info to the user we reinterpret_cast the internal compiler

   type to type_info.  A well formed program can only explicitly refer

   to the type_infos of complete types (& cv void).  However, we chain

   pointer type_infos to the pointed-to-type, and that can be

   incomplete.  We only need the addresses of such incomplete

   type_info objects for static initialization.

   The type information VAR_DECL of a type is held on the

   IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL

   will be the internal type.  It will usually have the correct

   internal type reflecting the kind of type it represents (pointer,

   array, function, class, inherited class, etc).  When the type it

   represents is incomplete, it will have the internal type

   corresponding to type_info.  That will only happen at the end of

   translation, when we are emitting the type info objects.  */

/* Auxiliary data we hold for each type_info derived object we need.  */

typedef struct GTY (()) tinfo_s {

  tree type;  /* The RECORD_TYPE for this type_info object */

  tree vtable; /* The VAR_DECL of the vtable.  Only filled at end of

                  translation.  */

  tree name;  /* IDENTIFIER_NODE for the ABI specified name of

                 the type_info derived type.  */

} tinfo_s;

DEF_VEC_O(tinfo_s);

DEF_VEC_ALLOC_O(tinfo_s,gc);

typedef enum tinfo_kind

{

  TK_TYPE_INFO_TYPE,    /* abi::__type_info_pseudo */

  TK_BASE_TYPE,         /* abi::__base_class_type_info */

  TK_BUILTIN_TYPE,      /* abi::__fundamental_type_info */

  TK_ARRAY_TYPE,        /* abi::__array_type_info */

  TK_FUNCTION_TYPE,     /* abi::__function_type_info */

  TK_ENUMERAL_TYPE,     /* abi::__enum_type_info */

  TK_POINTER_TYPE,      /* abi::__pointer_type_info */

  TK_POINTER_MEMBER_TYPE, /* abi::__pointer_to_member_type_info */

  TK_CLASS_TYPE,        /* abi::__class_type_info */

  TK_SI_CLASS_TYPE,     /* abi::__si_class_type_info */

  TK_FIXED              /* end of fixed descriptors. */

  /* ...                   abi::__vmi_type_info<I> */

} tinfo_kind;

/* A vector of all tinfo decls that haven't yet been emitted.  */

VEC(tree,gc) *unemitted_tinfo_decls;

/* A vector of all type_info derived types we need.  The first few are

   fixed and created early. The remainder are for multiple inheritance

   and are generated as needed. */

static GTY (()) VEC(tinfo_s,gc) *tinfo_descs;

static tree ifnonnull (tree, tree);

static tree tinfo_name (tree, bool);

static tree build_dynamic_cast_1 (tree, tree, tsubst_flags_t);

static tree throw_bad_cast (void);

static tree throw_bad_typeid (void);

static tree get_tinfo_decl_dynamic (tree);

static tree get_tinfo_ptr (tree);

static bool typeid_ok_p (void);

static int qualifier_flags (tree);

static bool target_incomplete_p (tree);

static tree tinfo_base_init (tinfo_s *, tree);

static tree generic_initializer (tinfo_s *, tree);

static tree ptr_initializer (tinfo_s *, tree);

static tree ptm_initializer (tinfo_s *, tree);

static tree class_initializer (tinfo_s *, tree, tree);

static void create_pseudo_type_info (int, const char *, ...);

static tree get_pseudo_ti_init (tree, unsigned);

static unsigned get_pseudo_ti_index (tree);

static void create_tinfo_types (void);

static bool typeinfo_in_lib_p (tree);

static int doing_runtime = 0;

static void

push_abi_namespace (void)

{

  push_nested_namespace (abi_node);

  push_visibility ("default", 2);

}

static void

pop_abi_namespace (void)

{

  pop_visibility (2);

  pop_nested_namespace (abi_node);

}

/* Declare language defined type_info type and a pointer to const

   type_info.  This is incomplete here, and will be completed when

   the user #includes <typeinfo>.  There are language defined

   restrictions on what can be done until that is included.  Create

   the internal versions of the ABI types.  */

void

init_rtti_processing (void)

{

  tree type_info_type;

  push_namespace (std_identifier);

  type_info_type = xref_tag (class_type, get_identifier ("type_info"),

                             /*tag_scope=*/ts_current, false);

  pop_namespace ();

  const_type_info_type_node

    = build_qualified_type (type_info_type, TYPE_QUAL_CONST);

  type_info_ptr_type = build_pointer_type (const_type_info_type_node);

  unemitted_tinfo_decls = VEC_alloc (tree, gc, 124);

  create_tinfo_types ();

}

/* Given the expression EXP of type `class *', return the head of the

   object pointed to by EXP with type cv void*, if the class has any

   virtual functions (TYPE_POLYMORPHIC_P), else just return the

   expression.  */

tree

build_headof (tree exp)

{

  tree type = TREE_TYPE (exp);

  tree offset;

  tree index;

  gcc_assert (TREE_CODE (type) == POINTER_TYPE);

  type = TREE_TYPE (type);

  if (!TYPE_POLYMORPHIC_P (type))

    return exp;

  /* We use this a couple of times below, protect it.  */

  exp = save_expr (exp);

  /* The offset-to-top field is at index -2 from the vptr.  */

  index = build_int_cst (NULL_TREE,

                         -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);

  offset = build_vtbl_ref (cp_build_indirect_ref (exp, RO_NULL,

                                                  tf_warning_or_error),

                           index);

  type = build_qualified_type (ptr_type_node,

                               cp_type_quals (TREE_TYPE (exp)));

  return build2 (POINTER_PLUS_EXPR, type, exp,

                 convert_to_integer (sizetype, offset));

}

/* Get a bad_cast node for the program to throw...

   See libstdc++/exception.cc for __throw_bad_cast */

static tree

throw_bad_cast (void)

{

  tree fn = get_identifier ("__cxa_bad_cast");

  if (!get_global_value_if_present (fn, &fn))

    fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,

                                                         void_list_node));

  return build_cxx_call (fn, 0, NULL);

}

/* Return an expression for "__cxa_bad_typeid()".  The expression

   returned is an lvalue of type "const std::type_info".  */

static tree

throw_bad_typeid (void)

{

  tree fn = get_identifier ("__cxa_bad_typeid");

  if (!get_global_value_if_present (fn, &fn))

    {

      tree t;

      t = build_reference_type (const_type_info_type_node);

      t = build_function_type (t, void_list_node);

      fn = push_throw_library_fn (fn, t);

    }

  return build_cxx_call (fn, 0, NULL);

}

/* Return an lvalue expression whose type is "const std::type_info"

   and whose value indicates the type of the expression EXP.  If EXP

   is a reference to a polymorphic class, return the dynamic type;

   otherwise return the static type of the expression.  */

static tree

get_tinfo_decl_dynamic (tree exp)

{

  tree type;

  tree t;

  if (error_operand_p (exp))

    return error_mark_node;

  exp = resolve_nondeduced_context (exp);

  /* peel back references, so they match.  */

  type = non_reference (TREE_TYPE (exp));

  /* Peel off cv qualifiers.  */

  type = TYPE_MAIN_VARIANT (type);

  /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics.  */

  if (CLASS_TYPE_P (type) || TREE_CODE (type) == UNKNOWN_TYPE)

    type = complete_type_or_else (type, exp);

  if (!type)

    return error_mark_node;

  /* If exp is a reference to polymorphic type, get the real type_info.  */

  if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))

    {

      /* build reference to type_info from vtable.  */

      tree index;

      /* The RTTI information is at index -1.  */

      index = build_int_cst (NULL_TREE,

                             -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);

      t = build_vtbl_ref (exp, index);

      t = convert (type_info_ptr_type, t);

    }

  else

    /* Otherwise return the type_info for the static type of the expr.  */

    t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));

  return cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);

}

static bool

typeid_ok_p (void)

{

  tree pseudo_type_info, type_info_type;

  if (! flag_rtti)

    {

      error ("cannot use typeid with -fno-rtti");

      return false;

    }

  if (!COMPLETE_TYPE_P (const_type_info_type_node))

    {

      error ("must #include <typeinfo> before using typeid");

      return false;

    }

  pseudo_type_info

    = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE)->type;

  type_info_type = TYPE_MAIN_VARIANT (const_type_info_type_node);

  /* Make sure abi::__type_info_pseudo has the same alias set

     as std::type_info.  */

  if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info))

    TYPE_ALIAS_SET (pseudo_type_info) = get_alias_set (type_info_type);

  else

    gcc_assert (TYPE_ALIAS_SET (pseudo_type_info)

                == get_alias_set (type_info_type));

  return true;

}

/* Return an expression for "typeid(EXP)".  The expression returned is

   an lvalue of type "const std::type_info".  */

tree

build_typeid (tree exp)

{

  tree cond = NULL_TREE;

  int nonnull = 0;

  if (exp == error_mark_node || !typeid_ok_p ())

    return error_mark_node;

  if (processing_template_decl)

    return build_min (TYPEID_EXPR, const_type_info_type_node, exp);

  if (TREE_CODE (exp) == INDIRECT_REF

      && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE

      && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))

      && ! resolves_to_fixed_type_p (exp, &nonnull)

      && ! nonnull)

    {

      exp = stabilize_reference (exp);

      cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));

    }

  exp = get_tinfo_decl_dynamic (exp);

  if (exp == error_mark_node)

    return error_mark_node;

  if (cond)

    {

      tree bad = throw_bad_typeid ();

      exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);

    }

  return exp;

}

/* Generate the NTBS name of a type.  If MARK_PRIVATE, put a '*' in front so that

   comparisons will be done by pointer rather than string comparison.  */

static tree

tinfo_name (tree type, bool mark_private)

{

  const char *name;

  int length;

  tree name_string;

  name = mangle_type_string (type);

  length = strlen (name);

  if (mark_private)

    {

      /* Inject '*' at beginning of name to force pointer comparison.  */

      char* buf = (char*) XALLOCAVEC (char, length + 2);

      buf[0] = '*';

      memcpy (buf + 1, name, length + 1);

      name_string = build_string (length + 2, buf);

    }

  else

    name_string = build_string (length + 1, name);

  return fix_string_type (name_string);

}

/* Return a VAR_DECL for the internal ABI defined type_info object for

   TYPE. You must arrange that the decl is mark_used, if actually use

   it --- decls in vtables are only used if the vtable is output.  */

tree

get_tinfo_decl (tree type)

{

  tree name;

  tree d;

  if (variably_modified_type_p (type, /*fn=*/NULL_TREE))

    {

      error ("cannot create type information for type %qT because "

             "it involves types of variable size",

             type);

      return error_mark_node;

    }

  if (TREE_CODE (type) == METHOD_TYPE)

    type = build_function_type (TREE_TYPE (type),

                                TREE_CHAIN (TYPE_ARG_TYPES (type)));

  /* For a class type, the variable is cached in the type node

     itself.  */

  if (CLASS_TYPE_P (type))

    {

      d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));

      if (d)

        return d;

    }

  name = mangle_typeinfo_for_type (type);

  d = IDENTIFIER_GLOBAL_VALUE (name);

  if (!d)

    {

      int ix = get_pseudo_ti_index (type);

      tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix);

      d = build_lang_decl (VAR_DECL, name, ti->type);

      SET_DECL_ASSEMBLER_NAME (d, name);

      /* Remember the type it is for.  */

      TREE_TYPE (name) = type;

      DECL_TINFO_P (d) = 1;

      DECL_ARTIFICIAL (d) = 1;

      DECL_IGNORED_P (d) = 1;

      TREE_READONLY (d) = 1;

      TREE_STATIC (d) = 1;

      /* Mark the variable as undefined -- but remember that we can

         define it later if we need to do so.  */

      DECL_EXTERNAL (d) = 1;

      DECL_NOT_REALLY_EXTERN (d) = 1;

      set_linkage_according_to_type (type, d);

      d = pushdecl_top_level_and_finish (d, NULL_TREE);

      if (CLASS_TYPE_P (type))

        CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;

      /* Add decl to the global array of tinfo decls.  */

      VEC_safe_push (tree, gc, unemitted_tinfo_decls, d);

    }

  return d;

}

/* Return a pointer to a type_info object describing TYPE, suitably

   cast to the language defined type.  */

static tree

get_tinfo_ptr (tree type)

{

  tree decl = get_tinfo_decl (type);

  mark_used (decl);

  return build_nop (type_info_ptr_type,

                    build_address (decl));

}

/* Return the type_info object for TYPE.  */

tree

get_typeid (tree type)

{

  if (type == error_mark_node || !typeid_ok_p ())

    return error_mark_node;

  if (processing_template_decl)

    return build_min (TYPEID_EXPR, const_type_info_type_node, type);

  /* If the type of the type-id is a reference type, the result of the

     typeid expression refers to a type_info object representing the

     referenced type.  */

  type = non_reference (type);

  /* The top-level cv-qualifiers of the lvalue expression or the type-id

     that is the operand of typeid are always ignored.  */

  type = TYPE_MAIN_VARIANT (type);

  /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics.  */

  if (CLASS_TYPE_P (type) || TREE_CODE (type) == UNKNOWN_TYPE)

    type = complete_type_or_else (type, NULL_TREE);

  if (!type)

    return error_mark_node;

  return cp_build_indirect_ref (get_tinfo_ptr (type), RO_NULL,

                                tf_warning_or_error);

}

/* Check whether TEST is null before returning RESULT.  If TEST is used in

   RESULT, it must have previously had a save_expr applied to it.  */

static tree

ifnonnull (tree test, tree result)

{

  return build3 (COND_EXPR, TREE_TYPE (result),

                 build2 (EQ_EXPR, boolean_type_node, test,

                         cp_convert (TREE_TYPE (test), integer_zero_node)),

                 cp_convert (TREE_TYPE (result), integer_zero_node),

                 result);

}

/* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working

   paper.  */

static tree

build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)

{

  enum tree_code tc = TREE_CODE (type);

  tree exprtype = TREE_TYPE (expr);

  tree dcast_fn;

  tree old_expr = expr;

  const char *errstr = NULL;

  /* Save casted types in the function's used types hash table.  */

  used_types_insert (type);

  /* T shall be a pointer or reference to a complete class type, or

     `pointer to cv void''.  */

  switch (tc)

    {

    case POINTER_TYPE:

      if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)

        break;

      /* Fall through.  */

    case REFERENCE_TYPE:

      if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))

        {

          errstr = _("target is not pointer or reference to class");

          goto fail;

        }

      if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))

        {

          errstr = _("target is not pointer or reference to complete type");

          goto fail;

        }

      break;

    default:

      errstr = _("target is not pointer or reference");

      goto fail;

    }

  if (tc == POINTER_TYPE)

    {

      /* If T is a pointer type, v shall be an rvalue of a pointer to

         complete class type, and the result is an rvalue of type T.  */

      if (TREE_CODE (exprtype) != POINTER_TYPE)

        {

          errstr = _("source is not a pointer");

          goto fail;

        }

      if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))

        {

          errstr = _("source is not a pointer to class");

          goto fail;

        }

      if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))

        {

          errstr = _("source is a pointer to incomplete type");

          goto fail;

        }

    }

  else

    {

      exprtype = build_reference_type (exprtype);

      /* T is a reference type, v shall be an lvalue of a complete class

         type, and the result is an lvalue of the type referred to by T.  */

      if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))

        {

          errstr = _("source is not of class type");

          goto fail;

        }

      if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))

        {

          errstr = _("source is of incomplete class type");

          goto fail;

        }

      /* Apply trivial conversion T -> T& for dereferenced ptrs.  */

      expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,

                                   LOOKUP_NORMAL, NULL_TREE);

    }

  /* The dynamic_cast operator shall not cast away constness.  */

  if (!at_least_as_qualified_p (TREE_TYPE (type),

                                TREE_TYPE (exprtype)))

    {

      errstr = _("conversion casts away constness");

      goto fail;

    }

  /* If *type is an unambiguous accessible base class of *exprtype,

     convert statically.  */

  {

    tree binfo;

    binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),

                         ba_check, NULL);

    if (binfo)

      {

        expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),

                                binfo, 0);

        if (TREE_CODE (exprtype) == POINTER_TYPE)

          expr = rvalue (expr);

        return expr;

      }

  }

  /* Otherwise *exprtype must be a polymorphic class (have a vtbl).  */

  if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))

    {

      tree expr1;

      /* if TYPE is `void *', return pointer to complete object.  */

      if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))

        {

          /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b.  */

          if (TREE_CODE (expr) == ADDR_EXPR

              && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL

              && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)

            return build1 (NOP_EXPR, type, expr);

          /* Since expr is used twice below, save it.  */

          expr = save_expr (expr);

          expr1 = build_headof (expr);

          if (TREE_TYPE (expr1) != type)

            expr1 = build1 (NOP_EXPR, type, expr1);

          return ifnonnull (expr, expr1);

        }

      else

        {

          tree retval;

          tree result, td2, td3;

          tree elems[4];

          tree static_type, target_type, boff;

          /* If we got here, we can't convert statically.  Therefore,

             dynamic_cast<D&>(b) (b an object) cannot succeed.  */

          if (tc == REFERENCE_TYPE)

            {

              if (TREE_CODE (old_expr) == VAR_DECL

                  && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)

                {

                  tree expr = throw_bad_cast ();

                  if (complain & tf_warning)

                    warning (0, "dynamic_cast of %q#D to %q#T can never succeed",

                             old_expr, type);

                  /* Bash it to the expected type.  */

                  TREE_TYPE (expr) = type;

                  return expr;

                }

            }

          /* Ditto for dynamic_cast<D*>(&b).  */

          else if (TREE_CODE (expr) == ADDR_EXPR)

            {

              tree op = TREE_OPERAND (expr, 0);

              if (TREE_CODE (op) == VAR_DECL

                  && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)

                {

                  if (complain & tf_warning)

                    warning (0, "dynamic_cast of %q#D to %q#T can never succeed",

                             op, type);

                  retval = build_int_cst (type, 0);

                  return retval;

                }

            }

          /* Use of dynamic_cast when -fno-rtti is prohibited.  */

          if (!flag_rtti)

            {

              if (complain & tf_error)

                error ("%<dynamic_cast%> not permitted with -fno-rtti");

              return error_mark_node;

            }

          target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));

          static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));

          td2 = get_tinfo_decl (target_type);

          mark_used (td2);

          td2 = cp_build_unary_op (ADDR_EXPR, td2, 0, complain);

          td3 = get_tinfo_decl (static_type);

          mark_used (td3);

          td3 = cp_build_unary_op (ADDR_EXPR, td3, 0, complain);

          /* Determine how T and V are related.  */

          boff = dcast_base_hint (static_type, target_type);

          /* Since expr is used twice below, save it.  */

          expr = save_expr (expr);

          expr1 = expr;

          if (tc == REFERENCE_TYPE)

            expr1 = cp_build_unary_op (ADDR_EXPR, expr1, 0, complain);

          elems[0] = expr1;

          elems[1] = td3;

          elems[2] = td2;

          elems[3] = boff;

          dcast_fn = dynamic_cast_node;

          if (!dcast_fn)

            {