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, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
/* This file is part of the C++ front end.
tree attributes;
/* FIXME: Attributes. */
- gcc_assert (ARITHMETIC_TYPE_P (t1)
+ gcc_assert (ARITHMETIC_TYPE_P (t1)
|| TREE_CODE (t1) == COMPLEX_TYPE
+ || TREE_CODE (t1) == VECTOR_TYPE
|| TREE_CODE (t1) == ENUMERAL_TYPE);
- gcc_assert (ARITHMETIC_TYPE_P (t2)
+ gcc_assert (ARITHMETIC_TYPE_P (t2)
|| TREE_CODE (t2) == COMPLEX_TYPE
+ || TREE_CODE (t1) == VECTOR_TYPE
|| TREE_CODE (t2) == ENUMERAL_TYPE);
/* In what follows, we slightly generalize the rules given in [expr] so
attributes);
}
+ if (code1 == VECTOR_TYPE)
+ {
+ /* When we get here we should have two vectors of the same size.
+ Just prefer the unsigned one if present. */
+ if (TYPE_UNSIGNED (t1))
+ return build_type_attribute_variant (t1, attributes);
+ else
+ return build_type_attribute_variant (t2, attributes);
+ }
+
/* If only one is real, use it as the result. */
if (code1 == REAL_TYPE && code2 != REAL_TYPE)
return build_type_attribute_variant (t1, attributes);
convert to a long long. Otherwise, convert to an unsigned long
long. Otherwise, if either operand is long long, convert the
other to long long.
-
+
Since we're here, we know the TYPE_PRECISION is the same;
therefore converting to long long cannot represent all the values
of an unsigned long, so we choose unsigned long long in that
|| same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
{
tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
- ? long_long_unsigned_type_node
+ ? long_long_unsigned_type_node
: long_long_integer_type_node);
return build_type_attribute_variant (t, attributes);
}
-
+
/* Go through the same procedure, but for longs. */
if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
|| same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
|| same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
return build_type_attribute_variant (float_type_node,
attributes);
-
+
/* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
- the standard C++ floating-point types. Logic earlier in this
- function has already eliminated the possibility that
- TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
- compelling reason to choose one or the other. */
+ the standard C++ floating-point types. Logic earlier in this
+ function has already eliminated the possibility that
+ TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
+ compelling reason to choose one or the other. */
return build_type_attribute_variant (t1, attributes);
}
}
/* Return the composite pointer type (see [expr.rel]) for T1 and T2.
ARG1 and ARG2 are the values with those types. The LOCATION is a
- string describing the current location, in case an error occurs.
+ string describing the current location, in case an error occurs.
This routine also implements the computation of a common type for
pointers-to-members as per [expr.eq]. */
-tree
+tree
composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
const char* location)
{
return t2;
if (null_ptr_cst_p (arg2))
return t1;
-
+
/* We have:
[expr.rel]
if (pedantic && TYPE_PTRFN_P (t2))
pedwarn ("ISO C++ forbids %s between pointer of type %<void *%> "
- "and pointer-to-function", location);
- result_type
+ "and pointer-to-function", location);
+ result_type
= cp_build_qualified_type (void_type_node,
(cp_type_quals (TREE_TYPE (t1))
| cp_type_quals (TREE_TYPE (t2))));
return build_type_attribute_variant (result_type, attributes);
}
+ if (c_dialect_objc () && TREE_CODE (t1) == POINTER_TYPE
+ && TREE_CODE (t2) == POINTER_TYPE)
+ {
+ if (objc_compare_types (t1, t2, -3, NULL_TREE))
+ return t1;
+ }
+
/* [expr.eq] permits the application of a pointer conversion to
bring the pointers to a common type. */
if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
class2 = TREE_TYPE (t2);
if (DERIVED_FROM_P (class1, class2))
- t2 = (build_pointer_type
+ t2 = (build_pointer_type
(cp_build_qualified_type (class1, TYPE_QUALS (class2))));
else if (DERIVED_FROM_P (class2, class1))
- t1 = (build_pointer_type
+ t1 = (build_pointer_type
(cp_build_qualified_type (class2, TYPE_QUALS (class1))));
else
{
code2 = TREE_CODE (t2);
if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
- || code1 == COMPLEX_TYPE)
+ || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
&& (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
- || code2 == COMPLEX_TYPE))
+ || code2 == COMPLEX_TYPE || code2 == VECTOR_TYPE))
return type_after_usual_arithmetic_conversions (t1, t2);
else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
/* Compare two exception specifier types for exactness or subsetness, if
allowed. Returns false for mismatch, true for match (same, or
derived and !exact).
-
+
[except.spec] "If a class X ... objects of class X or any class publicly
and unambiguously derived from X. Similarly, if a pointer type Y * ...
exceptions of type Y * or that are pointers to any type publicly and
[except.throw] and catch [except.catch] will do. They will ignore the
top level cv qualifiers, and allow qualifiers in the pointer to class
example.
-
+
We implement the letter of the standard. */
static bool
else if (!exact)
{
if (cp_type_quals (a) || cp_type_quals (b))
- return false;
-
+ return false;
+
if (TREE_CODE (a) == POINTER_TYPE
- && TREE_CODE (b) == POINTER_TYPE)
- {
- a = TREE_TYPE (a);
- b = TREE_TYPE (b);
- if (cp_type_quals (a) || cp_type_quals (b))
- return false;
- }
-
+ && TREE_CODE (b) == POINTER_TYPE)
+ {
+ a = TREE_TYPE (a);
+ b = TREE_TYPE (b);
+ if (cp_type_quals (a) || cp_type_quals (b))
+ return false;
+ }
+
if (TREE_CODE (a) != RECORD_TYPE
- || TREE_CODE (b) != RECORD_TYPE)
- return false;
-
+ || TREE_CODE (b) != RECORD_TYPE)
+ return false;
+
if (PUBLICLY_UNIQUELY_DERIVED_P (a, b))
- return true;
+ return true;
}
return false;
}
if (t1 == t2)
return true;
-
- if (t1 == NULL_TREE) /* T1 is ... */
+
+ if (t1 == NULL_TREE) /* T1 is ... */
return t2 == NULL_TREE || !exact;
- if (!TREE_VALUE (t1)) /* t1 is EMPTY */
+ if (!TREE_VALUE (t1)) /* t1 is EMPTY */
return t2 != NULL_TREE && !TREE_VALUE (t2);
- if (t2 == NULL_TREE) /* T2 is ... */
+ if (t2 == NULL_TREE) /* T2 is ... */
return false;
if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
return !exact;
-
+
/* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
Count how many we find, to determine exactness. For exact matching and
ordered T1, T2, this is an O(n) operation, otherwise its worst case is
for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
{
for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
- {
- tree a = TREE_VALUE (probe);
- tree b = TREE_VALUE (t2);
-
- if (comp_except_types (a, b, exact))
- {
- if (probe == base && exact)
- base = TREE_CHAIN (probe);
- length++;
- break;
- }
- }
+ {
+ tree a = TREE_VALUE (probe);
+ tree b = TREE_VALUE (t2);
+
+ if (comp_except_types (a, b, exact))
+ {
+ if (probe == base && exact)
+ base = TREE_CHAIN (probe);
+ length++;
+ break;
+ }
+ }
if (probe == NULL_TREE)
- return false;
+ return false;
}
return !exact || base == NULL_TREE || length == list_length (t1);
}
extern int a[];
int a[3];
- by [basic.link]:
+ by [basic.link]:
declarations for an array object can specify
array types that differ by the presence or absence of a major
&& !value_dependent_expression_p (max2))
{
/* With abi-1 we do not fold non-dependent array bounds, (and
- consequently mangle them incorrectly). We must therefore
- fold them here, to verify the domains have the same
- value. */
+ consequently mangle them incorrectly). We must therefore
+ fold them here, to verify the domains have the same
+ value. */
max1 = fold (max1);
max2 = fold (max2);
}
bool
comptypes (tree t1, tree t2, int strict)
{
- int retval;
-
if (t1 == t2)
return true;
/* Suppress errors caused by previously reported errors. */
if (t1 == error_mark_node || t2 == error_mark_node)
return false;
-
+
gcc_assert (TYPE_P (t1) && TYPE_P (t2));
-
+
/* TYPENAME_TYPEs should be resolved if the qualifying scope is the
current instantiation. */
if (TREE_CODE (t1) == TYPENAME_TYPE)
if (resolved != error_mark_node)
t1 = resolved;
}
-
+
if (TREE_CODE (t2) == TYPENAME_TYPE)
{
tree resolved = resolve_typename_type (t2, /*only_current_p=*/true);
&& TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
return true;
- if (!(*targetm.comp_type_attributes) (t1, t2))
- return false;
-
+ /* Compare the types. Break out if they could be the same. */
switch (TREE_CODE (t1))
{
case TEMPLATE_TEMPLATE_PARM:
DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
return false;
if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
- return true;
+ break;
/* Don't check inheritance. */
strict = COMPARE_STRICT;
/* Fall through. */
&& (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
|| TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
&& comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
- return true;
-
+ break;
+
if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
- return true;
+ break;
else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
- return true;
-
- /* We may be dealing with Objective-C instances... */
- if (TREE_CODE (t1) == RECORD_TYPE
- && ((retval = objc_comptypes (t1, t2, 0)) >= 0))
- return retval;
- /* ...but fall through if we are not. */
+ break;
return false;
if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
strict & ~COMPARE_REDECLARATION))
return false;
- return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
+ if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
+ return false;
+ break;
case POINTER_TYPE:
case REFERENCE_TYPE:
- return TYPE_MODE (t1) == TYPE_MODE (t2)
- && TYPE_REF_CAN_ALIAS_ALL (t1) == TYPE_REF_CAN_ALIAS_ALL (t2)
- && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
+ if (TYPE_MODE (t1) != TYPE_MODE (t2)
+ || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
+ || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
+ return false;
+ break;
case METHOD_TYPE:
case FUNCTION_TYPE:
if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
return false;
- return compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
+ if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
+ return false;
+ break;
case ARRAY_TYPE:
/* Target types must match incl. qualifiers. */
- return comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION));
+ if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
+ return false;
+ break;
case TEMPLATE_TYPE_PARM:
- return (TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2)
- && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2));
+ if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
+ || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
+ return false;
+ break;
case TYPENAME_TYPE:
if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
TYPENAME_TYPE_FULLNAME (t2)))
- return false;
- return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
+ return false;
+ if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
+ return false;
+ break;
case UNBOUND_CLASS_TEMPLATE:
if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
- return false;
- return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
+ return false;
+ if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
+ return false;
+ break;
case COMPLEX_TYPE:
- return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
+ if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
+ return false;
+ break;
case VECTOR_TYPE:
- return TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
- && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
+ if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
+ || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
+ return false;
break;
default:
- break;
+ return false;
}
- return false;
+
+ /* If we get here, we know that from a target independent POV the
+ types are the same. Make sure the target attributes are also
+ the same. */
+ return targetm.comp_type_attributes (t1, t2);
}
/* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
{
int q1 = cp_type_quals (type1);
int q2 = cp_type_quals (type2);
-
+
/* All qualifiers for TYPE2 must also appear in TYPE1. */
return (q1 & q2) == q2;
}
{
tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt1), i));
tree trial = common_base_type (basetype, tt2);
-
+
if (trial)
{
if (trial == error_mark_node)
{
tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt2), i));
tree trial = common_base_type (tt1, basetype);
-
+
if (trial)
{
if (trial == error_mark_node)
gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
if (type == error_mark_node)
return error_mark_node;
-
- if (processing_template_decl)
+
+ if (dependent_type_p (type))
{
value = build_min (op, size_type_node, type);
TREE_READONLY (value) = 1;
return value;
}
-
+
op_name = operator_name_info[(int) op].name;
type = non_reference (type);
value = size_one_node;
}
else
- value = c_sizeof_or_alignof_type (complete_type (type), op, complain);
+ value = c_sizeof_or_alignof_type (complete_type (type),
+ op == SIZEOF_EXPR,
+ complain);
return value;
}
cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
{
const char *op_name = operator_name_info[(int) op].name;
-
+
if (e == error_mark_node)
return error_mark_node;
-
+
if (processing_template_decl)
{
e = build_min (op, size_type_node, e);
TREE_SIDE_EFFECTS (e) = 0;
TREE_READONLY (e) = 1;
-
+
return e;
}
-
+
if (TREE_CODE (e) == COMPONENT_REF
&& TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
&& DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
else if (is_overloaded_fn (e))
{
pedwarn ("ISO C++ forbids applying %qs to an expression of "
- "function type", op_name);
+ "function type", op_name);
e = char_type_node;
}
else if (type_unknown_p (e))
}
else
e = TREE_TYPE (e);
-
+
return cxx_sizeof_or_alignof_type (e, op, true);
}
-
+
\f
/* EXPR is being used in a context that is not a function call.
Enforce:
- [expr.ref]
+ [expr.ref]
The expression can be used only as the left-hand operand of a
- member function call.
+ member function call.
[expr.mptr.operator]
If the result of .* or ->* is a function, then that result can be
- used only as the operand for the function call operator ().
+ used only as the operand for the function call operator ().
by issuing an error message if appropriate. Returns true iff EXPR
violates these rules. */
}
exp = integral_constant_value (exp);
-
+
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
tree ptrtype;
if (TREE_CODE (exp) == INDIRECT_REF)
- return build_nop (build_pointer_type (TREE_TYPE (type)),
+ return build_nop (build_pointer_type (TREE_TYPE (type)),
TREE_OPERAND (exp, 0));
if (TREE_CODE (exp) == COMPOUND_EXPR)
/* This warning is not very useful, as it complains about printf. */
if (warn && warn_write_strings)
- warning ("deprecated conversion from string constant to %qT'", totype);
+ warning (0, "deprecated conversion from string constant to %qT'", totype);
return 1;
}
non-NULL, it indicates the path to the base used to name MEMBER.
If PRESERVE_REFERENCE is true, the expression returned will have
REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
- returned will have the type referred to by the reference.
+ returned will have the type referred to by the reference.
This function does not perform access control; that is either done
earlier by the parser when the name of MEMBER is resolved to MEMBER
functions indicated by MEMBER. */
tree
-build_class_member_access_expr (tree object, tree member,
+build_class_member_access_expr (tree object, tree member,
tree access_path, bool preserve_reference)
{
tree object_type;
The type of the first expression shall be "class object" (of a
complete type). */
object_type = TREE_TYPE (object);
- if (!currently_open_class (object_type)
+ if (!currently_open_class (object_type)
&& !complete_type_or_else (object_type, object))
return error_mark_node;
if (!CLASS_TYPE_P (object_type))
{
- error ("request for member %qD in %qE, which is of non-class type %qT",
+ error ("request for member %qD in %qE, which is of non-class type %qT",
member, object, object_type);
return error_mark_node;
}
if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
{
if (TREE_CODE (member) == FIELD_DECL)
- error ("invalid use of nonstatic data member %qE", member);
+ error ("invalid use of nonstatic data member %qE", member);
else
- error ("%qD is not a member of %qT", member, object_type);
+ error ("%qD is not a member of %qT", member, object_type);
return error_mark_node;
}
if (null_object_p && kind == bk_via_virtual)
{
error ("invalid access to non-static data member %qD of "
- "NULL object",
+ "NULL object",
member);
error ("(perhaps the %<offsetof%> macro was used incorrectly)");
return error_mark_node;
}
/* Convert to the base. */
- object = build_base_path (PLUS_EXPR, object, binfo,
+ object = build_base_path (PLUS_EXPR, object, binfo,
/*nonnull=*/1);
/* If we found the base successfully then we should be able
to convert to it successfully. */
&& !DECL_FIELD_IS_BASE (member)
&& !skip_evaluation)
{
- warning ("invalid access to non-static data member %qD of NULL object",
+ warning (0, "invalid access to non-static data member %qD of NULL object",
member);
- warning ("(perhaps the %<offsetof%> macro was used incorrectly)");
+ warning (0, "(perhaps the %<offsetof%> macro was used incorrectly)");
}
/* If MEMBER is from an anonymous aggregate, we have converted
constructed, and was then disassembled before calling
build_field_call. After the function-call code is
cleaned up, this waste can be eliminated. */
- && (!same_type_ignoring_top_level_qualifiers_p
+ && (!same_type_ignoring_top_level_qualifiers_p
(TREE_TYPE (object), DECL_CONTEXT (member))))
{
tree anonymous_union;
member_type = TREE_TYPE (member);
if (TREE_CODE (member_type) != REFERENCE_TYPE)
{
- type_quals = (cp_type_quals (member_type)
+ type_quals = (cp_type_quals (member_type)
| cp_type_quals (object_type));
-
+
/* A field is const (volatile) if the enclosing object, or the
field itself, is const (volatile). But, a mutable field is
not const, even within a const object. */
if (!preserve_reference)
/* [expr.ref]
-
+
If E2 is declared to have type "reference to T", then ... the
type of E1.E2 is T. */
result = convert_from_reference (result);
if (object == error_mark_node || name == error_mark_node)
return error_mark_node;
+ /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
+ if (!objc_is_public (object, name))
+ return error_mark_node;
+
object_type = TREE_TYPE (object);
if (processing_template_decl)
return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
object = build_non_dependent_expr (object);
}
-
+
/* [expr.ref]
The type of the first expression shall be "class object" (of a
complete type). */
- if (!currently_open_class (object_type)
+ if (!currently_open_class (object_type)
&& !complete_type_or_else (object_type, object))
return error_mark_node;
if (!CLASS_TYPE_P (object_type))
{
- error ("request for member %qD in %qE, which is of non-class type %qT",
+ error ("request for member %qD in %qE, which is of non-class type %qT",
name, object, object_type);
return error_mark_node;
}
name a member of OBJECT_TYPE. */
if (TREE_CODE (scope) == NAMESPACE_DECL)
{
- error ("%<%D::%D%> is not a member of %qT",
+ error ("%<%D::%D%> is not a member of %qT",
scope, name, object_type);
return error_mark_node;
}
else
{
/* Look up the member. */
- member = lookup_member (access_path, name, /*protect=*/1,
+ member = lookup_member (access_path, name, /*protect=*/1,
/*want_type=*/false);
if (member == NULL_TREE)
{
if (member == error_mark_node)
return error_mark_node;
}
-
+
if (is_template_id)
{
tree template = member;
-
+
if (BASELINK_P (template))
template = lookup_template_function (template, template_args);
else
/*want_type=*/false);
member_type = cp_build_qualified_type (TREE_TYPE (member),
cp_type_quals (ptrmem_type));
- return fold (build3 (COMPONENT_REF, member_type,
- ptrmem, member, NULL_TREE));
+ return fold_build3 (COMPONENT_REF, member_type,
+ ptrmem, member, NULL_TREE);
}
/* Given an expression PTR for a pointer, return an expression
if (POINTER_TYPE_P (type))
{
/* [expr.unary.op]
-
+
If the type of the expression is "pointer to T," the type
- of the result is "T."
+ of the result is "T."
- We must use the canonical variant because certain parts of
+ We must use the canonical variant because certain parts of
the back end, like fold, do pointer comparisons between
types. */
tree t = canonical_type_variant (TREE_TYPE (type));
if (VOID_TYPE_P (t))
- {
- /* A pointer to incomplete type (other than cv void) can be
- dereferenced [expr.unary.op]/1 */
- error ("%qT is not a pointer-to-object type", type);
- return error_mark_node;
- }
+ {
+ /* A pointer to incomplete type (other than cv void) can be
+ dereferenced [expr.unary.op]/1 */
+ error ("%qT is not a pointer-to-object type", type);
+ return error_mark_node;
+ }
else if (TREE_CODE (pointer) == ADDR_EXPR
&& same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
/* The POINTER was something like `&x'. We simplify `*&x' to
must have done so deliberately. */
if (warn_char_subscripts
&& TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
- warning ("array subscript has type %<char%>");
+ warning (0, "array subscript has type %<char%>");
if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
{
while (TREE_CODE (foo) == COMPONENT_REF)
foo = TREE_OPERAND (foo, 0);
if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
- warning ("subscripting array declared %<register%>");
+ warning (0, "subscripting array declared %<register%>");
}
type = TREE_TYPE (TREE_TYPE (array));
gcc_unreachable ();
}
- /* Convert down to the right base before using the instance. First
- use the type... */
+ /* Convert down to the right base before using the instance. A
+ special case is that in a pointer to member of class C, C may
+ be incomplete. In that case, the function will of course be
+ a member of C, and no conversion is required. In fact,
+ lookup_base will fail in that case, because incomplete
+ classes do not have BINFOs. */
basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
- basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
- basetype, ba_check, NULL);
- instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1);
- if (instance_ptr == error_mark_node)
- return error_mark_node;
+ if (!same_type_ignoring_top_level_qualifiers_p
+ (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
+ {
+ basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
+ basetype, ba_check, NULL);
+ instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
+ 1);
+ if (instance_ptr == error_mark_node)
+ return error_mark_node;
+ }
/* ...and then the delta in the PMF. */
instance_ptr = build2 (PLUS_EXPR, TREE_TYPE (instance_ptr),
instance_ptr, delta);
vtbl = build_indirect_ref (vtbl, NULL);
/* Finally, extract the function pointer from the vtable. */
- e2 = fold (build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx));
+ e2 = fold_build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx);
e2 = build_indirect_ref (e2, NULL);
TREE_CONSTANT (e2) = 1;
TREE_INVARIANT (e2) = 1;
TREE_TYPE (e2) = TREE_TYPE (e3);
e1 = build_conditional_expr (e1, e2, e3);
-
+
/* Make sure this doesn't get evaluated first inside one of the
branches of the COND_EXPR. */
if (instance_save_expr)
int is_method;
tree original = function;
+ /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
+ expressions, like those used for ObjC messenger dispatches. */
+ function = objc_rewrite_function_call (function, params);
+
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
if (TREE_CODE (function) == NOP_EXPR
/* Differs from default_conversion by not setting TREE_ADDRESSABLE
(because calling an inline function does not mean the function
needs to be separately compiled). */
-
+
if (DECL_INLINE (function))
function = inline_conversion (function);
else
if (TYPE_PTRMEMFUNC_P (fntype))
{
error ("must use %<.*%> or %<->*%> to call pointer-to-member "
- "function in %<%E (...)%>",
- original);
+ "function in %<%E (...)%>",
+ original);
return error_mark_node;
}
/* Check for errors in format strings and inappropriately
null parameters. */
- check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
+ check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params,
+ TYPE_ARG_TYPES (fntype));
return build_cxx_call (function, coerced_params);
}
NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
This is also where warnings about wrong number of args are generated.
-
+
Return a list of expressions for the parameters as converted.
Both VALUES and the returned value are chains of TREE_LIST nodes
if (typetail != 0 && typetail != void_list_node)
{
/* See if there are default arguments that can be used. */
- if (TREE_PURPOSE (typetail)
+ if (TREE_PURPOSE (typetail)
&& TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
{
for (; typetail != void_list_node; ++i)
{
- tree parmval
- = convert_default_arg (TREE_VALUE (typetail),
- TREE_PURPOSE (typetail),
+ tree parmval
+ = convert_default_arg (TREE_VALUE (typetail),
+ TREE_PURPOSE (typetail),
fndecl, i);
if (parmval == error_mark_node)
if (fndecl)
{
cp_error_at ("too few arguments to %s %q+#D",
- called_thing, fndecl);
+ called_thing, fndecl);
error ("at this point in file");
}
else
conversions on the operands. CODE is the kind of expression to build. */
tree
-build_x_binary_op (enum tree_code code, tree arg1, tree arg2,
+build_x_binary_op (enum tree_code code, tree arg1, tree arg2,
bool *overloaded_p)
{
tree orig_arg1;
if (code == DOTSTAR_EXPR)
expr = build_m_component_ref (arg1, arg2);
else
- expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
+ expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
overloaded_p);
if (processing_template_decl && expr != error_mark_node)
return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
-
+
return expr;
}
tree op0, op1;
enum tree_code code0, code1;
tree type0, type1;
+ const char *invalid_op_diag;
/* Expression code to give to the expression when it is built.
Normally this is CODE, which is what the caller asked for,
/* Apply default conversions. */
op0 = orig_op0;
op1 = orig_op1;
-
+
if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
|| code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
|| code == TRUTH_XOR_EXPR)
if (t != error_mark_node)
{
pedwarn ("assuming cast to type %qT from overloaded function",
- TREE_TYPE (t));
+ TREE_TYPE (t));
op0 = t;
}
}
if (t != error_mark_node)
{
pedwarn ("assuming cast to type %qT from overloaded function",
- TREE_TYPE (t));
+ TREE_TYPE (t));
op1 = t;
}
}
if (code0 == ERROR_MARK || code1 == ERROR_MARK)
return error_mark_node;
+ if ((invalid_op_diag
+ = targetm.invalid_binary_op (code, type0, type1)))
+ {
+ error (invalid_op_diag);
+ return error_mark_node;
+ }
+
switch (code)
{
case PLUS_EXPR:
|| code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
{
if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
- warning ("division by zero in %<%E / 0%>", op0);
+ warning (0, "division by zero in %<%E / 0%>", op0);
else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
- warning ("division by zero in %<%E / 0.%>", op0);
-
+ warning (0, "division by zero in %<%E / 0.%>", op0);
+
if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
case BIT_AND_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
- if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+ if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+ || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE))
shorten = -1;
break;
case TRUNC_MOD_EXPR:
case FLOOR_MOD_EXPR:
if (code1 == INTEGER_TYPE && integer_zerop (op1))
- warning ("division by zero in %<%E %% 0%>", op0);
+ warning (0, "division by zero in %<%E %% 0%>", op0);
else if (code1 == REAL_TYPE && real_zerop (op1))
- warning ("division by zero in %<%E %% 0.%>", op0);
-
+ warning (0, "division by zero in %<%E %% 0.%>", op0);
+
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
{
/* Although it would be tempting to shorten always here, that loses
if (TREE_CODE (op1) == INTEGER_CST)
{
if (tree_int_cst_lt (op1, integer_zero_node))
- warning ("right shift count is negative");
+ warning (0, "right shift count is negative");
else
{
if (! integer_zerop (op1))
short_shift = 1;
if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
- warning ("right shift count >= width of type");
+ warning (0, "right shift count >= width of type");
}
}
/* Convert the shift-count to an integer, regardless of
if (TREE_CODE (op1) == INTEGER_CST)
{
if (tree_int_cst_lt (op1, integer_zero_node))
- warning ("left shift count is negative");
+ warning (0, "left shift count is negative");
else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
- warning ("left shift count >= width of type");
+ warning (0, "left shift count >= width of type");
}
/* Convert the shift-count to an integer, regardless of
size of value being shifted. */
if (TREE_CODE (op1) == INTEGER_CST)
{
if (tree_int_cst_lt (op1, integer_zero_node))
- warning ("%s rotate count is negative",
+ warning (0, "%s rotate count is negative",
(code == LROTATE_EXPR) ? "left" : "right");
else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
- warning ("%s rotate count >= width of type",
+ warning (0, "%s rotate count >= width of type",
(code == LROTATE_EXPR) ? "left" : "right");
}
/* Convert the shift-count to an integer, regardless of
case EQ_EXPR:
case NE_EXPR:
if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
- warning ("comparing floating point with == or != is unsafe");
+ warning (0, "comparing floating point with == or != is unsafe");
- build_type = boolean_type_node;
+ build_type = boolean_type_node;
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
|| code0 == COMPLEX_TYPE)
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE
/* We generate:
- (op0.pfn == op1.pfn
+ (op0.pfn == op1.pfn
&& (!op0.pfn || op0.delta == op1.delta))
-
+
The reason for the `!op0.pfn' bit is that a NULL
pointer-to-member is any member with a zero PFN; the
DELTA field is unspecified. */
delta1 = build_ptrmemfunc_access_expr (op1,
delta_identifier);
e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
- e2 = cp_build_binary_op (EQ_EXPR,
+ e2 = cp_build_binary_op (EQ_EXPR,
pfn0,
cp_convert (TREE_TYPE (pfn0),
integer_zero_node));
|| !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
type0));
}
-
+
break;
case MAX_EXPR:
break;
}
- arithmetic_types_p =
- ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
- && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
- || code1 == COMPLEX_TYPE));
+ if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
+ && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+ || code1 == COMPLEX_TYPE)))
+ arithmetic_types_p = 1;
+ else
+ {
+ arithmetic_types_p = 0;
+ /* Vector arithmetic is only allowed when both sides are vectors. */
+ if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
+ {
+ if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
+ || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
+ TREE_TYPE (type1)))
+ {
+ binary_op_error (code);
+ return error_mark_node;
+ }
+ arithmetic_types_p = 1;
+ }
+ }
/* Determine the RESULT_TYPE, if it is not already known. */
if (!result_type
- && arithmetic_types_p
+ && arithmetic_types_p
&& (shorten || common || short_compare))
result_type = common_type (type0, type1);
/* If we're in a template, the only thing we need to know is the
RESULT_TYPE. */
if (processing_template_decl)
- return build2 (resultcode,
- build_type ? build_type : result_type,
+ return build2 (resultcode,
+ build_type ? build_type : result_type,
op0, op1);
if (arithmetic_types_p)
pass the copies by reference, then copy them back afterward. */
tree xop0 = op0, xop1 = op1, xresult_type = result_type;
enum tree_code xresultcode = resultcode;
- tree val
+ tree val
= shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
if (val != 0)
return cp_convert (boolean_type_node, val);
tree primop1 = get_narrower (op1, &unsignedp1);
/* Check for comparison of different enum types. */
- if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
- && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
+ if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
+ && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
&& TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
- != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
+ != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
{
- warning ("comparison between types %q#T and %q#T",
- TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
+ warning (0, "comparison between types %q#T and %q#T",
+ TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
}
/* Give warnings for comparisons between signed and unsigned
(result_type)))))
/* OK */;
else
- warning ("comparison between signed and unsigned integer expressions");
+ warning (0, "comparison between signed and unsigned integer expressions");
/* Warn if two unsigned values are being compared in a size
larger than their original size, and one (and only one) is the
primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
if (TREE_CODE (primop1) == BIT_NOT_EXPR)
primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
-
+
if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
{
tree primop;
{
mask = (~ (HOST_WIDE_INT) 0) << bits;
if ((mask & constant) != mask)
- warning ("comparison of promoted ~unsigned with constant");
+ warning (0, "comparison of promoted ~unsigned with constant");
}
}
else if (unsignedp0 && unsignedp1
< TYPE_PRECISION (result_type))
&& (TYPE_PRECISION (TREE_TYPE (primop1))
< TYPE_PRECISION (result_type)))
- warning ("comparison of promoted ~unsigned with unsigned");
+ warning (0, "comparison of promoted ~unsigned with unsigned");
}
}
}
|| (orig_op1 == null_node
&& TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
/* Or, both are NULL and the operation was not a comparison. */
- || (orig_op0 == null_node && orig_op1 == null_node
+ || (orig_op0 == null_node && orig_op1 == null_node
&& code != EQ_EXPR && code != NE_EXPR)))
/* Some sort of arithmetic operation involving NULL was
performed. Note that pointer-difference and pointer-addition
have already been handled above, and so we don't end up here in
that case. */
- warning ("NULL used in arithmetic");
+ warning (0, "NULL used in arithmetic");
if (! converted)
{
if (TREE_TYPE (op0) != result_type)
- op0 = cp_convert (result_type, op0);
+ op0 = cp_convert (result_type, op0);
if (TREE_TYPE (op1) != result_type)
- op1 = cp_convert (result_type, op1);
+ op1 = cp_convert (result_type, op1);
if (op0 == error_mark_node || op1 == error_mark_node)
return error_mark_node;
/* First do the subtraction as integers;
then drop through to build the divide operator. */
- op0 = cp_build_binary_op (MINUS_EXPR,
+ op0 = cp_build_binary_op (MINUS_EXPR,
cp_convert (restype, op0),
cp_convert (restype, op1));
if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
- op1 = (TYPE_PTROB_P (ptrtype)
+ op1 = (TYPE_PTROB_P (ptrtype)
? size_in_bytes (target_type)
: integer_one_node);
tree orig_expr = xarg;
tree exp;
int ptrmem = 0;
-
+
if (processing_template_decl)
{
if (type_dependent_expression_p (xarg))
if (TREE_CODE (xarg) != OFFSET_REF)
{
error ("invalid use of %qE to form a pointer-to-member-function."
- " Use a qualified-id.",
+ " Use a qualified-id.",
xarg);
return error_mark_node;
}
else
{
error ("parenthesis around %qE cannot be used to form a"
- " pointer-to-member-function",
+ " pointer-to-member-function",
xarg);
PTRMEM_OK_P (xarg) = 1;
}
}
-
+
if (TREE_CODE (xarg) == OFFSET_REF)
- {
- ptrmem = PTRMEM_OK_P (xarg);
-
- if (!ptrmem && !flag_ms_extensions
- && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
+ {
+ ptrmem = PTRMEM_OK_P (xarg);
+
+ if (!ptrmem && !flag_ms_extensions
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
{
/* A single non-static member, make sure we don't allow a
- pointer-to-member. */
+ pointer-to-member. */
xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
TREE_OPERAND (xarg, 0),
ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
PTRMEM_OK_P (xarg) = ptrmem;
- }
- }
+ }
+ }
else if (TREE_CODE (xarg) == TARGET_EXPR)
- warning ("taking address of temporary");
+ warning (0, "taking address of temporary");
exp = build_unary_op (ADDR_EXPR, xarg, 0);
}
}
/* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
-
+
tree
condition_conversion (tree expr)
{
t = fold_build_cleanup_point_expr (boolean_type_node, t);
return t;
}
-
+
/* Return an ADDR_EXPR giving the address of T. This function
attempts no optimizations or simplifications; it is a low-level
primitive. */
tree argtype = 0;
const char *errstring = NULL;
tree val;
+ const char *invalid_op_diag;
if (arg == error_mark_node)
return error_mark_node;
+ if ((invalid_op_diag
+ = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
+ ? CONVERT_EXPR
+ : code),
+ TREE_TYPE (xarg))))
+ {
+ error (invalid_op_diag);
+ return error_mark_node;
+ }
+
switch (code)
{
- /* CONVERT_EXPR stands for unary plus in this context. */
- case CONVERT_EXPR:
+ case UNARY_PLUS_EXPR:
case NEGATE_EXPR:
{
int flags = WANT_ARITH | WANT_ENUM;
/* Unary plus (but not unary minus) is allowed on pointers. */
- if (code == CONVERT_EXPR)
+ if (code == UNARY_PLUS_EXPR)
flags |= WANT_POINTER;
arg = build_expr_type_conversion (flags, arg, true);
if (!arg)
case NOP_EXPR:
break;
-
+
case REALPART_EXPR:
if (TREE_CODE (arg) == COMPLEX_CST)
return TREE_REALPART (arg);
}
else
return cp_convert (TREE_TYPE (arg), integer_zero_node);
-
+
case PREINCREMENT_EXPR:
case POSTINCREMENT_EXPR:
case PREDECREMENT_EXPR:
pedwarn ("ISO C++ forbids %sing an enum",
(code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
? "increment" : "decrement");
-
+
/* Compute the increment. */
if (TREE_CODE (argtype) == POINTER_TYPE)
{
tree type = complete_type (TREE_TYPE (argtype));
-
+
if (!COMPLETE_OR_VOID_TYPE_P (type))
error ("cannot %s a pointer to incomplete type %qT",
- ((code == PREINCREMENT_EXPR
- || code == POSTINCREMENT_EXPR)
- ? "increment" : "decrement"), TREE_TYPE (argtype));
+ ((code == PREINCREMENT_EXPR
+ || code == POSTINCREMENT_EXPR)
+ ? "increment" : "decrement"), TREE_TYPE (argtype));
else if ((pedantic || warn_pointer_arith)
&& !TYPE_PTROB_P (argtype))
pedwarn ("ISO C++ forbids %sing a pointer of type %qT",
- ((code == PREINCREMENT_EXPR
- || code == POSTINCREMENT_EXPR)
- ? "increment" : "decrement"), argtype);
+ ((code == PREINCREMENT_EXPR
+ || code == POSTINCREMENT_EXPR)
+ ? "increment" : "decrement"), argtype);
inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
}
else
if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
&& !really_overloaded_fn (TREE_OPERAND (arg, 1)))
- {
+ {
/* They're trying to take the address of a unique non-static
member function. This is ill-formed (except in MS-land),
but let's try to DTRT.
base, name);
}
arg = build_offset_ref (base, name, /*address_p=*/true);
- }
+ }
- offset_ref:
+ offset_ref:
if (type_unknown_p (arg))
return build1 (ADDR_EXPR, unknown_type_node, arg);
-
+
/* Handle complex lvalues (when permitted)
by reduction to simpler cases. */
val = unary_complex_lvalue (code, arg);
arg = OVL_CURRENT (arg);
break;
+ case OFFSET_REF:
+ /* Turn a reference to a non-static data member into a
+ pointer-to-member. */
+ {
+ tree type;
+ tree t;
+
+ if (!PTRMEM_OK_P (arg))
+ return build_unary_op (code, arg, 0);
+
+ t = TREE_OPERAND (arg, 1);
+ if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
+ {
+ error ("cannot create pointer to reference member %qD", t);
+ return error_mark_node;
+ }
+
+ type = build_ptrmem_type (context_for_name_lookup (t),
+ TREE_TYPE (t));
+ t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
+ return t;
+ }
+
default:
break;
}
}
else
{
+ tree object = TREE_OPERAND (arg, 0);
tree field = TREE_OPERAND (arg, 1);
- tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
- tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (rval)),
- decl_type_context (field),
- ba_check, NULL);
-
- rval = build_base_path (PLUS_EXPR, rval, binfo, 1);
-
- TREE_OPERAND (arg, 0) = build_indirect_ref (rval, NULL);
+ gcc_assert (same_type_ignoring_top_level_qualifiers_p
+ (TREE_TYPE (object), decl_type_context (field)));
addr = build_address (arg);
}
If ARG is not a kind of expression we can handle, return
NULL_TREE. */
-
+
tree
unary_complex_lvalue (enum tree_code code, tree arg)
{
if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
|| TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
|| TREE_CODE (arg) == OFFSET_REF)
- {
- tree t;
-
- gcc_assert (TREE_CODE (arg) != SCOPE_REF);
-
- if (TREE_CODE (arg) != OFFSET_REF)
- return 0;
-
- t = TREE_OPERAND (arg, 1);
-
- /* Check all this code for right semantics. */
- if (TREE_CODE (t) == FUNCTION_DECL)
- {
- if (DECL_DESTRUCTOR_P (t))
- error ("taking address of destructor");
- return build_unary_op (ADDR_EXPR, t, 0);
- }
- if (TREE_CODE (t) == VAR_DECL)
- return build_unary_op (ADDR_EXPR, t, 0);
- else
- {
- tree type;
-
- if (TREE_OPERAND (arg, 0)
- && ! is_dummy_object (TREE_OPERAND (arg, 0))
- && TREE_CODE (t) != FIELD_DECL)
- {
- error ("taking address of bound pointer-to-member expression");
- return error_mark_node;
- }
- if (!PTRMEM_OK_P (arg))
- return build_unary_op (code, arg, 0);
-
- if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
- {
- error ("cannot create pointer to reference member %qD", t);
- return error_mark_node;
- }
-
- type = build_ptrmem_type (context_for_name_lookup (t),
- TREE_TYPE (t));
- t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
- return t;
- }
- }
+ return NULL_TREE;
-
/* We permit compiler to make function calls returning
objects of aggregate type look like lvalues. */
{
case PARM_DECL:
if (x == current_class_ptr)
{
- error ("cannot take the address of %<this%>, which is an rvalue expression");
+ error ("cannot take the address of %<this%>, which is an rvalue expression");
TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */
return true;
}
}
else if (extra_warnings)
warning
- ("address requested for %qD, which is declared %<register%>", x);
+ (0, "address requested for %qD, which is declared %<register%>", x);
}
TREE_ADDRESSABLE (x) = 1;
return true;
expr = build_conditional_expr (ifexp, op1, op2);
if (processing_template_decl && expr != error_mark_node)
- return build_min_non_dep (COND_EXPR, expr,
+ return build_min_non_dep (COND_EXPR, expr,
orig_ifexp, orig_op1, orig_op2);
return expr;
}
tree build_x_compound_expr_from_list (tree list, const char *msg)
{
tree expr = TREE_VALUE (list);
-
+
if (TREE_CHAIN (list))
{
if (msg)
for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
expr = build_x_compound_expr (expr, TREE_VALUE (list));
}
-
+
return expr;
}
if (processing_template_decl && result != error_mark_node)
return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
-
+
return result;
}
build_compound_expr (tree lhs, tree rhs)
{
lhs = convert_to_void (lhs, "left-hand operand of comma");
-
+
if (lhs == error_mark_node || rhs == error_mark_node)
return error_mark_node;
-
+
if (TREE_CODE (rhs) == TARGET_EXPR)
{
/* If the rhs is a TARGET_EXPR, then build the compound
- expression inside the target_expr's initializer. This
+ expression inside the target_expr's initializer. This
helps the compiler to eliminate unnecessary temporaries. */
tree init = TREE_OPERAND (rhs, 1);
-
+
init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
TREE_OPERAND (rhs, 1) = init;
-
+
return rhs;
}
-
+
return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
}
static void
check_for_casting_away_constness (tree src_type, tree dest_type,
- void (*diag_fn)(const char *, ...),
+ void (*diag_fn)(const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2),
const char *description)
{
if (diag_fn && casts_away_constness (src_type, dest_type))
only the other direction is permitted. If C_CAST_P is true, this
conversion is taking place as part of a C-style cast. */
-tree
+tree
convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
bool c_cast_p)
{
if (TREE_CODE (expr) == PTRMEM_CST)
expr = cplus_expand_constant (expr);
delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
- TYPE_PTRMEM_CLASS_TYPE (type),
+ TYPE_PTRMEM_CLASS_TYPE (type),
allow_inverse_p,
c_cast_p);
if (!integer_zerop (delta))
- expr = cp_build_binary_op (PLUS_EXPR,
+ expr = cp_build_binary_op (PLUS_EXPR,
build_nop (ptrdiff_type_node, expr),
delta);
return build_nop (type, expr);
}
else
- return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
+ return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
allow_inverse_p, c_cast_p);
}
tree intype;
tree result;
tree orig;
- void (*diag_fn)(const char*, ...);
+ void (*diag_fn)(const char*, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
const char *desc;
/* Assume the cast is valid. */
if (c_cast_p)
{
/* C-style casts are allowed to cast away constness. With
- WARN_CAST_QUAL, we still want to issue a warning. */
- diag_fn = warn_cast_qual ? warning : NULL;
+ WARN_CAST_QUAL, we still want to issue a warning. */
+ diag_fn = warn_cast_qual ? warning0 : NULL;
desc = "cast";
}
else
diag_fn = error;
desc = "static_cast";
}
-
+
/* [expr.static.cast]
An lvalue of type "cv1 B", where B is a class type, can be cast
&& real_lvalue_p (expr)
&& DERIVED_FROM_P (intype, TREE_TYPE (type))
&& can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
- build_pointer_type (TYPE_MAIN_VARIANT
+ build_pointer_type (TYPE_MAIN_VARIANT
(TREE_TYPE (type))))
&& (c_cast_p
|| at_least_as_qualified_p (TREE_TYPE (type), intype)))
ambiguity. However, if this is a static_cast being performed
because the user wrote a C-style cast, then accessibility is
not considered. */
- base = lookup_base (TREE_TYPE (type), intype,
- c_cast_p ? ba_unique : ba_check,
+ base = lookup_base (TREE_TYPE (type), intype,
+ c_cast_p ? ba_unique : ba_check,
NULL);
/* Convert from "B*" to "D*". This function will check that "B"
is not a virtual base of "D". */
- expr = build_base_path (MINUS_EXPR, build_address (expr),
+ expr = build_base_path (MINUS_EXPR, build_address (expr),
base, /*nonnull=*/false);
/* Convert the pointer to a reference -- but then remember that
there are no expressions with reference type in C++. */
}
/* [expr.static.cast]
- If T is a reference type, the result is an lvalue; otherwise,
+ If T is a reference type, the result is an lvalue; otherwise,
the result is an rvalue. */
if (TREE_CODE (type) != REFERENCE_TYPE
&& real_lvalue_p (result))
result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
return result;
}
-
+
/* [expr.static.cast]
Any expression can be explicitly converted to type cv void. */
promotions, floating point promotion, integral conversions,
floating point conversions, floating-integral conversions,
pointer conversions, and pointer to member conversions. */
- if ((ARITHMETIC_TYPE_P (type) && ARITHMETIC_TYPE_P (intype))
- /* DR 128
+ /* DR 128
- A value of integral _or enumeration_ type can be explicitly
- converted to an enumeration type. */
- || (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
- && INTEGRAL_OR_ENUMERATION_TYPE_P (intype)))
+ A value of integral _or enumeration_ type can be explicitly
+ converted to an enumeration type. */
+ /* The effect of all that is that any conversion between any two
+ types which are integral, floating, or enumeration types can be
+ performed. */
+ if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
+ && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
{
expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
&& CLASS_TYPE_P (TREE_TYPE (type))
&& CLASS_TYPE_P (TREE_TYPE (intype))
- && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
- (TREE_TYPE (intype))),
- build_pointer_type (TYPE_MAIN_VARIANT
+ && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
+ (TREE_TYPE (intype))),
+ build_pointer_type (TYPE_MAIN_VARIANT
(TREE_TYPE (type)))))
{
tree base;
if (!c_cast_p)
check_for_casting_away_constness (intype, type, diag_fn, desc);
- base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
- c_cast_p ? ba_unique : ba_check,
+ base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
+ c_cast_p ? ba_unique : ba_check,
NULL);
return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
}
-
+
if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
|| (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
{
if (TYPE_PTRMEM_P (type))
{
- t1 = (build_ptrmem_type
+ t1 = (build_ptrmem_type
(c1,
TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
- t2 = (build_ptrmem_type
+ t2 = (build_ptrmem_type
(c2,
TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
}
if (can_convert (t1, t2))
{
if (!c_cast_p)
- check_for_casting_away_constness (intype, type, diag_fn,
+ check_for_casting_away_constness (intype, type, diag_fn,
desc);
return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
c_cast_p);
}
}
-
+
/* [expr.static.cast]
An rvalue of type "pointer to cv void" can be explicitly
converted to a pointer to object type. A value of type pointer
to object converted to "pointer to cv void" and back to the
original pointer type will have its original value. */
- if (TREE_CODE (intype) == POINTER_TYPE
+ if (TREE_CODE (intype) == POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (intype))
&& TYPE_PTROB_P (type))
{
if (valid_p)
return result;
- error ("invalid static_cast from type %qT to type %qT",
+ error ("invalid static_cast from type %qT to type %qT",
TREE_TYPE (expr), type);
return error_mark_node;
}
if (pedantic || warn_pmf2ptr)
pedwarn ("converting from %qT to %qT", intype, type);
-
+
if (TREE_CODE (intype) == METHOD_TYPE)
expr = build_addr_func (expr);
else if (TREE_CODE (expr) == PTRMEM_CST)
if (! real_lvalue_p (expr))
{
error ("invalid cast of an rvalue expression of type "
- "%qT to type %qT",
+ "%qT to type %qT",
intype, type);
return error_mark_node;
}
if (TYPE_PTR_P (intype)
&& (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
COMPARE_BASE | COMPARE_DERIVED)))
- warning ("casting %qT to %qT does not dereference pointer",
+ warning (0, "casting %qT to %qT does not dereference pointer",
intype, type);
expr = build_unary_op (ADDR_EXPR, expr, 0);
pointer-to-function and pointer-to-void types. If
-Wno-pmf-conversions has not been specified,
convert_member_func_to_ptr will issue an error message. */
- if ((TYPE_PTRMEMFUNC_P (intype)
+ if ((TYPE_PTRMEMFUNC_P (intype)
|| TREE_CODE (intype) == METHOD_TYPE)
&& TYPE_PTR_P (type)
&& (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
array-to-pointer, and function-to-pointer conversions are
performed. */
expr = decay_conversion (expr);
-
+
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
if (TREE_CODE (expr) == NOP_EXPR
{
if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
pedwarn ("cast from %qT to %qT loses precision",
- intype, type);
+ intype, type);
}
/* [expr.reinterpret.cast]
A value of integral or enumeration type can be explicitly
|| (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
{
if (!c_cast_p)
- check_for_casting_away_constness (intype, type, error,
+ check_for_casting_away_constness (intype, type, error,
"reinterpret_cast");
/* Warn about possible alignment problems. */
if (STRICT_ALIGNMENT && warn_cast_align
&& COMPLETE_TYPE_P (TREE_TYPE (type))
&& COMPLETE_TYPE_P (TREE_TYPE (intype))
&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
- warning ("cast from %qT to %qT increases required alignment of "
+ warning (0, "cast from %qT to %qT increases required alignment of "
"target type",
intype, type);
-
+
return fold_if_not_in_template (build_nop (type, expr));
}
else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
{
if (pedantic)
/* Only issue a warning, as we have always supported this
- where possible, and it is necessary in some cases. DR 195
- addresses this issue, but as of 2004/10/26 is still in
- drafting. */
- warning ("ISO C++ forbids casting between pointer-to-function and pointer-to-object");
+ where possible, and it is necessary in some cases. DR 195
+ addresses this issue, but as of 2004/10/26 is still in
+ drafting. */
+ warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
return fold_if_not_in_template (build_nop (type, expr));
}
else if (TREE_CODE (type) == VECTOR_TYPE)
error ("invalid cast from type %qT to type %qT", intype, type);
return error_mark_node;
}
-
+
return cp_convert (type, expr);
}
if (processing_template_decl)
{
tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
-
+
if (!TREE_SIDE_EFFECTS (t)
&& type_dependent_expression_p (expr))
/* There might turn out to be side effects inside expr. */
}
if (complain)
- error ("invalid const_cast from type %qT to type %qT",
+ error ("invalid const_cast from type %qT to type %qT",
src_type, dst_type);
return error_mark_node;
}
if (processing_template_decl)
{
tree t = build_min (CONST_CAST_EXPR, type, expr);
-
+
if (!TREE_SIDE_EFFECTS (t)
&& type_dependent_expression_p (expr))
/* There might turn out to be side effects inside expr. */
&valid_p);
/* The static_cast or reinterpret_cast may be followed by a
const_cast. */
- if (valid_p
+ if (valid_p
/* A valid cast may result in errors if, for example, a
conversion to am ambiguous base class is required. */
&& !error_operand_p (result))
tree preeval = NULL_TREE;
rhs = stabilize_expr (rhs, &preeval);
-
+
/* Check this here to avoid odd errors when trying to convert
a throw to the type of the COND_EXPR. */
if (!lvalue_or_else (lhs, lv_assign))
cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
return cond;
}
-
+
default:
break;
}
else
{
/* A binary op has been requested. Combine the old LHS
- value with the RHS producing the value we should actually
- store into the LHS. */
+ value with the RHS producing the value we should actually
+ store into the LHS. */
gcc_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE));
lhs = stabilize_reference (lhs);
TREE_TYPE (lhs), TREE_TYPE (rhs));
return error_mark_node;
}
-
+
/* Now it looks like a plain assignment. */
modifycode = NOP_EXPR;
}
if (TREE_CODE (lhstype) == ARRAY_TYPE)
{
int from_array;
-
+
if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
{
pedwarn ("ISO C++ forbids assignment of arrays");
from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
- ? 1 + (modifycode != INIT_EXPR): 0;
+ ? 1 + (modifycode != INIT_EXPR): 0;
return build_vec_init (lhs, NULL_TREE, newrhs, from_array);
}
if (newrhs == error_mark_node)
return error_mark_node;
+ if (c_dialect_objc () && flag_objc_gc)
+ {
+ result = objc_generate_write_barrier (lhs, modifycode, newrhs);
+
+ if (result)
+ return result;
+ }
+
result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
lhstype, lhs, newrhs);
a pointer to member of FROM to a pointer to member of TO. */
static tree
-get_delta_difference (tree from, tree to,
+get_delta_difference (tree from, tree to,
bool allow_inverse_p,
bool c_cast_p)
{
tree binfo;
- tree virt_binfo;
base_kind kind;
tree result;
binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
if (kind == bk_inaccessible || kind == bk_ambig)
error (" in pointer to member function conversion");
- else if (!binfo)
- {
- if (!allow_inverse_p)
- {
- error_not_base_type (from, to);
- error (" in pointer to member conversion");
- }
- else
- {
- binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check,
- &kind);
- if (binfo)
- {
- virt_binfo = binfo_from_vbase (binfo);
- if (virt_binfo)
- /* This is a reinterpret cast, we choose to do nothing. */
- warning ("pointer to member cast via virtual base %qT",
- BINFO_TYPE (virt_binfo));
- else
- result = size_diffop (size_zero_node, BINFO_OFFSET (binfo));
- }
- }
- }
- else
+ else if (binfo)
{
- virt_binfo = binfo_from_vbase (binfo);
- if (!virt_binfo)
+ if (kind != bk_via_virtual)
result = BINFO_OFFSET (binfo);
else
{
+ tree virt_binfo = binfo_from_vbase (binfo);
+
/* This is a reinterpret cast, we choose to do nothing. */
if (allow_inverse_p)
- warning ("pointer to member cast via virtual base %qT",
+ warning (0, "pointer to member cast via virtual base %qT",
BINFO_TYPE (virt_binfo));
else
error ("pointer to member conversion via virtual base %qT",
BINFO_TYPE (virt_binfo));
}
}
+ else if (same_type_ignoring_top_level_qualifiers_p (from, to))
+ /* Pointer to member of incomplete class is permitted*/;
+ else if (!allow_inverse_p)
+ {
+ error_not_base_type (from, to);
+ error (" in pointer to member conversion");
+ }
+ else
+ {
+ binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check, &kind);
+ if (binfo)
+ {
+ if (kind != bk_via_virtual)
+ result = size_diffop (size_zero_node, BINFO_OFFSET (binfo));
+ else
+ {
+ /* This is a reinterpret cast, we choose to do nothing. */
+ tree virt_binfo = binfo_from_vbase (binfo);
- return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
+ warning (0, "pointer to member cast via virtual base %qT",
+ BINFO_TYPE (virt_binfo));
+ }
+ }
+ }
+
+ return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
result));
}
TREE_STATIC (u) = (TREE_CONSTANT (u)
&& (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
!= NULL_TREE)
- && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
+ && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
!= NULL_TREE));
return u;
}
tree npfn = NULL_TREE;
tree n;
- if (!force
+ if (!force
&& !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
- error ("invalid conversion to type %qT from type %qT",
- to_type, pfn_type);
+ error ("invalid conversion to type %qT from type %qT",
+ to_type, pfn_type);
n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
{
pfn = build_c_cast (type, integer_zero_node);
return build_ptrmemfunc1 (to_type,
- integer_zero_node,
+ integer_zero_node,
pfn);
}
return instantiate_type (type, pfn, tf_error | tf_warning);
fn = TREE_OPERAND (pfn, 0);
- gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
+ gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
+ /* In a template, we will have preserved the
+ OFFSET_REF. */
+ || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
return make_ptrmem_cst (to_type, fn);
}
else
{
/* If we're dealing with a virtual function, we have to adjust 'this'
- again, to point to the base which provides the vtable entry for
- fn; the call will do the opposite adjustment. */
+ again, to point to the base which provides the vtable entry for
+ fn; the call will do the opposite adjustment. */
tree orig_class = DECL_CONTEXT (fn);
tree binfo = binfo_or_else (orig_class, fn_class);
*delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
{
tree delta;
tree pfn;
-
+
expand_ptrmemfunc_cst (t, &delta, &pfn);
if (pfn)
return pfn;
/* Simplify the RHS if possible. */
if (TREE_CODE (rhs) == CONST_DECL)
rhs = DECL_INITIAL (rhs);
-
+
+ if (c_dialect_objc ())
+ {
+ int parmno;
+ tree rname = fndecl;
+
+ if (!strcmp (errtype, "assignment"))
+ parmno = -1;
+ else if (!strcmp (errtype, "initialization"))
+ parmno = -2;
+ else
+ {
+ tree selector = objc_message_selector ();
+
+ parmno = parmnum;
+
+ if (selector && parmno > 1)
+ {
+ rname = selector;
+ parmno -= 1;
+ }
+ }
+
+ if (objc_compare_types (type, rhstype, parmno, rname))
+ return convert (type, rhs);
+ }
+
/* [expr.ass]
The expression is implicitly converted (clause _conv_) to the
/* When -Wno-pmf-conversions is use, we just silently allow
conversions from pointers-to-members to plain pointers. If
the conversion doesn't work, cp_convert will complain. */
- if (!warn_pmf2ptr
- && TYPE_PTR_P (type)
+ if (!warn_pmf2ptr
+ && TYPE_PTR_P (type)
&& TYPE_PTRMEMFUNC_P (rhstype))
rhs = cp_convert (strip_top_quals (type), rhs);
else
instantiate_type (type, rhs, tf_error | tf_warning);
else if (fndecl)
error ("cannot convert %qT to %qT for argument %qP to %qD",
- rhstype, type, parmnum, fndecl);
+ rhstype, type, parmnum, fndecl);
else
error ("cannot convert %qT to %qT in %s", rhstype, type, errtype);
return error_mark_node;
/* We accept references to incomplete types, so we can
return here before checking if RHS is of complete type. */
-
+
if (codel == REFERENCE_TYPE)
{
/* This should eventually happen in convert_arguments. */
cp_error_at ("in passing argument %P of %q+D", parmnum, fndecl);
}
return rhs;
- }
+ }
if (exp != 0)
exp = require_complete_type (exp);
if (TREE_CODE (whats_returned) != ADDR_EXPR)
return;
- whats_returned = TREE_OPERAND (whats_returned, 0);
+ whats_returned = TREE_OPERAND (whats_returned, 0);
if (TREE_CODE (valtype) == REFERENCE_TYPE)
{
if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
|| TREE_CODE (whats_returned) == TARGET_EXPR)
{
- warning ("returning reference to temporary");
+ warning (0, "returning reference to temporary");
return;
}
- if (TREE_CODE (whats_returned) == VAR_DECL
+ if (TREE_CODE (whats_returned) == VAR_DECL
&& DECL_NAME (whats_returned)
&& TEMP_NAME_P (DECL_NAME (whats_returned)))
{
- warning ("reference to non-lvalue returned");
+ warning (0, "reference to non-lvalue returned");
return;
}
}
|| TREE_PUBLIC (whats_returned)))
{
if (TREE_CODE (valtype) == REFERENCE_TYPE)
- cp_warning_at ("reference to local variable %qD returned",
+ cp_warning_at ("reference to local variable %qD returned",
whats_returned);
else
- cp_warning_at ("address of local variable %qD returned",
+ cp_warning_at ("address of local variable %qD returned",
whats_returned);
return;
}
(This is a G++ extension, used to get better code for functions
that call the `volatile' function.) */
if (TREE_THIS_VOLATILE (current_function_decl))
- warning ("function declared %<noreturn%> has a %<return%> statement");
+ warning (0, "function declared %<noreturn%> has a %<return%> statement");
/* Check for various simple errors. */
if (DECL_DESTRUCTOR_P (current_function_decl))
current_function_returns_value = 1;
return retval;
}
-
+
/* When no explicit return-value is given in a function with a named
return value, the named return value is used. */
result = DECL_RESULT (current_function_decl);
/* Check for a return statement with a value in a function that
isn't supposed to return a value. */
else if (retval && !fn_returns_value_p)
- {
+ {
if (VOID_TYPE_P (TREE_TYPE (retval)))
/* You can return a `void' value from a function of `void'
type. In that case, we have to evaluate the expression for
finish_expr_stmt (retval);
else
pedwarn ("return-statement with a value, in function "
- "returning 'void'");
+ "returning 'void'");
current_function_returns_null = 1;
&& !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
&& ! flag_check_new
&& null_ptr_cst_p (retval))
- warning ("%<operator new%> must not return NULL unless it is "
- "declared %<throw()%> (or -fcheck-new is in effect)");
+ warning (0, "%<operator new%> must not return NULL unless it is "
+ "declared %<throw()%> (or -fcheck-new is in effect)");
/* Effective C++ rule 15. See also start_function. */
if (warn_ecpp
}
if (warn)
- warning ("%<operator=%> should return a reference to %<*this%>");
+ warning (0, "%<operator=%> should return a reference to %<*this%>");
}
/* The fabled Named Return Value optimization, as per [class.copy]/15:
/* First convert the value to the function's return type, then
to the type of return value's location to handle the
- case that functype is smaller than the valtype. */
+ case that functype is smaller than the valtype. */
retval = convert_for_initialization
(NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
"return", NULL_TREE, 0);
else
maybe_warn_about_returning_address_of_local (retval);
}
-
+
/* Actually copy the value returned into the appropriate location. */
if (retval && retval != result)
retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
so the usual checks are not appropriate. */
if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
{
- if (!at_least_as_qualified_p (to, from))
+ /* In Objective-C++, some types may have been 'volatilized' by
+ the compiler for EH; when comparing them here, the volatile
+ qualification must be ignored. */
+ bool objc_quals_match = objc_type_quals_match (to, from);
+
+ if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
return 0;
- if (!at_least_as_qualified_p (from, to))
+ if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
{
if (constp == 0)
return 0;
if (TREE_CODE (from) == OFFSET_TYPE
&& comptypes (TYPE_OFFSET_BASETYPE (to),
- TYPE_OFFSET_BASETYPE (from),
+ TYPE_OFFSET_BASETYPE (from),
COMPARE_BASE | COMPARE_DERIVED))
continue;
if (TREE_CODE (to) != POINTER_TYPE)
return comptypes
- (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
+ (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
COMPARE_BASE | COMPARE_DERIVED);
}
}
if (type == error_mark_node)
return;
- if (TREE_CODE (type) == FUNCTION_TYPE
+ if (TREE_CODE (type) == FUNCTION_TYPE
&& type_quals != TYPE_UNQUALIFIED)
{
/* This was an error in C++98 (cv-qualifiers cannot be added to
- a function type), but DR 295 makes the code well-formed by
- dropping the extra qualifiers. */
+ a function type), but DR 295 makes the code well-formed by
+ dropping the extra qualifiers. */
if (pedantic)
- {
- tree bad_type = build_qualified_type (type, type_quals);
- pedwarn ("ignoring %qV qualifiers added to function type %qT",
- bad_type, type);
- }
+ {
+ tree bad_type = build_qualified_type (type, type_quals);
+ pedwarn ("ignoring %qV qualifiers added to function type %qT",
+ bad_type, type);
+ }
TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
return;
TYPE_NEEDS_CONSTRUCTING (type)
/* If the type isn't complete, we don't know yet if it will need
constructing. */
- || !COMPLETE_TYPE_P (type)
+ || !COMPLETE_TYPE_P (type)
/* If the type has a mutable component, that component might be
modified. */
|| TYPE_HAS_MUTABLE_P (type))
and pointers to members (conv.qual), the "member" aspect of a
pointer to member level is ignored when determining if a const
cv-qualifier has been cast away. */
- if (TYPE_PTRMEM_P (*t1))
- *t1 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t1));
- if (TYPE_PTRMEM_P (*t2))
- *t2 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t2));
-
/* [expr.const.cast]
For two pointer types:
- X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
- X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
- K is min(N,M)
+ X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
+ X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
+ K is min(N,M)
casting from X1 to X2 casts away constness if, for a non-pointer
type T there does not exist an implicit conversion (clause
_conv_) from:
- Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
-
- to
+ Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
- Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
+ to
- if (TREE_CODE (*t1) != POINTER_TYPE
- || TREE_CODE (*t2) != POINTER_TYPE)
+ Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
+ if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
+ || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
{
*t1 = cp_build_qualified_type (void_type_node,
cp_type_quals (*t1));
cp_type_quals (*t2));
return;
}
-
+
quals1 = cp_type_quals (*t1);
quals2 = cp_type_quals (*t2);
- *t1 = TREE_TYPE (*t1);
- *t2 = TREE_TYPE (*t2);
+
+ if (TYPE_PTRMEM_P (*t1))
+ *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
+ else
+ *t1 = TREE_TYPE (*t1);
+ if (TYPE_PTRMEM_P (*t2))
+ *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
+ else
+ *t2 = TREE_TYPE (*t2);
+
casts_away_constness_r (t1, t2);
*t1 = build_pointer_type (*t1);
*t2 = build_pointer_type (*t2);
if (TREE_CODE (t2) == REFERENCE_TYPE)
{
/* [expr.const.cast]
-
+
Casting from an lvalue of type T1 to an lvalue of type T2
using a reference cast casts away constness if a cast from an
rvalue of type "pointer to T1" to the type "pointer to T2"
if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
/* [expr.const.cast]
-
+
Casting from an rvalue of type "pointer to data member of X
of type T1" to the type "pointer to data member of Y of type
T2" casts away constness if a cast from an rvalue of type
/* Casting away constness is only something that makes sense for
pointer or reference types. */
- if (TREE_CODE (t1) != POINTER_TYPE
+ if (TREE_CODE (t1) != POINTER_TYPE
|| TREE_CODE (t2) != POINTER_TYPE)
return false;
t = TREE_TYPE (t);
return t;
}
+
+
+/* Return nonzero if REF is an lvalue valid for this language;
+ otherwise, print an error message and return zero. USE says
+ how the lvalue is being used and so selects the error message. */
+
+int
+lvalue_or_else (tree ref, enum lvalue_use use)
+{
+ int win = lvalue_p (ref);
+
+ if (!win)
+ lvalue_error (use);
+
+ return win;
+}