On Wed, 19 Nov 2014, Jakub Jelinek wrote:
> Hi!
>
> This patch:
> 1) adds unary op overload to gimple_build_assign_with_ops
> so that many callers don't need to pass NULL_TREE as the last
> argument explicitly
> 2) adds unary op overload to gimple_assign_set_rhs_with_ops for similar
> reasons
> 3) renames gimple_assign_set_rhs_with_ops_1 to
> gimple_assign_set_rhs_with_ops so it becomes ternary op overload
> to the existing binary op one and 2) added unary op
> and adjusts all users that I found.
>
> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
Ok.
Thanks,
Richard.
> 2014-11-19 Jakub Jelinek <ja...@redhat.com>
>
> * gimple.h (gimple_build_assign_with_ops): Add unary arg overload.
> (gimple_assign_set_rhs_with_ops_1): Renamed to ...
> (gimple_assign_set_rhs_with_ops): ... this. Adjust binary arg
> inline overload to use it. Add unary arg overload.
> * gimple.c (gimple_build_assign_with_ops): New unary arg overload.
> (gimple_assign_set_rhs_from_tree): Use
> gimple_assign_set_rhs_with_ops instead of
> gimple_assign_set_rhs_with_ops_1.
> (gimple_assign_set_rhs_with_ops_1): Renamed to ...
> (gimple_assign_set_rhs_with_ops): ... this.
> * ipa-split.c (split_function): Remove last NULL argument
> from gimple_build_assign_with_ops call.
> * tree-ssa-loop-im.c
> (move_computations_dom_walker::before_dom_children): Likewise.
> * tsan.c (instrument_builtin_call): Likewise.
> * tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
> vectorizable_conversion, vectorizable_load): Likewise.
> * tree-vect-loop.c (vect_is_simple_reduction_1,
> get_initial_def_for_induction): Likewise.
> * tree-loop-distribution.c (generate_memset_builtin): Likewise.
> * tree-vect-patterns.c (vect_handle_widen_op_by_const,
> vect_recog_widen_mult_pattern, vect_operation_fits_smaller_type,
> vect_recog_over_widening_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.
> * tree-ssa-phiopt.c (conditional_replacement, abs_replacement,
> neg_replacement): Likewise.
> * asan.c (build_shadow_mem_access, maybe_create_ssa_name,
> maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
> * tree-vect-slp.c (vect_get_constant_vectors): Likewise.
> * omp-low.c (lower_rec_input_clauses, expand_omp_for_generic,
> expand_omp_for_static_nochunk, expand_omp_for_static_chunk,
> simd_clone_adjust): Likewise.
> * tree-vect-loop-manip.c (vect_create_cond_for_align_checks): Likewise.
> * gimple-ssa-strength-reduction.c (introduce_cast_before_cand,
> replace_one_candidate): Likewise.
> * gimple-builder.c (build_type_cast): Likewise.
> * tree-ssa-forwprop.c (simplify_rotate): Likewise.
> (forward_propagate_addr_expr_1): Remove last NULL argument
> from gimple_assign_set_rhs_with_ops call.
> (simplify_vector_constructor): Use gimple_assign_set_rhs_with_ops
> instead of gimple_assign_set_rhs_with_ops_1.
> * tree-ssa-reassoc.c (maybe_optimize_range_tests): Remove last NULL
> argument from gimple_build_assign_with_ops call.
> (repropagate_negates): Remove last NULL argument from
> gimple_assign_set_rhs_with_ops call.
> * ubsan.c (ubsan_expand_null_ifn, ubsan_expand_objsize_ifn): Remove
> last NULL argument from gimple_build_assign_with_ops call.
> (instrument_bool_enum_load): Likewise. Remove last NULL argument
> from gimple_assign_set_rhs_with_ops call.
> * tree-ssa-math-opts.c (build_and_insert_cast, convert_mult_to_fma):
> Remove last NULL argument from gimple_build_assign_with_ops call.
> (bswap_replace): Likewise. Use gimple_assign_set_rhs_with_ops instead
> of gimple_assign_set_rhs_with_ops_1.
> (convert_plusminus_to_widen): Use gimple_assign_set_rhs_with_ops
> instead of gimple_assign_set_rhs_with_ops_1.
> * gimple-fold.c (replace_stmt_with_simplification): Likewise.
> (rewrite_to_defined_overflow, gimple_build): Remove last NULL argument
> from gimple_build_assign_with_ops call.
> * tree-ssa-strlen.c (handle_pointer_plus): Remove last NULL argument
> from gimple_assign_set_rhs_with_ops call.
> * tree-vrp.c (simplify_truth_ops_using_ranges,
> simplify_bit_ops_using_ranges): Remove last NULL argument from
> gimple_assign_set_rhs_with_ops call.
> (simplify_float_conversion_using_ranges,
> simplify_internal_call_using_ranges): Remove last NULL argument from
> gimple_build_assign_with_ops call.
>
> --- gcc/gimple.h.jj 2014-11-19 10:45:17.780769013 +0100
> +++ gcc/gimple.h 2014-11-19 10:52:52.118574835 +0100
> @@ -1180,6 +1180,8 @@ gimple gimple_build_assign_with_ops (enu
> tree, tree, tree CXX_MEM_STAT_INFO);
> gimple gimple_build_assign_with_ops (enum tree_code, tree,
> tree, tree CXX_MEM_STAT_INFO);
> +gimple gimple_build_assign_with_ops (enum tree_code, tree,
> + tree CXX_MEM_STAT_INFO);
> gimple gimple_build_cond (enum tree_code, tree, tree, tree, tree);
> gimple gimple_build_cond_from_tree (tree, tree, tree);
> void gimple_cond_set_condition_from_tree (gimple, tree);
> @@ -1244,8 +1246,8 @@ bool gimple_assign_ssa_name_copy_p (gimp
> bool gimple_assign_unary_nop_p (gimple);
> void gimple_set_bb (gimple, basic_block);
> void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
> -void gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *, enum
> tree_code,
> - tree, tree, tree);
> +void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
> + tree, tree, tree);
> tree gimple_get_lhs (const_gimple);
> void gimple_set_lhs (gimple, tree);
> gimple gimple_copy (gimple);
> @@ -2313,14 +2315,24 @@ gimple_assign_set_rhs3 (gimple gs, tree
> gimple_set_op (gs, 3, rhs);
> }
>
> -/* A wrapper around gimple_assign_set_rhs_with_ops_1, for callers which
> expect
> - to see only a maximum of two operands. */
> +/* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
> + which expect to see only two operands. */
>
> static inline void
> gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code
> code,
> tree op1, tree op2)
> {
> - gimple_assign_set_rhs_with_ops_1 (gsi, code, op1, op2, NULL);
> + gimple_assign_set_rhs_with_ops (gsi, code, op1, op2, NULL);
> +}
> +
> +/* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
> + which expect to see only one operands. */
> +
> +static inline void
> +gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code
> code,
> + tree op1)
> +{
> + gimple_assign_set_rhs_with_ops (gsi, code, op1, NULL, NULL);
> }
>
> /* Returns true if GS is a nontemporal move. */
> --- gcc/gimple.c.jj 2014-11-19 10:45:17.763769320 +0100
> +++ gcc/gimple.c 2014-11-19 10:52:52.119574816 +0100
> @@ -446,6 +446,14 @@ gimple_build_assign_with_ops (enum tree_
> PASS_MEM_STAT);
> }
>
> +gimple
> +gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1
> + MEM_STAT_DECL)
> +{
> + return gimple_build_assign_with_ops (subcode, lhs, op1, NULL_TREE,
> NULL_TREE
> + PASS_MEM_STAT);
> +}
> +
>
> /* Build a GIMPLE_COND statement.
>
> @@ -1550,7 +1558,7 @@ gimple_assign_set_rhs_from_tree (gimple_
> tree op1, op2, op3;
>
> extract_ops_from_tree_1 (expr, &subcode, &op1, &op2, &op3);
> - gimple_assign_set_rhs_with_ops_1 (gsi, subcode, op1, op2, op3);
> + gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
> }
>
>
> @@ -1561,8 +1569,8 @@ gimple_assign_set_rhs_from_tree (gimple_
> did not have enough operand slots. */
>
> void
> -gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *gsi, enum tree_code
> code,
> - tree op1, tree op2, tree op3)
> +gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code
> code,
> + tree op1, tree op2, tree op3)
> {
> unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
> gimple stmt = gsi_stmt (*gsi);
> --- gcc/ipa-split.c.jj 2014-11-11 00:06:19.000000000 +0100
> +++ gcc/ipa-split.c 2014-11-19 11:03:41.326884348 +0100
> @@ -1577,7 +1577,7 @@ split_function (struct split_point *spli
> tree tem = create_tmp_reg (restype, NULL);
> tem = make_ssa_name (tem, call);
> cpy = gimple_build_assign_with_ops (NOP_EXPR, retval,
> - tem, NULL_TREE);
> + tem);
> gsi_insert_after (&gsi, cpy, GSI_NEW_STMT);
> retval = tem;
> }
> --- gcc/tree-ssa-loop-im.c.jj 2014-10-28 14:39:56.000000000 +0100
> +++ gcc/tree-ssa-loop-im.c 2014-11-19 11:07:44.142513141 +0100
> @@ -1211,7 +1211,7 @@ move_computations_dom_walker::before_dom
> tree arg = PHI_ARG_DEF (stmt, 0);
> new_stmt = gimple_build_assign_with_ops (TREE_CODE (arg),
> gimple_phi_result (stmt),
> - arg, NULL_TREE);
> + arg);
> }
> else
> {
> --- gcc/tree-ssa-forwprop.c.jj 2014-11-18 08:26:47.000000000 +0100
> +++ gcc/tree-ssa-forwprop.c 2014-11-19 11:07:01.423281870 +0100
> @@ -757,10 +757,9 @@ forward_propagate_addr_expr_1 (tree name
>
> if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE
> (new_def_rhs)))
> gimple_assign_set_rhs_with_ops (use_stmt_gsi, TREE_CODE (new_def_rhs),
> - new_def_rhs, NULL_TREE);
> + new_def_rhs);
> else if (is_gimple_min_invariant (new_def_rhs))
> - gimple_assign_set_rhs_with_ops (use_stmt_gsi, NOP_EXPR,
> - new_def_rhs, NULL_TREE);
> + gimple_assign_set_rhs_with_ops (use_stmt_gsi, NOP_EXPR, new_def_rhs);
> else
> return false;
> gcc_assert (gsi_stmt (*use_stmt_gsi) == use_stmt);
> @@ -1725,8 +1724,7 @@ simplify_rotate (gimple_stmt_iterator *g
> {
> g = gimple_build_assign_with_ops (NOP_EXPR,
> make_ssa_name (TREE_TYPE (def_arg2[0]),
> - NULL),
> - rotcnt, NULL_TREE);
> + NULL), rotcnt);
> gsi_insert_before (gsi, g, GSI_SAME_STMT);
> rotcnt = gimple_assign_lhs (g);
> }
> @@ -1740,7 +1738,7 @@ simplify_rotate (gimple_stmt_iterator *g
> {
> gsi_insert_before (gsi, g, GSI_SAME_STMT);
> g = gimple_build_assign_with_ops (NOP_EXPR, gimple_assign_lhs (stmt),
> - lhs, NULL_TREE);
> + lhs);
> }
> gsi_replace (gsi, g, false);
> return true;
> @@ -2055,7 +2053,7 @@ simplify_vector_constructor (gimple_stmt
> for (i = 0; i < nelts; i++)
> mask_elts[i] = build_int_cst (TREE_TYPE (mask_type), sel[i]);
> op2 = build_vector (mask_type, mask_elts);
> - gimple_assign_set_rhs_with_ops_1 (gsi, VEC_PERM_EXPR, orig, orig, op2);
> + gimple_assign_set_rhs_with_ops (gsi, VEC_PERM_EXPR, orig, orig, op2);
> }
> update_stmt (gsi_stmt (*gsi));
> return true;
> --- gcc/tsan.c.jj 2014-10-30 14:42:26.000000000 +0100
> +++ gcc/tsan.c 2014-11-19 11:20:35.024641177 +0100
> @@ -501,8 +501,7 @@ instrument_builtin_call (gimple_stmt_ite
> TREE_TYPE (args[1])))
> {
> tree var = make_ssa_name (TREE_TYPE (lhs), NULL);
> - g = gimple_build_assign_with_ops (NOP_EXPR, var,
> - args[1], NULL_TREE);
> + g = gimple_build_assign_with_ops (NOP_EXPR, var, args[1]);
> gsi_insert_after (gsi, g, GSI_NEW_STMT);
> args[1] = var;
> }
> @@ -516,8 +515,7 @@ instrument_builtin_call (gimple_stmt_ite
> 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,
> - NULL_TREE);
> + g = gimple_build_assign_with_ops (BIT_NOT_EXPR, lhs, var);
> }
> else
> g = gimple_build_assign_with_ops (tsan_atomic_table[i].code,
> @@ -560,7 +558,7 @@ instrument_builtin_call (gimple_stmt_ite
> g = gimple_build_assign_with_ops (NOP_EXPR,
> make_ssa_name (TREE_TYPE (t),
> NULL),
> - args[1], NULL_TREE);
> + args[1]);
> gsi_insert_before (gsi, g, GSI_SAME_STMT);
> args[1] = gimple_assign_lhs (g);
> }
> --- gcc/tree-vect-stmts.c.jj 2014-11-19 10:50:31.000000000 +0100
> +++ gcc/tree-vect-stmts.c 2014-11-19 11:18:16.389135912 +0100
> @@ -1333,8 +1333,7 @@ vect_init_vector (gimple stmt, tree val,
> {
> new_temp = make_ssa_name (TREE_TYPE (type), NULL);
> init_stmt = gimple_build_assign_with_ops (NOP_EXPR,
> - new_temp, val,
> - NULL_TREE);
> + new_temp, val);
> vect_init_vector_1 (stmt, init_stmt, gsi);
> val = new_temp;
> }
> @@ -1970,8 +1969,7 @@ vectorizable_mask_load_store (gimple stm
> var = make_ssa_name (var, NULL);
> op = build1 (VIEW_CONVERT_EXPR, idxtype, op);
> new_stmt
> - = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var,
> - op, NULL_TREE);
> + = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
> vect_finish_stmt_generation (stmt, new_stmt, gsi);
> op = var;
> }
> @@ -2001,7 +1999,7 @@ vectorizable_mask_load_store (gimple stm
> mask_op = build1 (VIEW_CONVERT_EXPR, masktype, mask_op);
> new_stmt
> = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var,
> - mask_op, NULL_TREE);
> + mask_op);
> vect_finish_stmt_generation (stmt, new_stmt, gsi);
> mask_op = var;
> }
> @@ -2022,8 +2020,7 @@ vectorizable_mask_load_store (gimple stm
> var = make_ssa_name (vec_dest, NULL);
> op = build1 (VIEW_CONVERT_EXPR, vectype, op);
> new_stmt
> - = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op,
> - NULL_TREE);
> + = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
> }
> else
> {
> @@ -3790,7 +3787,7 @@ vectorizable_conversion (gimple stmt, gi
> {
> gcc_assert (TREE_CODE_LENGTH (code1) == unary_op);
> new_stmt = gimple_build_assign_with_ops (code1, vec_dest,
> - vop0, NULL);
> + vop0);
> new_temp = make_ssa_name (vec_dest, new_stmt);
> gimple_assign_set_lhs (new_stmt, new_temp);
> }
> @@ -3902,8 +3899,7 @@ vectorizable_conversion (gimple stmt, gi
> gcc_assert (TREE_CODE_LENGTH (codecvt1) == unary_op);
> new_temp = make_ssa_name (vec_dest, NULL);
> new_stmt = gimple_build_assign_with_ops (codecvt1,
> - new_temp,
> - vop0, NULL);
> + new_temp, vop0);
> }
>
> vect_finish_stmt_generation (stmt, new_stmt, gsi);
> @@ -3960,7 +3956,7 @@ vectorizable_conversion (gimple stmt, gi
> gcc_assert (TREE_CODE_LENGTH (codecvt1) == unary_op);
> new_temp = make_ssa_name (vec_dest, NULL);
> new_stmt = gimple_build_assign_with_ops (codecvt1, new_temp,
> - vop0, NULL);
> + vop0);
> }
>
> vect_finish_stmt_generation (stmt, new_stmt, gsi);
> @@ -5958,8 +5954,7 @@ vectorizable_load (gimple stmt, gimple_s
> var = make_ssa_name (var, NULL);
> op = build1 (VIEW_CONVERT_EXPR, idxtype, op);
> new_stmt
> - = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var,
> - op, NULL_TREE);
> + = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
> vect_finish_stmt_generation (stmt, new_stmt, gsi);
> op = var;
> }
> @@ -5978,8 +5973,7 @@ vectorizable_load (gimple stmt, gimple_s
> var = make_ssa_name (vec_dest, NULL);
> op = build1 (VIEW_CONVERT_EXPR, vectype, op);
> new_stmt
> - = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op,
> - NULL_TREE);
> + = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
> }
> else
> {
> --- gcc/tree-ssa-reassoc.c.jj 2014-11-11 00:06:21.000000000 +0100
> +++ gcc/tree-ssa-reassoc.c 2014-11-19 11:10:22.486663750 +0100
> @@ -3307,7 +3307,7 @@ maybe_optimize_range_tests (gimple stmt)
> }
> else
> g = gimple_build_assign_with_ops (rhs_code, new_lhs,
> - new_op, NULL_TREE);
> + new_op);
> gimple_stmt_iterator gsi = gsi_for_stmt (cast_stmt);
> gimple_set_uid (g, gimple_uid (cast_stmt));
> gimple_set_visited (g, true);
> @@ -4214,10 +4214,11 @@ repropagate_negates (void)
> tree b = gimple_assign_rhs2 (user);
> 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)),
> NULL);
> + tree x = make_ssa_name (TREE_TYPE (gimple_assign_lhs (feed)),
> + NULL);
> gimple g = gimple_build_assign_with_ops (PLUS_EXPR, x, a, b);
> gsi_insert_before (&gsi2, g, GSI_SAME_STMT);
> - gimple_assign_set_rhs_with_ops (&gsi2, NEGATE_EXPR, x, NULL);
> + gimple_assign_set_rhs_with_ops (&gsi2, NEGATE_EXPR, x);
> user = gsi_stmt (gsi2);
> update_stmt (user);
> reassoc_remove_stmt (&gsi);
> --- gcc/ubsan.c.jj 2014-11-19 10:22:36.000000000 +0100
> +++ gcc/ubsan.c 2014-11-19 11:21:07.621054607 +0100
> @@ -736,8 +736,7 @@ ubsan_expand_null_ifn (gimple_stmt_itera
> if (compare_tree_int (align, ptralign) == 1)
> {
> check_align = make_ssa_name (pointer_sized_int_node, NULL);
> - g = gimple_build_assign_with_ops (NOP_EXPR, check_align,
> - ptr, NULL_TREE);
> + g = gimple_build_assign_with_ops (NOP_EXPR, check_align, ptr);
> gimple_set_location (g, loc);
> gsi_insert_before (&gsi, g, GSI_SAME_STMT);
> }
> @@ -934,7 +933,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, NULL);
> - g = gimple_build_assign_with_ops (NOP_EXPR, p, ptr, NULL_TREE);
> + g = gimple_build_assign_with_ops (NOP_EXPR, p, 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);
> @@ -1175,7 +1174,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, NULL_TREE);
> + g = gimple_build_assign_with_ops (NOP_EXPR, lhs, urhs);
> gimple_set_location (g, loc);
> edge e = find_fallthru_edge (gimple_bb (stmt)->succs);
> gsi_insert_on_edge_immediate (e, g);
> @@ -1213,7 +1212,7 @@ instrument_bool_enum_load (gimple_stmt_i
>
> if (!can_throw)
> {
> - gimple_assign_set_rhs_with_ops (&gsi2, NOP_EXPR, urhs, NULL_TREE);
> + gimple_assign_set_rhs_with_ops (&gsi2, NOP_EXPR, urhs);
> update_stmt (stmt);
> }
>
> --- gcc/tree-vect-loop.c.jj 2014-11-14 18:27:46.000000000 +0100
> +++ gcc/tree-vect-loop.c 2014-11-19 11:13:02.069792064 +0100
> @@ -2501,7 +2501,7 @@ vect_is_simple_reduction_1 (loop_vec_inf
> tree rhs = gimple_assign_rhs2 (def_stmt);
> tree negrhs = make_ssa_name (TREE_TYPE (rhs), NULL);
> gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
> - rhs, NULL);
> + 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));
> @@ -3379,7 +3379,7 @@ get_initial_def_for_induction (gimple iv
> 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), NULL_TREE);
> + 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),
> @@ -3555,7 +3555,7 @@ get_initial_def_for_induction (gimple iv
> vect_get_new_vect_var (resvectype, vect_simple_var,
> "vec_iv_"),
> build1 (VIEW_CONVERT_EXPR, resvectype,
> - gimple_assign_lhs (new_stmt)), NULL_TREE);
> + gimple_assign_lhs (new_stmt)));
> gimple_assign_set_lhs (new_stmt,
> make_ssa_name
> (gimple_assign_lhs (new_stmt),
> new_stmt));
> @@ -3622,7 +3622,7 @@ get_initial_def_for_induction (gimple iv
> 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), NULL_TREE);
> + 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);
> --- gcc/tree-ssa-math-opts.c.jj 2014-11-12 13:10:17.000000000 +0100
> +++ gcc/tree-ssa-math-opts.c 2014-11-19 11:08:43.533444405 +0100
> @@ -1129,7 +1129,7 @@ build_and_insert_cast (gimple_stmt_itera
> tree type, tree val)
> {
> tree result = make_ssa_name (type, NULL);
> - gimple stmt = gimple_build_assign_with_ops (NOP_EXPR, result, val,
> NULL_TREE);
> + gimple stmt = gimple_build_assign_with_ops (NOP_EXPR, result, val);
> gimple_set_location (stmt, loc);
> gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
> return result;
> @@ -2259,13 +2259,11 @@ bswap_replace (gimple cur_stmt, gimple s
> load_stmt = gimple_build_assign (val_tmp, val_expr);
> gimple_set_vuse (load_stmt, n->vuse);
> gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
> - gimple_assign_set_rhs_with_ops_1 (&gsi, NOP_EXPR, val_tmp,
> - NULL_TREE, NULL_TREE);
> + gimple_assign_set_rhs_with_ops (&gsi, NOP_EXPR, val_tmp);
> }
> else
> {
> - gimple_assign_set_rhs_with_ops_1 (&gsi, MEM_REF, val_expr,
> - NULL_TREE, NULL_TREE);
> + gimple_assign_set_rhs_with_ops (&gsi, MEM_REF, val_expr);
> gimple_set_vuse (cur_stmt, n->vuse);
> }
> update_stmt (cur_stmt);
> @@ -2319,8 +2317,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,
> - NULL);
> + convert_stmt = gimple_build_assign_with_ops (NOP_EXPR, tmp, src);
> gsi_insert_before (&gsi, convert_stmt, GSI_SAME_STMT);
> }
>
> @@ -2334,7 +2331,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, NULL);
> + convert_stmt = gimple_build_assign_with_ops (NOP_EXPR, tgt, tmp);
> gsi_insert_after (&gsi, convert_stmt, GSI_SAME_STMT);
> }
>
> @@ -2973,8 +2970,8 @@ convert_plusminus_to_widen (gimple_stmt_
> if (TREE_CODE (mult_rhs2) == INTEGER_CST)
> mult_rhs2 = fold_convert (type2, mult_rhs2);
>
> - gimple_assign_set_rhs_with_ops_1 (gsi, wmult_code, mult_rhs1, mult_rhs2,
> - add_rhs);
> + gimple_assign_set_rhs_with_ops (gsi, wmult_code, mult_rhs1, mult_rhs2,
> + add_rhs);
> update_stmt (gsi_stmt (*gsi));
> widen_mul_stats.maccs_inserted++;
> return true;
> @@ -3177,8 +3174,7 @@ convert_mult_to_fma (gimple mul_stmt, tr
>
> fma_stmt = gimple_build_assign_with_ops (FMA_EXPR,
> gimple_assign_lhs (use_stmt),
> - mulop1, op2,
> - addop);
> + mulop1, op2, addop);
> gsi_replace (&gsi, fma_stmt, true);
> widen_mul_stats.fmas_inserted++;
> }
> --- gcc/tree-loop-distribution.c.jj 2014-10-28 14:39:56.000000000 +0100
> +++ gcc/tree-loop-distribution.c 2014-11-19 11:06:07.496252282 +0100
> @@ -821,9 +821,8 @@ generate_memset_builtin (struct loop *lo
> val = fold_convert (integer_type_node, val);
> else if (!useless_type_conversion_p (integer_type_node, TREE_TYPE (val)))
> {
> - gimple cstmt;
> tree tem = make_ssa_name (integer_type_node, NULL);
> - cstmt = gimple_build_assign_with_ops (NOP_EXPR, tem, val, NULL_TREE);
> + gimple cstmt = gimple_build_assign_with_ops (NOP_EXPR, tem, val);
> gsi_insert_after (&gsi, cstmt, GSI_CONTINUE_LINKING);
> val = tem;
> }
> --- gcc/tree-vect-patterns.c.jj 2014-11-11 00:06:21.000000000 +0100
> +++ gcc/tree-vect-patterns.c 2014-11-19 11:16:05.138497757 +0100
> @@ -760,8 +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, NULL);
> - new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd, *oprnd,
> - NULL_TREE);
> + new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd, *oprnd);
> STMT_VINFO_RELATED_STMT (vinfo_for_stmt (def_stmt)) = new_stmt;
> stmts->safe_push (def_stmt);
> *oprnd = new_oprnd;
> @@ -935,7 +934,7 @@ vect_recog_widen_mult_pattern (vec<gimpl
> tree old_oprnd = gimple_assign_rhs1 (def_stmt);
> tree new_oprnd = make_ssa_name (half_type0, NULL);
> new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
> - old_oprnd, NULL_TREE);
> + old_oprnd);
> *oprnd = new_oprnd;
> }
>
> @@ -1032,8 +1031,7 @@ vect_recog_widen_mult_pattern (vec<gimpl
> pattern_stmt
> = gimple_build_assign_with_ops (NOP_EXPR,
> vect_recog_temp_ssa_var (type, NULL),
> - gimple_assign_lhs (pattern_stmt),
> - NULL_TREE);
> + gimple_assign_lhs (pattern_stmt));
> }
>
> if (dump_enabled_p ())
> @@ -1443,7 +1441,7 @@ vect_operation_fits_smaller_type (gimple
> oprnd = gimple_assign_rhs1 (def_stmt);
> new_oprnd = make_ssa_name (interm_type, NULL);
> new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
> - oprnd, NULL_TREE);
> + oprnd);
> STMT_VINFO_RELATED_STMT (vinfo_for_stmt (def_stmt)) = new_stmt;
> stmts->safe_push (def_stmt);
> oprnd = new_oprnd;
> @@ -1462,7 +1460,7 @@ vect_operation_fits_smaller_type (gimple
> /* Create a type conversion HALF_TYPE->INTERM_TYPE. */
> new_oprnd = make_ssa_name (interm_type, NULL);
> new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
> - oprnd, NULL_TREE);
> + oprnd);
> oprnd = new_oprnd;
> *new_def_stmt = new_stmt;
> }
> @@ -1594,7 +1592,7 @@ vect_recog_over_widening_pattern (vec<gi
> /* Create NEW_TYPE->USE_TYPE conversion. */
> new_oprnd = make_ssa_name (use_type, NULL);
> pattern_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
> - var, NULL_TREE);
> + var);
> STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use_stmt)) = pattern_stmt;
>
> *type_in = get_vectype_for_scalar_type (new_type);
> @@ -1946,8 +1944,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,
> - NULL_TREE);
> + def_stmt = gimple_build_assign_with_ops (NOP_EXPR, def, oprnd1);
> if (ext_def)
> {
> basic_block new_bb
> @@ -1977,8 +1974,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,
> - NULL_TREE);
> + def_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, def2, def);
> if (ext_def)
> {
> basic_block new_bb
> @@ -2151,8 +2147,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,
> - NULL_TREE);
> + def_stmt = gimple_build_assign_with_ops (NOP_EXPR, def, oprnd1);
> new_pattern_def_seq (stmt_vinfo, def_stmt);
> }
>
> @@ -2350,8 +2345,7 @@ 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,
> - NULL_TREE);
> + = gimple_build_assign_with_ops (NOP_EXPR, signmask, var);
> append_pattern_def_seq (stmt_vinfo, def_stmt);
> }
> def_stmt
> @@ -2613,8 +2607,7 @@ vect_recog_divmod_pattern (vec<gimple> *
> if (msb != 1)
> def_stmt
> = gimple_build_assign_with_ops (INTEGER_CST,
> - t4, build_int_cst (itype, msb),
> - NULL_TREE);
> + t4, build_int_cst (itype, msb));
> else
> def_stmt
> = gimple_build_assign_with_ops (RSHIFT_EXPR, t4, oprnd0,
> @@ -2809,7 +2802,7 @@ vect_recog_mixed_size_cond_pattern (vec<
> pattern_stmt
> = gimple_build_assign_with_ops (NOP_EXPR,
> vect_recog_temp_ssa_var (type, NULL),
> - gimple_assign_lhs (def_stmt), NULL_TREE);
> + 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);
> @@ -2923,8 +2916,7 @@ adjust_bool_pattern_cast (tree type, tre
> cast_stmt
> = gimple_build_assign_with_ops (NOP_EXPR,
> vect_recog_temp_ssa_var (type, NULL),
> - gimple_assign_lhs (pattern_stmt),
> - NULL_TREE);
> + gimple_assign_lhs (pattern_stmt));
> STMT_VINFO_RELATED_STMT (stmt_vinfo) = cast_stmt;
> return gimple_assign_lhs (cast_stmt);
> }
> @@ -2961,7 +2953,7 @@ adjust_bool_pattern (tree var, tree out_
> pattern_stmt
> = gimple_build_assign_with_ops (SSA_NAME,
> vect_recog_temp_ssa_var (itype, NULL),
> - irhs1, NULL_TREE);
> + irhs1);
> break;
>
> case BIT_NOT_EXPR:
> @@ -3209,10 +3201,10 @@ vect_recog_bool_pattern (vec<gimple> *st
> 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, NULL_TREE);
> + = gimple_build_assign_with_ops (SSA_NAME, lhs, rhs);
> else
> pattern_stmt
> - = gimple_build_assign_with_ops (NOP_EXPR, lhs, rhs, NULL_TREE);
> + = gimple_build_assign_with_ops (NOP_EXPR, lhs, rhs);
> *type_out = vectype;
> *type_in = vectype;
> stmts->safe_push (last_stmt);
> @@ -3278,12 +3270,12 @@ vect_recog_bool_pattern (vec<gimple> *st
> {
> tree rhs2 = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
> gimple cast_stmt
> - = gimple_build_assign_with_ops (NOP_EXPR, rhs2, rhs, NULL_TREE);
> + = gimple_build_assign_with_ops (NOP_EXPR, rhs2, rhs);
> new_pattern_def_seq (stmt_vinfo, cast_stmt);
> rhs = rhs2;
> }
> pattern_stmt
> - = gimple_build_assign_with_ops (SSA_NAME, lhs, rhs, NULL_TREE);
> + = gimple_build_assign_with_ops (SSA_NAME, lhs, rhs);
> pattern_stmt_info = new_stmt_vec_info (pattern_stmt, loop_vinfo,
> bb_vinfo);
> set_vinfo_for_stmt (pattern_stmt, pattern_stmt_info);
> --- gcc/tree-ssa-phiopt.c.jj 2014-11-13 12:50:47.000000000 +0100
> +++ gcc/tree-ssa-phiopt.c 2014-11-19 11:09:33.025553799 +0100
> @@ -536,7 +536,7 @@ conditional_replacement (basic_block con
>
> new_var2 = make_ssa_name (TREE_TYPE (result), NULL);
> new_stmt = gimple_build_assign_with_ops (CONVERT_EXPR, new_var2,
> - new_var, NULL);
> + new_var);
> gsi_insert_before (&gsi, new_stmt, GSI_SAME_STMT);
> new_var = new_var2;
>
> @@ -1254,7 +1254,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, NULL);
> + new_stmt = gimple_build_assign_with_ops (ABS_EXPR, lhs, rhs);
>
> gsi = gsi_last_bb (cond_bb);
> gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
> @@ -1264,7 +1264,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,
> NULL);
> + new_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, result, lhs);
>
> gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
> }
> @@ -1388,12 +1388,12 @@ neg_replacement (basic_block cond_bb, ba
> logical and arithmetic operations on it. */
> tree cond_val_converted = make_ssa_name (TREE_TYPE (rhs), NULL);
> new_stmt = gimple_build_assign_with_ops (NOP_EXPR, cond_val_converted,
> - cond_val, NULL_TREE);
> + cond_val);
> gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
>
> tree neg_cond_val_converted = make_ssa_name (TREE_TYPE (rhs), NULL);
> new_stmt = gimple_build_assign_with_ops (NEGATE_EXPR,
> neg_cond_val_converted,
> - cond_val_converted, NULL_TREE);
> + cond_val_converted);
> gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
>
> tree tmp = make_ssa_name (TREE_TYPE (rhs), NULL);
> --- gcc/asan.c.jj 2014-11-18 23:10:56.000000000 +0100
> +++ gcc/asan.c 2014-11-19 10:59:53.002995844 +0100
> @@ -1599,15 +1599,14 @@ build_shadow_mem_access (gimple_stmt_ite
>
> g = gimple_build_assign_with_ops (NOP_EXPR,
> make_ssa_name (shadow_ptr_type, NULL),
> - gimple_assign_lhs (g), NULL_TREE);
> + 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, NULL),
> - t, NULL_TREE);
> + make_ssa_name (shadow_type, NULL), t);
> gimple_set_location (g, location);
> gsi_insert_after (gsi, g, GSI_NEW_STMT);
> return gimple_assign_lhs (g);
> @@ -1625,7 +1624,7 @@ maybe_create_ssa_name (location_t loc, t
> gimple g
> = gimple_build_assign_with_ops (TREE_CODE (base),
> make_ssa_name (TREE_TYPE (base), NULL),
> - base, NULL_TREE);
> + base);
> gimple_set_location (g, loc);
> if (before_p)
> gsi_insert_before (iter, g, GSI_SAME_STMT);
> @@ -1645,8 +1644,8 @@ maybe_cast_to_ptrmode (location_t loc, t
> return len;
> gimple g
> = gimple_build_assign_with_ops (NOP_EXPR,
> - make_ssa_name (pointer_sized_int_node,
> NULL),
> - len, NULL);
> + make_ssa_name (pointer_sized_int_node,
> + NULL), len);
> gimple_set_location (g, loc);
> if (before_p)
> gsi_insert_before (iter, g, GSI_SAME_STMT);
> @@ -2536,8 +2535,7 @@ asan_expand_check_ifn (gimple_stmt_itera
> gimple g
> = gimple_build_assign_with_ops (NOP_EXPR,
> make_ssa_name (pointer_sized_int_node,
> - NULL),
> - base, NULL_TREE);
> + NULL), base);
> gimple_set_location (g, loc);
> gsi_insert_before (iter, g, GSI_SAME_STMT);
> tree base_addr = gimple_assign_lhs (g);
> @@ -2551,8 +2549,7 @@ asan_expand_check_ifn (gimple_stmt_itera
> gcc_assert (nargs == 2);
> g = gimple_build_assign_with_ops (NOP_EXPR,
> make_ssa_name
> (pointer_sized_int_node,
> - NULL),
> - len, NULL_TREE);
> + NULL), len);
> gimple_set_location (g, loc);
> gsi_insert_before (iter, g, GSI_SAME_STMT);
> tree sz_arg = gimple_assign_lhs (g);
> @@ -2610,8 +2607,7 @@ asan_expand_check_ifn (gimple_stmt_itera
>
> g = gimple_build_assign_with_ops (NOP_EXPR,
> make_ssa_name (pointer_sized_int_node,
> - NULL),
> - base, NULL_TREE);
> + NULL), base);
> gimple_set_location (g, loc);
> gsi_insert_before (&gsi, g, GSI_NEW_STMT);
> tree base_addr = gimple_assign_lhs (g);
> --- gcc/tree-vect-slp.c.jj 2014-11-11 00:06:25.000000000 +0100
> +++ gcc/tree-vect-slp.c 2014-11-19 11:16:29.618057250 +0100
> @@ -2609,7 +2609,7 @@ vect_get_constant_vectors (tree op, slp_
> op);
> init_stmt
> = gimple_build_assign_with_ops (VIEW_CONVERT_EXPR,
> - new_temp, op, NULL_TREE);
> + new_temp, op);
> gimple_seq_add_stmt (&ctor_seq, init_stmt);
> op = new_temp;
> }
> --- gcc/omp-low.c.jj 2014-11-19 10:48:20.000000000 +0100
> +++ gcc/omp-low.c 2014-11-19 11:04:41.052808846 +0100
> @@ -3839,8 +3839,7 @@ lower_rec_input_clauses (tree clauses, g
> 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),
> - NULL_TREE);
> + build_int_cst (unsigned_type_node, 0));
> gimple_seq_add_stmt (ilist, g);
> for (int i = 0; i < 2; i++)
> if (llist[i])
> @@ -3851,7 +3850,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, NULL_TREE);
> + g = gimple_build_assign_with_ops (INTEGER_CST, idx, t);
> gimple_seq_add_stmt (seq, g);
> tree body = create_artificial_label (UNKNOWN_LOCATION);
> tree header = create_artificial_label (UNKNOWN_LOCATION);
> @@ -5845,8 +5844,7 @@ expand_omp_for_generic (struct omp_regio
> if (useless_type_conversion_p (TREE_TYPE (fd->loop.v), TREE_TYPE
> (iend)))
> stmt = gimple_build_assign (fd->loop.v, iend);
> else
> - stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, iend,
> - NULL_TREE);
> + stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, iend);
> gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
> }
> if (fd->collapse > 1)
> @@ -6266,8 +6264,7 @@ expand_omp_for_static_nochunk (struct om
> if (useless_type_conversion_p (TREE_TYPE (fd->loop.v), TREE_TYPE (e)))
> stmt = gimple_build_assign (fd->loop.v, e);
> else
> - stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, e,
> - NULL_TREE);
> + stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, e);
> gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
> }
> if (fd->collapse > 1)
> @@ -6657,8 +6654,7 @@ expand_omp_for_static_chunk (struct omp_
> if (useless_type_conversion_p (TREE_TYPE (fd->loop.v), TREE_TYPE (e)))
> stmt = gimple_build_assign (fd->loop.v, e);
> else
> - stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, e,
> - NULL_TREE);
> + stmt = gimple_build_assign_with_ops (NOP_EXPR, fd->loop.v, e);
> gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
> }
> if (fd->collapse > 1)
> @@ -12198,8 +12194,7 @@ simd_clone_adjust (struct cgraph_node *n
> {
> t = make_ssa_name (orig_arg, NULL);
> g = gimple_build_assign_with_ops (NOP_EXPR, t,
> - gimple_call_lhs (g),
> - NULL_TREE);
> + gimple_call_lhs (g));
> gimple_seq_add_stmt_without_update (&seq, g);
> }
> gsi_insert_seq_on_edge_immediate
> --- gcc/tree-ssa-strlen.c.jj 2014-11-18 08:26:38.000000000 +0100
> +++ gcc/tree-ssa-strlen.c 2014-11-19 11:10:51.596139927 +0100
> @@ -1816,7 +1816,7 @@ handle_pointer_plus (gimple_stmt_iterato
> enum tree_code rhs_code
> = useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (si->endptr))
> ? SSA_NAME : NOP_EXPR;
> - gimple_assign_set_rhs_with_ops (gsi, rhs_code, si->endptr, NULL_TREE);
> + gimple_assign_set_rhs_with_ops (gsi, rhs_code, si->endptr);
> gcc_assert (gsi_stmt (*gsi) == stmt);
> update_stmt (stmt);
> }
> --- gcc/gimple-fold.c.jj 2014-11-14 15:11:49.000000000 +0100
> +++ gcc/gimple-fold.c 2014-11-19 11:01:57.211759180 +0100
> @@ -2962,8 +2962,7 @@ replace_stmt_with_simplification (gimple
> maybe_build_generic_op (rcode,
> TREE_TYPE (gimple_assign_lhs (stmt)),
> &ops[0], ops[1], ops[2]);
> - gimple_assign_set_rhs_with_ops_1 (gsi, rcode,
> - ops[0], ops[1], ops[2]);
> + gimple_assign_set_rhs_with_ops (gsi, rcode, ops[0], ops[1], ops[2]);
> if (dump_file && (dump_flags & TDF_DETAILS))
> {
> fprintf (dump_file, "gimple_simplified to ");
> @@ -5623,8 +5622,8 @@ 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), NULL_TREE);
> + gimple cvt = gimple_build_assign_with_ops (NOP_EXPR, lhs,
> + gimple_assign_lhs (stmt));
> gimple_seq_add_stmt (&stmts, cvt);
>
> return stmts;
> @@ -5654,10 +5653,9 @@ gimple_build (gimple_seq *seq, location_
> || code == IMAGPART_EXPR
> || code == VIEW_CONVERT_EXPR)
> stmt = gimple_build_assign_with_ops (code, res,
> - build1 (code, type,
> - op0), NULL_TREE);
> + build1 (code, type, op0));
> else
> - stmt = gimple_build_assign_with_ops (code, res, op0, NULL_TREE);
> + stmt = gimple_build_assign_with_ops (code, res, op0);
> gimple_set_location (stmt, loc);
> gimple_seq_add_stmt_without_update (seq, stmt);
> }
> @@ -5712,8 +5710,7 @@ gimple_build (gimple_seq *seq, location_
> if (code == BIT_FIELD_REF)
> stmt = gimple_build_assign_with_ops (code, res,
> build3 (BIT_FIELD_REF, type,
> - op0, op1, op2),
> - NULL_TREE);
> + op0, op1, op2));
> else
> stmt = gimple_build_assign_with_ops (code, res, op0, op1, op2);
> gimple_set_location (stmt, loc);
> --- gcc/tree-vect-loop-manip.c.jj 2014-10-28 14:40:00.000000000 +0100
> +++ gcc/tree-vect-loop-manip.c 2014-11-19 11:13:22.357426990 +0100
> @@ -2157,7 +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, NULL_TREE);
> + addr_base);
> gimple_seq_add_stmt (cond_expr_stmt_list, addr_stmt);
>
> /* The addresses are OR together. */
> --- gcc/gimple-ssa-strength-reduction.c.jj 2014-11-11 00:06:18.000000000
> +0100
> +++ gcc/gimple-ssa-strength-reduction.c 2014-11-19 11:03:10.675436298
> +0100
> @@ -3261,8 +3261,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, NULL_TREE);
> + cast_stmt = gimple_build_assign_with_ops (NOP_EXPR, cast_lhs, from_expr);
> gimple_set_location (cast_stmt, gimple_location (c->cand_stmt));
> gsi_insert_before (&gsi, cast_stmt, GSI_SAME_STMT);
>
> @@ -3432,8 +3431,7 @@ replace_one_candidate (slsr_cand_t c, un
> {
> gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt);
> gimple cast_stmt = gimple_build_assign_with_ops (NOP_EXPR, lhs,
> - basis_name,
> - NULL_TREE);
> + basis_name);
> gimple_set_location (cast_stmt, gimple_location (c->cand_stmt));
> gsi_replace (&gsi, cast_stmt, false);
> c->cand_stmt = cast_stmt;
> --- gcc/gimple-builder.c.jj 2014-10-28 14:40:20.000000000 +0100
> +++ gcc/gimple-builder.c 2014-11-19 11:00:26.613390612 +0100
> @@ -120,7 +120,7 @@ build_type_cast (tree to_type, tree op,
> {
> if (lhs == NULL_TREE)
> lhs = make_ssa_name (to_type, NULL);
> - return gimple_build_assign_with_ops (NOP_EXPR, lhs, op, NULL_TREE);
> + return gimple_build_assign_with_ops (NOP_EXPR, lhs, op);
> }
>
> gimple
> --- gcc/tree-vrp.c.jj 2014-11-14 15:11:48.000000000 +0100
> +++ gcc/tree-vrp.c 2014-11-19 11:19:55.120359252 +0100
> @@ -8879,15 +8879,14 @@ simplify_truth_ops_using_ranges (gimple_
> if (integer_zerop (op1))
> gimple_assign_set_rhs_with_ops (gsi,
> need_conversion
> - ? NOP_EXPR : TREE_CODE (op0),
> - op0, NULL_TREE);
> + ? NOP_EXPR : TREE_CODE (op0), op0);
> /* For A != B we substitute A ^ B. Either with conversion. */
> else if (need_conversion)
> {
> tree tem = make_ssa_name (TREE_TYPE (op0), NULL);
> gimple newop = gimple_build_assign_with_ops (BIT_XOR_EXPR, tem, op0,
> op1);
> gsi_insert_before (gsi, newop, GSI_SAME_STMT);
> - gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem, NULL_TREE);
> + gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem);
> }
> /* Or without. */
> else
> @@ -9107,7 +9106,7 @@ simplify_bit_ops_using_ranges (gimple_st
> if (op == NULL_TREE)
> return false;
>
> - gimple_assign_set_rhs_with_ops (gsi, TREE_CODE (op), op, NULL);
> + gimple_assign_set_rhs_with_ops (gsi, TREE_CODE (op), op);
> update_stmt (gsi_stmt (*gsi));
> return true;
> }
> @@ -9611,7 +9610,7 @@ simplify_float_conversion_using_ranges (
> float conversion. */
> tem = make_ssa_name (build_nonstandard_integer_type
> (GET_MODE_PRECISION (mode), 0), NULL);
> - conv = gimple_build_assign_with_ops (NOP_EXPR, tem, rhs1, NULL_TREE);
> + conv = gimple_build_assign_with_ops (NOP_EXPR, tem, rhs1);
> gsi_insert_before (gsi, conv, GSI_SAME_STMT);
> gimple_assign_set_rhs1 (stmt, tem);
> update_stmt (stmt);
> @@ -9685,8 +9684,7 @@ simplify_internal_call_using_ranges (gim
> else if (!useless_type_conversion_p (utype, TREE_TYPE (op0)))
> {
> g = gimple_build_assign_with_ops (NOP_EXPR,
> - make_ssa_name (utype, NULL),
> - op0, NULL_TREE);
> + make_ssa_name (utype, NULL), op0);
> gimple_set_location (g, loc);
> gsi_insert_before (gsi, g, GSI_SAME_STMT);
> op0 = gimple_assign_lhs (g);
> @@ -9696,8 +9694,7 @@ simplify_internal_call_using_ranges (gim
> else if (!useless_type_conversion_p (utype, TREE_TYPE (op1)))
> {
> g = gimple_build_assign_with_ops (NOP_EXPR,
> - make_ssa_name (utype, NULL),
> - op1, NULL_TREE);
> + make_ssa_name (utype, NULL), op1);
> gimple_set_location (g, loc);
> gsi_insert_before (gsi, g, GSI_SAME_STMT);
> op1 = gimple_assign_lhs (g);
> @@ -9710,7 +9707,7 @@ simplify_internal_call_using_ranges (gim
> {
> g = gimple_build_assign_with_ops (NOP_EXPR,
> make_ssa_name (type, NULL),
> - gimple_assign_lhs (g), NULL_TREE);
> + gimple_assign_lhs (g));
> gimple_set_location (g, loc);
> gsi_insert_before (gsi, g, GSI_SAME_STMT);
> }
>
> 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
