Thunk.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Thunk_H
#define ROSE_BinaryAnalysis_Partitioner2_Thunk_H

#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Partitioner2/BasicTypes.h>
#include <Sawyer/SharedObject.h>

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 Partitioner&, const std::vector<SgAsmInstruction*>&);

ThunkDetection isX86JmpMemThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);

ThunkDetection isX86LeaJmpThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);

ThunkDetection isX86MovJmpThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);

ThunkDetection isX86AddJmpThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);


// Collective thunk predicates

typedef ThunkDetection(*ThunkPredicate)(const Partitioner&, 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 Partitioner&, const std::vector<SgAsmInstruction*>&) const;
};

// Thunk utilities

void splitThunkFunctions(Partitioner&, const ThunkPredicates::Ptr&);

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

#endif
#endif