1 #ifndef ROSE_BinaryAnalysis_Partitioner2_EngineBinary_H
2 #define ROSE_BinaryAnalysis_Partitioner2_EngineBinary_H
3 #include <featureTests.h>
4 #ifdef ROSE_ENABLE_BINARY_ANALYSIS
6 #include <Rose/BinaryAnalysis/Partitioner2/Engine.h>
7 #include <Rose/BinaryAnalysis/Partitioner2/ModulesLinux.h>
8 #include <Rose/BinaryAnalysis/Partitioner2/Utility.h>
9 #include <Rose/BinaryAnalysis/SerialIo.h>
11 #include <boost/noncopyable.hpp>
12 #include <boost/regex.hpp>
15 #ifdef ROSE_ENABLE_PYTHON_API
16 #undef slots // stupid Qt pollution
17 #include <boost/python.hpp>
21 namespace BinaryAnalysis {
22 namespace Partitioner2 {
88 virtual bool matchFactory(
const std::vector<std::string> &specimen)
const override;
119 using Engine::frontend;
120 SgAsmBlock* frontend(
const std::vector<std::string> &args,
121 const std::string &purpose,
const std::string &description)
override;
133 virtual void reset()
override;
154 using Engine::parseContainers;
155 virtual SgAsmInterpretation* parseContainers(
const std::vector<std::string> &fileNames)
override;
178 using Engine::loadSpecimens;
179 virtual MemoryMapPtr loadSpecimens(
const std::vector<std::string> &fileNames = std::vector<std::string>())
override;
201 using Engine::partition;
202 virtual PartitionerPtr partition(
const std::vector<std::string> &fileNames = std::vector<std::string>())
override;
219 using Engine::buildAst;
220 virtual SgAsmBlock* buildAst(
const std::vector<std::string> &fileNames = std::vector<std::string>())
override;
227 virtual std::list<Sawyer::CommandLine::SwitchGroup> commandLineSwitches()
override;
228 virtual std::pair<std::string, std::string> specimenNameDocumentation()
override;
279 virtual void loadVxCore(
const std::string &spec);
313 virtual void loadContainers(
const std::vector<std::string> &fileNames);
508 rose_addr_t &lastSearchedVa);
529 virtual std::vector<FunctionPtr>
555 size_t maxIterations=
size_t(-1));
706 #ifdef ROSE_ENABLE_PYTHON_API
709 PartitionerPtr pythonParseVector(boost::python::list &pyArgs,
const std::string &purpose,
const std::string &description);
710 PartitionerPtr pythonParseSingle(
const std::string &specimen,
const std::string &purpose,
const std::string &description);
721 virtual SgProject* roseFrontendReplacement(
const std::vector<boost::filesystem::path> &fileNames)
override;
virtual std::set< rose_addr_t > attachDeadCodeToFunction(const PartitionerPtr &, const FunctionPtr &, size_t maxIterations=size_t(-1))
Attach dead code to function.
virtual void reset() override
Reset the engine to its initial state.
virtual void loadVxCore(const std::string &spec)
Parses a vxcore specification and initializes memory.
virtual void runPartitionerInit(const PartitionerPtr &) override
Finds interesting things to work on initially.
Settings for controling the engine behavior.
EngineBinary()=delete
Default constructor.
virtual std::vector< FunctionPtr > makeFunctionFromInterFunctionCalls(const PartitionerPtr &, rose_addr_t &startVa)
Make functions from inter-function calls.
virtual std::vector< FunctionPtr > makeCalledFunctions(const PartitionerPtr &)
Make functions for function call edges.
virtual bool areContainersParsed() const override
Returns true if containers are parsed.
virtual void attachBlocksToFunctions(const PartitionerPtr &)
Attach basic blocks to functions.
virtual size_t attachSurroundedCodeToFunctions(const PartitionerPtr &)
Attach intra-function basic blocks to functions.
Settings that control the disassembler.
Engine for specimens containing machine instructions.
virtual void partitionCilSections(const PartitionerPtr &)
Partition any sections containing CIL code.
Base class for engines driving the partitioner.
virtual FunctionPtr makeNextDataReferencedFunction(const PartitionerConstPtr &, rose_addr_t &startVa)
Scan read-only data to find function pointers.
virtual PartitionerPtr createPartitionerFromAst(SgAsmInterpretation *)
Create a partitioner from an AST.
virtual BasicBlockPtr makeNextBasicBlockFromPlaceholder(const PartitionerPtr &)
Discover basic block at next placeholder.
virtual std::vector< FunctionPtr > makeErrorHandlingFunctions(const PartitionerPtr &, SgAsmInterpretation *)
Make functions at error handling addresses.
static Sawyer::CommandLine::SwitchGroup disassemblerSwitches(DisassemblerSettings &)
Command-line switches related to decoding instructions.
Engine()=delete
Default constructor.
A collection of related switch declarations.
virtual std::vector< FunctionPtr > makeImportFunctions(const PartitionerPtr &, SgAsmInterpretation *)
Make functions at import trampolines.
virtual DataBlockPtr attachPaddingToFunction(const PartitionerPtr &, const FunctionPtr &)
Attach function padding to function.
Main namespace for the ROSE library.
Settings for loading specimens.
static Sawyer::CommandLine::SwitchGroup engineSwitches(EngineSettings &)
Command-line switches related to the general engine behavior.
Settings that control building the AST.
ThunkPredicatesPtr functionSplittingThunks() const
Property: Predicate for finding thunks at the start of functions.
static EngineBinaryPtr instance()
Allocating constructor.
static Sawyer::CommandLine::SwitchGroup astConstructionSwitches(AstConstructionSettings &)
Command-line switches related to constructing an AST from the partitioner.
BinaryLoaderPtr binaryLoader() const
Property: binary loader.
virtual void loadContainers(const std::vector< std::string > &fileNames)
Loads memory from binary containers.
static Sawyer::CommandLine::SwitchGroup loaderSwitches(LoaderSettings &)
Command-line switches related to loading specimen into memory.
Settings that control the engine partitioning.
virtual PartitionerPtr createTunedPartitioner()
Create a tuned partitioner.
virtual void runPartitionerFinal(const PartitionerPtr &) override
Runs the final parts of partitioning.
virtual std::vector< FunctionPtr > makeInterruptVectorFunctions(const PartitionerPtr &, const AddressInterval &vector)
Make functions from an interrupt vector.
virtual std::vector< DataBlockPtr > attachPaddingToFunctions(const PartitionerPtr &)
Attach padding to all functions.
virtual size_t attachAllSurroundedCodeToFunctions(const PartitionerPtr &)
Attach all possible intra-function basic blocks to functions.
virtual std::set< rose_addr_t > attachDeadCodeToFunctions(const PartitionerPtr &, size_t maxIterations=size_t(-1))
Attach dead code to functions.
virtual FunctionPtr makeNextCodeReferencedFunction(const PartitionerConstPtr &)
Scan instruction ASTs to function pointers.
Sawyer::SharedPointer< EngineBinary > EngineBinaryPtr
Shared-ownership pointer for EngineBinary.
static Sawyer::CommandLine::SwitchGroup partitionerSwitches(PartitionerSettings &)
Command-line switches related to partitioning instructions.
static EngineBinaryPtr factory()
Allocate a factory.
virtual PartitionerPtr createGenericPartitioner()
Create a generic partitioner.
virtual std::vector< FunctionPtr > makeContainerFunctions(const PartitionerPtr &, SgAsmInterpretation *)
Make functions based on specimen container.
virtual void discoverBasicBlocks(const PartitionerPtr &)
Discover as many basic blocks as possible.
virtual std::vector< FunctionPtr > makeExportFunctions(const PartitionerPtr &, SgAsmInterpretation *)
Make functions at export addresses.
virtual std::vector< FunctionPtr > makeUserFunctions(const PartitionerPtr &, const std::vector< rose_addr_t > &)
Make a function at each specified address.
virtual void loadNonContainers(const std::vector< std::string > &names)
Loads memory from non-containers.
virtual std::vector< FunctionPtr > makeEntryFunctions(const PartitionerPtr &, SgAsmInterpretation *)
Make functions at specimen entry addresses.
virtual void discoverFunctions(const PartitionerPtr &)
Discover as many functions as possible.
virtual bool isNonContainer(const std::string &) override
Determine whether a specimen name is a non-container.
virtual BinaryLoaderPtr obtainLoader()
Obtain a binary loader.
virtual PartitionerPtr createPartitioner() override
Create partitioner.
virtual bool makeNextCallReturnEdge(const PartitionerPtr &, boost::logic::tribool assumeCallReturns)
Insert a call-return edge and discover its basic block.
virtual std::vector< FunctionPtr > makeNextPrologueFunction(const PartitionerPtr &, rose_addr_t startVa)
Make function at prologue pattern.
ThunkPredicatesPtr functionMatcherThunks() const
Property: Predicate for finding functions that are thunks.
This class represents a source project, with a list of SgFile objects and global information about th...
virtual std::vector< DataBlockPtr > attachSurroundedDataToFunctions(const PartitionerPtr &)
Attach intra-function data to functions.
virtual BasicBlockPtr makeNextBasicBlock(const PartitionerPtr &)
Discover a basic block.
virtual void runPartitionerRecursive(const PartitionerPtr &) override
Runs the recursive part of partioning.
Represents an interpretation of a binary container.
virtual std::vector< FunctionPtr > makeSymbolFunctions(const PartitionerPtr &, SgAsmInterpretation *)
Make functions for symbols.