This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[tuples] patch: C++ and vectorizer changes
- From: Aldy Hernandez <aldyh at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Thu, 28 Sep 2006 08:19:11 -0400
- Subject: [tuples] patch: C++ and vectorizer changes
This patch tuplefies the C++ front end and the vectorizer. I have
also modified the PPC backend, as I was doing tests on a PPC box.
Committed to branch.
* cp/cp-tree.h (union lang_tree_node): Gimple statements do not
have a TREE_CHAIN.
(TREE_INDIRECT_USING): Look in base.
* tree-ssa-math-opts.c (replace_reciprocal): Use GIMPLE_STMT_OPERAND.
* tree-if-conv.c (if_convertible_gimple_modify_stmt_p): Same.
(ifc_temp_var): Same.
* tree-vect-analyze.c (vect_determine_vectorization_factor): Check
for gimple statements.
(vect_analyze_operations): Same.
(exist_non_indexing_operands_for_use_p): Use GIMPLE_STMT_OPERAND.
* gimplify.c (gimplify_return_expr): Handle gimple statements.
* lambda-code.c (can_put_in_inner_loop): Same.
(can_put_after_inner_loop): Same.
* tree-vect-transform.c (vect_create_addr_base_for_vector_ref): Same.
(vect_create_data_ref_ptr): Same.
(vect_init_vector): Same.
(vect_get_vec_def_for_operand): Same.
(vect_create_epilog_for_reduction): Same.
(vectorizable_reduction): Same.
(vectorizable_assignment): Same.
(vectorizable_operation): Same.
(vectorizable_load): Same.
(vectorizable_condition): Same.
* config/rs6000/rs6000.c (rs6000_va_start): Do not create MODIFY_EXPRs.
(rs6000_gimplify_va_arg): Same.
Index: cp/cp-tree.h
===================================================================
--- cp/cp-tree.h (revision 116647)
+++ cp/cp-tree.h (working copy)
@@ -461,7 +461,7 @@ enum cp_tree_node_structure_enum {
/* The resulting tree type. */
union lang_tree_node GTY((desc ("cp_tree_node_structure (&%h)"),
- chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))
+ chain_next ("(GIMPLE_STMT_P (&%h.generic) ? (union lang_tree_node *) 0 : (union lang_tree_node *)TREE_CHAIN (&%h.generic))")))
{
union tree_node GTY ((tag ("TS_CP_GENERIC"),
desc ("tree_node_structure (&%h)"))) generic;
@@ -2040,7 +2040,7 @@ struct lang_decl GTY(())
/* In a TREE_LIST concatenating using directives, indicate indirect
directives */
-#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->common.lang_flag_0)
+#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0)
extern tree decl_shadowed_for_var_lookup (tree);
extern void decl_shadowed_for_var_insert (tree, tree);
Index: tree-ssa-math-opts.c
===================================================================
--- tree-ssa-math-opts.c (revision 116725)
+++ tree-ssa-math-opts.c (working copy)
@@ -353,7 +353,7 @@ replace_reciprocal (use_operand_p use_p)
if (occ->recip_def && use_stmt != occ->recip_def_stmt)
{
- TREE_SET_CODE (TREE_OPERAND (use_stmt, 1), MULT_EXPR);
+ TREE_SET_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1), MULT_EXPR);
SET_USE (use_p, occ->recip_def);
fold_stmt_inplace (use_stmt);
update_stmt (use_stmt);
Index: tree-if-conv.c
===================================================================
--- tree-if-conv.c (revision 116725)
+++ tree-if-conv.c (working copy)
@@ -362,21 +362,21 @@ if_convertible_gimple_modify_stmt_p (str
/* See if it needs speculative loading or not. */
if (bb != loop->header
- && tree_could_trap_p (TREE_OPERAND (m_expr, 1)))
+ && tree_could_trap_p (GIMPLE_STMT_OPERAND (m_expr, 1)))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "tree could trap...\n");
return false;
}
- if (TREE_CODE (TREE_OPERAND (m_expr, 1)) == CALL_EXPR)
+ if (TREE_CODE (GIMPLE_STMT_OPERAND (m_expr, 1)) == CALL_EXPR)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "CALL_EXPR \n");
return false;
}
- if (TREE_CODE (TREE_OPERAND (m_expr, 0)) != SSA_NAME
+ if (TREE_CODE (GIMPLE_STMT_OPERAND (m_expr, 0)) != SSA_NAME
&& bb != loop->header
&& !bb_with_exit_edge_p (loop, bb))
{
@@ -1000,7 +1000,7 @@ ifc_temp_var (tree type, tree exp)
/* Get SSA name for the new variable and set make new statement
its definition statement. */
new_name = make_ssa_name (var, stmt);
- TREE_OPERAND (stmt, 0) = new_name;
+ GIMPLE_STMT_OPERAND (stmt, 0) = new_name;
SSA_NAME_DEF_STMT (new_name) = stmt;
return stmt;
Index: tree-vect-analyze.c
===================================================================
--- tree-vect-analyze.c (revision 116725)
+++ tree-vect-analyze.c (working copy)
@@ -132,7 +132,8 @@ vect_determine_vectorization_factor (loo
continue;
}
- if (VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))))
+ if (!GIMPLE_STMT_P (stmt)
+ && VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))))
{
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS))
{
@@ -307,7 +308,8 @@ vect_analyze_operations (loop_vec_info l
if (STMT_VINFO_RELEVANT_P (stmt_info))
{
- gcc_assert (!VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))));
+ gcc_assert (GIMPLE_STMT_P (stmt)
+ || !VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))));
gcc_assert (STMT_VINFO_VECTYPE (stmt_info));
ok = (vectorizable_operation (stmt, NULL, NULL)
@@ -440,10 +442,10 @@ exist_non_indexing_operands_for_use_p (t
Therefore, all we need to check is if STMT falls into the
first case, and whether var corresponds to USE. */
- if (TREE_CODE (TREE_OPERAND (stmt, 0)) == SSA_NAME)
+ if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME)
return false;
- operand = TREE_OPERAND (stmt, 1);
+ operand = GIMPLE_STMT_OPERAND (stmt, 1);
if (TREE_CODE (operand) != SSA_NAME)
return false;
Index: gimplify.c
===================================================================
--- gimplify.c (revision 117221)
+++ gimplify.c (working copy)
@@ -1151,12 +1151,13 @@ gimplify_return_expr (tree stmt, tree *p
result_decl = NULL_TREE;
else
{
- result_decl = TREE_OPERAND (ret_expr, 0);
+ result_decl = PROTECTED_TREE_OPERAND (ret_expr, 0);
if (TREE_CODE (result_decl) == INDIRECT_REF)
/* See through a return by reference. */
result_decl = TREE_OPERAND (result_decl, 0);
gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
+ || TREE_CODE (ret_expr) == GIMPLE_MODIFY_STMT
|| TREE_CODE (ret_expr) == INIT_EXPR)
&& TREE_CODE (result_decl) == RESULT_DECL);
}
@@ -1190,7 +1191,7 @@ gimplify_return_expr (tree stmt, tree *p
/* Smash the lhs of the GIMPLE_MODIFY_STMT to the temporary we plan to use.
Then gimplify the whole thing. */
if (result != result_decl)
- TREE_OPERAND (ret_expr, 0) = result;
+ PROTECTED_TREE_OPERAND (ret_expr, 0) = result;
gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
Index: lambda-code.c
===================================================================
--- lambda-code.c (revision 116725)
+++ lambda-code.c (working copy)
@@ -2158,10 +2158,10 @@ can_put_in_inner_loop (struct loop *inne
gcc_assert (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT);
if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)
- || !expr_invariant_in_loop_p (inner, TREE_OPERAND (stmt, 1)))
+ || !expr_invariant_in_loop_p (inner, GIMPLE_STMT_OPERAND (stmt, 1)))
return false;
- FOR_EACH_IMM_USE_FAST (use_p, imm_iter, TREE_OPERAND (stmt, 0))
+ FOR_EACH_IMM_USE_FAST (use_p, imm_iter, GIMPLE_STMT_OPERAND (stmt, 0))
{
if (!exit_phi_for_loop_p (inner, USE_STMT (use_p)))
{
@@ -2184,7 +2184,7 @@ can_put_after_inner_loop (struct loop *l
if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
return false;
- FOR_EACH_IMM_USE_FAST (use_p, imm_iter, TREE_OPERAND (stmt, 0))
+ FOR_EACH_IMM_USE_FAST (use_p, imm_iter, GIMPLE_STMT_OPERAND (stmt, 0))
{
if (!exit_phi_for_loop_p (loop, USE_STMT (use_p)))
{
Index: tree-vect-transform.c
===================================================================
--- tree-vect-transform.c (revision 116725)
+++ tree-vect-transform.c (working copy)
@@ -179,7 +179,7 @@ vect_create_addr_base_for_vector_ref (tr
add_referenced_var (addr_expr);
vec_stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr_expr, addr_base);
new_temp = make_ssa_name (addr_expr, vec_stmt);
- TREE_OPERAND (vec_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (vec_stmt, 0) = new_temp;
append_to_statement_list_force (vec_stmt, new_stmt_list);
if (vect_print_dump_info (REPORT_DETAILS))
@@ -325,7 +325,7 @@ vect_create_data_ref_ptr (tree stmt,
vec_stmt = fold_convert (vect_ptr_type, new_temp);
vec_stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, vect_ptr, vec_stmt);
vect_ptr_init = make_ssa_name (vect_ptr, vec_stmt);
- TREE_OPERAND (vec_stmt, 0) = vect_ptr_init;
+ GIMPLE_STMT_OPERAND (vec_stmt, 0) = vect_ptr_init;
new_bb = bsi_insert_on_edge_immediate (pe, vec_stmt);
gcc_assert (!new_bb);
@@ -421,7 +421,7 @@ vect_init_vector (tree stmt, tree vector
init_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, new_var, vector_var);
new_temp = make_ssa_name (new_var, init_stmt);
- TREE_OPERAND (init_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (init_stmt, 0) = new_temp;
pe = loop_preheader_edge (loop);
new_bb = bsi_insert_on_edge_immediate (pe, init_stmt);
@@ -433,7 +433,7 @@ vect_init_vector (tree stmt, tree vector
print_generic_expr (vect_dump, init_stmt, TDF_SLIM);
}
- vec_oprnd = TREE_OPERAND (init_stmt, 0);
+ vec_oprnd = GIMPLE_STMT_OPERAND (init_stmt, 0);
return vec_oprnd;
}
@@ -541,7 +541,7 @@ vect_get_vec_def_for_operand (tree op, t
def_stmt_info = vinfo_for_stmt (def_stmt);
vec_stmt = STMT_VINFO_VEC_STMT (def_stmt_info);
gcc_assert (vec_stmt);
- vec_oprnd = TREE_OPERAND (vec_stmt, 0);
+ vec_oprnd = GIMPLE_STMT_OPERAND (vec_stmt, 0);
return vec_oprnd;
}
@@ -903,7 +903,7 @@ vect_create_epilog_for_reduction (tree v
build1 (reduc_code, vectype,
PHI_RESULT (new_phi)));
new_temp = make_ssa_name (vec_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
extract_scalar_result = true;
@@ -961,13 +961,13 @@ vect_create_epilog_for_reduction (tree v
epilog_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest,
build2 (shift_code, vectype, new_temp, bitpos));
new_name = make_ssa_name (vec_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_name;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_name;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
epilog_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest,
build2 (code, vectype, new_name, new_temp));
new_temp = make_ssa_name (vec_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
}
@@ -998,7 +998,7 @@ vect_create_epilog_for_reduction (tree v
epilog_stmt = build2 (GIMPLE_MODIFY_STMT, scalar_type,
new_scalar_dest, rhs);
new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
for (bit_offset = element_bitsize;
@@ -1014,7 +1014,7 @@ vect_create_epilog_for_reduction (tree v
new_scalar_dest,
rhs);
new_name = make_ssa_name (new_scalar_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_name;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_name;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
epilog_stmt = build2 (GIMPLE_MODIFY_STMT, scalar_type,
@@ -1022,7 +1022,7 @@ vect_create_epilog_for_reduction (tree v
build2 (code, scalar_type, new_name,
new_temp));
new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
}
@@ -1052,7 +1052,7 @@ vect_create_epilog_for_reduction (tree v
epilog_stmt = build2 (GIMPLE_MODIFY_STMT, scalar_type, new_scalar_dest,
rhs);
new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
}
@@ -1069,7 +1069,7 @@ vect_create_epilog_for_reduction (tree v
build2 (code, scalar_type, new_temp,
scalar_initial_def));
new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
- TREE_OPERAND (epilog_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp;
bsi_insert_after (&exit_bsi, epilog_stmt, BSI_NEW_STMT);
}
@@ -1363,7 +1363,7 @@ vectorizable_reduction (tree stmt, block
/* Create the vectorized operation that computes the partial results */
*vec_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, expr);
new_temp = make_ssa_name (vec_dest, *vec_stmt);
- TREE_OPERAND (*vec_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (*vec_stmt, 0) = new_temp;
vect_finish_stmt_generation (stmt, *vec_stmt, bsi);
/* Finalize the reduction-phi (set it's arguments) and create the
@@ -1435,7 +1435,7 @@ vectorizable_assignment (tree stmt, bloc
/* Arguments are ready. create the new vector stmt. */
*vec_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, vec_oprnd);
new_temp = make_ssa_name (vec_dest, *vec_stmt);
- TREE_OPERAND (*vec_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (*vec_stmt, 0) = new_temp;
vect_finish_stmt_generation (stmt, *vec_stmt, bsi);
return true;
@@ -1645,7 +1645,7 @@ vectorizable_operation (tree stmt, block
*vec_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest,
build1 (code, vectype, vec_oprnd0));
new_temp = make_ssa_name (vec_dest, *vec_stmt);
- TREE_OPERAND (*vec_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (*vec_stmt, 0) = new_temp;
vect_finish_stmt_generation (stmt, *vec_stmt, bsi);
return true;
@@ -1861,7 +1861,7 @@ vectorizable_load (tree stmt, block_stmt
}
new_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, data_ref);
new_temp = make_ssa_name (vec_dest, new_stmt);
- TREE_OPERAND (new_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp;
vect_finish_stmt_generation (stmt, new_stmt, bsi);
copy_virtual_operands (new_stmt, stmt);
}
@@ -1897,10 +1897,10 @@ vectorizable_load (tree stmt, block_stmt
data_ref = build1 (ALIGN_INDIRECT_REF, vectype, data_ref);
new_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, data_ref);
new_temp = make_ssa_name (vec_dest, new_stmt);
- TREE_OPERAND (new_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp;
new_bb = bsi_insert_on_edge_immediate (pe, new_stmt);
gcc_assert (!new_bb);
- msq_init = TREE_OPERAND (new_stmt, 0);
+ msq_init = GIMPLE_STMT_OPERAND (new_stmt, 0);
copy_virtual_operands (new_stmt, stmt);
update_vuses_to_preheader (new_stmt, loop);
@@ -1912,9 +1912,9 @@ vectorizable_load (tree stmt, block_stmt
data_ref = build1 (ALIGN_INDIRECT_REF, vectype, dataref_ptr);
new_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, data_ref);
new_temp = make_ssa_name (vec_dest, new_stmt);
- TREE_OPERAND (new_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp;
vect_finish_stmt_generation (stmt, new_stmt, bsi);
- lsq = TREE_OPERAND (new_stmt, 0);
+ lsq = GIMPLE_STMT_OPERAND (new_stmt, 0);
copy_virtual_operands (new_stmt, stmt);
@@ -1929,10 +1929,10 @@ vectorizable_load (tree stmt, block_stmt
new_stmt = build_function_call_expr (builtin_decl, params);
new_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, new_stmt);
new_temp = make_ssa_name (vec_dest, new_stmt);
- TREE_OPERAND (new_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp;
new_bb = bsi_insert_on_edge_immediate (pe, new_stmt);
gcc_assert (!new_bb);
- magic = TREE_OPERAND (new_stmt, 0);
+ magic = GIMPLE_STMT_OPERAND (new_stmt, 0);
/* The result of the CALL_EXPR to this builtin is determined from
the value of the parameter and no global variables are touched
@@ -1963,7 +1963,7 @@ vectorizable_load (tree stmt, block_stmt
new_stmt = build3 (REALIGN_LOAD_EXPR, vectype, msq, lsq, magic);
new_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, new_stmt);
new_temp = make_ssa_name (vec_dest, new_stmt);
- TREE_OPERAND (new_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp;
vect_finish_stmt_generation (stmt, new_stmt, bsi);
}
else
@@ -2186,7 +2186,7 @@ vectorizable_condition (tree stmt, block
*vec_stmt = build2 (GIMPLE_MODIFY_STMT, vectype, vec_dest, vec_cond_expr);
new_temp = make_ssa_name (vec_dest, *vec_stmt);
- TREE_OPERAND (*vec_stmt, 0) = new_temp;
+ GIMPLE_STMT_OPERAND (*vec_stmt, 0) = new_temp;
vect_finish_stmt_generation (stmt, *vec_stmt, bsi);
return true;
Index: config/rs6000/rs6000.c
===================================================================
--- config/rs6000/rs6000.c (revision 116647)
+++ config/rs6000/rs6000.c (working copy)
@@ -5820,7 +5820,7 @@ rs6000_va_start (tree valist, rtx nextar
if (cfun->va_list_gpr_size)
{
- t = build2 (MODIFY_EXPR, TREE_TYPE (gpr), gpr,
+ t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (gpr), gpr,
build_int_cst (NULL_TREE, n_gpr));
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -5828,7 +5828,7 @@ rs6000_va_start (tree valist, rtx nextar
if (cfun->va_list_fpr_size)
{
- t = build2 (MODIFY_EXPR, TREE_TYPE (fpr), fpr,
+ t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (fpr), fpr,
build_int_cst (NULL_TREE, n_fpr));
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -5839,7 +5839,7 @@ rs6000_va_start (tree valist, rtx nextar
if (words != 0)
t = build2 (PLUS_EXPR, TREE_TYPE (ovf), t,
build_int_cst (NULL_TREE, words * UNITS_PER_WORD));
- t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
+ t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovf), ovf, t);
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -5856,7 +5856,7 @@ rs6000_va_start (tree valist, rtx nextar
if (cfun->machine->varargs_save_offset)
t = build2 (PLUS_EXPR, TREE_TYPE (sav), t,
build_int_cst (NULL_TREE, cfun->machine->varargs_save_offset));
- t = build2 (MODIFY_EXPR, TREE_TYPE (sav), sav, t);
+ t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (sav), sav, t);
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
}
@@ -5989,7 +5989,7 @@ rs6000_gimplify_va_arg (tree valist, tre
u = build2 (MULT_EXPR, integer_type_node, u, size_int (sav_scale));
t = build2 (PLUS_EXPR, ptr_type_node, t, u);
- t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+ t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
gimplify_and_add (t, pre_p);
t = build1 (GOTO_EXPR, void_type_node, lab_over);
@@ -6002,7 +6002,7 @@ rs6000_gimplify_va_arg (tree valist, tre
{
/* Ensure that we don't find any more args in regs.
Alignment has taken care of the n_reg == 2 gpr case. */
- t = build2 (MODIFY_EXPR, TREE_TYPE (reg), reg, size_int (8));
+ t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (reg), reg, size_int (8));
gimplify_and_add (t, pre_p);
}
}
@@ -6019,11 +6019,11 @@ rs6000_gimplify_va_arg (tree valist, tre
}
gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
- u = build2 (MODIFY_EXPR, void_type_node, addr, t);
+ u = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
gimplify_and_add (u, pre_p);
t = build2 (PLUS_EXPR, TREE_TYPE (t), t, size_int (size));
- t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
+ t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovf), ovf, t);
gimplify_and_add (t, pre_p);
if (lab_over)