From: Jakub Jelinek Date: Mon, 1 Dec 2014 13:58:10 +0000 (+0100) Subject: gimple.h (gimple_build_assign_stat): Remove prototype. X-Git-Tag: upstream/12.2.0~58423 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=0d0e4a03e98cf8c3dbb1dc1a3ba15d2d9a6a5912;p=platform%2Fupstream%2Fgcc.git 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 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d6d92b6..ff430be 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,86 @@ +2014-12-01 Jakub Jelinek + + * 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 PR middle-end/64111 diff --git a/gcc/asan.c b/gcc/asan.c index a976455..a8987b7 100644 --- a/gcc/asan.c +++ b/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); diff --git a/gcc/gimple-builder.c b/gcc/gimple-builder.c index 5217673..8a0a9c2d 100644 --- a/gcc/gimple-builder.c +++ b/gcc/gimple-builder.c @@ -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 * diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 1219176..4374c1d 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -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); } diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c index 2e31f10..d708132 100644 --- a/gcc/gimple-match-head.c +++ b/gcc/gimple-match-head.c @@ -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; } diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c index e719129..547327c 100644 --- a/gcc/gimple-ssa-strength-reduction.c +++ b/gcc/gimple-ssa-strength-reduction.c @@ -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; diff --git a/gcc/gimple.c b/gcc/gimple.c index 69cac22..c25fffa 100644 --- a/gcc/gimple.c +++ b/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; } +/* 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); } diff --git a/gcc/gimple.h b/gcc/gimple.h index 9380211..04403f1 100644 --- a/gcc/gimple.h +++ b/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 ); 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); diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c index 98afe4c..276de3c 100644 --- a/gcc/ipa-split.c +++ b/gcc/ipa-split.c @@ -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; } diff --git a/gcc/omp-low.c b/gcc/omp-low.c index 41400c7..a5cf925 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -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); diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index 49c2920..a81bf87 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -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); diff --git a/gcc/tree-chkp.c b/gcc/tree-chkp.c index 6665ce2..56bc303 100644 --- a/gcc/tree-chkp.c +++ b/gcc/tree-chkp.c @@ -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 diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c index c88a411..f2d63d7 100644 --- a/gcc/tree-loop-distribution.c +++ b/gcc/tree-loop-distribution.c @@ -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; } diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c index e5f3ea7..3482bf0 100644 --- a/gcc/tree-predcom.c +++ b/gcc/tree-predcom.c @@ -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); diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c index 73844e8..dd38af7 100644 --- a/gcc/tree-profile.c +++ b/gcc/tree-profile.c @@ -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); diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c index 9c6f25b..6c14e13 100644 --- a/gcc/tree-ssa-forwprop.c +++ b/gcc/tree-ssa-forwprop.c @@ -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; diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index 0e806f4..2c676e3 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -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); diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c index eb98b42..124b67a 100644 --- a/gcc/tree-ssa-loop-manip.c +++ b/gcc/tree-ssa-loop-manip.c @@ -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 diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index 14b09b4..4b95ee4 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -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++; } diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c index dc3bbdc..5a3519d 100644 --- a/gcc/tree-ssa-phiopt.c +++ b/gcc/tree-ssa-phiopt.c @@ -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); diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index 4a2bda6..68a67b6 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -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 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 *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 *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); } diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c index 0b7673b..c2f3493 100644 --- a/gcc/tree-ssa-strlen.c +++ b/gcc/tree-ssa-strlen.c @@ -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; diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c index 3a04b25..8f5c773 100644 --- a/gcc/tree-tailcall.c +++ b/gcc/tree-tailcall.c @@ -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), diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index 4ed9bb1..f7b192f 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -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 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 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 dr_chain, high = VEC_PERM_EXPR */ 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 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 dr_chain, low = VEC_PERM_EXPR */ 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 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 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 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 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 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 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 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; diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c index 9757a61..a8a8ecd 100644 --- a/gcc/tree-vect-generic.c +++ b/gcc/tree-vect-generic.c @@ -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); } diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c index 57d2b34..a318a7e 100644 --- a/gcc/tree-vect-loop-manip.c +++ b/gcc/tree-vect-loop-manip.c @@ -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. diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 94feea0..d1d4596 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -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 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 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 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); diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c index d97008f..d5effab 100644 --- a/gcc/tree-vect-patterns.c +++ b/gcc/tree-vect-patterns.c @@ -439,8 +439,8 @@ vect_recog_dot_prod_pattern (vec *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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); diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index 4c1b742..f43b724 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -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); diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index 09c887c..6903f0a 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -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 *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); diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index f3dbc50..bd238d5 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -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); diff --git a/gcc/tsan.c b/gcc/tsan.c index 18b4d92..d221e45 100644 --- a/gcc/tsan.c +++ b/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); diff --git a/gcc/ubsan.c b/gcc/ubsan.c index ea5ccb4..6d3caee 100644 --- a/gcc/ubsan.c +++ b/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); } diff --git a/gcc/value-prof.c b/gcc/value-prof.c index 7aac67d..82a144f 100644 --- a/gcc/value-prof.c +++ b/gcc/value-prof.c @@ -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;