Call graph: optionally record callsites

This makes it easier for call-graph users to discover the particular instruction responsible
for a call-graph edge.

Ideally these would be recorded in-line with the map (i.e. change the graph type to
std::multimap<irep_idt, std::pair<locationt, irep_idt>>), but here we introduce an optional
auxiliary map to avoid breaking existing users.

Author: smowton

src/analyses/call_graph.cpp

@@ -14,16 +14,19 @@ Author: Daniel Kroening, [email protected]
 #include <util/std_expr.h>
 #include <util/xml.h>
 
-call_grapht::call_grapht()
+call_grapht::call_grapht(bool collect_callsites):
+  collect_callsites(collect_callsites)
 {
 }
 
-call_grapht::call_grapht(const goto_modelt &goto_model):
-  call_grapht(goto_model.goto_functions)
+call_grapht::call_grapht(const goto_modelt &goto_model, bool collect_callsites):
+  call_grapht(goto_model.goto_functions, collect_callsites)
 {
 }
 
-call_grapht::call_grapht(const goto_functionst &goto_functions)
+call_grapht::call_grapht(
+  const goto_functionst &goto_functions, bool collect_callsites):
+  collect_callsites(collect_callsites)
 {
   forall_goto_functions(f_it, goto_functions)
   {
@@ -42,7 +45,12 @@ void call_grapht::add(
     {
       const exprt &function_expr=to_code_function_call(i_it->code).function();
       if(function_expr.id()==ID_symbol)
-        add(function, to_symbol_expr(function_expr).get_identifier());
+      {
+        const irep_idt &callee=to_symbol_expr(function_expr).get_identifier();
+        add(function, callee);
+        if(collect_callsites)
+          callsites[{function, callee}].insert(i_it);
+      }
     }
   }
 }
@@ -54,6 +62,21 @@ void call_grapht::add(
   graph.insert(std::pair<irep_idt, irep_idt>(caller, callee));
 }
 
+/// Add edge with optional callsite information
+/// \param caller: caller function
+/// \param callee: callee function
+/// \param callsite: call instruction responsible for this edge. Note this is
+///   only stored if `collect_callsites` was specified during construction.
+void call_grapht::add(
+  const irep_idt &caller,
+  const irep_idt &callee,
+  locationt callsite)
+{
+  add(caller, callee);
+  if(collect_callsites)
+    callsites[{caller, callee}].insert(callsite);
+}
+
 /// Returns an inverted copy of this call graph
 /// \return Inverted (callee -> caller) call graph
 call_grapht call_grapht::get_inverted() const
@@ -64,6 +87,20 @@ call_grapht call_grapht::get_inverted() const
   return result;
 }
 
+std::string call_grapht::format_callsites(const edget &edge) const
+{
+  PRECONDITION(collect_callsites);
+  std::string ret="{";
+  for(const locationt &loc : callsites.at(edge))
+  {
+    if(ret.size()>1)
+      ret+=", ";
+    ret+=std::to_string(loc->location_number);
+  }
+  ret+='}';
+  return ret;
+}
+
 void call_grapht::output_dot(std::ostream &out) const
 {
   out << "digraph call_graph {\n";
@@ -72,8 +109,10 @@ void call_grapht::output_dot(std::ostream &out) const
   {
     out << "  \"" << edge.first << "\" -> "
         << "\"" << edge.second << "\" "
-        << " [arrowhead=\"vee\"];"
-        << "\n";
+        << " [arrowhead=\"vee\"";
+    if(collect_callsites)
+      out << " label=\"" << format_callsites(edge) << "\"";
+    out << "];\n";
   }
 
   out << "}\n";
@@ -84,11 +123,18 @@ void call_grapht::output(std::ostream &out) const
   for(const auto &edge : graph)
   {
     out << edge.first << " -> " << edge.second << "\n";
+    if(collect_callsites)
+      out << "  (callsites: " << format_callsites(edge) << ")\n";
   }
 }
 
 void call_grapht::output_xml(std::ostream &out) const
 {
+  // Note I don't implement callsite output here; I'll leave that
+  // to the first interested XML user.
+  if(collect_callsites)
+    out << "<!-- XML call-graph representation does not document callsites yet."
+      " If you need this, edit call_grapht::output_xml -->\n";
   for(const auto &edge : graph)
   {
     out << "<call_graph_edge caller=\"";

src/analyses/call_graph.h

@@ -20,23 +20,33 @@ Author: Daniel Kroening, [email protected]
 class call_grapht
 {
 public:
-  call_grapht();
-  explicit call_grapht(const goto_modelt &);
-  explicit call_grapht(const goto_functionst &);
+  explicit call_grapht(bool collect_callsites=false);
+  explicit call_grapht(const goto_modelt &, bool collect_callsites=false);
+  explicit call_grapht(const goto_functionst &, bool collect_callsites=false);
 
   void output_dot(std::ostream &out) const;
   void output(std::ostream &out) const;
   void output_xml(std::ostream &out) const;
 
   typedef std::multimap<irep_idt, irep_idt> grapht;
+  typedef std::pair<irep_idt, irep_idt> edget;
+  typedef goto_programt::const_targett locationt;
+  typedef std::set<locationt> locationst;
+  typedef std::map<edget, locationst> callsitest;
+
   grapht graph;
+  callsitest callsites;
 
   void add(const irep_idt &caller, const irep_idt &callee);
+  void add(const irep_idt &caller, const irep_idt &callee, locationt callsite);
   call_grapht get_inverted() const;
 
 protected:
   void add(const irep_idt &function,
            const goto_programt &body);
+private:
+  bool collect_callsites;
+  std::string format_callsites(const edget &edge) const;
 };
 
 #endif // CPROVER_ANALYSES_CALL_GRAPH_H

unit/analyses/call_graph.cpp

@@ -54,6 +54,7 @@ SCENARIO("call_graph",
     // {
     //    A();
     //    B();
+    //    B();
     // }
     // void B()
     // {
@@ -72,8 +73,11 @@ SCENARIO("call_graph",
       call1.function()=symbol_exprt("A", void_function_type);
       code_function_callt call2;
       call2.function()=symbol_exprt("B", void_function_type);
+      code_function_callt call3;
+      call3.function()=symbol_exprt("B", void_function_type);
       calls.move_to_operands(call1);
       calls.move_to_operands(call2);
+      calls.move_to_operands(call3);
 
       goto_model.symbol_table.add(
         create_void_function_symbol("A", calls));
@@ -104,30 +108,56 @@ SCENARIO("call_graph",
 
     WHEN("A call graph is constructed from the GOTO functions")
     {
-      THEN("We expect A -> { A, B }, B -> { C, D }")
+      THEN("We expect A -> { A, B, B }, B -> { C, D }")
       {
         const auto &check_graph=call_graph_from_goto_functions.graph;
-        REQUIRE(check_graph.size()==4);
-        REQUIRE(multimap_key_matches(check_graph, "A", {"A", "B"}));
+        REQUIRE(check_graph.size()==5);
+        REQUIRE(multimap_key_matches(check_graph, "A", {"A", "B", "B"}));
         REQUIRE(multimap_key_matches(check_graph, "B", {"C", "D"}));
       }
+      THEN("No callsite data should be collected")
+      {
+        REQUIRE(call_graph_from_goto_functions.callsites.empty());
+      }
     }
 
     WHEN("The call graph is inverted")
     {
       call_grapht inverse_call_graph_from_goto_functions=
         call_graph_from_goto_functions.get_inverted();
-      THEN("We expect A -> { A }, B -> { A }, C -> { B }, D -> { B }")
+      THEN("We expect A -> { A }, B -> { A, A }, C -> { B }, D -> { B }")
       {
         const auto &check_graph=inverse_call_graph_from_goto_functions.graph;
-        REQUIRE(check_graph.size()==4);
+        REQUIRE(check_graph.size()==5);
         REQUIRE(multimap_key_matches(check_graph, "A", {"A"}));
-        REQUIRE(multimap_key_matches(check_graph, "B", {"A"}));
+        REQUIRE(multimap_key_matches(check_graph, "B", {"A", "A"}));
         REQUIRE(multimap_key_matches(check_graph, "C", {"B"}));
         REQUIRE(multimap_key_matches(check_graph, "D", {"B"}));
       }
     }
 
+    WHEN("A call graph is constructed with call-site tracking")
+    {
+      call_grapht call_graph_from_goto_functions(goto_model, true);
+      THEN("We expect two callsites for the A -> B edge, one for all others")
+      {
+        const auto &check_callsites=call_graph_from_goto_functions.callsites;
+        for(const auto &edge : call_graph_from_goto_functions.graph)
+        {
+          if(edge==call_grapht::grapht::value_type("A", "B"))
+            REQUIRE(check_callsites.at(edge).size()==2);
+          else
+            REQUIRE(check_callsites.at(edge).size()==1);
+        }
+      }
+      WHEN("Such a graph is inverted")
+      {
+        call_grapht inverted=call_graph_from_goto_functions.get_inverted();
+        THEN("The callsite data should be discarded")
+        {
+          REQUIRE(inverted.callsites.empty());
+        }
+      }
+    }
   }
-
 }