OSDN Git Service

2010-04-28 Martin Jambor <mjambor@suse.cz>
authorjamborm <jamborm@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 28 Apr 2010 14:05:54 +0000 (14:05 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 05:36:47 +0000 (14:36 +0900)
* cgraph.h (struct cgraph_node): New field indirect_calls.
(struct cgraph_indirect_call_info): New type.
(struct cgraph_edge): Removed field indirect_call. New fields
indirect_info, indirect_inlining_edge and indirect_unknown_callee.
(cgraph_create_indirect_edge): Declare.
(cgraph_make_edge_direct): Likewise.
(enum LTO_cgraph_tags): New item LTO_cgraph_indirect_edge.
* ipa-prop.h (struct ipa_param_call_note): Removed.
(struct ipa_node_params): Removed field param_calls.
(ipa_create_all_structures_for_iinln): Declare.
* cgraph.c: Described indirect edges and uids in initial comment.
(cgraph_add_edge_to_call_site_hash): New function.
(cgraph_edge): Search also among the indirect edges, use
cgraph_add_edge_to_call_site_hash to add edges to the call site hash.
(cgraph_set_call_stmt): Possibly turn an indirect edge into a direct
one, use cgraph_add_edge_to_call_site_hash to add edges to the call
site hash.
(initialize_inline_failed): Assign a reason to indirect edges.
(cgraph_create_edge_1): New function.
(cgraph_create_edge): Moved some functionality to
cgraph_create_edge_1.
(cgraph_create_indirect_edge): New function.
(cgraph_edge_remove_callee): Add an assert checking for
non-indirectness.
(cgraph_edge_remove_caller): Special-case indirect edges.
(cgraph_remove_edge): Likewise.
(cgraph_set_edge_callee): New function.
(cgraph_redirect_edge_callee): Use cgraph_set_edge_callee.
(cgraph_make_edge_direct): New function.
(cgraph_update_edges_for_call_stmt_node): Do nothing only when also
the declaration of the call statement matches.
(cgraph_node_remove_callees): Special-case indirect edges.
(cgraph_clone_edge): Likewise.
(cgraph_clone_node): Clone also the indirect edges.
(dump_cgraph_node): Dump indirect_inlining_edge flag instead of
indirect_call, dump count of indirect_calls edges.
* ipa-prop.c (iinlining_processed_edges): New variable.
(ipa_note_param_call): Create indirect edges instead of
creating notes.  New parameter node.
(ipa_analyze_call_uses): New parameter node, pass it on to
ipa_note_param_call.
(ipa_analyze_stmt_uses): Likewise.
(ipa_analyze_params_uses): Pass node to ipa_analyze_stmt_uses.
(print_edge_addition_message): Work on edges rather than on notes.
(update_call_notes_after_inlining): Likewise, renamed to
update_indirect_edges_after_inlining.
(ipa_create_all_structures_for_iinln): New function.
(ipa_free_node_params_substructures): Do not free notes.
(ipa_edge_duplication_hook): Propagate bits within
iinlining_processed_edges bitmap.
(ipa_node_duplication_hook): Do not duplicate notes.
(free_all_ipa_structures_after_ipa_cp): Renamed to
ipa_free_all_structures_after_ipa_cp.
(free_all_ipa_structures_after_iinln): Renamed to
ipa_free_all_structures_after_iinln.g
(ipa_write_param_call_note): Removed.
(ipa_read_param_call_note): Removed.
(ipa_write_indirect_edge_info): New function.
(ipa_read_indirect_edge_info): Likewise.
(ipa_write_node_info): Do not stream notes, do stream information
in indirect edges.
(ipa_read_node_info): Likewise.
(lto_ipa_fixup_call_notes): Removed.
* ipa-cp.c (pass_ipa_cp): Set stmt_fixup to NULL.
* ipa-inline.c (pass_ipa_inline): Likewise.
* cgraphunit.c (verify_cgraph_node): Check also indirect edges.
* cif-code.def (INDIRECT_UNKNOWN_CALL): New reason.
* tree-inline.c (copy_bb): Removed an unnecessary double check for
is_gimple_call.
* tree-inline.c (get_indirect_callee_fndecl): Do not consider indirect
edges.
* lto-cgraph.c (output_outgoing_cgraph_edges): New function.
(output_cgraph): Stream also indirect edges.
(lto_output_edge): Added capability to stream indirect edges.
(input_edge): Likewise.
(input_cgraph_1): Likewise.

* testsuite/gcc.dg/lto/20091209-1_0.c: New testcase.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158827 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/cgraph.c
gcc/cgraph.h
gcc/cgraphunit.c
gcc/ipa-cp.c
gcc/ipa-inline.c
gcc/ipa-prop.c
gcc/lto-cgraph.c
gcc/testsuite/ChangeLog

index 3a13c62..f86bc5b 100644 (file)
@@ -1,3 +1,82 @@
+2010-04-28  Martin Jambor  <mjambor@suse.cz>
+
+       * cgraph.h (struct cgraph_node): New field indirect_calls.
+       (struct cgraph_indirect_call_info): New type.
+       (struct cgraph_edge): Removed field indirect_call. New fields
+       indirect_info, indirect_inlining_edge and indirect_unknown_callee.
+       (cgraph_create_indirect_edge): Declare.
+       (cgraph_make_edge_direct): Likewise.
+       (enum LTO_cgraph_tags): New item LTO_cgraph_indirect_edge.
+       * ipa-prop.h (struct ipa_param_call_note): Removed.
+       (struct ipa_node_params): Removed field param_calls.
+       (ipa_create_all_structures_for_iinln): Declare.
+       * cgraph.c: Described indirect edges and uids in initial comment.
+       (cgraph_add_edge_to_call_site_hash): New function.
+       (cgraph_edge): Search also among the indirect edges, use
+       cgraph_add_edge_to_call_site_hash to add edges to the call site hash.
+       (cgraph_set_call_stmt): Possibly turn an indirect edge into a direct
+       one, use cgraph_add_edge_to_call_site_hash to add edges to the call
+       site hash.
+       (initialize_inline_failed): Assign a reason to indirect edges.
+       (cgraph_create_edge_1): New function.
+       (cgraph_create_edge): Moved some functionality to
+       cgraph_create_edge_1.
+       (cgraph_create_indirect_edge): New function.
+       (cgraph_edge_remove_callee): Add an assert checking for
+       non-indirectness.
+       (cgraph_edge_remove_caller): Special-case indirect edges.
+       (cgraph_remove_edge): Likewise.
+       (cgraph_set_edge_callee): New function.
+       (cgraph_redirect_edge_callee): Use cgraph_set_edge_callee.
+       (cgraph_make_edge_direct): New function.
+       (cgraph_update_edges_for_call_stmt_node): Do nothing only when also
+       the declaration of the call statement matches.
+       (cgraph_node_remove_callees): Special-case indirect edges.
+       (cgraph_clone_edge): Likewise.
+       (cgraph_clone_node): Clone also the indirect edges.
+       (dump_cgraph_node): Dump indirect_inlining_edge flag instead of
+       indirect_call, dump count of indirect_calls edges.
+       * ipa-prop.c (iinlining_processed_edges): New variable.
+       (ipa_note_param_call): Create indirect edges instead of
+       creating notes.  New parameter node.
+       (ipa_analyze_call_uses): New parameter node, pass it on to
+       ipa_note_param_call.
+       (ipa_analyze_stmt_uses): Likewise.
+       (ipa_analyze_params_uses): Pass node to ipa_analyze_stmt_uses.
+       (print_edge_addition_message): Work on edges rather than on notes.
+       (update_call_notes_after_inlining): Likewise, renamed to
+       update_indirect_edges_after_inlining.
+       (ipa_create_all_structures_for_iinln): New function.
+       (ipa_free_node_params_substructures): Do not free notes.
+       (ipa_edge_duplication_hook): Propagate bits within
+       iinlining_processed_edges bitmap.
+       (ipa_node_duplication_hook): Do not duplicate notes.
+       (free_all_ipa_structures_after_ipa_cp): Renamed to
+       ipa_free_all_structures_after_ipa_cp.
+       (free_all_ipa_structures_after_iinln): Renamed to
+       ipa_free_all_structures_after_iinln.g
+       (ipa_write_param_call_note): Removed.
+       (ipa_read_param_call_note): Removed.
+       (ipa_write_indirect_edge_info): New function.
+       (ipa_read_indirect_edge_info): Likewise.
+       (ipa_write_node_info): Do not stream notes, do stream information
+       in indirect edges.
+       (ipa_read_node_info): Likewise.
+       (lto_ipa_fixup_call_notes): Removed.
+       * ipa-cp.c (pass_ipa_cp): Set stmt_fixup to NULL.
+       * ipa-inline.c (pass_ipa_inline): Likewise.
+       * cgraphunit.c (verify_cgraph_node): Check also indirect edges.
+       * cif-code.def (INDIRECT_UNKNOWN_CALL): New reason.
+       * tree-inline.c (copy_bb): Removed an unnecessary double check for
+       is_gimple_call.
+       * tree-inline.c (get_indirect_callee_fndecl): Do not consider indirect
+       edges.
+       * lto-cgraph.c (output_outgoing_cgraph_edges): New function.
+       (output_cgraph): Stream also indirect edges.
+       (lto_output_edge): Added capability to stream indirect edges.
+       (input_edge): Likewise.
+       (input_cgraph_1): Likewise.
+
 2010-04-28  Richard Guenther  <rguenther@suse.de>
 
        PR tree-optimization/43879
index 781d3b0..c7b619a 100644 (file)
@@ -34,10 +34,16 @@ The callgraph:
     based on DECL_UID.  The call-graph nodes are created lazily using
     cgraph_node function when called for unknown declaration.
 
-    The callgraph at the moment does not represent indirect calls or calls
-    from other compilation unit.  Flag NEEDED is set for each node that may
-    be accessed in such an invisible way and it shall be considered an
-    entry point to the callgraph.
+    The callgraph at the moment does not represent all indirect calls or calls
+    from other compilation units.  Flag NEEDED is set for each node that may be
+    accessed in such an invisible way and it shall be considered an entry point
+    to the callgraph.
+
+    On the other hand, the callgraph currently does contain some edges for
+    indirect calls with unknown callees which can be accessed through
+    indirect_calls field of a node.  It should be noted however that at the
+    moment only calls which are potential candidates for indirect inlining are
+    added there.
 
     Interprocedural information:
 
@@ -48,6 +54,9 @@ The callgraph:
       rtl_info used by RTL backend to propagate data from already compiled
       functions to their callers.
 
+      Moreover, each node has a uid which can be used to keep information in
+      on-the-side arrays.  UIDs are reused and therefore reasonably dense.
+
     Inlining plans:
 
       The function inlining information is decided in advance and maintained
@@ -723,6 +732,19 @@ edge_eq (const void *x, const void *y)
   return ((const struct cgraph_edge *) x)->call_stmt == y;
 }
 
