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,                                
    };
    enum Termination {…};
 
    struct Results {
        Termination terminate;                          
        Results(): terminate(CONTINUE_DISCOVERY) {}
    };
    struct Results {…};
 
    struct Args {
        PartitionerConstPtr partitioner;                
        BasicBlockPtr bblock;                           
        Results &results;                               
        Args(const PartitionerConstPtr&, const BasicBlockPtr&, Results&);
        ~Args();
    };
    struct Args {…};
 
    virtual bool operator()(bool chain, const Args&) = 0;
};
class BasicBlockCallback: public Sawyer::SharedObject {…};
 
class InstructionMatcher: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<InstructionMatcher> Ptr;
 
    virtual bool match(const PartitionerConstPtr&, Address anchor) = 0;
};
class InstructionMatcher: public Sawyer::SharedObject {…};
 
 
class FunctionPrologueMatcher: public InstructionMatcher {
public:
    using Ptr = FunctionPrologueMatcherPtr;
 
    virtual std::vector<FunctionPtr> functions() const = 0;
};
class FunctionPrologueMatcher: public InstructionMatcher {…};
 
 
class FunctionPaddingMatcher: public Sawyer::SharedObject {
public:
    using Ptr = FunctionPaddingMatcherPtr;
 
    virtual Address match(const PartitionerConstPtr&, Address anchor) = 0;
};
class FunctionPaddingMatcher: public Sawyer::SharedObject {…};
 
//                                      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 AddGhostSuccessors: public BasicBlockCallback {…};
 
class PreventDiscontiguousBlocks: public BasicBlockCallback {
public:
    static Ptr instance() { return Ptr(new PreventDiscontiguousBlocks); }
    virtual bool operator()(bool chain, const Args &args) override;
};
class PreventDiscontiguousBlocks: public BasicBlockCallback {…};
 
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));
    }
    static Ptr instance(size_t maxInsns) {…}
 
    size_t maxInstructions() const { return maxInsns_; }
    void maxInstructions(size_t maxInsns) { maxInsns_ = maxInsns; }
    virtual bool operator()(bool chain, const Args&) override;
};
class BasicBlockSizeLimiter: public BasicBlockCallback {…};
 
class IpRewriter: public BasicBlockCallback {
public:
    typedef std::pair<Address, Address> 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));
    }
    static Ptr instance(const std::vector<AddressPair> &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 IpRewriter: public BasicBlockCallback {…};
 
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()) {}
    };
    struct Settings {…};
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 InstructionLister: public CfgAdjustmentCallback {…};
 
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") {}
    };
    struct Settings {…};
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 CfgGraphVizDumper: public CfgAdjustmentCallback {…};
 
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) {}
    };
    struct Settings {…};
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 HexDumper: public CfgAdjustmentCallback {…};
 
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
    };
    struct Settings {…};
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(Address, const BasicBlockPtr&);
};
class Debugger: public CfgAdjustmentCallback {…};
 
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&, Address anchor) override;
};
class MatchThunk: public FunctionPrologueMatcher {…};
 
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 Modules {…}
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif