On Mon, 1 Dec 2014, Jakub Jelinek wrote:
> On Fri, Nov 28, 2014 at 08:02:23PM +0100, Jakub Jelinek wrote:
> > As possible follow-up, I wonder if gimple_build_assign_with_ops
> > isn't too long and too verbose either, couldn't we just
> > use overloads of gimple_build_assign instead?
> > Either with the argument order of gimple_build_assign_with_ops,
> > i.e. tree_code, lhs, operands... , or perhaps swap the lhs and
> > tree_code, so lhs, tree_code, operands... In either case, I'd
> > find it to be pretty much unambiguous with the current two operand
> > gimple_build_assign which takes lhs, treeop, the presence of
> > enum tree_code would make it obvious that you are supplying ops for it
> > rather than building it from what is extracted from the tree.
>
> The following patch implements that. Bootstrapped/regtested on x86_64-linux
> and i686-linux, ok for trunk?
Ok.
Thanks,
Richard.
> 2014-12-01 Jakub Jelinek <ja...@redhat.com>
>
> * gimple.h (gimple_build_assign_stat): Remove prototype.
> (gimple_build_assign): Remove define. Add overload prototypes
> with tree lhs and either a tree rhs, or enum tree_code and
> 1, 2 or 3 tree operands.
> * gimple.c (gimple_build_assign_stat): Renamed to...
> (gimple_build_assign): ... this. Add overloads with
> enum tree_code and 1, 2 or 3 tree operands.
> (gimple_build_assign_with_ops): Remove 1 and 2 operand overloads.
> Rename the 3 operand overload to ...
> (gimple_build_assign_1): ... this. Make it static inline.
> * tree-ssa-strlen.c (get_string_length): Use gimple_build_assign
> instead of gimple_build_assign_with_ops, swap the order of first
> two arguments and adjust formatting where necessary.
> * tree-vect-slp.c (vect_get_constant_vectors,
> vect_create_mask_and_perm): Likewise.
> * tree-ssa-forwprop.c (simplify_rotate): Likewise.
> * asan.c (build_shadow_mem_access, maybe_create_ssa_name,
> maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
> * tsan.c (instrument_builtin_call): Likewise.
> * tree-chkp.c (chkp_compute_bounds_for_assignment,
> chkp_generate_extern_var_bounds): Likewise.
> * tree-loop-distribution.c (generate_memset_builtin): Likewise.
> * tree-ssa-loop-im.c (rewrite_reciprocal): Likewise.
> * gimple-builder.c (build_assign, build_type_cast): Likewise.
> * tree-vect-loop-manip.c (vect_create_cond_for_align_checks): Likewise.
> * value-prof.c (gimple_divmod_fixed_value, gimple_mod_pow2,
> gimple_mod_subtract): Likewise.
> * gimple-match-head.c (maybe_push_res_to_seq): Likewise.
> * tree-vect-patterns.c (vect_recog_dot_prod_pattern,
> vect_recog_sad_pattern, vect_handle_widen_op_by_const,
> vect_recog_widen_mult_pattern, vect_recog_pow_pattern,
> vect_recog_widen_sum_pattern, vect_operation_fits_smaller_type,
> vect_recog_over_widening_pattern, vect_recog_widen_shift_pattern,
> vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern,
> vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern,
> adjust_bool_pattern_cast, adjust_bool_pattern,
> vect_recog_bool_pattern): Likewise.
> * gimple-ssa-strength-reduction.c (create_add_on_incoming_edge,
> insert_initializers, introduce_cast_before_cand,
> replace_one_candidate): Likewise.
> * tree-ssa-math-opts.c (insert_reciprocals, powi_as_mults_1,
> powi_as_mults, build_and_insert_binop, build_and_insert_cast,
> pass_cse_sincos::execute, bswap_replace, convert_mult_to_fma):
> Likewise.
> * tree-tailcall.c (adjust_return_value_with_ops,
> update_accumulator_with_ops): Likewise.
> * tree-predcom.c (reassociate_to_the_same_stmt): Likewise.
> * tree-ssa-reassoc.c (build_and_add_sum,
> optimize_range_tests_to_bit_test, update_ops,
> maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr,
> negate_value, repropagate_negates, attempt_builtin_powi,
> reassociate_bb): Likewise.
> * tree-vect-loop.c (vect_is_simple_reduction_1,
> get_initial_def_for_induction, vect_create_epilog_for_reduction):
> Likewise.
> * ipa-split.c (split_function): Likewise.
> * tree-ssa-phiopt.c (conditional_replacement, minmax_replacement,
> abs_replacement, neg_replacement): Likewise.
> * tree-profile.c (gimple_gen_edge_profiler): Likewise.
> * tree-vrp.c (simplify_truth_ops_using_ranges,
> simplify_float_conversion_using_ranges,
> simplify_internal_call_using_ranges): Likewise.
> * gimple-fold.c (rewrite_to_defined_overflow, gimple_build): Likewise.
> * tree-vect-generic.c (expand_vector_divmod,
> optimize_vector_constructor): Likewise.
> * ubsan.c (ubsan_expand_null_ifn, ubsan_expand_objsize_ifn,
> instrument_bool_enum_load): Likewise.
> * tree-ssa-loop-manip.c (create_iv): Likewise.
> * omp-low.c (lower_rec_input_clauses, expand_omp_for_generic,
> expand_omp_for_static_nochunk, expand_omp_for_static_chunk,
> expand_cilk_for, simd_clone_adjust): Likewise.
> * trans-mem.c (expand_transaction): Likewise.
> * tree-vect-data-refs.c (bump_vector_ptr, vect_permute_store_chain,
> vect_setup_realignment, vect_permute_load_chain,
> vect_shift_permute_load_chain): Likewise.
> * tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
> vectorizable_simd_clone_call, vect_gen_widened_results_half,
> vect_create_vectorized_demotion_stmts, vectorizable_conversion,
> vectorizable_shift, vectorizable_operation, vectorizable_store,
> permute_vec_elements, vectorizable_load): Likewise.
>
> --- gcc/gimple.h.jj 2014-11-20 17:06:26.908397762 +0100
> +++ gcc/gimple.h 2014-12-01 11:40:44.848212993 +0100
> @@ -1296,14 +1296,12 @@ gcall *gimple_build_call_valist (tree, u
> gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
> gcall *gimple_build_call_internal_vec (enum internal_fn, vec<tree> );
> gcall *gimple_build_call_from_tree (tree);
> -gassign *gimple_build_assign_stat (tree, tree MEM_STAT_DECL);
> -#define gimple_build_assign(l,r) gimple_build_assign_stat (l, r
> MEM_STAT_INFO)
> -gassign *gimple_build_assign_with_ops (enum tree_code, tree,
> - tree, tree, tree CXX_MEM_STAT_INFO);
> -gassign *gimple_build_assign_with_ops (enum tree_code, tree,
> - tree, tree CXX_MEM_STAT_INFO);
> -gassign *gimple_build_assign_with_ops (enum tree_code, tree,
> - tree CXX_MEM_STAT_INFO);
> +gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_DECL);
> +gassign *gimple_build_assign (tree, enum tree_code,
> + tree, tree, tree CXX_MEM_STAT_INFO);
> +gassign *gimple_build_assign (tree, enum tree_code,
> + tree, tree CXX_MEM_STAT_INFO);
> +gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO);
> gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
> gcond *gimple_build_cond_from_tree (tree, tree, tree);
> void gimple_cond_set_condition_from_tree (gcond *, tree);
> --- gcc/gimple.c.jj 2014-11-20 17:06:26.906397799 +0100
> +++ gcc/gimple.c 2014-12-01 11:40:37.550343605 +0100
> @@ -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_
> 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);
> }
>
>
> --- gcc/tree-ssa-strlen.c.jj 2014-12-01 10:44:27.576594419 +0100
> +++ gcc/tree-ssa-strlen.c 2014-12-01 12:07:40.584155577 +0100
> @@ -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;
> --- gcc/tree-vect-slp.c.jj 2014-12-01 10:44:28.073585547 +0100
> +++ gcc/tree-vect-slp.c 2014-12-01 12:28:38.136222874 +0100
> @@ -2671,11 +2671,9 @@ vect_get_constant_vectors (tree op, slp_
> {
> 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,
> 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);
> --- gcc/tree-ssa-forwprop.c.jj 2014-12-01 10:44:28.046586029 +0100
> +++ gcc/tree-ssa-forwprop.c 2014-12-01 12:00:38.523849348 +0100
> @@ -1722,23 +1722,21 @@ simplify_rotate (gimple_stmt_iterator *g
> 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;
> --- gcc/asan.c.jj 2014-12-01 10:44:27.803590367 +0100
> +++ gcc/asan.c 2014-12-01 11:52:00.636118172 +0100
> @@ -1585,25 +1585,25 @@ build_shadow_mem_access (gimple_stmt_ite
> 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, t
> {
> 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, t
> {
> 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_itera
> 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_itera
> 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_itera
> &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_itera
> 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);
> --- gcc/tsan.c.jj 2014-12-01 10:44:27.803590367 +0100
> +++ gcc/tsan.c 2014-12-01 12:37:15.871738028 +0100
> @@ -500,7 +500,7 @@ instrument_builtin_call (gimple_stmt_ite
> 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_ite
> 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_ite
> 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_ite
> 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);
> --- gcc/tree-chkp.c.jj 2014-11-20 17:06:24.819436009 +0100
> +++ gcc/tree-chkp.c 2014-12-01 11:58:19.434338683 +0100
> @@ -2536,8 +2536,7 @@ chkp_compute_bounds_for_assignment (tree
> 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))
> @@ -2563,8 +2562,7 @@ chkp_compute_bounds_for_assignment (tree
> 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);
>
> @@ -2840,9 +2838,9 @@ chkp_generate_extern_var_bounds (tree va
> 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
> --- gcc/tree-loop-distribution.c.jj 2014-12-01 10:44:27.274599811 +0100
> +++ gcc/tree-loop-distribution.c 2014-12-01 11:58:25.955221977 +0100
> @@ -823,7 +823,7 @@ generate_memset_builtin (struct loop *lo
> 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;
> }
> --- gcc/tree-ssa-loop-im.c.jj 2014-11-20 17:06:24.817436046 +0100
> +++ gcc/tree-ssa-loop-im.c 2014-12-01 12:01:28.849948644 +0100
> @@ -898,11 +898,10 @@ rewrite_reciprocal (gimple_stmt_iterator
> 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
> 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
> 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);
> --- gcc/gimple-builder.c.jj 2014-12-01 10:44:28.036586207 +0100
> +++ gcc/gimple-builder.c 2014-12-01 11:52:37.293462102 +0100
> @@ -66,7 +66,7 @@ build_assign (enum tree_code code, tree
> 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
> {
> 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,
> {
> 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 *
> --- gcc/tree-vect-loop-manip.c.jj 2014-12-01 10:44:27.583594294 +0100
> +++ gcc/tree-vect-loop-manip.c 2014-12-01 12:17:14.887573545 +0100
> @@ -2157,8 +2157,7 @@ vect_create_cond_for_align_checks (loop_
>
> 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_
> /* 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_
> /* 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.
> --- gcc/value-prof.c.jj 2014-11-20 17:06:25.140430132 +0100
> +++ gcc/value-prof.c 2014-12-01 12:38:34.931289482 +0100
> @@ -775,13 +775,11 @@ gimple_divmod_fixed_value (gassign *stmt
> bb1end = stmt3;
>
> tmp2 = create_tmp_reg (optype, "PROF");
> - stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
> - op1, tmp0);
> + stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1,
> tmp0);
> gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
> bb2end = stmt1;
>
> - stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
> - op1, op2);
> + stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1,
> op2);
> gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
> bb3end = stmt1;
>
> @@ -930,9 +928,9 @@ gimple_mod_pow2 (gassign *stmt, int prob
> 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
> 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
>
> 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
> }
>
> /* 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;
>
> --- gcc/gimple-match-head.c.jj 2014-12-01 10:44:28.040586136 +0100
> +++ gcc/gimple-match-head.c 2014-12-01 11:54:43.830197429 +0100
> @@ -332,8 +332,8 @@ maybe_push_res_to_seq (code_helper rcode
> 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;
> }
> --- gcc/tree-vect-patterns.c.jj 2014-12-01 10:44:28.046586029 +0100
> +++ gcc/tree-vect-patterns.c 2014-12-01 12:39:12.293604921 +0100
> @@ -439,8 +439,8 @@ vect_recog_dot_prod_pattern (vec<gimple>
>
> /* Pattern detected. Create a stmt to be used to replace the pattern: */
> var = vect_recog_temp_ssa_var (type, NULL);
> - pattern_stmt = gimple_build_assign_with_ops (DOT_PROD_EXPR, var,
> - oprnd00, oprnd01, oprnd1);
> + pattern_stmt = gimple_build_assign (var, DOT_PROD_EXPR,
> + oprnd00, oprnd01, oprnd1);
>
> if (dump_enabled_p ())
> {
> @@ -673,8 +673,8 @@ vect_recog_sad_pattern (vec<gimple> *stm
>
> /* 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 st
> /* 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<gimpl
>
> 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<gimpl
>
> /* 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<gimpl
> = new_stmt_vec_info (pattern_stmt, loop_vinfo, bb_vinfo);
> set_vinfo_for_stmt (pattern_stmt, pattern_stmt_info);
> STMT_VINFO_VECTYPE (pattern_stmt_info) = vecitype;
> - pattern_stmt
> - = gimple_build_assign_with_ops (NOP_EXPR,
> - vect_recog_temp_ssa_var (type, NULL),
> - gimple_assign_lhs (pattern_stmt));
> + pattern_stmt = gimple_build_assign (vect_recog_temp_ssa_var (type,
> NULL),
> + NOP_EXPR,
> + gimple_assign_lhs (pattern_stmt));
> }
>
> if (dump_enabled_p ())
> @@ -1115,7 +1112,7 @@ vect_recog_pow_pattern (vec<gimple> *stm
> *type_in = TREE_TYPE (base);
>
> var = vect_recog_temp_ssa_var (TREE_TYPE (base), NULL);
> - stmt = gimple_build_assign_with_ops (MULT_EXPR, var, base, base);
> + stmt = gimple_build_assign (var, MULT_EXPR, base, base);
> return stmt;
> }
>
> @@ -1244,8 +1241,7 @@ vect_recog_widen_sum_pattern (vec<gimple
>
> /* 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
> /* 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
> {
> /* 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<gi
>
> 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<gi
> {
> /* 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<gimp
> /* Pattern supported. Create a stmt to be used to replace the pattern. */
> var = vect_recog_temp_ssa_var (type, NULL);
> pattern_stmt =
> - gimple_build_assign_with_ops (WIDEN_LSHIFT_EXPR, var, oprnd0, oprnd1);
> + gimple_build_assign (var, WIDEN_LSHIFT_EXPR, oprnd0, oprnd1);
>
> if (dump_enabled_p ())
> dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt,
> 0);
> @@ -1944,7 +1936,7 @@ vect_recog_rotate_pattern (vec<gimple> *
> if (def == NULL_TREE)
> {
> def = vect_recog_temp_ssa_var (type, NULL);
> - def_stmt = gimple_build_assign_with_ops (NOP_EXPR, def, oprnd1);
> + def_stmt = gimple_build_assign (def, NOP_EXPR, oprnd1);
> if (ext_def)
> {
> basic_block new_bb
> @@ -1974,7 +1966,7 @@ vect_recog_rotate_pattern (vec<gimple> *
> if (vecstype == NULL_TREE)
> return NULL;
> def2 = vect_recog_temp_ssa_var (stype, NULL);
> - def_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, def2, def);
> + def_stmt = gimple_build_assign (def2, NEGATE_EXPR, def);
> if (ext_def)
> {
> basic_block new_bb
> @@ -1992,9 +1984,8 @@ vect_recog_rotate_pattern (vec<gimple> *
> def2 = vect_recog_temp_ssa_var (stype, NULL);
> tree mask
> = build_int_cst (stype, GET_MODE_PRECISION (TYPE_MODE (stype)) - 1);
> - def_stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, def2,
> - gimple_assign_lhs (def_stmt),
> - mask);
> + def_stmt = gimple_build_assign (def2, BIT_AND_EXPR,
> + gimple_assign_lhs (def_stmt), mask);
> if (ext_def)
> {
> basic_block new_bb
> @@ -2011,15 +2002,15 @@ vect_recog_rotate_pattern (vec<gimple> *
> }
>
> var1 = vect_recog_temp_ssa_var (type, NULL);
> - def_stmt = gimple_build_assign_with_ops (rhs_code == LROTATE_EXPR
> - ? LSHIFT_EXPR : RSHIFT_EXPR,
> - var1, oprnd0, def);
> + def_stmt = gimple_build_assign (var1, rhs_code == LROTATE_EXPR
> + ? LSHIFT_EXPR : RSHIFT_EXPR,
> + oprnd0, def);
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> var2 = vect_recog_temp_ssa_var (type, NULL);
> - def_stmt = gimple_build_assign_with_ops (rhs_code == LROTATE_EXPR
> - ? RSHIFT_EXPR : LSHIFT_EXPR,
> - var2, oprnd0, def2);
> + def_stmt = gimple_build_assign (var2, rhs_code == LROTATE_EXPR
> + ? RSHIFT_EXPR : LSHIFT_EXPR,
> + oprnd0, def2);
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> /* Pattern detected. */
> @@ -2029,7 +2020,7 @@ vect_recog_rotate_pattern (vec<gimple> *
>
> /* 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 (
> 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 (
>
> /* Pattern supported. Create a stmt to be used to replace the pattern. */
> var = vect_recog_temp_ssa_var (TREE_TYPE (oprnd0), NULL);
> - pattern_stmt = gimple_build_assign_with_ops (rhs_code, var, oprnd0, def);
> + pattern_stmt = gimple_build_assign (var, rhs_code, oprnd0, def);
>
> if (dump_enabled_p ())
> dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt,
> 0);
> @@ -2281,25 +2272,21 @@ vect_recog_divmod_pattern (vec<gimple> *
> tree var = vect_recog_temp_ssa_var (itype, NULL);
> tree shift;
> def_stmt
> - = gimple_build_assign_with_ops (COND_EXPR, var, cond,
> - fold_build2 (MINUS_EXPR, itype,
> - oprnd1,
> - build_int_cst (itype,
> - 1)),
> - build_int_cst (itype, 0));
> + = gimple_build_assign (var, COND_EXPR, cond,
> + fold_build2 (MINUS_EXPR, itype, oprnd1,
> + build_int_cst (itype, 1)),
> + build_int_cst (itype, 0));
> new_pattern_def_seq (stmt_vinfo, def_stmt);
> var = vect_recog_temp_ssa_var (itype, NULL);
> def_stmt
> - = gimple_build_assign_with_ops (PLUS_EXPR, var, oprnd0,
> - gimple_assign_lhs (def_stmt));
> + = gimple_build_assign (var, PLUS_EXPR, oprnd0,
> + gimple_assign_lhs (def_stmt));
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> shift = build_int_cst (itype, tree_log2 (oprnd1));
> pattern_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR,
> - vect_recog_temp_ssa_var (itype,
> - NULL),
> - var, shift);
> + = gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
> + RSHIFT_EXPR, var, shift);
> }
> else
> {
> @@ -2308,10 +2295,9 @@ vect_recog_divmod_pattern (vec<gimple> *
> if (compare_tree_int (oprnd1, 2) == 0)
> {
> signmask = vect_recog_temp_ssa_var (itype, NULL);
> - def_stmt
> - = gimple_build_assign_with_ops (COND_EXPR, signmask, cond,
> - build_int_cst (itype, 1),
> - build_int_cst (itype, 0));
> + def_stmt = gimple_build_assign (signmask, COND_EXPR, cond,
> + build_int_cst (itype, 1),
> + build_int_cst (itype, 0));
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> }
> else
> @@ -2324,20 +2310,18 @@ vect_recog_divmod_pattern (vec<gimple> *
> - tree_log2 (oprnd1));
> tree var = vect_recog_temp_ssa_var (utype, NULL);
>
> - def_stmt
> - = gimple_build_assign_with_ops (COND_EXPR, var, cond,
> - build_int_cst (utype, -1),
> - build_int_cst (utype, 0));
> + def_stmt = gimple_build_assign (var, COND_EXPR, cond,
> + build_int_cst (utype, -1),
> + build_int_cst (utype, 0));
> def_stmt_vinfo
> = new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
> set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
> STMT_VINFO_VECTYPE (def_stmt_vinfo) = vecutype;
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> var = vect_recog_temp_ssa_var (utype, NULL);
> - def_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR, var,
> - gimple_assign_lhs (def_stmt),
> - shift);
> + def_stmt = gimple_build_assign (var, RSHIFT_EXPR,
> + gimple_assign_lhs (def_stmt),
> + shift);
> def_stmt_vinfo
> = new_stmt_vec_info (def_stmt, loop_vinfo, bb_vinfo);
> set_vinfo_for_stmt (def_stmt, def_stmt_vinfo);
> @@ -2345,32 +2329,24 @@ vect_recog_divmod_pattern (vec<gimple> *
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> signmask = vect_recog_temp_ssa_var (itype, NULL);
> def_stmt
> - = gimple_build_assign_with_ops (NOP_EXPR, signmask, var);
> + = gimple_build_assign (signmask, NOP_EXPR, var);
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> }
> def_stmt
> - = gimple_build_assign_with_ops (PLUS_EXPR,
> - vect_recog_temp_ssa_var (itype,
> - NULL),
> - oprnd0, signmask);
> + = gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
> + PLUS_EXPR, oprnd0, signmask);
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> def_stmt
> - = gimple_build_assign_with_ops (BIT_AND_EXPR,
> - vect_recog_temp_ssa_var (itype,
> - NULL),
> - gimple_assign_lhs (def_stmt),
> - fold_build2 (MINUS_EXPR, itype,
> - oprnd1,
> - build_int_cst (itype,
> - 1)));
> + = gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
> + BIT_AND_EXPR, gimple_assign_lhs (def_stmt),
> + fold_build2 (MINUS_EXPR, itype, oprnd1,
> + build_int_cst (itype, 1)));
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> pattern_stmt
> - = gimple_build_assign_with_ops (MINUS_EXPR,
> - vect_recog_temp_ssa_var (itype,
> - NULL),
> - gimple_assign_lhs (def_stmt),
> - signmask);
> + = gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
> + MINUS_EXPR, gimple_assign_lhs (def_stmt),
> + signmask);
> }
>
> if (dump_enabled_p ())
> @@ -2432,25 +2408,23 @@ vect_recog_divmod_pattern (vec<gimple> *
> t4 = t1 + t3;
> q = t4 >> (post_shift - 1); */
> t1 = vect_recog_temp_ssa_var (itype, NULL);
> - def_stmt
> - = gimple_build_assign_with_ops (MULT_HIGHPART_EXPR, t1, oprnd0,
> - build_int_cst (itype, ml));
> + def_stmt = gimple_build_assign (t1, MULT_HIGHPART_EXPR, oprnd0,
> + build_int_cst (itype, ml));
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> t2 = vect_recog_temp_ssa_var (itype, NULL);
> def_stmt
> - = gimple_build_assign_with_ops (MINUS_EXPR, t2, oprnd0, t1);
> + = gimple_build_assign (t2, MINUS_EXPR, oprnd0, t1);
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> t3 = vect_recog_temp_ssa_var (itype, NULL);
> def_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR, t3, t2,
> - integer_one_node);
> + = gimple_build_assign (t3, RSHIFT_EXPR, t2, integer_one_node);
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> t4 = vect_recog_temp_ssa_var (itype, NULL);
> def_stmt
> - = gimple_build_assign_with_ops (PLUS_EXPR, t4, t1, t3);
> + = gimple_build_assign (t4, PLUS_EXPR, t1, t3);
>
> if (post_shift != 1)
> {
> @@ -2458,10 +2432,8 @@ vect_recog_divmod_pattern (vec<gimple> *
>
> q = vect_recog_temp_ssa_var (itype, NULL);
> pattern_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR, q, t4,
> - build_int_cst (itype,
> - post_shift
> - - 1));
> + = gimple_build_assign (q, RSHIFT_EXPR, t4,
> + build_int_cst (itype, post_shift - 1));
> }
> else
> {
> @@ -2481,18 +2453,16 @@ vect_recog_divmod_pattern (vec<gimple> *
> {
> t1 = vect_recog_temp_ssa_var (itype, NULL);
> def_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR, t1, oprnd0,
> - build_int_cst (NULL,
> - pre_shift));
> + = gimple_build_assign (t1, RSHIFT_EXPR, oprnd0,
> + build_int_cst (NULL, pre_shift));
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> }
> else
> t1 = oprnd0;
>
> t2 = vect_recog_temp_ssa_var (itype, NULL);
> - def_stmt
> - = gimple_build_assign_with_ops (MULT_HIGHPART_EXPR, t2, t1,
> - build_int_cst (itype, ml));
> + def_stmt = gimple_build_assign (t2, MULT_HIGHPART_EXPR, t1,
> + build_int_cst (itype, ml));
>
> if (post_shift)
> {
> @@ -2500,9 +2470,8 @@ vect_recog_divmod_pattern (vec<gimple> *
>
> q = vect_recog_temp_ssa_var (itype, NULL);
> def_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR, q, t2,
> - build_int_cst (itype,
> - post_shift));
> + = gimple_build_assign (q, RSHIFT_EXPR, t2,
> + build_int_cst (itype, post_shift));
> }
> else
> q = t2;
> @@ -2552,17 +2521,15 @@ vect_recog_divmod_pattern (vec<gimple> *
>
> /* t1 = oprnd0 h* ml; */
> t1 = vect_recog_temp_ssa_var (itype, NULL);
> - def_stmt
> - = gimple_build_assign_with_ops (MULT_HIGHPART_EXPR, t1, oprnd0,
> - build_int_cst (itype, ml));
> + def_stmt = gimple_build_assign (t1, MULT_HIGHPART_EXPR, oprnd0,
> + build_int_cst (itype, ml));
>
> if (add)
> {
> /* t2 = t1 + oprnd0; */
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> t2 = vect_recog_temp_ssa_var (itype, NULL);
> - def_stmt
> - = gimple_build_assign_with_ops (PLUS_EXPR, t2, t1, oprnd0);
> + def_stmt = gimple_build_assign (t2, PLUS_EXPR, t1, oprnd0);
> }
> else
> t2 = t1;
> @@ -2572,9 +2539,8 @@ vect_recog_divmod_pattern (vec<gimple> *
> /* t3 = t2 >> post_shift; */
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> t3 = vect_recog_temp_ssa_var (itype, NULL);
> - def_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR, t3, t2,
> - build_int_cst (itype, post_shift));
> + def_stmt = gimple_build_assign (t3, RSHIFT_EXPR, t2,
> + build_int_cst (itype, post_shift));
> }
> else
> t3 = t2;
> @@ -2605,20 +2571,17 @@ vect_recog_divmod_pattern (vec<gimple> *
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> t4 = vect_recog_temp_ssa_var (itype, NULL);
> if (msb != 1)
> - def_stmt
> - = gimple_build_assign_with_ops (INTEGER_CST,
> - t4, build_int_cst (itype, msb));
> + def_stmt = gimple_build_assign (t4, INTEGER_CST,
> + build_int_cst (itype, msb));
> else
> - def_stmt
> - = gimple_build_assign_with_ops (RSHIFT_EXPR, t4, oprnd0,
> - build_int_cst (itype, prec - 1));
> + def_stmt = gimple_build_assign (t4, RSHIFT_EXPR, oprnd0,
> + build_int_cst (itype, prec - 1));
> append_pattern_def_seq (stmt_vinfo, def_stmt);
>
> /* q = t3 - t4; or q = t4 - t3; */
> q = vect_recog_temp_ssa_var (itype, NULL);
> - pattern_stmt
> - = gimple_build_assign_with_ops (MINUS_EXPR, q, d < 0 ? t4 : t3,
> - d < 0 ? t3 : t4);
> + pattern_stmt = gimple_build_assign (q, MINUS_EXPR, d < 0 ? t4 : t3,
> + d < 0 ? t3 : t4);
> }
> }
>
> @@ -2632,13 +2595,11 @@ vect_recog_divmod_pattern (vec<gimple> *
> 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<
> 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, tre
> 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_
> 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_
> }
> 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_
> gcc_checking_assert (useless_type_conversion_p (itype,
> TREE_TYPE (trueval)));
> pattern_stmt
> - = gimple_build_assign_with_ops (COND_EXPR,
> - vect_recog_temp_ssa_var (itype, NULL),
> - cond_expr, trueval,
> - build_int_cst (itype, 0));
> + = gimple_build_assign (vect_recog_temp_ssa_var (itype, NULL),
> + COND_EXPR, cond_expr, trueval,
> + build_int_cst (itype, 0));
> break;
> }
>
> @@ -3200,11 +3151,10 @@ vect_recog_bool_pattern (vec<gimple> *st
> rhs = adjust_bool_pattern (var, TREE_TYPE (lhs), NULL_TREE, stmts);
> lhs = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
> if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
> - pattern_stmt
> - = gimple_build_assign_with_ops (SSA_NAME, lhs, rhs);
> + pattern_stmt = gimple_build_assign (lhs, SSA_NAME, rhs);
> else
> pattern_stmt
> - = gimple_build_assign_with_ops (NOP_EXPR, lhs, rhs);
> + = gimple_build_assign (lhs, NOP_EXPR, rhs);
> *type_out = vectype;
> *type_in = vectype;
> stmts->safe_push (last_stmt);
> @@ -3239,11 +3189,11 @@ vect_recog_bool_pattern (vec<gimple> *st
> rhs = adjust_bool_pattern (var, type, NULL_TREE, stmts);
> lhs = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
> pattern_stmt
> - = gimple_build_assign_with_ops (COND_EXPR, lhs,
> - build2 (NE_EXPR, boolean_type_node,
> - rhs, build_int_cst (type, 0)),
> - gimple_assign_rhs2 (last_stmt),
> - gimple_assign_rhs3 (last_stmt));
> + = gimple_build_assign (lhs, COND_EXPR,
> + build2 (NE_EXPR, boolean_type_node,
> + rhs, build_int_cst (type, 0)),
> + gimple_assign_rhs2 (last_stmt),
> + gimple_assign_rhs3 (last_stmt));
> *type_out = vectype;
> *type_in = vectype;
> stmts->safe_push (last_stmt);
> @@ -3269,13 +3219,11 @@ vect_recog_bool_pattern (vec<gimple> *st
> 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);
> --- gcc/gimple-ssa-strength-reduction.c.jj 2014-11-20 17:06:26.483405543
> +0100
> +++ gcc/gimple-ssa-strength-reduction.c 2014-12-01 11:55:59.034851464
> +0100
> @@ -2186,8 +2186,7 @@ create_add_on_incoming_edge (slsr_cand_t
> }
>
> 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
> 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
> 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, un
> 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;
> --- gcc/tree-ssa-math-opts.c.jj 2014-12-01 10:44:27.651593080 +0100
> +++ gcc/tree-ssa-math-opts.c 2014-12-01 12:02:54.194421203 +0100
> @@ -378,8 +378,8 @@ insert_reciprocals (gimple_stmt_iterator
> /* 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 *g
> 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
>
> /* 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_iter
> 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_itera
> 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 s
> {
> 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 s
> {
> 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, tr
> 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++;
> }
> --- gcc/tree-tailcall.c.jj 2014-12-01 10:44:27.575594437 +0100
> +++ gcc/tree-tailcall.c 2014-12-01 12:07:57.412839914 +0100
> @@ -665,7 +665,7 @@ adjust_return_value_with_ops (enum tree_
> }
> if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1))
> && code != POINTER_PLUS_EXPR)
> - stmt = gimple_build_assign_with_ops (code, result, acc, op1);
> + stmt = gimple_build_assign (result, code, acc, op1);
> else
> {
> tree tem;
> @@ -696,7 +696,7 @@ update_accumulator_with_ops (enum tree_c
> 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),
> --- gcc/tree-predcom.c.jj 2014-12-01 10:44:28.044586064 +0100
> +++ gcc/tree-predcom.c 2014-12-01 11:58:54.210716278 +0100
> @@ -2192,7 +2192,7 @@ reassociate_to_the_same_stmt (tree name1
> 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
> /* 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);
> --- gcc/tree-ssa-reassoc.c.jj 2014-12-01 10:44:28.054585886 +0100
> +++ gcc/tree-ssa-reassoc.c 2014-12-01 12:06:39.891294023 +0100
> @@ -1342,7 +1342,7 @@ build_and_add_sum (tree type, tree op1,
>
> /* 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 t
> 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 cod
> {
> 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
> 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
> 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
> 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<o
> 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<o
> 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);
> }
> --- gcc/tree-vect-loop.c.jj 2014-12-01 10:44:28.036586207 +0100
> +++ gcc/tree-vect-loop.c 2014-12-01 12:16:48.056177821 +0100
> @@ -2503,8 +2503,7 @@ vect_is_simple_reduction_1 (loop_vec_inf
> {
> 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
> /* 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
> 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
> 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
> 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<tr
> {
> 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<tr
> }
> 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<tr
> 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);
> --- gcc/ipa-split.c.jj 2014-12-01 10:44:28.034586243 +0100
> +++ gcc/ipa-split.c 2014-12-01 11:56:06.836711831 +0100
> @@ -1586,8 +1586,7 @@ split_function (struct split_point *spli
> 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;
> }
> --- gcc/tree-ssa-phiopt.c.jj 2014-12-01 10:44:28.040586136 +0100
> +++ gcc/tree-ssa-phiopt.c 2014-12-01 12:04:13.947993824 +0100
> @@ -537,8 +537,7 @@ conditional_replacement (basic_block con
> 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,
>
> /* 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, ba
> 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, ba
> /* 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, ba
> }
>
> 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, ba
> 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, ba
> /* 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);
> --- gcc/tree-profile.c.jj 2014-11-20 17:06:26.904397836 +0100
> +++ gcc/tree-profile.c 2014-12-01 11:59:05.387516243 +0100
> @@ -315,8 +315,8 @@ gimple_gen_edge_profiler (int edgeno, ed
> 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);
> --- gcc/tree-vrp.c.jj 2014-12-01 10:44:27.237600471 +0100
> +++ gcc/tree-vrp.c 2014-12-01 12:36:16.977817095 +0100
> @@ -8968,7 +8968,7 @@ simplify_truth_ops_using_ranges (gimple_
> {
> 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 (
> 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 (gim
> 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 (gim
> 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 (gim
> 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);
> --- gcc/gimple-fold.c.jj 2014-12-01 10:44:28.041586118 +0100
> +++ gcc/gimple-fold.c 2014-12-01 11:54:05.180889149 +0100
> @@ -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_
> 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_
> 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_
> 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);
> }
> --- gcc/tree-vect-generic.c.jj 2014-12-01 10:44:28.052585921 +0100
> +++ gcc/tree-vect-generic.c 2014-12-01 12:13:25.825679714 +0100
> @@ -640,8 +640,8 @@ expand_vector_divmod (gimple_stmt_iterat
> << 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
> 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);
> }
>
> --- gcc/ubsan.c.jj 2014-12-01 10:44:28.044586064 +0100
> +++ gcc/ubsan.c 2014-12-01 11:40:37.550343605 +0100
> @@ -748,7 +748,7 @@ ubsan_expand_null_ifn (gimple_stmt_itera
> 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_itera
>
> 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_it
> ? 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_i
> 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_i
> 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);
> }
> --- gcc/tree-ssa-loop-manip.c.jj 2014-12-01 10:44:27.574594455 +0100
> +++ gcc/tree-ssa-loop-manip.c 2014-12-01 12:01:38.016784582 +0100
> @@ -145,7 +145,7 @@ create_iv (tree base, tree step, tree va
> 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
> --- gcc/omp-low.c.jj 2014-12-01 10:44:27.578594384 +0100
> +++ gcc/omp-low.c 2014-12-01 11:57:35.786119871 +0100
> @@ -3635,7 +3635,7 @@ lower_rec_input_clauses (tree clauses, g
> 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, g
> 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, g
> 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, g
> 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_regio
> 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 om
> 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 om
> 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_
> 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 *regi
> 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 *n
> 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 *n
> 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 *n
> ? 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);
>
> --- gcc/trans-mem.c.jj 2014-12-01 10:44:28.038586171 +0100
> +++ gcc/trans-mem.c 2014-12-01 11:57:52.917813259 +0100
> @@ -2807,8 +2807,7 @@ expand_transaction (struct tm_region *re
>
> 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 *re
>
> 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 *re
> 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);
>
> --- gcc/tree-vect-data-refs.c.jj 2014-12-01 10:44:28.037586189 +0100
> +++ gcc/tree-vect-data-refs.c 2014-12-01 12:13:00.790149318 +0100
> @@ -4348,8 +4348,8 @@ bump_vector_ptr (tree dataref_ptr, gimpl
> update = bump;
>
> new_dataref_ptr = copy_ssa_name (dataref_ptr);
> - incr_stmt = gimple_build_assign_with_ops (POINTER_PLUS_EXPR,
> new_dataref_ptr,
> - dataref_ptr, update);
> + incr_stmt = gimple_build_assign (new_dataref_ptr, POINTER_PLUS_EXPR,
> + dataref_ptr, update);
> vect_finish_stmt_generation (stmt, incr_stmt, gsi);
>
> /* Copy the points-to information if it exists. */
> @@ -4640,9 +4640,8 @@ vect_permute_store_chain (vec<tree> dr_c
> {j, nelt, *, j + 1, nelt + j + 1, *,
> j + 2, nelt + j + 2, *, ...}> */
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_low");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - vect1, vect2,
> - perm3_mask_low);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, vect1,
> + vect2, perm3_mask_low);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
>
> vect1 = data_ref;
> @@ -4652,9 +4651,8 @@ vect_permute_store_chain (vec<tree> dr_c
> {0, 1, nelt + j, 3, 4, nelt + j + 1,
> 6, 7, nelt + j + 2, ...}> */
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_high");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - vect1, vect2,
> - perm3_mask_high);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, vect1,
> + vect2, perm3_mask_high);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> (*result_chain)[j] = data_ref;
> }
> @@ -4686,9 +4684,8 @@ vect_permute_store_chain (vec<tree> dr_c
> high = VEC_PERM_EXPR <vect1, vect2, {0, nelt, 1, nelt+1,
> ...}> */
> high = make_temp_ssa_name (vectype, NULL, "vect_inter_high");
> - perm_stmt
> - = gimple_build_assign_with_ops (VEC_PERM_EXPR, high,
> - vect1, vect2, perm_mask_high);
> + perm_stmt = gimple_build_assign (high, VEC_PERM_EXPR, vect1,
> + vect2, perm_mask_high);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> (*result_chain)[2*j] = high;
>
> @@ -4697,9 +4694,8 @@ vect_permute_store_chain (vec<tree> dr_c
> {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, gim
> NULL_TREE, &init_addr, NULL, &inc,
> true, &inv_p);
> new_temp = copy_ssa_name (ptr);
> - new_stmt = gimple_build_assign_with_ops
> - (BIT_AND_EXPR, new_temp, ptr,
> + new_stmt = gimple_build_assign
> + (new_temp, BIT_AND_EXPR, ptr,
> build_int_cst (TREE_TYPE (ptr),
> -(HOST_WIDE_INT)TYPE_ALIGN_UNIT (vectype)));
> new_bb = gsi_insert_on_edge_immediate (pe, new_stmt);
> @@ -5194,9 +5190,8 @@ vect_permute_load_chain (vec<tree> dr_ch
> low = VEC_PERM_EXPR <first_vect, second_vect2, {k, 3 + k, 6 + k,
> ...}> */
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_low");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - first_vect, second_vect,
> - perm3_mask_low);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, first_vect,
> + second_vect, perm3_mask_low);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
>
> /* Create interleaving stmt (high part of):
> @@ -5205,9 +5200,8 @@ vect_permute_load_chain (vec<tree> dr_ch
> first_vect = data_ref;
> second_vect = dr_chain[2];
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_high");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - first_vect, second_vect,
> - perm3_mask_high);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, first_vect,
> + second_vect, perm3_mask_high);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> (*result_chain)[k] = data_ref;
> }
> @@ -5234,17 +5228,17 @@ vect_permute_load_chain (vec<tree> dr_ch
>
> /* data_ref = permute_even (first_data_ref, second_data_ref); */
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_perm_even");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - first_vect, second_vect,
> - perm_mask_even);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + first_vect, second_vect,
> + perm_mask_even);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> (*result_chain)[j/2] = data_ref;
>
> /* data_ref = permute_odd (first_data_ref, second_data_ref); */
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_perm_odd");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - first_vect, second_vect,
> - perm_mask_odd);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + first_vect, second_vect,
> + perm_mask_odd);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> (*result_chain)[j/2+length/2] = data_ref;
> }
> @@ -5431,30 +5425,28 @@ vect_shift_permute_load_chain (vec<tree>
> second_vect = dr_chain[j + 1];
>
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle2");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - first_vect, first_vect,
> - perm2_mask1);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + first_vect, first_vect,
> + perm2_mask1);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> vect[0] = data_ref;
>
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle2");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - second_vect,
> second_vect,
> - perm2_mask2);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + second_vect, second_vect,
> + perm2_mask2);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> vect[1] = data_ref;
>
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - vect[0], vect[1],
> - shift1_mask);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + vect[0], vect[1], shift1_mask);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> (*result_chain)[j/2 + length/2] = data_ref;
>
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_select");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - vect[0], vect[1],
> - select_mask);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + vect[0], vect[1], select_mask);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> (*result_chain)[j/2] = data_ref;
> }
> @@ -5544,9 +5536,9 @@ vect_shift_permute_load_chain (vec<tree>
> for (k = 0; k < 3; k++)
> {
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - dr_chain[k], dr_chain[k],
> - perm3_mask);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + dr_chain[k], dr_chain[k],
> + perm3_mask);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> vect[k] = data_ref;
> }
> @@ -5554,10 +5546,9 @@ vect_shift_permute_load_chain (vec<tree>
> for (k = 0; k < 3; k++)
> {
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift1");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - vect[k % 3],
> - vect[(k + 1) % 3],
> - shift1_mask);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + vect[k % 3], vect[(k + 1) % 3],
> + shift1_mask);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> vect_shift[k] = data_ref;
> }
> @@ -5565,10 +5556,10 @@ vect_shift_permute_load_chain (vec<tree>
> for (k = 0; k < 3; k++)
> {
> data_ref = make_temp_ssa_name (vectype, NULL, "vect_shift2");
> - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
> - vect_shift[(4 - k) % 3],
> - vect_shift[(3 - k) % 3],
> - shift2_mask);
> + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR,
> + vect_shift[(4 - k) % 3],
> + vect_shift[(3 - k) % 3],
> + shift2_mask);
> vect_finish_stmt_generation (stmt, perm_stmt, gsi);
> vect[k] = data_ref;
> }
> @@ -5576,16 +5567,14 @@ vect_shift_permute_load_chain (vec<tree>
> (*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;
> --- gcc/tree-vect-stmts.c.jj 2014-12-01 10:44:28.047586011 +0100
> +++ gcc/tree-vect-stmts.c 2014-12-01 12:33:20.373052887 +0100
> @@ -1332,8 +1332,7 @@ vect_init_vector (gimple stmt, tree val,
> 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 stm
> 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 stm
> 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 stm
> 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 stm
> 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 stm
> 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
> 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 (v
> /* 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, gi
> 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, gi
> {
> 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, gi
> {
> 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_
> 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, gim
> ? 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_
>
> /* 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, tr
> 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_s
> 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_s
> 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_s
> 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_s
> 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_s
> 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_s
> }
> 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_s
> 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);
>
>
> Jakub
>
>
--
Richard Biener <rguent...@suse.de>
SUSE LINUX GmbH, GF: Jeff Hawn, Jennifer Guild, Felix Imendoerffer, HRB 21284
(AG Nuernberg)
Maxfeldstrasse 5, 90409 Nuernberg, Germany