+/* Add call graph edge E to call site hash of its caller.  */
+
+static inline void
+cgraph_add_edge_to_call_site_hash (struct cgraph_edge *e)
+{
+  void **slot;
+  slot = htab_find_slot_with_hash (e->caller->call_site_hash,
+                                  e->call_stmt,
+                                  htab_hash_pointer (e->call_stmt),
+                                  INSERT);
+  gcc_assert (!*slot);
+  *slot = e;
+}
 
 /* Return the callgraph edge representing the GIMPLE_CALL statement
    CALL_STMT.  */
@@ -743,26 +765,28 @@ cgraph_edge (struct cgraph_node *node, gimple call_stmt)
      solution.  It is not good idea to add pointer into CALL_EXPR itself
      because we want to make possible having multiple cgraph nodes representing
      different clones of the same body before the body is actually cloned.  */
-  for (e = node->callees; e; e= e->next_callee)
+  for (e = node->callees; e; e = e->next_callee)
     {
       if (e->call_stmt == call_stmt)
        break;
       n++;
     }
 
+  if (!e)
+    for (e = node->indirect_calls; e; e = e->next_callee)
+      {
+       if (e->call_stmt == call_stmt)
+         break;
+       n++;
+      }
+
   if (n > 100)
     {
       node->call_site_hash = htab_create_ggc (120, edge_hash, edge_eq, NULL);
       for (e2 = node->callees; e2; e2 = e2->next_callee)
-       {
-          void **slot;
-         slot = htab_find_slot_with_hash (node->call_site_hash,
-                                          e2->call_stmt,
-                                          htab_hash_pointer (e2->call_stmt),
-                                          INSERT);
-         gcc_assert (!*slot);
-         *slot = e2;
-       }
+       cgraph_add_edge_to_call_site_hash (e2);
+      for (e2 = node->indirect_calls; e2; e2 = e2->next_callee)
+       cgraph_add_edge_to_call_site_hash (e2);
     }
 
   return e;
@@ -774,26 +798,31 @@ cgraph_edge (struct cgraph_node *node, gimple call_stmt)
 void
 cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt)
 {
+  tree decl;
+
   if (e->caller->call_site_hash)
     {
       htab_remove_elt_with_hash (e->caller->call_site_hash,
                                 e->call_stmt,
                                 htab_hash_pointer (e->call_stmt));
     }
+
   e->call_stmt = new_stmt;
+  if (e->indirect_unknown_callee
+      && (decl = gimple_call_fndecl (new_stmt)))
+    {
+      /* Constant propagation (and possibly also inlining?) can turn an
+        indirect call into a direct one.  */
+      struct cgraph_node *new_callee = cgraph_node (decl);
+
+      cgraph_make_edge_direct (e, new_callee);
+    }
+
   push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
   e->can_throw_external = stmt_can_throw_external (new_stmt);
   pop_cfun ();
   if (e->caller->call_site_hash)
-    {
-      void **slot;
-      slot = htab_find_slot_with_hash (e->caller->call_site_hash,
-                                      e->call_stmt,
-                                      htab_hash_pointer
-                                      (e->call_stmt), INSERT);
-      gcc_assert (!*slot);
-      *slot = e;
-    }
+    cgraph_add_edge_to_call_site_hash (e);
 }
 
 /* Like cgraph_set_call_stmt but walk the clone tree and update all
@@ -895,7 +924,9 @@ initialize_inline_failed (struct cgraph_edge *e)
 {
   struct cgraph_node *callee = e->callee;
 
-  if (!callee->analyzed)
+  if (e->indirect_unknown_callee)
+    e->inline_failed = CIF_INDIRECT_UNKNOWN_CALL;
+  else if (!callee->analyzed)
     e->inline_failed = CIF_BODY_NOT_AVAILABLE;
   else if (callee->local.redefined_extern_inline)
     e->inline_failed = CIF_REDEFINED_EXTERN_INLINE;
@@ -907,15 +938,16 @@ initialize_inline_failed (struct cgraph_edge *e)
     e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
 }
 
-/* Create edge from CALLER to CALLEE in the cgraph.  */
+/* Allocate a cgraph_edge structure and fill it with data according to the
+   parameters of which only CALLEE can be NULL (when creating an indirect call
+   edge).  */
 
-struct cgraph_edge *
-cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
-                   gimple call_stmt, gcov_type count, int freq, int nest)
+static struct cgraph_edge *
+cgraph_create_edge_1 (struct cgraph_node *caller, struct cgraph_node *callee,
+                      gimple call_stmt, gcov_type count, int freq, int nest)
 {
   struct cgraph_edge *edge;
 
-
   /* LTO does not actually have access to the call_stmt since these
      have not been loaded yet.  */
   if (call_stmt)
@@ -941,47 +973,83 @@ cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
     }
 
   edge->aux = NULL;
-
   edge->caller = caller;
   edge->callee = callee;
+  edge->prev_caller = NULL;
+  edge->next_caller = NULL;
+  edge->prev_callee = NULL;
+  edge->next_callee = NULL;
+
+  edge->count = count;
+  gcc_assert (count >= 0);
+  edge->frequency = freq;
+  gcc_assert (freq >= 0);
+  gcc_assert (freq <= CGRAPH_FREQ_MAX);
+  edge->loop_nest = nest;
+
   edge->call_stmt = call_stmt;
   push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
   edge->can_throw_external
     = call_stmt ? stmt_can_throw_external (call_stmt) : false;
   pop_cfun ();
-  edge->prev_caller = NULL;
+  edge->call_stmt_cannot_inline_p =
+    (call_stmt ? gimple_call_cannot_inline_p (call_stmt) : false);
+  if (call_stmt && caller->call_site_hash)
+    cgraph_add_edge_to_call_site_hash (edge);
+
+  edge->indirect_info = NULL;
+  edge->indirect_inlining_edge = 0;
+
+  return edge;
+}
+
+/* Create edge from CALLER to CALLEE in the cgraph.  */
+
+struct cgraph_edge *
+cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
+                   gimple call_stmt, gcov_type count, int freq, int nest)
+{
+  struct cgraph_edge *edge = cgraph_create_edge_1 (caller, callee, call_stmt,
+                                                  count, freq, nest);
+
+  edge->indirect_unknown_callee = 0;
+  initialize_inline_failed (edge);
+
   edge->next_caller = callee->callers;
   if (callee->callers)
     callee->callers->prev_caller = edge;
-  edge->prev_callee = NULL;
   edge->next_callee = caller->callees;
   if (caller->callees)
     caller->callees->prev_callee = edge;
   caller->callees = edge;
   callee->callers = edge;
-  edge->count = count;
-  gcc_assert (count >= 0);
-  edge->frequency = freq;
-  gcc_assert (freq >= 0);
-  gcc_assert (freq <= CGRAPH_FREQ_MAX);
-  edge->loop_nest = nest;
-  edge->indirect_call = 0;
-  edge->call_stmt_cannot_inline_p =
-    (call_stmt ? gimple_call_cannot_inline_p (call_stmt) : false);
-  if (call_stmt && caller->call_site_hash)
-    {
-      void **slot;
-      slot = htab_find_slot_with_hash (caller->call_site_hash,
-                                      edge->call_stmt,
-                                      htab_hash_pointer
-                                        (edge->call_stmt),
-                                      INSERT);
-      gcc_assert (!*slot);
-      *slot = edge;
-    }
 
+  return edge;
+}
+
+
+/* Create an indirect edge with a yet-undetermined callee where the call
+   statement destination is a formal parameter of the caller with index
+   PARAM_INDEX. */
+
+struct cgraph_edge *
+cgraph_create_indirect_edge (struct cgraph_node *caller, gimple call_stmt,
+                            gcov_type count, int freq, int nest)
+{
+  struct cgraph_edge *edge = cgraph_create_edge_1 (caller, NULL, call_stmt,
+                                                  count, freq, nest);
+
+  edge->indirect_unknown_callee = 1;
   initialize_inline_failed (edge);
 
+  edge->indirect_info = GGC_NEW (struct cgraph_indirect_call_info);
+  edge->indirect_info->param_index = -1;
+
+  edge->next_callee = caller->indirect_calls;
+  if (caller->indirect_calls)
+    caller->indirect_calls->prev_callee = edge;
+  caller->indirect_calls = edge;
+
   return edge;
 }
 
