Thunk.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Thunk_H
#define ROSE_BinaryAnalysis_Partitioner2_Thunk_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Sawyer/SharedObject.h>
 
class SgAsmInstruction;
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
// Individual thunk predicates
 
struct ThunkDetection {
    size_t nInsns;                                      
    std::string name;                                   
    ThunkDetection()
        : nInsns(0) {}
 
    ThunkDetection(size_t nInsns, const std::string &name)
        : nInsns(nInsns), name(name) {}
 
    // C++03 safe bool conversion since we don't have explicit operator bool.
private:
    typedef void(ThunkDetection::*unspecified_bool)() const;
    void this_type_does_not_support_comparisons() const {}
public:
    operator unspecified_bool() const {
        return nInsns ? &ThunkDetection::this_type_does_not_support_comparisons : 0;
    }
};
 
ThunkDetection isX86JmpImmThunk(const PartitionerConstPtr&, const std::vector<SgAsmInstruction*>&);
 
ThunkDetection isX86JmpMemThunk(const PartitionerConstPtr&, const std::vector<SgAsmInstruction*>&);
 
ThunkDetection isX86LeaJmpThunk(const PartitionerConstPtr&, const std::vector<SgAsmInstruction*>&);
 
ThunkDetection isX86MovJmpThunk(const PartitionerConstPtr&, const std::vector<SgAsmInstruction*>&);
 
ThunkDetection isX86AddJmpThunk(const PartitionerConstPtr&, const std::vector<SgAsmInstruction*>&);
 
 
// Collective thunk predicates
 
typedef ThunkDetection(*ThunkPredicate)(const PartitionerConstPtr&, const std::vector<SgAsmInstruction*>&);
 
class ThunkPredicates: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<ThunkPredicates> Ptr;
 
private:
    std::vector<ThunkPredicate> predicates_;
 
protected:
    // use 'instance' instead
    ThunkPredicates() {}
 
public:
    static Ptr instance() {
        return Ptr(new ThunkPredicates);
    }
 
    static Ptr allThunks();
 
    static Ptr functionMatcherThunks();
 
    const std::vector<ThunkPredicate>& predicates() const { return predicates_; }
    std::vector<ThunkPredicate>& predicates() { return predicates_; }
    ThunkDetection isThunk(const PartitionerConstPtr&, const std::vector<SgAsmInstruction*>&) const;
};
 
// Thunk utilities
 
void splitThunkFunctions(const PartitionerPtr&, const ThunkPredicates::Ptr&);
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif