Rename gimple_build_assign_with_ops to gimple_build_assign and swap the first two arguments of it

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?

2014-12-01  Jakub Jelinek  <jakub@redhat.com>

	* gimple.h (gimple_build_assign_stat): Remove prototype.
	(gimple_build_assign): Remove define.  Add overload prototypes
	with tree lhs and either a tree rhs, or enum tree_code and
	1, 2 or 3 tree operands.
	* gimple.c (gimple_build_assign_stat): Renamed to...
	(gimple_build_assign): ... this.  Add overloads with
	enum tree_code and 1, 2 or 3 tree operands.
	(gimple_build_assign_with_ops): Remove 1 and 2 operand overloads.
	Rename the 3 operand overload to ...
	(gimple_build_assign_1): ... this.  Make it static inline.
	* tree-ssa-strlen.c (get_string_length): Use gimple_build_assign
	instead of gimple_build_assign_with_ops, swap the order of first
	two arguments and adjust formatting where necessary.
	* tree-vect-slp.c (vect_get_constant_vectors,
	vect_create_mask_and_perm): Likewise.
	* tree-ssa-forwprop.c (simplify_rotate): Likewise.
	* asan.c (build_shadow_mem_access, maybe_create_ssa_name,
	maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
	* tsan.c (instrument_builtin_call): Likewise.
	* tree-chkp.c (chkp_compute_bounds_for_assignment,
	chkp_generate_extern_var_bounds): Likewise.
	* tree-loop-distribution.c (generate_memset_builtin): Likewise.
	* tree-ssa-loop-im.c (rewrite_reciprocal): Likewise.
	* gimple-builder.c (build_assign, build_type_cast): Likewise.
	* tree-vect-loop-manip.c (vect_create_cond_for_align_checks): Likewise.
	* value-prof.c (gimple_divmod_fixed_value, gimple_mod_pow2,
	gimple_mod_subtract): Likewise.
	* gimple-match-head.c (maybe_push_res_to_seq): Likewise.
	* tree-vect-patterns.c (vect_recog_dot_prod_pattern,
	vect_recog_sad_pattern, vect_handle_widen_op_by_const,
	vect_recog_widen_mult_pattern, vect_recog_pow_pattern,
	vect_recog_widen_sum_pattern, vect_operation_fits_smaller_type,
	vect_recog_over_widening_pattern, vect_recog_widen_shift_pattern,
	vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern,
	vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern,
	adjust_bool_pattern_cast, adjust_bool_pattern,
	vect_recog_bool_pattern): Likewise.
	* gimple-ssa-strength-reduction.c (create_add_on_incoming_edge,
	insert_initializers, introduce_cast_before_cand,
	replace_one_candidate): Likewise.
	* tree-ssa-math-opts.c (insert_reciprocals, powi_as_mults_1,
	powi_as_mults, build_and_insert_binop, build_and_insert_cast,
	pass_cse_sincos::execute, bswap_replace, convert_mult_to_fma):
	Likewise.
	* tree-tailcall.c (adjust_return_value_with_ops,
	update_accumulator_with_ops): Likewise.
	* tree-predcom.c (reassociate_to_the_same_stmt): Likewise.
	* tree-ssa-reassoc.c (build_and_add_sum,
	optimize_range_tests_to_bit_test, update_ops,
	maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr,
	negate_value, repropagate_negates, attempt_builtin_powi,
	reassociate_bb): Likewise.
	* tree-vect-loop.c (vect_is_simple_reduction_1,
	get_initial_def_for_induction, vect_create_epilog_for_reduction):
	Likewise.
	* ipa-split.c (split_function): Likewise.
	* tree-ssa-phiopt.c (conditional_replacement, minmax_replacement,
	abs_replacement, neg_replacement): Likewise.
	* tree-profile.c (gimple_gen_edge_profiler): Likewise.
	* tree-vrp.c (simplify_truth_ops_using_ranges,
	simplify_float_conversion_using_ranges,
	simplify_internal_call_using_ranges): Likewise.
	* gimple-fold.c (rewrite_to_defined_overflow, gimple_build): Likewise.
	* tree-vect-generic.c (expand_vector_divmod,
	optimize_vector_constructor): Likewise.
	* ubsan.c (ubsan_expand_null_ifn, ubsan_expand_objsize_ifn,
	instrument_bool_enum_load): Likewise.
	* tree-ssa-loop-manip.c (create_iv): Likewise.
	* omp-low.c (lower_rec_input_clauses, expand_omp_for_generic,
	expand_omp_for_static_nochunk, expand_omp_for_static_chunk,
	expand_cilk_for, simd_clone_adjust): Likewise.
	* trans-mem.c (expand_transaction): Likewise.
	* tree-vect-data-refs.c (bump_vector_ptr, vect_permute_store_chain,
	vect_setup_realignment, vect_permute_load_chain,
	vect_shift_permute_load_chain): Likewise.
	* tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
	vectorizable_simd_clone_call, vect_gen_widened_results_half,
	vect_create_vectorized_demotion_stmts, vectorizable_conversion,
	vectorizable_shift, vectorizable_operation, vectorizable_store,
	permute_vec_elements, vectorizable_load): Likewise.



	Jakub

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  <jakub@redhat.com>
> 
> 	* gimple.h (gimple_build_assign_stat): Remove prototype.
> 	(gimple_build_assign): Remove define.  Add overload prototypes
> 	with tree lhs and either a tree rhs, or enum tree_code and
> 	1, 2 or 3 tree operands.
> 	* gimple.c (gimple_build_assign_stat): Renamed to...
> 	(gimple_build_assign): ... this.  Add overloads with
> 	enum tree_code and 1, 2 or 3 tree operands.
> 	(gimple_build_assign_with_ops): Remove 1 and 2 operand overloads.
> 	Rename the 3 operand overload to ...
> 	(gimple_build_assign_1): ... this.  Make it static inline.
> 	* tree-ssa-strlen.c (get_string_length): Use gimple_build_assign
> 	instead of gimple_build_assign_with_ops, swap the order of first
> 	two arguments and adjust formatting where necessary.
> 	* tree-vect-slp.c (vect_get_constant_vectors,
> 	vect_create_mask_and_perm): Likewise.
> 	* tree-ssa-forwprop.c (simplify_rotate): Likewise.
> 	* asan.c (build_shadow_mem_access, maybe_create_ssa_name,
> 	maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
> 	* tsan.c (instrument_builtin_call): Likewise.
> 	* tree-chkp.c (chkp_compute_bounds_for_assignment,
> 	chkp_generate_extern_var_bounds): Likewise.
> 	* tree-loop-distribution.c (generate_memset_builtin): Likewise.
> 	* tree-ssa-loop-im.c (rewrite_reciprocal): Likewise.
> 	* gimple-builder.c (build_assign, build_type_cast): Likewise.
> 	* tree-vect-loop-manip.c (vect_create_cond_for_align_checks): Likewise.
> 	* value-prof.c (gimple_divmod_fixed_value, gimple_mod_pow2,
> 	gimple_mod_subtract): Likewise.
> 	* gimple-match-head.c (maybe_push_res_to_seq): Likewise.
> 	* tree-vect-patterns.c (vect_recog_dot_prod_pattern,
> 	vect_recog_sad_pattern, vect_handle_widen_op_by_const,
> 	vect_recog_widen_mult_pattern, vect_recog_pow_pattern,
> 	vect_recog_widen_sum_pattern, vect_operation_fits_smaller_type,
> 	vect_recog_over_widening_pattern, vect_recog_widen_shift_pattern,
> 	vect_recog_rotate_pattern, vect_recog_vector_vector_shift_pattern,
> 	vect_recog_divmod_pattern, vect_recog_mixed_size_cond_pattern,
> 	adjust_bool_pattern_cast, adjust_bool_pattern,
> 	vect_recog_bool_pattern): Likewise.
> 	* gimple-ssa-strength-reduction.c (create_add_on_incoming_edge,
> 	insert_initializers, introduce_cast_before_cand,
> 	replace_one_candidate): Likewise.
> 	* tree-ssa-math-opts.c (insert_reciprocals, powi_as_mults_1,
> 	powi_as_mults, build_and_insert_binop, build_and_insert_cast,
> 	pass_cse_sincos::execute, bswap_replace, convert_mult_to_fma):
> 	Likewise.
> 	* tree-tailcall.c (adjust_return_value_with_ops,
> 	update_accumulator_with_ops): Likewise.
> 	* tree-predcom.c (reassociate_to_the_same_stmt): Likewise.
> 	* tree-ssa-reassoc.c (build_and_add_sum,
> 	optimize_range_tests_to_bit_test, update_ops,
> 	maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr,
> 	negate_value, repropagate_negates, attempt_builtin_powi,
> 	reassociate_bb): Likewise.
> 	* tree-vect-loop.c (vect_is_simple_reduction_1,
> 	get_initial_def_for_induction, vect_create_epilog_for_reduction):
> 	Likewise.
> 	* ipa-split.c (split_function): Likewise.
> 	* tree-ssa-phiopt.c (conditional_replacement, minmax_replacement,
> 	abs_replacement, neg_replacement): Likewise.
> 	* tree-profile.c (gimple_gen_edge_profiler): Likewise.
> 	* tree-vrp.c (simplify_truth_ops_using_ranges,
> 	simplify_float_conversion_using_ranges,
> 	simplify_internal_call_using_ranges): Likewise.
> 	* gimple-fold.c (rewrite_to_defined_overflow, gimple_build): Likewise.
> 	* tree-vect-generic.c (expand_vector_divmod,
> 	optimize_vector_constructor): Likewise.
> 	* ubsan.c (ubsan_expand_null_ifn, ubsan_expand_objsize_ifn,
> 	instrument_bool_enum_load): Likewise.
> 	* tree-ssa-loop-manip.c (create_iv): Likewise.
> 	* omp-low.c (lower_rec_input_clauses, expand_omp_for_generic,
> 	expand_omp_for_static_nochunk, expand_omp_for_static_chunk,
> 	expand_cilk_for, simd_clone_adjust): Likewise.
> 	* trans-mem.c (expand_transaction): Likewise.
> 	* tree-vect-data-refs.c (bump_vector_ptr, vect_permute_store_chain,
> 	vect_setup_realignment, vect_permute_load_chain,
> 	vect_shift_permute_load_chain): Likewise.
> 	* tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
> 	vectorizable_simd_clone_call, vect_gen_widened_results_half,
> 	vect_create_vectorized_demotion_stmts, vectorizable_conversion,
> 	vectorizable_shift, vectorizable_operation, vectorizable_store,
> 	permute_vec_elements, vectorizable_load): Likewise.
> 
> --- 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
> 
>

On Mon, 2014-12-01 14:52:05 +0100, Jakub Jelinek <jakub@redhat.com> 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?

Seems this caused some fallout for aarch64_be-elf, see eg.
http://toolchain.lug-owl.de/buildbot/show_build_details.php?id=380617 :

g++ -c   -g -O2 -DIN_GCC  -DCROSS_DIRECTORY_STRUCTURE  -fno-exceptions -fno-rtti -fasynchronous-unwind-tables -W -Wall -Wwrite-strings -Wcast-qual -Wmissing-format-attribute -Woverloaded-virtual -pedantic -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fno-common  -DHAVE_CONFIG_H -I. -I. -I/home/jbglaw/repos/gcc/gcc -I/home/jbglaw/repos/gcc/gcc/. -I/home/jbglaw/repos/gcc/gcc/../include -I/home/jbglaw/repos/gcc/gcc/../libcpp/include -I/opt/cfarm/gmp-latest/include -I/opt/cfarm/mpfr-latest/include -I/opt/cfarm/mpc-latest/include  -I/home/jbglaw/repos/gcc/gcc/../libdecnumber -I/home/jbglaw/repos/gcc/gcc/../libdecnumber/dpd -I../libdecnumber -I/home/jbglaw/repos/gcc/gcc/../libbacktrace    -o aarch64.o -MT aarch64.o -MMD -MP -MF ./.deps/aarch64.TPo /home/jbglaw/repos/gcc/gcc/config/aarch64/aarch64.c
/home/jbglaw/repos/gcc/gcc/wide-int.h: In function ‘bool aarch64_float_const_representable_p(rtx_def*)’:
/home/jbglaw/repos/gcc/gcc/wide-int.h:798: warning: array subscript is above array bounds
/bin/bash /home/jbglaw/repos/gcc/gcc/config/aarch64/geniterators.sh \
/home/jbglaw/repos/gcc/gcc/config/aarch64/iterators.md > \
aarch64-builtin-iterators.h
g++ -c   -g -O2 -DIN_GCC  -DCROSS_DIRECTORY_STRUCTURE  -fno-exceptions -fno-rtti -fasynchronous-unwind-tables -W -Wall -Wwrite-strings -Wcast-qual -Wmissing-format-attribute -Woverloaded-virtual -pedantic -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fno-common  -DHAVE_CONFIG_H -I. -I. -I/home/jbglaw/repos/gcc/gcc -I/home/jbglaw/repos/gcc/gcc/. -I/home/jbglaw/repos/gcc/gcc/../include -I/home/jbglaw/repos/gcc/gcc/../libcpp/include -I/opt/cfarm/gmp-latest/include -I/opt/cfarm/mpfr-latest/include -I/opt/cfarm/mpc-latest/include  -I/home/jbglaw/repos/gcc/gcc/../libdecnumber -I/home/jbglaw/repos/gcc/gcc/../libdecnumber/dpd -I../libdecnumber -I/home/jbglaw/repos/gcc/gcc/../libbacktrace    -I. -I. -I/home/jbglaw/repos/gcc/gcc -I/home/jbglaw/repos/gcc/gcc/. -I/home/jbglaw/repos/gcc/gcc/../include -I/home/jbglaw/repos/gcc/gcc/../libcpp/include -I/opt/cfarm/gmp-latest/include -I/opt/cfarm/mpfr-latest/include -I/opt/cfarm/mpc-latest/include  -I/home/jbglaw/repos/gcc/gcc/../libdecnumber -I/home/jbglaw/repos/gcc/gcc/../libdecnumber/dpd -I../libdecnumber -I/home/jbglaw/repos/gcc/gcc/../libbacktrace   \
/home/jbglaw/repos/gcc/gcc/config/aarch64/aarch64-builtins.c
/home/jbglaw/repos/gcc/gcc/config/aarch64/aarch64-builtins.c: In function ‘bool aarch64_gimple_fold_builtin(gimple_stmt_iterator*)’:
/home/jbglaw/repos/gcc/gcc/config/aarch64/aarch64-builtins.c:1329: error: ‘gimple_build_assign_with_ops’ was not declared in this scope
make[1]: *** [aarch64-builtins.o] Error 1
make[1]: Leaving directory `/home/jbglaw/build/aarch64_be-elf/build-gcc/gcc'
make: *** [all-gcc] Error 2



MfG, JBG

The following patch implements that.  Bootstrapped/regtested on x86_64-linux
and i686-linux, ok for trunk?

Our aarch64 build also breaks as mentioned in https://gcc.gnu.org/ml/gcc-patches/2014-12/msg00119.html

Regards
Ganesh