Fix time accounting in the inliner

[Jan Hubicka]

Hi,
estimate_edge_time was originally derrived from estimate_edge_growth.
estimate_edge_growth returns estimated function body growth by inlining.
That is size_of_inlined_body-size_of_call_stmt.
For estimate_edge_time it is kind of confusing and led me to double
account time of call stmt in the badness computation.

This patch fixes estimate_edge_time to actually return time of inlined
sequence and adds estimate_edge_size that is the size variant + makes
do_estimate_edge_growth a wrapper about it (because at most places
the inline heuristic really care about growth)

Bootstrapped/regtested x86_64-linux, comitted.

Honza

	* ipa-inline-analysis.c (do_estimate_edge_time): Return actual
	time spent by the inlined sequence.
	(do_estimate_edge_growth): Rename to ...
	(do_estimate_edge_time): ... this one; return size of inlined
	sequence.
	* ipa-inline.h (do_estimate_edge_size): New.
	(do_estimate_edge_growth): Remove.
	(estimate_edge_size): New function.
	(estimate_edge_growth): Use it.
Index: ipa-inline-analysis.c
===================================================================
--- ipa-inline-analysis.c	(revision 192116)
+++ ipa-inline-analysis.c	(working copy)
@@ -3312,14 +3312,12 @@ do_estimate_edge_time (struct cgraph_edg
   VEC_free (tree, heap, known_binfos);
   VEC_free (ipa_agg_jump_function_p, heap, known_aggs);
 
-  ret = (((gcov_type)time
-	   - es->call_stmt_time) * edge->frequency
-	 + CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE;
+  ret = RDIV ((gcov_type)time * edge->frequency,
+	      CGRAPH_FREQ_BASE);
 
   /* When caching, update the cache entry.  */
   if (edge_growth_cache)
     {
-      int ret_size;
       if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache)
 	  <= edge->uid)
 	VEC_safe_grow_cleared (edge_growth_cache_entry, heap, edge_growth_cache,
@@ -3327,10 +3325,8 @@ do_estimate_edge_time (struct cgraph_edg
       VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid).time
 	= ret + (ret >= 0);
 
-      ret_size = size - es->call_stmt_size;
-      gcc_checking_assert (es->call_stmt_size);
       VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid).size
-	= ret_size + (ret_size >= 0);
+	= size + (size >= 0);
       VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid).hints
 	= hints + 1;
     }
@@ -3338,11 +3334,11 @@ do_estimate_edge_time (struct cgraph_edg
 }
 
 
-/* Estimate the growth of the caller when inlining EDGE.
+/* Return estimated callee growth after inlining EDGE.
    Only to be called via estimate_edge_size.  */
 
 int
-do_estimate_edge_growth (struct cgraph_edge *edge)
+do_estimate_edge_size (struct cgraph_edge *edge)
 {
   int size;
   struct cgraph_node *callee;
@@ -3375,8 +3371,7 @@ do_estimate_edge_growth (struct cgraph_e
   VEC_free (tree, heap, known_vals);
   VEC_free (tree, heap, known_binfos);
   VEC_free (ipa_agg_jump_function_p, heap, known_aggs);
-  gcc_checking_assert (inline_edge_summary (edge)->call_stmt_size);
-  return size - inline_edge_summary (edge)->call_stmt_size;
+  return size;
 }
 
 
Index: ipa-inline.h
===================================================================
--- ipa-inline.h	(revision 192116)
+++ ipa-inline.h	(working copy)
@@ -201,7 +201,7 @@ void estimate_ipcp_clone_size_and_time (
 int do_estimate_growth (struct cgraph_node *);
 void inline_merge_summary (struct cgraph_edge *edge);
 void inline_update_overall_summary (struct cgraph_node *node);
-int do_estimate_edge_growth (struct cgraph_edge *edge);
+int do_estimate_edge_size (struct cgraph_edge *edge);
 int do_estimate_edge_time (struct cgraph_edge *edge);
 inline_hints do_estimate_edge_hints (struct cgraph_edge *edge);
 void initialize_growth_caches (void);
@@ -245,20 +245,31 @@ estimate_growth (struct cgraph_node *nod
 }
 
 
-/* Return estimated callee growth after inlining EDGE.  */
+/* Return estimated size of the inline sequence of EDGE.  */
 
 static inline int
-estimate_edge_growth (struct cgraph_edge *edge)
+estimate_edge_size (struct cgraph_edge *edge)
 {
   int ret;
   if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache) <= edge->uid
       || !(ret = VEC_index (edge_growth_cache_entry,
 			    edge_growth_cache,
 			    edge->uid).size))
-    return do_estimate_edge_growth (edge);
+    return do_estimate_edge_size (edge);
   return ret - (ret > 0);
 }
 
+/* Return estimated callee growth after inlining EDGE.  */
+
+static inline int
+estimate_edge_growth (struct cgraph_edge *edge)
+{
+#ifdef ENABLE_CHECKING
+  gcc_checking_assert (inline_edge_summary (edge)->call_stmt_size);
+#endif
+  return (estimate_edge_size (edge)
+	  - inline_edge_summary (edge)->call_stmt_size);
+}
 
 /* Return estimated callee runtime increase after inlning
    EDGE.  */