/* RunTime Type Identification
Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006
+ 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Mostly written by Jason Merrill (jason@cygnus.com).
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 2, or (at your option)
+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,
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 COPYING. If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+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 "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
translation, when we are emitting the type info objects. */
/* Auxiliary data we hold for each type_info derived object we need. */
-typedef struct tinfo_s GTY (())
-{
+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
typedef enum tinfo_kind
{
- TK_TYPE_INFO_TYPE, /* std::type_info */
+ 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 */
and are generated as needed. */
static GTY (()) VEC(tinfo_s,gc) *tinfo_descs;
-static tree build_headof (tree);
static tree ifnonnull (tree, tree);
-static tree tinfo_name (tree);
-static tree build_dynamic_cast_1 (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 int doing_runtime = 0;
\f
+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
virtual functions (TYPE_POLYMORPHIC_P), else just return the
expression. */
-static tree
+tree
build_headof (tree exp)
{
tree type = TREE_TYPE (exp);
index = build_int_cst (NULL_TREE,
-2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
- offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
+ 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 (PLUS_EXPR, type, exp,
- convert_to_integer (ptrdiff_type_node, offset));
+ return build2 (POINTER_PLUS_EXPR, type, exp,
+ convert_to_integer (sizetype, offset));
}
/* Get a bad_cast node for the program to throw...
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);
- if (!VOID_TYPE_P (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)
/* Otherwise return the type_info for the static type of the expr. */
t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
- return build_indirect_ref (t, NULL);
+ 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;
}
+ 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 exp;
}
-/* Generate the NTBS name of a type. */
+/* 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)
+tinfo_name (tree type, bool mark_private)
{
const char *name;
+ int length;
tree name_string;
name = mangle_type_string (type);
- name_string = fix_string_type (build_string (strlen (name) + 1, name));
- return name_string;
+ 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
that is the operand of typeid are always ignored. */
type = TYPE_MAIN_VARIANT (type);
- if (!VOID_TYPE_P (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 build_indirect_ref (get_tinfo_ptr (type), NULL);
+ 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
paper. */
static tree
-build_dynamic_cast_1 (tree type, tree expr)
+build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
{
enum tree_code tc = TREE_CODE (type);
tree exprtype = TREE_TYPE (expr);
break;
/* Fall through. */
case REFERENCE_TYPE:
- if (! IS_AGGR_TYPE (TREE_TYPE (type)))
+ if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
{
- errstr = "target is not pointer or reference to class";
+ 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";
+ errstr = _("target is not pointer or reference to complete type");
goto fail;
}
break;
default:
- errstr = "target is not pointer or reference";
+ errstr = _("target is not pointer or reference");
goto fail;
}
if (TREE_CODE (exprtype) != POINTER_TYPE)
{
- errstr = "source is not a pointer";
+ errstr = _("source is not a pointer");
goto fail;
}
- if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
+ if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
{
- errstr = "source is not a pointer to class";
+ 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";
+ errstr = _("source is a pointer to incomplete type");
goto fail;
}
}
/* 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 (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
+ if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
{
- errstr = "source is not of class type";
+ 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";
+ errstr = _("source is of incomplete class type");
goto fail;
}
if (!at_least_as_qualified_p (TREE_TYPE (type),
TREE_TYPE (exprtype)))
{
- errstr = "conversion casts away constness";
+ errstr = _("conversion casts away constness");
goto fail;
}
&& TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
{
tree expr = throw_bad_cast ();
- warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
- old_expr, type);
+ 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;
if (TREE_CODE (op) == VAR_DECL
&& TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
{
- warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
- op, 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)
{
- error ("%<dynamic_cast%> not permitted with -fno-rtti");
+ if (complain & tf_error)
+ error ("%<dynamic_cast%> not permitted with -fno-rtti");
return error_mark_node;
}
static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
td2 = get_tinfo_decl (target_type);
mark_used (td2);
- td2 = build_unary_op (ADDR_EXPR, td2, 0);
+ td2 = cp_build_unary_op (ADDR_EXPR, td2, 0, complain);
td3 = get_tinfo_decl (static_type);
mark_used (td3);
- td3 = build_unary_op (ADDR_EXPR, td3, 0);
+ 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);
expr1 = expr;
if (tc == REFERENCE_TYPE)
- expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
+ expr1 = cp_build_unary_op (ADDR_EXPR, expr1, 0, complain);
elems[0] = expr1;
elems[1] = td3;
{
tree tmp;
tree tinfo_ptr;
- tree ns = abi_node;
const char *name;
- push_nested_namespace (ns);
+ push_abi_namespace ();
tinfo_ptr = xref_tag (class_type,
get_identifier ("__class_type_info"),
/*tag_scope=*/ts_current, false);
(NULL_TREE, ptrdiff_type_node, void_list_node))));
tmp = build_function_type (ptr_type_node, tmp);
dcast_fn = build_library_fn_ptr (name, tmp);
- DECL_IS_PURE (dcast_fn) = 1;
- pop_nested_namespace (ns);
+ DECL_PURE_P (dcast_fn) = 1;
+ pop_abi_namespace ();
dynamic_cast_node = dcast_fn;
}
result = build_cxx_call (dcast_fn, 4, elems);
tree neq;
result = save_expr (result);
- neq = c_common_truthvalue_conversion (result);
- return build3 (COND_EXPR, type, neq, result, bad);
+ neq = c_common_truthvalue_conversion (input_location, result);
+ return cp_convert (type,
+ build3 (COND_EXPR, TREE_TYPE (result),
+ neq, result, bad));
}
/* Now back to the type we want from a void*. */
}
}
else
- errstr = "source type is not polymorphic";
+ errstr = _("source type is not polymorphic");
fail:
- error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
- expr, exprtype, type, errstr);
+ if (complain & tf_error)
+ error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
+ expr, exprtype, type, errstr);
return error_mark_node;
}
tree
-build_dynamic_cast (tree type, tree expr)
+build_dynamic_cast (tree type, tree expr, tsubst_flags_t complain)
{
if (type == error_mark_node || expr == error_mark_node)
return error_mark_node;
{
expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
TREE_SIDE_EFFECTS (expr) = 1;
-
- return expr;
+ return convert_from_reference (expr);
}
- return convert_from_reference (build_dynamic_cast_1 (type, expr));
+ return convert_from_reference (build_dynamic_cast_1 (type, expr, complain));
}
\f
/* Return the runtime bit mask encoding the qualifiers of TYPE. */
tree vtable_ptr;
{
- tree name_name;
+ tree name_name, name_string;
/* Generate the NTBS array variable. */
tree name_type = build_cplus_array_type
(build_qualified_type (char_type_node, TYPE_QUAL_CONST),
NULL_TREE);
- tree name_string = tinfo_name (target);
/* Determine the name of the variable -- and remember with which
type it is associated. */
DECL_TINFO_P (name_decl) = 1;
set_linkage_according_to_type (target, name_decl);
import_export_decl (name_decl);
+ name_string = tinfo_name (target, !TREE_PUBLIC (name_decl));
DECL_INITIAL (name_decl) = name_string;
mark_used (name_decl);
pushdecl_top_level_and_finish (name_decl, name_string);
if (!vtable_ptr)
{
tree real_type;
- push_nested_namespace (abi_node);
+ push_abi_namespace ();
real_type = xref_tag (class_type, ti->name,
/*tag_scope=*/ts_current, false);
- pop_nested_namespace (abi_node);
+ pop_abi_namespace ();
if (!COMPLETE_TYPE_P (real_type))
{
}
vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
- vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0);
+ vtable_ptr = cp_build_unary_op (ADDR_EXPR, vtable_ptr, 0,
+ tf_warning_or_error);
/* We need to point into the middle of the vtable. */
vtable_ptr = build2
- (PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
+ (POINTER_PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
size_binop (MULT_EXPR,
size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
TYPE_SIZE_UNIT (vtable_entry_type)));
init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
- init = build_constructor_from_list (NULL_TREE, nreverse (init));
+ init = build_constructor_from_list (init_list_type_node, nreverse (init));
TREE_CONSTANT (init) = 1;
- TREE_INVARIANT (init) = 1;
TREE_STATIC (init) = 1;
init = tree_cons (NULL_TREE, init, NULL_TREE);
{
tree init = tinfo_base_init (ti, target);
- init = build_constructor_from_list (NULL_TREE, init);
+ init = build_constructor_from_list (init_list_type_node, init);
TREE_CONSTANT (init) = 1;
- TREE_INVARIANT (init) = 1;
TREE_STATIC (init) = 1;
return init;
}
get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
init);
- init = build_constructor_from_list (NULL_TREE, nreverse (init));
+ init = build_constructor_from_list (init_list_type_node, nreverse (init));
TREE_CONSTANT (init) = 1;
- TREE_INVARIANT (init) = 1;
TREE_STATIC (init) = 1;
return init;
}
get_tinfo_ptr (klass),
init);
- init = build_constructor_from_list (NULL_TREE, nreverse (init));
+ init = build_constructor_from_list (init_list_type_node, nreverse (init));
TREE_CONSTANT (init) = 1;
- TREE_INVARIANT (init) = 1;
TREE_STATIC (init) = 1;
return init;
}
tree init = tinfo_base_init (ti, target);
TREE_CHAIN (init) = trail;
- init = build_constructor_from_list (NULL_TREE, init);
+ init = build_constructor_from_list (init_list_type_node, init);
TREE_CONSTANT (init) = 1;
- TREE_INVARIANT (init) = 1;
TREE_STATIC (init) = 1;
return init;
}
/* Combine offset and flags into one field. */
offset = fold_convert (offset_type, offset);
- offset = fold_build2 (LSHIFT_EXPR, offset_type, offset,
+ offset = fold_build2_loc (input_location,
+ LSHIFT_EXPR, offset_type, offset,
build_int_cst (offset_type, 8));
- offset = fold_build2 (BIT_IOR_EXPR, offset_type, offset,
+ offset = fold_build2_loc (input_location,
+ BIT_IOR_EXPR, offset_type, offset,
build_int_cst (offset_type, flags));
base_init = tree_cons (NULL_TREE, offset, base_init);
base_init = tree_cons (NULL_TREE, tinfo, base_init);
- base_init = build_constructor_from_list (NULL_TREE, base_init);
+ base_init = build_constructor_from_list (init_list_type_node, base_init);
base_inits = tree_cons (NULL_TREE, base_init, base_inits);
}
- base_inits = build_constructor_from_list (NULL_TREE, base_inits);
+ base_inits = build_constructor_from_list (init_list_type_node, base_inits);
base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
/* Prepend the number of bases. */
base_inits = tree_cons (NULL_TREE,
sprintf (pseudo_name + strlen (pseudo_name), "%d", tk - TK_FIXED);
/* First field is the pseudo type_info base class. */
- fields = build_decl (FIELD_DECL, NULL_TREE,
+ fields = build_decl (input_location,
+ FIELD_DECL, NULL_TREE,
VEC_index (tinfo_s, tinfo_descs,
TK_TYPE_INFO_TYPE)->type);
}
/* Create the pseudo type. */
- pseudo_type = make_aggr_type (RECORD_TYPE);
+ pseudo_type = make_class_type (RECORD_TYPE);
finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
TK_BASE_TYPE)->type,
array_domain);
- push_nested_namespace (abi_node);
+ push_abi_namespace ();
create_pseudo_type_info
(ix, "__vmi_class_type_info",
- build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_decl (FIELD_DECL, NULL_TREE, base_array),
+ build_decl (input_location,
+ FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (input_location,
+ FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (input_location,
+ FIELD_DECL, NULL_TREE, base_array),
NULL);
- pop_nested_namespace (abi_node);
+ pop_abi_namespace ();
break;
}
}
VEC_safe_grow (tinfo_s, gc, tinfo_descs, TK_FIXED);
- push_nested_namespace (abi_node);
+ push_abi_namespace ();
/* Create the internal type_info structure. This is used as a base for
the other structures. */
{
tree field, fields;
- field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
+ field = build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, const_ptr_type_node);
fields = field;
- field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
+ field = build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, const_string_type_node);
TREE_CHAIN (field) = fields;
fields = field;
ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE);
- ti->type = make_aggr_type (RECORD_TYPE);
+ ti->type = make_class_type (RECORD_TYPE);
ti->vtable = NULL_TREE;
ti->name = NULL_TREE;
finish_builtin_struct (ti->type, "__type_info_pseudo",
fields, NULL_TREE);
- TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
}
/* Fundamental type_info */
/* Single public non-virtual base class. Add pointer to base class.
This is really a descendant of __class_type_info. */
create_pseudo_type_info (TK_SI_CLASS_TYPE, "__si_class_type_info",
- build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
+ build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, type_info_ptr_type),
NULL);
/* Base class internal helper. Pointer to base type, offset to base,
{
tree field, fields;
- field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
+ field = build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, type_info_ptr_type);
fields = field;
- field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
+ field = build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, integer_types[itk_long]);
TREE_CHAIN (field) = fields;
fields = field;
ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE);
- ti->type = make_aggr_type (RECORD_TYPE);
+ ti->type = make_class_type (RECORD_TYPE);
ti->vtable = NULL_TREE;
ti->name = NULL_TREE;
finish_builtin_struct (ti->type, "__base_class_type_info_pseudo",
fields, NULL_TREE);
- TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
}
/* Pointer type_info. Adds two fields, qualification mask
and pointer to the pointed to type. This is really a descendant of
__pbase_type_info. */
create_pseudo_type_info (TK_POINTER_TYPE, "__pointer_type_info",
- build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
+ build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, type_info_ptr_type),
NULL);
/* Pointer to member data type_info. Add qualifications flags,
This is really a descendant of __pbase_type_info. */
create_pseudo_type_info (TK_POINTER_MEMBER_TYPE,
"__pointer_to_member_type_info",
- build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
- build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
+ build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, type_info_ptr_type),
+ build_decl (BUILTINS_LOCATION,
+ FIELD_DECL, NULL_TREE, type_info_ptr_type),
NULL);
- pop_nested_namespace (abi_node);
+ pop_abi_namespace ();
}
/* Emit the type_info descriptors which are guaranteed to be in the runtime
{
&void_type_node,
&boolean_type_node,
- &wchar_type_node,
+ &wchar_type_node, &char16_type_node, &char32_type_node,
&char_type_node, &signed_char_type_node, &unsigned_char_type_node,
&short_integer_type_node, &short_unsigned_type_node,
&integer_type_node, &unsigned_type_node,
&long_integer_type_node, &long_unsigned_type_node,
&long_long_integer_type_node, &long_long_unsigned_type_node,
&float_type_node, &double_type_node, &long_double_type_node,
+ &dfloat32_type_node, &dfloat64_type_node, &dfloat128_type_node,
0
};
int ix;
tree bltn_type, dtor;
- push_nested_namespace (abi_node);
+ push_abi_namespace ();
bltn_type = xref_tag (class_type,
get_identifier ("__fundamental_type_info"),
/*tag_scope=*/ts_current, false);
- pop_nested_namespace (abi_node);
+ pop_abi_namespace ();
if (!COMPLETE_TYPE_P (bltn_type))
return;
dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
init = get_pseudo_ti_init (type, get_pseudo_ti_index (type));
DECL_INITIAL (decl) = init;
mark_used (decl);
- finish_decl (decl, init, NULL_TREE);
+ cp_finish_decl (decl, init, false, NULL_TREE, 0);
return true;
}
else
OSDN Git Service