@@ -990,6 +1058,7 @@ cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
 static inline void
 cgraph_edge_remove_callee (struct cgraph_edge *e)
 {
+  gcc_assert (!e->indirect_unknown_callee);
   if (e->prev_caller)
     e->prev_caller->next_caller = e->next_caller;
   if (e->next_caller)
@@ -1008,7 +1077,12 @@ cgraph_edge_remove_caller (struct cgraph_edge *e)
   if (e->next_callee)
     e->next_callee->prev_callee = e->prev_callee;
   if (!e->prev_callee)
-    e->caller->callees = e->next_callee;
+    {
+      if (e->indirect_unknown_callee)
+       e->caller->indirect_calls = e->next_callee;
+      else
+       e->caller->callees = e->next_callee;
+    }
   if (e->caller->call_site_hash)
     htab_remove_elt_with_hash (e->caller->call_site_hash,
                               e->call_stmt,
@@ -1037,8 +1111,9 @@ cgraph_remove_edge (struct cgraph_edge *e)
   /* Call all edge removal hooks.  */
   cgraph_call_edge_removal_hooks (e);
 
-  /* Remove from callers list of the callee.  */
-  cgraph_edge_remove_callee (e);
+  if (!e->indirect_unknown_callee)
+    /* Remove from callers list of the callee.  */
+    cgraph_edge_remove_callee (e);
 
   /* Remove from callees list of the callers.  */
   cgraph_edge_remove_caller (e);
@@ -1047,6 +1122,20 @@ cgraph_remove_edge (struct cgraph_edge *e)
   cgraph_free_edge (e);
 }
 
+/* Set callee of call graph edge E and add it to the corresponding set of
+   callers. */
+
+static void
+cgraph_set_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
+{
+  e->prev_caller = NULL;
+  if (n->callers)
+    n->callers->prev_caller = e;
+  e->next_caller = n->callers;
+  n->callers = e;
+  e->callee = n;
+}
+
 /* Redirect callee of E to N.  The function does not update underlying
    call expression.  */
 
@@ -1057,12 +1146,37 @@ cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
   cgraph_edge_remove_callee (e);
 
   /* Insert to callers list of the new callee.  */
-  e->prev_caller = NULL;
-  if (n->callers)
-    n->callers->prev_caller = e;
-  e->next_caller = n->callers;
-  n->callers = e;
-  e->callee = n;
+  cgraph_set_edge_callee (e, n);
+}
+
+/* Make an indirect EDGE with an unknown callee an ordinary edge leading to
+   CALLEE.  */
+
+void
+cgraph_make_edge_direct (struct cgraph_edge *edge, struct cgraph_node *callee)
+{
+  edge->indirect_unknown_callee = 0;
+
+  /* Get the edge out of the indirect edge list. */
+  if (edge->prev_callee)
+    edge->prev_callee->next_callee = edge->next_callee;
+  if (edge->next_callee)
+    edge->next_callee->prev_callee = edge->prev_callee;
+  if (!edge->prev_callee)
+    edge->caller->indirect_calls = edge->next_callee;
+
+  /* Put it into the normal callee list */
+  edge->prev_callee = NULL;
+  edge->next_callee = edge->caller->callees;
+  if (edge->caller->callees)
+    edge->caller->callees->prev_callee = edge;
+  edge->caller->callees = edge;
+
+  /* Insert to callers list of the new callee.  */
+  cgraph_set_edge_callee (edge, callee);
+
+  /* We need to re-determine the inlining status of the edge.  */
+  initialize_inline_failed (edge);
 }
 
 
@@ -1091,9 +1205,10 @@ cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
 
       if (e)
        {
-         /* See if the call is already there.  It might be because of indirect
-            inlining already found it.  */
-         if (new_call && e->callee->decl == new_call)
+         /* See if the edge is already there and has the correct callee.  It
+            might be so because of indirect inlining has already updated
+            it.  */
+         if (new_call && e->callee && e->callee->decl == new_call)
            return;
 
          /* Otherwise remove edge and create new one; we can't simply redirect
@@ -1171,7 +1286,8 @@ cgraph_node_remove_callees (struct cgraph_node *node)
     {
       f = e->next_callee;
       cgraph_call_edge_removal_hooks (e);
-      cgraph_edge_remove_callee (e);
+      if (!e->indirect_unknown_callee)
+       cgraph_edge_remove_callee (e);
       cgraph_free_edge (e);
     }
   node->callees = NULL;
@@ -1627,6 +1743,8 @@ void
 dump_cgraph_node (FILE *f, struct cgraph_node *node)
 {
   struct cgraph_edge *edge;
+  int indirect_calls_count = 0;
+
   fprintf (f, "%s/%i(%i)", cgraph_node_name (node), node->uid,
           node->pid);
   dump_addr (f, " @", (void *)node);
@@ -1708,8 +1826,8 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
                 edge->frequency / (double)CGRAPH_FREQ_BASE);
       if (!edge->inline_failed)
        fprintf(f, "(inlined) ");
-      if (edge->indirect_call)
-       fprintf(f, "(indirect) ");
+      if (edge->indirect_inlining_edge)
+       fprintf(f, "(indirect_inlining) ");
       if (edge->can_throw_external)
        fprintf(f, "(can throw external) ");
     }
@@ -1721,8 +1839,8 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
               edge->callee->uid);
       if (!edge->inline_failed)
        fprintf(f, "(inlined) ");
-      if (edge->indirect_call)
-       fprintf(f, "(indirect) ");
+      if (edge->indirect_inlining_edge)
+       fprintf(f, "(indirect_inlining) ");
       if (edge->count)
        fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
                 (HOST_WIDEST_INT)edge->count);
@@ -1736,6 +1854,12 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
     }
   fprintf (f, "\n");
 
+  for (edge = node->indirect_calls; edge; edge = edge->next_callee)
+    indirect_calls_count++;
+  if (indirect_calls_count)
+    fprintf (f, "  has %i outgoing edges for indirect calls.\n",
+            indirect_calls_count);
+
   if (node->same_body)
     {
       struct cgraph_node *n;
@@ -1855,11 +1979,30 @@ cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
   freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
   if (freq > CGRAPH_FREQ_MAX)
     freq = CGRAPH_FREQ_MAX;
-  new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
-                           e->loop_nest + loop_nest);
+
+  if (e->indirect_unknown_callee)
+    {
+      tree decl;
+
+      if (call_stmt && (decl = gimple_call_fndecl (call_stmt)))
+       {
+         struct cgraph_node *callee = cgraph_node (decl);
+         new_edge = cgraph_create_edge (n, callee, call_stmt, count, freq,
+                                        e->loop_nest + loop_nest);
+       }
+      else
+       {
+         new_edge = cgraph_create_indirect_edge (n, call_stmt, count, freq,
+                                                 e->loop_nest + loop_nest);
+         new_edge->indirect_info->param_index = e->indirect_info->param_index;
+       }
+    }
+  else
+    new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
+                                  e->loop_nest + loop_nest);
 
   new_edge->inline_failed = e->inline_failed;
-  new_edge->indirect_call = e->indirect_call;
+  new_edge->indirect_inlining_edge = e->indirect_inlining_edge;
   new_edge->lto_stmt_uid = stmt_uid;
   if (update_original)
     {
@@ -1933,6 +2076,10 @@ cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq,
     cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
                       count_scale, freq, loop_nest, update_original);
 
+  for (e = n->indirect_calls; e; e = e->next_callee)
+    cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
+                      count_scale, freq, loop_nest, update_original);
+
   new_node->next_sibling_clone = n->clones;
   if (n->clones)
     n->clones->prev_sibling_clone = new_node;
index c208cfa..1bd4b2c 100644 (file)
@@ -199,6 +199,9 @@ struct GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) cgraph_node {
   struct cgraph_edge *callers;
   struct cgraph_node *next;
   struct cgraph_node *previous;
+  /* List of edges representing indirect calls with a yet undetermined
+     callee.  */
+  struct cgraph_edge *indirect_calls;
   /* For nested functions points to function the node is nested in.  */
   struct cgraph_node *origin;
   /* Points to first nested function, if any.  */
@@ -333,6 +336,14 @@ typedef enum {
   CIF_N_REASONS
 } cgraph_inline_failed_t;
 
+/* Structure containing additional information about an indirect call.  */
+
+struct GTY(()) cgraph_indirect_call_info
+{
+  /* Index of the parameter that is called.  */
+  int param_index;
+};
+
 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge {
   /* Expected number of executions: calculated in profile.c.  */
   gcov_type count;
@@ -343,6 +354,9 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgrap
   struct cgraph_edge *prev_callee;
   struct cgraph_edge *next_callee;
   gimple call_stmt;
+  /* Additional information about an indirect call.  Not cleared when an edge
+     becomes direct.  */
+  struct cgraph_indirect_call_info *indirect_info;
   PTR GTY ((skip (""))) aux;
   /* When equal to CIF_OK, inline this call.  Otherwise, points to the
      explanation why function was not inlined.  */
@@ -358,8 +372,12 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgrap
   int uid;
   /* Depth of loop nest, 1 means no loop nest.  */
   unsigned short int loop_nest;
-  /* Whether this edge describes a call that was originally indirect.  */
-  unsigned int indirect_call : 1;
+  /* Whether this edge was made direct by indirect inlining.  */
+  unsigned int indirect_inlining_edge : 1;
+  /* Whether this edge describes an indirect call with an undetermined
+     callee.  */
+  unsigned int indirect_unknown_callee : 1;
+  /* Whether this edge is still a dangling  */
   /* True if the corresponding CALL stmt cannot be inlined.  */
   unsigned int call_stmt_cannot_inline_p : 1;
   /* Can this call throw externally?  */
@@ -461,7 +479,8 @@ void cgraph_node_remove_callees (struct cgraph_node *node);
 struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
                                        struct cgraph_node *,
                                        gimple, gcov_type, int, int);
-
+struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple,
+                                                gcov_type, int, int);
 struct cgraph_node * cgraph_get_node (tree);
 struct cgraph_node *cgraph_node (tree);
 bool cgraph_same_body_alias (tree, tree);
