FunctionCallGraph.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_FunctionCallGraph_H
#define ROSE_BinaryAnalysis_Partitioner2_FunctionCallGraph_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
#include <Sawyer/Graph.h>
#include <Sawyer/Map.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
class FunctionCallGraph {
public:
    class Edge {
        friend class FunctionCallGraph;
        EdgeType type_;
        size_t count_;
    public:
        explicit Edge(EdgeType type): type_(type), count_(1) {}
 
        EdgeType type() const { return type_; }
 
        size_t count() const { return count_; }
    };
 
    class VertexKey {
    public:
        rose_addr_t address;
        VertexKey();
        explicit VertexKey(rose_addr_t);
        explicit VertexKey(const FunctionPtr&);
        bool operator<(VertexKey) const;
    };
        
    typedef Sawyer::Container::Graph<FunctionPtr, Edge, VertexKey> Graph;
 
private:
    Graph graph_;
 
public:
    const Graph& graph() const { return graph_; }
 
    FunctionCallGraph();
 
    ~FunctionCallGraph();
 
    boost::iterator_range<Graph::ConstVertexValueIterator> functions() {
        return graph_.vertexValues();
    }
    
    Graph::ConstVertexIterator findFunction(const FunctionPtr &function) const;
    Graph::ConstVertexIterator findFunction(rose_addr_t entryVa) const;
    bool exists(const FunctionPtr &function) const;
    bool exists(rose_addr_t entryVa) const;
    Graph::VertexIterator insertFunction(const FunctionPtr &function);
 
    Graph::EdgeIterator insertCall(const FunctionPtr &source, const FunctionPtr &target,
                                   EdgeType type = E_FUNCTION_CALL, size_t edgeCount = 0);
    Graph::EdgeIterator insertCall(const Graph::VertexIterator &source, const Graph::VertexIterator &target,
                                   EdgeType type = E_FUNCTION_CALL, size_t edgeCount = 0);
    std::vector<FunctionPtr> callers(const FunctionPtr &target) const;
    std::vector<FunctionPtr> callers(const Graph::ConstVertexIterator &target) const;
    size_t nCallers(const FunctionPtr &target) const;
    size_t nCallers(const Graph::ConstVertexIterator &target) const;
    std::vector<FunctionPtr> callees(const FunctionPtr &source) const;
    std::vector<FunctionPtr> callees(const Graph::ConstVertexIterator &source) const;
    size_t nCallees(const FunctionPtr &source) const;
    size_t nCallees(const Graph::ConstVertexIterator &source) const;
    size_t nCallsIn(const FunctionPtr &target) const;
    size_t nCallsIn(const Graph::ConstVertexIterator &target) const;
    size_t nCallsOut(const FunctionPtr &source) const;
    size_t nCallsOut(const Graph::ConstVertexIterator &source) const;
    size_t nCalls(const FunctionPtr &source, const FunctionPtr &target) const;
    size_t nCalls(const Graph::ConstVertexIterator &source, const Graph::ConstVertexIterator &target) const;
};
        
} // namespace
} // namespace
} // namespace
 
#endif
#endif