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/BasicTypes.h>

#include <Rose/BinaryAnalysis/Partitioner2/ControlFlowGraph.h>
#include <Rose/BinaryAnalysis/Partitioner2/Thunk.h>

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

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

class BasicBlockCallback: public Sawyer::SharedObject {
public:
    using Ptr = BasicBlockCallbackPtr;

    enum Termination {
        CONTINUE_DISCOVERY,                             
        TERMINATE_NOW,                                  
        TERMINATE_PRIOR,                                
    };

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

    struct Args {
        PartitionerConstPtr partitioner;                
        BasicBlockPtr bblock;                           
        Results &results;                               
        Args(const PartitionerConstPtr&, const BasicBlockPtr&, Results&);
        ~Args();
    };

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

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

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


class FunctionPrologueMatcher: public InstructionMatcher {
public:
    using Ptr = FunctionPrologueMatcherPtr;

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


class FunctionPaddingMatcher: public Sawyer::SharedObject {
public:
    using Ptr = FunctionPaddingMatcherPtr;

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

//                                      Generic modules

namespace Modules {

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

void demangleFunctionNames(const PartitionerConstPtr&);

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 BasicBlockPtr&);
};

class MatchThunk: public FunctionPrologueMatcher {
private:
    ThunkPredicatesPtr predicates_;
protected:
    std::vector<FunctionPtr> functions_;

protected:
    // use 'instance' instead
    MatchThunk(const ThunkPredicatesPtr&);
public:
    ~MatchThunk();

public:
    static Ptr instance(const ThunkPredicatesPtr&);

    ThunkPredicatesPtr predicates() const;
    void predicates(const ThunkPredicatesPtr&);
    virtual std::vector<FunctionPtr> functions() const override;
    virtual bool match(const PartitionerConstPtr&, rose_addr_t anchor) override;
};

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

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

std::vector<FunctionPtr> findSymbolFunctions(const PartitionerConstPtr&, SgAsmGenericHeader*);
std::vector<FunctionPtr> findSymbolFunctions(const PartitionerConstPtr&, SgAsmInterpretation*);
size_t findSymbolFunctions(const PartitionerConstPtr&, SgAsmGenericHeader*, std::vector<FunctionPtr>&);
void nameConstants(const PartitionerConstPtr&, const AddressInterval&);

std::vector<FunctionPtr> findNoopFunctions(const PartitionerConstPtr&);

void nameNoopFunctions(const PartitionerConstPtr&);

boost::logic::tribool isStackBasedReturn(const PartitionerConstPtr&, const BasicBlockPtr&);

//                                  Partitioner conversion to AST

SgAsmBlock* buildBasicBlockAst(const PartitionerConstPtr&, const BasicBlockPtr&, const FunctionPtr&,
                               const AstConstructionSettings&);

SgAsmBlock* buildDataBlockAst(const PartitionerConstPtr&, const DataBlockPtr&, const AstConstructionSettings&);

SgAsmFunction* buildFunctionAst(const PartitionerConstPtr&, const FunctionPtr&, const AstConstructionSettings&);

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

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

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

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

} // namespace

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

#endif
#endif