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/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 EngineBinaryPtr instance();

    static EngineBinaryPtr instance(const Settings&);

    static EngineBinaryPtr factory();

    virtual bool matchFactory(const std::vector<std::string> &specimen) const override;
    virtual EnginePtr instanceFromFactory(const Settings&) override;

    //                                  The very top-level use case
public:
    using Engine::frontend;
    SgAsmBlock* frontend(const std::vector<std::string> &args,
                         const std::string &purpose, const std::string &description) override;
    //                                  Basic top-level steps
public:
    virtual void reset() 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;
    //                                  Command-line parsing

    virtual std::list<Sawyer::CommandLine::SwitchGroup> commandLineSwitches() override;
    virtual std::pair<std::string, std::string> specimenNameDocumentation() override;

    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 bool isNonContainer(const std::string&) override;

    virtual bool areContainersParsed() const override;

    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 createGenericPartitioner();

    virtual PartitionerPtr createTunedPartitioner();

    virtual PartitionerPtr createPartitionerFromAst(SgAsmInterpretation*);

    virtual PartitionerPtr createPartitioner() override;

    virtual void runPartitionerInit(const PartitionerPtr&) override;

    virtual void runPartitionerRecursive(const PartitionerPtr&) override;

    virtual void runPartitionerFinal(const PartitionerPtr&) override;

    virtual void partitionCilSections(const PartitionerPtr&);

    //                                  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();

    // Similar to ::frontend but a lot less complicated.
    virtual SgProject* roseFrontendReplacement(const std::vector<boost::filesystem::path> &fileNames) override;
};

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

#endif
#endif