Modules.h

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

#include <Rose/BinaryAnalysis/Partitioner2/BasicBlock.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/ControlFlowGraph.h>
#include <Rose/BinaryAnalysis/Partitioner2/Function.h>
#include <Rose/BinaryAnalysis/Partitioner2/Thunk.h>
#include <Rose/BinaryAnalysis/Partitioner2/Utility.h>

#include <boost/logic/tribool.hpp>
#include <Sawyer/SharedPointer.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

class BasicBlockCallback: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<BasicBlockCallback> Ptr;

    enum Termination {
        CONTINUE_DISCOVERY,                             
        TERMINATE_NOW,                                  
        TERMINATE_PRIOR,                                
    };

    struct Results {
        Termination terminate;                          
        Results(): terminate(CONTINUE_DISCOVERY) {}
    };

    struct Args {
        const Partitioner &partitioner;                 
        BasicBlock::Ptr bblock;                         
        Results &results;                               
        Args(const Partitioner &partitioner, const BasicBlock::Ptr &bblock, Results &results)
            : partitioner(partitioner), bblock(bblock), results(results) {}
    };

    virtual bool operator()(bool chain, const Args&) = 0;
};

class InstructionMatcher: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<InstructionMatcher> Ptr;

    virtual bool match(const Partitioner&, rose_addr_t anchor) = 0;
};


class FunctionPrologueMatcher: public InstructionMatcher {
public:
    typedef Sawyer::SharedPointer<FunctionPrologueMatcher> Ptr;

    virtual std::vector<Function::Ptr> functions() const = 0;
};


class FunctionPaddingMatcher: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<FunctionPaddingMatcher> Ptr;

    virtual rose_addr_t match(const Partitioner&, rose_addr_t anchor) = 0;
};

//                                      Generic modules

namespace Modules {

std::string canonicalFunctionName(const std::string&);

void demangleFunctionNames(const Partitioner&);

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

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

class BasicBlockSizeLimiter: public BasicBlockCallback {
    size_t maxInsns_;

protected:
    BasicBlockSizeLimiter(size_t maxInsns)
        : maxInsns_(maxInsns) {}

public:
    typedef Sawyer::SharedPointer<BasicBlockSizeLimiter> Ptr;

    static Ptr instance(size_t maxInsns) {
        return Ptr(new BasicBlockSizeLimiter(maxInsns));
    }

    size_t maxInstructions() const { return maxInsns_; }
    void maxInstructions(size_t maxInsns) { maxInsns_ = maxInsns; }
    virtual bool operator()(bool chain, const Args&) override;
};

class IpRewriter: public BasicBlockCallback {
public:
    typedef std::pair<rose_addr_t, rose_addr_t> AddressPair;

private:
    std::vector<AddressPair> rewrites_;

protected:
    IpRewriter(const std::vector<AddressPair> &rewrites)
        : rewrites_(rewrites) {}

public:
    typedef Sawyer::SharedPointer<IpRewriter> Ptr;

    static Ptr instance(const std::vector<AddressPair> &rewrites) {
        return Ptr(new IpRewriter(rewrites));
    }

