gimple.h (gimple_build_assign_stat): Remove prototype.
* gimple.h (gimple_build_assign_stat): Remove prototype. (gimple_build_assign): Remove define. Add overload prototypes with tree lhs and either a tree rhs, or enum tree_code and 1, 2 or 3 tree operands. * gimple.c (gimple_build_assign_stat): Renamed to... (gimple_build_assign): ... this. Add overloads with enum tree_code and 1, 2 or 3 tree operands. (gimple_build_assign_with_ops): Remove 1 and 2 operand overloads. Rename the 3 operand overload to ... (gimple_build_assign_1): ... this. Make it static inline. * tree-ssa-strlen.c (get_string_length): Use gimple_build_assign instead of gimple_build_assign_with_ops, swap the order of first two arguments and adjust formatting where necessary. * tree-vect-slp.c (vect_get_constant_vectors, vect_create_mask_and_perm): Likewise. * tree-ssa-forwprop.c (simplify_rotate): Likewise. * asan.c (build_shadow_mem_access, maybe_create_ssa_name, maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise. * tsan.c (instrument_builtin_call): Likewise. * tree-chkp.c (chkp_compute_bounds_for_assignment, chkp_generate_extern_var_bounds): Likewise. * tree-loop-distribution.c (generate_memset_builtin): Likewise. * tree-ssa-loop-im.c (rewrite_reciprocal): Likewise. * gimple-builder.c (build_assign, build_type_cast): Likewise. * tree-vect-loop-manip.c (vect_create_cond_for_align_checks): Likewise. * value-prof.c (gimple_divmod_fixed_value, gimple_mod_pow2, gimple_mod_subtract): Likewise. * gimple-match-head.c (maybe_push_res_to_seq): Likewise. * tree-vect-patterns.c (vect_recog_dot_prod_pattern, vect_recog_sad_pattern, vect_handle_widen_op_by_const, vect_recog_widen_mult_pattern, vect_recog_pow_pattern, vect_recog_widen_sum_pattern, vect_operation_fits_smaller_type, vect_recog_over_widening_pattern, vect_recog_widen_shift_pattern, vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern, vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern, adjust_bool_pattern_cast, adjust_bool_pattern, vect_recog_bool_pattern): Likewise. * gimple-ssa-strength-reduction.c (create_add_on_incoming_edge, insert_initializers, introduce_cast_before_cand, replace_one_candidate): Likewise. * tree-ssa-math-opts.c (insert_reciprocals, powi_as_mults_1, powi_as_mults, build_and_insert_binop, build_and_insert_cast, pass_cse_sincos::execute, bswap_replace, convert_mult_to_fma): Likewise. * tree-tailcall.c (adjust_return_value_with_ops, update_accumulator_with_ops): Likewise. * tree-predcom.c (reassociate_to_the_same_stmt): Likewise. * tree-ssa-reassoc.c (build_and_add_sum, optimize_range_tests_to_bit_test, update_ops, maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr, negate_value, repropagate_negates, attempt_builtin_powi, reassociate_bb): Likewise. * tree-vect-loop.c (vect_is_simple_reduction_1, get_initial_def_for_induction, vect_create_epilog_for_reduction): Likewise. * ipa-split.c (split_function): Likewise. * tree-ssa-phiopt.c (conditional_replacement, minmax_replacement, abs_replacement, neg_replacement): Likewise. * tree-profile.c (gimple_gen_edge_profiler): Likewise. * tree-vrp.c (simplify_truth_ops_using_ranges, simplify_float_conversion_using_ranges, simplify_internal_call_using_ranges): Likewise. * gimple-fold.c (rewrite_to_defined_overflow, gimple_build): Likewise. * tree-vect-generic.c (expand_vector_divmod, optimize_vector_constructor): Likewise. * ubsan.c (ubsan_expand_null_ifn, ubsan_expand_objsize_ifn, instrument_bool_enum_load): Likewise. * tree-ssa-loop-manip.c (create_iv): Likewise. * omp-low.c (lower_rec_input_clauses, expand_omp_for_generic, expand_omp_for_static_nochunk, expand_omp_for_static_chunk, expand_cilk_for, simd_clone_adjust): Likewise. * trans-mem.c (expand_transaction): Likewise. * tree-vect-data-refs.c (bump_vector_ptr, vect_permute_store_chain, vect_setup_realignment, vect_permute_load_chain, vect_shift_permute_load_chain): Likewise. * tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store, vectorizable_simd_clone_call, vect_gen_widened_results_half, vect_create_vectorized_demotion_stmts, vectorizable_conversion, vectorizable_shift, vectorizable_operation, vectorizable_store, permute_vec_elements, vectorizable_load): Likewise. From-SVN: r218216
This commit is contained in:
Jakub Jelinek
Jakub Jelinek
parent
7b55fa54d4
commit
0d0e4a03e9
|
|
@ -1,3 +1,86 @@
|
|||
2014-12-01 Jakub Jelinek <jakub@redhat.com>
|
||||
|
||||
* gimple.h (gimple_build_assign_stat): Remove prototype.
|
||||
(gimple_build_assign): Remove define. Add overload prototypes
|
||||
with tree lhs and either a tree rhs, or enum tree_code and
|
||||
1, 2 or 3 tree operands.
|
||||
* gimple.c (gimple_build_assign_stat): Renamed to...
|
||||
(gimple_build_assign): ... this. Add overloads with
|
||||
enum tree_code and 1, 2 or 3 tree operands.
|
||||
(gimple_build_assign_with_ops): Remove 1 and 2 operand overloads.
|
||||
Rename the 3 operand overload to ...
|
||||
(gimple_build_assign_1): ... this. Make it static inline.
|
||||
* tree-ssa-strlen.c (get_string_length): Use gimple_build_assign
|
||||
instead of gimple_build_assign_with_ops, swap the order of first
|
||||
two arguments and adjust formatting where necessary.
|
||||
* tree-vect-slp.c (vect_get_constant_vectors,
|
||||
vect_create_mask_and_perm): Likewise.
|
||||
* tree-ssa-forwprop.c (simplify_rotate): Likewise.
|
||||
* asan.c (build_shadow_mem_access, maybe_create_ssa_name,
|
||||
maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
|
||||
* tsan.c (instrument_builtin_call): Likewise.
|
||||
* tree-chkp.c (chkp_compute_bounds_for_assignment,
|
||||
chkp_generate_extern_var_bounds): Likewise.
|
||||
* tree-loop-distribution.c (generate_memset_builtin): Likewise.
|
||||
* tree-ssa-loop-im.c (rewrite_reciprocal): Likewise.
|
||||
* gimple-builder.c (build_assign, build_type_cast): Likewise.
|
||||
* tree-vect-loop-manip.c (vect_create_cond_for_align_checks): Likewise.
|
||||
* value-prof.c (gimple_divmod_fixed_value, gimple_mod_pow2,
|
||||
gimple_mod_subtract): Likewise.
|
||||
* gimple-match-head.c (maybe_push_res_to_seq): Likewise.
|
||||
* tree-vect-patterns.c (vect_recog_dot_prod_pattern,
|
||||
vect_recog_sad_pattern, vect_handle_widen_op_by_const,
|
||||
vect_recog_widen_mult_pattern, vect_recog_pow_pattern,
|
||||
vect_recog_widen_sum_pattern, vect_operation_fits_smaller_type,
|
||||
vect_recog_over_widening_pattern, vect_recog_widen_shift_pattern,
|
||||
vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern,
|
||||
vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern,
|
||||
adjust_bool_pattern_cast, adjust_bool_pattern,
|
||||
vect_recog_bool_pattern): Likewise.
|
||||
* gimple-ssa-strength-reduction.c (create_add_on_incoming_edge,
|
||||
insert_initializers, introduce_cast_before_cand,
|
||||
replace_one_candidate): Likewise.
|
||||
* tree-ssa-math-opts.c (insert_reciprocals, powi_as_mults_1,
|
||||
powi_as_mults, build_and_insert_binop, build_and_insert_cast,
|
||||
pass_cse_sincos::execute, bswap_replace, convert_mult_to_fma):
|
||||
Likewise.
|
||||
* tree-tailcall.c (adjust_return_value_with_ops,
|
||||
update_accumulator_with_ops): Likewise.
|
||||
* tree-predcom.c (reassociate_to_the_same_stmt): Likewise.
|
||||
* tree-ssa-reassoc.c (build_and_add_sum,
|
||||
optimize_range_tests_to_bit_test, update_ops,
|
||||
maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr,
|
||||
negate_value, repropagate_negates, attempt_builtin_powi,
|
||||
reassociate_bb): Likewise.
|
||||
* tree-vect-loop.c (vect_is_simple_reduction_1,
|
||||
get_initial_def_for_induction, vect_create_epilog_for_reduction):
|
||||
Likewise.
|
||||
* ipa-split.c (split_function): Likewise.
|
||||
* tree-ssa-phiopt.c (conditional_replacement, minmax_replacement,
|
||||
abs_replacement, neg_replacement): Likewise.
|
||||
* tree-profile.c (gimple_gen_edge_profiler): Likewise.
|
||||
* tree-vrp.c (simplify_truth_ops_using_ranges,
|
||||
simplify_float_conversion_using_ranges,
|
||||
simplify_internal_call_using_ranges): Likewise.
|
||||
* gimple-fold.c (rewrite_to_defined_overflow, gimple_build): Likewise.
|
||||
* tree-vect-generic.c (expand_vector_divmod,
|
||||
optimize_vector_constructor): Likewise.
|
||||
* ubsan.c (ubsan_expand_null_ifn, ubsan_expand_objsize_ifn,
|
||||
instrument_bool_enum_load): Likewise.
|
||||
* tree-ssa-loop-manip.c (create_iv): Likewise.
|
||||
* omp-low.c (lower_rec_input_clauses, expand_omp_for_generic,
|
||||
expand_omp_for_static_nochunk, expand_omp_for_static_chunk,
|
||||
expand_cilk_for, simd_clone_adjust): Likewise.
|
||||
* trans-mem.c (expand_transaction): Likewise.
|
||||
* tree-vect-data-refs.c (bump_vector_ptr, vect_permute_store_chain,
|
||||
vect_setup_realignment, vect_permute_load_chain,
|
||||
vect_shift_permute_load_chain): Likewise.
|
||||
* tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
|
||||
vectorizable_simd_clone_call, vect_gen_widened_results_half,
|
||||
vect_create_vectorized_demotion_stmts, vectorizable_conversion,
|
||||
vectorizable_shift, vectorizable_operation, vectorizable_store,
|
||||
permute_vec_elements, vectorizable_load): Likewise.
|
||||
|
||||
2014-12-01 Richard Biener <rguenther@suse.de>
|
||||
|
||||
PR middle-end/64111
|
||||
|
|
|
|||
54
gcc/asan.c
54
gcc/asan.c
|
|
@ -1585,25 +1585,25 @@ build_shadow_mem_access (gimple_stmt_iterator *gsi, location_t location,
|
|||
gimple g;
|
||||
|
||||
t = build_int_cst (uintptr_type, ASAN_SHADOW_SHIFT);
|
||||
g = gimple_build_assign_with_ops (RSHIFT_EXPR, make_ssa_name (uintptr_type),
|
||||
base_addr, t);
|
||||
g = gimple_build_assign (make_ssa_name (uintptr_type), RSHIFT_EXPR,
|
||||
base_addr, t);
|
||||
gimple_set_location (g, location);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
|
||||
t = build_int_cst (uintptr_type, asan_shadow_offset ());
|
||||
g = gimple_build_assign_with_ops (PLUS_EXPR, make_ssa_name (uintptr_type),
|
||||
gimple_assign_lhs (g), t);
|
||||
g = gimple_build_assign (make_ssa_name (uintptr_type), PLUS_EXPR,
|
||||
gimple_assign_lhs (g), t);
|
||||
gimple_set_location (g, location);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, make_ssa_name (shadow_ptr_type),
|
||||
gimple_assign_lhs (g));
|
||||
g = gimple_build_assign (make_ssa_name (shadow_ptr_type), NOP_EXPR,
|
||||
gimple_assign_lhs (g));
|
||||
gimple_set_location (g, location);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
|
||||
t = build2 (MEM_REF, shadow_type, gimple_assign_lhs (g),
|
||||
build_int_cst (shadow_ptr_type, 0));
|
||||
g = gimple_build_assign_with_ops (MEM_REF, make_ssa_name (shadow_type), t);
|
||||
g = gimple_build_assign (make_ssa_name (shadow_type), MEM_REF, t);
|
||||
gimple_set_location (g, location);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
return gimple_assign_lhs (g);
|
||||
|
|
@ -1618,9 +1618,8 @@ maybe_create_ssa_name (location_t loc, tree base, gimple_stmt_iterator *iter,
|
|||
{
|
||||
if (TREE_CODE (base) == SSA_NAME)
|
||||
return base;
|
||||
gimple g
|
||||
= gimple_build_assign_with_ops (TREE_CODE (base),
|
||||
make_ssa_name (TREE_TYPE (base)), base);
|
||||
gimple g = gimple_build_assign (make_ssa_name (TREE_TYPE (base)),
|
||||
TREE_CODE (base), base);
|
||||
gimple_set_location (g, loc);
|
||||
if (before_p)
|
||||
gsi_insert_before (iter, g, GSI_SAME_STMT);
|
||||
|
|
@ -1638,10 +1637,8 @@ maybe_cast_to_ptrmode (location_t loc, tree len, gimple_stmt_iterator *iter,
|
|||
{
|
||||
if (ptrofftype_p (len))
|
||||
return len;
|
||||
gimple g
|
||||
= gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (pointer_sized_int_node),
|
||||
len);
|
||||
gimple g = gimple_build_assign (make_ssa_name (pointer_sized_int_node),
|
||||
NOP_EXPR, len);
|
||||
gimple_set_location (g, loc);
|
||||
if (before_p)
|
||||
gsi_insert_before (iter, g, GSI_SAME_STMT);
|
||||
|
|
@ -2542,10 +2539,8 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
|
|||
if (use_calls)
|
||||
{
|
||||
/* Instrument using callbacks. */
|
||||
gimple g
|
||||
= gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (pointer_sized_int_node),
|
||||
base);
|
||||
gimple g = gimple_build_assign (make_ssa_name (pointer_sized_int_node),
|
||||
NOP_EXPR, base);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (iter, g, GSI_SAME_STMT);
|
||||
tree base_addr = gimple_assign_lhs (g);
|
||||
|
|
@ -2557,9 +2552,8 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
|
|||
else
|
||||
{
|
||||
gcc_assert (nargs == 2);
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (pointer_sized_int_node),
|
||||
len);
|
||||
g = gimple_build_assign (make_ssa_name (pointer_sized_int_node),
|
||||
NOP_EXPR, len);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (iter, g, GSI_SAME_STMT);
|
||||
tree sz_arg = gimple_assign_lhs (g);
|
||||
|
|
@ -2616,9 +2610,8 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
|
|||
&then_bb,
|
||||
&else_bb);
|
||||
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (pointer_sized_int_node),
|
||||
base);
|
||||
g = gimple_build_assign (make_ssa_name (pointer_sized_int_node),
|
||||
NOP_EXPR, base);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (&gsi, g, GSI_NEW_STMT);
|
||||
tree base_addr = gimple_assign_lhs (g);
|
||||
|
|
@ -2670,17 +2663,14 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
|
|||
check first and last byte. */
|
||||
if (size_in_bytes == -1)
|
||||
{
|
||||
g = gimple_build_assign_with_ops (MINUS_EXPR,
|
||||
make_ssa_name (pointer_sized_int_node),
|
||||
len,
|
||||
build_int_cst (pointer_sized_int_node, 1));
|
||||
g = gimple_build_assign (make_ssa_name (pointer_sized_int_node),
|
||||
MINUS_EXPR, len,
|
||||
build_int_cst (pointer_sized_int_node, 1));
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_after (&gsi, g, GSI_NEW_STMT);
|
||||
tree last = gimple_assign_lhs (g);
|
||||
g = gimple_build_assign_with_ops (PLUS_EXPR,
|
||||
make_ssa_name (pointer_sized_int_node),
|
||||
base_addr,
|
||||
last);
|
||||
g = gimple_build_assign (make_ssa_name (pointer_sized_int_node),
|
||||
PLUS_EXPR, base_addr, last);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_after (&gsi, g, GSI_NEW_STMT);
|
||||
tree base_end_addr = gimple_assign_lhs (g);
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ build_assign (enum tree_code code, tree op1, int val, tree lhs)
|
|||
tree op2 = build_int_cst (TREE_TYPE (op1), val);
|
||||
if (lhs == NULL_TREE)
|
||||
lhs = make_ssa_name (get_expr_type (code, op1));
|
||||
return gimple_build_assign_with_ops (code, lhs, op1, op2);
|
||||
return gimple_build_assign (lhs, code, op1, op2);
|
||||
}
|
||||
|
||||
gassign *
|
||||
|
|
@ -89,7 +89,7 @@ build_assign (enum tree_code code, tree op1, tree op2, tree lhs)
|
|||
{
|
||||
if (lhs == NULL_TREE)
|
||||
lhs = make_ssa_name (get_expr_type (code, op1));
|
||||
return gimple_build_assign_with_ops (code, lhs, op1, op2);
|
||||
return gimple_build_assign (lhs, code, op1, op2);
|
||||
}
|
||||
|
||||
gassign *
|
||||
|
|
@ -120,7 +120,7 @@ build_type_cast (tree to_type, tree op, tree lhs)
|
|||
{
|
||||
if (lhs == NULL_TREE)
|
||||
lhs = make_ssa_name (to_type);
|
||||
return gimple_build_assign_with_ops (NOP_EXPR, lhs, op);
|
||||
return gimple_build_assign (lhs, NOP_EXPR, op);
|
||||
}
|
||||
|
||||
gassign *
|
||||
|
|
|
|||
|
|
@ -5642,8 +5642,7 @@ rewrite_to_defined_overflow (gimple stmt)
|
|||
if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
||||
gimple_assign_set_rhs_code (stmt, PLUS_EXPR);
|
||||
gimple_seq_add_stmt (&stmts, stmt);
|
||||
gimple cvt = gimple_build_assign_with_ops (NOP_EXPR, lhs,
|
||||
gimple_assign_lhs (stmt));
|
||||
gimple cvt = gimple_build_assign (lhs, NOP_EXPR, gimple_assign_lhs (stmt));
|
||||
gimple_seq_add_stmt (&stmts, cvt);
|
||||
|
||||
return stmts;
|
||||
|
|
@ -5672,10 +5671,9 @@ gimple_build (gimple_seq *seq, location_t loc,
|
|||
if (code == REALPART_EXPR
|
||||
|| code == IMAGPART_EXPR
|
||||
|| code == VIEW_CONVERT_EXPR)
|
||||
stmt = gimple_build_assign_with_ops (code, res,
|
||||
build1 (code, type, op0));
|
||||
stmt = gimple_build_assign (res, code, build1 (code, type, op0));
|
||||
else
|
||||
stmt = gimple_build_assign_with_ops (code, res, op0);
|
||||
stmt = gimple_build_assign (res, code, op0);
|
||||
gimple_set_location (stmt, loc);
|
||||
gimple_seq_add_stmt_without_update (seq, stmt);
|
||||
}
|
||||
|
|
@ -5700,7 +5698,7 @@ gimple_build (gimple_seq *seq, location_t loc,
|
|||
res = make_ssa_name (type);
|
||||
else
|
||||
res = create_tmp_reg (type);
|
||||
gimple stmt = gimple_build_assign_with_ops (code, res, op0, op1);
|
||||
gimple stmt = gimple_build_assign (res, code, op0, op1);
|
||||
gimple_set_location (stmt, loc);
|
||||
gimple_seq_add_stmt_without_update (seq, stmt);
|
||||
}
|
||||
|
|
@ -5728,11 +5726,10 @@ gimple_build (gimple_seq *seq, location_t loc,
|
|||
res = create_tmp_reg (type);
|
||||
gimple stmt;
|
||||
if (code == BIT_FIELD_REF)
|
||||
stmt = gimple_build_assign_with_ops (code, res,
|
||||
build3 (BIT_FIELD_REF, type,
|
||||
op0, op1, op2));
|
||||
stmt = gimple_build_assign (res, code,
|
||||
build3 (code, type, op0, op1, op2));
|
||||
else
|
||||
stmt = gimple_build_assign_with_ops (code, res, op0, op1, op2);
|
||||
stmt = gimple_build_assign (res, code, op0, op1, op2);
|
||||
gimple_set_location (stmt, loc);
|
||||
gimple_seq_add_stmt_without_update (seq, stmt);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -332,8 +332,8 @@ maybe_push_res_to_seq (code_helper rcode, tree type, tree *ops,
|
|||
if (!res)
|
||||
res = make_ssa_name (type);
|
||||
maybe_build_generic_op (rcode, type, &ops[0], ops[1], ops[2]);
|
||||
gimple new_stmt = gimple_build_assign_with_ops (rcode, res,
|
||||
ops[0], ops[1], ops[2]);
|
||||
gimple new_stmt = gimple_build_assign (res, rcode,
|
||||
ops[0], ops[1], ops[2]);
|
||||
gimple_seq_add_stmt_without_update (seq, new_stmt);
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2186,8 +2186,7 @@ create_add_on_incoming_edge (slsr_cand_t c, tree basis_name,
|
|||
}
|
||||
|
||||
bump_tree = wide_int_to_tree (basis_type, bump);
|
||||
new_stmt = gimple_build_assign_with_ops (code, lhs, basis_name,
|
||||
bump_tree);
|
||||
new_stmt = gimple_build_assign (lhs, code, basis_name, bump_tree);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2199,15 +2198,14 @@ create_add_on_incoming_edge (slsr_cand_t c, tree basis_name,
|
|||
if (incr_vec[i].initializer)
|
||||
{
|
||||
enum tree_code code = negate_incr ? MINUS_EXPR : PLUS_EXPR;
|
||||
new_stmt = gimple_build_assign_with_ops (code, lhs, basis_name,
|
||||
incr_vec[i].initializer);
|
||||
new_stmt = gimple_build_assign (lhs, code, basis_name,
|
||||
incr_vec[i].initializer);
|
||||
}
|
||||
else if (increment == 1)
|
||||
new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, lhs, basis_name,
|
||||
c->stride);
|
||||
new_stmt = gimple_build_assign (lhs, PLUS_EXPR, basis_name, c->stride);
|
||||
else if (increment == -1)
|
||||
new_stmt = gimple_build_assign_with_ops (MINUS_EXPR, lhs, basis_name,
|
||||
c->stride);
|
||||
new_stmt = gimple_build_assign (lhs, MINUS_EXPR, basis_name,
|
||||
c->stride);
|
||||
else
|
||||
gcc_unreachable ();
|
||||
}
|
||||
|
|
@ -3160,8 +3158,8 @@ insert_initializers (slsr_cand_t c)
|
|||
/* Create the initializer and insert it in the latest possible
|
||||
dominating position. */
|
||||
incr_tree = wide_int_to_tree (stride_type, incr);
|
||||
init_stmt = gimple_build_assign_with_ops (MULT_EXPR, new_name,
|
||||
c->stride, incr_tree);
|
||||
init_stmt = gimple_build_assign (new_name, MULT_EXPR,
|
||||
c->stride, incr_tree);
|
||||
if (where)
|
||||
{
|
||||
gimple_stmt_iterator gsi = gsi_for_stmt (where->cand_stmt);
|
||||
|
|
@ -3264,7 +3262,7 @@ introduce_cast_before_cand (slsr_cand_t c, tree to_type, tree from_expr)
|
|||
gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt);
|
||||
|
||||
cast_lhs = make_temp_ssa_name (to_type, NULL, "slsr");
|
||||
cast_stmt = gimple_build_assign_with_ops (NOP_EXPR, cast_lhs, from_expr);
|
||||
cast_stmt = gimple_build_assign (cast_lhs, NOP_EXPR, from_expr);
|
||||
gimple_set_location (cast_stmt, gimple_location (c->cand_stmt));
|
||||
gsi_insert_before (&gsi, cast_stmt, GSI_SAME_STMT);
|
||||
|
||||
|
|
@ -3433,8 +3431,7 @@ replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name)
|
|||
else
|
||||
{
|
||||
gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt);
|
||||
gassign *cast_stmt = gimple_build_assign_with_ops (NOP_EXPR, lhs,
|
||||
basis_name);
|
||||
gassign *cast_stmt = gimple_build_assign (lhs, NOP_EXPR, basis_name);
|
||||
gimple_set_location (cast_stmt, gimple_location (c->cand_stmt));
|
||||
gsi_replace (&gsi, cast_stmt, false);
|
||||
c->cand_stmt = cast_stmt;
|
||||
|
|
|
|||
50
gcc/gimple.c
50
gcc/gimple.c
|
|
@ -399,24 +399,22 @@ gimple_build_call_from_tree (tree t)
|
|||
RHS of the assignment which can be unary or binary. */
|
||||
|
||||
gassign *
|
||||
gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
|
||||
gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
|
||||
{
|
||||
enum tree_code subcode;
|
||||
tree op1, op2, op3;
|
||||
|
||||
extract_ops_from_tree_1 (rhs, &subcode, &op1, &op2, &op3);
|
||||
return gimple_build_assign_with_ops (subcode, lhs, op1, op2, op3
|
||||
PASS_MEM_STAT);
|
||||
return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
|
||||
}
|
||||
|
||||
|
||||
/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
|
||||
OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
|
||||
GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
|
||||
OP1, OP2 and OP3. */
|
||||
|
||||
gassign *
|
||||
gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
|
||||
tree op2, tree op3 MEM_STAT_DECL)
|
||||
static inline gassign *
|
||||
gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
|
||||
tree op2, tree op3 MEM_STAT_DECL)
|
||||
{
|
||||
unsigned num_ops;
|
||||
gassign *p;
|
||||
|
|
@ -445,20 +443,34 @@ gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
|
|||
return p;
|
||||
}
|
||||
|
||||
gassign *
|
||||
gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
|
||||
tree op2 MEM_STAT_DECL)
|
||||
{
|
||||
return gimple_build_assign_with_ops (subcode, lhs, op1, op2, NULL_TREE
|
||||
PASS_MEM_STAT);
|
||||
}
|
||||
/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
|
||||
OP1, OP2 and OP3. */
|
||||
|
||||
gassign *
|
||||
gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1
|
||||
MEM_STAT_DECL)
|
||||
gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
|
||||
tree op2, tree op3 MEM_STAT_DECL)
|
||||
{
|
||||
return gimple_build_assign_with_ops (subcode, lhs, op1, NULL_TREE, NULL_TREE
|
||||
PASS_MEM_STAT);
|
||||
return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
|
||||
}
|
||||
|
||||
/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
|
||||
OP1 and OP2. */
|
||||
|
||||
gassign *
|
||||
gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
|
||||
tree op2 MEM_STAT_DECL)
|
||||
{
|
||||
return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
|
||||
PASS_MEM_STAT);
|
||||
}
|
||||
|
||||
/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
|
||||
|
||||
gassign *
|
||||
gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
|
||||
{
|
||||
return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
|
||||
PASS_MEM_STAT);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
14
gcc/gimple.h
14
gcc/gimple.h
|
|
@ -1296,14 +1296,12 @@ gcall *gimple_build_call_valist (tree, unsigned, va_list);
|
|||
gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
|
||||
gcall *gimple_build_call_internal_vec (enum internal_fn, vec<tree> );
|
||||
gcall *gimple_build_call_from_tree (tree);
|
||||
gassign *gimple_build_assign_stat (tree, tree MEM_STAT_DECL);
|
||||
#define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO)
|
||||
gassign *gimple_build_assign_with_ops (enum tree_code, tree,
|
||||
tree, tree, tree CXX_MEM_STAT_INFO);
|
||||
gassign *gimple_build_assign_with_ops (enum tree_code, tree,
|
||||
tree, tree CXX_MEM_STAT_INFO);
|
||||
gassign *gimple_build_assign_with_ops (enum tree_code, tree,
|
||||
tree CXX_MEM_STAT_INFO);
|
||||
gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_DECL);
|
||||
gassign *gimple_build_assign (tree, enum tree_code,
|
||||
tree, tree, tree CXX_MEM_STAT_INFO);
|
||||
gassign *gimple_build_assign (tree, enum tree_code,
|
||||
tree, tree CXX_MEM_STAT_INFO);
|
||||
gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO);
|
||||
gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
|
||||
gcond *gimple_build_cond_from_tree (tree, tree, tree);
|
||||
void gimple_cond_set_condition_from_tree (gcond *, tree);
|
||||
|
|
|
|||
|
|
@ -1586,8 +1586,7 @@ split_function (struct split_point *split_point)
|
|||
gimple cpy;
|
||||
tree tem = create_tmp_reg (restype);
|
||||
tem = make_ssa_name (tem, call);
|
||||
cpy = gimple_build_assign_with_ops (NOP_EXPR, retval,
|
||||
tem);
|
||||
cpy = gimple_build_assign (retval, NOP_EXPR, tem);
|
||||
gsi_insert_after (&gsi, cpy, GSI_NEW_STMT);
|
||||
retval = tem;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3635,7 +3635,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
|
|||
enum tree_code code = PLUS_EXPR;
|
||||
if (POINTER_TYPE_P (TREE_TYPE (new_var)))
|
||||
code = POINTER_PLUS_EXPR;
|
||||
g = gimple_build_assign_with_ops (code, iv, iv, t);
|
||||
g = gimple_build_assign (iv, code, iv, t);
|
||||
gsi_insert_before_without_update (&gsi, g,
|
||||
GSI_SAME_STMT);
|
||||
break;
|
||||
|
|
@ -3845,8 +3845,8 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
|
|||
OMP_CLAUSE__SIMDUID__DECL (c) = uid;
|
||||
OMP_CLAUSE_CHAIN (c) = gimple_omp_for_clauses (ctx->stmt);
|
||||
gimple_omp_for_set_clauses (ctx->stmt, c);
|
||||
g = gimple_build_assign_with_ops (INTEGER_CST, lane,
|
||||
build_int_cst (unsigned_type_node, 0));
|
||||
g = gimple_build_assign (lane, INTEGER_CST,
|
||||
build_int_cst (unsigned_type_node, 0));
|
||||
gimple_seq_add_stmt (ilist, g);
|
||||
for (int i = 0; i < 2; i++)
|
||||
if (llist[i])
|
||||
|
|
@ -3857,7 +3857,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
|
|||
gimple_seq *seq = i == 0 ? ilist : dlist;
|
||||
gimple_seq_add_stmt (seq, g);
|
||||
tree t = build_int_cst (unsigned_type_node, 0);
|
||||
g = gimple_build_assign_with_ops (INTEGER_CST, idx, t);
|
||||
g = gimple_build_assign (idx, INTEGER_CST, t);
|
||||
gimple_seq_add_stmt (seq, g);
|
||||
tree body = create_artificial_label (UNKNOWN_LOCATION);
|
||||
tree header = create_artificial_label (UNKNOWN_LOCATION);
|
||||
|
|
@ -3866,7 +3866,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
|
|||
gimple_seq_add_stmt (seq, gimple_build_label (body));
|
||||
gimple_seq_add_seq (seq, llist[i]);
|
||||
t = build_int_cst (unsigned_type_node, 1);
|
||||
g = gimple_build_assign_with_ops (PLUS_EXPR, idx, idx, t);
|
||||
g = gimple_build_assign (idx, PLUS_EXPR, idx, t);
|
||||
gimple_seq_add_stmt (seq, g);
|
||||
gimple_seq_add_stmt (seq, gimple_build_label (header));
|
||||
g = gimple_build_cond (LT_EXPR, idx, vf, body, end);
|
||||
|
|
@ -5856,7 +5856,7 @@ expand_omp_for_generic (struct omp_region *region,
|
|||
if (useless_type_conversion_p (TREE_TYPE (fd->loop.v), TREE_TYPE (iend)))
|
||||
assign_stmt = gimple_build_assign (fd->loop.v, iend);
|
||||
else
|
||||
assign_stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, iend);
|
||||
assign_stmt = gimple_build_assign (fd->loop.v, NOP_EXPR, iend);
|
||||
gsi_insert_after (&gsi, assign_stmt, GSI_CONTINUE_LINKING);
|
||||
}
|
||||
if (fd->collapse > 1)
|
||||
|
|
@ -6206,8 +6206,7 @@ expand_omp_for_static_nochunk (struct omp_region *region,
|
|||
gsi_insert_before (&gsi, gimple_build_assign (tt, build_int_cst (itype, 0)),
|
||||
GSI_SAME_STMT);
|
||||
gassign *assign_stmt
|
||||
= gimple_build_assign_with_ops (PLUS_EXPR, q, q,
|
||||
build_int_cst (itype, 1));
|
||||
= gimple_build_assign (q, PLUS_EXPR, q, build_int_cst (itype, 1));
|
||||
gsi_insert_before (&gsi, assign_stmt, GSI_SAME_STMT);
|
||||
|
||||
third_bb = split_block (second_bb, assign_stmt)->dest;
|
||||
|
|
@ -6276,7 +6275,7 @@ expand_omp_for_static_nochunk (struct omp_region *region,
|
|||
if (useless_type_conversion_p (TREE_TYPE (fd->loop.v), TREE_TYPE (e)))
|
||||
assign_stmt = gimple_build_assign (fd->loop.v, e);
|
||||
else
|
||||
assign_stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, e);
|
||||
assign_stmt = gimple_build_assign (fd->loop.v, NOP_EXPR, e);
|
||||
gsi_insert_after (&gsi, assign_stmt, GSI_CONTINUE_LINKING);
|
||||
}
|
||||
if (fd->collapse > 1)
|
||||
|
|
@ -6666,7 +6665,7 @@ expand_omp_for_static_chunk (struct omp_region *region,
|
|||
if (useless_type_conversion_p (TREE_TYPE (fd->loop.v), TREE_TYPE (e)))
|
||||
assign_stmt = gimple_build_assign (fd->loop.v, e);
|
||||
else
|
||||
assign_stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, e);
|
||||
assign_stmt = gimple_build_assign (fd->loop.v, NOP_EXPR, e);
|
||||
gsi_insert_after (&gsi, assign_stmt, GSI_CONTINUE_LINKING);
|
||||
}
|
||||
if (fd->collapse > 1)
|
||||
|
|
@ -6934,8 +6933,8 @@ expand_cilk_for (struct omp_region *region, struct omp_for_data *fd)
|
|||
gsi = gsi_last_bb (cont_bb);
|
||||
stmt = gsi_stmt (gsi);
|
||||
gcc_assert (gimple_code (stmt) == GIMPLE_OMP_CONTINUE);
|
||||
stmt = gimple_build_assign_with_ops (PLUS_EXPR, ind_var, ind_var,
|
||||
build_one_cst (type));
|
||||
stmt = gimple_build_assign (ind_var, PLUS_EXPR, ind_var,
|
||||
build_one_cst (type));
|
||||
|
||||
/* Replace GIMPLE_OMP_CONTINUE. */
|
||||
gsi_replace (&gsi, stmt, true);
|
||||
|
|
@ -12121,9 +12120,8 @@ simd_clone_adjust (struct cgraph_node *node)
|
|||
edge e = make_edge (incr_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
|
||||
e->probability = REG_BR_PROB_BASE;
|
||||
gsi = gsi_last_bb (incr_bb);
|
||||
gimple g = gimple_build_assign_with_ops (PLUS_EXPR, iter2, iter1,
|
||||
build_int_cst (unsigned_type_node,
|
||||
1));
|
||||
gimple g = gimple_build_assign (iter2, PLUS_EXPR, iter1,
|
||||
build_int_cst (unsigned_type_node, 1));
|
||||
gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
|
||||
|
||||
/* Mostly annotate the loop for the vectorizer (the rest is done below). */
|
||||
|
|
@ -12239,8 +12237,7 @@ simd_clone_adjust (struct cgraph_node *node)
|
|||
if (need_cvt)
|
||||
{
|
||||
t = make_ssa_name (orig_arg);
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, t,
|
||||
gimple_call_lhs (g));
|
||||
g = gimple_build_assign (t, NOP_EXPR, gimple_call_lhs (g));
|
||||
gimple_seq_add_stmt_without_update (&seq, g);
|
||||
}
|
||||
gsi_insert_seq_on_edge_immediate
|
||||
|
|
@ -12284,7 +12281,7 @@ simd_clone_adjust (struct cgraph_node *node)
|
|||
? TREE_TYPE (orig_arg) : sizetype;
|
||||
tree addcst
|
||||
= build_int_cst (addtype, node->simdclone->args[i].linear_step);
|
||||
g = gimple_build_assign_with_ops (code, iter2, iter1, addcst);
|
||||
g = gimple_build_assign (iter2, code, iter1, addcst);
|
||||
gsi = gsi_last_bb (incr_bb);
|
||||
gsi_insert_before (&gsi, g, GSI_SAME_STMT);
|
||||
|
||||
|
|
|
|||
|
|
@ -2807,8 +2807,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
|
|||
|
||||
tree t1 = create_tmp_reg (tm_state_type);
|
||||
tree t2 = build_int_cst (tm_state_type, A_RESTORELIVEVARIABLES);
|
||||
gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
|
||||
tm_state, t2);
|
||||
gimple stmt = gimple_build_assign (t1, BIT_AND_EXPR, tm_state, t2);
|
||||
gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
|
||||
gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
|
||||
|
||||
|
|
@ -2848,8 +2847,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
|
|||
|
||||
tree t1 = create_tmp_reg (tm_state_type);
|
||||
tree t2 = build_int_cst (tm_state_type, A_ABORTTRANSACTION);
|
||||
gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
|
||||
tm_state, t2);
|
||||
gimple stmt = gimple_build_assign (t1, BIT_AND_EXPR, tm_state, t2);
|
||||
gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
|
||||
gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
|
||||
|
||||
|
|
@ -2891,8 +2889,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
|
|||
tree t1 = create_tmp_reg (tm_state_type);
|
||||
tree t2 = build_int_cst (tm_state_type, A_RUNUNINSTRUMENTEDCODE);
|
||||
|
||||
gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
|
||||
tm_state, t2);
|
||||
gimple stmt = gimple_build_assign (t1, BIT_AND_EXPR, tm_state, t2);
|
||||
gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
|
||||
gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
|
||||
|
||||
|
|
|
|||
|
|
@ -2538,8 +2538,7 @@ chkp_compute_bounds_for_assignment (tree node, gimple assign)
|
|||
rhs1 = unshare_expr (rhs1);
|
||||
|
||||
bounds = chkp_get_tmp_reg (assign);
|
||||
stmt = gimple_build_assign_with_ops (COND_EXPR, bounds,
|
||||
rhs1, bnd1, bnd2);
|
||||
stmt = gimple_build_assign (bounds, COND_EXPR, rhs1, bnd1, bnd2);
|
||||
gsi_insert_after (&iter, stmt, GSI_SAME_STMT);
|
||||
|
||||
if (!chkp_valid_bounds (bnd1) && !chkp_valid_bounds (bnd2))
|
||||
|
|
@ -2565,8 +2564,7 @@ chkp_compute_bounds_for_assignment (tree node, gimple assign)
|
|||
tree cond = build2 (rhs_code == MAX_EXPR ? GT_EXPR : LT_EXPR,
|
||||
boolean_type_node, rhs1, rhs2);
|
||||
bounds = chkp_get_tmp_reg (assign);
|
||||
stmt = gimple_build_assign_with_ops (COND_EXPR, bounds,
|
||||
cond, bnd1, bnd2);
|
||||
stmt = gimple_build_assign (bounds, COND_EXPR, cond, bnd1, bnd2);
|
||||
|
||||
gsi_insert_after (&iter, stmt, GSI_SAME_STMT);
|
||||
|
||||
|
|
@ -2842,9 +2840,9 @@ chkp_generate_extern_var_bounds (tree var)
|
|||
fold_convert (chkp_uintptr_type, lb));
|
||||
max_size = chkp_force_gimple_call_op (max_size, &seq);
|
||||
|
||||
cond = build2 (NE_EXPR, boolean_type_node, size_reloc, integer_zero_node);
|
||||
stmt = gimple_build_assign_with_ops (COND_EXPR, size,
|
||||
cond, size_reloc, max_size);
|
||||
cond = build2 (NE_EXPR, boolean_type_node,
|
||||
size_reloc, integer_zero_node);
|
||||
stmt = gimple_build_assign (size, COND_EXPR, cond, size_reloc, max_size);
|
||||
gimple_seq_add_stmt (&seq, stmt);
|
||||
}
|
||||
else
|
||||
|
|
|
|||
|
|
@ -823,7 +823,7 @@ generate_memset_builtin (struct loop *loop, partition_t partition)
|
|||
else if (!useless_type_conversion_p (integer_type_node, TREE_TYPE (val)))
|
||||
{
|
||||
tree tem = make_ssa_name (integer_type_node);
|
||||
gimple cstmt = gimple_build_assign_with_ops (NOP_EXPR, tem, val);
|
||||
gimple cstmt = gimple_build_assign (tem, NOP_EXPR, val);
|
||||
gsi_insert_after (&gsi, cstmt, GSI_CONTINUE_LINKING);
|
||||
val = tem;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2192,7 +2192,7 @@ reassociate_to_the_same_stmt (tree name1, tree name2)
|
|||
combine it with the rhs of S1. */
|
||||
var = create_tmp_reg (type, "predreastmp");
|
||||
new_name = make_ssa_name (var);
|
||||
new_stmt = gimple_build_assign_with_ops (code, new_name, name1, name2);
|
||||
new_stmt = gimple_build_assign (new_name, code, name1, name2);
|
||||
|
||||
var = create_tmp_reg (type, "predreastmp");
|
||||
tmp_name = make_ssa_name (var);
|
||||
|
|
@ -2200,10 +2200,9 @@ reassociate_to_the_same_stmt (tree name1, tree name2)
|
|||
/* Rhs of S1 may now be either a binary expression with operation
|
||||
CODE, or gimple_val (in case that stmt1 == s1 or stmt2 == s1,
|
||||
so that name1 or name2 was removed from it). */
|
||||
tmp_stmt = gimple_build_assign_with_ops (gimple_assign_rhs_code (s1),
|
||||
tmp_name,
|
||||
gimple_assign_rhs1 (s1),
|
||||
gimple_assign_rhs2 (s1));
|
||||
tmp_stmt = gimple_build_assign (tmp_name, gimple_assign_rhs_code (s1),
|
||||
gimple_assign_rhs1 (s1),
|
||||
gimple_assign_rhs2 (s1));
|
||||
|
||||
bsi = gsi_for_stmt (s1);
|
||||
gimple_assign_set_rhs_with_ops (&bsi, code, new_name, tmp_name);
|
||||
|
|
|
|||
|
|
@ -315,8 +315,8 @@ gimple_gen_edge_profiler (int edgeno, edge e)
|
|||
stmt1 = gimple_build_assign (gcov_type_tmp_var, ref);
|
||||
gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
|
||||
NULL, "PROF_edge_counter");
|
||||
stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, gcov_type_tmp_var,
|
||||
gimple_assign_lhs (stmt1), one);
|
||||
stmt2 = gimple_build_assign (gcov_type_tmp_var, PLUS_EXPR,
|
||||
gimple_assign_lhs (stmt1), one);
|
||||
stmt3 = gimple_build_assign (unshare_expr (ref), gimple_assign_lhs (stmt2));
|
||||
gsi_insert_on_edge (e, stmt1);
|
||||
gsi_insert_on_edge (e, stmt2);
|
||||
|
|
|
|||
|
|
@ -1722,23 +1722,21 @@ simplify_rotate (gimple_stmt_iterator *gsi)
|
|||
if (!useless_type_conversion_p (TREE_TYPE (def_arg2[0]),
|
||||
TREE_TYPE (rotcnt)))
|
||||
{
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (TREE_TYPE (def_arg2[0])),
|
||||
rotcnt);
|
||||
g = gimple_build_assign (make_ssa_name (TREE_TYPE (def_arg2[0])),
|
||||
NOP_EXPR, rotcnt);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
rotcnt = gimple_assign_lhs (g);
|
||||
}
|
||||
lhs = gimple_assign_lhs (stmt);
|
||||
if (!useless_type_conversion_p (rtype, TREE_TYPE (def_arg1[0])))
|
||||
lhs = make_ssa_name (TREE_TYPE (def_arg1[0]));
|
||||
g = gimple_build_assign_with_ops (((def_code[0] == LSHIFT_EXPR) ^ swapped_p)
|
||||
? LROTATE_EXPR : RROTATE_EXPR,
|
||||
lhs, def_arg1[0], rotcnt);
|
||||
g = gimple_build_assign (lhs,
|
||||
((def_code[0] == LSHIFT_EXPR) ^ swapped_p)
|
||||
? LROTATE_EXPR : RROTATE_EXPR, def_arg1[0], rotcnt);
|
||||
if (!useless_type_conversion_p (rtype, TREE_TYPE (def_arg1[0])))
|
||||
{
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, gimple_assign_lhs (stmt),
|
||||
lhs);
|
||||
g = gimple_build_assign (gimple_assign_lhs (stmt), NOP_EXPR, lhs);
|
||||
}
|
||||
gsi_replace (gsi, g, false);
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -898,11 +898,10 @@ rewrite_reciprocal (gimple_stmt_iterator *bsi)
|
|||
real_one = build_one_cst (type);
|
||||
|
||||
name = make_temp_ssa_name (type, NULL, "reciptmp");
|
||||
stmt1 = gimple_build_assign_with_ops (RDIV_EXPR, name, real_one,
|
||||
gimple_assign_rhs2 (stmt));
|
||||
|
||||
stmt2 = gimple_build_assign_with_ops (MULT_EXPR, lhs, name,
|
||||
gimple_assign_rhs1 (stmt));
|
||||
stmt1 = gimple_build_assign (name, RDIV_EXPR, real_one,
|
||||
gimple_assign_rhs2 (stmt));
|
||||
stmt2 = gimple_build_assign (lhs, MULT_EXPR, name,
|
||||
gimple_assign_rhs1 (stmt));
|
||||
|
||||
/* Replace division stmt with reciprocal and multiply stmts.
|
||||
The multiply stmt is not invariant, so update iterator
|
||||
|
|
@ -1215,9 +1214,8 @@ move_computations_dom_walker::before_dom_children (basic_block bb)
|
|||
if (gimple_phi_num_args (stmt) == 1)
|
||||
{
|
||||
tree arg = PHI_ARG_DEF (stmt, 0);
|
||||
new_stmt = gimple_build_assign_with_ops (TREE_CODE (arg),
|
||||
gimple_phi_result (stmt),
|
||||
arg);
|
||||
new_stmt = gimple_build_assign (gimple_phi_result (stmt),
|
||||
TREE_CODE (arg), arg);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1230,9 +1228,8 @@ move_computations_dom_walker::before_dom_children (basic_block bb)
|
|||
gcc_assert (arg0 && arg1);
|
||||
t = build2 (gimple_cond_code (cond), boolean_type_node,
|
||||
gimple_cond_lhs (cond), gimple_cond_rhs (cond));
|
||||
new_stmt = gimple_build_assign_with_ops (COND_EXPR,
|
||||
gimple_phi_result (stmt),
|
||||
t, arg0, arg1);
|
||||
new_stmt = gimple_build_assign (gimple_phi_result (stmt),
|
||||
COND_EXPR, t, arg0, arg1);
|
||||
todo_ |= TODO_cleanup_cfg;
|
||||
}
|
||||
gsi_insert_on_edge (loop_preheader_edge (level), new_stmt);
|
||||
|
|
|
|||
|
|
@ -145,7 +145,7 @@ create_iv (tree base, tree step, tree var, struct loop *loop,
|
|||
if (stmts)
|
||||
gsi_insert_seq_on_edge_immediate (pe, stmts);
|
||||
|
||||
stmt = gimple_build_assign_with_ops (incr_op, va, vb, step);
|
||||
stmt = gimple_build_assign (va, incr_op, vb, step);
|
||||
if (after)
|
||||
gsi_insert_after (incr_pos, stmt, GSI_NEW_STMT);
|
||||
else
|
||||
|
|
|
|||
|
|
@ -378,8 +378,8 @@ insert_reciprocals (gimple_stmt_iterator *def_gsi, struct occurrence *occ,
|
|||
/* Make a variable with the replacement and substitute it. */
|
||||
type = TREE_TYPE (def);
|
||||
recip_def = create_tmp_reg (type, "reciptmp");
|
||||
new_stmt = gimple_build_assign_with_ops (RDIV_EXPR, recip_def,
|
||||
build_one_cst (type), def);
|
||||
new_stmt = gimple_build_assign (recip_def, RDIV_EXPR,
|
||||
build_one_cst (type), def);
|
||||
|
||||
if (occ->bb_has_division)
|
||||
{
|
||||
|
|
@ -1009,7 +1009,7 @@ powi_as_mults_1 (gimple_stmt_iterator *gsi, location_t loc, tree type,
|
|||
op1 = op0;
|
||||
}
|
||||
|
||||
mult_stmt = gimple_build_assign_with_ops (MULT_EXPR, ssa_target, op0, op1);
|
||||
mult_stmt = gimple_build_assign (ssa_target, MULT_EXPR, op0, op1);
|
||||
gimple_set_location (mult_stmt, loc);
|
||||
gsi_insert_before (gsi, mult_stmt, GSI_SAME_STMT);
|
||||
|
||||
|
|
@ -1039,9 +1039,8 @@ powi_as_mults (gimple_stmt_iterator *gsi, location_t loc,
|
|||
|
||||
/* If the original exponent was negative, reciprocate the result. */
|
||||
target = make_temp_ssa_name (type, NULL, "powmult");
|
||||
div_stmt = gimple_build_assign_with_ops (RDIV_EXPR, target,
|
||||
build_real (type, dconst1),
|
||||
result);
|
||||
div_stmt = gimple_build_assign (target, RDIV_EXPR,
|
||||
build_real (type, dconst1), result);
|
||||
gimple_set_location (div_stmt, loc);
|
||||
gsi_insert_before (gsi, div_stmt, GSI_SAME_STMT);
|
||||
|
||||
|
|
@ -1100,7 +1099,7 @@ build_and_insert_binop (gimple_stmt_iterator *gsi, location_t loc,
|
|||
tree arg0, tree arg1)
|
||||
{
|
||||
tree result = make_temp_ssa_name (TREE_TYPE (arg0), NULL, name);
|
||||
gassign *stmt = gimple_build_assign_with_ops (code, result, arg0, arg1);
|
||||
gassign *stmt = gimple_build_assign (result, code, arg0, arg1);
|
||||
gimple_set_location (stmt, loc);
|
||||
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
|
||||
return result;
|
||||
|
|
@ -1130,7 +1129,7 @@ build_and_insert_cast (gimple_stmt_iterator *gsi, location_t loc,
|
|||
tree type, tree val)
|
||||
{
|
||||
tree result = make_ssa_name (type);
|
||||
gassign *stmt = gimple_build_assign_with_ops (NOP_EXPR, result, val);
|
||||
gassign *stmt = gimple_build_assign (result, NOP_EXPR, val);
|
||||
gimple_set_location (stmt, loc);
|
||||
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
|
||||
return result;
|
||||
|
|
@ -1533,17 +1532,14 @@ pass_cse_sincos::execute (function *fun)
|
|||
minus_one = build_real (t0, dconstm1);
|
||||
|
||||
cond = make_temp_ssa_name (t1, NULL, "powi_cond");
|
||||
stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, cond,
|
||||
arg1,
|
||||
build_int_cst (t1,
|
||||
1));
|
||||
stmt = gimple_build_assign (cond, BIT_AND_EXPR,
|
||||
arg1, build_int_cst (t1, 1));
|
||||
gimple_set_location (stmt, loc);
|
||||
gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
|
||||
|
||||
result = make_temp_ssa_name (t0, NULL, "powi");
|
||||
stmt = gimple_build_assign_with_ops (COND_EXPR, result,
|
||||
cond,
|
||||
minus_one, one);
|
||||
stmt = gimple_build_assign (result, COND_EXPR, cond,
|
||||
minus_one, one);
|
||||
gimple_set_location (stmt, loc);
|
||||
gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
|
||||
}
|
||||
|
|
@ -2318,7 +2314,7 @@ bswap_replace (gimple cur_stmt, gimple src_stmt, tree fndecl, tree bswap_type,
|
|||
{
|
||||
gimple convert_stmt;
|
||||
tmp = make_temp_ssa_name (bswap_type, NULL, "bswapsrc");
|
||||
convert_stmt = gimple_build_assign_with_ops (NOP_EXPR, tmp, src);
|
||||
convert_stmt = gimple_build_assign (tmp, NOP_EXPR, src);
|
||||
gsi_insert_before (&gsi, convert_stmt, GSI_SAME_STMT);
|
||||
}
|
||||
|
||||
|
|
@ -2332,7 +2328,7 @@ bswap_replace (gimple cur_stmt, gimple src_stmt, tree fndecl, tree bswap_type,
|
|||
{
|
||||
gimple convert_stmt;
|
||||
tmp = make_temp_ssa_name (bswap_type, NULL, "bswapdst");
|
||||
convert_stmt = gimple_build_assign_with_ops (NOP_EXPR, tgt, tmp);
|
||||
convert_stmt = gimple_build_assign (tgt, NOP_EXPR, tmp);
|
||||
gsi_insert_after (&gsi, convert_stmt, GSI_SAME_STMT);
|
||||
}
|
||||
|
||||
|
|
@ -3174,9 +3170,8 @@ convert_mult_to_fma (gimple mul_stmt, tree op1, tree op2)
|
|||
true, NULL_TREE, true,
|
||||
GSI_SAME_STMT);
|
||||
|
||||
fma_stmt = gimple_build_assign_with_ops (FMA_EXPR,
|
||||
gimple_assign_lhs (use_stmt),
|
||||
mulop1, op2, addop);
|
||||
fma_stmt = gimple_build_assign (gimple_assign_lhs (use_stmt),
|
||||
FMA_EXPR, mulop1, op2, addop);
|
||||
gsi_replace (&gsi, fma_stmt, true);
|
||||
widen_mul_stats.fmas_inserted++;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -537,8 +537,7 @@ conditional_replacement (basic_block cond_bb, basic_block middle_bb,
|
|||
source_location locus_0, locus_1;
|
||||
|
||||
new_var2 = make_ssa_name (TREE_TYPE (result));
|
||||
new_stmt = gimple_build_assign_with_ops (CONVERT_EXPR, new_var2,
|
||||
new_var);
|
||||
new_stmt = gimple_build_assign (new_var2, CONVERT_EXPR, new_var);
|
||||
gsi_insert_before (&gsi, new_stmt, GSI_SAME_STMT);
|
||||
new_var = new_var2;
|
||||
|
||||
|
|
@ -1151,7 +1150,7 @@ minmax_replacement (basic_block cond_bb, basic_block middle_bb,
|
|||
|
||||
/* Emit the statement to compute min/max. */
|
||||
result = duplicate_ssa_name (PHI_RESULT (phi), NULL);
|
||||
new_stmt = gimple_build_assign_with_ops (minmax, result, arg0, arg1);
|
||||
new_stmt = gimple_build_assign (result, minmax, arg0, arg1);
|
||||
gsi = gsi_last_bb (cond_bb);
|
||||
gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
|
||||
|
|
@ -1258,7 +1257,7 @@ abs_replacement (basic_block cond_bb, basic_block middle_bb,
|
|||
lhs = result;
|
||||
|
||||
/* Build the modify expression with abs expression. */
|
||||
new_stmt = gimple_build_assign_with_ops (ABS_EXPR, lhs, rhs);
|
||||
new_stmt = gimple_build_assign (lhs, ABS_EXPR, rhs);
|
||||
|
||||
gsi = gsi_last_bb (cond_bb);
|
||||
gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
|
|
@ -1268,7 +1267,7 @@ abs_replacement (basic_block cond_bb, basic_block middle_bb,
|
|||
/* Get the right GSI. We want to insert after the recently
|
||||
added ABS_EXPR statement (which we know is the first statement
|
||||
in the block. */
|
||||
new_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, result, lhs);
|
||||
new_stmt = gimple_build_assign (result, NEGATE_EXPR, lhs);
|
||||
|
||||
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
}
|
||||
|
|
@ -1371,9 +1370,9 @@ neg_replacement (basic_block cond_bb, basic_block middle_bb,
|
|||
}
|
||||
|
||||
tree cond_val = make_ssa_name (boolean_type_node);
|
||||
new_stmt = gimple_build_assign_with_ops (cond_code, cond_val,
|
||||
gimple_cond_lhs (cond),
|
||||
gimple_cond_rhs (cond));
|
||||
new_stmt = gimple_build_assign (cond_val, cond_code,
|
||||
gimple_cond_lhs (cond),
|
||||
gimple_cond_rhs (cond));
|
||||
gsi = gsi_last_bb (cond_bb);
|
||||
gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
|
||||
|
|
@ -1382,8 +1381,8 @@ neg_replacement (basic_block cond_bb, basic_block middle_bb,
|
|||
if (invert)
|
||||
{
|
||||
tree tmp = make_ssa_name (boolean_type_node);
|
||||
new_stmt = gimple_build_assign_with_ops (BIT_XOR_EXPR, tmp,
|
||||
cond_val, boolean_true_node);
|
||||
new_stmt = gimple_build_assign (tmp, BIT_XOR_EXPR, cond_val,
|
||||
boolean_true_node);
|
||||
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
cond_val = tmp;
|
||||
}
|
||||
|
|
@ -1391,23 +1390,21 @@ neg_replacement (basic_block cond_bb, basic_block middle_bb,
|
|||
/* Get the condition in the right type so that we can perform
|
||||
logical and arithmetic operations on it. */
|
||||
tree cond_val_converted = make_ssa_name (TREE_TYPE (rhs));
|
||||
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, cond_val_converted,
|
||||
cond_val);
|
||||
new_stmt = gimple_build_assign (cond_val_converted, NOP_EXPR, cond_val);
|
||||
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
|
||||
tree neg_cond_val_converted = make_ssa_name (TREE_TYPE (rhs));
|
||||
new_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, neg_cond_val_converted,
|
||||
cond_val_converted);
|
||||
new_stmt = gimple_build_assign (neg_cond_val_converted, NEGATE_EXPR,
|
||||
cond_val_converted);
|
||||
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
|
||||
tree tmp = make_ssa_name (TREE_TYPE (rhs));
|
||||
new_stmt = gimple_build_assign_with_ops (BIT_XOR_EXPR, tmp,
|
||||
rhs, neg_cond_val_converted);
|
||||
new_stmt = gimple_build_assign (tmp, BIT_XOR_EXPR, rhs,
|
||||
neg_cond_val_converted);
|
||||
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
|
||||
tree new_lhs = make_ssa_name (TREE_TYPE (rhs));
|
||||
new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, new_lhs,
|
||||
tmp, cond_val_converted);
|
||||
new_stmt = gimple_build_assign (new_lhs, PLUS_EXPR, tmp, cond_val_converted);
|
||||
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
|
||||
|
||||
replace_phi_edge_with_variable (cond_bb, e1, phi, new_lhs);
|
||||
|
|
|
|||
|
|
@ -1342,7 +1342,7 @@ build_and_add_sum (tree type, tree op1, tree op2, enum tree_code opcode)
|
|||
|
||||
/* Create the addition statement. */
|
||||
op = make_ssa_name (type);
|
||||
sum = gimple_build_assign_with_ops (opcode, op, op1, op2);
|
||||
sum = gimple_build_assign (op, opcode, op1, op2);
|
||||
|
||||
/* Find an insertion place and insert. */
|
||||
if (TREE_CODE (op1) == SSA_NAME)
|
||||
|
|
@ -2592,9 +2592,8 @@ optimize_range_tests_to_bit_test (enum tree_code opcode, int first, int length,
|
|||
gimple_seq_add_seq_without_update (&seq, seq2);
|
||||
gcc_assert (TREE_CODE (exp) == SSA_NAME);
|
||||
gimple_set_visited (SSA_NAME_DEF_STMT (exp), true);
|
||||
gimple g
|
||||
= gimple_build_assign_with_ops (BIT_IOR_EXPR,
|
||||
make_ssa_name (optype), tem, exp);
|
||||
gimple g = gimple_build_assign (make_ssa_name (optype),
|
||||
BIT_IOR_EXPR, tem, exp);
|
||||
gimple_set_location (g, loc);
|
||||
gimple_seq_add_stmt_without_update (&seq, g);
|
||||
exp = gimple_assign_lhs (g);
|
||||
|
|
@ -2999,8 +2998,8 @@ update_ops (tree var, enum tree_code code, vec<operand_entry_t> ops,
|
|||
{
|
||||
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
||||
var = make_ssa_name (TREE_TYPE (var));
|
||||
gassign *g = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
|
||||
var, rhs[2], rhs[3]);
|
||||
gassign *g = gimple_build_assign (var, gimple_assign_rhs_code (stmt),
|
||||
rhs[2], rhs[3]);
|
||||
gimple_set_uid (g, gimple_uid (stmt));
|
||||
gimple_set_visited (g, true);
|
||||
gsi_insert_before (&gsi, g, GSI_SAME_STMT);
|
||||
|
|
@ -3305,8 +3304,7 @@ maybe_optimize_range_tests (gimple stmt)
|
|||
g = gimple_build_assign (new_lhs, new_op);
|
||||
}
|
||||
else
|
||||
g = gimple_build_assign_with_ops (rhs_code, new_lhs,
|
||||
new_op);
|
||||
g = gimple_build_assign (new_lhs, rhs_code, new_op);
|
||||
gimple_stmt_iterator gsi = gsi_for_stmt (cast_stmt);
|
||||
gimple_set_uid (g, gimple_uid (cast_stmt));
|
||||
gimple_set_visited (g, true);
|
||||
|
|
@ -3519,8 +3517,8 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
|
|||
gimple insert_point = find_insert_point (stmt, oe1->op, oe2->op);
|
||||
lhs = make_ssa_name (TREE_TYPE (lhs));
|
||||
stmt
|
||||
= gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
|
||||
lhs, oe1->op, oe2->op);
|
||||
= gimple_build_assign (lhs, gimple_assign_rhs_code (stmt),
|
||||
oe1->op, oe2->op);
|
||||
gimple_set_uid (stmt, uid);
|
||||
gimple_set_visited (stmt, true);
|
||||
if (insert_point == gsi_stmt (gsi))
|
||||
|
|
@ -3583,8 +3581,8 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
|
|||
gimple insert_point = find_insert_point (stmt, new_rhs1, oe->op);
|
||||
|
||||
lhs = make_ssa_name (TREE_TYPE (lhs));
|
||||
stmt = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
|
||||
lhs, new_rhs1, oe->op);
|
||||
stmt = gimple_build_assign (lhs, gimple_assign_rhs_code (stmt),
|
||||
new_rhs1, oe->op);
|
||||
gimple_set_uid (stmt, uid);
|
||||
gimple_set_visited (stmt, true);
|
||||
if (insert_point == gsi_stmt (gsi))
|
||||
|
|
@ -3800,10 +3798,10 @@ linearize_expr (gimple stmt)
|
|||
gsi = gsi_for_stmt (stmt);
|
||||
|
||||
gimple_assign_set_rhs2 (stmt, gimple_assign_rhs1 (binrhs));
|
||||
binrhs = gimple_build_assign_with_ops (gimple_assign_rhs_code (binrhs),
|
||||
make_ssa_name (TREE_TYPE (lhs)),
|
||||
gimple_assign_lhs (binlhs),
|
||||
gimple_assign_rhs2 (binrhs));
|
||||
binrhs = gimple_build_assign (make_ssa_name (TREE_TYPE (lhs)),
|
||||
gimple_assign_rhs_code (binrhs),
|
||||
gimple_assign_lhs (binlhs),
|
||||
gimple_assign_rhs2 (binrhs));
|
||||
gimple_assign_set_rhs1 (stmt, gimple_assign_lhs (binrhs));
|
||||
gsi_insert_before (&gsi, binrhs, GSI_SAME_STMT);
|
||||
gimple_set_uid (binrhs, gimple_uid (stmt));
|
||||
|
|
@ -3891,7 +3889,7 @@ negate_value (tree tonegate, gimple_stmt_iterator *gsip)
|
|||
gsi = gsi_for_stmt (negatedefstmt);
|
||||
lhs = make_ssa_name (TREE_TYPE (lhs));
|
||||
gimple_set_visited (negatedefstmt, true);
|
||||
g = gimple_build_assign_with_ops (PLUS_EXPR, lhs, rhs1, rhs2);
|
||||
g = gimple_build_assign (lhs, PLUS_EXPR, rhs1, rhs2);
|
||||
gimple_set_uid (g, gimple_uid (negatedefstmt));
|
||||
gsi_insert_before (&gsi, g, GSI_SAME_STMT);
|
||||
return lhs;
|
||||
|
|
@ -4217,7 +4215,7 @@ repropagate_negates (void)
|
|||
gimple_stmt_iterator gsi = gsi_for_stmt (feed);
|
||||
gimple_stmt_iterator gsi2 = gsi_for_stmt (user);
|
||||
tree x = make_ssa_name (TREE_TYPE (gimple_assign_lhs (feed)));
|
||||
gimple g = gimple_build_assign_with_ops (PLUS_EXPR, x, a, b);
|
||||
gimple g = gimple_build_assign (x, PLUS_EXPR, a, b);
|
||||
gsi_insert_before (&gsi2, g, GSI_SAME_STMT);
|
||||
gimple_assign_set_rhs_with_ops (&gsi2, NEGATE_EXPR, x);
|
||||
user = gsi_stmt (gsi2);
|
||||
|
|
@ -4570,9 +4568,8 @@ attempt_builtin_powi (gimple stmt, vec<operand_entry_t> *ops)
|
|||
op2 = rf2->repr;
|
||||
|
||||
target_ssa = make_temp_ssa_name (type, NULL, "reassocpow");
|
||||
mul_stmt = gimple_build_assign_with_ops (MULT_EXPR,
|
||||
target_ssa,
|
||||
op1, op2);
|
||||
mul_stmt = gimple_build_assign (target_ssa, MULT_EXPR,
|
||||
op1, op2);
|
||||
gimple_set_location (mul_stmt, gimple_location (stmt));
|
||||
gsi_insert_before (&gsi, mul_stmt, GSI_SAME_STMT);
|
||||
rf1->repr = target_ssa;
|
||||
|
|
@ -4599,8 +4596,8 @@ attempt_builtin_powi (gimple stmt, vec<operand_entry_t> *ops)
|
|||
if (result)
|
||||
{
|
||||
tree new_result = make_temp_ssa_name (type, NULL, "reassocpow");
|
||||
mul_stmt = gimple_build_assign_with_ops (MULT_EXPR, new_result,
|
||||
result, iter_result);
|
||||
mul_stmt = gimple_build_assign (new_result, MULT_EXPR,
|
||||
result, iter_result);
|
||||
gimple_set_location (mul_stmt, gimple_location (stmt));
|
||||
gsi_insert_before (&gsi, mul_stmt, GSI_SAME_STMT);
|
||||
gimple_set_visited (mul_stmt, true);
|
||||
|
|
@ -4857,9 +4854,8 @@ reassociate_bb (basic_block bb)
|
|||
update_stmt (lhs_stmt);
|
||||
if (lhs != new_lhs)
|
||||
target_ssa = new_lhs;
|
||||
mul_stmt = gimple_build_assign_with_ops (MULT_EXPR, lhs,
|
||||
powi_result,
|
||||
target_ssa);
|
||||
mul_stmt = gimple_build_assign (lhs, MULT_EXPR,
|
||||
powi_result, target_ssa);
|
||||
gimple_set_location (mul_stmt, gimple_location (stmt));
|
||||
gsi_insert_after (&gsi, mul_stmt, GSI_NEW_STMT);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -465,11 +465,9 @@ get_string_length (strinfo si)
|
|||
lhs = force_gimple_operand_gsi (&gsi, lhs, true, NULL_TREE,
|
||||
true, GSI_SAME_STMT);
|
||||
}
|
||||
lenstmt
|
||||
= gimple_build_assign_with_ops
|
||||
(POINTER_PLUS_EXPR,
|
||||
make_ssa_name (TREE_TYPE (gimple_call_arg (stmt, 0))),
|
||||
tem, lhs);
|
||||
lenstmt = gimple_build_assign
|
||||
(make_ssa_name (TREE_TYPE (gimple_call_arg (stmt, 0))),
|
||||
POINTER_PLUS_EXPR,tem, lhs);
|
||||
gsi_insert_before (&gsi, lenstmt, GSI_SAME_STMT);
|
||||
gimple_call_set_arg (stmt, 0, gimple_assign_lhs (lenstmt));
|
||||
lhs = NULL_TREE;
|
||||
|
|
|
|||
|
|
@ -665,7 +665,7 @@ adjust_return_value_with_ops (enum tree_code code, const char *label,
|
|||
}
|
||||
if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1))
|
||||
&& code != POINTER_PLUS_EXPR)
|
||||
stmt = gimple_build_assign_with_ops (code, result, acc, op1);
|
||||
stmt = gimple_build_assign (result, code, acc, op1);
|
||||
else
|
||||
{
|
||||
tree tem;
|
||||
|
|
@ -696,7 +696,7 @@ update_accumulator_with_ops (enum tree_code code, tree acc, tree op1,
|
|||
gassign *stmt;
|
||||
tree var = copy_ssa_name (acc);
|
||||
if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1)))
|
||||
stmt = gimple_build_assign_with_ops (code, var, acc, op1);
|
||||
stmt = gimple_build_assign (var, code, acc, op1);
|
||||
else
|
||||
{
|
||||
tree rhs = fold_convert (TREE_TYPE (acc),
|
||||
|
|
|
|||
|
|
@ -4348,8 +4348,8 @@ bump_vector_ptr (tree dataref_ptr, gimple ptr_incr, gimple_stmt_iterator *gsi,
|
|||
update = bump;
|
||||
|
||||
new_dataref_ptr = copy_ssa_name (dataref_ptr);
|
||||
incr_stmt = gimple_build_assign_with_ops (POINTER_PLUS_EXPR, new_dataref_ptr,
|
||||
dataref_ptr, update);
|
||||
incr_stmt = gimple_build_assign (new_dataref_ptr, POINTER_PLUS_EXPR,
|
||||
dataref_ptr, update);
|
||||
vect_finish_stmt_generation (stmt, incr_stmt, gsi);
|
||||
|
||||
/* Copy the points-to information if it exists. */
|
||||
|
|
@ -4640,9 +4640,8 @@ vect_permute_store_chain (vec<tree> dr_chain,
|
|||
{j, nelt, *, j + 1, nelt + j + 1, *,
|
||||
j + 2, nelt + j + 2, *, ...}> */
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_low");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect1, vect2,
|
||||
perm3_mask_low);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, vect1,
|
||||
vect2, perm3_mask_low);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
|
||||
vect1 = data_ref;
|
||||
|
|
@ -4652,9 +4651,8 @@ vect_permute_store_chain (vec<tree> dr_chain,
|
|||
{0, 1, nelt + j, 3, 4, nelt + j + 1,
|
||||
6, 7, nelt + j + 2, ...}> */
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_high");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect1, vect2,
|
||||
perm3_mask_high);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, vect1,
|
||||
vect2, perm3_mask_high);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[j] = data_ref;
|
||||
}
|
||||
|
|
@ -4686,9 +4684,8 @@ vect_permute_store_chain (vec<tree> dr_chain,
|
|||
high = VEC_PERM_EXPR <vect1, vect2, {0, nelt, 1, nelt+1,
|
||||
...}> */
|
||||
high = make_temp_ssa_name (vectype, NULL, "vect_inter_high");
|
||||
perm_stmt
|
||||
= gimple_build_assign_with_ops (VEC_PERM_EXPR, high,
|
||||
vect1, vect2, perm_mask_high);
|
||||
perm_stmt = gimple_build_assign (high, VEC_PERM_EXPR, vect1,
|
||||
vect2, perm_mask_high);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[2*j] = high;
|
||||
|
||||
|
|
@ -4697,9 +4694,8 @@ vect_permute_store_chain (vec<tree> dr_chain,
|
|||
{nelt/2, nelt*3/2, nelt/2+1, nelt*3/2+1,
|
||||
...}> */
|
||||
low = make_temp_ssa_name (vectype, NULL, "vect_inter_low");
|
||||
perm_stmt
|
||||
= gimple_build_assign_with_ops (VEC_PERM_EXPR, low,
|
||||
vect1, vect2, perm_mask_low);
|
||||
perm_stmt = gimple_build_assign (low, VEC_PERM_EXPR, vect1,
|
||||
vect2, perm_mask_low);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[2*j+1] = low;
|
||||
}
|
||||
|
|
@ -4880,8 +4876,8 @@ vect_setup_realignment (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
NULL_TREE, &init_addr, NULL, &inc,
|
||||
true, &inv_p);
|
||||
new_temp = copy_ssa_name (ptr);
|
||||
new_stmt = gimple_build_assign_with_ops
|
||||
(BIT_AND_EXPR, new_temp, ptr,
|
||||
new_stmt = gimple_build_assign
|
||||
(new_temp, BIT_AND_EXPR, ptr,
|
||||
build_int_cst (TREE_TYPE (ptr),
|
||||
-(HOST_WIDE_INT)TYPE_ALIGN_UNIT (vectype)));
|
||||
new_bb = gsi_insert_on_edge_immediate (pe, new_stmt);
|
||||
|
|
@ -5194,9 +5190,8 @@ vect_permute_load_chain (vec<tree> dr_chain,
|
|||
low = VEC_PERM_EXPR <first_vect, second_vect2, {k, 3 + k, 6 + k,
|
||||
...}> */
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_low");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
first_vect, second_vect,
|
||||
perm3_mask_low);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, first_vect,
|
||||
second_vect, perm3_mask_low);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
|
||||
/* Create interleaving stmt (high part of):
|
||||
|
|
@ -5205,9 +5200,8 @@ vect_permute_load_chain (vec<tree> dr_chain,
|
|||
first_vect = data_ref;
|
||||
second_vect = dr_chain[2];
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_high");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
first_vect, second_vect,
|
||||
perm3_mask_high);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, first_vect,
|
||||
second_vect, perm3_mask_high);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[k] = data_ref;
|
||||
}
|
||||
|
|
@ -5234,17 +5228,17 @@ vect_permute_load_chain (vec<tree> dr_chain,
|
|||
|
||||
/* data_ref = permute_even (first_data_ref, second_data_ref); */
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_perm_even");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
first_vect, second_vect,
|
||||
perm_mask_even);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
first_vect, second_vect,
|
||||
perm_mask_even);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[j/2] = data_ref;
|
||||
|
||||
/* data_ref = permute_odd (first_data_ref, second_data_ref); */
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_perm_odd");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
first_vect, second_vect,
|
||||
perm_mask_odd);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
first_vect, second_vect,
|
||||
perm_mask_odd);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[j/2+length/2] = data_ref;
|
||||
}
|
||||
|
|
@ -5431,30 +5425,28 @@ vect_shift_permute_load_chain (vec<tree> dr_chain,
|
|||
second_vect = dr_chain[j + 1];
|
||||
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle2");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
first_vect, first_vect,
|
||||
perm2_mask1);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
first_vect, first_vect,
|
||||
perm2_mask1);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
vect[0] = data_ref;
|
||||
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle2");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
second_vect, second_vect,
|
||||
perm2_mask2);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
second_vect, second_vect,
|
||||
perm2_mask2);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
vect[1] = data_ref;
|
||||
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect[0], vect[1],
|
||||
shift1_mask);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
vect[0], vect[1], shift1_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[j/2 + length/2] = data_ref;
|
||||
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_select");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect[0], vect[1],
|
||||
select_mask);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
vect[0], vect[1], select_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[j/2] = data_ref;
|
||||
}
|
||||
|
|
@ -5544,9 +5536,9 @@ vect_shift_permute_load_chain (vec<tree> dr_chain,
|
|||
for (k = 0; k < 3; k++)
|
||||
{
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
dr_chain[k], dr_chain[k],
|
||||
perm3_mask);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
dr_chain[k], dr_chain[k],
|
||||
perm3_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
vect[k] = data_ref;
|
||||
}
|
||||
|
|
@ -5554,10 +5546,9 @@ vect_shift_permute_load_chain (vec<tree> dr_chain,
|
|||
for (k = 0; k < 3; k++)
|
||||
{
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift1");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect[k % 3],
|
||||
vect[(k + 1) % 3],
|
||||
shift1_mask);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
vect[k % 3], vect[(k + 1) % 3],
|
||||
shift1_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
vect_shift[k] = data_ref;
|
||||
}
|
||||
|
|
@ -5565,10 +5556,10 @@ vect_shift_permute_load_chain (vec<tree> dr_chain,
|
|||
for (k = 0; k < 3; k++)
|
||||
{
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift2");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect_shift[(4 - k) % 3],
|
||||
vect_shift[(3 - k) % 3],
|
||||
shift2_mask);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
|
||||
vect_shift[(4 - k) % 3],
|
||||
vect_shift[(3 - k) % 3],
|
||||
shift2_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
vect[k] = data_ref;
|
||||
}
|
||||
|
|
@ -5576,16 +5567,14 @@ vect_shift_permute_load_chain (vec<tree> dr_chain,
|
|||
(*result_chain)[3 - (nelt % 3)] = vect[2];
|
||||
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift3");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect[0], vect[0],
|
||||
shift3_mask);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, vect[0],
|
||||
vect[0], shift3_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[nelt % 3] = data_ref;
|
||||
|
||||
data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift4");
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
vect[1], vect[1],
|
||||
shift4_mask);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, vect[1],
|
||||
vect[1], shift4_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
(*result_chain)[0] = data_ref;
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -640,8 +640,8 @@ expand_vector_divmod (gimple_stmt_iterator *gsi, tree type, tree op0,
|
|||
<< shifts[i]) - 1);
|
||||
cst = build_vector (type, vec);
|
||||
addend = make_ssa_name (type);
|
||||
stmt = gimple_build_assign_with_ops (VEC_COND_EXPR, addend,
|
||||
cond, cst, zero);
|
||||
stmt = gimple_build_assign (addend, VEC_COND_EXPR, cond,
|
||||
cst, zero);
|
||||
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
|
||||
}
|
||||
}
|
||||
|
|
@ -1082,8 +1082,8 @@ optimize_vector_constructor (gimple_stmt_iterator *gsi)
|
|||
CONSTRUCTOR_ELT (rhs, i)->value = base;
|
||||
g = gimple_build_assign (make_ssa_name (type), rhs);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
g = gimple_build_assign_with_ops (PLUS_EXPR, lhs, gimple_assign_lhs (g),
|
||||
build_vector (type, cst));
|
||||
g = gimple_build_assign (lhs, PLUS_EXPR, gimple_assign_lhs (g),
|
||||
build_vector (type, cst));
|
||||
gsi_replace (gsi, g, false);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2157,8 +2157,7 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo,
|
|||
|
||||
sprintf (tmp_name, "addr2int%d", i);
|
||||
addr_tmp_name = make_temp_ssa_name (int_ptrsize_type, NULL, tmp_name);
|
||||
addr_stmt = gimple_build_assign_with_ops (NOP_EXPR, addr_tmp_name,
|
||||
addr_base);
|
||||
addr_stmt = gimple_build_assign (addr_tmp_name, NOP_EXPR, addr_base);
|
||||
gimple_seq_add_stmt (cond_expr_stmt_list, addr_stmt);
|
||||
|
||||
/* The addresses are OR together. */
|
||||
|
|
@ -2168,9 +2167,8 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo,
|
|||
/* create: or_tmp = or_tmp | addr_tmp */
|
||||
sprintf (tmp_name, "orptrs%d", i);
|
||||
new_or_tmp_name = make_temp_ssa_name (int_ptrsize_type, NULL, tmp_name);
|
||||
or_stmt = gimple_build_assign_with_ops (BIT_IOR_EXPR,
|
||||
new_or_tmp_name,
|
||||
or_tmp_name, addr_tmp_name);
|
||||
or_stmt = gimple_build_assign (new_or_tmp_name, BIT_IOR_EXPR,
|
||||
or_tmp_name, addr_tmp_name);
|
||||
gimple_seq_add_stmt (cond_expr_stmt_list, or_stmt);
|
||||
or_tmp_name = new_or_tmp_name;
|
||||
}
|
||||
|
|
@ -2184,8 +2182,8 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo,
|
|||
/* create: and_tmp = or_tmp & mask */
|
||||
and_tmp_name = make_temp_ssa_name (int_ptrsize_type, NULL, "andmask");
|
||||
|
||||
and_stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, and_tmp_name,
|
||||
or_tmp_name, mask_cst);
|
||||
and_stmt = gimple_build_assign (and_tmp_name, BIT_AND_EXPR,
|
||||
or_tmp_name, mask_cst);
|
||||
gimple_seq_add_stmt (cond_expr_stmt_list, and_stmt);
|
||||
|
||||
/* Make and_tmp the left operand of the conditional test against zero.
|
||||
|
|
|
|||
|
|
@ -2503,8 +2503,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
|
|||
{
|
||||
tree rhs = gimple_assign_rhs2 (def_stmt);
|
||||
tree negrhs = make_ssa_name (TREE_TYPE (rhs));
|
||||
gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
|
||||
rhs);
|
||||
gimple negate_stmt = gimple_build_assign (negrhs, NEGATE_EXPR, rhs);
|
||||
gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
|
||||
set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt,
|
||||
loop_info, NULL));
|
||||
|
|
@ -3380,10 +3379,13 @@ get_initial_def_for_induction (gimple iv_phi)
|
|||
/* If the initial value is not of proper type, convert it. */
|
||||
if (!useless_type_conversion_p (vectype, TREE_TYPE (vec_init)))
|
||||
{
|
||||
new_stmt = gimple_build_assign_with_ops
|
||||
(VIEW_CONVERT_EXPR,
|
||||
vect_get_new_vect_var (vectype, vect_simple_var, "vec_iv_"),
|
||||
build1 (VIEW_CONVERT_EXPR, vectype, vec_init));
|
||||
new_stmt
|
||||
= gimple_build_assign (vect_get_new_vect_var (vectype,
|
||||
vect_simple_var,
|
||||
"vec_iv_"),
|
||||
VIEW_CONVERT_EXPR,
|
||||
build1 (VIEW_CONVERT_EXPR, vectype,
|
||||
vec_init));
|
||||
vec_init = make_ssa_name (gimple_assign_lhs (new_stmt), new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, vec_init);
|
||||
new_bb = gsi_insert_on_edge_immediate (loop_preheader_edge (iv_loop),
|
||||
|
|
@ -3496,8 +3498,7 @@ get_initial_def_for_induction (gimple iv_phi)
|
|||
induc_def = PHI_RESULT (induction_phi);
|
||||
|
||||
/* Create the iv update inside the loop */
|
||||
new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
|
||||
induc_def, vec_step);
|
||||
new_stmt = gimple_build_assign (vec_dest, PLUS_EXPR, induc_def, vec_step);
|
||||
vec_def = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, vec_def);
|
||||
gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
|
||||
|
|
@ -3546,20 +3547,21 @@ get_initial_def_for_induction (gimple iv_phi)
|
|||
for (i = 1; i < ncopies; i++)
|
||||
{
|
||||
/* vec_i = vec_prev + vec_step */
|
||||
new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
|
||||
vec_def, vec_step);
|
||||
new_stmt = gimple_build_assign (vec_dest, PLUS_EXPR,
|
||||
vec_def, vec_step);
|
||||
vec_def = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, vec_def);
|
||||
|
||||
gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
|
||||
if (!useless_type_conversion_p (resvectype, vectype))
|
||||
{
|
||||
new_stmt = gimple_build_assign_with_ops
|
||||
(VIEW_CONVERT_EXPR,
|
||||
vect_get_new_vect_var (resvectype, vect_simple_var,
|
||||
"vec_iv_"),
|
||||
build1 (VIEW_CONVERT_EXPR, resvectype,
|
||||
gimple_assign_lhs (new_stmt)));
|
||||
new_stmt
|
||||
= gimple_build_assign
|
||||
(vect_get_new_vect_var (resvectype, vect_simple_var,
|
||||
"vec_iv_"),
|
||||
VIEW_CONVERT_EXPR,
|
||||
build1 (VIEW_CONVERT_EXPR, resvectype,
|
||||
gimple_assign_lhs (new_stmt)));
|
||||
gimple_assign_set_lhs (new_stmt,
|
||||
make_ssa_name
|
||||
(gimple_assign_lhs (new_stmt), new_stmt));
|
||||
|
|
@ -3623,10 +3625,12 @@ get_initial_def_for_induction (gimple iv_phi)
|
|||
STMT_VINFO_VEC_STMT (phi_info) = induction_phi;
|
||||
if (!useless_type_conversion_p (resvectype, vectype))
|
||||
{
|
||||
new_stmt = gimple_build_assign_with_ops
|
||||
(VIEW_CONVERT_EXPR,
|
||||
vect_get_new_vect_var (resvectype, vect_simple_var, "vec_iv_"),
|
||||
build1 (VIEW_CONVERT_EXPR, resvectype, induc_def));
|
||||
new_stmt = gimple_build_assign (vect_get_new_vect_var (resvectype,
|
||||
vect_simple_var,
|
||||
"vec_iv_"),
|
||||
VIEW_CONVERT_EXPR,
|
||||
build1 (VIEW_CONVERT_EXPR, resvectype,
|
||||
induc_def));
|
||||
induc_def = make_ssa_name (gimple_assign_lhs (new_stmt), new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, induc_def);
|
||||
si = gsi_after_labels (bb);
|
||||
|
|
@ -4299,15 +4303,14 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
|
|||
{
|
||||
calc_vec_perm_mask_for_shift (mode, elt_offset, sel);
|
||||
tree mask = vect_gen_perm_mask_any (vectype, sel);
|
||||
epilog_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR,
|
||||
vec_dest, new_temp,
|
||||
zero_vec, mask);
|
||||
epilog_stmt = gimple_build_assign (vec_dest, VEC_PERM_EXPR,
|
||||
new_temp, zero_vec, mask);
|
||||
new_name = make_ssa_name (vec_dest, epilog_stmt);
|
||||
gimple_assign_set_lhs (epilog_stmt, new_name);
|
||||
gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
|
||||
|
||||
epilog_stmt = gimple_build_assign_with_ops (code, vec_dest,
|
||||
new_name, new_temp);
|
||||
epilog_stmt = gimple_build_assign (vec_dest, code, new_name,
|
||||
new_temp);
|
||||
new_temp = make_ssa_name (vec_dest, epilog_stmt);
|
||||
gimple_assign_set_lhs (epilog_stmt, new_temp);
|
||||
gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
|
||||
|
|
@ -4386,8 +4389,8 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
|
|||
}
|
||||
else
|
||||
{
|
||||
epilog_stmt = gimple_build_assign_with_ops (code,
|
||||
new_scalar_dest, new_name, new_temp);
|
||||
epilog_stmt = gimple_build_assign (new_scalar_dest, code,
|
||||
new_name, new_temp);
|
||||
new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
|
||||
gimple_assign_set_lhs (epilog_stmt, new_temp);
|
||||
gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
|
||||
|
|
@ -4409,8 +4412,8 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
|
|||
j++)
|
||||
{
|
||||
first_res = scalar_results[j % group_size];
|
||||
new_stmt = gimple_build_assign_with_ops (code,
|
||||
new_scalar_dest, first_res, res);
|
||||
new_stmt = gimple_build_assign (new_scalar_dest, code,
|
||||
first_res, res);
|
||||
new_res = make_ssa_name (new_scalar_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, new_res);
|
||||
gsi_insert_before (&exit_gsi, new_stmt, GSI_SAME_STMT);
|
||||
|
|
|
|||
|
|
@ -439,8 +439,8 @@ vect_recog_dot_prod_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
|
||||
/* Pattern detected. Create a stmt to be used to replace the pattern: */
|
||||
var = vect_recog_temp_ssa_var (type, NULL);
|
||||
pattern_stmt = gimple_build_assign_with_ops (DOT_PROD_EXPR, var,
|
||||
oprnd00, oprnd01, oprnd1);
|
||||
pattern_stmt = gimple_build_assign (var, DOT_PROD_EXPR,
|
||||
oprnd00, oprnd01, oprnd1);
|
||||
|
||||
if (dump_enabled_p ())
|
||||
{
|
||||
|
|
@ -673,8 +673,8 @@ vect_recog_sad_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
|
||||
/* Pattern detected. Create a stmt to be used to replace the pattern: */
|
||||
tree var = vect_recog_temp_ssa_var (sum_type, NULL);
|
||||
gimple pattern_stmt = gimple_build_assign_with_ops
|
||||
(SAD_EXPR, var, sad_oprnd0, sad_oprnd1, plus_oprnd1);
|
||||
gimple pattern_stmt = gimple_build_assign (var, SAD_EXPR, sad_oprnd0,
|
||||
sad_oprnd1, plus_oprnd1);
|
||||
|
||||
if (dump_enabled_p ())
|
||||
{
|
||||
|
|
@ -760,7 +760,7 @@ vect_handle_widen_op_by_const (gimple stmt, enum tree_code code,
|
|||
/* Create a_T = (NEW_TYPE) a_t; */
|
||||
*oprnd = gimple_assign_rhs1 (def_stmt);
|
||||
new_oprnd = make_ssa_name (new_type);
|
||||
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd, *oprnd);
|
||||
new_stmt = gimple_build_assign (new_oprnd, NOP_EXPR, *oprnd);
|
||||
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (def_stmt)) = new_stmt;
|
||||
stmts->safe_push (def_stmt);
|
||||
*oprnd = new_oprnd;
|
||||
|
|
@ -933,8 +933,7 @@ vect_recog_widen_mult_pattern (vec<gimple> *stmts,
|
|||
|
||||
tree old_oprnd = gimple_assign_rhs1 (def_stmt);
|
||||
tree new_oprnd = make_ssa_name (half_type0);
|
||||
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
|
||||
old_oprnd);
|
||||
new_stmt = gimple_build_assign (new_oprnd, NOP_EXPR, old_oprnd);
|
||||
*oprnd = new_oprnd;
|
||||
}
|
||||
|
||||
|
|
@ -999,8 +998,7 @@ vect_recog_widen_mult_pattern (vec<gimple> *stmts,
|
|||
|
||||
/* Pattern supported. Create a stmt to be used to replace the pattern: */
|
||||
var = vect_recog_temp_ssa_var (itype, NULL);
|
||||
pattern_stmt = gimple_build_assign_with_ops (WIDEN_MULT_EXPR, var, oprnd0,
|
||||
oprnd1);
|
||||
pattern_stmt = gimple_build_assign (var, WIDEN_MULT_EXPR, oprnd0, oprnd1);
|
||||
|
||||
stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
|
||||
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
|
||||
|
|
@ -1028,10 +1026,9 @@ vect_recog_widen_mult_pattern (vec<gimple> *stmts,
|
|||
= new_stmt_vec_info (pattern_stmt, loop_vinfo, bb_vinfo);
|
||||
set_vinfo_for_stmt (pattern_stmt, pattern_stmt_info);
|
||||
STMT_VINFO_VECTYPE (pattern_stmt_info) = vecitype;
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (NOP_EXPR,
|
||||
vect_recog_temp_ssa_var (type, NULL),
|
||||
gimple_assign_lhs (pattern_stmt));
|
||||
pattern_stmt = gimple_build_assign (vect_recog_temp_ssa_var (type, NULL),
|
||||
NOP_EXPR,
|
||||
gimple_assign_lhs (pattern_stmt));
|
||||
}
|
||||
|
||||
if (dump_enabled_p ())
|
||||
|
|
@ -1115,7 +1112,7 @@ vect_recog_pow_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
*type_in = TREE_TYPE (base);
|
||||
|
||||
var = vect_recog_temp_ssa_var (TREE_TYPE (base), NULL);
|
||||
stmt = gimple_build_assign_with_ops (MULT_EXPR, var, base, base);
|
||||
stmt = gimple_build_assign (var, MULT_EXPR, base, base);
|
||||
return stmt;
|
||||
}
|
||||
|
||||
|
|
@ -1244,8 +1241,7 @@ vect_recog_widen_sum_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
|
||||
/* Pattern detected. Create a stmt to be used to replace the pattern: */
|
||||
var = vect_recog_temp_ssa_var (type, NULL);
|
||||
pattern_stmt = gimple_build_assign_with_ops (WIDEN_SUM_EXPR, var,
|
||||
oprnd0, oprnd1);
|
||||
pattern_stmt = gimple_build_assign (var, WIDEN_SUM_EXPR, oprnd0, oprnd1);
|
||||
|
||||
if (dump_enabled_p ())
|
||||
{
|
||||
|
|
@ -1440,8 +1436,7 @@ vect_operation_fits_smaller_type (gimple stmt, tree def, tree *new_type,
|
|||
/* Create NEW_OPRND = (INTERM_TYPE) OPRND. */
|
||||
oprnd = gimple_assign_rhs1 (def_stmt);
|
||||
new_oprnd = make_ssa_name (interm_type);
|
||||
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
|
||||
oprnd);
|
||||
new_stmt = gimple_build_assign (new_oprnd, NOP_EXPR, oprnd);
|
||||
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (def_stmt)) = new_stmt;
|
||||
stmts->safe_push (def_stmt);
|
||||
oprnd = new_oprnd;
|
||||
|
|
@ -1459,8 +1454,7 @@ vect_operation_fits_smaller_type (gimple stmt, tree def, tree *new_type,
|
|||
{
|
||||
/* Create a type conversion HALF_TYPE->INTERM_TYPE. */
|
||||
new_oprnd = make_ssa_name (interm_type);
|
||||
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
|
||||
oprnd);
|
||||
new_stmt = gimple_build_assign (new_oprnd, NOP_EXPR, oprnd);
|
||||
oprnd = new_oprnd;
|
||||
*new_def_stmt = new_stmt;
|
||||
}
|
||||
|
|
@ -1548,8 +1542,7 @@ vect_recog_over_widening_pattern (vec<gimple> *stmts,
|
|||
|
||||
var = vect_recog_temp_ssa_var (new_type, NULL);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), var,
|
||||
op0, op1);
|
||||
= gimple_build_assign (var, gimple_assign_rhs_code (stmt), op0, op1);
|
||||
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt)) = pattern_stmt;
|
||||
new_pattern_def_seq (vinfo_for_stmt (stmt), new_def_stmt);
|
||||
|
||||
|
|
@ -1591,8 +1584,7 @@ vect_recog_over_widening_pattern (vec<gimple> *stmts,
|
|||
{
|
||||
/* Create NEW_TYPE->USE_TYPE conversion. */
|
||||
new_oprnd = make_ssa_name (use_type);
|
||||
pattern_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
|
||||
var);
|
||||
pattern_stmt = gimple_build_assign (new_oprnd, NOP_EXPR, var);
|
||||
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use_stmt)) = pattern_stmt;
|
||||
|
||||
*type_in = get_vectype_for_scalar_type (new_type);
|
||||
|
|
@ -1781,7 +1773,7 @@ vect_recog_widen_shift_pattern (vec<gimple> *stmts,
|
|||
/* Pattern supported. Create a stmt to be used to replace the pattern. */
|
||||
var = vect_recog_temp_ssa_var (type, NULL);
|
||||
pattern_stmt =
|
||||
gimple_build_assign_with_ops (WIDEN_LSHIFT_EXPR, var, oprnd0, oprnd1);
|
||||
gimple_build_assign (var, WIDEN_LSHIFT_EXPR, oprnd0, oprnd1);
|
||||
|
||||
if (dump_enabled_p ())
|
||||
dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);
|
||||
|
|
@ -1944,7 +1936,7 @@ vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
|
|||
if (def == NULL_TREE)
|
||||
{
|
||||
def = vect_recog_temp_ssa_var (type, NULL);
|
||||
def_stmt = gimple_build_assign_with_ops (NOP_EXPR, def, oprnd1);
|
||||
def_stmt = gimple_build_assign (def, NOP_EXPR, oprnd1);
|
||||
if (ext_def)
|
||||
{
|
||||
basic_block new_bb
|
||||
|
|
@ -1974,7 +1966,7 @@ vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
|
|||
if (vecstype == NULL_TREE)
|
||||
return NULL;
|
||||
def2 = vect_recog_temp_ssa_var (stype, NULL);
|
||||
def_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, def2, def);
|
||||
def_stmt = gimple_build_assign (def2, NEGATE_EXPR, def);
|
||||
if (ext_def)
|
||||
{
|
||||
basic_block new_bb
|
||||
|
|
@ -1992,9 +1984,8 @@ vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
|
|||
def2 = vect_recog_temp_ssa_var (stype, NULL);
|
||||
tree mask
|
||||
= build_int_cst (stype, GET_MODE_PRECISION (TYPE_MODE (stype)) - 1);
|
||||
def_stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, def2,
|
||||
gimple_assign_lhs (def_stmt),
|
||||
mask);
|
||||
def_stmt = gimple_build_assign (def2, BIT_AND_EXPR,
|
||||
gimple_assign_lhs (def_stmt), mask);
|
||||
if (ext_def)
|
||||
{
|
||||
basic_block new_bb
|
||||
|
|
@ -2011,15 +2002,15 @@ vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
|
|||
}
|
||||
|
||||
var1 = vect_recog_temp_ssa_var (type, NULL);
|
||||
def_stmt = gimple_build_assign_with_ops (rhs_code == LROTATE_EXPR
|
||||
? LSHIFT_EXPR : RSHIFT_EXPR,
|
||||
var1, oprnd0, def);
|
||||
def_stmt = gimple_build_assign (var1, rhs_code == LROTATE_EXPR
|
||||
? LSHIFT_EXPR : RSHIFT_EXPR,
|
||||
oprnd0, def);
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
var2 = vect_recog_temp_ssa_var (type, NULL);
|
||||
def_stmt = gimple_build_assign_with_ops (rhs_code == LROTATE_EXPR
|
||||
? RSHIFT_EXPR : LSHIFT_EXPR,
|
||||
var2, oprnd0, def2);
|
||||
def_stmt = gimple_build_assign (var2, rhs_code == LROTATE_EXPR
|
||||
? RSHIFT_EXPR : LSHIFT_EXPR,
|
||||
oprnd0, def2);
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
/* Pattern detected. */
|
||||
|
|
@ -2029,7 +2020,7 @@ vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
|
|||
|
||||
/* Pattern supported. Create a stmt to be used to replace the pattern. */
|
||||
var = vect_recog_temp_ssa_var (type, NULL);
|
||||
pattern_stmt = gimple_build_assign_with_ops (BIT_IOR_EXPR, var, var1, var2);
|
||||
pattern_stmt = gimple_build_assign (var, BIT_IOR_EXPR, var1, var2);
|
||||
|
||||
if (dump_enabled_p ())
|
||||
dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);
|
||||
|
|
@ -2147,7 +2138,7 @@ vect_recog_vector_vector_shift_pattern (vec<gimple> *stmts,
|
|||
if (def == NULL_TREE)
|
||||
{
|
||||
def = vect_recog_temp_ssa_var (TREE_TYPE (oprnd0), NULL);
|
||||
def_stmt = gimple_build_assign_with_ops (NOP_EXPR, def, oprnd1);
|
||||
def_stmt = gimple_build_assign (def, NOP_EXPR, oprnd1);
|
||||
new_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
}
|
||||
|
||||
|
|
@ -2158,7 +2149,7 @@ vect_recog_vector_vector_shift_pattern (vec<gimple> *stmts,
|
|||
|
||||
/* Pattern supported. Create a stmt to be used to replace the pattern. */
|
||||
var = vect_recog_temp_ssa_var (TREE_TYPE (oprnd0), NULL);
|
||||
pattern_stmt = gimple_build_assign_with_ops (rhs_code, var, oprnd0, def);
|
||||
pattern_stmt = gimple_build_assign (var, rhs_code, oprnd0, def);
|
||||
|
||||
if (dump_enabled_p ())
|
||||
dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);
|
||||
|
|
@ -2281,25 +2272,21 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
tree var = vect_recog_temp_ssa_var (itype, NULL);
|
||||
tree shift;
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (COND_EXPR, var, cond,
|
||||
fold_build2 (MINUS_EXPR, itype,
|
||||
oprnd1,
|
||||
build_int_cst (itype,
|
||||
1)),
|
||||
build_int_cst (itype, 0));
|
||||
= gimple_build_assign (var, COND_EXPR, cond,
|
||||
fold_build2 (MINUS_EXPR, itype, oprnd1,
|
||||
build_int_cst (itype, 1)),
|
||||
build_int_cst (itype, 0));
|
||||
new_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
var = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (PLUS_EXPR, var, oprnd0,
|
||||
gimple_assign_lhs (def_stmt));
|
||||
= gimple_build_assign (var, PLUS_EXPR, oprnd0,
|
||||
gimple_assign_lhs (def_stmt));
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
shift = build_int_cst (itype, tree_log2 (oprnd1));
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR,
|
||||
vect_recog_temp_ssa_var (itype,
|
||||
NULL),
|
||||
var, shift);
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
RSHIFT_EXPR, var, shift);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2308,10 +2295,9 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
if (compare_tree_int (oprnd1, 2) == 0)
|
||||
{
|
||||
signmask = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (COND_EXPR, signmask, cond,
|
||||
build_int_cst (itype, 1),
|
||||
build_int_cst (itype, 0));
|
||||
def_stmt = gimple_build_assign (signmask, COND_EXPR, cond,
|
||||
build_int_cst (itype, 1),
|
||||
build_int_cst (itype, 0));
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
}
|
||||
else
|
||||
|
|
@ -2324,20 +2310,18 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
- tree_log2 (oprnd1));
|
||||
tree var = vect_recog_temp_ssa_var (utype, NULL);
|
||||
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (COND_EXPR, var, cond,
|
||||
build_int_cst (utype, -1),
|
||||
build_int_cst (utype, 0));
|
||||
def_stmt = gimple_build_assign (var, COND_EXPR, cond,
|
||||
build_int_cst (utype, -1),
|
||||
build_int_cst (utype, 0));
|
||||
def_stmt_vinfo
|
||||
= new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
|
||||
set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
|
||||
STMT_VINFO_VECTYPE (def_stmt_vinfo) = vecutype;
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
var = vect_recog_temp_ssa_var (utype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR, var,
|
||||
gimple_assign_lhs (def_stmt),
|
||||
shift);
|
||||
def_stmt = gimple_build_assign (var, RSHIFT_EXPR,
|
||||
gimple_assign_lhs (def_stmt),
|
||||
shift);
|
||||
def_stmt_vinfo
|
||||
= new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
|
||||
set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
|
||||
|
|
@ -2345,32 +2329,24 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
signmask = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (NOP_EXPR, signmask, var);
|
||||
= gimple_build_assign (signmask, NOP_EXPR, var);
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
}
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (PLUS_EXPR,
|
||||
vect_recog_temp_ssa_var (itype,
|
||||
NULL),
|
||||
oprnd0, signmask);
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
PLUS_EXPR, oprnd0, signmask);
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (BIT_AND_EXPR,
|
||||
vect_recog_temp_ssa_var (itype,
|
||||
NULL),
|
||||
gimple_assign_lhs (def_stmt),
|
||||
fold_build2 (MINUS_EXPR, itype,
|
||||
oprnd1,
|
||||
build_int_cst (itype,
|
||||
1)));
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
BIT_AND_EXPR, gimple_assign_lhs (def_stmt),
|
||||
fold_build2 (MINUS_EXPR, itype, oprnd1,
|
||||
build_int_cst (itype, 1)));
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (MINUS_EXPR,
|
||||
vect_recog_temp_ssa_var (itype,
|
||||
NULL),
|
||||
gimple_assign_lhs (def_stmt),
|
||||
signmask);
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
MINUS_EXPR, gimple_assign_lhs (def_stmt),
|
||||
signmask);
|
||||
}
|
||||
|
||||
if (dump_enabled_p ())
|
||||
|
|
@ -2432,25 +2408,23 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
t4 = t1 + t3;
|
||||
q = t4 >> (post_shift - 1); */
|
||||
t1 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (MULT_HIGHPART_EXPR, t1, oprnd0,
|
||||
build_int_cst (itype, ml));
|
||||
def_stmt = gimple_build_assign (t1, MULT_HIGHPART_EXPR, oprnd0,
|
||||
build_int_cst (itype, ml));
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
t2 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (MINUS_EXPR, t2, oprnd0, t1);
|
||||
= gimple_build_assign (t2, MINUS_EXPR, oprnd0, t1);
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
t3 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR, t3, t2,
|
||||
integer_one_node);
|
||||
= gimple_build_assign (t3, RSHIFT_EXPR, t2, integer_one_node);
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
t4 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (PLUS_EXPR, t4, t1, t3);
|
||||
= gimple_build_assign (t4, PLUS_EXPR, t1, t3);
|
||||
|
||||
if (post_shift != 1)
|
||||
{
|
||||
|
|
@ -2458,10 +2432,8 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
|
||||
q = vect_recog_temp_ssa_var (itype, NULL);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR, q, t4,
|
||||
build_int_cst (itype,
|
||||
post_shift
|
||||
- 1));
|
||||
= gimple_build_assign (q, RSHIFT_EXPR, t4,
|
||||
build_int_cst (itype, post_shift - 1));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2481,18 +2453,16 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
{
|
||||
t1 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR, t1, oprnd0,
|
||||
build_int_cst (NULL,
|
||||
pre_shift));
|
||||
= gimple_build_assign (t1, RSHIFT_EXPR, oprnd0,
|
||||
build_int_cst (NULL, pre_shift));
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
}
|
||||
else
|
||||
t1 = oprnd0;
|
||||
|
||||
t2 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (MULT_HIGHPART_EXPR, t2, t1,
|
||||
build_int_cst (itype, ml));
|
||||
def_stmt = gimple_build_assign (t2, MULT_HIGHPART_EXPR, t1,
|
||||
build_int_cst (itype, ml));
|
||||
|
||||
if (post_shift)
|
||||
{
|
||||
|
|
@ -2500,9 +2470,8 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
|
||||
q = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR, q, t2,
|
||||
build_int_cst (itype,
|
||||
post_shift));
|
||||
= gimple_build_assign (q, RSHIFT_EXPR, t2,
|
||||
build_int_cst (itype, post_shift));
|
||||
}
|
||||
else
|
||||
q = t2;
|
||||
|
|
@ -2552,17 +2521,15 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
|
||||
/* t1 = oprnd0 h* ml; */
|
||||
t1 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (MULT_HIGHPART_EXPR, t1, oprnd0,
|
||||
build_int_cst (itype, ml));
|
||||
def_stmt = gimple_build_assign (t1, MULT_HIGHPART_EXPR, oprnd0,
|
||||
build_int_cst (itype, ml));
|
||||
|
||||
if (add)
|
||||
{
|
||||
/* t2 = t1 + oprnd0; */
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
t2 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (PLUS_EXPR, t2, t1, oprnd0);
|
||||
def_stmt = gimple_build_assign (t2, PLUS_EXPR, t1, oprnd0);
|
||||
}
|
||||
else
|
||||
t2 = t1;
|
||||
|
|
@ -2572,9 +2539,8 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
/* t3 = t2 >> post_shift; */
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
t3 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR, t3, t2,
|
||||
build_int_cst (itype, post_shift));
|
||||
def_stmt = gimple_build_assign (t3, RSHIFT_EXPR, t2,
|
||||
build_int_cst (itype, post_shift));
|
||||
}
|
||||
else
|
||||
t3 = t2;
|
||||
|
|
@ -2605,20 +2571,17 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
t4 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
if (msb != 1)
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (INTEGER_CST,
|
||||
t4, build_int_cst (itype, msb));
|
||||
def_stmt = gimple_build_assign (t4, INTEGER_CST,
|
||||
build_int_cst (itype, msb));
|
||||
else
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (RSHIFT_EXPR, t4, oprnd0,
|
||||
build_int_cst (itype, prec - 1));
|
||||
def_stmt = gimple_build_assign (t4, RSHIFT_EXPR, oprnd0,
|
||||
build_int_cst (itype, prec - 1));
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
/* q = t3 - t4; or q = t4 - t3; */
|
||||
q = vect_recog_temp_ssa_var (itype, NULL);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (MINUS_EXPR, q, d < 0 ? t4 : t3,
|
||||
d < 0 ? t3 : t4);
|
||||
pattern_stmt = gimple_build_assign (q, MINUS_EXPR, d < 0 ? t4 : t3,
|
||||
d < 0 ? t3 : t4);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2632,13 +2595,11 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
|
|||
append_pattern_def_seq (stmt_vinfo, pattern_stmt);
|
||||
|
||||
t1 = vect_recog_temp_ssa_var (itype, NULL);
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (MULT_EXPR, t1, q, oprnd1);
|
||||
def_stmt = gimple_build_assign (t1, MULT_EXPR, q, oprnd1);
|
||||
append_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
|
||||
r = vect_recog_temp_ssa_var (itype, NULL);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (MINUS_EXPR, r, oprnd0, t1);
|
||||
pattern_stmt = gimple_build_assign (r, MINUS_EXPR, oprnd0, t1);
|
||||
}
|
||||
|
||||
/* Pattern detected. */
|
||||
|
|
@ -2793,16 +2754,12 @@ vect_recog_mixed_size_cond_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
def_stmt
|
||||
= gimple_build_assign_with_ops (COND_EXPR,
|
||||
vect_recog_temp_ssa_var (itype, NULL),
|
||||
unshare_expr (cond_expr),
|
||||
fold_convert (itype, then_clause),
|
||||
fold_convert (itype, else_clause));
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (NOP_EXPR,
|
||||
vect_recog_temp_ssa_var (type, NULL),
|
||||
gimple_assign_lhs (def_stmt));
|
||||
def_stmt = gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
COND_EXPR, unshare_expr (cond_expr),
|
||||
fold_convert (itype, then_clause),
|
||||
fold_convert (itype, else_clause));
|
||||
pattern_stmt = gimple_build_assign (vect_recog_temp_ssa_var (type, NULL),
|
||||
NOP_EXPR, gimple_assign_lhs (def_stmt));
|
||||
|
||||
new_pattern_def_seq (stmt_vinfo, def_stmt);
|
||||
def_stmt_info = new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
|
||||
|
|
@ -2913,10 +2870,8 @@ adjust_bool_pattern_cast (tree type, tree var)
|
|||
gcc_assert (!STMT_VINFO_PATTERN_DEF_SEQ (stmt_vinfo));
|
||||
pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo);
|
||||
new_pattern_def_seq (stmt_vinfo, pattern_stmt);
|
||||
cast_stmt
|
||||
= gimple_build_assign_with_ops (NOP_EXPR,
|
||||
vect_recog_temp_ssa_var (type, NULL),
|
||||
gimple_assign_lhs (pattern_stmt));
|
||||
cast_stmt = gimple_build_assign (vect_recog_temp_ssa_var (type, NULL),
|
||||
NOP_EXPR, gimple_assign_lhs (pattern_stmt));
|
||||
STMT_VINFO_RELATED_STMT (stmt_vinfo) = cast_stmt;
|
||||
return gimple_assign_lhs (cast_stmt);
|
||||
}
|
||||
|
|
@ -2951,18 +2906,16 @@ adjust_bool_pattern (tree var, tree out_type, tree trueval,
|
|||
irhs1 = adjust_bool_pattern (rhs1, out_type, NULL_TREE, stmts);
|
||||
itype = TREE_TYPE (irhs1);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (SSA_NAME,
|
||||
vect_recog_temp_ssa_var (itype, NULL),
|
||||
irhs1);
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
SSA_NAME, irhs1);
|
||||
break;
|
||||
|
||||
case BIT_NOT_EXPR:
|
||||
irhs1 = adjust_bool_pattern (rhs1, out_type, NULL_TREE, stmts);
|
||||
itype = TREE_TYPE (irhs1);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (BIT_XOR_EXPR,
|
||||
vect_recog_temp_ssa_var (itype, NULL),
|
||||
irhs1, build_int_cst (itype, 1));
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
BIT_XOR_EXPR, irhs1, build_int_cst (itype, 1));
|
||||
break;
|
||||
|
||||
case BIT_AND_EXPR:
|
||||
|
|
@ -3073,9 +3026,8 @@ adjust_bool_pattern (tree var, tree out_type, tree trueval,
|
|||
}
|
||||
itype = TREE_TYPE (irhs1);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (rhs_code,
|
||||
vect_recog_temp_ssa_var (itype, NULL),
|
||||
irhs1, irhs2);
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
rhs_code, irhs1, irhs2);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -3098,10 +3050,9 @@ adjust_bool_pattern (tree var, tree out_type, tree trueval,
|
|||
gcc_checking_assert (useless_type_conversion_p (itype,
|
||||
TREE_TYPE (trueval)));
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (COND_EXPR,
|
||||
vect_recog_temp_ssa_var (itype, NULL),
|
||||
cond_expr, trueval,
|
||||
build_int_cst (itype, 0));
|
||||
= gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
|
||||
COND_EXPR, cond_expr, trueval,
|
||||
build_int_cst (itype, 0));
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -3200,11 +3151,10 @@ vect_recog_bool_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
rhs = adjust_bool_pattern (var, TREE_TYPE (lhs), NULL_TREE, stmts);
|
||||
lhs = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
|
||||
if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (SSA_NAME, lhs, rhs);
|
||||
pattern_stmt = gimple_build_assign (lhs, SSA_NAME, rhs);
|
||||
else
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (NOP_EXPR, lhs, rhs);
|
||||
= gimple_build_assign (lhs, NOP_EXPR, rhs);
|
||||
*type_out = vectype;
|
||||
*type_in = vectype;
|
||||
stmts->safe_push (last_stmt);
|
||||
|
|
@ -3239,11 +3189,11 @@ vect_recog_bool_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
rhs = adjust_bool_pattern (var, type, NULL_TREE, stmts);
|
||||
lhs = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (COND_EXPR, lhs,
|
||||
build2 (NE_EXPR, boolean_type_node,
|
||||
rhs, build_int_cst (type, 0)),
|
||||
gimple_assign_rhs2 (last_stmt),
|
||||
gimple_assign_rhs3 (last_stmt));
|
||||
= gimple_build_assign (lhs, COND_EXPR,
|
||||
build2 (NE_EXPR, boolean_type_node,
|
||||
rhs, build_int_cst (type, 0)),
|
||||
gimple_assign_rhs2 (last_stmt),
|
||||
gimple_assign_rhs3 (last_stmt));
|
||||
*type_out = vectype;
|
||||
*type_in = vectype;
|
||||
stmts->safe_push (last_stmt);
|
||||
|
|
@ -3269,13 +3219,11 @@ vect_recog_bool_pattern (vec<gimple> *stmts, tree *type_in,
|
|||
if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
|
||||
{
|
||||
tree rhs2 = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
|
||||
gimple cast_stmt
|
||||
= gimple_build_assign_with_ops (NOP_EXPR, rhs2, rhs);
|
||||
gimple cast_stmt = gimple_build_assign (rhs2, NOP_EXPR, rhs);
|
||||
new_pattern_def_seq (stmt_vinfo, cast_stmt);
|
||||
rhs = rhs2;
|
||||
}
|
||||
pattern_stmt
|
||||
= gimple_build_assign_with_ops (SSA_NAME, lhs, rhs);
|
||||
pattern_stmt = gimple_build_assign (lhs, SSA_NAME, rhs);
|
||||
pattern_stmt_info = new_stmt_vec_info (pattern_stmt, loop_vinfo,
|
||||
bb_vinfo);
|
||||
set_vinfo_for_stmt (pattern_stmt, pattern_stmt_info);
|
||||
|
|
|
|||
|
|
@ -2671,11 +2671,9 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
|
|||
{
|
||||
tree new_temp = make_ssa_name (TREE_TYPE (vector_type));
|
||||
gimple init_stmt;
|
||||
op = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (vector_type),
|
||||
op);
|
||||
op = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (vector_type), op);
|
||||
init_stmt
|
||||
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR,
|
||||
new_temp, op);
|
||||
= gimple_build_assign (new_temp, VIEW_CONVERT_EXPR, op);
|
||||
gimple_seq_add_stmt (&ctor_seq, init_stmt);
|
||||
op = new_temp;
|
||||
}
|
||||
|
|
@ -2899,8 +2897,8 @@ vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt,
|
|||
second_vec = dr_chain[second_vec_indx];
|
||||
|
||||
/* Generate the permute statement. */
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, perm_dest,
|
||||
first_vec, second_vec, mask);
|
||||
perm_stmt = gimple_build_assign (perm_dest, VEC_PERM_EXPR,
|
||||
first_vec, second_vec, mask);
|
||||
data_ref = make_ssa_name (perm_dest, perm_stmt);
|
||||
gimple_set_lhs (perm_stmt, data_ref);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
|
|
|
|||
|
|
@ -1332,8 +1332,7 @@ vect_init_vector (gimple stmt, tree val, tree type, gimple_stmt_iterator *gsi)
|
|||
else
|
||||
{
|
||||
new_temp = make_ssa_name (TREE_TYPE (type));
|
||||
init_stmt = gimple_build_assign_with_ops (NOP_EXPR,
|
||||
new_temp, val);
|
||||
init_stmt = gimple_build_assign (new_temp, NOP_EXPR, val);
|
||||
vect_init_vector_1 (stmt, init_stmt, gsi);
|
||||
val = new_temp;
|
||||
}
|
||||
|
|
@ -1969,7 +1968,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
var = make_ssa_name (var);
|
||||
op = build1 (VIEW_CONVERT_EXPR, idxtype, op);
|
||||
new_stmt
|
||||
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
|
||||
= gimple_build_assign (var, VIEW_CONVERT_EXPR, op);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
op = var;
|
||||
}
|
||||
|
|
@ -1998,8 +1997,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
var = make_ssa_name (var);
|
||||
mask_op = build1 (VIEW_CONVERT_EXPR, masktype, mask_op);
|
||||
new_stmt
|
||||
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var,
|
||||
mask_op);
|
||||
= gimple_build_assign (var, VIEW_CONVERT_EXPR, mask_op);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
mask_op = var;
|
||||
}
|
||||
|
|
@ -2019,8 +2017,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
var = make_ssa_name (vec_dest);
|
||||
op = build1 (VIEW_CONVERT_EXPR, vectype, op);
|
||||
new_stmt
|
||||
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
|
||||
new_stmt = gimple_build_assign (var, VIEW_CONVERT_EXPR, op);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -3049,8 +3046,8 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
ncopies * nunits);
|
||||
tree tcst = wide_int_to_tree (type, cst);
|
||||
tree phi_arg = copy_ssa_name (op);
|
||||
new_stmt = gimple_build_assign_with_ops (code, phi_arg,
|
||||
phi_res, tcst);
|
||||
new_stmt
|
||||
= gimple_build_assign (phi_arg, code, phi_res, tcst);
|
||||
gimple_stmt_iterator si = gsi_after_labels (loop->header);
|
||||
gsi_insert_after (&si, new_stmt, GSI_NEW_STMT);
|
||||
set_vinfo_for_stmt (new_stmt,
|
||||
|
|
@ -3073,9 +3070,8 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
j * nunits);
|
||||
tree tcst = wide_int_to_tree (type, cst);
|
||||
new_temp = make_ssa_name (TREE_TYPE (op));
|
||||
new_stmt
|
||||
= gimple_build_assign_with_ops (code, new_temp,
|
||||
arginfo[i].op, tcst);
|
||||
new_stmt = gimple_build_assign (new_temp, code,
|
||||
arginfo[i].op, tcst);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
vargs.safe_push (new_temp);
|
||||
}
|
||||
|
|
@ -3275,8 +3271,7 @@ vect_gen_widened_results_half (enum tree_code code,
|
|||
gcc_assert (op_type == TREE_CODE_LENGTH (code));
|
||||
if (op_type != binary_op)
|
||||
vec_oprnd1 = NULL;
|
||||
new_stmt = gimple_build_assign_with_ops (code, vec_dest, vec_oprnd0,
|
||||
vec_oprnd1);
|
||||
new_stmt = gimple_build_assign (vec_dest, code, vec_oprnd0, vec_oprnd1);
|
||||
new_temp = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, new_temp);
|
||||
}
|
||||
|
|
@ -3346,7 +3341,7 @@ vect_create_vectorized_demotion_stmts (vec<tree> *vec_oprnds,
|
|||
/* Create demotion operation. */
|
||||
vop0 = (*vec_oprnds)[i];
|
||||
vop1 = (*vec_oprnds)[i + 1];
|
||||
new_stmt = gimple_build_assign_with_ops (code, vec_dest, vop0, vop1);
|
||||
new_stmt = gimple_build_assign (vec_dest, code, vop0, vop1);
|
||||
new_tmp = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, new_tmp);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
|
|
@ -3826,8 +3821,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
else
|
||||
{
|
||||
gcc_assert (TREE_CODE_LENGTH (code1) == unary_op);
|
||||
new_stmt = gimple_build_assign_with_ops (code1, vec_dest,
|
||||
vop0);
|
||||
new_stmt = gimple_build_assign (vec_dest, code1, vop0);
|
||||
new_temp = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, new_temp);
|
||||
}
|
||||
|
|
@ -3938,8 +3932,8 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
{
|
||||
gcc_assert (TREE_CODE_LENGTH (codecvt1) == unary_op);
|
||||
new_temp = make_ssa_name (vec_dest);
|
||||
new_stmt = gimple_build_assign_with_ops (codecvt1,
|
||||
new_temp, vop0);
|
||||
new_stmt = gimple_build_assign (new_temp, codecvt1,
|
||||
vop0);
|
||||
}
|
||||
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
|
|
@ -3995,8 +3989,8 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
{
|
||||
gcc_assert (TREE_CODE_LENGTH (codecvt1) == unary_op);
|
||||
new_temp = make_ssa_name (vec_dest);
|
||||
new_stmt = gimple_build_assign_with_ops (codecvt1, new_temp,
|
||||
vop0);
|
||||
new_stmt = gimple_build_assign (new_temp, codecvt1,
|
||||
vop0);
|
||||
}
|
||||
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
|
|
@ -4557,7 +4551,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
FOR_EACH_VEC_ELT (vec_oprnds0, i, vop0)
|
||||
{
|
||||
vop1 = vec_oprnds1[i];
|
||||
new_stmt = gimple_build_assign_with_ops (code, vec_dest, vop0, vop1);
|
||||
new_stmt = gimple_build_assign (vec_dest, code, vop0, vop1);
|
||||
new_temp = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, new_temp);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
|
|
@ -4910,8 +4904,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
|
|||
? vec_oprnds1[i] : NULL_TREE);
|
||||
vop2 = ((op_type == ternary_op)
|
||||
? vec_oprnds2[i] : NULL_TREE);
|
||||
new_stmt = gimple_build_assign_with_ops (code, vec_dest,
|
||||
vop0, vop1, vop2);
|
||||
new_stmt = gimple_build_assign (vec_dest, code, vop0, vop1, vop2);
|
||||
new_temp = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, new_temp);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
|
|
@ -5467,9 +5460,8 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
|
||||
/* Generate the permute statement. */
|
||||
gimple perm_stmt
|
||||
= gimple_build_assign_with_ops (VEC_PERM_EXPR, new_temp,
|
||||
vec_oprnd, vec_oprnd,
|
||||
perm_mask);
|
||||
= gimple_build_assign (new_temp, VEC_PERM_EXPR, vec_oprnd,
|
||||
vec_oprnd, perm_mask);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
|
||||
perm_stmt = SSA_NAME_DEF_STMT (new_temp);
|
||||
|
|
@ -5558,8 +5550,7 @@ permute_vec_elements (tree x, tree y, tree mask_vec, gimple stmt,
|
|||
data_ref = make_ssa_name (perm_dest);
|
||||
|
||||
/* Generate the permute statement. */
|
||||
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
|
||||
x, y, mask_vec);
|
||||
perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, x, y, mask_vec);
|
||||
vect_finish_stmt_generation (stmt, perm_stmt, gsi);
|
||||
|
||||
return data_ref;
|
||||
|
|
@ -5994,7 +5985,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
var = make_ssa_name (var);
|
||||
op = build1 (VIEW_CONVERT_EXPR, idxtype, op);
|
||||
new_stmt
|
||||
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
|
||||
= gimple_build_assign (var, VIEW_CONVERT_EXPR, op);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
op = var;
|
||||
}
|
||||
|
|
@ -6013,7 +6004,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
var = make_ssa_name (vec_dest);
|
||||
op = build1 (VIEW_CONVERT_EXPR, vectype, op);
|
||||
new_stmt
|
||||
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
|
||||
= gimple_build_assign (var, VIEW_CONVERT_EXPR, op);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -6117,8 +6108,8 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
GSI_SAME_STMT);
|
||||
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, newref);
|
||||
newoff = copy_ssa_name (running_off);
|
||||
incr = gimple_build_assign_with_ops (POINTER_PLUS_EXPR, newoff,
|
||||
running_off, stride_step);
|
||||
incr = gimple_build_assign (newoff, POINTER_PLUS_EXPR,
|
||||
running_off, stride_step);
|
||||
vect_finish_stmt_generation (stmt, incr, gsi);
|
||||
|
||||
running_off = newoff;
|
||||
|
|
@ -6456,8 +6447,8 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
dataref_ptr, NULL);
|
||||
|
||||
ptr = copy_ssa_name (dataref_ptr);
|
||||
new_stmt = gimple_build_assign_with_ops
|
||||
(BIT_AND_EXPR, ptr, dataref_ptr,
|
||||
new_stmt = gimple_build_assign
|
||||
(ptr, BIT_AND_EXPR, dataref_ptr,
|
||||
build_int_cst
|
||||
(TREE_TYPE (dataref_ptr),
|
||||
-(HOST_WIDE_INT)TYPE_ALIGN_UNIT (vectype)));
|
||||
|
|
@ -6479,8 +6470,8 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
bump = size_binop (MULT_EXPR, vs_minus_1,
|
||||
TYPE_SIZE_UNIT (elem_type));
|
||||
ptr = bump_vector_ptr (dataref_ptr, NULL, gsi, stmt, bump);
|
||||
new_stmt = gimple_build_assign_with_ops
|
||||
(BIT_AND_EXPR, NULL_TREE, ptr,
|
||||
new_stmt = gimple_build_assign
|
||||
(NULL_TREE, BIT_AND_EXPR, ptr,
|
||||
build_int_cst
|
||||
(TREE_TYPE (ptr),
|
||||
-(HOST_WIDE_INT)TYPE_ALIGN_UNIT (vectype)));
|
||||
|
|
@ -6495,8 +6486,8 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
}
|
||||
case dr_explicit_realign_optimized:
|
||||
new_temp = copy_ssa_name (dataref_ptr);
|
||||
new_stmt = gimple_build_assign_with_ops
|
||||
(BIT_AND_EXPR, new_temp, dataref_ptr,
|
||||
new_stmt = gimple_build_assign
|
||||
(new_temp, BIT_AND_EXPR, dataref_ptr,
|
||||
build_int_cst
|
||||
(TREE_TYPE (dataref_ptr),
|
||||
-(HOST_WIDE_INT)TYPE_ALIGN_UNIT (vectype)));
|
||||
|
|
@ -6525,10 +6516,8 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
|
|||
if (!realignment_token)
|
||||
realignment_token = dataref_ptr;
|
||||
vec_dest = vect_create_destination_var (scalar_dest, vectype);
|
||||
new_stmt
|
||||
= gimple_build_assign_with_ops (REALIGN_LOAD_EXPR,
|
||||
vec_dest, msq, lsq,
|
||||
realignment_token);
|
||||
new_stmt = gimple_build_assign (vec_dest, REALIGN_LOAD_EXPR,
|
||||
msq, lsq, realignment_token);
|
||||
new_temp = make_ssa_name (vec_dest, new_stmt);
|
||||
gimple_assign_set_lhs (new_stmt, new_temp);
|
||||
vect_finish_stmt_generation (stmt, new_stmt, gsi);
|
||||
|
|
|
|||
|
|
@ -8968,7 +8968,7 @@ simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
|
|||
{
|
||||
tree tem = make_ssa_name (TREE_TYPE (op0));
|
||||
gassign *newop
|
||||
= gimple_build_assign_with_ops (BIT_XOR_EXPR, tem, op0, op1);
|
||||
= gimple_build_assign (tem, BIT_XOR_EXPR, op0, op1);
|
||||
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
|
||||
gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem);
|
||||
}
|
||||
|
|
@ -9735,7 +9735,7 @@ simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
|
|||
float conversion. */
|
||||
tem = make_ssa_name (build_nonstandard_integer_type
|
||||
(GET_MODE_PRECISION (mode), 0));
|
||||
conv = gimple_build_assign_with_ops (NOP_EXPR, tem, rhs1);
|
||||
conv = gimple_build_assign (tem, NOP_EXPR, rhs1);
|
||||
gsi_insert_before (gsi, conv, GSI_SAME_STMT);
|
||||
gimple_assign_set_rhs1 (stmt, tem);
|
||||
update_stmt (stmt);
|
||||
|
|
@ -9794,8 +9794,7 @@ simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
|
|||
gimple g;
|
||||
location_t loc = gimple_location (stmt);
|
||||
if (is_ubsan)
|
||||
g = gimple_build_assign_with_ops (subcode, gimple_call_lhs (stmt),
|
||||
op0, op1);
|
||||
g = gimple_build_assign (gimple_call_lhs (stmt), subcode, op0, op1);
|
||||
else
|
||||
{
|
||||
int prec = TYPE_PRECISION (type);
|
||||
|
|
@ -9808,8 +9807,7 @@ simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
|
|||
op0 = fold_convert (utype, op0);
|
||||
else if (!useless_type_conversion_p (utype, TREE_TYPE (op0)))
|
||||
{
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (utype), op0);
|
||||
g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op0);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
op0 = gimple_assign_lhs (g);
|
||||
|
|
@ -9818,26 +9816,24 @@ simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
|
|||
op1 = fold_convert (utype, op1);
|
||||
else if (!useless_type_conversion_p (utype, TREE_TYPE (op1)))
|
||||
{
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (utype), op1);
|
||||
g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op1);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
op1 = gimple_assign_lhs (g);
|
||||
}
|
||||
g = gimple_build_assign_with_ops (subcode, make_ssa_name (utype),
|
||||
op0, op1);
|
||||
g = gimple_build_assign (make_ssa_name (utype), subcode, op0, op1);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
if (utype != type)
|
||||
{
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, make_ssa_name (type),
|
||||
gimple_assign_lhs (g));
|
||||
g = gimple_build_assign (make_ssa_name (type), NOP_EXPR,
|
||||
gimple_assign_lhs (g));
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
}
|
||||
g = gimple_build_assign_with_ops (COMPLEX_EXPR, gimple_call_lhs (stmt),
|
||||
gimple_assign_lhs (g),
|
||||
build_int_cst (type, ovf));
|
||||
g = gimple_build_assign (gimple_call_lhs (stmt), COMPLEX_EXPR,
|
||||
gimple_assign_lhs (g),
|
||||
build_int_cst (type, ovf));
|
||||
}
|
||||
gimple_set_location (g, loc);
|
||||
gsi_replace (gsi, g, false);
|
||||
|
|
|
|||
25
gcc/tsan.c
25
gcc/tsan.c
|
|
@ -500,7 +500,7 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
|
|||
TREE_TYPE (args[1])))
|
||||
{
|
||||
tree var = make_ssa_name (TREE_TYPE (lhs));
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, var, args[1]);
|
||||
g = gimple_build_assign (var, NOP_EXPR, args[1]);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
args[1] = var;
|
||||
}
|
||||
|
|
@ -509,17 +509,14 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
|
|||
if (tsan_atomic_table[i].code == BIT_NOT_EXPR)
|
||||
{
|
||||
tree var = make_ssa_name (TREE_TYPE (lhs));
|
||||
g = gimple_build_assign_with_ops (BIT_AND_EXPR, var,
|
||||
gimple_call_lhs (stmt),
|
||||
args[1]);
|
||||
g = gimple_build_assign (var, BIT_AND_EXPR,
|
||||
gimple_call_lhs (stmt), args[1]);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
g = gimple_build_assign_with_ops (BIT_NOT_EXPR, lhs, var);
|
||||
g = gimple_build_assign (lhs, BIT_NOT_EXPR, var);
|
||||
}
|
||||
else
|
||||
g = gimple_build_assign_with_ops (tsan_atomic_table[i].code,
|
||||
lhs,
|
||||
gimple_call_lhs (stmt),
|
||||
args[1]);
|
||||
g = gimple_build_assign (lhs, tsan_atomic_table[i].code,
|
||||
gimple_call_lhs (stmt), args[1]);
|
||||
update_stmt (stmt);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
}
|
||||
|
|
@ -553,9 +550,8 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
|
|||
if (!useless_type_conversion_p (TREE_TYPE (t),
|
||||
TREE_TYPE (args[1])))
|
||||
{
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR,
|
||||
make_ssa_name (TREE_TYPE (t)),
|
||||
args[1]);
|
||||
g = gimple_build_assign (make_ssa_name (TREE_TYPE (t)),
|
||||
NOP_EXPR, args[1]);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
args[1] = gimple_assign_lhs (g);
|
||||
}
|
||||
|
|
@ -577,9 +573,8 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
|
|||
t = make_ssa_name (TREE_TYPE (TREE_TYPE (decl)), stmt);
|
||||
cond = build2 (NE_EXPR, boolean_type_node, t,
|
||||
build_int_cst (TREE_TYPE (t), 0));
|
||||
g = gimple_build_assign_with_ops (COND_EXPR, lhs, cond,
|
||||
args[1],
|
||||
gimple_assign_lhs (g));
|
||||
g = gimple_build_assign (lhs, COND_EXPR, cond, args[1],
|
||||
gimple_assign_lhs (g));
|
||||
gimple_call_set_lhs (stmt, t);
|
||||
update_stmt (stmt);
|
||||
gsi_insert_after (gsi, g, GSI_NEW_STMT);
|
||||
|
|
|
|||
14
gcc/ubsan.c
14
gcc/ubsan.c
|
|
@ -748,7 +748,7 @@ ubsan_expand_null_ifn (gimple_stmt_iterator *gsip)
|
|||
if (compare_tree_int (align, ptralign) == 1)
|
||||
{
|
||||
check_align = make_ssa_name (pointer_sized_int_node);
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, check_align, ptr);
|
||||
g = gimple_build_assign (check_align, NOP_EXPR, ptr);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (&gsi, g, GSI_SAME_STMT);
|
||||
}
|
||||
|
|
@ -870,9 +870,8 @@ ubsan_expand_null_ifn (gimple_stmt_iterator *gsip)
|
|||
|
||||
tree mask = build_int_cst (pointer_sized_int_node,
|
||||
tree_to_uhwi (align) - 1);
|
||||
g = gimple_build_assign_with_ops (BIT_AND_EXPR,
|
||||
make_ssa_name (pointer_sized_int_node),
|
||||
check_align, mask);
|
||||
g = gimple_build_assign (make_ssa_name (pointer_sized_int_node),
|
||||
BIT_AND_EXPR, check_align, mask);
|
||||
gimple_set_location (g, loc);
|
||||
if (check_null)
|
||||
gsi_insert_after (&gsi2, g, GSI_NEW_STMT);
|
||||
|
|
@ -944,7 +943,7 @@ ubsan_expand_objsize_ifn (gimple_stmt_iterator *gsi)
|
|||
? BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH
|
||||
: BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_ABORT;
|
||||
tree p = make_ssa_name (pointer_sized_int_node);
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, p, ptr);
|
||||
g = gimple_build_assign (p, NOP_EXPR, ptr);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
g = gimple_build_call (builtin_decl_explicit (bcode), 2, data, p);
|
||||
|
|
@ -1185,7 +1184,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi)
|
|||
if (can_throw)
|
||||
{
|
||||
gimple_assign_set_lhs (stmt, urhs);
|
||||
g = gimple_build_assign_with_ops (NOP_EXPR, lhs, urhs);
|
||||
g = gimple_build_assign (lhs, NOP_EXPR, urhs);
|
||||
gimple_set_location (g, loc);
|
||||
edge e = find_fallthru_edge (gimple_bb (stmt)->succs);
|
||||
gsi_insert_on_edge_immediate (e, g);
|
||||
|
|
@ -1204,8 +1203,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi)
|
|||
maxv = fold_convert (utype, maxv);
|
||||
if (!integer_zerop (minv))
|
||||
{
|
||||
g = gimple_build_assign_with_ops (MINUS_EXPR, make_ssa_name (utype),
|
||||
urhs, minv);
|
||||
g = gimple_build_assign (make_ssa_name (utype), MINUS_EXPR, urhs, minv);
|
||||
gimple_set_location (g, loc);
|
||||
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -775,13 +775,11 @@ gimple_divmod_fixed_value (gassign *stmt, tree value, int prob,
|
|||
bb1end = stmt3;
|
||||
|
||||
tmp2 = create_tmp_reg (optype, "PROF");
|
||||
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
|
||||
op1, tmp0);
|
||||
stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, tmp0);
|
||||
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
||||
bb2end = stmt1;
|
||||
|
||||
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
|
||||
op1, op2);
|
||||
stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, op2);
|
||||
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
||||
bb3end = stmt1;
|
||||
|
||||
|
|
@ -930,9 +928,9 @@ gimple_mod_pow2 (gassign *stmt, int prob, gcov_type count, gcov_type all)
|
|||
result = create_tmp_reg (optype, "PROF");
|
||||
tmp2 = make_temp_ssa_name (optype, NULL, "PROF");
|
||||
tmp3 = make_temp_ssa_name (optype, NULL, "PROF");
|
||||
stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, tmp2, op2,
|
||||
build_int_cst (optype, -1));
|
||||
stmt3 = gimple_build_assign_with_ops (BIT_AND_EXPR, tmp3, tmp2, op2);
|
||||
stmt2 = gimple_build_assign (tmp2, PLUS_EXPR, op2,
|
||||
build_int_cst (optype, -1));
|
||||
stmt3 = gimple_build_assign (tmp3, BIT_AND_EXPR, tmp2, op2);
|
||||
stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0),
|
||||
NULL_TREE, NULL_TREE);
|
||||
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
||||
|
|
@ -941,12 +939,12 @@ gimple_mod_pow2 (gassign *stmt, int prob, gcov_type count, gcov_type all)
|
|||
bb1end = stmt4;
|
||||
|
||||
/* tmp2 == op2-1 inherited from previous block. */
|
||||
stmt1 = gimple_build_assign_with_ops (BIT_AND_EXPR, result, op1, tmp2);
|
||||
stmt1 = gimple_build_assign (result, BIT_AND_EXPR, op1, tmp2);
|
||||
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
||||
bb2end = stmt1;
|
||||
|
||||
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
|
||||
op1, op2);
|
||||
stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt),
|
||||
op1, op2);
|
||||
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
||||
bb3end = stmt1;
|
||||
|
||||
|
|
@ -1094,7 +1092,7 @@ gimple_mod_subtract (gassign *stmt, int prob1, int prob2, int ncounts,
|
|||
|
||||
if (ncounts) /* Assumed to be 0 or 1 */
|
||||
{
|
||||
stmt1 = gimple_build_assign_with_ops (MINUS_EXPR, result, result, tmp1);
|
||||
stmt1 = gimple_build_assign (result, MINUS_EXPR, result, tmp1);
|
||||
stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
|
||||
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
||||
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
||||
|
|
@ -1102,8 +1100,8 @@ gimple_mod_subtract (gassign *stmt, int prob1, int prob2, int ncounts,
|
|||
}
|
||||
|
||||
/* Fallback case. */
|
||||
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
|
||||
result, tmp1);
|
||||
stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt),
|
||||
result, tmp1);
|
||||
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
||||
bb3end = stmt1;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue