From patchwork Mon Dec 1 13:52:05 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Jelinek X-Patchwork-Id: 416453 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 59B181401AF for ; Tue, 2 Dec 2014 00:52:35 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:reply-to:references:mime-version :content-type:in-reply-to; q=dns; s=default; b=Z+Flc6lOKQFKWl8DT 0rDsJNOirbRyDor+jbyRlXDSKPx6EdJ5ehlCLNLrwpVJPGXZuM7wIwikFIi90jOz h/g/ssNpCxtiPEfYCy7eFMEPUO0KEicctJ3C+xcmSInKPsMXal/py8pQZHSzcK77 9y0dVWm/cn9cBckeHig53Kc4EI= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:reply-to:references:mime-version :content-type:in-reply-to; s=default; bh=08R67WQVYtZPZA3I7mh9K8f DBJ8=; b=wMlhNrNy0XjWEngtI00l0M9EY0yt/M9d1dvHOz74IHBELkma+1NKFJK bs9d7nnhYpZR5m1nGQJkiya3hwYDXXcIMNA22MqmSSPaSf+BKVztk1HrXZ4mURmc kXmkOuIIVxkrtwe0dm6VQ5neDEmsu79ME3cPBJDE0IqRwUPG9efw= Received: (qmail 14605 invoked by alias); 1 Dec 2014 13:52:24 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 14572 invoked by uid 89); 1 Dec 2014 13:52:22 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.1 required=5.0 tests=AWL, BAYES_00, SPF_HELO_PASS, SPF_PASS, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Mon, 01 Dec 2014 13:52:12 +0000 Received: from int-mx14.intmail.prod.int.phx2.redhat.com (int-mx14.intmail.prod.int.phx2.redhat.com [10.5.11.27]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id sB1DqAds007870 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Mon, 1 Dec 2014 08:52:10 -0500 Received: from tucnak.zalov.cz (ovpn-116-70.ams2.redhat.com [10.36.116.70]) by int-mx14.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id sB1Dq8Kj019598 (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128 verify=NO); Mon, 1 Dec 2014 08:52:09 -0500 Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.14.9/8.14.9) with ESMTP id sB1Dq6vf002854; Mon, 1 Dec 2014 14:52:07 +0100 Received: (from jakub@localhost) by tucnak.zalov.cz (8.14.9/8.14.9/Submit) id sB1Dq5Zi002853; Mon, 1 Dec 2014 14:52:05 +0100 Date: Mon, 1 Dec 2014 14:52:05 +0100 From: Jakub Jelinek To: Richard Biener Cc: gcc-patches@gcc.gnu.org Subject: [PATCH] Rename gimple_build_assign_with_ops to gimple_build_assign and swap the first two arguments of it Message-ID: <20141201135205.GH1892@tucnak.redhat.com> Reply-To: Jakub Jelinek References: <20141128190223.GX1892@tucnak.redhat.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20141128190223.GX1892@tucnak.redhat.com> User-Agent: Mutt/1.5.23 (2014-03-12) X-IsSubscribed: yes 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 * 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 --- 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 ); 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 /* 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 *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 *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 (vecsafe_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 (vecUSE_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 * 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 * 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 * 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 * } 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 * /* 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 * 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 * 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 * - 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 * 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 * 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 * 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 * { 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 * 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 * /* 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 * /* 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 * 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 * 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 *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 *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 *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, vecrepr; 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, vecvalue = 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 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 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 dr_c high = VEC_PERM_EXPR */ high = make_temp_ssa_name (vectype, NULL, "vect_inter_high"); - perm_stmt - = gimple_build_assign_with_ops (VEC_PERM_EXPR, high, - vect1, vect2, perm_mask_high); + perm_stmt = gimple_build_assign (high, VEC_PERM_EXPR, vect1, + vect2, perm_mask_high); vect_finish_stmt_generation (stmt, perm_stmt, gsi); (*result_chain)[2*j] = high; @@ -4697,9 +4694,8 @@ vect_permute_store_chain (vec dr_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 dr_ch low = VEC_PERM_EXPR */ data_ref = make_temp_ssa_name (vectype, NULL, "vect_shuffle3_low"); - perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref, - first_vect, second_vect, - perm3_mask_low); + perm_stmt = gimple_build_assign (data_ref, VEC_PERM_EXPR, first_vect, + second_vect, perm3_mask_low); vect_finish_stmt_generation (stmt, perm_stmt, gsi); /* Create interleaving stmt (high part of): @@ -5205,9 +5200,8 @@ vect_permute_load_chain (vec dr_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 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 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 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 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 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 (*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);