Places that use this function (or _opt) to decide to elide a copy should
probably use make_safe_copy_elision instead. */
-static bool
+bool
unsafe_copy_elision_p (tree target, tree exp)
{
return unsafe_return_slot_p (target) && init_by_return_slot_p (exp);
&& !unsafe)
{
tree to = cp_build_fold_indirect_ref (fa);
- val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
+ val = cp_build_init_expr (to, arg);
return val;
}
}
}
call = cxx_constant_value (call, obj_arg, complain);
if (obj_arg && !error_operand_p (call))
- call = build2 (INIT_EXPR, void_type_node, obj_arg, call);
+ call = cp_build_init_expr (obj_arg, call);
call = convert_from_reference (call);
}
}
check_self_delegation (arg);
/* Avoid change of behavior on Wunused-var-2.C. */
instance = mark_lvalue_use (instance);
- return build2 (INIT_EXPR, class_type, instance, arg);
+ return cp_build_init_expr (instance, arg);
}
}
{
if (is_dummy_object (instance))
return get_target_expr (init, complain);
- init = build2 (INIT_EXPR, TREE_TYPE (instance), instance, init);
- TREE_SIDE_EFFECTS (init) = true;
- return init;
+ return cp_build_init_expr (instance, init);
}
/* Otherwise go ahead with overload resolution. */
ctor = digest_init (basetype, ctor, complain);
if (ctor == error_mark_node)
return error_mark_node;
- ctor = build2 (INIT_EXPR, TREE_TYPE (instance), instance, ctor);
- TREE_SIDE_EFFECTS (ctor) = true;
- return ctor;
+ return cp_build_init_expr (instance, ctor);
}
}
if (complain & tf_error)
if (!same_type_ignoring_top_level_qualifiers_p (susp_type,
void_coro_handle_type))
r = build1_loc (loc, VIEW_CONVERT_EXPR, void_coro_handle_type, r);
- r = build2_loc (loc, INIT_EXPR, void_coro_handle_type, data->conthand, r);
+ r = cp_build_init_expr (loc, data->conthand, r);
r = build1 (CONVERT_EXPR, void_type_node, r);
append_to_statement_list (r, &body_list);
is_cont = true;
r = build_call_expr_internal_loc (loc, IFN_CO_YIELD, integer_type_node, 5,
susp_idx, final_susp, r_l, d_l,
data->coro_fp);
- r = build2 (INIT_EXPR, integer_type_node, cond, r);
+ r = cp_build_init_expr (cond, r);
finish_switch_cond (r, sw);
r = build_case_label (build_int_cst (integer_type_node, 0), NULL_TREE,
create_anon_label_with_ctx (loc, actor));
vec<tree, va_gc> *args = make_tree_vector_single (r);
tree hfa = build_new_method_call (ash, hfa_m, &args, NULL_TREE, LOOKUP_NORMAL,
NULL, tf_warning_or_error);
- r = build2 (INIT_EXPR, handle_type, ash, hfa);
+ r = cp_build_init_expr (ash, hfa);
r = coro_build_cvt_void_expr_stmt (r, loc);
add_stmt (r);
release_tree_vector (args);
if (!VOID_TYPE_P (TREE_TYPE (then_cl)))
{
gcc_checking_assert (TREE_CODE (then_cl) != STATEMENT_LIST);
- then_cl
- = build2 (init_expr ? INIT_EXPR : MODIFY_EXPR, var_type,
- var, then_cl);
+ if (init_expr)
+ then_cl = cp_build_init_expr (var, then_cl);
+ else
+ then_cl = build2 (MODIFY_EXPR, var_type, var, then_cl);
}
tree else_cl = COND_EXPR_ELSE (old_expr);
if (!VOID_TYPE_P (TREE_TYPE (else_cl)))
{
gcc_checking_assert (TREE_CODE (else_cl) != STATEMENT_LIST);
- else_cl
- = build2 (init_expr ? INIT_EXPR : MODIFY_EXPR, var_type,
- var, else_cl);
+ if (init_expr)
+ else_cl = cp_build_init_expr (var, else_cl);
+ else
+ else_cl = build2 (MODIFY_EXPR, var_type, var, else_cl);
}
n->init = build3 (COND_EXPR, var_type, cond, then_cl, else_cl);
}
DECL_ARTIFICIAL (cond_var) = true;
layout_decl (cond_var, 0);
gcc_checking_assert (!TYPE_NEEDS_CONSTRUCTING (cond_type));
- cond = build2 (INIT_EXPR, cond_type, cond_var, cond);
+ cond = cp_build_init_expr (cond_var, cond);
var_nest_node *ins
= new var_nest_node (cond_var, cond, n->prev, n);
COND_EXPR_COND (n->init) = cond_var;
expression that performs the init and then records that the
variable is live (and the DTOR should be run at the scope
exit. */
- tree set_flag = build2 (INIT_EXPR, boolean_type_node,
- flag, boolean_true_node);
+ tree set_flag = cp_build_init_expr (flag, boolean_true_node);
n->init
= build2 (COMPOUND_EXPR, boolean_type_node, n->init, set_flag);
}
/* We want to initialize the new variable with the expression
that contains the await(s) and potentially also needs to
have truth_if expressions expanded. */
- tree new_s = build2_loc (sloc, INIT_EXPR, boolean_type_node,
- newvar, cond_inner);
+ tree new_s = cp_build_init_expr (sloc, newvar, cond_inner);
finish_expr_stmt (new_s);
IF_COND (if_stmt) = newvar;
add_stmt (if_stmt);
if (TREE_CODE (cond_inner) == CLEANUP_POINT_EXPR)
cond_inner = TREE_OPERAND (cond_inner, 0);
location_t sloc = EXPR_LOCATION (SWITCH_STMT_COND (sw_stmt));
- tree new_s = build2_loc (sloc, INIT_EXPR, sw_type, newvar,
+ tree new_s = cp_build_init_expr (sloc, newvar,
cond_inner);
finish_expr_stmt (new_s);
SWITCH_STMT_COND (sw_stmt) = newvar;
}
tree allocated = build1 (CONVERT_EXPR, coro_frame_ptr, new_fn);
- tree r = build2 (INIT_EXPR, TREE_TYPE (coro_fp), coro_fp, allocated);
+ tree r = cp_build_init_expr (coro_fp, allocated);
r = coro_build_cvt_void_expr_stmt (r, fn_start);
add_stmt (r);
1, 0,tf_warning_or_error);
tree fnf_x = build_class_member_access_expr (deref_fp, fnf_m, NULL_TREE,
false, tf_warning_or_error);
- r = build2 (INIT_EXPR, boolean_type_node, fnf_x, boolean_true_node);
+ r = cp_build_init_expr (fnf_x, boolean_true_node);
r = coro_build_cvt_void_expr_stmt (r, fn_start);
add_stmt (r);
/*protect=*/1, /*want_type=*/0, tf_warning_or_error);
tree resume_x = build_class_member_access_expr (deref_fp, resume_m, NULL_TREE,
false, tf_warning_or_error);
- r = build2_loc (fn_start, INIT_EXPR, act_des_fn_ptr, resume_x, actor_addr);
+ r = cp_build_init_expr (fn_start, resume_x, actor_addr);
finish_expr_stmt (r);
tree destroy_addr = build1 (ADDR_EXPR, act_des_fn_ptr, destroy);
tree destroy_x
= build_class_member_access_expr (deref_fp, destroy_m, NULL_TREE, false,
tf_warning_or_error);
- r = build2_loc (fn_start, INIT_EXPR, act_des_fn_ptr, destroy_x, destroy_addr);
+ r = cp_build_init_expr (fn_start, destroy_x, destroy_addr);
finish_expr_stmt (r);
/* [dcl.fct.def.coroutine] /13
release_tree_vector (arg);
}
else
- r = build2_loc (fn_start, INIT_EXPR, gro_type,
- DECL_RESULT (orig), get_ro);
+ r = cp_build_init_expr (fn_start, DECL_RESULT (orig), get_ro);
if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (gro_type))
/* If some part of the initalization code (prior to the await_resume
= build_class_member_access_expr (deref_fp, resume_idx_m, NULL_TREE, false,
tf_warning_or_error);
r = build_int_cst (short_unsigned_type_node, 0);
- r = build2_loc (fn_start, INIT_EXPR, short_unsigned_type_node, resume_idx, r);
+ r = cp_build_init_expr (fn_start, resume_idx, r);
r = coro_build_cvt_void_expr_stmt (r, fn_start);
add_stmt (r);
if (TREE_CODE (from) == TARGET_EXPR)
if (tree init = TARGET_EXPR_INITIAL (from))
{
+ gcc_checking_assert (TARGET_EXPR_ELIDING_P (from));
if (target_expr_needs_replace (from))
{
/* If this was changed by cp_genericize_target_expr, we need to
/* A TARGET_EXPR that expresses direct-initialization should have been
elided by cp_gimplify_init_expr. */
gcc_checking_assert (!TARGET_EXPR_DIRECT_INIT_P (*expr_p));
+ /* Likewise, but allow extra temps of trivial type so that
+ gimplify_init_ctor_preeval can materialize subobjects of a CONSTRUCTOR
+ on the rhs of an assignment, as in constexpr-aggr1.C. */
+ gcc_checking_assert (!TARGET_EXPR_ELIDING_P (*expr_p)
+ || !TREE_ADDRESSABLE (TREE_TYPE (*expr_p)));
ret = GS_UNHANDLED;
break;
cp_walk_tree (&init, cp_fold_r, data, NULL);
*walk_subtrees = 0;
if (TREE_CODE (init) == TARGET_EXPR)
- *stmt_p = init;
+ {
+ TARGET_EXPR_ELIDING_P (init) = TARGET_EXPR_ELIDING_P (stmt);
+ *stmt_p = init;
+ }
}
break;
loc = EXPR_LOCATION (x);
tree s = build_fold_indirect_ref_loc (loc,
CALL_EXPR_ARG (x, 0));
- r = build2_loc (loc, INIT_EXPR, TREE_TYPE (s), s, r);
+ r = cp_build_init_expr (s, r);
}
x = r;
break;
DECL_MODULE_EXPORT_P (in _DECL)
PACK_EXPANSION_FORCE_EXTRA_ARGS_P (in *_PACK_EXPANSION)
LAMBDA_EXPR_STATIC_P (in LAMBDA_EXPR)
+ TARGET_EXPR_ELIDING_P (in TARGET_EXPR)
4: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
CALL_EXPR, or FIELD_DECL).
#define TARGET_EXPR_DIRECT_INIT_P(NODE) \
TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE))
+/* True if we expect this TARGET_EXPR to be used as an initializer, not to
+ materialize as a temporary. */
+#define TARGET_EXPR_ELIDING_P(NODE) \
+ TREE_LANG_FLAG_3 (TARGET_EXPR_CHECK (NODE))
+
/* True if NODE is a TARGET_EXPR that just expresses a copy of its INITIAL; if
the initializer has void type, it's doing something more complicated. */
#define SIMPLE_TARGET_EXPR_P(NODE) \
extern void validate_conversion_obstack (void);
extern void mark_versions_used (tree);
extern int unsafe_return_slot_p (tree);
+extern bool unsafe_copy_elision_p (tree, tree);
extern bool make_safe_copy_elision (tree, tree);
extern bool cp_handle_deprecated_or_unavailable (tree, tsubst_flags_t = tf_warning_or_error);
extern void cp_warn_deprecated_use_scopes (tree);
tsubst_flags_t);
extern tree add_exception_specifier (tree, tree, tsubst_flags_t);
extern tree merge_exception_specifiers (tree, tree);
+extern void set_target_expr_eliding (tree);
+extern tree cp_build_init_expr (location_t, tree, tree);
+inline tree cp_build_init_expr (tree t, tree i)
+{ return cp_build_init_expr (input_location, t, i); }
/* in mangle.cc */
extern void init_mangle (void);
}
if (init && init != error_mark_node)
- init_code = build2 (INIT_EXPR, type, decl, init);
+ init_code = cp_build_init_expr (decl, init);
if (init_code && !TREE_SIDE_EFFECTS (init_code)
&& init_code != error_mark_node)
tree tmp = decay_conversion (exp, tf_warning_or_error);
if (tmp == error_mark_node)
return error_mark_node;
- exp = build2 (INIT_EXPR, temp_type, object, tmp);
+ exp = cp_build_init_expr (object, tmp);
}
/* Mark any cleanups from the initialization as MUST_NOT_THROW, since
/* Now put it back so C++17 copy elision works. */
init = get_target_expr (init);
+ set_target_expr_eliding (init);
+
current_class_ptr = save_ccp;
current_class_ref = save_ccr;
return init;
if (TREE_CODE (type) == ARRAY_TYPE)
{
init = build_vec_init_expr (type, init, tf_warning_or_error);
- init = build2 (INIT_EXPR, type, decl, init);
+ init = cp_build_init_expr (decl, init);
finish_expr_stmt (init);
}
else
tree value = build_value_init (type, tf_warning_or_error);
if (value == error_mark_node)
return;
- init = build2 (INIT_EXPR, type, decl, value);
+ init = cp_build_init_expr (decl, value);
finish_expr_stmt (init);
}
}
{
if (init)
{
- init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
+ init = cp_build_init_expr (decl, TREE_VALUE (init));
finish_expr_stmt (init);
}
}
if (TREE_CODE (type) == ARRAY_TYPE
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type)))
init = build_vec_init_expr (type, init, tf_warning_or_error);
- init = build2 (INIT_EXPR, type, decl, init);
+ init = cp_build_init_expr (decl, init);
finish_expr_stmt (init);
FOR_EACH_VEC_ELT (*cleanups, i, t)
push_cleanup (NULL_TREE, t, false);
/* Initialize the array only if it's not a flexible
array member (i.e., if it has an upper bound). */
init = build_vec_init_expr (type, init, tf_warning_or_error);
- init = build2 (INIT_EXPR, type, decl, init);
+ init = cp_build_init_expr (decl, init);
finish_expr_stmt (init);
}
}
complete objects. */
gcc_assert (TREE_CODE (init) == CONSTRUCTOR || true_exp == exp);
- init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
+ init = cp_build_init_expr (exp, init);
TREE_SIDE_EFFECTS (init) = 1;
finish_expr_stmt (init);
return true;
TREE_TYPE (*p) = void_type_node;
p = &TREE_OPERAND (*p, 0);
}
- *p = build2 (INIT_EXPR, TREE_TYPE (exp), exp, *p);
- TREE_SIDE_EFFECTS (*p) = 1;
+ *p = cp_build_init_expr (exp, *p);
finish_expr_stmt (init);
return true;
}
{
tree e = maybe_constant_init (rval, exp);
if (TREE_CONSTANT (e))
- rval = build2 (INIT_EXPR, type, exp, e);
+ rval = cp_build_init_expr (exp, e);
}
}
field_size = TYPE_SIZE (CLASSTYPE_AS_BASE (type));
init = build_zero_init_1 (type, NULL_TREE, /*static_storage_p=*/false,
field_size);
- init = build2 (INIT_EXPR, type, exp, init);
+ init = cp_build_init_expr (exp, init);
finish_expr_stmt (init);
}
tree val = build_value_init (type, complain | tf_no_cleanup);
if (val == error_mark_node)
return error_mark_node;
- init_expr = build2 (INIT_EXPR, type, init_expr, val);
+ init_expr = cp_build_init_expr (init_expr, val);
}
else
{
if (BRACE_ENCLOSED_INITIALIZER_P (init))
init = digest_init (atype, init, complain);
- stmt_expr = build2 (INIT_EXPR, atype, base, init);
+ stmt_expr = cp_build_init_expr (base, init);
return stmt_expr;
}
gcc_checking_assert (!target_expr_needs_replace (elt));
if (digested)
- one_init = build2 (INIT_EXPR, type, baseref, elt);
+ one_init = cp_build_init_expr (baseref, elt);
else if (tree vi = get_vec_init_expr (elt))
one_init = expand_vec_init_expr (baseref, vi, complain, flags);
else if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
if (do_static_init)
one_init = NULL_TREE;
else
- one_init = build2 (INIT_EXPR, type, baseref, e);
+ one_init = cp_build_init_expr (baseref, e);
}
else
{
{
elt_init = build_value_init (type, complain);
if (elt_init != error_mark_node)
- elt_init = build2 (INIT_EXPR, type, to, elt_init);
+ elt_init = cp_build_init_expr (to, elt_init);
}
else
{
else if (tree_int_cst_equal (TYPE_SIZE (current_class_type),
CLASSTYPE_SIZE (current_class_type)))
{
- tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
+ tree t = cp_build_init_expr (current_class_ref, parm);
finish_expr_stmt (t);
}
else
current_class_ptr, alias_set);
tree rhs = build2 (MEM_REF, array_type,
TREE_OPERAND (parm, 0), alias_set);
- tree t = build2 (INIT_EXPR, void_type_node, lhs, rhs);
+ tree t = cp_build_init_expr (lhs, rhs);
finish_expr_stmt (t);
}
}
/* Update for array-to-pointer decay. */
type = TREE_TYPE (expr);
+ /* This TARGET_EXPR will initialize the outer one added by
+ finish_stmt_expr. */
+ set_target_expr_eliding (expr);
+
/* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
normal statement, but don't convert to void or actually add
the EXPR_STMT. */
expand_call{,_inline}. */
cxx_mark_addressable (slot);
CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
- call_expr = build2 (INIT_EXPR, TREE_TYPE (call_expr), slot, call_expr);
+ call_expr = cp_build_init_expr (slot, call_expr);
}
else if (style == pcc)
{
{
tree init = build_zero_init (type, NULL_TREE,
/*static_storage_p=*/false);
- init = build2 (INIT_EXPR, void_type_node, slot, init);
+ init = cp_build_init_expr (slot, init);
call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (call_expr),
init, call_expr);
}
tree init;
if (DECL_INITIAL (dp->var)
&& DECL_INITIAL (dp->var) != error_mark_node)
- init = build2 (INIT_EXPR, void_type_node, dp->result,
+ init = cp_build_init_expr (dp->result,
DECL_INITIAL (dp->var));
else
init = build_empty_stmt (EXPR_LOCATION (*tp));
else
init = fold_convert (TREE_TYPE (v), integer_zero_node);
OMP_CLAUSE_REDUCTION_INIT (c)
- = build2 (INIT_EXPR, TREE_TYPE (v), v, init);
+ = cp_build_init_expr (v, init);
}
}
}
if (t == error_mark_node)
return error_mark_node;
}
+
+ set_target_expr_eliding (value);
+
t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE);
if (location_t eloc = cp_expr_location (value))
SET_EXPR_LOCATION (t, eloc);
TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
+ TARGET_EXPR_ELIDING_P (u) = TARGET_EXPR_ELIDING_P (t);
/* Map the old variable to the new one. */
splay_tree_insert (target_remap,
if (! same_type_p (TREE_TYPE (rhs), lhstype))
/* Call convert to generate an error; see PR 11063. */
rhs = convert (lhstype, rhs);
- result = build2 (INIT_EXPR, lhstype, lhs, rhs);
+ result = cp_build_init_expr (lhs, rhs);
TREE_SIDE_EFFECTS (result) = 1;
goto ret;
}
result = build2_loc (loc, modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
lhstype, lhs, newrhs);
+ if (modifycode == INIT_EXPR)
+ set_target_expr_eliding (newrhs);
TREE_SIDE_EFFECTS (result) = 1;
if (!plain_assign)
/* Actually copy the value returned into the appropriate location. */
if (retval && retval != result)
- retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
+ retval = cp_build_init_expr (result, retval);
if (tree set = maybe_set_retval_sentinel ())
retval = build2 (COMPOUND_EXPR, void_type_node, retval, set);
else
{
build_init:
- code = build2 (INIT_EXPR, inner_type, sub, value);
+ code = cp_build_init_expr (sub, value);
}
code = build_stmt (input_location, EXPR_STMT, code);
add_stmt (code);
}
else if (init)
{
- tree ie = build2 (INIT_EXPR, void_type_node, dest, init);
+ tree ie = cp_build_init_expr (dest, init);
code = add_stmt_to_compound (ie, code);
}
}
code = build_vec_init (dest, NULL_TREE, init, /*value-init*/false,
/*from array*/1, tf_warning_or_error);
else
- code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
+ code = cp_build_init_expr (dest, init);
return code;
}
&& CP_AGGREGATE_TYPE_P (type))
init = reshape_init (type, init, complain);
init = digest_init_flags (type, init, flags, complain);
+ set_target_expr_eliding (init);
/* We may have temporary materialization in a NSDMI, if the initializer
has something like A{} in it. Digesting the {} could have introduced
tree t = fold_non_dependent_init (init, complain);
if (TREE_CONSTANT (t))
init = t;
+ set_target_expr_eliding (init);
}
return init;
}
{
gcc_assert (ce->value);
next = massage_init_elt (fldtype, next, nested, flags, complain);
+ /* We can't actually elide the temporary when initializing a
+ potentially-overlapping field from a function that returns by
+ value. */
+ if (ce->index
+ && TREE_CODE (next) == TARGET_EXPR
+ && unsafe_copy_elision_p (ce->index, next))
+ TARGET_EXPR_ELIDING_P (next) = false;
++idx;
}
}
a class, just build one up; if it's an array, recurse. */
next = build_constructor (init_list_type_node, NULL);
next = massage_init_elt (fldtype, next, nested, flags, complain);
+ if (TREE_CODE (next) == TARGET_EXPR
+ && unsafe_copy_elision_p (field, next))
+ TARGET_EXPR_ELIDING_P (next) = false;
/* Warn when some struct elements are implicitly initialized. */
if ((complain & tf_warning)
}
}
}
+
+/* Record that any TARGET_EXPR in T are going to be elided in
+ cp_gimplify_init_expr (or sooner). */
+
+void
+set_target_expr_eliding (tree t)
+{
+ if (!t)
+ return;
+ switch (TREE_CODE (t))
+ {
+ case TARGET_EXPR:
+ TARGET_EXPR_ELIDING_P (t) = true;
+ break;
+ case COMPOUND_EXPR:
+ set_target_expr_eliding (TREE_OPERAND (t, 1));
+ break;
+ case COND_EXPR:
+ set_target_expr_eliding (TREE_OPERAND (t, 1));
+ set_target_expr_eliding (TREE_OPERAND (t, 2));
+ break;
+
+ default:
+ break;
+ }
+}
+
+/* Call the above in the process of building an INIT_EXPR. */
+
+tree
+cp_build_init_expr (location_t loc, tree target, tree init)
+{
+ set_target_expr_eliding (init);
+ tree ie = build2_loc (loc, INIT_EXPR, TREE_TYPE (target),
+ target, init);
+ TREE_SIDE_EFFECTS (ie) = true;
+ return ie;
+}
projects / platform / upstream / gcc.git / commitdiff