re PR tree-optimization/51600 (ice in estimate_local_effects)

PR tree-optimization/51600
	* ipa-inline-analysis.c (estimate_edge_devirt_benefit): Disable code
	that benefits small functions.

From-SVN: r182984

gcc/ChangeLog

@@ -1,3 +1,13 @@
+2012-01-07  Jan Hubicka  <jh@suse.cz>
+
+	PR tree-optimization/51600
+	* ipa-inline-analysis.c (estimate_edge_devirt_benefit): Disable code
+	that benefits small functions.
+
+2012-01-07  Jan Hubicka  <jh@suse.cz>
+
+	* ipa-inline.c (want_inline_small_function_p): Fix formating.
+
 2012-01-07  Jan Hubicka  <jh@suse.cz>
 
 	PR tree-optimization/51680

gcc/ipa-inline-analysis.c

@@ -2202,11 +2202,9 @@ estimate_edge_devirt_benefit (struct cgraph_edge *ie,
 			      VEC (tree, heap) *known_binfos)
 {
   tree target;
-  struct cgraph_node *callee;
+  int time_diff, size_diff;
-  struct inline_summary *isummary;
-  int edge_size = 0, edge_time = 0;
 
-  if (!known_vals || !known_binfos)
+  if (!known_vals && !known_binfos)
     return;
 
   target = ipa_get_indirect_edge_target (ie, known_vals, known_binfos);
@@ -2214,10 +2212,22 @@ estimate_edge_devirt_benefit (struct cgraph_edge *ie,
     return;
 
   /* Account for difference in cost between indirect and direct calls.  */
-  *size -= ((eni_size_weights.indirect_call_cost - eni_size_weights.call_cost)
+  size_diff = ((eni_size_weights.indirect_call_cost - eni_size_weights.call_cost)
-	    * INLINE_SIZE_SCALE);
+	        * INLINE_SIZE_SCALE);
-  *time -= ((eni_time_weights.indirect_call_cost - eni_time_weights.call_cost)
+  *size -= size_diff;
-	    * INLINE_TIME_SCALE * prob / REG_BR_PROB_BASE);
+  time_diff = ((eni_time_weights.indirect_call_cost - eni_time_weights.call_cost)
+	       * INLINE_TIME_SCALE * prob / REG_BR_PROB_BASE);
+  *time -= time_diff;
+
+  /* TODO: This code is trying to benefit indirect calls that will be inlined later.
+     The logic however do not belong into local size/time estimates and can not be
+     done here, or the accounting of changes will get wrong and we result with 
+     negative function body sizes.  We need to introduce infrastructure for independent
+     benefits to the inliner.  */
+#if 0
+  struct cgraph_node *callee;
+  struct inline_summary *isummary;
+  int edge_size, edge_time, time_diff, size_diff;
 
   callee = cgraph_get_node (target);
   if (!callee || !callee->analyzed)
@@ -2229,22 +2239,20 @@ estimate_edge_devirt_benefit (struct cgraph_edge *ie,
   estimate_edge_size_and_time (ie, &edge_size, &edge_time, prob);
 
   /* Count benefit only from functions that definitely will be inlined
-     if additional context from NODE's caller were available.  */
+     if additional context from NODE's caller were available. 
-  if (edge_size >= isummary->size * INLINE_SIZE_SCALE)
+
+     We just account overall size change by inlining.  TODO:
+     we really need to add sort of benefit metrics for these kind of
+     cases. */
+  if (edge_size - size_diff >= isummary->size * INLINE_SIZE_SCALE)
     {
       /* Subtract size and time that we added for edge IE.  */
-      *size -= edge_size;
+      *size -= edge_size - size_diff;
-      *time -= edge_time;
 
-      /* Subtract benefit from inlining devirtualized call.  */
+      /* Account inlined call.  */
-      *size -= edge_size - isummary->size * INLINE_SIZE_SCALE;
+      *size += isummary->size * INLINE_SIZE_SCALE;
-      *time -= edge_time - (isummary->time * INLINE_TIME_SCALE * prob
-			    / REG_BR_PROB_BASE);
-
-      /* TODO: estimate benefit from optimizing CALLEE's body provided
-	 additional context from IE call site.
-	 For insipiration see ipa-cp.c: devirtualization_time_bonus().  */
     }
+#endif
 }
 
 

gcc/testsuite/ChangeLog

@@ -1,3 +1,8 @@
+2012-01-07  Jan Hubicka  <jh@suse.cz>
+
+	PR tree-optimization/51600
+	* g++.dg/torture/pr51600.C: New testcase.
+
 2012-01-07  John David Anglin  <dave.anglin@nrc-cnrc.gc.ca>
 
 	PR gcov-profile/51715

gcc/testsuite/g++.dg/torture/pr51600.C

@@ -0,0 +1,16 @@
+template<class T> inline T min(T a, T b) { return a < b ? a : b; }
+double cornerbound(double *P, double (*m)(double, double))
+{
+  double b=m(P[0],P[3]);
+  return m(b,P[12]);
+}
+void bound(double *P, double (*m)(double, double), double b)
+{
+  m(b,cornerbound(P,m));
+}
+void bounds(double fuzz, unsigned maxdepth)
+{
+  double Px[]={};
+  double bx=Px[0];
+  bound(Px,min,bx);
+}