tree-inline.h (estimate_move_cost): Add speed_p parameter.

2014-07-24  Richard Biener  <rguenther@suse.de>

	* tree-inline.h (estimate_move_cost): Add speed_p parameter.
	* tree-inline.c (estimate_move_cost): Add speed_p parameter
	and adjust MOVE_RATIO query accordingly.
	(estimate_num_insns): Adjust callers.
	* ipa-prop.c (ipa_populate_param_decls): Likewise.
	* ipa-cp.c (gather_context_independent_values,
	estimate_local_effects): Likewise.
	* ipa-split.c (consider_split): Likewise.

From-SVN: r212970

gcc/ChangeLog

+2014-07-24  Richard Biener  <rguenther@suse.de>
+
+	* tree-inline.h (estimate_move_cost): Add speed_p parameter.
+	* tree-inline.c (estimate_move_cost): Add speed_p parameter
+	and adjust MOVE_RATIO query accordingly.
+	(estimate_num_insns): Adjust callers.
+	* ipa-prop.c (ipa_populate_param_decls): Likewise.
+	* ipa-cp.c (gather_context_independent_values,
+	estimate_local_effects): Likewise.
+	* ipa-split.c (consider_split): Likewise.
+
 2014-07-24  Trevor Saunders  <tsaunders@mozilla.com>
 
 	* config/i386/driver-i386.c: Remove names of unused arguments and

gcc/ipa-cp.c

@@ -1845,7 +1845,7 @@ gather_context_independent_values (struct ipa_node_params *info,
 	      (*known_csts)[i] = val->value;
 	      if (removable_params_cost)
 		*removable_params_cost
-		  += estimate_move_cost (TREE_TYPE (val->value));
+		  += estimate_move_cost (TREE_TYPE (val->value), false);
 	      ret = true;
 	    }
 	  else if (plats->virt_call)
@@ -1997,7 +1997,7 @@ estimate_local_effects (struct cgraph_node *node)
 	    {
 	      known_csts[i] = val->value;
 	      known_binfos[i] = NULL_TREE;
-	      emc = estimate_move_cost (TREE_TYPE (val->value));
+	      emc = estimate_move_cost (TREE_TYPE (val->value), true);
 	    }
 	  else if (plats->virt_call)
 	    {

gcc/ipa-prop.c

@@ -204,7 +204,8 @@ ipa_populate_param_decls (struct cgraph_node *node,
   for (parm = fnargs; parm; parm = DECL_CHAIN (parm))
     {
       descriptors[param_num].decl = parm;
-      descriptors[param_num].move_cost = estimate_move_cost (TREE_TYPE (parm));
+      descriptors[param_num].move_cost = estimate_move_cost (TREE_TYPE (parm),
+							     true);
       param_num++;
     }
 }

gcc/ipa-split.c

@@ -488,13 +488,14 @@ consider_split (struct split_point *current, bitmap non_ssa_vars,
 			       SSA_NAME_VERSION (ddef)))
 	    {
 	      if (!VOID_TYPE_P (TREE_TYPE (parm)))
-		call_overhead += estimate_move_cost (TREE_TYPE (parm));
+		call_overhead += estimate_move_cost (TREE_TYPE (parm), false);
 	      num_args++;
 	    }
 	}
     }
   if (!VOID_TYPE_P (TREE_TYPE (current_function_decl)))
-    call_overhead += estimate_move_cost (TREE_TYPE (current_function_decl));
+    call_overhead += estimate_move_cost (TREE_TYPE (current_function_decl),
+					 false);
 
   if (current->split_size <= call_overhead)
     {

gcc/tree-inline.c

@@ -3623,11 +3623,12 @@ tree_inlinable_function_p (tree fn)
   return inlinable;
 }
 
-/* Estimate the cost of a memory move.  Use machine dependent
-   word size and take possible memcpy call into account.  */
+/* Estimate the cost of a memory move of type TYPE.  Use machine dependent
+   word size and take possible memcpy call into account and return
+   cost based on whether optimizing for size or speed according to SPEED_P.  */
 
 int
-estimate_move_cost (tree type)
+estimate_move_cost (tree type, bool speed_p)
 {
   HOST_WIDE_INT size;
 
@@ -3645,7 +3646,7 @@ estimate_move_cost (tree type)
 
   size = int_size_in_bytes (type);
 
-  if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (!optimize_size))
+  if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (speed_p))
     /* Cost of a memcpy call, 3 arguments and the call.  */
     return 4;
   else
@@ -3847,9 +3848,9 @@ estimate_num_insns (gimple stmt, eni_weights *weights)
 
       /* Account for the cost of moving to / from memory.  */
       if (gimple_store_p (stmt))
-	cost += estimate_move_cost (TREE_TYPE (lhs));
+	cost += estimate_move_cost (TREE_TYPE (lhs), weights->time_based);
       if (gimple_assign_load_p (stmt))
-	cost += estimate_move_cost (TREE_TYPE (rhs));
+	cost += estimate_move_cost (TREE_TYPE (rhs), weights->time_based);
 
       cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights,
       				      gimple_assign_rhs1 (stmt),
@@ -3923,11 +3924,13 @@ estimate_num_insns (gimple stmt, eni_weights *weights)
 
 	cost = decl ? weights->call_cost : weights->indirect_call_cost;
 	if (gimple_call_lhs (stmt))
-	  cost += estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt)));
+	  cost += estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt)),
+				      weights->time_based);
 	for (i = 0; i < gimple_call_num_args (stmt); i++)
 	  {
 	    tree arg = gimple_call_arg (stmt, i);
-	    cost += estimate_move_cost (TREE_TYPE (arg));
+	    cost += estimate_move_cost (TREE_TYPE (arg),
+					weights->time_based);
 	  }
 	break;
       }

gcc/tree-inline.h

@@ -191,7 +191,7 @@ tree maybe_inline_call_in_expr (tree);
 bool tree_inlinable_function_p (tree);
 tree copy_tree_r (tree *, int *, void *);
 tree copy_decl_no_change (tree decl, copy_body_data *id);
-int estimate_move_cost (tree type);
+int estimate_move_cost (tree type, bool);
 int estimate_num_insns (gimple, eni_weights *);
 int estimate_num_insns_fn (tree, eni_weights *);
 int count_insns_seq (gimple_seq, eni_weights *);