@@ -487,6 +506,7 @@ struct cgraph_node * cgraph_clone_node (struct cgraph_node *, gcov_type, int,
                                        int, bool, VEC(cgraph_edge_p,heap) *);
 
 void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *);
+void cgraph_make_edge_direct (struct cgraph_edge *, struct cgraph_node *);
 
 struct cgraph_asm_node *cgraph_add_asm_node (tree);
 
@@ -657,6 +677,7 @@ enum LTO_cgraph_tags
   LTO_cgraph_overwritable_node,
   LTO_cgraph_unavail_node,
   LTO_cgraph_edge,
+  LTO_cgraph_indirect_edge,
   LTO_cgraph_last_tag
 };
 
index 51b4732..5ace85b 100644 (file)
@@ -607,6 +607,24 @@ verify_cgraph_node (struct cgraph_node *node)
       error ("Inline clone is needed");
       error_found = true;
     }
+  for (e = node->indirect_calls; e; e = e->next_callee)
+    {
+      if (e->aux)
+       {
+         error ("aux field set for indirect edge from %s",
+                identifier_to_locale (cgraph_node_name (e->caller)));
+         error_found = true;
+       }
+      if (!e->indirect_unknown_callee
+         || !e->indirect_info)
+       {
+         error ("An indirect edge from %s is not marked as indirect or has "
+                "associated indirect_info, the corresponding statement is: ",
+                identifier_to_locale (cgraph_node_name (e->caller)));
+         debug_gimple_stmt (e->call_stmt);
+         error_found = true;
+       }
+    }
   for (e = node->callers; e; e = e->next_caller)
     {
       if (e->count < 0)
@@ -759,10 +777,10 @@ verify_cgraph_node (struct cgraph_node *node)
                  gsi_next (&gsi))
              {
                gimple stmt = gsi_stmt (gsi);
-               tree decl;
-               if (is_gimple_call (stmt) && (decl = gimple_call_fndecl (stmt)))
+               if (is_gimple_call (stmt))
                  {
                    struct cgraph_edge *e = cgraph_edge (node, stmt);
+                   tree decl = gimple_call_fndecl (stmt);
                    if (e)
                      {
                        if (e->aux)
@@ -771,25 +789,38 @@ verify_cgraph_node (struct cgraph_node *node)
                            debug_gimple_stmt (stmt);
                            error_found = true;
                          }
-                       if (e->callee->same_body_alias)
+                       if (!e->indirect_unknown_callee)
                          {
-                           error ("edge points to same body alias:");
-                           debug_tree (e->callee->decl);
-                           error_found = true;
+                           if (e->callee->same_body_alias)
+                             {
+                               error ("edge points to same body alias:");
+                               debug_tree (e->callee->decl);
+                               error_found = true;
+                             }
+                           else if (!node->global.inlined_to
+                                    && !e->callee->global.inlined_to
+                                    && decl
+                                    && !clone_of_p (cgraph_node (decl),
+                                                    e->callee))
+                             {
+                               error ("edge points to wrong declaration:");
+                               debug_tree (e->callee->decl);
+                               fprintf (stderr," Instead of:");
+                               debug_tree (decl);
+                               error_found = true;
+                             }
                          }
-                       else if (!node->global.inlined_to
-                                && !e->callee->global.inlined_to
-                                && !clone_of_p (cgraph_node (decl), e->callee))
+                       else if (decl)
                          {
-                           error ("edge points to wrong declaration:");
-                           debug_tree (e->callee->decl);
-                           fprintf (stderr," Instead of:");
-                           debug_tree (decl);
+                           error ("an indirect edge with unknown callee "
+                                  "corresponding to a call_stmt with "
+                                  "a known declaration:");
                            error_found = true;
+                           debug_gimple_stmt (e->call_stmt);
                          }
                        e->aux = (void *)1;
                      }
-                   else
+                   else if (decl)
                      {
                        error ("missing callgraph edge for call stmt:");
                        debug_gimple_stmt (stmt);
@@ -805,7 +836,7 @@ verify_cgraph_node (struct cgraph_node *node)
 
       for (e = node->callees; e; e = e->next_callee)
        {
-         if (!e->aux && !e->indirect_call)
+         if (!e->aux)
            {
              error ("edge %s->%s has no corresponding call_stmt",
                     identifier_to_locale (cgraph_node_name (e->caller)),
@@ -815,6 +846,17 @@ verify_cgraph_node (struct cgraph_node *node)
            }
          e->aux = 0;
        }
+      for (e = node->indirect_calls; e; e = e->next_callee)
+       {
+         if (!e->aux)
+           {
+             error ("an indirect edge from %s has no corresponding call_stmt",
+                    identifier_to_locale (cgraph_node_name (e->caller)));
+             debug_gimple_stmt (e->call_stmt);
+             error_found = true;
+           }
+         e->aux = 0;
+       }
     }
   if (error_found)
     {
index ca7c0e6..74d365e 100644 (file)
@@ -1282,7 +1282,7 @@ ipcp_driver (void)
       ipcp_print_profile_data (dump_file);
     }
   /* Free all IPCP structures.  */
-  free_all_ipa_structures_after_ipa_cp ();
+  ipa_free_all_structures_after_ipa_cp ();
   if (dump_file)
     fprintf (dump_file, "\nIPA constant propagation end\n");
   return 0;
@@ -1346,7 +1346,7 @@ struct ipa_opt_pass_d pass_ipa_cp =
  ipcp_read_summary,                    /* read_summary */
  NULL,                                 /* write_optimization_summary */
  NULL,                                 /* read_optimization_summary */
lto_ipa_fixup_call_notes,             /* stmt_fixup */
NULL,                                 /* stmt_fixup */
  0,                                    /* TODOs */
  NULL,                                 /* function_transform */
  NULL,                                 /* variable_transform */
index 381942a..75adb01 100644 (file)
@@ -1322,6 +1322,8 @@ cgraph_decide_inlining (void)
   cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
   if (in_lto_p && flag_indirect_inlining)
     ipa_update_after_lto_read ();
+  if (flag_indirect_inlining)
+    ipa_create_all_structures_for_iinln ();
 
   max_count = 0;
   max_benefit = 0;
@@ -1442,7 +1444,7 @@ cgraph_decide_inlining (void)
 
   /* Free ipa-prop structures if they are no longer needed.  */
   if (flag_indirect_inlining)
-    free_all_ipa_structures_after_iinln ();
+    ipa_free_all_structures_after_iinln ();
 
   if (dump_file)
     fprintf (dump_file,
@@ -2138,7 +2140,7 @@ struct ipa_opt_pass_d pass_ipa_inline =
  inline_read_summary,                  /* read_summary */
  NULL,                                 /* write_optimization_summary */
  NULL,                                 /* read_optimization_summary */
lto_ipa_fixup_call_notes,             /* stmt_fixup */
NULL,                                 /* stmt_fixup */
  0,                                    /* TODOs */
  inline_transform,                     /* function_transform */
  NULL,                                 /* variable_transform */
index 6437389..7ab3a3e 100644 (file)
@@ -30,7 +30,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-flow.h"
 #include "tree-pass.h"
 #include "tree-inline.h"
-#include "gimple.h"
 #include "flags.h"
 #include "timevar.h"
 #include "flags.h"
@@ -211,29 +210,6 @@ visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
       int index = ipa_get_param_decl_index (info, op);
       gcc_assert (index >= 0);
       info->params[index].modified = true;
-      info->params[index].used = true;
-    }
-
-  return false;
-}
-
-/* Callback of walk_stmt_load_store_addr_ops for the visit_load.
-   If OP is a parameter declaration, mark it as used in the info structure
-   passed in DATA.  */
-
-static bool
-visit_load_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
-                            tree op, void *data)
-{
-  struct ipa_node_params *info = (struct ipa_node_params *) data;
-
-  op = get_base_address (op);
-  if (op
-      && TREE_CODE (op) == PARM_DECL)
-    {
-      int index = ipa_get_param_decl_index (info, op);
-      gcc_assert (index >= 0);
-      info->params[index].used = true;
     }
 
   return false;
@@ -252,35 +228,16 @@ ipa_detect_param_modifications (struct cgraph_node *node)
   struct function *func;
   gimple_stmt_iterator gsi;
   struct ipa_node_params *info = IPA_NODE_REF (node);
-  int i;
 
   if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
     return;
 
-  for (i = 0; i < ipa_get_param_count (info); i++)
-    {
-      tree parm = ipa_get_param (info, i);
-      /* For SSA regs see if parameter is used.  For non-SSA we compute
-        the flag during modification analysis.  */
-      if (is_gimple_reg (parm)
-         && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
-       info->params[i].used = true;
-    }
-
   func = DECL_STRUCT_FUNCTION (decl);
   FOR_EACH_BB_FN (bb, func)
-    {
-      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-       walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
-                                      visit_load_for_mod_analysis,
-                                      visit_store_addr_for_mod_analysis,
-                                      visit_store_addr_for_mod_analysis);
-      for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
-       walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
-                                      visit_load_for_mod_analysis,
-                                      visit_store_addr_for_mod_analysis,
-                                      visit_store_addr_for_mod_analysis);
-    }
+    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+      walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info, NULL,
+                                    visit_store_addr_for_mod_analysis,
+                                    visit_store_addr_for_mod_analysis);
 
   info->modification_analysis_done = 1;
 }
