don't use TYPE_ARG_TYPES in the Ada frontend

[pf3gnuchains/gcc-fork.git] / gcc / ipa-inline-transform.c

diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c
index 25ad84a..117958c 100644 (file)
--- a/gcc/ipa-inline-transform.c
+++ b/gcc/ipa-inline-transform.c
@@ -49,12 +49,11 @@ along with GCC; see the file COPYING3.  If not see
 int ncalls_inlined;
 int nfunctions_inlined;
 
-/* Scale frequency of NODE edges by FREQ_SCALE and increase loop nest
-   by NEST.  */
+/* Scale frequency of NODE edges by FREQ_SCALE.  */
 
 static void
 update_noncloned_frequencies (struct cgraph_node *node,
-                             int freq_scale, int nest)
+                             int freq_scale)
 {
   struct cgraph_edge *e;
 
@@ -63,12 +62,17 @@ update_noncloned_frequencies (struct cgraph_node *node,
     freq_scale = 1;
   for (e = node->callees; e; e = e->next_callee)
     {
-      e->loop_nest += nest;
       e->frequency = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
       if (e->frequency > CGRAPH_FREQ_MAX)
         e->frequency = CGRAPH_FREQ_MAX;
       if (!e->inline_failed)
-        update_noncloned_frequencies (e->callee, freq_scale, nest);
+        update_noncloned_frequencies (e->callee, freq_scale);
+    }
+  for (e = node->indirect_calls; e; e = e->next_callee)
+    {
+      e->frequency = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
+      if (e->frequency > CGRAPH_FREQ_MAX)
+        e->frequency = CGRAPH_FREQ_MAX;
     }
 }
 
@@ -83,9 +87,6 @@ void
 clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
                     bool update_original, int *overall_size)
 {
-  HOST_WIDE_INT peak;
-  struct inline_summary *caller_info, *callee_info;
-
   if (duplicate)
     {
       /* We may eliminate the need for out-of-line copy to be output.
@@ -125,34 +126,22 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
            }
          duplicate = false;
          e->callee->local.externally_visible = false;
-          update_noncloned_frequencies (e->callee, e->frequency, e->loop_nest);
+          update_noncloned_frequencies (e->callee, e->frequency);
        }
       else
        {
          struct cgraph_node *n;
          n = cgraph_clone_node (e->callee, e->callee->decl,
-                                e->count, e->frequency, e->loop_nest,
+                                e->count, e->frequency,
                                 update_original, NULL);
          cgraph_redirect_edge_callee (e, n);
        }
     }
 
-  callee_info = inline_summary (e->callee);
-  caller_info = inline_summary (e->caller);
-
   if (e->caller->global.inlined_to)
     e->callee->global.inlined_to = e->caller->global.inlined_to;
   else
     e->callee->global.inlined_to = e->caller;
-  callee_info->stack_frame_offset
-    = caller_info->stack_frame_offset
-      + caller_info->estimated_self_stack_size;
-  peak = callee_info->stack_frame_offset
-      + callee_info->estimated_self_stack_size;
-  if (inline_summary (e->callee->global.inlined_to)->estimated_stack_size
-      < peak)
-    inline_summary (e->callee->global.inlined_to)->estimated_stack_size = peak;
-  cgraph_propagate_frequency (e->callee);
 
   /* Recursively clone all bodies.  */
   for (e = e->callee->callees; e; e = e->next_callee)
@@ -175,7 +164,6 @@ inline_call (struct cgraph_edge *e, bool update_original,
   int old_size = 0, new_size = 0;
   struct cgraph_node *to = NULL;
   struct cgraph_edge *curr = e;
-  struct inline_summary *info;
 
   /* Don't inline inlined edges.  */
   gcc_assert (e->inline_failed);
@@ -185,19 +173,17 @@ inline_call (struct cgraph_edge *e, bool update_original,
   e->inline_failed = CIF_OK;
   DECL_POSSIBLY_INLINED (e->callee->decl) = true;
 
+  to = e->caller;
+  if (to->global.inlined_to)
+    to = to->global.inlined_to;
+
   clone_inlined_nodes (e, true, update_original, overall_size);
 
-  /* Now update size of caller and all functions caller is inlined into.  */
-  for (;e && !e->inline_failed; e = e->caller->callers)
-    {
-      to = e->caller;
-      info = inline_summary (to);
-      old_size = info->size;
-      new_size = estimate_size_after_inlining (to, curr);
-      info->size = new_size;
-      info->time = estimate_time_after_inlining (to, curr);
-    }
   gcc_assert (curr->callee->global.inlined_to == to);
+
+  old_size = inline_summary (to)->size;
+  inline_merge_summary (e);
+  new_size = inline_summary (to)->size;
   if (overall_size && new_size > old_size)
     *overall_size += new_size - old_size;
   ncalls_inlined++;
@@ -311,7 +297,7 @@ inline_transform (struct cgraph_node *node)
 
   /* We might need the body of this function so that we can expand
      it inline somewhere else.  */
-  if (cgraph_preserve_function_body_p (node->decl))
+  if (cgraph_preserve_function_body_p (node))
     save_inline_function_body (node);
 
   for (e = node->callees; e; e = e->next_callee)