ReturnValueUsed.h

#ifndef ROSE_BinaryAnalysis_ReturnValueUsed_H
#define ROSE_BinaryAnalysis_ReturnValueUsed_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/ControlFlowGraph.h>
#include <Rose/BinaryAnalysis/RegisterParts.h>
 
namespace Rose {
namespace BinaryAnalysis {
 
namespace ReturnValueUsed {
 
void initDiagnostics();
 
extern Sawyer::Message::Facility mlog;
 
//                                      Miscellaneous small types
 
class CallSiteResults {
    bool didConverge_;                                  // Are the following data members valid (else only approximations)?
    std::vector<Partitioner2::FunctionPtr> callees_;
    RegisterParts returnRegistersUsed_;
    RegisterParts returnRegistersUnused_;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S & s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(didConverge_);
        s & BOOST_SERIALIZATION_NVP(callees_);
        s & BOOST_SERIALIZATION_NVP(returnRegistersUsed_);
        s & BOOST_SERIALIZATION_NVP(returnRegistersUnused_);
    }
#endif
 
public:
    CallSiteResults();
    ~CallSiteResults();
 
    bool didConverge() const;
    void didConverge(bool);
    const std::vector<Partitioner2::FunctionPtr> callees() const;
 
    const RegisterParts& returnRegistersUsed() const;
    RegisterParts& returnRegistersUsed();
    void returnRegistersUsed(const RegisterParts&);
    const RegisterParts& returnRegistersUnused() const;
    RegisterParts& returnRegistersUnused();
    void returnRegistersUnused(const RegisterParts&);
private:
    friend class Analysis;
    void callees(const std::vector<Partitioner2::FunctionPtr>&);
};
 
//                                      Main analysis class
 
class Analysis {
private:
    typedef Sawyer::Container::Map<Address /*call_site*/, CallSiteResults> CallSiteMap;
 
private:
    CallingConvention::Definition::Ptr defaultCallingConvention_;
    CallSiteMap callSites_;
    bool assumeCallerReturnsValue_;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(defaultCallingConvention_);
        s & BOOST_SERIALIZATION_NVP(callSites_);
        s & BOOST_SERIALIZATION_NVP(assumeCallerReturnsValue_);
    }
#endif
 
public:
    Analysis();
 
    ~Analysis();
 
    CallingConvention::Definition::Ptr defaultCallingConvention() const;
    void defaultCallingConvention(const CallingConvention::DefinitionPtr&);
    bool assumeCallerReturnsValue() const;
    void assumeCallerReturnsValue(bool);
    void clearResults();
 
    CallSiteResults analyzeCallSite(const Partitioner2::PartitionerConstPtr&,
                                    const Partitioner2::ControlFlowGraph::ConstVertexIterator&);
 
private:
    // Given a control flow graph vertex, if that vertex is a function call basic block then return a list of the known, called
    // functions.
    std::vector<Partitioner2::FunctionPtr>
    findCallees(const Partitioner2::PartitionerConstPtr&, const Partitioner2::ControlFlowGraph::ConstVertexIterator &callSite);
 
    // Given a control flow graph vertex, if that vertex is a function call basic block then return a list of all vertices that
    // are known call-return points for that call.
    std::vector<Partitioner2::ControlFlowGraph::ConstVertexIterator>
    findReturnTargets(const Partitioner2::PartitionerConstPtr&,
                      const Partitioner2::ControlFlowGraph::ConstVertexIterator &callSite);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif