1142 lines
34 KiB
C
1142 lines
34 KiB
C
/* Language-level data type conversion for GNU C++.
|
||
Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
|
||
Hacked by Michael Tiemann (tiemann@cygnus.com)
|
||
|
||
This file is part of GNU CC.
|
||
|
||
GNU CC 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)
|
||
any later version.
|
||
|
||
GNU CC 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 GNU CC; see the file COPYING. If not, write to
|
||
the Free Software Foundation, 59 Temple Place - Suite 330,
|
||
Boston, MA 02111-1307, USA. */
|
||
|
||
|
||
/* This file contains the functions for converting C expressions
|
||
to different data types. The only entry point is `convert'.
|
||
Every language front end must have a `convert' function
|
||
but what kind of conversions it does will depend on the language. */
|
||
|
||
#include "config.h"
|
||
#include "system.h"
|
||
#include "tree.h"
|
||
#include "flags.h"
|
||
#include "cp-tree.h"
|
||
#include "convert.h"
|
||
#include "toplev.h"
|
||
#include "decl.h"
|
||
|
||
static tree cp_convert_to_pointer PROTO((tree, tree));
|
||
static tree convert_to_pointer_force PROTO((tree, tree));
|
||
static tree build_up_reference PROTO((tree, tree, int));
|
||
|
||
/* Change of width--truncation and extension of integers or reals--
|
||
is represented with NOP_EXPR. Proper functioning of many things
|
||
assumes that no other conversions can be NOP_EXPRs.
|
||
|
||
Conversion between integer and pointer is represented with CONVERT_EXPR.
|
||
Converting integer to real uses FLOAT_EXPR
|
||
and real to integer uses FIX_TRUNC_EXPR.
|
||
|
||
Here is a list of all the functions that assume that widening and
|
||
narrowing is always done with a NOP_EXPR:
|
||
In convert.c, convert_to_integer.
|
||
In c-typeck.c, build_binary_op_nodefault (boolean ops),
|
||
and truthvalue_conversion.
|
||
In expr.c: expand_expr, for operands of a MULT_EXPR.
|
||
In fold-const.c: fold.
|
||
In tree.c: get_narrower and get_unwidened.
|
||
|
||
C++: in multiple-inheritance, converting between pointers may involve
|
||
adjusting them by a delta stored within the class definition. */
|
||
|
||
/* Subroutines of `convert'. */
|
||
|
||
/* if converting pointer to pointer
|
||
if dealing with classes, check for derived->base or vice versa
|
||
else if dealing with method pointers, delegate
|
||
else convert blindly
|
||
else if converting class, pass off to build_type_conversion
|
||
else try C-style pointer conversion */
|
||
|
||
static tree
|
||
cp_convert_to_pointer (type, expr)
|
||
tree type, expr;
|
||
{
|
||
register tree intype = TREE_TYPE (expr);
|
||
register enum tree_code form;
|
||
tree rval;
|
||
|
||
if (IS_AGGR_TYPE (intype))
|
||
{
|
||
intype = complete_type (intype);
|
||
if (TYPE_SIZE (intype) == NULL_TREE)
|
||
{
|
||
cp_error ("can't convert from incomplete type `%T' to `%T'",
|
||
intype, type);
|
||
return error_mark_node;
|
||
}
|
||
|
||
rval = build_type_conversion (type, expr, 1);
|
||
if (rval)
|
||
{
|
||
if (rval == error_mark_node)
|
||
cp_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
|
||
|| TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node))
|
||
{
|
||
/* Allow an implicit this pointer for pointer to member
|
||
functions. */
|
||
if (TYPE_PTRMEMFUNC_P (intype))
|
||
{
|
||
tree fntype = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (intype));
|
||
tree decl = maybe_dummy_object (TYPE_METHOD_BASETYPE (fntype), 0);
|
||
expr = build (OFFSET_REF, fntype, decl, expr);
|
||
}
|
||
|
||
if (TREE_CODE (expr) == OFFSET_REF
|
||
&& TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
|
||
expr = resolve_offset_ref (expr);
|
||
if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
|
||
expr = build_addr_func (expr);
|
||
if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
|
||
{
|
||
if (TREE_CODE (TREE_TYPE (TREE_TYPE (expr))) == METHOD_TYPE)
|
||
if (pedantic || warn_pmf2ptr)
|
||
cp_pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
|
||
type);
|
||
return build1 (NOP_EXPR, type, expr);
|
||
}
|
||
intype = TREE_TYPE (expr);
|
||
}
|
||
|
||
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
|
||
/* If EXPR is NULL, then we don't need to do any arithmetic
|
||
to convert it:
|
||
|
||
[conv.ptr]
|
||
|
||
The null pointer value is converted to the null pointer
|
||
value of the destination type. */
|
||
&& !integer_zerop (expr))
|
||
{
|
||
enum tree_code code = PLUS_EXPR;
|
||
tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
|
||
if (binfo == error_mark_node)
|
||
return error_mark_node;
|
||
if (binfo == NULL_TREE)
|
||
{
|
||
binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
|
||
if (binfo == error_mark_node)
|
||
return error_mark_node;
|
||
code = MINUS_EXPR;
|
||
}
|
||
if (binfo)
|
||
{
|
||
if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
|
||
|| TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
|
||
|| ! BINFO_OFFSET_ZEROP (binfo))
|
||
{
|
||
/* Need to get the path we took. */
|
||
tree path;
|
||
|
||
if (code == PLUS_EXPR)
|
||
get_base_distance (TREE_TYPE (type), TREE_TYPE (intype),
|
||
0, &path);
|
||
else
|
||
get_base_distance (TREE_TYPE (intype), TREE_TYPE (type),
|
||
0, &path);
|
||
return build_vbase_path (code, type, expr, path, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
|
||
{
|
||
tree b1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (type));
|
||
tree b2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (intype));
|
||
tree binfo = get_binfo (b2, b1, 1);
|
||
enum tree_code code = PLUS_EXPR;
|
||
|
||
if (binfo == NULL_TREE)
|
||
{
|
||
binfo = get_binfo (b1, b2, 1);
|
||
code = MINUS_EXPR;
|
||
}
|
||
|
||
if (binfo == error_mark_node)
|
||
return error_mark_node;
|
||
if (binfo && ! TREE_VIA_VIRTUAL (binfo))
|
||
expr = size_binop (code, expr, BINFO_OFFSET (binfo));
|
||
}
|
||
else if (TYPE_PTRMEMFUNC_P (type))
|
||
{
|
||
cp_error ("cannot convert `%E' from type `%T' to type `%T'",
|
||
expr, intype, type);
|
||
return error_mark_node;
|
||
}
|
||
|
||
rval = build1 (NOP_EXPR, type, expr);
|
||
TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
|
||
return rval;
|
||
}
|
||
else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))
|
||
return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 1);
|
||
else if (TYPE_PTRMEMFUNC_P (intype))
|
||
{
|
||
cp_error ("cannot convert `%E' from type `%T' to type `%T'",
|
||
expr, intype, type);
|
||
return error_mark_node;
|
||
}
|
||
|
||
my_friendly_assert (form != OFFSET_TYPE, 186);
|
||
|
||
if (TYPE_LANG_SPECIFIC (intype)
|
||
&& (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
|
||
return convert_to_pointer (type, build_optr_ref (expr));
|
||
|
||
if (integer_zerop (expr))
|
||
{
|
||
if (TYPE_PTRMEMFUNC_P (type))
|
||
return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
|
||
expr = build_int_2 (0, 0);
|
||
TREE_TYPE (expr) = type;
|
||
return expr;
|
||
}
|
||
|
||
if (INTEGRAL_CODE_P (form))
|
||
{
|
||
if (TYPE_PRECISION (intype) == POINTER_SIZE)
|
||
return build1 (CONVERT_EXPR, type, expr);
|
||
expr = cp_convert (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, 1);
|
||
|
||
cp_error ("cannot convert `%E' from type `%T' to type `%T'",
|
||
expr, intype, type);
|
||
return error_mark_node;
|
||
}
|
||
|
||
/* Like convert, except permit conversions to take place which
|
||
are not normally allowed due to access restrictions
|
||
(such as conversion from sub-type to private super-type). */
|
||
|
||
static tree
|
||
convert_to_pointer_force (type, expr)
|
||
tree type, expr;
|
||
{
|
||
register tree intype = TREE_TYPE (expr);
|
||
register enum tree_code form = TREE_CODE (intype);
|
||
|
||
if (integer_zerop (expr))
|
||
{
|
||
expr = build_int_2 (0, 0);
|
||
TREE_TYPE (expr) = type;
|
||
return expr;
|
||
}
|
||
|
||
/* Convert signature pointer/reference to `void *' first. */
|
||
if (form == RECORD_TYPE
|
||
&& (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
|
||
{
|
||
expr = build_optr_ref (expr);
|
||
intype = TREE_TYPE (expr);
|
||
form = TREE_CODE (intype);
|
||
}
|
||
|
||
if (form == POINTER_TYPE)
|
||
{
|
||
intype = TYPE_MAIN_VARIANT (intype);
|
||
|
||
if (TYPE_MAIN_VARIANT (type) != intype
|
||
&& 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 path;
|
||
int distance = get_base_distance (TREE_TYPE (type),
|
||
TREE_TYPE (intype), 0, &path);
|
||
if (distance == -2)
|
||
{
|
||
ambig:
|
||
cp_error ("type `%T' is ambiguous baseclass of `%s'",
|
||
TREE_TYPE (type),
|
||
TYPE_NAME_STRING (TREE_TYPE (intype)));
|
||
return error_mark_node;
|
||
}
|
||
if (distance == -1)
|
||
{
|
||
distance = get_base_distance (TREE_TYPE (intype),
|
||
TREE_TYPE (type), 0, &path);
|
||
if (distance == -2)
|
||
goto ambig;
|
||
if (distance < 0)
|
||
/* Doesn't need any special help from us. */
|
||
return build1 (NOP_EXPR, type, expr);
|
||
|
||
code = MINUS_EXPR;
|
||
}
|
||
return build_vbase_path (code, type, expr, path, 0);
|
||
}
|
||
}
|
||
|
||
return cp_convert_to_pointer (type, expr);
|
||
}
|
||
|
||
/* We are passing something to a function which requires a reference.
|
||
The type we are interested in is in TYPE. The initial
|
||
value we have to begin with is in ARG.
|
||
|
||
FLAGS controls how we manage access checking.
|
||
DIRECT_BIND in FLAGS controls how any temporaries are generated. */
|
||
|
||
static tree
|
||
build_up_reference (type, arg, flags)
|
||
tree type, arg;
|
||
int flags;
|
||
{
|
||
tree rval;
|
||
tree argtype = TREE_TYPE (arg);
|
||
tree target_type = TREE_TYPE (type);
|
||
|
||
my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
|
||
|
||
if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg))
|
||
{
|
||
tree targ = arg;
|
||
if (toplevel_bindings_p ())
|
||
arg = get_temp_name (argtype, 1);
|
||
else
|
||
{
|
||
arg = pushdecl (build_decl (VAR_DECL, NULL_TREE, argtype));
|
||
DECL_ARTIFICIAL (arg) = 1;
|
||
}
|
||
DECL_INITIAL (arg) = targ;
|
||
cp_finish_decl (arg, targ, NULL_TREE, 0,
|
||
LOOKUP_ONLYCONVERTING|DIRECT_BIND);
|
||
}
|
||
else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
|
||
{
|
||
tree slot = build_decl (VAR_DECL, NULL_TREE, argtype);
|
||
DECL_ARTIFICIAL (slot) = 1;
|
||
arg = build (TARGET_EXPR, argtype, slot, arg, NULL_TREE, NULL_TREE);
|
||
TREE_SIDE_EFFECTS (arg) = 1;
|
||
}
|
||
|
||
/* If we had a way to wrap this up, and say, if we ever needed it's
|
||
address, transform all occurrences of the register, into a memory
|
||
reference we could win better. */
|
||
rval = build_unary_op (ADDR_EXPR, arg, 1);
|
||
if (rval == error_mark_node)
|
||
return error_mark_node;
|
||
|
||
if ((flags & LOOKUP_PROTECT)
|
||
&& TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
|
||
&& IS_AGGR_TYPE (argtype)
|
||
&& IS_AGGR_TYPE (target_type))
|
||
{
|
||
/* We go through get_binfo for the access control. */
|
||
tree binfo = get_binfo (target_type, argtype, 1);
|
||
if (binfo == error_mark_node)
|
||
return error_mark_node;
|
||
if (binfo == NULL_TREE)
|
||
return error_not_base_type (target_type, argtype);
|
||
rval = convert_pointer_to_real (binfo, rval);
|
||
}
|
||
else
|
||
rval
|
||
= convert_to_pointer_force (build_pointer_type (target_type), rval);
|
||
rval = build1 (NOP_EXPR, type, rval);
|
||
TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
|
||
return rval;
|
||
}
|
||
|
||
/* For C++: Only need to do one-level references, but cannot
|
||
get tripped up on signed/unsigned differences.
|
||
|
||
DECL is either NULL_TREE or the _DECL node for a reference that is being
|
||
initialized. It can be error_mark_node if we don't know the _DECL but
|
||
we know it's an initialization. */
|
||
|
||
tree
|
||
convert_to_reference (reftype, expr, convtype, flags, decl)
|
||
tree reftype, expr;
|
||
int convtype, flags;
|
||
tree decl;
|
||
{
|
||
register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
|
||
register tree intype = TREE_TYPE (expr);
|
||
tree rval = NULL_TREE;
|
||
tree rval_as_conversion = NULL_TREE;
|
||
int i;
|
||
|
||
if (TREE_CODE (type) == FUNCTION_TYPE && intype == unknown_type_node)
|
||
{
|
||
expr = instantiate_type (type, expr,
|
||
(flags & LOOKUP_COMPLAIN) != 0);
|
||
if (expr == error_mark_node)
|
||
return error_mark_node;
|
||
|
||
intype = TREE_TYPE (expr);
|
||
}
|
||
|
||
if (TREE_CODE (intype) == REFERENCE_TYPE)
|
||
my_friendly_abort (364);
|
||
|
||
intype = TYPE_MAIN_VARIANT (intype);
|
||
|
||
i = comp_target_types (type, intype, 0);
|
||
|
||
if (i <= 0 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype)
|
||
&& ! (flags & LOOKUP_NO_CONVERSION))
|
||
{
|
||
/* Look for a user-defined conversion to lvalue that we can use. */
|
||
|
||
rval_as_conversion
|
||
= build_type_conversion (reftype, expr, 1);
|
||
|
||
if (rval_as_conversion && rval_as_conversion != error_mark_node
|
||
&& real_lvalue_p (rval_as_conversion))
|
||
{
|
||
expr = rval_as_conversion;
|
||
rval_as_conversion = NULL_TREE;
|
||
intype = type;
|
||
i = 1;
|
||
}
|
||
}
|
||
|
||
if (((convtype & CONV_STATIC) && i == -1)
|
||
|| ((convtype & CONV_IMPLICIT) && i == 1))
|
||
{
|
||
if (flags & LOOKUP_COMPLAIN)
|
||
{
|
||
tree ttl = TREE_TYPE (reftype);
|
||
tree ttr = lvalue_type (expr);
|
||
|
||
/* [dcl.init.ref] says that if an rvalue is used to
|
||
initialize a reference, then the reference must be to a
|
||
non-volatile const type. */
|
||
if (! real_lvalue_p (expr)
|
||
&& !CP_TYPE_CONST_NON_VOLATILE_P (ttl))
|
||
{
|
||
const char *msg;
|
||
|
||
if (CP_TYPE_VOLATILE_P (ttl) && decl)
|
||
msg = "initialization of volatile reference type `%#T'";
|
||
else if (CP_TYPE_VOLATILE_P (ttl))
|
||
msg = "conversion to volatile reference type `%#T'";
|
||
else if (decl)
|
||
msg = "initialization of non-const reference type `%#T'";
|
||
else
|
||
msg = "conversion to non-const reference type `%#T'";
|
||
|
||
cp_pedwarn (msg, reftype);
|
||
cp_pedwarn ("from rvalue of type `%T'", intype);
|
||
}
|
||
else if (! (convtype & CONV_CONST)
|
||
&& !at_least_as_qualified_p (ttl, ttr))
|
||
cp_pedwarn ("conversion from `%T' to `%T' discards qualifiers",
|
||
ttr, reftype);
|
||
}
|
||
|
||
return build_up_reference (reftype, expr, flags);
|
||
}
|
||
else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
|
||
{
|
||
/* When casting an lvalue to a reference type, just convert into
|
||
a pointer to the new type and deference it. This is allowed
|
||
by San Diego WP section 5.2.9 paragraph 12, though perhaps it
|
||
should be done directly (jason). (int &)ri ---> *(int*)&ri */
|
||
|
||
/* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
|
||
meant. */
|
||
if (TREE_CODE (intype) == POINTER_TYPE
|
||
&& (comptypes (TREE_TYPE (intype), type,
|
||
COMPARE_BASE | COMPARE_RELAXED )))
|
||
cp_warning ("casting `%T' to `%T' does not dereference pointer",
|
||
intype, reftype);
|
||
|
||
rval = build_unary_op (ADDR_EXPR, expr, 0);
|
||
if (rval != error_mark_node)
|
||
rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
|
||
rval, 0);
|
||
if (rval != error_mark_node)
|
||
rval = build1 (NOP_EXPR, reftype, rval);
|
||
}
|
||
else
|
||
{
|
||
rval = convert_for_initialization (NULL_TREE, type, expr, flags,
|
||
"converting", 0, 0);
|
||
if (rval == NULL_TREE || rval == error_mark_node)
|
||
return rval;
|
||
rval = build_up_reference (reftype, rval, flags);
|
||
|
||
if (rval && ! CP_TYPE_CONST_P (TREE_TYPE (reftype)))
|
||
cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
|
||
reftype, intype);
|
||
}
|
||
|
||
if (rval)
|
||
{
|
||
/* If we found a way to convert earlier, then use it. */
|
||
return rval;
|
||
}
|
||
|
||
my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
|
||
|
||
if (flags & LOOKUP_COMPLAIN)
|
||
cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
|
||
|
||
if (flags & LOOKUP_SPECULATIVELY)
|
||
return NULL_TREE;
|
||
|
||
return error_mark_node;
|
||
}
|
||
|
||
/* We are using a reference VAL for its value. Bash that reference all the
|
||
way down to its lowest form. */
|
||
|
||
tree
|
||
convert_from_reference (val)
|
||
tree val;
|
||
{
|
||
tree type = TREE_TYPE (val);
|
||
|
||
if (TREE_CODE (type) == OFFSET_TYPE)
|
||
type = TREE_TYPE (type);
|
||
if (TREE_CODE (type) == REFERENCE_TYPE)
|
||
return build_indirect_ref (val, NULL_PTR);
|
||
return val;
|
||
}
|
||
|
||
/* Call this when we know (for any reason) that expr is not, in fact,
|
||
zero. This routine is like convert_pointer_to, but it pays
|
||
attention to which specific instance of what type we want to
|
||
convert to. This routine should eventually become
|
||
convert_to_pointer after all references to convert_to_pointer
|
||
are removed. */
|
||
|
||
tree
|
||
convert_pointer_to_real (binfo, expr)
|
||
tree binfo, expr;
|
||
{
|
||
register tree intype = TREE_TYPE (expr);
|
||
tree ptr_type;
|
||
tree type, rval;
|
||
|
||
if (intype == error_mark_node)
|
||
return error_mark_node;
|
||
|
||
if (TREE_CODE (binfo) == TREE_VEC)
|
||
type = BINFO_TYPE (binfo);
|
||
else if (IS_AGGR_TYPE (binfo))
|
||
{
|
||
type = binfo;
|
||
}
|
||
else
|
||
{
|
||
type = binfo;
|
||
binfo = NULL_TREE;
|
||
}
|
||
|
||
ptr_type = cp_build_qualified_type (type,
|
||
CP_TYPE_QUALS (TREE_TYPE (intype)));
|
||
ptr_type = build_pointer_type (ptr_type);
|
||
if (same_type_p (ptr_type, TYPE_MAIN_VARIANT (intype)))
|
||
return expr;
|
||
|
||
my_friendly_assert (!integer_zerop (expr), 191);
|
||
|
||
intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
|
||
if (TREE_CODE (type) == RECORD_TYPE
|
||
&& TREE_CODE (intype) == RECORD_TYPE
|
||
&& type != intype)
|
||
{
|
||
tree path;
|
||
int distance
|
||
= get_base_distance (binfo, intype, 0, &path);
|
||
|
||
/* This function shouldn't be called with unqualified arguments
|
||
but if it is, give them an error message that they can read. */
|
||
if (distance < 0)
|
||
{
|
||
cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
|
||
intype, type);
|
||
|
||
if (distance == -2)
|
||
cp_error ("because `%T' is an ambiguous base class", type);
|
||
return error_mark_node;
|
||
}
|
||
|
||
return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
|
||
}
|
||
rval = build1 (NOP_EXPR, ptr_type,
|
||
TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
|
||
TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
|
||
return rval;
|
||
}
|
||
|
||
/* Call this when we know (for any reason) that expr is
|
||
not, in fact, zero. This routine gets a type out of the first
|
||
argument and uses it to search for the type to convert to. If there
|
||
is more than one instance of that type in the expr, the conversion is
|
||
ambiguous. This routine should eventually go away, and all
|
||
callers should use convert_to_pointer_real. */
|
||
|
||
tree
|
||
convert_pointer_to (binfo, expr)
|
||
tree binfo, expr;
|
||
{
|
||
tree type;
|
||
|
||
if (TREE_CODE (binfo) == TREE_VEC)
|
||
type = BINFO_TYPE (binfo);
|
||
else if (IS_AGGR_TYPE (binfo))
|
||
type = binfo;
|
||
else
|
||
type = binfo;
|
||
return convert_pointer_to_real (type, expr);
|
||
}
|
||
|
||
/* C++ conversions, preference to static cast conversions. */
|
||
|
||
tree
|
||
cp_convert (type, expr)
|
||
tree type, expr;
|
||
{
|
||
return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL);
|
||
}
|
||
|
||
/* Conversion...
|
||
|
||
FLAGS indicates how we should behave. */
|
||
|
||
tree
|
||
ocp_convert (type, expr, convtype, flags)
|
||
tree type, expr;
|
||
int convtype, flags;
|
||
{
|
||
register tree e = expr;
|
||
register enum tree_code code = TREE_CODE (type);
|
||
|
||
if (e == error_mark_node
|
||
|| TREE_TYPE (e) == error_mark_node)
|
||
return error_mark_node;
|
||
|
||
if (TREE_READONLY_DECL_P (e))
|
||
e = decl_constant_value (e);
|
||
|
||
if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
|
||
/* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
|
||
don't go through finish_struct, so they don't have the synthesized
|
||
constructors. So don't force a temporary. */
|
||
&& TYPE_HAS_CONSTRUCTOR (type))
|
||
/* We need a new temporary; don't take this shortcut. */;
|
||
else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
|
||
{
|
||
if (same_type_p (type, TREE_TYPE (e)))
|
||
/* The call to fold will not always remove the NOP_EXPR as
|
||
might be expected, since if one of the types is a typedef;
|
||
the comparsion in fold is just equality of pointers, not a
|
||
call to comptypes. We don't call fold in this case because
|
||
that can result in infinite recursion; fold will call
|
||
convert, which will call ocp_convert, etc. */
|
||
return e;
|
||
else
|
||
return fold (build1 (NOP_EXPR, type, e));
|
||
}
|
||
|
||
if (code == VOID_TYPE && (convtype & CONV_STATIC))
|
||
{
|
||
e = require_complete_type_in_void (e);
|
||
if (e != error_mark_node)
|
||
e = build1 (CONVERT_EXPR, void_type_node, e);
|
||
|
||
return e;
|
||
}
|
||
|
||
#if 0
|
||
/* This is incorrect. A truncation can't be stripped this way.
|
||
Extensions will be stripped by the use of get_unwidened. */
|
||
if (TREE_CODE (e) == NOP_EXPR)
|
||
return cp_convert (type, TREE_OPERAND (e, 0));
|
||
#endif
|
||
|
||
/* Just convert to the type of the member. */
|
||
if (code == OFFSET_TYPE)
|
||
{
|
||
type = TREE_TYPE (type);
|
||
code = TREE_CODE (type);
|
||
}
|
||
|
||
#if 0
|
||
if (code == REFERENCE_TYPE)
|
||
return fold (convert_to_reference (type, e, convtype, flags, NULL_TREE));
|
||
else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
|
||
e = convert_from_reference (e);
|
||
#endif
|
||
|
||
if (TREE_CODE (e) == OFFSET_REF)
|
||
e = resolve_offset_ref (e);
|
||
|
||
if (INTEGRAL_CODE_P (code))
|
||
{
|
||
tree intype = TREE_TYPE (e);
|
||
/* enum = enum, enum = int, enum = float, (enum)pointer are all
|
||
errors. */
|
||
if (TREE_CODE (type) == ENUMERAL_TYPE
|
||
&& ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
|
||
|| (TREE_CODE (intype) == POINTER_TYPE)))
|
||
{
|
||
cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
|
||
|
||
if (flag_pedantic_errors)
|
||
return error_mark_node;
|
||
}
|
||
if (IS_AGGR_TYPE (intype))
|
||
{
|
||
tree rval;
|
||
rval = build_type_conversion (type, e, 1);
|
||
if (rval)
|
||
return rval;
|
||
if (flags & LOOKUP_COMPLAIN)
|
||
cp_error ("`%#T' used where a `%T' was expected", intype, type);
|
||
if (flags & LOOKUP_SPECULATIVELY)
|
||
return NULL_TREE;
|
||
return error_mark_node;
|
||
}
|
||
if (code == BOOLEAN_TYPE)
|
||
{
|
||
/* Common Ada/Pascal programmer's mistake. We always warn
|
||
about this since it is so bad. */
|
||
if (TREE_CODE (expr) == FUNCTION_DECL)
|
||
cp_warning ("the address of `%D', will always be `true'", expr);
|
||
return truthvalue_conversion (e);
|
||
}
|
||
return fold (convert_to_integer (type, e));
|
||
}
|
||
if (code == POINTER_TYPE || code == REFERENCE_TYPE
|
||
|| TYPE_PTRMEMFUNC_P (type))
|
||
return fold (cp_convert_to_pointer (type, e));
|
||
if (code == REAL_TYPE || code == COMPLEX_TYPE)
|
||
{
|
||
if (IS_AGGR_TYPE (TREE_TYPE (e)))
|
||
{
|
||
tree rval;
|
||
rval = build_type_conversion (type, e, 1);
|
||
if (rval)
|
||
return rval;
|
||
else
|
||
if (flags & LOOKUP_COMPLAIN)
|
||
cp_error ("`%#T' used where a floating point value was expected",
|
||
TREE_TYPE (e));
|
||
}
|
||
if (code == REAL_TYPE)
|
||
return fold (convert_to_real (type, e));
|
||
else if (code == COMPLEX_TYPE)
|
||
return fold (convert_to_complex (type, e));
|
||
}
|
||
|
||
/* New C++ semantics: since assignment is now based on
|
||
memberwise copying, if the rhs type is derived from the
|
||
lhs type, then we may still do a conversion. */
|
||
if (IS_AGGR_TYPE_CODE (code))
|
||
{
|
||
tree dtype = TREE_TYPE (e);
|
||
tree ctor = NULL_TREE;
|
||
|
||
dtype = TYPE_MAIN_VARIANT (dtype);
|
||
|
||
/* Conversion of object pointers or signature pointers/references
|
||
to signature pointers/references. */
|
||
|
||
if (TYPE_LANG_SPECIFIC (type)
|
||
&& (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
|
||
{
|
||
tree constructor = build_signature_pointer_constructor (type, expr);
|
||
tree sig_ty = SIGNATURE_TYPE (type);
|
||
tree sig_ptr;
|
||
|
||
if (constructor == error_mark_node)
|
||
return error_mark_node;
|
||
|
||
sig_ptr = get_temp_name (type, 1);
|
||
DECL_INITIAL (sig_ptr) = constructor;
|
||
CLEAR_SIGNATURE (sig_ty);
|
||
cp_finish_decl (sig_ptr, constructor, NULL_TREE, 0, 0);
|
||
SET_SIGNATURE (sig_ty);
|
||
TREE_READONLY (sig_ptr) = 1;
|
||
|
||
return sig_ptr;
|
||
}
|
||
|
||
/* Conversion between aggregate types. New C++ semantics allow
|
||
objects of derived type to be cast to objects of base type.
|
||
Old semantics only allowed this between pointers.
|
||
|
||
There may be some ambiguity between using a constructor
|
||
vs. using a type conversion operator when both apply. */
|
||
|
||
ctor = e;
|
||
|
||
if (IS_AGGR_TYPE (type) && CLASSTYPE_ABSTRACT_VIRTUALS (type))
|
||
{
|
||
abstract_virtuals_error (NULL_TREE, type);
|
||
return error_mark_node;
|
||
}
|
||
|
||
if ((flags & LOOKUP_ONLYCONVERTING)
|
||
&& ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
|
||
/* For copy-initialization, first we create a temp of the proper type
|
||
with a user-defined conversion sequence, then we direct-initialize
|
||
the target with the temp (see [dcl.init]). */
|
||
ctor = build_user_type_conversion (type, ctor, flags);
|
||
if (ctor)
|
||
ctor = build_method_call (NULL_TREE, ctor_identifier,
|
||
build_expr_list (NULL_TREE, ctor),
|
||
TYPE_BINFO (type), flags);
|
||
if (ctor)
|
||
return build_cplus_new (type, ctor);
|
||
}
|
||
|
||
/* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
|
||
then it won't be hashed and hence compare as not equal,
|
||
even when it is. */
|
||
if (code == ARRAY_TYPE
|
||
&& TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
|
||
&& index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
|
||
return e;
|
||
|
||
if (flags & LOOKUP_COMPLAIN)
|
||
cp_error ("conversion from `%T' to non-scalar type `%T' requested",
|
||
TREE_TYPE (expr), type);
|
||
if (flags & LOOKUP_SPECULATIVELY)
|
||
return NULL_TREE;
|
||
return error_mark_node;
|
||
}
|
||
|
||
/* Create an expression whose value is that of EXPR,
|
||
converted to type TYPE. The TREE_TYPE of the value
|
||
is always TYPE. This function implements all reasonable
|
||
conversions; callers should filter out those that are
|
||
not permitted by the language being compiled.
|
||
|
||
Most of this routine is from build_reinterpret_cast.
|
||
|
||
The backend cannot call cp_convert (what was convert) because
|
||
conversions to/from basetypes may involve memory references
|
||
(vbases) and adding or subtracting small values (multiple
|
||
inheritance), but it calls convert from the constant folding code
|
||
on subtrees of already build trees after it has ripped them apart.
|
||
|
||
Also, if we ever support range variables, we'll probably also have to
|
||
do a little bit more work. */
|
||
|
||
tree
|
||
convert (type, expr)
|
||
tree type, expr;
|
||
{
|
||
tree intype;
|
||
|
||
if (type == error_mark_node || expr == error_mark_node)
|
||
return error_mark_node;
|
||
|
||
intype = TREE_TYPE (expr);
|
||
|
||
if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
|
||
{
|
||
if (TREE_READONLY_DECL_P (expr))
|
||
expr = decl_constant_value (expr);
|
||
return fold (build1 (NOP_EXPR, type, expr));
|
||
}
|
||
|
||
return ocp_convert (type, expr, CONV_OLD_CONVERT,
|
||
LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
|
||
}
|
||
|
||
/* Like cp_convert, except permit conversions to take place which
|
||
are not normally allowed due to access restrictions
|
||
(such as conversion from sub-type to private super-type). */
|
||
|
||
tree
|
||
convert_force (type, expr, convtype)
|
||
tree type;
|
||
tree expr;
|
||
int convtype;
|
||
{
|
||
register tree e = expr;
|
||
register enum tree_code code = TREE_CODE (type);
|
||
|
||
if (code == REFERENCE_TYPE)
|
||
return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
|
||
NULL_TREE));
|
||
else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
|
||
e = convert_from_reference (e);
|
||
|
||
if (code == POINTER_TYPE)
|
||
return fold (convert_to_pointer_force (type, e));
|
||
|
||
/* From typeck.c convert_for_assignment */
|
||
if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
|
||
&& TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
|
||
&& TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
|
||
|| integer_zerop (e)
|
||
|| TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
|
||
&& TYPE_PTRMEMFUNC_P (type))
|
||
{
|
||
/* compatible pointer to member functions. */
|
||
return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
|
||
}
|
||
|
||
return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
|
||
}
|
||
|
||
/* Convert an aggregate EXPR to type XTYPE. If a conversion
|
||
exists, return the attempted conversion. This may
|
||
return ERROR_MARK_NODE if the conversion is not
|
||
allowed (references private members, etc).
|
||
If no conversion exists, NULL_TREE is returned.
|
||
|
||
If (FOR_SURE & 1) is non-zero, then we allow this type conversion
|
||
to take place immediately. Otherwise, we build a SAVE_EXPR
|
||
which can be evaluated if the results are ever needed.
|
||
|
||
Changes to this functions should be mirrored in user_harshness.
|
||
|
||
FIXME: Ambiguity checking is wrong. Should choose one by the implicit
|
||
object parameter, or by the second standard conversion sequence if
|
||
that doesn't do it. This will probably wait for an overloading rewrite.
|
||
(jason 8/9/95) */
|
||
|
||
tree
|
||
build_type_conversion (xtype, expr, for_sure)
|
||
tree xtype, expr;
|
||
int for_sure;
|
||
{
|
||
/* C++: check to see if we can convert this aggregate type
|
||
into the required type. */
|
||
return build_user_type_conversion
|
||
(xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
|
||
}
|
||
|
||
/* Convert the given EXPR to one of a group of types suitable for use in an
|
||
expression. DESIRES is a combination of various WANT_* flags (q.v.)
|
||
which indicates which types are suitable. If COMPLAIN is 1, complain
|
||
about ambiguity; otherwise, the caller will deal with it. */
|
||
|
||
tree
|
||
build_expr_type_conversion (desires, expr, complain)
|
||
int desires;
|
||
tree expr;
|
||
int complain;
|
||
{
|
||
tree basetype = TREE_TYPE (expr);
|
||
tree conv = NULL_TREE;
|
||
tree winner = NULL_TREE;
|
||
|
||
if (expr == null_node
|
||
&& (desires & WANT_INT)
|
||
&& !(desires & WANT_NULL))
|
||
cp_warning ("converting NULL to non-pointer type");
|
||
|
||
if (TREE_CODE (expr) == OFFSET_REF)
|
||
expr = resolve_offset_ref (expr);
|
||
expr = convert_from_reference (expr);
|
||
basetype = TREE_TYPE (expr);
|
||
|
||
if (! IS_AGGR_TYPE (basetype))
|
||
switch (TREE_CODE (basetype))
|
||
{
|
||
case INTEGER_TYPE:
|
||
if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
|
||
return expr;
|
||
/* else fall through... */
|
||
|
||
case BOOLEAN_TYPE:
|
||
return (desires & WANT_INT) ? expr : NULL_TREE;
|
||
case ENUMERAL_TYPE:
|
||
return (desires & WANT_ENUM) ? expr : NULL_TREE;
|
||
case REAL_TYPE:
|
||
return (desires & WANT_FLOAT) ? expr : NULL_TREE;
|
||
case POINTER_TYPE:
|
||
return (desires & WANT_POINTER) ? expr : NULL_TREE;
|
||
|
||
case FUNCTION_TYPE:
|
||
case ARRAY_TYPE:
|
||
return (desires & WANT_POINTER) ? default_conversion (expr)
|
||
: NULL_TREE;
|
||
default:
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* The code for conversions from class type is currently only used for
|
||
delete expressions. Other expressions are handled by build_new_op. */
|
||
|
||
if (! TYPE_HAS_CONVERSION (basetype))
|
||
return NULL_TREE;
|
||
|
||
for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
|
||
{
|
||
int win = 0;
|
||
tree candidate;
|
||
tree cand = TREE_VALUE (conv);
|
||
|
||
if (winner && winner == cand)
|
||
continue;
|
||
|
||
candidate = TREE_TYPE (TREE_TYPE (cand));
|
||
if (TREE_CODE (candidate) == REFERENCE_TYPE)
|
||
candidate = TREE_TYPE (candidate);
|
||
|
||
switch (TREE_CODE (candidate))
|
||
{
|
||
case BOOLEAN_TYPE:
|
||
case INTEGER_TYPE:
|
||
win = (desires & WANT_INT); break;
|
||
case ENUMERAL_TYPE:
|
||
win = (desires & WANT_ENUM); break;
|
||
case REAL_TYPE:
|
||
win = (desires & WANT_FLOAT); break;
|
||
case POINTER_TYPE:
|
||
win = (desires & WANT_POINTER); break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (win)
|
||
{
|
||
if (winner)
|
||
{
|
||
if (complain)
|
||
{
|
||
cp_error ("ambiguous default type conversion from `%T'",
|
||
basetype);
|
||
cp_error (" candidate conversions include `%D' and `%D'",
|
||
winner, cand);
|
||
}
|
||
return error_mark_node;
|
||
}
|
||
else
|
||
winner = cand;
|
||
}
|
||
}
|
||
|
||
if (winner)
|
||
{
|
||
tree type = TREE_TYPE (TREE_TYPE (winner));
|
||
if (TREE_CODE (type) == REFERENCE_TYPE)
|
||
type = TREE_TYPE (type);
|
||
return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Implements integral promotion (4.1) and float->double promotion. */
|
||
|
||
tree
|
||
type_promotes_to (type)
|
||
tree type;
|
||
{
|
||
int type_quals;
|
||
|
||
if (type == error_mark_node)
|
||
return error_mark_node;
|
||
|
||
type_quals = CP_TYPE_QUALS (type);
|
||
type = TYPE_MAIN_VARIANT (type);
|
||
|
||
/* bool always promotes to int (not unsigned), even if it's the same
|
||
size. */
|
||
if (type == boolean_type_node)
|
||
type = integer_type_node;
|
||
|
||
/* Normally convert enums to int, but convert wide enums to something
|
||
wider. */
|
||
else if (TREE_CODE (type) == ENUMERAL_TYPE
|
||
|| type == wchar_type_node)
|
||
{
|
||
int precision = MAX (TYPE_PRECISION (type),
|
||
TYPE_PRECISION (integer_type_node));
|
||
tree totype = type_for_size (precision, 0);
|
||
if (TREE_UNSIGNED (type)
|
||
&& ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
|
||
type = type_for_size (precision, 1);
|
||
else
|
||
type = totype;
|
||
}
|
||
else if (C_PROMOTING_INTEGER_TYPE_P (type))
|
||
{
|
||
/* Retain unsignedness if really not getting bigger. */
|
||
if (TREE_UNSIGNED (type)
|
||
&& TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
|
||
type = unsigned_type_node;
|
||
else
|
||
type = integer_type_node;
|
||
}
|
||
else if (type == float_type_node)
|
||
type = double_type_node;
|
||
|
||
return cp_build_qualified_type (type, type_quals);
|
||
}
|
||
|
||
/* The routines below this point are carefully written to conform to
|
||
the standard. They use the same terminology, and follow the rules
|
||
closely. Although they are used only in pt.c at the moment, they
|
||
should presumably be used everywhere in the future. */
|
||
|
||
/* Attempt to perform qualification conversions on EXPR to convert it
|
||
to TYPE. Return the resulting expression, or error_mark_node if
|
||
the conversion was impossible. */
|
||
|
||
tree
|
||
perform_qualification_conversions (type, expr)
|
||
tree type;
|
||
tree expr;
|
||
{
|
||
if (TREE_CODE (type) == POINTER_TYPE
|
||
&& TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
|
||
&& comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
|
||
return build1 (NOP_EXPR, type, expr);
|
||
else
|
||
return error_mark_node;
|
||
}
|