@@ -333,13 +290,6 @@ ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
          fprintf (f, "       param %d: ", i);
          if (type == IPA_JF_UNKNOWN)
            fprintf (f, "UNKNOWN\n");
-         else if (type == IPA_JF_KNOWN_TYPE)
-           {
-             tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
-             fprintf (f, "KNOWN TYPE, type in binfo is: ");
-             print_generic_expr (f, binfo_type, 0);
-             fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
-           }
          else if (type == IPA_JF_CONST)
            {
              tree val = jump_func->value.constant;
@@ -377,11 +327,9 @@ ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
          else if (type == IPA_JF_ANCESTOR)
            {
              fprintf (f, "ANCESTOR: ");
-             fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC"",
+             fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC"\n",
                       jump_func->value.ancestor.formal_id,
                       jump_func->value.ancestor.offset);
-             print_generic_expr (f, jump_func->value.ancestor.type, 0);
-             fprintf (dump_file, "\n");
            }
        }
     }
@@ -401,60 +349,51 @@ ipa_print_all_jump_functions (FILE *f)
     }
 }
 
-/* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
-   of an assignment statement STMT, try to find out whether NAME can be
-   described by a (possibly polynomial) pass-through jump-function or an
-   ancestor jump function and if so, write the appropriate function into
-   JFUNC */
+/* Determine whether passing ssa name NAME constitutes a polynomial
+   pass-through function or getting an address of an acestor and if so, write
+   such a jump function to JFUNC.  INFO describes the caller.  */
 
 static void
-compute_complex_assign_jump_func (struct ipa_node_params *info,
-                                 struct ipa_jump_func *jfunc,
-                                 gimple stmt, tree name)
+compute_complex_pass_through (struct ipa_node_params *info,
+                             struct ipa_jump_func *jfunc,
+                             tree name)
 {
   HOST_WIDE_INT offset, size, max_size;
   tree op1, op2, type;
   int index;
+  gimple stmt = SSA_NAME_DEF_STMT (name);
 
+  if (!is_gimple_assign (stmt))
+    return;
   op1 = gimple_assign_rhs1 (stmt);
   op2 = gimple_assign_rhs2 (stmt);
 
-  if (TREE_CODE (op1) == SSA_NAME
-      && SSA_NAME_IS_DEFAULT_DEF (op1))
+  if (op2)
     {
-      index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
-      if (index < 0)
+      if (TREE_CODE (op1) != SSA_NAME
+         || !SSA_NAME_IS_DEFAULT_DEF (op1)
+         || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
+             && !useless_type_conversion_p (TREE_TYPE (name),
+                                            TREE_TYPE (op1)))
+         || !is_gimple_ip_invariant (op2))
        return;
 
-      if (op2)
+      index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
+      if (index >= 0)
        {
-         if (!is_gimple_ip_invariant (op2)
-             || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
-                 && !useless_type_conversion_p (TREE_TYPE (name),
-                                                TREE_TYPE (op1))))
-           return;
-
          jfunc->type = IPA_JF_PASS_THROUGH;
          jfunc->value.pass_through.formal_id = index;
          jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
          jfunc->value.pass_through.operand = op2;
        }
-      else if (gimple_assign_unary_nop_p (stmt))
-       {
-         jfunc->type = IPA_JF_PASS_THROUGH;
-         jfunc->value.pass_through.formal_id = index;
-         jfunc->value.pass_through.operation = NOP_EXPR;
-       }
       return;
     }
 
   if (TREE_CODE (op1) != ADDR_EXPR)
     return;
-
   op1 = TREE_OPERAND (op1, 0);
   type = TREE_TYPE (op1);
