It occurred to me that we should be able to use treat_lvalue_as_rvalue_p in the
second context where we're supposed to use a move operation as well. Except
that for a throw-expression, the operand may not be a function parameter.
While at it, also make use of CP_TYPE_VOLATILE_P.
Bootstrapped/regtested on x86_64-linux, ok for trunk?
2018-09-04 Marek Polacek <pola...@redhat.com>
* cp-tree.h (treat_lvalue_as_rvalue_p): Declare.
* except.c (build_throw): Use it. Use CP_TYPE_VOLATILE_P.
* typeck.c (treat_lvalue_as_rvalue_p): No longer static. Add PARM_OK
parameter.
(maybe_warn_pessimizing_move): Adjust treat_lvalue_as_rvalue_p call.
(check_return_expr): Likewise.
diff --git gcc/cp/cp-tree.h gcc/cp/cp-tree.h
index 43e452cc1a3..df441fca304 100644
--- gcc/cp/cp-tree.h
+++ gcc/cp/cp-tree.h
@@ -7354,6 +7354,7 @@ extern tree cp_perform_integral_promotions (tree,
tsubst_flags_t);
extern tree finish_left_unary_fold_expr (tree, int);
extern tree finish_right_unary_fold_expr (tree, int);
extern tree finish_binary_fold_expr (tree, tree, int);
+extern bool treat_lvalue_as_rvalue_p (tree, bool);
/* in typeck2.c */
extern void require_complete_eh_spec_types (tree, tree);
diff --git gcc/cp/except.c gcc/cp/except.c
index f85ae047cfc..2db90eedcf7 100644
--- gcc/cp/except.c
+++ gcc/cp/except.c
@@ -676,12 +676,9 @@ build_throw (tree exp)
/* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
treated as an rvalue for the purposes of overload resolution
to favor move constructors over copy constructors. */
- if (/* Must be a local, automatic variable. */
- VAR_P (exp)
- && DECL_CONTEXT (exp) == current_function_decl
- && ! TREE_STATIC (exp)
+ if (treat_lvalue_as_rvalue_p (exp, /*parm_ok*/false)
/* The variable must not have the `volatile' qualifier. */
- && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
+ && !CP_TYPE_VOLATILE_P (TREE_TYPE (exp)))
{
tree moved = move (exp);
exp_vec = make_tree_vector_single (moved);
diff --git gcc/cp/typeck.c gcc/cp/typeck.c
index ab088a946b3..84cf4c478aa 100644
--- gcc/cp/typeck.c
+++ gcc/cp/typeck.c
@@ -9180,14 +9180,15 @@ can_do_nrvo_p (tree retval, tree functype)
}
/* Returns true if we should treat RETVAL, an expression being returned,
- as if it were designated by an rvalue. See [class.copy.elision]. */
+ as if it were designated by an rvalue. See [class.copy.elision].
+ PARM_P is true if a function parameter is OK in this context. */
-static bool
-treat_lvalue_as_rvalue_p (tree retval)
+bool
+treat_lvalue_as_rvalue_p (tree retval, bool parm_ok)
{
return ((cxx_dialect != cxx98)
&& ((VAR_P (retval) && !DECL_HAS_VALUE_EXPR_P (retval))
- || TREE_CODE (retval) == PARM_DECL)
+ || (parm_ok && TREE_CODE (retval) == PARM_DECL))
&& DECL_CONTEXT (retval) == current_function_decl
&& !TREE_STATIC (retval));
}
@@ -9240,7 +9241,7 @@ maybe_warn_pessimizing_move (tree retval, tree functype)
}
/* Warn if the move is redundant. It is redundant when we would
do maybe-rvalue overload resolution even without std::move. */
- else if (treat_lvalue_as_rvalue_p (arg))
+ else if (treat_lvalue_as_rvalue_p (arg, /*parm_ok*/true))
{
auto_diagnostic_group d;
if (warning_at (loc, OPT_Wredundant_move,
@@ -9525,7 +9526,7 @@ check_return_expr (tree retval, bool *no_warning)
Note that these conditions are similar to, but not as strict as,
the conditions for the named return value optimization. */
bool converted = false;
- if (treat_lvalue_as_rvalue_p (retval)
+ if (treat_lvalue_as_rvalue_p (retval, /*parm_ok*/true)
/* This is only interesting for class type. */
&& CLASS_TYPE_P (functype))
{
