tree
convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
{
if (expr == error_mark_node
|| TREE_TYPE (expr) == error_mark_node)
return error_mark_node;
if (!TREE_TYPE (expr))
return expr;
if (invalid_nonstatic_memfn_p (expr, complain))
return error_mark_node;
if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
{
if (complain & tf_error)
error ("pseudo-destructor is not called");
return error_mark_node;
}
if (VOID_TYPE_P (TREE_TYPE (expr)))
return expr;
switch (TREE_CODE (expr))
{
case COND_EXPR:
{
/* The two parts of a cond expr might be separate lvalues. */
tree op1 = TREE_OPERAND (expr,1);
tree op2 = TREE_OPERAND (expr,2);
tree new_op1 = convert_to_void
(op1, (implicit && !TREE_SIDE_EFFECTS (op2)
? "second operand of conditional" : NULL), complain);
tree new_op2 = convert_to_void
(op2, (implicit && !TREE_SIDE_EFFECTS (op1)
? "third operand of conditional" : NULL), complain);
expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
TREE_OPERAND (expr, 0), new_op1, new_op2);
break;
}
case COMPOUND_EXPR:
{
/* The second part of a compound expr contains the value. */
tree op1 = TREE_OPERAND (expr,1);
tree new_op1 = convert_to_void
(op1, (implicit && !TREE_NO_WARNING (expr)
? "right-hand operand of comma" : NULL), complain);
if (new_op1 != op1)
{
tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1),
TREE_OPERAND (expr, 0), new_op1);
expr = t;
}
break;
}
case NON_LVALUE_EXPR:
case NOP_EXPR:
/* These have already decayed to rvalue. */
break;
case CALL_EXPR: /* We have a special meaning for volatile void fn(). */
break;
case INDIRECT_REF:
{
tree type = TREE_TYPE (expr);
int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
== REFERENCE_TYPE;
int is_volatile = TYPE_VOLATILE (type);
int is_complete = COMPLETE_TYPE_P (complete_type (type));
/* Can't load the value if we don't know the type. */
if (is_volatile && !is_complete)
{
if (complain & tf_warning)
warning (0, "object of incomplete type %qT will not be accessed in %s",
type, implicit ? implicit : "void context");
}
/* Don't load the value if this is an implicit dereference, or if
the type needs to be handled by ctors/dtors. */
else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
{
if (complain & tf_warning)
warning (0, "object of type %qT will not be accessed in %s",
TREE_TYPE (TREE_OPERAND (expr, 0)),
implicit ? implicit : "void context");
}
if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
expr = TREE_OPERAND (expr, 0);
break;
}
case VAR_DECL:
{
/* External variables might be incomplete. */
tree type = TREE_TYPE (expr);
int is_complete = COMPLETE_TYPE_P (complete_type (type));
if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
expr, type, implicit ? implicit : "void context");
break;
}
case TARGET_EXPR:
/* Don't bother with the temporary object returned from a function if
we don't use it and don't need to destroy it. We'll still
allocate space for it in expand_call or declare_return_variable,
but we don't need to track it through all the tree phases. */
if (TARGET_EXPR_IMPLICIT_P (expr)
&& TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (expr)))
{
tree init = TARGET_EXPR_INITIAL (expr);
if (TREE_CODE (init) == AGGR_INIT_EXPR
&& !AGGR_INIT_VIA_CTOR_P (init))
{
tree fn = AGGR_INIT_EXPR_FN (init);
expr = build_call_array (TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
fn,
aggr_init_expr_nargs (init),
AGGR_INIT_EXPR_ARGP (init));
}
}
break;
default:;
}
{
tree probe = expr;
if (TREE_CODE (probe) == ADDR_EXPR)
probe = TREE_OPERAND (expr, 0);
if (type_unknown_p (probe))
{
/* [over.over] enumerates the places where we can take the address
of an overloaded function, and this is not one of them. */
if (complain & tf_error)
error ("%s cannot resolve address of overloaded function",
implicit ? implicit : "void cast");
else
return error_mark_node;
expr = void_zero_node;
}
else if (implicit && probe == expr && is_overloaded_fn (probe))
{
/* Only warn when there is no &. */
if (complain & tf_warning)
warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
implicit, expr);
if (TREE_CODE (expr) == COMPONENT_REF)
expr = TREE_OPERAND (expr, 0);
}
}
if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
{
if (implicit
&& warn_unused_value
&& !TREE_NO_WARNING (expr)
&& !processing_template_decl)
{
/* The middle end does not warn about expressions that have
been explicitly cast to void, so we must do so here. */
if (!TREE_SIDE_EFFECTS (expr)) {
if (complain & tf_warning)
warning (OPT_Wunused_value, "%s has no effect", implicit);
}
else
{
tree e;
enum tree_code code;
enum tree_code_class tclass;
e = expr;
/* We might like to warn about (say) "(int) f()", as the
cast has no effect, but the compiler itself will
generate implicit conversions under some
circumstances. (For example a block copy will be
turned into a call to "__builtin_memcpy", with a
conversion of the return value to an appropriate
type.) So, to avoid false positives, we strip
conversions. Do not use STRIP_NOPs because it will
not strip conversions to "void", as that is not a
mode-preserving conversion. */
while (TREE_CODE (e) == NOP_EXPR)
e = TREE_OPERAND (e, 0);
code = TREE_CODE (e);
tclass = TREE_CODE_CLASS (code);
if ((tclass == tcc_comparison
|| tclass == tcc_unary
|| (tclass == tcc_binary
&& !(code == MODIFY_EXPR
|| code == INIT_EXPR
|| code == PREDECREMENT_EXPR
|| code == PREINCREMENT_EXPR
|| code == POSTDECREMENT_EXPR
|| code == POSTINCREMENT_EXPR)))
&& (complain & tf_warning))
warning (OPT_Wunused_value, "value computed is not used");
}
}
expr = build1 (CONVERT_EXPR, void_type_node, expr);
}
if (! TREE_SIDE_EFFECTS (expr))
expr = void_zero_node;
return expr;
}
tree
convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
{
if (expr == error_mark_node
|| TREE_TYPE (expr) == error_mark_node)
return error_mark_node;
if (implicit == ICV_CAST)
mark_exp_read (expr);
else
{
tree exprv = expr;
while (TREE_CODE (exprv) == COMPOUND_EXPR)
exprv = TREE_OPERAND (exprv, 1);
if (DECL_P (exprv)
|| handled_component_p (exprv)
|| TREE_CODE (exprv) == INDIRECT_REF)
/* Expr is not being 'used' here, otherwise we whould have
called mark_{rl}value_use use here, which would have in turn
called mark_exp_read. Rather, we call mark_exp_read directly
to avoid some warnings when
-Wunused-but-set-{variable,parameter} is in effect. */
mark_exp_read (exprv);
}
if (!TREE_TYPE (expr))
return expr;
if (invalid_nonstatic_memfn_p (expr, complain))
return error_mark_node;
if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
{
if (complain & tf_error)
error ("pseudo-destructor is not called");
return error_mark_node;
}
if (VOID_TYPE_P (TREE_TYPE (expr)))
return expr;
switch (TREE_CODE (expr))
{
case COND_EXPR:
{
/* The two parts of a cond expr might be separate lvalues. */
tree op1 = TREE_OPERAND (expr,1);
tree op2 = TREE_OPERAND (expr,2);
bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2);
tree new_op1, new_op2;
if (implicit != ICV_CAST && !side_effects)
{
new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
}
else
{
new_op1 = convert_to_void (op1, ICV_CAST, complain);
new_op2 = convert_to_void (op2, ICV_CAST, complain);
}
expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
TREE_OPERAND (expr, 0), new_op1, new_op2);
break;
}
case COMPOUND_EXPR:
{
/* The second part of a compound expr contains the value. */
tree op1 = TREE_OPERAND (expr,1);
tree new_op1;
if (implicit != ICV_CAST && !TREE_NO_WARNING (expr))
new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
else
new_op1 = convert_to_void (op1, ICV_CAST, complain);
if (new_op1 != op1)
{
tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1),
TREE_OPERAND (expr, 0), new_op1);
expr = t;
}
break;
}
case NON_LVALUE_EXPR:
case NOP_EXPR:
/* These have already decayed to rvalue. */
break;
case CALL_EXPR: /* We have a special meaning for volatile void fn(). */
break;
case INDIRECT_REF:
{
tree type = TREE_TYPE (expr);
int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
== REFERENCE_TYPE;
int is_volatile = TYPE_VOLATILE (type);
int is_complete = COMPLETE_TYPE_P (complete_type (type));
/* Can't load the value if we don't know the type. */
if (is_volatile && !is_complete)
{
if (complain & tf_warning)
switch (implicit)
{
case ICV_CAST:
warning (0, "conversion to void will not access "
"object of incomplete type %qT", type);
break;
case ICV_SECOND_OF_COND:
warning (0, "indirection will not access object of "
"incomplete type %qT in second operand "
"of conditional expression", type);
break;
case ICV_THIRD_OF_COND:
warning (0, "indirection will not access object of "
"incomplete type %qT in third operand "
"of conditional expression", type);
break;
case ICV_RIGHT_OF_COMMA:
warning (0, "indirection will not access object of "
"incomplete type %qT in right operand of "
"comma operator", type);
break;
case ICV_LEFT_OF_COMMA:
warning (0, "indirection will not access object of "
"incomplete type %qT in left operand of "
"comma operator", type);
break;
case ICV_STATEMENT:
warning (0, "indirection will not access object of "
"incomplete type %qT in statement", type);
break;
case ICV_THIRD_IN_FOR:
warning (0, "indirection will not access object of "
"incomplete type %qT in for increment "
"expression", type);
break;
default:
gcc_unreachable ();
}
}
/* Don't load the value if this is an implicit dereference, or if
the type needs to be handled by ctors/dtors. */
else if (is_volatile && is_reference)
{
if (complain & tf_warning)
switch (implicit)
{
case ICV_CAST:
warning (0, "conversion to void will not access "
"object of type %qT", type);
break;
case ICV_SECOND_OF_COND:
warning (0, "implicit dereference will not access object "
"of type %qT in second operand of "
"conditional expression", type);
break;
case ICV_THIRD_OF_COND:
warning (0, "implicit dereference will not access object "
"of type %qT in third operand of "
"conditional expression", type);
break;
case ICV_RIGHT_OF_COMMA:
warning (0, "implicit dereference will not access object "
"of type %qT in right operand of "
"comma operator", type);
break;
case ICV_LEFT_OF_COMMA:
warning (0, "implicit dereference will not access object "
"of type %qT in left operand of comma operator",
type);
break;
case ICV_STATEMENT:
warning (0, "implicit dereference will not access object "
"of type %qT in statement", type);
break;
case ICV_THIRD_IN_FOR:
warning (0, "implicit dereference will not access object "
"of type %qT in for increment expression",
type);
break;
default:
gcc_unreachable ();
}
}
else if (is_volatile && TREE_ADDRESSABLE (type))
{
if (complain & tf_warning)
switch (implicit)
{
case ICV_CAST:
warning (0, "conversion to void will not access "
"object of non-trivially-copyable type %qT",
type);
break;
case ICV_SECOND_OF_COND:
warning (0, "indirection will not access object of "
"non-trivially-copyable type %qT in second "
"operand of conditional expression", type);
break;
case ICV_THIRD_OF_COND:
warning (0, "indirection will not access object of "
"non-trivially-copyable type %qT in third "
"operand of conditional expression", type);
break;
case ICV_RIGHT_OF_COMMA:
warning (0, "indirection will not access object of "
"non-trivially-copyable type %qT in right "
"operand of comma operator", type);
break;
case ICV_LEFT_OF_COMMA:
warning (0, "indirection will not access object of "
"non-trivially-copyable type %qT in left "
"operand of comma operator", type);
break;
case ICV_STATEMENT:
warning (0, "indirection will not access object of "
"non-trivially-copyable type %qT in statement",
type);
break;
case ICV_THIRD_IN_FOR:
warning (0, "indirection will not access object of "
"non-trivially-copyable type %qT in for "
"increment expression", type);
break;
default:
gcc_unreachable ();
}
}
if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
{
/* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
operation is stripped off. Note that we don't warn about
- an expression with TREE_NO_WARNING set. (For an example of
such expressions, see build_over_call in call.c.)
- automatic dereferencing of references, since the user cannot
control it. (See also warn_if_unused_value() in stmt.c.) */
if (warn_unused_value
&& implicit != ICV_CAST
&& (complain & tf_warning)
&& !TREE_NO_WARNING (expr)
&& !is_reference)
warning (OPT_Wunused_value, "value computed is not used");
expr = TREE_OPERAND (expr, 0);
}
break;
}
case VAR_DECL:
{
/* External variables might be incomplete. */
tree type = TREE_TYPE (expr);
int is_complete = COMPLETE_TYPE_P (complete_type (type));
if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
switch (implicit)
{
case ICV_CAST:
warning (0, "conversion to void will not access "
"object %qE of incomplete type %qT", expr, type);
break;
case ICV_SECOND_OF_COND:
warning (0, "variable %qE of incomplete type %qT will not "
"be accessed in second operand of "
"conditional expression", expr, type);
break;
case ICV_THIRD_OF_COND:
warning (0, "variable %qE of incomplete type %qT will not "
"be accessed in third operand of "
"conditional expression", expr, type);
break;
case ICV_RIGHT_OF_COMMA:
warning (0, "variable %qE of incomplete type %qT will not "
"be accessed in right operand of comma operator",
expr, type);
break;
case ICV_LEFT_OF_COMMA:
warning (0, "variable %qE of incomplete type %qT will not "
"be accessed in left operand of comma operator",
expr, type);
break;
case ICV_STATEMENT:
warning (0, "variable %qE of incomplete type %qT will not "
"be accessed in statement", expr, type);
break;
case ICV_THIRD_IN_FOR:
warning (0, "variable %qE of incomplete type %qT will not "
"be accessed in for increment expression",
expr, type);
break;
default:
gcc_unreachable ();
}
break;
}
case TARGET_EXPR:
/* Don't bother with the temporary object returned from a function if
we don't use it and don't need to destroy it. We'll still
allocate space for it in expand_call or declare_return_variable,
but we don't need to track it through all the tree phases. */
if (TARGET_EXPR_IMPLICIT_P (expr)
&& TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (expr)))
{
tree init = TARGET_EXPR_INITIAL (expr);
if (TREE_CODE (init) == AGGR_INIT_EXPR
&& !AGGR_INIT_VIA_CTOR_P (init))
{
tree fn = AGGR_INIT_EXPR_FN (init);
expr = build_call_array_loc (input_location,
TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
fn,
aggr_init_expr_nargs (init),
AGGR_INIT_EXPR_ARGP (init));
}
}
break;
default:;
}
expr = resolve_nondeduced_context (expr);
{
tree probe = expr;
if (TREE_CODE (probe) == ADDR_EXPR)
probe = TREE_OPERAND (expr, 0);
if (type_unknown_p (probe))
{
/* [over.over] enumerates the places where we can take the address
of an overloaded function, and this is not one of them. */
if (complain & tf_error)
switch (implicit)
{
case ICV_CAST:
error ("conversion to void "
"cannot resolve address of overloaded function");
break;
case ICV_SECOND_OF_COND:
error ("second operand of conditional expression "
"cannot resolve address of overloaded function");
break;
case ICV_THIRD_OF_COND:
error ("third operand of conditional expression "
"cannot resolve address of overloaded function");
break;
case ICV_RIGHT_OF_COMMA:
error ("right operand of comma operator "
"cannot resolve address of overloaded function");
break;
case ICV_LEFT_OF_COMMA:
error ("left operand of comma operator "
"cannot resolve address of overloaded function");
break;
case ICV_STATEMENT:
error ("statement "
"cannot resolve address of overloaded function");
break;
case ICV_THIRD_IN_FOR:
error ("for increment expression "
"cannot resolve address of overloaded function");
break;
}
else
return error_mark_node;
expr = void_zero_node;
}
else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
{
/* Only warn when there is no &. */
if (complain & tf_warning)
switch (implicit)
{
case ICV_SECOND_OF_COND:
warning (OPT_Waddress,
"second operand of conditional expression "
"is a reference, not call, to function %qE", expr);
break;
case ICV_THIRD_OF_COND:
warning (OPT_Waddress,
"third operand of conditional expression "
"is a reference, not call, to function %qE", expr);
break;
case ICV_RIGHT_OF_COMMA:
warning (OPT_Waddress,
"right operand of comma operator "
"is a reference, not call, to function %qE", expr);
break;
case ICV_LEFT_OF_COMMA:
warning (OPT_Waddress,
"left operand of comma operator "
"is a reference, not call, to function %qE", expr);
break;
case ICV_STATEMENT:
warning (OPT_Waddress,
"statement is a reference, not call, to function %qE",
expr);
break;
case ICV_THIRD_IN_FOR:
warning (OPT_Waddress,
"for increment expression "
"is a reference, not call, to function %qE", expr);
break;
default:
gcc_unreachable ();
}
if (TREE_CODE (expr) == COMPONENT_REF)
expr = TREE_OPERAND (expr, 0);
}
}
if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
{
if (implicit != ICV_CAST
&& warn_unused_value
&& !TREE_NO_WARNING (expr)
&& !processing_template_decl)
{
/* The middle end does not warn about expressions that have
been explicitly cast to void, so we must do so here. */
if (!TREE_SIDE_EFFECTS (expr)) {
if (complain & tf_warning)
switch (implicit)
{
case ICV_SECOND_OF_COND:
warning (OPT_Wunused_value,
"second operand of conditional expression has no effect");
break;
case ICV_THIRD_OF_COND:
warning (OPT_Wunused_value,
"third operand of conditional expression has no effect");
break;
case ICV_RIGHT_OF_COMMA:
warning (OPT_Wunused_value,
"right operand of comma operator has no effect");
break;
case ICV_LEFT_OF_COMMA:
warning (OPT_Wunused_value,
"left operand of comma operator has no effect");
break;
case ICV_STATEMENT:
warning (OPT_Wunused_value,
"statement has no effect");
break;
case ICV_THIRD_IN_FOR:
warning (OPT_Wunused_value,
"for increment expression has no effect");
break;
default:
gcc_unreachable ();
}
}
else
{
tree e;
enum tree_code code;
enum tree_code_class tclass;
e = expr;
/* We might like to warn about (say) "(int) f()", as the
cast has no effect, but the compiler itself will
generate implicit conversions under some
circumstances. (For example a block copy will be
turned into a call to "__builtin_memcpy", with a
conversion of the return value to an appropriate
type.) So, to avoid false positives, we strip
conversions. Do not use STRIP_NOPs because it will
not strip conversions to "void", as that is not a
mode-preserving conversion. */
while (TREE_CODE (e) == NOP_EXPR)
e = TREE_OPERAND (e, 0);
code = TREE_CODE (e);
tclass = TREE_CODE_CLASS (code);
if ((tclass == tcc_comparison
|| tclass == tcc_unary
|| (tclass == tcc_binary
&& !(code == MODIFY_EXPR
|| code == INIT_EXPR
|| code == PREDECREMENT_EXPR
|| code == PREINCREMENT_EXPR
|| code == POSTDECREMENT_EXPR
|| code == POSTINCREMENT_EXPR)))
&& (complain & tf_warning))
warning (OPT_Wunused_value, "value computed is not used");
}
}
expr = build1 (CONVERT_EXPR, void_type_node, expr);
}
if (! TREE_SIDE_EFFECTS (expr))
expr = void_zero_node;
return expr;
}
tree
convert_to_void (tree expr, const char *implicit)
{
if (expr == error_mark_node
|| TREE_TYPE (expr) == error_mark_node)
return error_mark_node;
if (!TREE_TYPE (expr))
return expr;
if (invalid_nonstatic_memfn_p (expr))
return error_mark_node;
if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
{
error ("pseudo-destructor is not called");
return error_mark_node;
}
if (VOID_TYPE_P (TREE_TYPE (expr)))
return expr;
switch (TREE_CODE (expr))
{
case COND_EXPR:
{
/* The two parts of a cond expr might be separate lvalues. */
tree op1 = TREE_OPERAND (expr,1);
tree op2 = TREE_OPERAND (expr,2);
tree new_op1 = convert_to_void
(op1, (implicit && !TREE_SIDE_EFFECTS (op2)
? "second operand of conditional" : NULL));
tree new_op2 = convert_to_void
(op2, (implicit && !TREE_SIDE_EFFECTS (op1)
? "third operand of conditional" : NULL));
expr = build (COND_EXPR, TREE_TYPE (new_op1),
TREE_OPERAND (expr, 0), new_op1, new_op2);
break;
}
case COMPOUND_EXPR:
{
/* The second part of a compound expr contains the value. */
tree op1 = TREE_OPERAND (expr,1);
tree new_op1 = convert_to_void
(op1, (implicit && !TREE_NO_UNUSED_WARNING (expr)
? "right-hand operand of comma" : NULL));
if (new_op1 != op1)
{
tree t = build (COMPOUND_EXPR, TREE_TYPE (new_op1),
TREE_OPERAND (expr, 0), new_op1);
expr = t;
}
break;
}
case NON_LVALUE_EXPR:
case NOP_EXPR:
/* These have already decayed to rvalue. */
break;
case CALL_EXPR: /* We have a special meaning for volatile void fn(). */
break;
case INDIRECT_REF:
{
tree type = TREE_TYPE (expr);
int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
== REFERENCE_TYPE;
int is_volatile = TYPE_VOLATILE (type);
int is_complete = COMPLETE_TYPE_P (complete_type (type));
if (is_volatile && !is_complete)
warning ("object of incomplete type `%T' will not be accessed in %s",
type, implicit ? implicit : "void context");
else if (is_reference && is_volatile)
warning ("object of type `%T' will not be accessed in %s",
TREE_TYPE (TREE_OPERAND (expr, 0)),
implicit ? implicit : "void context");
if (is_reference || !is_volatile || !is_complete)
expr = TREE_OPERAND (expr, 0);
break;
}
case VAR_DECL:
{
/* External variables might be incomplete. */
tree type = TREE_TYPE (expr);
int is_complete = COMPLETE_TYPE_P (complete_type (type));
if (TYPE_VOLATILE (type) && !is_complete)
warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
expr, type, implicit ? implicit : "void context");
break;
}
default:;
}
{
tree probe = expr;
if (TREE_CODE (probe) == ADDR_EXPR)
probe = TREE_OPERAND (expr, 0);
if (type_unknown_p (probe))
{
/* [over.over] enumerates the places where we can take the address
of an overloaded function, and this is not one of them. */
pedwarn ("%s cannot resolve address of overloaded function",
implicit ? implicit : "void cast");
expr = void_zero_node;
}
else if (implicit && probe == expr && is_overloaded_fn (probe))
/* Only warn when there is no &. */
warning ("%s is a reference, not call, to function `%E'",
implicit, expr);
}
if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
{
if (implicit && !TREE_SIDE_EFFECTS (expr) && warn_unused_value)
warning ("%s has no effect", implicit);
expr = build1 (CONVERT_EXPR, void_type_node, expr);
}
return expr;
}
tree
ocp_convert (tree type, tree expr, int convtype, int flags)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
const char *invalid_conv_diag;
tree e1;
if (error_operand_p (e) || type == error_mark_node)
return error_mark_node;
complete_type (type);
complete_type (TREE_TYPE (expr));
if ((invalid_conv_diag
= targetm.invalid_conversion (TREE_TYPE (expr), type)))
{
error (invalid_conv_diag);
return error_mark_node;
}
e = integral_constant_value (e);
if (error_operand_p (e))
return error_mark_node;
if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
/* We need a new temporary; don't take this shortcut. */;
else if (same_type_ignoring_top_level_qualifiers_p (type, 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 comparison 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;
/* For complex data types, we need to perform componentwise
conversion. */
else if (TREE_CODE (type) == COMPLEX_TYPE)
return fold_if_not_in_template (convert_to_complex (type, e));
else if (TREE_CODE (e) == TARGET_EXPR)
{
/* Don't build a NOP_EXPR of class type. Instead, change the
type of the temporary. */
TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
return e;
}
else
{
/* We shouldn't be treating objects of ADDRESSABLE type as
rvalues. */
gcc_assert (!TREE_ADDRESSABLE (type));
return fold_if_not_in_template (build_nop (type, e));
}
}
e1 = targetm.convert_to_type (type, e);
if (e1)
return e1;
if (code == VOID_TYPE && (convtype & CONV_STATIC))
{
e = convert_to_void (e, ICV_CAST, tf_warning_or_error);
return e;
}
if (INTEGRAL_CODE_P (code))
{
tree intype = TREE_TYPE (e);
if (TREE_CODE (type) == ENUMERAL_TYPE)
{
/* enum = enum, enum = int, enum = float, (enum)pointer are all
errors. */
if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
|| TREE_CODE (intype) == REAL_TYPE)
&& ! (convtype & CONV_STATIC))
|| TREE_CODE (intype) == POINTER_TYPE)
{
if (flags & LOOKUP_COMPLAIN)
permerror (input_location, "conversion from %q#T to %q#T", intype, type);
if (!flag_permissive)
return error_mark_node;
}
/* [expr.static.cast]
8. A value of integral or enumeration type can be explicitly
converted to an enumeration type. The value is unchanged if
the original value is within the range of the enumeration
values. Otherwise, the resulting enumeration value is
unspecified. */
if (TREE_CODE (expr) == INTEGER_CST
&& !int_fits_type_p (expr, ENUM_UNDERLYING_TYPE (type)))
warning (OPT_Wconversion,
"the result of the conversion is unspecified because "
"%qE is outside the range of type %qT",
expr, type);
}
if (MAYBE_CLASS_TYPE_P (intype))
{
tree rval;
rval = build_type_conversion (type, e);
if (rval)
return rval;
if (flags & LOOKUP_COMPLAIN)
error ("%q#T used where a %qT was expected", intype, type);
return error_mark_node;
}
if (code == BOOLEAN_TYPE)
return cp_truthvalue_conversion (e);
return fold_if_not_in_template (convert_to_integer (type, e));
}
if (NULLPTR_TYPE_P (type) && e && null_ptr_cst_p (e))
return nullptr_node;
if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type))
return fold_if_not_in_template (cp_convert_to_pointer (type, e));
if (code == VECTOR_TYPE)
{
tree in_vtype = TREE_TYPE (e);
if (MAYBE_CLASS_TYPE_P (in_vtype))
{
tree ret_val;
ret_val = build_type_conversion (type, e);
if (ret_val)
return ret_val;
if (flags & LOOKUP_COMPLAIN)
error ("%q#T used where a %qT was expected", in_vtype, type);
return error_mark_node;
}
return fold_if_not_in_template (convert_to_vector (type, e));
}
if (code == REAL_TYPE || code == COMPLEX_TYPE)
{
if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e)))
{
tree rval;
rval = build_type_conversion (type, e);
if (rval)
return rval;
else
if (flags & LOOKUP_COMPLAIN)
error ("%q#T used where a floating point value was expected",
TREE_TYPE (e));
}
if (code == REAL_TYPE)
return fold_if_not_in_template (convert_to_real (type, e));
else if (code == COMPLEX_TYPE)
return fold_if_not_in_template (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 (RECORD_OR_UNION_CODE_P (code))
{
tree dtype = TREE_TYPE (e);
tree ctor = NULL_TREE;
dtype = TYPE_MAIN_VARIANT (dtype);
/* 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 (abstract_virtuals_error (NULL_TREE, type))
return error_mark_node;
if (BRACE_ENCLOSED_INITIALIZER_P (ctor))
ctor = perform_implicit_conversion (type, ctor, tf_warning_or_error);
else if ((flags & LOOKUP_ONLYCONVERTING)
&& ! (CLASS_TYPE_P (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);
else
{
VEC(tree,gc) *ctor_vec = make_tree_vector_single (ctor);
ctor = build_special_member_call (NULL_TREE,
complete_ctor_identifier,
&ctor_vec,
type, flags,
tf_warning_or_error);
release_tree_vector (ctor_vec);
}
if (ctor)
return build_cplus_new (type, ctor);
}
if (flags & LOOKUP_COMPLAIN)
{
/* If the conversion failed and expr was an invalid use of pointer to
member function, try to report a meaningful error. */
if (invalid_nonstatic_memfn_p (expr, tf_warning_or_error))
/* We displayed the error message. */;
else
error ("conversion from %qT to non-scalar type %qT requested",
TREE_TYPE (expr), type);
}
return error_mark_node;
}
