Skip to content

Extension of the call-graph and call-graph-based algorithms #641

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Mar 24, 2017
Merged

Extension of the call-graph and call-graph-based algorithms #641

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
4407269
Added mapping from edges of the call-graph to particular instructions…
marek-trtik Mar 15, 2017
0e37d79
CPPLINT
marek-trtik Mar 15, 2017
3541cd5
Unimportant: added void comments, some white characters, and one arti…
marek-trtik Mar 16, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
190 changes: 163 additions & 27 deletions src/analyses/call_graph.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,10 +6,12 @@ Author: Daniel Kroening, kroening@kroening.com

\*******************************************************************/

#include "call_graph.h"
#include <util/std_expr.h>
#include <util/xml.h>
#include <algorithm>
#include <iterator>

#include "call_graph.h"

/*******************************************************************\

Expand Down Expand Up @@ -70,11 +72,31 @@ 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());
add(function, to_symbol_expr(function_expr).get_identifier(), {i_it});
}
}
}

/*******************************************************************\

Function: call_grapht::swap

Inputs:

Outputs:

Purpose:

\*******************************************************************/

void call_grapht::swap(call_grapht &other)
{
std::swap(graph, other.graph);
std::swap(map_from_edges_to_call_locations,
other.map_from_edges_to_call_locations);
}


/*******************************************************************\

Function: call_grapht::add
Expand All @@ -96,7 +118,7 @@ void call_grapht::add(

/*******************************************************************\

Function: call_grapht::output_dot
Function: call_grapht::add

Inputs:

Expand All @@ -106,37 +128,60 @@ Function: call_grapht::output_dot

\*******************************************************************/

void call_grapht::output_dot(std::ostream &out) const
void call_grapht::add(
const irep_idt &caller,
const irep_idt &callee,
const map_from_edges_to_call_locationst::mapped_type &call_sites)
{
out << "digraph call_graph {\n";

for(const auto &edge : graph)
bool exists=false;
const call_grapht::call_edges_ranget range=out_edges(caller);
for(auto it=range.first; it!=range.second; ++it)
{
out << " \"" << edge.first << "\" -> "
<< "\"" << edge.second << "\" "
<< " [arrowhead=\"vee\"];"
<< "\n";
if(it->second==callee)
{
exists=true;
break;
}
}

out << "}\n";
if(!exists)
add(caller, callee);
std::copy(
call_sites.cbegin(), call_sites.cend(),
std::back_inserter(map_from_edges_to_call_locations[{caller, callee}]));
}


void call_grapht::output_dot(
const goto_functionst &functions,
std::ostream &out) const
/*******************************************************************\

Function: call_grapht::output_dot

Inputs:

Outputs:

Purpose:

\*******************************************************************/