-  if (TREE_CODE (type) != RECORD_TYPE)
-    return;
+
   op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
   if (TREE_CODE (op1) != INDIRECT_REF
       /* If this is a varying address, punt.  */
@@ -477,120 +416,6 @@ compute_complex_assign_jump_func (struct ipa_node_params *info,
 }
 
 
-/* Given that an actual argument is an SSA_NAME that is a result of a phi
-   statement PHI, try to find out whether NAME is in fact a
-   multiple-inheritance typecast from a descendant into an ancestor of a formal
-   parameter and thus can be described by an ancestor jump function and if so,
-   write the appropriate function into JFUNC.
-
-   Essentially we want to match the following pattern:
-
-     if (obj_2(D) != 0B)
-       goto <bb 3>;
-     else
-       goto <bb 4>;
-
-   <bb 3>:
-     iftmp.1_3 = &obj_2(D)->D.1762;
-
-   <bb 4>:
-     # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
-     D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
-     return D.1879_6;  */
-
-static void
-compute_complex_ancestor_jump_func (struct ipa_node_params *info,
-                                   struct ipa_jump_func *jfunc,
-                                   gimple phi)
-{
-  HOST_WIDE_INT offset, size, max_size;
-  gimple assign, cond;
-  basic_block phi_bb, assign_bb, cond_bb;
-  tree tmp, parm, expr;
-  int index, i;
-
-  if (gimple_phi_num_args (phi) != 2
-      || !integer_zerop (PHI_ARG_DEF (phi, 1)))
-    return;
-
-  tmp = PHI_ARG_DEF (phi, 0);
-  if (TREE_CODE (tmp) != SSA_NAME
-      || SSA_NAME_IS_DEFAULT_DEF (tmp)
-      || !POINTER_TYPE_P (TREE_TYPE (tmp))
-      || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
-    return;
-
-  assign = SSA_NAME_DEF_STMT (tmp);
-  assign_bb = gimple_bb (assign);
-  if (!single_pred_p (assign_bb)
-      || !gimple_assign_single_p (assign))
-    return;
-  expr = gimple_assign_rhs1 (assign);
-
-  if (TREE_CODE (expr) != ADDR_EXPR)
-    return;
-  expr = TREE_OPERAND (expr, 0);
-  expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
-
-  if (TREE_CODE (expr) != INDIRECT_REF
-      /* If this is a varying address, punt.  */
-      || max_size == -1
-      || max_size != size)
-    return;
-  parm = TREE_OPERAND (expr, 0);
-  if (TREE_CODE (parm) != SSA_NAME
-      || !SSA_NAME_IS_DEFAULT_DEF (parm))
-    return;
-
-  index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
-  if (index < 0)
-    return;
-
-  cond_bb = single_pred (assign_bb);
-  cond = last_stmt (cond_bb);
-  if (gimple_code (cond) != GIMPLE_COND
-      || gimple_cond_code (cond) != NE_EXPR
-      || gimple_cond_lhs (cond) != parm
-      || !integer_zerop (gimple_cond_rhs (cond)))
-    return;
-
-
-  phi_bb = gimple_bb (phi);
-  for (i = 0; i < 2; i++)
-    {
-      basic_block pred = EDGE_PRED (phi_bb, i)->src;
-      if (pred != assign_bb && pred != cond_bb)
-       return;
-    }
-
-  jfunc->type = IPA_JF_ANCESTOR;
-  jfunc->value.ancestor.formal_id = index;
-  jfunc->value.ancestor.offset = offset;
-  jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
-}
-
-/* Given OP whch is passed as an actual argument to a called function,
-   determine if it is possible to construct a KNOWN_TYPE jump function for it
-   and if so, create one and store it to JFUNC.  */
-
-static void
-compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
-{
-  tree binfo;
-
-  if (TREE_CODE (op) != ADDR_EXPR)
-    return;
-
-  op = TREE_OPERAND (op, 0);
-  binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
-  if (binfo)
-    {
-      jfunc->type = IPA_JF_KNOWN_TYPE;
-      jfunc->value.base_binfo = binfo;
-    }
-}
-
-
 /* Determine the jump functions of scalar arguments.  Scalar means SSA names
    and constants of a number of selected types.  INFO is the ipa_node_params
    structure associated with the caller, FUNCTIONS is a pointer to an array of
@@ -628,18 +453,8 @@ compute_scalar_jump_functions (struct ipa_node_params *info,
                }
            }
          else
-           {
-             gimple stmt = SSA_NAME_DEF_STMT (arg);
-             if (is_gimple_assign (stmt))
-               compute_complex_assign_jump_func (info, &functions[num],
-                                                 stmt, arg);
-             else if (gimple_code (stmt) == GIMPLE_PHI)
-               compute_complex_ancestor_jump_func (info, &functions[num],
-                                                   stmt);
-           }
+           compute_complex_pass_through (info, &functions[num], arg);
        }
-      else
-       compute_known_type_jump_func (arg, &functions[num]);
     }
 }
 
@@ -934,29 +749,21 @@ ipa_is_ssa_with_stmt_def (tree t)
     return false;
 }
 
-/* Find the indirect call graph edge corresponding to STMT and add to it all
-   information necessary to describe a call to a parameter number PARAM_INDEX.
-   NODE is the caller.  POLYMORPHIC should be set to true iff the call is a
-   virtual one.  */
+/* Create a new indirect call graph edge describing a call to a parameter
+   number FORMAL_ID and and set the called flag of the parameter.  NODE is the
+   caller.  STMT is the corresponding call statement.  */
 
 static void
-ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
-                    bool polymorphic)
+ipa_note_param_call (struct cgraph_node *node, int formal_id, gimple stmt)
 {
   struct cgraph_edge *cs;
+  basic_block bb = gimple_bb (stmt);
+  int freq;
 
-  cs = cgraph_edge (node, stmt);
-  cs->indirect_info->param_index = param_index;
-  cs->indirect_info->anc_offset = 0;
-  cs->indirect_info->polymorphic = polymorphic;
-  if (polymorphic)
-    {
-      tree otr = gimple_call_fn (stmt);
-      tree type, token = OBJ_TYPE_REF_TOKEN (otr);
-      cs->indirect_info->otr_token = tree_low_cst (token, 1);
-      type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
-      cs->indirect_info->otr_type = type;
-    }
+  freq = compute_call_stmt_bb_frequency (current_function_decl, bb);
+  cs = cgraph_create_indirect_edge (node, stmt, bb->count, freq,
+                                   bb->loop_depth);
+  cs->indirect_info->param_index = formal_id;
 }
 
 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
@@ -1006,11 +813,12 @@ ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
 */
 
 static void
-ipa_analyze_indirect_call_uses (struct cgraph_node *node,
-                               struct ipa_node_params *info,
-                               gimple call, tree target)
+ipa_analyze_call_uses (struct cgraph_node *node, struct ipa_node_params *info,
+                      gimple call)
 {
+  tree target = gimple_call_fn (call);
   gimple def;
+  tree var;
   tree n1, n2;
   gimple d1, d2;
   tree rec, rec2, cond;
@@ -1018,12 +826,16 @@ ipa_analyze_indirect_call_uses (struct cgraph_node *node,
   int index;
   basic_block bb, virt_bb, join;
 
+  if (TREE_CODE (target) != SSA_NAME)
+    return;
+
+  var = SSA_NAME_VAR (target);
   if (SSA_NAME_IS_DEFAULT_DEF (target))
     {
-      tree var = SSA_NAME_VAR (target);
+      /* assuming TREE_CODE (var) == PARM_DECL */
       index = ipa_get_param_decl_index (info, var);
       if (index >= 0)
-       ipa_note_param_call (node, index, call, false);
+       ipa_note_param_call (node, index, call);
       return;
     }
 
@@ -1120,63 +932,11 @@ ipa_analyze_indirect_call_uses (struct cgraph_node *node,
 
   index = ipa_get_param_decl_index (info, rec);
   if (index >= 0 && !ipa_is_param_modified (info, index))
-    ipa_note_param_call (node, index, call, false);
+    ipa_note_param_call (node, index, call);
 
   return;
 }
 
-/* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
-   object referenced in the expression is a formal parameter of the caller
-   (described by INFO), create a call note for the statement. */
-
-static void
-ipa_analyze_virtual_call_uses (struct cgraph_node *node,
-                              struct ipa_node_params *info, gimple call,
-                              tree target)
-{
-  tree obj = OBJ_TYPE_REF_OBJECT (target);
-  tree var;
-  int index;
-
-  if (TREE_CODE (obj) == ADDR_EXPR)
-    {
-      do
-       {
-         obj = TREE_OPERAND (obj, 0);
-       }
-      while (TREE_CODE (obj) == COMPONENT_REF);
-      if (TREE_CODE (obj) != INDIRECT_REF)
-       return;
-      obj = TREE_OPERAND (obj, 0);
-    }
-
-  if (TREE_CODE (obj) != SSA_NAME
-      || !SSA_NAME_IS_DEFAULT_DEF (obj))
-    return;
-
-  var = SSA_NAME_VAR (obj);
-  index = ipa_get_param_decl_index (info, var);
-
-  if (index >= 0)
-    ipa_note_param_call (node, index, call, true);
-}
-
-/* Analyze a call statement CALL whether and how it utilizes formal parameters
-   of the caller (described by INFO). */
-
-static void
-ipa_analyze_call_uses (struct cgraph_node *node,
-                      struct ipa_node_params *info, gimple call)
-{
-  tree target = gimple_call_fn (call);
-
-  if (TREE_CODE (target) == SSA_NAME)
-    ipa_analyze_indirect_call_uses (node, info, call, target);
-  else if (TREE_CODE (target) == OBJ_TYPE_REF)
-    ipa_analyze_virtual_call_uses (node, info, call, target);
-}
-
-
 /* Analyze the call statement STMT with respect to formal parameters (described
    in INFO) of caller given by NODE.  Currently it only checks whether formal
    parameters are called.  */
@@ -1218,31 +978,12 @@ ipa_analyze_params_uses (struct cgraph_node *node)
   info->uses_analysis_done = 1;
 }
 
-/* Update the jump function DST when the call graph edge correspondng to SRC is
-   is being inlined, knowing that DST is of type ancestor and src of known
-   type.  */
-
-static void
-combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
-                                    struct ipa_jump_func *dst)
-{
-  tree new_binfo;
-
-  new_binfo = get_binfo_at_offset (src->value.base_binfo,
-                                  dst->value.ancestor.offset,
-                                  dst->value.ancestor.type);
-  if (new_binfo)
-    {
-      dst->type = IPA_JF_KNOWN_TYPE;
-      dst->value.base_binfo = new_binfo;
-    }
-  else
-    dst->type = IPA_JF_UNKNOWN;
-}
-
 /* Update the jump functions associated with call graph edge E when the call
    graph edge CS is being inlined, assuming that E->caller is already (possibly
-   indirectly) inlined into CS->callee and that E has not been inlined.  */
+   indirectly) inlined into CS->callee and that E has not been inlined.
+
+   We keep pass through functions only if they do not contain any operation.
+   This is sufficient for inlining and greately simplifies things.  */
 
 static void
 update_jump_functions_after_inlining (struct cgraph_edge *cs,
@@ -1255,161 +996,51 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
 
   for (i = 0; i < count; i++)
     {
-      struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
+      struct ipa_jump_func *src, *dst = ipa_get_ith_jump_func (args, i);
 
       if (dst->type == IPA_JF_ANCESTOR)
        {
-         struct ipa_jump_func *src;
-
-         /* Variable number of arguments can cause havoc if we try to access
-            one that does not exist in the inlined edge.  So make sure we
-            don't.  */
-         if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
-           {
-             dst->type = IPA_JF_UNKNOWN;
-             continue;
-           }
+         dst->type = IPA_JF_UNKNOWN;
+         continue;
+       }
 
-         src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
-         if (src->type == IPA_JF_KNOWN_TYPE)
-           combine_known_type_and_ancestor_jfs (src, dst);
-         else if (src->type == IPA_JF_CONST)
-           {
-             struct ipa_jump_func kt_func;
+      if (dst->type != IPA_JF_PASS_THROUGH)
+       continue;
 
-             kt_func.type = IPA_JF_UNKNOWN;
-             compute_known_type_jump_func (src->value.constant, &kt_func);
-             if (kt_func.type == IPA_JF_KNOWN_TYPE)
-               combine_known_type_and_ancestor_jfs (&kt_func, dst);
-             else
-               dst->type = IPA_JF_UNKNOWN;
-           }
-         else if (src->type == IPA_JF_PASS_THROUGH
-                  && src->value.pass_through.operation == NOP_EXPR)
-           dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
-         else if (src->type == IPA_JF_ANCESTOR)
-           {
-             dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
-             dst->value.ancestor.offset += src->value.ancestor.offset;
-           }
-         else
-           dst->type = IPA_JF_UNKNOWN;
-       }
-      else if (dst->type == IPA_JF_PASS_THROUGH)
+      /* We must check range due to calls with variable number of arguments and
+        we cannot combine jump functions with operations.  */
+      if (dst->value.pass_through.operation != NOP_EXPR
+         || (dst->value.pass_through.formal_id
+             >= ipa_get_cs_argument_count (top)))
        {
-         struct ipa_jump_func *src;
-         /* We must check range due to calls with variable number of arguments
-            and we cannot combine jump functions with operations.  */
-         if (dst->value.pass_through.operation == NOP_EXPR
-             && (dst->value.pass_through.formal_id
-                 < ipa_get_cs_argument_count (top)))
-           {
-             src = ipa_get_ith_jump_func (top,
-                                          dst->value.pass_through.formal_id);
-             *dst = *src;
-           }
-         else
-           dst->type = IPA_JF_UNKNOWN;
+         dst->type = IPA_JF_UNKNOWN;
+         continue;
        }
-    }
-}
-
-/* If TARGET is an addr_expr of a function declaration, make it the destination
-   of an indirect edge IE and return the edge.  Otherwise, return NULL.  */
 
-static struct cgraph_edge *
-make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
-{
-  struct cgraph_node *callee;
-
-  if (TREE_CODE (target) != ADDR_EXPR)
-    return NULL;
-  target = TREE_OPERAND (target, 0);
-  if (TREE_CODE (target) != FUNCTION_DECL)
-    return NULL;
-  callee = cgraph_node (target);
-  if (!callee)
-    return NULL;
-
-  cgraph_make_edge_direct (ie, callee);
-  if (dump_file)
-    {
-      fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
-              "(%s/%i -> %s/%i) for stmt ",
-              ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
-              cgraph_node_name (ie->caller), ie->caller->uid,
-              cgraph_node_name (ie->callee), ie->callee->uid);
-
-      if (ie->call_stmt)
-       print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
-      else
-       fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
+      src = ipa_get_ith_jump_func (top, dst->value.pass_through.formal_id);
+      *dst = *src;
     }
-  return ie;
 }
 
-/* Try to find a destination for indirect edge IE that corresponds to a simple
-   call or a call of a member function pointer and where the destination is a
-   pointer formal parameter described by jump function JFUNC.  If it can be
-   determined, return the newly direct edge, otherwise return NULL.  */
+/* Print out a debug message to file F that we have discovered that an indirect
+   call described by NT is in fact a call of a known constant function described
+   by JFUNC.  NODE is the node where the call is.  */
 
-static struct cgraph_edge *
-try_make_edge_direct_simple_call (struct cgraph_edge *ie,
-                                 struct ipa_jump_func *jfunc)
-{
-  tree target;
-
-  if (jfunc->type == IPA_JF_CONST)
-    target = jfunc->value.constant;
-  else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
-    target = jfunc->value.member_cst.pfn;
-  else
-    return NULL;
-
-  return make_edge_direct_to_target (ie, target);
-}
-
-/* Try to find a destination for indirect edge IE that corresponds to a
-   virtuall call based on a formal parameter which is described by jump
-   function JFUNC and if it can be determined, make it direct and return the
-   direct edge.  Otherwise, return NULL.  */
-
-static struct cgraph_edge *
-try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
-                                  struct ipa_jump_func *jfunc)
+static void
+print_edge_addition_message (FILE *f, struct cgraph_edge *e,
+                            struct ipa_jump_func *jfunc)
 {
-  tree binfo, type, target;
-  HOST_WIDE_INT token;
-
-  if (jfunc->type == IPA_JF_KNOWN_TYPE)
-    binfo = jfunc->value.base_binfo;
-  else if (jfunc->type == IPA_JF_CONST)
+  fprintf (f, "ipa-prop: Discovered an indirect call to a known target (");
+  if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
     {
-      tree cst = jfunc->value.constant;
-      if (TREE_CODE (cst) == ADDR_EXPR)
-       binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
-                                              NULL_TREE);
-      else
-       return NULL;
+      print_node_brief (f, "", jfunc->value.member_cst.pfn, 0);
+      print_node_brief (f, ", ", jfunc->value.member_cst.delta, 0);
     }
   else
-    return NULL;
-
-  if (!binfo)
-    return NULL;
-
-  token = ie->indirect_info->otr_token;
-  type = ie->indirect_info->otr_type;
-  binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
-  if (binfo)
-    target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
-  else
-    return NULL;
+    print_node_brief(f, "", jfunc->value.constant, 0);
 
-  if (target)
-    return make_edge_direct_to_target (ie, target);
-  else
-    return NULL;
+  fprintf (f, ") in %s: ", cgraph_node_name (e->caller));
+  print_gimple_stmt (f, e->call_stmt, 2, TDF_SLIM);
 }
 
 /* Update the param called notes associated with NODE when CS is being inlined,
@@ -1424,7 +1055,7 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs,
                                      VEC (cgraph_edge_p, heap) **new_edges)
 {
   struct ipa_edge_args *top = IPA_EDGE_REF (cs);
-  struct cgraph_edge *ie, *next_ie, *new_direct_edge;
+  struct cgraph_edge *ie, *next_ie;
   bool res = false;
 
   ipa_check_create_edge_args ();
@@ -1440,8 +1071,7 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs,
 
       /* If we ever use indirect edges for anything other than indirect
         inlining, we will need to skip those with negative param_indices. */
-      if (ici->param_index == -1)
-       continue;
+      gcc_assert (ici->param_index >= 0);
 
       /* We must check range due to calls with variable number of arguments:  */
       if (ici->param_index >= ipa_get_cs_argument_count (top))
@@ -1454,30 +1084,44 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs,
       if (jfunc->type == IPA_JF_PASS_THROUGH
          && jfunc->value.pass_through.operation == NOP_EXPR)
        ici->param_index = jfunc->value.pass_through.formal_id;
-      else if (jfunc->type == IPA_JF_ANCESTOR)
+      else if (jfunc->type == IPA_JF_CONST
+              || jfunc->type == IPA_JF_CONST_MEMBER_PTR)
        {
-         ici->param_index = jfunc->value.ancestor.formal_id;
-         ici->anc_offset += jfunc->value.ancestor.offset;
-       }
-      else
-       /* Either we can find a destination for this edge now or never. */
-       bitmap_set_bit (iinlining_processed_edges, ie->uid);
+         struct cgraph_node *callee;
+         tree decl;
 
-      if (ici->polymorphic)
-       new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
-      else
-       new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
+         bitmap_set_bit (iinlining_processed_edges, ie->uid);
+         if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
+           decl = jfunc->value.member_cst.pfn;
+         else
+           decl = jfunc->value.constant;
 
-      if (new_direct_edge)
-       {
-         new_direct_edge->indirect_inlining_edge = 1;
+         if (TREE_CODE (decl) != ADDR_EXPR)
+           continue;
+         decl = TREE_OPERAND (decl, 0);
+
+         if (TREE_CODE (decl) != FUNCTION_DECL)
+           continue;
+         callee = cgraph_node (decl);
+         if (!callee || !callee->local.inlinable)
+           continue;
+
+         res = true;
+         if (dump_file)
+           print_edge_addition_message (dump_file, ie, jfunc);
+
+         cgraph_make_edge_direct (ie, callee);
+         ie->indirect_inlining_edge = 1;
          if (new_edges)
-           {
-             VEC_safe_push (cgraph_edge_p, heap, *new_edges,
-                            new_direct_edge);
-             top = IPA_EDGE_REF (cs);
-             res = true;
-           }
+           VEC_safe_push (cgraph_edge_p, heap, *new_edges, ie);
+         top = IPA_EDGE_REF (cs);
+       }
+      else
+       {
+         /* Ancestor jump functions and pass theoughs with operations should
+            not be used on parameters that then get called.  */
+         gcc_assert (jfunc->type == IPA_JF_UNKNOWN);
+         bitmap_set_bit (iinlining_processed_edges, ie->uid);
        }
     }
 
@@ -1776,8 +1420,7 @@ ipa_print_node_params (FILE * f, struct cgraph_node *node)
   if (!node->analyzed)
     return;
   info = IPA_NODE_REF (node);
-  fprintf (f, "  function  %s parameter descriptors:\n",
-          cgraph_node_name (node));
+  fprintf (f, "  function  %s Trees :: \n", cgraph_node_name (node));
   count = ipa_get_param_count (info);
   for (i = 0; i < count; i++)
     {
@@ -1789,8 +1432,6 @@ ipa_print_node_params (FILE * f, struct cgraph_node *node)
                   : "(unnamed)"));
       if (ipa_is_param_modified (info, i))
        fprintf (f, " modified");
-      if (ipa_is_param_used (info, i))
-       fprintf (f, " used");
       fprintf (f, "\n");
     }
 }
@@ -2271,9 +1912,6 @@ ipa_write_jump_function (struct output_block *ob,
     {
     case IPA_JF_UNKNOWN:
       break;
-    case IPA_JF_KNOWN_TYPE:
-      lto_output_tree (ob, jump_func->value.base_binfo, true);
-      break;
     case IPA_JF_CONST:
       lto_output_tree (ob, jump_func->value.constant, true);
       break;
@@ -2311,9 +1949,6 @@ ipa_read_jump_function (struct lto_input_block *ib,
     {
     case IPA_JF_UNKNOWN:
       break;
-    case IPA_JF_KNOWN_TYPE:
-      jump_func->value.base_binfo = lto_input_tree (ib, data_in);
-      break;
     case IPA_JF_CONST:
       jump_func->value.constant = lto_input_tree (ib, data_in);
       break;
@@ -2342,20 +1977,8 @@ ipa_write_indirect_edge_info (struct output_block *ob,
                              struct cgraph_edge *cs)
 {
   struct cgraph_indirect_call_info *ii = cs->indirect_info;
-  struct bitpack_d *bp;
 
   lto_output_sleb128_stream (ob->main_stream, ii->param_index);
-  lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
-  bp = bitpack_create ();
-  bp_pack_value (bp, ii->polymorphic, 1);
-  lto_output_bitpack (ob->main_stream, bp);
-  bitpack_delete (bp);
-
-  if (ii->polymorphic)
-    {
-      lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
-      lto_output_tree (ob, ii->otr_type, true);
-    }
 }
 
 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
@@ -2367,18 +1990,8 @@ ipa_read_indirect_edge_info (struct lto_input_block *ib,
                             struct cgraph_edge *cs)
 {
   struct cgraph_indirect_call_info *ii = cs->indirect_info;
-  struct bitpack_d *bp;
 
   ii->param_index = (int) lto_input_sleb128 (ib);
-  ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
-  bp = lto_input_bitpack (ib);
-  ii->polymorphic = bp_unpack_value (bp, 1);
-  bitpack_delete (bp);
-  if (ii->polymorphic)
-    {
-      ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
-      ii->otr_type = lto_input_tree (ib, data_in);
-    }
 }
 
 /* Stream out NODE info to OB.  */
@@ -2405,10 +2018,7 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
   gcc_assert (!info->node_enqueued);
   gcc_assert (!info->ipcp_orig_node);
   for (j = 0; j < ipa_get_param_count (info); j++)
-    {
-      bp_pack_value (bp, info->params[j].modified, 1);
-      bp_pack_value (bp, info->params[j].used, 1);
-    }
+    bp_pack_value (bp, info->params[j].modified, 1);
   lto_output_bitpack (ob->main_stream, bp);
   bitpack_delete (bp);
   for (e = node->callees; e; e = e->next_callee)
@@ -2447,10 +2057,7 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
     }
   info->node_enqueued = false;
   for (k = 0; k < ipa_get_param_count (info); k++)
-    {
-      info->params[k].modified = bp_unpack_value (bp, 1);
-      info->params[k].used = bp_unpack_value (bp, 1);
-    }
+    info->params[k].modified = bp_unpack_value (bp, 1);
   bitpack_delete (bp);
   for (e = node->callees; e; e = e->next_callee)
     {
@@ -2536,7 +2143,6 @@ ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
       index = lto_input_uleb128 (&ib_main);
       encoder = file_data->cgraph_node_encoder;
       node = lto_cgraph_encoder_deref (encoder, index);
-      gcc_assert (node->analyzed);
       ipa_read_node_info (&ib_main, node, data_in);
     }
   lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
index 6f22968..b805768 100644 (file)
@@ -139,15 +139,21 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
   intptr_t ref;
   struct bitpack_d *bp;
 
-  lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
+  if (edge->indirect_unknown_callee)
+    lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
+  else
+    lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
 
   ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
   gcc_assert (ref != LCC_NOT_FOUND);
   lto_output_sleb128_stream (ob->main_stream, ref);
 
-  ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
-  gcc_assert (ref != LCC_NOT_FOUND);
-  lto_output_sleb128_stream (ob->main_stream, ref);
+  if (!edge->indirect_unknown_callee)
+    {
+      ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
+      gcc_assert (ref != LCC_NOT_FOUND);
+      lto_output_sleb128_stream (ob->main_stream, ref);
+    }
 
   lto_output_sleb128_stream (ob->main_stream, edge->count);
 
@@ -157,7 +163,7 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
   bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
   bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
   bp_pack_value (bp, edge->loop_nest, 30);
-  bp_pack_value (bp, edge->indirect_call, 1);
+  bp_pack_value (bp, edge->indirect_inlining_edge, 1);
   bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
   bp_pack_value (bp, edge->can_throw_external, 1);
   lto_output_bitpack (ob->main_stream, bp);
@@ -400,6 +406,25 @@ add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
   lto_cgraph_encoder_encode (encoder, node);
 }
 
+/* Output all callees or indirect outgoing edges.  EDGE must be the first such
+   edge.  */
+
+static void
+output_outgoing_cgraph_edges (struct cgraph_edge *edge,
+                             struct lto_simple_output_block *ob,
+                             lto_cgraph_encoder_t encoder)
+{
+  if (!edge)
+    return;
+
+  /* Output edges in backward direction, so the reconstructed callgraph match
+     and it is easy to associate call sites in the IPA pass summaries.  */
+  while (edge->next_callee)
+    edge = edge->next_callee;
+  for (; edge; edge = edge->prev_callee)
+    lto_output_edge (ob, edge, encoder);
+}
+
 /* Output the part of the cgraph in SET.  */
 
 void
@@ -468,16 +493,8 @@ output_cgraph (cgraph_node_set set)
   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
     {
       node = csi_node (csi);
-      if (node->callees)
-        {
-         /* Output edges in backward direction, so the reconstructed callgraph
-            match and it is easy to associate call sites in the IPA pass summaries.  */
-         edge = node->callees;
-         while (edge->next_callee)
-           edge = edge->next_callee;
-         for (; edge; edge = edge->prev_callee)
-           lto_output_edge (ob, edge, encoder);
-       }
+      output_outgoing_cgraph_edges (node->callees, ob, encoder);
+      output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
     }
 
   lto_output_uleb128_stream (ob->main_stream, 0);
@@ -497,7 +514,6 @@ output_cgraph (cgraph_node_set set)
   lto_destroy_simple_output_block (ob);
 }
 
-
 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
    NODE or to replace the values in it, for instance because the first
@@ -668,11 +684,14 @@ input_node (struct lto_file_decl_data *file_data,
 }
 
 
-/* Read an edge from IB.  NODES points to a vector of previously read
-   nodes for decoding caller and callee of the edge to be read.  */
+/* Read an edge from IB.  NODES points to a vector of previously read nodes for
+   decoding caller and callee of the edge to be read.  If INDIRECT is true, the
+   edge being read is indirect (in the sense that it has
+   indirect_unknown_callee set).  */
 
 static void
-input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
+input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
+           bool indirect)
 {
   struct cgraph_node *caller, *callee;
   struct cgraph_edge *edge;
@@ -688,9 +707,14 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
   if (caller == NULL || caller->decl == NULL_TREE)
     internal_error ("bytecode stream: no caller found while reading edge");
 
-  callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
-  if (callee == NULL || callee->decl == NULL_TREE)
-    internal_error ("bytecode stream: no callee found while reading edge");
+  if (!indirect)
+    {
+      callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
+      if (callee == NULL || callee->decl == NULL_TREE)
+       internal_error ("bytecode stream: no callee found while reading edge");
+    }
+  else
+    callee = NULL;
 
   count = (gcov_type) lto_input_sleb128 (ib);
 
@@ -708,10 +732,14 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
       || caller_resolution == LDPR_PREEMPTED_IR)
     return;
 
-  edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
+  if (indirect)
+    edge = cgraph_create_indirect_edge (caller, NULL, count, freq, nest);
+  else
+    edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
+
+  edge->indirect_inlining_edge = bp_unpack_value (bp, 1);
   edge->lto_stmt_uid = stmt_id;
   edge->inline_failed = inline_failed;
-  edge->indirect_call = bp_unpack_value (bp, 1);
   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
   edge->can_throw_external = bp_unpack_value (bp, 1);
   bitpack_delete (bp);
@@ -734,7 +762,9 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
   while (tag)
     {
       if (tag == LTO_cgraph_edge)
-        input_edge (ib, nodes);
+        input_edge (ib, nodes, false);
+      else if (tag == LTO_cgraph_indirect_edge)
+        input_edge (ib, nodes, true);
       else
        {
          node = input_node (file_data, ib, tag);
index 71c39f2..40fa288 100644 (file)
@@ -1,3 +1,7 @@
+2010-04-28  Martin Jambor  <mjambor@suse.cz>
+
+       * gcc.dg/lto/20091209-1_0.c: New testcase.
+
 2010-04-28  Richard Guenther  <rguenther@suse.de>
 
        PR tree-optimization/43879