* 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
+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
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);
{
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);
{
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);
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);
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);
&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);
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);
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 *
{
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 *
{
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 *
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;
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);
}
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);
}
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);
}
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;
}
}
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
{
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 ();
}
/* 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);
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);
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;
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;
return p;
}
+/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
+ OP1, OP2 and OP3. */
+
+gassign *
+gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
+ tree op2, tree op3 MEM_STAT_DECL)
+{
+ 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_with_ops (enum tree_code subcode, tree lhs, tree op1,
- tree op2 MEM_STAT_DECL)
+gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
+ tree op2 MEM_STAT_DECL)
{
- return gimple_build_assign_with_ops (subcode, lhs, op1, op2, NULL_TREE
- PASS_MEM_STAT);
+ 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_with_ops (enum tree_code subcode, tree lhs, tree op1
- MEM_STAT_DECL)
+gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 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, NULL_TREE, NULL_TREE
+ PASS_MEM_STAT);
}
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);
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;
}
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;
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])
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);
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);
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)
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;
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)
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)
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);
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). */
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
? 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);
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);
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);
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);
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))
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);
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
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;
}
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);
/* 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);
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);
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;
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
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
{
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);
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
/* 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)
{
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);
/* 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);
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;
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;
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);
}
{
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);
}
{
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);
}
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++;
}
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;
/* 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);
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);
/* 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);
}
}
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);
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;
}
/* 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);
/* 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)
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);
{
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);
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);
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))
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))
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));
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;
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);
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;
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);
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);
}
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;
}
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;
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),
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. */
{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;
{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;
}
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;
{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;
}
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);
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):
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;
}
/* 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;
}
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;
}
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;
}
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;
}
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;
}
(*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;
<< 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);
}
}
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);
}
\f
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. */
/* 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;
}
/* 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.
{
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));
/* 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),
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);
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));
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);
{
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);
}
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);
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);
/* 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 ())
{
/* 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 ())
{
/* 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;
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;
}
/* 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);
= 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 ())
*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;
}
/* 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 ())
{
/* 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;
{
/* 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;
}
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);
{
/* 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);
/* 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);
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
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
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
}
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. */
/* 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);
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);
}
/* 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);
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
{
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
- 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);
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 ())
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)
{
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
{
{
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)
{
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;
/* 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;
/* 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;
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);
}
}
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. */
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);
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);
}
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:
}
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:
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;
}
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);
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);
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);
{
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;
}
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);
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;
}
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;
}
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;
}
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
{
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,
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);
}
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);
}
/* 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);
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);
}
{
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);
{
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);
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);
? 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);
/* 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);
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;
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;
}
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
{
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;
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)));
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)));
}
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)));
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);
{
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);
}
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);
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);
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);
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);
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;
}
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);
}
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);
}
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);
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);
}
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);
? 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);
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);
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);
}
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;
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);
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;
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);
}
/* 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;
projects / gcc.git / commitdiff