BinaryReturnValueUsed.h

#ifndef ROSE_BinaryAnalysis_ReturnValueUsed_H
#define ROSE_BinaryAnalysis_ReturnValueUsed_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Partitioner2/BasicTypes.h>
#include <Partitioner2/ControlFlowGraph.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::Function::Ptr> callees_;
    RegisterParts returnRegistersUsed_;
    RegisterParts returnRegistersUnused_;

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
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()
        : didConverge_(false) {}

    bool didConverge() const { return didConverge_; }
    void didConverge(bool b) { didConverge_ = b; }
    const std::vector<Partitioner2::Function::Ptr> callees() const { return callees_; }

    const RegisterParts& returnRegistersUsed() const { return returnRegistersUsed_; }
    RegisterParts& returnRegistersUsed() { return returnRegistersUsed_; }
    void returnRegistersUsed(const RegisterParts &regs) { returnRegistersUsed_ = regs; }
    const RegisterParts& returnRegistersUnused() const { return returnRegistersUnused_; }
    RegisterParts& returnRegistersUnused() { return returnRegistersUnused_; }
    void returnRegistersUnused(const RegisterParts &regs) { returnRegistersUnused_ = regs; }
private:
    friend class Analysis;
    void callees(const std::vector<Partitioner2::Function::Ptr> &functions) { callees_ = functions; }
};

//                                      Main analysis class

class Analysis {
private:
    typedef Sawyer::Container::Map<rose_addr_t /*call_site*/, CallSiteResults> CallSiteMap;

private:
    CallingConvention::Definition::Ptr defaultCallingConvention_;
    CallSiteMap callSites_;
    bool assumeCallerReturnsValue_;

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
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()
        : assumeCallerReturnsValue_(true) {}

    CallingConvention::Definition::Ptr defaultCallingConvention() const { return defaultCallingConvention_; }
    void defaultCallingConvention(const CallingConvention::Definition::Ptr &defn) { defaultCallingConvention_ = defn; }
    bool assumeCallerReturnsValue() const { return assumeCallerReturnsValue_; }
    void assumeCallerReturnsValue(bool b) { assumeCallerReturnsValue_ = b; }
    void clearResults();

    CallSiteResults analyzeCallSite(const Partitioner2::Partitioner&, 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::Function::Ptr>
    findCallees(const Partitioner2::Partitioner&, 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::Partitioner&, const Partitioner2::ControlFlowGraph::ConstVertexIterator &callSite);
};

} // namespace
} // namespace
} // namespace

#endif
#endif