Call graph -> grapht transformation

Add export from call_grapht to grapht, such that generic graph algorithms
can be applied to the call graph.

Author: smowton

src/analyses/call_graph.cpp

@@ -87,6 +87,64 @@ call_grapht call_grapht::get_inverted() const
   return result;
 }
 
+/// Helper class that maintains a map from function name to grapht node index
+/// and adds nodes to the graph on demand.
+class function_indicest
+{
+  typedef call_grapht::directed_grapht::node_indext node_indext;
+  call_grapht::directed_grapht &graph;
+
+public:
+  std::unordered_map<irep_idt, node_indext, irep_id_hash> function_indices;
+
+  explicit function_indicest(call_grapht::directed_grapht &graph):
+    graph(graph)
+  {
+  }
+
+  node_indext operator[](const irep_idt &function)
+  {
+    auto findit=function_indices.insert({function, 0});
+    if(findit.second)
+    {
+      node_indext new_index=graph.add_node();
+      findit.first->second=new_index;
+      graph[new_index].function=function;
+    }
+    return findit.first->second;
+  }
+};
+
+/// Returns a `grapht` representation of this call graph, suitable for use
+/// with generic grapht algorithms. Note that parallel edges in call_grapht
+/// (e.g. A { B(); B(); } appearing as two A->B edges) will be condensed in
+/// the grapht output, so only one edge will appear. If `collect_callsites`
+/// was set when this call-graph was constructed the edge will be annotated
+/// with the call-site set.
+/// \return grapht representation of this call_grapht
+call_grapht::directed_grapht call_grapht::get_directed_graph() const
+{
+  call_grapht::directed_grapht ret;
+  function_indicest function_indices(ret);
+
+  for(const auto &edge : graph)
+  {
+    auto a_index=function_indices[edge.first];
+    auto b_index=function_indices[edge.second];
+    // Check then create the edge like this to avoid copying the callsites
+    // set once per parallel edge, which could be costly if there are many.
+    if(!ret.has_edge(a_index, b_index))
+    {
+      ret.add_edge(a_index, b_index);
+      if(collect_callsites)
+        ret[a_index].out[b_index].callsites=callsites.at(edge);
+    }
+  }
+
+  ret.nodes_by_name=std::move(function_indices.function_indices);
+  return ret;
+}
+
 std::string call_grapht::format_callsites(const edget &edge) const
 {
   PRECONDITION(collect_callsites);
@@ -144,3 +202,13 @@ void call_grapht::output_xml(std::ostream &out) const
     out << "\">\n";
   }
 }
+
+optionalt<std::size_t> call_grapht::directed_grapht::get_node_index(
+  const irep_idt &function) const
+{
+  auto findit=nodes_by_name.find(function);
+  if(findit==nodes_by_name.end())
+    return optionalt<node_indext>();
+  else
+    return findit->second;
+}

src/analyses/call_graph.h

@@ -16,6 +16,7 @@ Author: Daniel Kroening, [email protected]
 #include <map>
 
 #include <goto-programs/goto_model.h>
+#include <util/graph.h>
 
 class call_grapht
 {
@@ -41,6 +42,44 @@ class call_grapht
   void add(const irep_idt &caller, const irep_idt &callee, locationt callsite);
   call_grapht get_inverted() const;
 
+  struct edge_with_callsitest
+  {
+    locationst callsites;
+  };
+
+  struct function_nodet:public graph_nodet<edge_with_callsitest>
+  {
+    irep_idt function;
+  };
+
+  /// Directed graph representation of this call graph
+  class directed_grapht : public ::grapht<function_nodet>
+  {
+    friend class call_grapht;
+
+    /// Maps function names onto node indices
+    std::unordered_map<irep_idt, node_indext, irep_id_hash> nodes_by_name;
+
+  public:
+    /// Find the graph node by function name
+    /// \param function: function to find
+    /// \return none if function is not in this graph, or some index otherwise.
+    optionalt<node_indext> get_node_index(const irep_idt &function) const;
+
+    /// Type of the node name -> node index map.
+    typedef
+      std::unordered_map<irep_idt, node_indext, irep_id_hash> nodes_by_namet;
+
+    /// Get the node name -> node index map
+    /// \return node-by-name map
+    const nodes_by_namet &get_nodes_by_name() const
+    {
+      return nodes_by_name;
+    }
+  };
+
+  directed_grapht get_directed_graph() const;
+
 protected:
   void add(const irep_idt &function,
            const goto_programt &body);

unit/analyses/call_graph.cpp

@@ -159,5 +159,63 @@ SCENARIO("call_graph",
         }
       }
     }
+
+    WHEN("The call graph is exported as a grapht")
+    {
+      call_grapht::directed_call_grapht exported=
+        call_graph_from_goto_functions.get_directed_graph();
+
+      typedef call_grapht::directed_call_grapht::node_indext node_indext;
+      std::map<irep_idt, node_indext> nodes_by_name;
+      for(node_indext i=0; i<exported.size(); ++i)
+        nodes_by_name[exported[i].function]=i;
+
+      THEN("We expect edges A -> { A, B }, B -> { C, D }")
+      {
+        // Note that means the extra A -> B edge has gone away (the grapht
+        // structure can't represent the parallel edge)
+        REQUIRE(exported.has_edge(nodes_by_name["A"], nodes_by_name["A"]));
+        REQUIRE(exported.has_edge(nodes_by_name["A"], nodes_by_name["B"]));
+        REQUIRE(exported.has_edge(nodes_by_name["B"], nodes_by_name["C"]));
+        REQUIRE(exported.has_edge(nodes_by_name["B"], nodes_by_name["D"]));
+      }
+    }
+
+    WHEN("The call graph, with call sites, is exported as a grapht")
+    {
+      call_grapht call_graph_from_goto_functions(goto_model, true);
+      call_grapht::directed_call_grapht exported=
+        call_graph_from_goto_functions.get_directed_graph();
+
+      typedef call_grapht::directed_call_grapht::node_indext node_indext;
+      std::map<irep_idt, node_indext> nodes_by_name;
+      for(node_indext i=0; i<exported.size(); ++i)
+        nodes_by_name[exported[i].function]=i;
+
+      THEN("We expect edges A -> { A, B }, B -> { C, D }")
+      {
+        // Note that means the extra A -> B edge has gone away (the grapht
+        // structure can't represent the parallel edge)
+        REQUIRE(exported.has_edge(nodes_by_name["A"], nodes_by_name["A"]));
+        REQUIRE(exported.has_edge(nodes_by_name["A"], nodes_by_name["B"]));
+        REQUIRE(exported.has_edge(nodes_by_name["B"], nodes_by_name["C"]));
+        REQUIRE(exported.has_edge(nodes_by_name["B"], nodes_by_name["D"]));
+      }
+
+      THEN("We expect all edges to have one callsite apart from A -> B with 2")
+      {
+        for(node_indext i=0; i<exported.size(); ++i)
+        {
+          const auto &node=exported[i];
+          for(const auto &edge : node.out)
+          {
+            if(i==nodes_by_name["A"] && edge.first==nodes_by_name["B"])
+              REQUIRE(edge.second.callsites.size()==2);
+            else
+              REQUIRE(edge.second.callsites.size()==1);
+          }
+        }
+      }
+    }
   }
 }