ModulesX86.h

#ifndef ROSE_Partitioner2_ModulesX86_H
#define ROSE_Partitioner2_ModulesX86_H

#include <Partitioner2/Modules.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

namespace ModulesX86 {

class MatchStandardPrologue: public FunctionPrologueMatcher {
protected:
    Function::Ptr function_;
public:
    static Ptr instance() { return Ptr(new MatchStandardPrologue); } 
    virtual std::vector<Function::Ptr> functions() const ROSE_OVERRIDE { return std::vector<Function::Ptr>(1, function_); }
    virtual bool match(const Partitioner &partitioner, rose_addr_t anchor) ROSE_OVERRIDE;
};

class MatchHotPatchPrologue: public MatchStandardPrologue {
public:
    static Ptr instance() { return Ptr(new MatchHotPatchPrologue); } 
    virtual std::vector<Function::Ptr> functions() const ROSE_OVERRIDE { return std::vector<Function::Ptr>(1, function_); }
    virtual bool match(const Partitioner &partitioner, rose_addr_t anchor) ROSE_OVERRIDE;
};

class MatchAbbreviatedPrologue: public FunctionPrologueMatcher {
protected:
    Function::Ptr function_;
public:
    static Ptr instance() { return Ptr(new MatchAbbreviatedPrologue); }
    virtual std::vector<Function::Ptr> functions() const ROSE_OVERRIDE { return std::vector<Function::Ptr>(1, function_); }
    virtual bool match(const Partitioner &partitioner, rose_addr_t anchor) ROSE_OVERRIDE;
};

class MatchEnterPrologue: public FunctionPrologueMatcher {
protected:
    Function::Ptr function_;
public:
    static Ptr instance() { return Ptr(new MatchEnterPrologue); } 
    virtual std::vector<Function::Ptr> functions() const ROSE_OVERRIDE { return std::vector<Function::Ptr>(1, function_); }
    virtual bool match(const Partitioner &partitioner, rose_addr_t anchor) ROSE_OVERRIDE;
};

class MatchThunk: public FunctionPrologueMatcher {
protected:
    std::vector<Function::Ptr> functions_;
public:
    static Ptr instance() { return Ptr(new MatchThunk); } 
    virtual std::vector<Function::Ptr> functions() const ROSE_OVERRIDE { return functions_; }
    virtual bool match(const Partitioner&, rose_addr_t anchor) ROSE_OVERRIDE;
};

class MatchRetPadPush: public FunctionPrologueMatcher {
protected:
    Function::Ptr function_;
public:
    static Ptr instance() { return Ptr(new MatchRetPadPush); } 
    virtual std::vector<Function::Ptr> functions() const ROSE_OVERRIDE { return std::vector<Function::Ptr>(1, function_); }
    virtual bool match(const Partitioner &partitioner, rose_addr_t anchor) ROSE_OVERRIDE;
};

class FunctionReturnDetector: public BasicBlockCallback {
public:
    static Ptr instance() { return Ptr(new FunctionReturnDetector); } 
    virtual bool operator()(bool chain, const Args&) ROSE_OVERRIDE;
};

class SwitchSuccessors: public BasicBlockCallback {
public:
    static Ptr instance() { return Ptr(new SwitchSuccessors); } 
    virtual bool operator()(bool chain, const Args&) ROSE_OVERRIDE;
};

size_t isJmpMemThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);
size_t isLeaJmpThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);
size_t isMovJmpThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);
size_t isJmpImmThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);
size_t isThunk(const Partitioner&, const std::vector<SgAsmInstruction*>&);
bool matchEnterAnyZero(const Partitioner&, SgAsmX86Instruction*);

Sawyer::Optional<rose_addr_t> matchJmpConst(const Partitioner&, SgAsmX86Instruction*);

bool matchLeaCxMemBpConst(const Partitioner&, SgAsmX86Instruction*);

bool matchJmpMem(const Partitioner&, SgAsmX86Instruction*);

bool matchMovBpSp(const Partitioner&, SgAsmX86Instruction*);

bool matchMovDiDi(const Partitioner&, SgAsmX86Instruction*);

bool matchPushBp(const Partitioner&, SgAsmX86Instruction*);

bool matchPushSi(const Partitioner&, SgAsmX86Instruction*);

size_t isThunk(const std::vector<SgAsmInstruction*> &insns);

void splitThunkFunctions(Partitioner&);

std::vector<rose_addr_t> scanCodeAddressTable(const Partitioner&, AddressInterval &tableLimits /*in,out*/,
                                              const AddressInterval &targetLimits, size_t tableEntrySize);

Sawyer::Optional<rose_addr_t> findTableBase(SgAsmExpression*);


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

#endif