static tree
ifnonnull (tree test, tree result)
{
return build3 (COND_EXPR, TREE_TYPE (result),
build2 (EQ_EXPR, boolean_type_node, test, integer_zero_node),
cp_convert (TREE_TYPE (result), integer_zero_node),
result);
}
iconv_t
iconv_open (const char *cp_to, const char *cp_from)
{
UniChar *ucp;
iconv_t conv;
uconv_attribute_t attr;
conv = (iconv_t) malloc (sizeof (struct _iconv_t));
if (conv == NULL)
{
errno = ENOMEM;
return (iconv_t)(-1);
}
ucp = (UniChar *) alloca ((strlen (cp_from) + 2 + 1) * sizeof (UniChar));
cp_convert (cp_from, ucp);
if (UniCreateUconvObject (ucp, &conv->from))
{
free (conv);
errno = EINVAL;
return (iconv_t)(-1);
}
ucp = (UniChar *) alloca ((strlen (cp_to) + 2 + 1) * sizeof (UniChar));
cp_convert (cp_to, ucp);
if (UniCreateUconvObject (ucp, &conv->to))
{
UniFreeUconvObject (conv->from);
free (conv);
errno = EINVAL;
return (iconv_t)(-1);
}
UniQueryUconvObject (conv->from, &attr, sizeof (attr), NULL, NULL, NULL);
/* Do not treat 0x7f as a control character
(don't understand what it exactly means but without it MBCS prefix
character detection sometimes could fail (when 0x7f is a prefix)).
And don't treat the string as a path (the docs also don't explain
what it exactly means, but I'm pretty sure converted texts will
mostly not be paths). */
attr.converttype &= ~(CVTTYPE_CTRL7F | CVTTYPE_PATH);
UniSetUconvObject (conv->from, &attr);
return conv;
}
tree
cp_convert_and_check (tree type, tree expr)
{
tree result;
if (TREE_TYPE (expr) == type)
return expr;
result = cp_convert (type, expr);
if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
warnings_for_convert_and_check (type, expr, result);
return result;
}
static void _log_write(FILE * stream, int codepage, const char *format, va_list args)
{
if (codepage) {
char buffer[MAXLENGTH];
unsigned char converted[MAXLENGTH];
vsnprintf(buffer, sizeof(buffer), format, args);
if (cp_convert(buffer, converted, MAXLENGTH, codepage) == 0) {
fputs((char *)converted, stream);
}
else {
/* fall back to non-converted output */
vfprintf(stream, format, args);
}
}
else {
vfprintf(stream, format, args);
}
}
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;
}
static tree
cp_convert_to_pointer (tree type, tree expr)
{
tree intype = TREE_TYPE (expr);
enum tree_code form;
tree rval;
if (intype == error_mark_node)
return error_mark_node;
if (MAYBE_CLASS_TYPE_P (intype))
{
intype = complete_type (intype);
if (!COMPLETE_TYPE_P (intype))
{
error ("can't convert from incomplete type %qT to %qT",
intype, type);
return error_mark_node;
}
rval = build_type_conversion (type, expr);
if (rval)
{
if (rval == error_mark_node)
error ("conversion of %qE from %qT to %qT is ambiguous",
expr, intype, type);
return rval;
}
}
/* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
if (TREE_CODE (type) == POINTER_TYPE
&& (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
|| VOID_TYPE_P (TREE_TYPE (type))))
{
if (TYPE_PTRMEMFUNC_P (intype)
|| TREE_CODE (intype) == METHOD_TYPE)
return convert_member_func_to_ptr (type, expr);
if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
return build_nop (type, expr);
intype = TREE_TYPE (expr);
}
if (expr == error_mark_node)
return error_mark_node;
form = TREE_CODE (intype);
if (POINTER_TYPE_P (intype))
{
intype = TYPE_MAIN_VARIANT (intype);
if (TYPE_MAIN_VARIANT (type) != intype
&& TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
&& TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
{
enum tree_code code = PLUS_EXPR;
tree binfo;
tree intype_class;
tree type_class;
bool same_p;
intype_class = TREE_TYPE (intype);
type_class = TREE_TYPE (type);
same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
TYPE_MAIN_VARIANT (type_class));
binfo = NULL_TREE;
/* Try derived to base conversion. */
if (!same_p)
binfo = lookup_base (intype_class, type_class, ba_check, NULL);
if (!same_p && !binfo)
{
/* Try base to derived conversion. */
binfo = lookup_base (type_class, intype_class, ba_check, NULL);
code = MINUS_EXPR;
}
if (binfo == error_mark_node)
return error_mark_node;
if (binfo || same_p)
{
if (binfo)
expr = build_base_path (code, expr, binfo, 0);
/* Add any qualifier conversions. */
return build_nop (type, expr);
}
}
if (TYPE_PTRMEMFUNC_P (type))
{
error ("cannot convert %qE from type %qT to type %qT",
expr, intype, type);
return error_mark_node;
}
return build_nop (type, expr);
}
else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
|| (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
return convert_ptrmem (type, expr, /*allow_inverse_p=*/false,
/*c_cast_p=*/false);
else if (TYPE_PTRMEMFUNC_P (intype))
{
if (!warn_pmf2ptr)
{
if (TREE_CODE (expr) == PTRMEM_CST)
return cp_convert_to_pointer (type,
PTRMEM_CST_MEMBER (expr));
else if (TREE_CODE (expr) == OFFSET_REF)
{
tree object = TREE_OPERAND (expr, 0);
return get_member_function_from_ptrfunc (&object,
TREE_OPERAND (expr, 1));
}
}
error ("cannot convert %qE from type %qT to type %qT",
expr, intype, type);
return error_mark_node;
}
if (integer_zerop (expr))
{
if (TYPE_PTRMEMFUNC_P (type))
return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0,
/*c_cast_p=*/false);
if (TYPE_PTRMEM_P (type))
{
/* A NULL pointer-to-member is represented by -1, not by
zero. */
expr = build_int_cst_type (type, -1);
}
else
expr = build_int_cst (type, 0);
return expr;
}
else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form))
{
error ("invalid conversion from %qT to %qT", intype, type);
return error_mark_node;
}
if (INTEGRAL_CODE_P (form))
{
if (TYPE_PRECISION (intype) == POINTER_SIZE)
return build1 (CONVERT_EXPR, type, expr);
expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr);
/* Modes may be different but sizes should be the same. There
is supposed to be some integral type that is the same width
as a pointer. */
gcc_assert (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
== GET_MODE_SIZE (TYPE_MODE (type)));
return convert_to_pointer (type, expr);
}
if (type_unknown_p (expr))
return instantiate_type (type, expr, tf_warning_or_error);
error ("cannot convert %qE from type %qT to type %qT",
expr, intype, type);
return error_mark_node;
}
static tree
build_dynamic_cast_1 (tree type, tree expr)
{
enum tree_code tc = TREE_CODE (type);
tree exprtype = TREE_TYPE (expr);
tree dcast_fn;
tree old_expr = expr;
const char *errstr = NULL;
/* 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 (! IS_AGGR_TYPE (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 (! IS_AGGR_TYPE (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
{
/* Apply trivial conversion T -> T& for dereferenced ptrs. */
exprtype = build_reference_type (exprtype);
expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
LOOKUP_NORMAL, NULL_TREE);
/* 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)))
{
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;
}
}
/* 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 = non_lvalue (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, elems;
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 ();
warning ("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)
{
warning ("dynamic_cast of %q#D to %q#T can never succeed",
op, type);
retval = build_int_cst (type, 0);
return retval;
}
}
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 = build_unary_op (ADDR_EXPR, td2, 0);
td3 = get_tinfo_decl (static_type);
mark_used (td3);
td3 = build_unary_op (ADDR_EXPR, td3, 0);
/* 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 = build_unary_op (ADDR_EXPR, expr1, 0);
elems = tree_cons
(NULL_TREE, expr1, tree_cons
(NULL_TREE, td3, tree_cons
(NULL_TREE, td2, tree_cons
(NULL_TREE, boff, NULL_TREE))));
dcast_fn = dynamic_cast_node;
if (!dcast_fn)
{
tree tmp;
tree tinfo_ptr;
tree ns = abi_node;
const char *name;
push_nested_namespace (ns);
tinfo_ptr = xref_tag (class_type,
get_identifier ("__class_type_info"),
/* APPLE LOCAL 4184203 */
/*tag_scope=*/ts_global, false);
tinfo_ptr = build_pointer_type
(build_qualified_type
(tinfo_ptr, TYPE_QUAL_CONST));
name = "__dynamic_cast";
tmp = tree_cons
(NULL_TREE, const_ptr_type_node, tree_cons
(NULL_TREE, tinfo_ptr, tree_cons
(NULL_TREE, tinfo_ptr, tree_cons
(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);
dynamic_cast_node = dcast_fn;
}
result = build_cxx_call (dcast_fn, elems);
if (tc == REFERENCE_TYPE)
{
tree bad = throw_bad_cast ();
result = save_expr (result);
return build3 (COND_EXPR, type, result, result, bad);
}
/* Now back to the type we want from a void*. */
result = cp_convert (type, result);
return ifnonnull (expr, result);
}
}
else
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);
return error_mark_node;
}
void
use_thunk (tree thunk_fndecl, bool emit_p)
{
tree a, t, function, alias;
tree virtual_offset;
HOST_WIDE_INT fixed_offset, virtual_value;
bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
/* We should have called finish_thunk to give it a name. */
gcc_assert (DECL_NAME (thunk_fndecl));
/* We should never be using an alias, always refer to the
aliased thunk. */
gcc_assert (!THUNK_ALIAS (thunk_fndecl));
if (TREE_ASM_WRITTEN (thunk_fndecl))
return;
function = THUNK_TARGET (thunk_fndecl);
if (DECL_RESULT (thunk_fndecl))
/* We already turned this thunk into an ordinary function.
There's no need to process this thunk again. */
return;
if (DECL_THUNK_P (function))
/* The target is itself a thunk, process it now. */
use_thunk (function, emit_p);
/* Thunks are always addressable; they only appear in vtables. */
TREE_ADDRESSABLE (thunk_fndecl) = 1;
/* Figure out what function is being thunked to. It's referenced in
this translation unit. */
TREE_ADDRESSABLE (function) = 1;
mark_used (function);
if (!emit_p)
return;
if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
alias = make_alias_for_thunk (function);
else
alias = function;
fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
if (virtual_offset)
{
if (!this_adjusting)
virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
gcc_assert (virtual_value);
}
else
virtual_value = 0;
/* And, if we need to emit the thunk, it's used. */
mark_used (thunk_fndecl);
/* This thunk is actually defined. */
DECL_EXTERNAL (thunk_fndecl) = 0;
/* The linkage of the function may have changed. FIXME in linkage
rewrite. */
TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
= DECL_VISIBILITY_SPECIFIED (function);
if (DECL_ONE_ONLY (function))
make_decl_one_only (thunk_fndecl);
if (flag_syntax_only)
{
TREE_ASM_WRITTEN (thunk_fndecl) = 1;
return;
}
push_to_top_level ();
if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
&& targetm.have_named_sections)
{
resolve_unique_section (function, 0, flag_function_sections);
if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
{
resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
/* Output the thunk into the same section as function. */
DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
}
}
/* The back-end expects DECL_INITIAL to contain a BLOCK, so we
create one. */
DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
/* Set up cloned argument trees for the thunk. */
t = NULL_TREE;
for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
{
tree x = copy_node (a);
TREE_CHAIN (x) = t;
DECL_CONTEXT (x) = thunk_fndecl;
SET_DECL_RTL (x, NULL_RTX);
DECL_HAS_VALUE_EXPR_P (x) = 0;
t = x;
}
a = nreverse (t);
DECL_ARGUMENTS (thunk_fndecl) = a;
BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a;
if (this_adjusting
&& targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
virtual_value, alias))
{
const char *fnname;
current_function_decl = thunk_fndecl;
DECL_RESULT (thunk_fndecl)
= build_decl (RESULT_DECL, 0, integer_type_node);
fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
init_function_start (thunk_fndecl);
current_function_is_thunk = 1;
assemble_start_function (thunk_fndecl, fnname);
targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
fixed_offset, virtual_value, alias);
assemble_end_function (thunk_fndecl, fnname);
init_insn_lengths ();
current_function_decl = 0;
cfun = 0;
TREE_ASM_WRITTEN (thunk_fndecl) = 1;
}
else
{
/* If this is a covariant thunk, or we don't have the necessary
code for efficient thunks, generate a thunk function that
just makes a call to the real function. Unfortunately, this
doesn't work for varargs. */
if (varargs_function_p (function))
error ("generic thunk code fails for method %q#D which uses %<...%>",
function);
DECL_RESULT (thunk_fndecl) = NULL_TREE;
start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
/* We don't bother with a body block for thunks. */
/* There's no need to check accessibility inside the thunk body. */
push_deferring_access_checks (dk_no_check);
t = a;
if (this_adjusting)
t = thunk_adjust (t, /*this_adjusting=*/1,
fixed_offset, virtual_offset);
/* Build up the call to the real function. */
t = tree_cons (NULL_TREE, t, NULL_TREE);
for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
t = tree_cons (NULL_TREE, a, t);
t = nreverse (t);
t = build_call (alias, t);
CALL_FROM_THUNK_P (t) = 1;
if (VOID_TYPE_P (TREE_TYPE (t)))
finish_expr_stmt (t);
else
{
if (!this_adjusting)
{
tree cond = NULL_TREE;
if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
{
/* If the return type is a pointer, we need to
protect against NULL. We know there will be an
adjustment, because that's why we're emitting a
thunk. */
t = save_expr (t);
cond = cp_convert (boolean_type_node, t);
}
t = thunk_adjust (t, /*this_adjusting=*/0,
fixed_offset, virtual_offset);
if (cond)
t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
cp_convert (TREE_TYPE (t), integer_zero_node));
}
if (IS_AGGR_TYPE (TREE_TYPE (t)))
t = build_cplus_new (TREE_TYPE (t), t);
finish_return_stmt (t);
}
/* Since we want to emit the thunk, we explicitly mark its name as
referenced. */
mark_decl_referenced (thunk_fndecl);
/* But we don't want debugging information about it. */
DECL_IGNORED_P (thunk_fndecl) = 1;
/* Re-enable access control. */
pop_deferring_access_checks ();
thunk_fndecl = finish_function (0);
tree_lowering_passes (thunk_fndecl);
expand_body (thunk_fndecl);
}
pop_from_top_level ();
}
static tree
cp_convert_to_pointer (tree type, tree expr, bool force)
{
tree intype = TREE_TYPE (expr);
enum tree_code form;
tree rval;
if (intype == error_mark_node)
return error_mark_node;
if (IS_AGGR_TYPE (intype))
{
intype = complete_type (intype);
if (!COMPLETE_TYPE_P (intype))
{
error ("can't convert from incomplete type `%T' to `%T'",
intype, type);
return error_mark_node;
}
rval = build_type_conversion (type, expr);
if (rval)
{
if (rval == error_mark_node)
error ("conversion of `%E' from `%T' to `%T' is ambiguous",
expr, intype, type);
return rval;
}
}
/* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
if (TREE_CODE (type) == POINTER_TYPE
&& (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
|| VOID_TYPE_P (TREE_TYPE (type))))
{
/* Allow an implicit this pointer for pointer to member
functions. */
if (TYPE_PTRMEMFUNC_P (intype))
{
if (pedantic || warn_pmf2ptr)
pedwarn ("converting from `%T' to `%T'", intype, type);
if (TREE_CODE (expr) == PTRMEM_CST)
expr = build_address (PTRMEM_CST_MEMBER (expr));
else
{
tree decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype),
0);
decl = build_address (decl);
expr = get_member_function_from_ptrfunc (&decl, expr);
}
}
else if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
{
if (pedantic || warn_pmf2ptr)
pedwarn ("converting from `%T' to `%T'", intype, type);
expr = build_addr_func (expr);
}
if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
return build_nop (type, expr);
intype = TREE_TYPE (expr);
}
if (expr == error_mark_node)
return error_mark_node;
form = TREE_CODE (intype);
if (POINTER_TYPE_P (intype))
{
intype = TYPE_MAIN_VARIANT (intype);
if (TYPE_MAIN_VARIANT (type) != intype
&& TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
&& IS_AGGR_TYPE (TREE_TYPE (type))
&& IS_AGGR_TYPE (TREE_TYPE (intype))
&& TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
{
enum tree_code code = PLUS_EXPR;
tree binfo;
tree intype_class;
tree type_class;
bool same_p;
intype_class = TREE_TYPE (intype);
type_class = TREE_TYPE (type);
same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
TYPE_MAIN_VARIANT (type_class));
binfo = NULL_TREE;
/* Try derived to base conversion. */
if (!same_p)
binfo = lookup_base (intype_class, type_class, ba_check, NULL);
if (!same_p && !binfo)
{
/* Try base to derived conversion. */
binfo = lookup_base (type_class, intype_class, ba_check, NULL);
code = MINUS_EXPR;
}
if (binfo == error_mark_node)
return error_mark_node;
if (binfo || same_p)
{
if (binfo)
expr = build_base_path (code, expr, binfo, 0);
/* Add any qualifier conversions. */
return build_nop (type, expr);
}
}
if (TYPE_PTRMEMFUNC_P (type))
{
error ("cannot convert `%E' from type `%T' to type `%T'",
expr, intype, type);
return error_mark_node;
}
return build_nop (type, expr);
}
else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
{
tree b1;
tree b2;
tree binfo;
enum tree_code code = PLUS_EXPR;
base_kind bk;
b1 = TYPE_PTRMEM_CLASS_TYPE (type);
b2 = TYPE_PTRMEM_CLASS_TYPE (intype);
binfo = lookup_base (b1, b2, ba_check, &bk);
if (!binfo)
{
binfo = lookup_base (b2, b1, ba_check, &bk);
code = MINUS_EXPR;
}
if (binfo == error_mark_node)
return error_mark_node;
if (bk == bk_via_virtual)
{
if (force)
warning ("pointer to member cast from `%T' to `%T' is via virtual base",
intype, type);
else
{
error ("pointer to member cast from `%T' to `%T' is via virtual base",
intype, type);
return error_mark_node;
}
/* This is a reinterpret cast, whose result is unspecified.
We choose to do nothing. */
return build1 (NOP_EXPR, type, expr);
}
if (TREE_CODE (expr) == PTRMEM_CST)
expr = cplus_expand_constant (expr);
if (binfo && !integer_zerop (BINFO_OFFSET (binfo)))
expr = size_binop (code,
build_nop (sizetype, expr),
BINFO_OFFSET (binfo));
return build_nop (type, expr);
}
else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))
return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
else if (TYPE_PTRMEMFUNC_P (intype))
{
if (!warn_pmf2ptr)
{
if (TREE_CODE (expr) == PTRMEM_CST)
return cp_convert_to_pointer (type,
PTRMEM_CST_MEMBER (expr),
force);
else if (TREE_CODE (expr) == OFFSET_REF)
{
tree object = TREE_OPERAND (expr, 0);
return get_member_function_from_ptrfunc (&object,
TREE_OPERAND (expr, 1));
}
}
error ("cannot convert `%E' from type `%T' to type `%T'",
expr, intype, type);
return error_mark_node;
}
if (integer_zerop (expr))
{
if (TYPE_PTRMEMFUNC_P (type))
return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
if (TYPE_PTRMEM_P (type))
/* A NULL pointer-to-member is represented by -1, not by
zero. */
expr = build_int_2 (-1, -1);
else
expr = build_int_2 (0, 0);
TREE_TYPE (expr) = type;
/* Fix up the representation of -1 if appropriate. */
force_fit_type (expr, 0);
return expr;
}
else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form))
{
error ("invalid conversion from '%T' to '%T'", intype, type);
return error_mark_node;
}
if (INTEGRAL_CODE_P (form))
{
if (TYPE_PRECISION (intype) == POINTER_SIZE)
return build1 (CONVERT_EXPR, type, expr);
expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr);
/* Modes may be different but sizes should be the same. */
if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
!= GET_MODE_SIZE (TYPE_MODE (type)))
/* There is supposed to be some integral type
that is the same width as a pointer. */
abort ();
return convert_to_pointer (type, expr);
}
if (type_unknown_p (expr))
return instantiate_type (type, expr, tf_error | tf_warning);
error ("cannot convert `%E' from type `%T' to type `%T'",
expr, intype, type);
return error_mark_node;
}
