EngineBinary.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_EngineBinary_H
#define ROSE_BinaryAnalysis_Partitioner2_EngineBinary_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/Engine.h>
#include <Rose/BinaryAnalysis/Partitioner2/ModulesLinux.h>
#include <Rose/BinaryAnalysis/Partitioner2/Utility.h>
#include <Rose/BinaryAnalysis/SerialIo.h>
 
#include <boost/noncopyable.hpp>
#include <boost/regex.hpp>
#include <stdexcept>
 
#ifdef ROSE_ENABLE_PYTHON_API
#undef slots                                            // stupid Qt pollution
#include <boost/python.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
class EngineBinary: public Engine {
    //                                  Types
public:
    using Ptr = EngineBinaryPtr;
 
private:
    using Super = Engine;
 
    //                                  Data members
private:
    BinaryLoaderPtr binaryLoader_;                      // how to remap, link, and fixup
    ModulesLinux::LibcStartMain::Ptr libcStartMain_;    // looking for "main" by analyzing libc_start_main?
    ThunkPredicatesPtr functionMatcherThunks_;          // predicates to find thunks when looking for functions
    ThunkPredicatesPtr functionSplittingThunks_;        // predicates for splitting thunks from front of functions
 
    // Constructors
protected:
    EngineBinary() = delete;
 
    explicit EngineBinary(const Settings&);
 
public:
    virtual ~EngineBinary();
 
    static Ptr instance();
 
    static Ptr instance(const Settings&);
 
    static Ptr factory();
 
    //                                  Command-line parsing
public:
 
    static Sawyer::CommandLine::SwitchGroup engineSwitches(EngineSettings&);
 
    static Sawyer::CommandLine::SwitchGroup loaderSwitches(LoaderSettings&);
 
    static Sawyer::CommandLine::SwitchGroup disassemblerSwitches(DisassemblerSettings&);
 
    static Sawyer::CommandLine::SwitchGroup partitionerSwitches(PartitionerSettings&);
 
    static Sawyer::CommandLine::SwitchGroup astConstructionSwitches(AstConstructionSettings&);
 
 
    //                                  Container parsing
    //
    // top-level: parseContainers
public:
    virtual void loadVxCore(const std::string &spec);
 
    //                                  Load specimens
    //
    // top-level: loadSpecimens
public:
    virtual BinaryLoaderPtr obtainLoader(const BinaryLoaderPtr &hint);
    virtual BinaryLoaderPtr obtainLoader();
    virtual void loadContainers(const std::vector<std::string> &fileNames);
 
    virtual void loadNonContainers(const std::vector<std::string> &names);
 
    //                                  Partitioner high-level functions
    //
    // top-level: partition
public:
    virtual PartitionerPtr createTunedPartitioner();
 
    virtual PartitionerPtr createPartitionerFromAst(SgAsmInterpretation*);
 
    virtual bool partitionCilSections(const PartitionerPtr&);
 
    bool hasCilCodeSection();
 
    //                                  Partitioner mid-level functions
    //
    // These are the functions called by the partitioner high-level stuff.  These are sometimes overridden in subclasses,
    // although it is more likely that the high-level stuff is overridden.
public:
    virtual std::vector<FunctionPtr> makeEntryFunctions(const PartitionerPtr&, SgAsmInterpretation*);
 
    virtual std::vector<FunctionPtr> makeErrorHandlingFunctions(const PartitionerPtr&, SgAsmInterpretation*);
 
    virtual std::vector<FunctionPtr> makeImportFunctions(const PartitionerPtr&, SgAsmInterpretation*);
 
    virtual std::vector<FunctionPtr> makeExportFunctions(const PartitionerPtr&, SgAsmInterpretation*);
 
    virtual std::vector<FunctionPtr> makeSymbolFunctions(const PartitionerPtr&, SgAsmInterpretation*);
 
    virtual std::vector<FunctionPtr> makeContainerFunctions(const PartitionerPtr&, SgAsmInterpretation*);
 
    virtual std::vector<FunctionPtr> makeInterruptVectorFunctions(const PartitionerPtr&, const AddressInterval &vector);
 
    virtual std::vector<FunctionPtr> makeUserFunctions(const PartitionerPtr&, const std::vector<rose_addr_t>&);
 
    virtual void discoverBasicBlocks(const PartitionerPtr&);
 
    virtual FunctionPtr makeNextDataReferencedFunction(const PartitionerConstPtr&, rose_addr_t &startVa /*in,out*/);
 
    virtual FunctionPtr makeNextCodeReferencedFunction(const PartitionerConstPtr&);
 
    virtual std::vector<FunctionPtr> makeCalledFunctions(const PartitionerPtr&);
 
    virtual std::vector<FunctionPtr> makeNextPrologueFunction(const PartitionerPtr&, rose_addr_t startVa);
    virtual std::vector<FunctionPtr> makeNextPrologueFunction(const PartitionerPtr&, rose_addr_t startVa,
                                                              rose_addr_t &lastSearchedVa);
    virtual std::vector<FunctionPtr>
    makeFunctionFromInterFunctionCalls(const PartitionerPtr&, rose_addr_t &startVa /*in,out*/);
 
    virtual void discoverFunctions(const PartitionerPtr&);
 
    virtual std::set<rose_addr_t> attachDeadCodeToFunction(const PartitionerPtr&, const FunctionPtr&,
                                                           size_t maxIterations=size_t(-1));
 
    virtual DataBlockPtr attachPaddingToFunction(const PartitionerPtr&, const FunctionPtr&);
 
    virtual std::vector<DataBlockPtr> attachPaddingToFunctions(const PartitionerPtr&);
 
    virtual size_t attachAllSurroundedCodeToFunctions(const PartitionerPtr&);
 
    virtual size_t attachSurroundedCodeToFunctions(const PartitionerPtr&);
 
    virtual void attachBlocksToFunctions(const PartitionerPtr&);
 
    virtual std::set<rose_addr_t> attachDeadCodeToFunctions(const PartitionerPtr&, size_t maxIterations=size_t(-1));
 
    virtual std::vector<DataBlockPtr> attachSurroundedDataToFunctions(const PartitionerPtr&);
 
    //                                  Partitioner low-level functions
    //
    // These are functions that a subclass seldom overrides, and maybe even shouldn't override because of their complexity or
    // the way the interact with one another.
public:
    virtual bool makeNextCallReturnEdge(const PartitionerPtr&, boost::logic::tribool assumeCallReturns);
 
    virtual BasicBlockPtr makeNextBasicBlockFromPlaceholder(const PartitionerPtr&);
 
    virtual BasicBlockPtr makeNextBasicBlock(const PartitionerPtr&);
 
 
    //                                  Build AST
 
    //                                  Settings and properties
public:
    BinaryLoaderPtr binaryLoader() const /*final*/;
    virtual void binaryLoader(const BinaryLoaderPtr&);
    ThunkPredicatesPtr functionMatcherThunks() const /*final*/;
    virtual void functionMatcherThunks(const ThunkPredicatesPtr&);
    ThunkPredicatesPtr functionSplittingThunks() const /*final*/;
    virtual void functionSplittingThunks(const ThunkPredicatesPtr&);
    //                                  Python API support functions
#ifdef ROSE_ENABLE_PYTHON_API
 
    // Similar to frontend, but returns a partitioner rather than an AST since the Python API doesn't yet support ASTs.
    PartitionerPtr pythonParseVector(boost::python::list &pyArgs, const std::string &purpose, const std::string &description);
    PartitionerPtr pythonParseSingle(const std::string &specimen, const std::string &purpose, const std::string &description);
 
#endif
 
    //                                  Internal stuff
private:
    void init();
 
    //                                  Overrides documented in the base class
public:
    virtual bool matchFactory(const std::vector<std::string> &specimen) const override;
    virtual EnginePtr instanceFromFactory(const Settings&) override;
    virtual void reset() override;
 
    using Engine::frontend;
    SgAsmBlock* frontend(const std::vector<std::string> &args,
                         const std::string &purpose, const std::string &description) override;
 
    using Engine::parseContainers;
    virtual SgAsmInterpretation* parseContainers(const std::vector<std::string> &fileNames) override;
 
    using Engine::loadSpecimens;
    virtual MemoryMapPtr loadSpecimens(const std::vector<std::string> &fileNames = std::vector<std::string>()) override;
 
    using Engine::partition;
    virtual PartitionerPtr partition(const std::vector<std::string> &fileNames = std::vector<std::string>()) override;
 
    using Engine::buildAst;
    virtual SgAsmBlock* buildAst(const std::vector<std::string> &fileNames = std::vector<std::string>()) override;
 
    virtual std::list<Sawyer::CommandLine::SwitchGroup> commandLineSwitches() override;
    virtual std::pair<std::string, std::string> specimenNameDocumentation() override;
    virtual bool isNonContainer(const std::string&) override;
    virtual bool areContainersParsed() const override;
    virtual PartitionerPtr createPartitioner() override;
    virtual void runPartitionerInit(const PartitionerPtr&) override;
    virtual void runPartitionerRecursive(const PartitionerPtr&) override;
    virtual void runPartitionerFinal(const PartitionerPtr&) override;
    virtual SgProject* roseFrontendReplacement(const std::vector<boost::filesystem::path> &fileNames) override;
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif