This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[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)


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]