    const std::vector<AddressPair>& rewrites() const { return rewrites_; }
    std::vector<AddressPair>& rewrites() { return rewrites_; }
    void rewrites(std::vector<AddressPair> &v) { rewrites_ = v; }
    virtual bool operator()(bool chain, const Args&) override;
};

class InstructionLister: public CfgAdjustmentCallback {
public:
    struct Settings {
        AddressInterval where;                          // which basic block(s) we should we monitor
        Trigger::Settings when;                         // once found, how often we produce a list
        AddressInterval what;                           // what instructions to list
        Settings(): what(AddressInterval::whole()) {}
    };
private:
    Settings settings_;
    Trigger trigger_;
protected:
    explicit InstructionLister(const Settings &settings): settings_(settings), trigger_(settings.when) {}
public:
    static Ptr instance(const Settings &settings) { return Ptr(new InstructionLister(settings)); }
    static Ptr instance(const std::string &config);
    static Ptr instance(const std::vector<std::string> &args);
    static Sawyer::CommandLine::SwitchGroup switches(Settings&);
    static std::string docString();
    virtual bool operator()(bool chain, const AttachedBasicBlock &args) override;
    virtual bool operator()(bool chain, const DetachedBasicBlock&) override { return chain; }
};

class CfgGraphVizDumper: public CfgAdjustmentCallback {
public:
    struct Settings {
        AddressInterval where;                          // what basic block(s) we should monitor (those starting within)
        Trigger::Settings when;                         // once found, which event triggers the output
        AddressInterval what;                           // which basic blocks should be in the output
        bool showNeighbors;                             // should neighbor blocks be included in the output?
        std::string fileName;                           // name of output; '%' gets expanded to a distinct identifier
        Settings(): what(AddressInterval::whole()), showNeighbors(true), fileName("cfg-%.dot") {}
    };
private:
    Settings settings_;
    Trigger trigger_;
protected:
    CfgGraphVizDumper(const Settings &settings): settings_(settings), trigger_(settings.when) {}
public:
    static Ptr instance(const Settings &settings) { return Ptr(new CfgGraphVizDumper(settings)); }
    static Ptr instance(const std::string &config);
    static Ptr instance(const std::vector<std::string> &args);
    static Sawyer::CommandLine::SwitchGroup switches(Settings&);
    static std::string docString();
    virtual bool operator()(bool chain, const AttachedBasicBlock &args) override;
    virtual bool operator()(bool chain, const DetachedBasicBlock&) override { return chain; }
};

class HexDumper: public CfgAdjustmentCallback {
public:
    struct Settings {
        AddressInterval where;                          // what basic block(s) we should monitor (those starting within)
        Trigger::Settings when;                         // once found, which event triggers the output
        AddressInterval what;                           // which bytes should be in the output
        bool accentSpecialValues;                       // use "." and "##" for 0 and 0xff?
        Settings(): accentSpecialValues(true) {}
    };
private:
    Settings settings_;
    Trigger trigger_;
protected:
    HexDumper(const Settings &settings): settings_(settings), trigger_(settings.when) {}
public:
    static Ptr instance(const Settings &settings) { return Ptr(new HexDumper(settings)); }
    static Ptr instance(const std::string &config);
    static Ptr instance(const std::vector<std::string> &args);
    static Sawyer::CommandLine::SwitchGroup switches(Settings&);
    static std::string docString();
    virtual bool operator()(bool chain, const AttachedBasicBlock &args) override;
    virtual bool operator()(bool chain, const DetachedBasicBlock&) override { return chain; }
};

class Debugger: public CfgAdjustmentCallback {
public:
    struct Settings {
        AddressInterval where;                          // what basic block(s) should we monitor (those starting within)
        Trigger::Settings when;                         // once found, which event triggers
    };
private:
    Settings settings_;
    Trigger trigger_;
protected:
    Debugger(const Settings &settings): settings_(settings), trigger_(settings.when) {}
public:
    static Ptr instance(const Settings &settings) { return Ptr(new Debugger(settings)); }
    static Ptr instance(const std::string &config);
    static Ptr instance(const std::vector<std::string> &args);
    static Sawyer::CommandLine::SwitchGroup switches(Settings&);
    static std::string docString();
    virtual bool operator()(bool chain, const AttachedBasicBlock &args) override;
    virtual bool operator()(bool chain, const DetachedBasicBlock&) override { return chain; }
    void debug(rose_addr_t, const BasicBlock::Ptr&);
};

class MatchThunk: public FunctionPrologueMatcher {
private:
    ThunkPredicates::Ptr predicates_;
protected:
    std::vector<Function::Ptr> functions_;

protected:
    // use 'instance' instead
    MatchThunk(const ThunkPredicates::Ptr &predicates)
        : predicates_(predicates) {}
    
public:
    static Ptr instance(const ThunkPredicates::Ptr &predicates) {
        return Ptr(new MatchThunk(predicates));
    }

    ThunkPredicates::Ptr predicates() const { return predicates_; }
    void predicates(const ThunkPredicates::Ptr &p) { predicates_ = p; }
    virtual std::vector<Function::Ptr> functions() const override { return functions_; }
    virtual bool match(const Partitioner&, rose_addr_t anchor) override;
};

AddressIntervalSet deExecuteZeros(const MemoryMap::Ptr &map /*in,out*/, size_t threshold,
                                  size_t leaveAtFront=16, size_t leaveAtBack=1);

void labelSymbolAddresses(Partitioner&, SgAsmGenericHeader*);
void labelSymbolAddresses(Partitioner&, SgAsmInterpretation*);
void nameStrings(const Partitioner&, const AddressInterval&);

std::vector<Function::Ptr> findSymbolFunctions(const Partitioner&, SgAsmGenericHeader*);
std::vector<Function::Ptr> findSymbolFunctions(const Partitioner&, SgAsmInterpretation*);
size_t findSymbolFunctions(const Partitioner&, SgAsmGenericHeader*, std::vector<Function::Ptr>&);
void nameConstants(const Partitioner&, const AddressInterval&);

std::vector<Function::Ptr> findNoopFunctions(const Partitioner&);

void nameNoopFunctions(const Partitioner&);

boost::logic::tribool isStackBasedReturn(const Partitioner&, const BasicBlock::Ptr&);

//                                  Partitioner conversion to AST

SgAsmBlock* buildBasicBlockAst(const Partitioner&, const BasicBlock::Ptr&, const Function::Ptr&, const AstConstructionSettings&);

SgAsmBlock* buildDataBlockAst(const Partitioner&, const DataBlock::Ptr&, const AstConstructionSettings&);

SgAsmFunction* buildFunctionAst(const Partitioner&, const Function::Ptr&, const AstConstructionSettings&);

SgAsmBlock* buildGlobalBlockAst(const Partitioner&, const AstConstructionSettings&);

SgAsmBlock* buildAst(const Partitioner&, SgAsmInterpretation *interp=NULL,
                     const AstConstructionSettings &settings = AstConstructionSettings::strict());

void fixupAstPointers(SgNode *ast, SgAsmInterpretation *interp=NULL);

void fixupAstCallingConventions(const Partitioner&, SgNode *ast);

} // namespace

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

#endif
#endif