void call_grapht::output_dot(std::ostream &out) const
{
out << "digraph call_graph {\n";
for(const auto &elem : functions.function_map)
out << " \"" << elem.first << "\";\n";
for(grapht::const_iterator it=graph.begin();
it!=graph.end();
it++)
out << "digraph call_graph {\n"
<< " node [fontsize=12 shape=box];\n";
for(const auto &edge : graph)
{
out << " \"" << it->first << "\" -> "
<< "\"" << it->second << "\" "
<< " [arrowhead=\"vee\"];"
<< "\n";
out << " \"" << edge.first << "\" -> "
<< "\"" << edge.second << "\" "
<< " [label=\"{";
bool first=true;
for(const auto instr_it :
get_map_from_edges_to_call_locations().at({edge.first, edge.second}))
{
if(!first)
out << ",";
out << instr_it->location_number;
first=false;
}
out << "}\"];\n";
}
out << "}\n";
}
Expand Down Expand Up @@ -382,7 +427,10 @@ void compute_inverted_call_graph(
{
assert(output_inverted_call_graph.graph.empty());
for(const auto &elem : original_call_graph.graph)
output_inverted_call_graph.add(elem.second, elem.first);
output_inverted_call_graph.add(
elem.second, elem.first,
original_call_graph.get_map_from_edges_to_call_locations().at(
{elem.first, elem.second}));
}

/*******************************************************************\
Expand Down Expand Up @@ -443,3 +491,91 @@ void find_leaves_below_function(
std::unordered_set<irep_idt, dstring_hash> to_avoid;
find_leaves_below_function(call_graph, function, to_avoid, output);
}

/*******************************************************************\

Function: find_direct_or_indirect_callees_of_function

Inputs:

Outputs:

Purpose:

\*******************************************************************/

void find_direct_or_indirect_callees_of_function(
const call_grapht &call_graph,
const irep_idt &function,
std::unordered_set<irep_idt, dstring_hash> &output)
{
std::unordered_set<irep_idt, dstring_hash> leaves;
find_leaves_below_function(call_graph, function, output, leaves);
output.insert(leaves.cbegin(), leaves.cend());
}

/*******************************************************************\

Function: find_nearest_common_callees

Inputs:

Outputs:

Purpose:

\*******************************************************************/

void find_nearest_common_callees(
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

What is the reason for not making this a member of call_grapht?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Couple of years ago I read in one of Scott Mayer's books the following recommendation for clean OO design in C++: "When an algorithm can be effectively implemented using only the public interface on a class, then the algorithm should be implemented as a free function."

It makes sense to me (i.e. the intention to minimise a set of algorithms with the direct access to private data of the class maximises the encapsulation of that class, and so it simplifies definition and maintenance of class invariants), so I follow it. However, one can easily disagree. For example, it would be quite difficult to follow this recommendation in Java.

I am not sure whether you only asked the question or whether you actually want me to make it a member function. So, please, let me know...

Copy link
Member

@peterschrammel peterschrammel Mar 24, 2017 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree with that if these functions provide convenience functions for manipulating the object through the public interface. There might be more reasons for doing that, e.g. avoiding clutter, reducing class size, not being allowed to change the class, etc. Then these functions should even go into a separate "utility" module.
One could argue that this is mixing procedural and object-oriented styles, or that functions floating around in the root namespace are bad (which could be improved by actually using namespaces ;) , which is, however, a global change to be done to the whole code base).

const call_grapht &call_graph,
const std::set<irep_idt> &functions,
std::set<irep_idt> &output)
{
if(functions.empty())
return;
if(functions.size()==1UL)
{
output.insert(*functions.cbegin());
return;
}

std::map<irep_idt, std::size_t> counting;
for(const auto &elem : call_graph.graph)
{
counting[elem.first]=0U;
counting[elem.second]=0U;
}
for(const auto &fn : functions)
{
std::unordered_set<irep_idt, dstring_hash> callees;
find_direct_or_indirect_callees_of_function(call_graph, fn, callees);
assert(callees.count(fn)==1U);
for(const auto &callee : callees)
++counting[callee];
}

std::set<irep_idt> leaves;
for(const auto &elem : counting)
if(elem.second!=0U)
{
const call_grapht::call_edges_ranget range=
call_graph.out_edges(elem.first);
if(range.first==range.second)
leaves.insert(elem.first);
}

for(auto &elem : counting)
if(leaves.count(elem.first)!=0UL)
output.insert(elem.first);
else if(elem.second!=0U && elem.second<functions.size())
{
const call_grapht::call_edges_ranget range=
call_graph.out_edges(elem.first);
for(auto it=range.first; it!=range.second; ++it)
{
auto cit=counting.find(it->second);
if(cit->second==functions.size())
output.insert(cit->first);
}
}
}
51 changes: 42 additions & 9 deletions src/analyses/call_graph.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,23 +23,31 @@ class call_grapht
explicit call_grapht(const goto_functionst &);

void output_dot(std::ostream &out) const;

/**
* It writes this into the passed stream in the Graphviz's DOT format.
* The method accepts also functions, because the callgraph does not
* store funtions (nodes). It only stores edges (from caller to callee).
* So, the resulting graph would not show not-called functions.
*/
void output_dot(const goto_functionst &functions, 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;
grapht graph;

void swap(call_grapht &other);

void add(const irep_idt &caller, const irep_idt &callee);

/**
* The type provides a mapping from edges of the call-graph to particular
* instructions in the caller GOTO programs, where the calls are performed.
*/
typedef std::map<
std::pair<irep_idt, irep_idt>,
std::vector<goto_programt::instructionst::const_iterator> >
map_from_edges_to_call_locationst;

const map_from_edges_to_call_locationst &
get_map_from_edges_to_call_locations() const
{ return map_from_edges_to_call_locations; }

void add(const irep_idt &caller, const irep_idt &callee,
const map_from_edges_to_call_locationst::mapped_type &call_sites);
protected:
void add(const irep_idt &function,
const goto_programt &body);
Expand Down Expand Up @@ -74,6 +82,9 @@ class call_grapht
* std::cout << it->second << ", ";
*/
call_edges_ranget out_edges(const irep_idt &caller) const;

private:
map_from_edges_to_call_locationst map_from_edges_to_call_locations;
};

/*******************************************************************\
Expand Down Expand Up @@ -160,4 +171,26 @@ void find_leaves_below_function(
const irep_idt &function,
std::unordered_set<irep_idt, dstring_hash> &output);

void find_direct_or_indirect_callees_of_function(
const call_grapht &call_graph,
const irep_idt &function,
std::unordered_set<irep_idt, dstring_hash> &output);

void find_nearest_common_callees(
const call_grapht &call_graph,
const std::set<irep_idt> &functions,
std::set<irep_idt> &output);

/**
* The "callee" must be a DIRECT callee of the "caller" in the "call_graph".
*/
inline const std::vector<goto_programt::instructionst::const_iterator> &
get_call_sites(
const call_grapht &call_graph,
const irep_idt &caller,
const irep_idt &callee)
{
return call_graph.get_map_from_edges_to_call_locations().at({caller, callee});
}

#endif // CPROVER_ANALYSES_CALL_GRAPH_H