1#ifndef ROSE_BinaryAnalysis_Partitioner2_Partitioner_H
2#define ROSE_BinaryAnalysis_Partitioner2_Partitioner_H
3#include <featureTests.h>
4#ifdef ROSE_ENABLE_BINARY_ANALYSIS
5#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
7#include <Rose/BinaryAnalysis/Partitioner2/AddressUsageMap.h>
8#include <Rose/BinaryAnalysis/Partitioner2/Configuration.h>
9#include <Rose/BinaryAnalysis/Partitioner2/ControlFlowGraph.h>
10#include <Rose/BinaryAnalysis/Partitioner2/Semantics.h>
12#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
13#include <Rose/BinaryAnalysis/InstructionProvider.h>
14#include <Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h>
15#include <Rose/BinaryAnalysis/SerialIo.h>
16#include <Rose/BinaryAnalysis/SourceLocations.h>
17#include <Rose/BinaryAnalysis/Unparser/Settings.h>
18#include <Rose/Progress.h>
20#include <Sawyer/Attribute.h>
21#include <Sawyer/Callbacks.h>
22#include <Sawyer/IntervalSet.h>
23#include <Sawyer/Map.h>
24#include <Sawyer/Message.h>
25#include <Sawyer/Optional.h>
26#include <Sawyer/ProgressBar.h>
27#include <Sawyer/SharedObject.h>
28#include <Sawyer/SharedPointer.h>
30#include <boost/filesystem.hpp>
31#include <boost/format.hpp>
32#include <boost/move/utility_core.hpp>
33#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34#include <boost/serialization/access.hpp>
45namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 = InstructionSemantics; }}
48namespace BinaryAnalysis {
49namespace Partitioner2 {
318 bool autoAddCallReturnEdges_ =
false;
319 bool assumeFunctionsReturn_ =
true;
320 size_t stackDeltaInterproceduralLimit_ = 1;
335 ControlFlowGraph::VertexIterator undiscoveredVertex_;
336 ControlFlowGraph::VertexIterator indeterminateVertex_;
337 ControlFlowGraph::VertexIterator nonexistingVertex_;
338 static const size_t nSpecialVertices = 3;
344 mutable SAWYER_THREAD_TRAITS::Mutex mutex_;
346 mutable size_t cfgProgressTotal_ = 0;
355#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
357 friend class boost::serialization::access;
358 template<
class Archive>
void serializeCommon(Archive&,
unsigned);
359 template<
class Archive>
void save(Archive&,
unsigned)
const;
360 template<
class Archive>
void load(Archive&,
unsigned);
361 BOOST_SERIALIZATION_SPLIT_MEMBER();
607 std::vector<AddressUser>
users(rose_addr_t)
const;
1056 ControlFlowGraph::VertexIterator
truncateBasicBlock(
const ControlFlowGraph::ConstVertexIterator &basicBlock,
1395 struct MayReturnVertexInfo {
1396 enum State {INIT, CALCULATING, FINISHED};
1398 bool processedCallees;
1399 boost::logic::tribool anyCalleesReturn;
1400 boost::logic::tribool result;
1401 MayReturnVertexInfo(): state(INIT), processedCallees(false), anyCalleesReturn(false), result(boost::indeterminate) {}
1405 bool mayReturnIsSignificantEdge(
const ControlFlowGraph::ConstEdgeIterator &edge,
1406 std::vector<MayReturnVertexInfo> &vertexInfo)
const;
1409 boost::logic::tribool mayReturnDoesCalleeReturn(
const ControlFlowGraph::ConstVertexIterator &vertex,
1410 std::vector<MayReturnVertexInfo> &vertexInfo)
const;
1413 boost::logic::tribool mayReturnDoesSuccessorReturn(
const ControlFlowGraph::ConstVertexIterator &vertex,
1414 std::vector<MayReturnVertexInfo> &vertexInfo)
const;
1418 std::vector<MayReturnVertexInfo> &vertexInfo)
const;
1768 std::vector<FunctionPtr>
1771 std::vector<FunctionPtr>
1774 std::vector<FunctionPtr>
1777 std::vector<FunctionPtr>
1780 template<
class Container>
1781 std::vector<FunctionPtr>
1783 std::vector<FunctionPtr> retval;
1784 for (
const typename Container::value_type& bblock: bblocks) {
1785 for (
const FunctionPtr &function: functionsOwningBasicBlock(bblock,
false))
1786 insertUnique(retval, function, sortFunctionsByAddress);
2175 void dumpCfg(std::ostream&,
const std::string &prefix=
"",
bool showBlocks=
true,
bool computeProperties=
true)
const;
2198 std::string
vertexName(
const ControlFlowGraph::ConstVertexIterator&)
const;
2212 std::string
edgeNameSrc(
const ControlFlowGraph::ConstEdgeIterator&)
const;
2221 std::string
edgeNameDst(
const ControlFlowGraph::ConstEdgeIterator&)
const;
2229 static std::string
edgeName(
const ControlFlowGraph::Edge&);
2230 std::string
edgeName(
const ControlFlowGraph::ConstEdgeIterator&)
const;
2285 void checkConsistency()
const;
2476#ifdef ROSE_ENABLE_PYTHON_API
2477 void pythonUnparse()
const;
2492 void updateCfgProgress();
2497 ControlFlowGraph::VertexIterator convertFrom(
const Partitioner &other,
2498 ControlFlowGraph::ConstVertexIterator otherIter);
2502 ControlFlowGraph::EdgeIterator adjustPlaceholderEdges(
const ControlFlowGraph::VertexIterator &placeholder);
2506 ControlFlowGraph::EdgeIterator adjustNonexistingEdges(
const ControlFlowGraph::VertexIterator &vertex);
2509 BasicBlockPtr discoverBasicBlockInternal(rose_addr_t startVa)
const;
2513 void bblockAttached(
const ControlFlowGraph::VertexIterator &newVertex);
2517 void bblockDetached(rose_addr_t startVa,
const BasicBlockPtr &removedBlock);
2520 void rebuildVertexIndices();
Function calling convention.
Provides and caches instructions.
Holds configuration information.
Function call information.
Partitions instructions into basic blocks and functions.
Sawyer::Container::Map< rose_addr_t, std::string > AddressNameMap
Map address to name.
AddressIntervalSet basicBlockInstructionExtent(const BasicBlockPtr &) const
Returns the addresses used by basic block instructions.
Sawyer::Callbacks< CfgAdjustmentCallback::Ptr > CfgAdjustmentCallbacks
See cfgAdjustmentCallbacks.
const Configuration & configuration() const
Property: Configuration information.
std::vector< FunctionPtr > nextFunctionPrologue(rose_addr_t startVa)
Finds the next function by searching for a function prologue.
ControlFlowGraph::VertexIterator nonexistingVertex()
Returns the special "non-existing" vertex.
ControlFlowGraph::ConstVertexIterator nonexistingVertex() const
Returns the special "non-existing" vertex.
static std::string dataBlockName(const DataBlockPtr &)
Name of a data block.
BasicBlockPtr basicBlockContainingInstruction(rose_addr_t insnVa) const
Returns the basic block that contains a specific instruction address.
bool basicBlockIsFunctionReturn(const BasicBlockPtr &) const
Determine if a basic block looks like a function return.
std::vector< Function::Ptr > entryFunctions()
Entry points of the binary.
std::vector< BasicBlockPtr > basicBlocksContainedIn(const AddressInterval &) const
Returns basic blocks that are fully contained in an address interval.
FunctionPrologueMatchers & functionPrologueMatchers()
Ordered list of function prologue matchers.
ControlFlowGraph::VertexIterator undiscoveredVertex()
Returns the special "undiscovered" vertex.
void basicBlockDropSemantics() const
Immediately drop semantic information for all attached basic blocks.
size_t nDataBlocks() const
Returns the number of data blocks attached to the CFG/AUM.
ControlFlowGraph::ConstVertexIterator indeterminateVertex() const
Returns the special "indeterminate" vertex.
void allFunctionCallingConvention() const
Compute calling conventions for all functions.
InstructionSemantics::BaseSemantics::SValuePtr functionStackDelta(const FunctionPtr &function) const
Stack delta analysis for one function.
void interpretation(SgAsmInterpretation *)
Property: Interpretation corresponding to the memory map.
Unparser::BasePtr unparser() const
Returns an unparser.
void forgetFunctionIsNoop() const
Clears cached function no-op analysis results.
CfgAdjustmentCallbacks & cfgAdjustmentCallbacks()
List of all callbacks invoked when the CFG is adjusted.
Sawyer::Optional< bool > functionOptionalMayReturn(const FunctionPtr &function) const
May-return analysis for one function.
bool addressIsExecutable(rose_addr_t) const
Returns true if address is executable.
std::vector< SgAsmInstruction * > instructionsContainedIn(const AddressInterval &) const
Returns instructions that are fully contained in an address interval.
Sawyer::Optional< bool > basicBlockOptionalMayReturn(const BasicBlockPtr &) const
Determine if part of the CFG can pop the top stack frame.
BasicBlockSuccessors basicBlockSuccessors(const BasicBlockPtr &, Precision::Level precision=Precision::HIGH) const
Determine successors for a basic block.
std::vector< DataBlockPtr > dataBlocksContainedIn(const AddressInterval &) const
Returns data blocks that are fully contained in an address interval.
SemanticMemoryParadigm semanticMemoryParadigm() const
Property: Whether to use map- or list-based memory states.
void allFunctionCallingConvention(const CallingConvention::Definition::Ptr &dflt) const
Compute calling conventions for all functions.
FunctionCallGraph functionCallGraph(AllowParallelEdges::Type allowParallelEdges) const
Returns a function call graph.
SgAsmInstruction * discoverInstruction(rose_addr_t startVa) const
Discover an instruction.
size_t stackDeltaInterproceduralLimit() const
Property: max depth for inter-procedural stack delta analysis.
void stackDeltaInterproceduralLimit(size_t)
Property: max depth for inter-procedural stack delta analysis.
FunctionPtr functionExists(const FunctionPtr &function) const
Determines whether a function exists in the CFG/AUM.
void forgetStackDeltas(const FunctionPtr &) const
Clears all cached stack deltas.
void unparse(std::ostream &, const DataBlockPtr &) const
Unparse some entity.
std::vector< FunctionPtr > functionsOverlapping(const AddressInterval &) const
Returns functions that overlap with specified address interval.
DataBlockPtr matchFunctionPadding(const FunctionPtr &)
Finds function padding.
std::set< rose_addr_t > basicBlockGhostSuccessors(const BasicBlockPtr &) const
Determine ghost successors for a basic block.
void configureInsnPlainUnparser(const Unparser::BasePtr &) const
Configure plain single-instruction unparser.
bool functionIsNoop(const FunctionPtr &) const
Function no-op analysis.
void fixInterFunctionEdge(const ControlFlowGraph::ConstEdgeIterator &)
Adjust inter-function edge types.
ControlFlowGraph::VertexIterator truncateBasicBlock(const ControlFlowGraph::ConstVertexIterator &basicBlock, SgAsmInstruction *insn)
Truncate an attached basic-block.
Sawyer::Optional< Thunk > functionIsThunk(const FunctionPtr &) const
True if function is a thunk.
std::set< rose_addr_t > ghostSuccessors() const
Determine all ghost successors in the control flow graph.
size_t attachFunctionBasicBlocks(const Functions &)
Create placeholders for function basic blocks.
const ControlFlowGraph & cfg() const
Returns the control flow graph.
const CallingConvention::Analysis & functionCallingConvention(const FunctionPtr &, const CallingConvention::Definition::Ptr &dflt) const
Calling convention analysis for one function.
const SourceLocations & sourceLocations() const
Property: Source locations.
Partitioner & operator=(BOOST_RV_REF(Partitioner))
Move assignment.
bool isEdgeInterProcedural(ControlFlowGraph::ConstEdgeIterator edge) const
Determine if an edge is inter-procedural.
void checkingCallBranch(bool)
Property: Whether to look for function calls used as branches.
std::vector< BasicBlockPtr > basicBlocksSpanning(const AddressInterval &) const
Returns basic blocks that span an entire address interval.
Configuration & configuration()
Property: Configuration information.
BasicBlockPtr discoverBasicBlock(rose_addr_t startVa) const
Discover instructions for a detached basic block.
AddressUsageMap aum(const FunctionPtr &) const
Returns the address usage map for a single function.
std::vector< FunctionPaddingMatcherPtr > FunctionPaddingMatchers
See functionPaddingMatchers.
ControlFlowGraph::VertexIterator findPlaceholder(rose_addr_t startVa)
Find the CFG vertex for a basic block placeholder.
bool placeholderExists(rose_addr_t startVa) const
Determines whether a basic block placeholder exists in the CFG.
SgAsmGenericSection * elfGot(SgAsmElfFileHeader *)
Find the ELF global offset table and save its address.
std::vector< DataBlockPtr > dataBlocksSpanning(const AddressInterval &) const
Returns data blocks that span an entire address interval.
DataBlockPtr findBestDataBlock(const AddressInterval &) const
Find an existing data block.
void forgetStackDeltas() const
Clears all cached stack deltas.
void allFunctionStackDelta() const
Compute stack delta analysis for all functions.
bool assumeFunctionsReturn() const
Property: Assume (or not) that function calls return.
static std::string basicBlockName(const BasicBlockPtr &)
Name of a basic block.
void unparse(std::ostream &, const BasicBlockPtr &) const
Unparse some entity.
AddressIntervalSet basicBlockDataExtent(const BasicBlockPtr &) const
Returns the addresses used by basic block data.
size_t nPlaceholders() const
Returns the number of basic basic block placeholders in the CFG.
const std::string & addressName(rose_addr_t) const
Property: Name for address.
AddressIntervalSet functionExtent(const FunctionPtr &) const
Returns the addresses used by a function.
std::vector< BasicBlockPtr > basicBlocks() const
Returns all basic blocks attached to the CFG.
bool isEdgeInterProcedural(const ControlFlowGraph::Edge &edge, const FunctionPtr &sourceFunction) const
Determine if an edge is inter-procedural.
size_t nFunctions() const
Returns the number of functions attached to the CFG/AUM.
std::vector< FunctionPtr > discoverCalledFunctions() const
Scans the CFG to find function calls.
bool isEdgeIntraProcedural(ControlFlowGraph::ConstEdgeIterator edge) const
Determine if an edge is intra-procedural.
FunctionPtr functionExists(rose_addr_t entryVa) const
Determines whether a function exists in the CFG/AUM.
BasicBlockPtr basicBlockExists(const BasicBlockPtr &) const
Determines whether a discovered basic block exists in the CFG/AUM.
void settings(const BasePartitionerSettings &)
Partitioner settings.
bool autoAddCallReturnEdges() const
Property: Insert (or not) function call return edges.
Architecture::BaseConstPtr architecture() const
Property: Architecture information.
void unparse(std::ostream &, SgAsmInstruction *) const
Unparse some entity.
bool isEdgeInterProcedural(const ControlFlowGraph::Edge &edge, const FunctionPtr &sourceFunction, const FunctionPtr &targetFunction) const
Determine if an edge is inter-procedural.
std::string edgeName(const ControlFlowGraph::ConstEdgeIterator &) const
Name of an edge.
void unparse(std::ostream &, const FunctionPtr &) const
Unparse some entity.
void addressName(rose_addr_t, const std::string &)
Property: Name for address.
ControlFlowGraph::VertexIterator indeterminateVertex()
Returns the special "indeterminate" vertex.
bool isEdgeIntraProcedural(const ControlFlowGraph::Edge &edge, const FunctionPtr &) const
Determine if an edge is intra-procedural.
ControlFlowGraph::ConstVertexIterator findPlaceholder(rose_addr_t startVa) const
Find the CFG vertex for a basic block placeholder.
size_t nBytes() const
Returns the number of bytes represented by the CFG.
bool basicBlockIsFunctionCall(const BasicBlockPtr &, Precision::Level precision=Precision::HIGH) const
Determine if a basic block looks like a function call.
void attachBasicBlock(const ControlFlowGraph::ConstVertexIterator &placeholder, const BasicBlockPtr &)
Attach a basic block to the CFG/AUM.
InstructionSemantics::BaseSemantics::RiscOperatorsPtr newOperators(SemanticMemoryParadigm) const
Obtain new RiscOperators.
void basicBlockMayReturnReset() const
Clear all may-return properties.
BasicBlockPtr basicBlockExists(rose_addr_t startVa) const
Determines whether a discovered basic block exists in the CFG/AUM.
void discoverFunctionBasicBlocks(const FunctionPtr &function) const
Adds basic blocks to a function.
const CallingConvention::Analysis & functionCallingConvention(const FunctionPtr &) const
Calling convention analysis for one function.
bool usingSymbolicSemantics() const
Use or not use symbolic semantics.
std::vector< FunctionPtr > functionsOwningBasicBlocks(const Container &bblocks) const
Finds functions that own the specified basic block.
bool checkingCallBranch() const
Property: Whether to look for function calls used as branches.
void cfgGraphViz(std::ostream &, const AddressInterval &restrict=AddressInterval::whole(), bool showNeighbors=true) const
Output CFG as GraphViz.
const BasicBlockCallbacks & basicBlockCallbacks() const
Callbacks for adjusting basic block during discovery.
std::vector< SgAsmInstruction * > instructionsSpanning(const AddressInterval &) const
Returns instructions that span an entire address interval.
static std::string functionName(const FunctionPtr &)
Name of a function.
std::vector< FunctionPtr > functionsOwningBasicBlock(const BasicBlockPtr &, bool doSort=true) const
Finds functions that own the specified basic block.
void expandIndeterminateCalls()
Expands indeterminate function calls.
ControlFlowGraph::ConstVertexIterator instructionVertex(rose_addr_t insnVa) const
Returns the CFG vertex containing specified instruction.
void unparse(std::ostream &) const
Unparse some entity.
bool isEdgeIntraProcedural(const ControlFlowGraph::Edge &edge) const
Determine if an edge is intra-procedural.
DataBlockPtr attachDataBlock(const DataBlockPtr &)
Attach a data block to the CFG/AUM.
size_t attachFunctionBasicBlocks(const FunctionPtr &)
Create placeholders for function basic blocks.
void dumpCfg(std::ostream &, const std::string &prefix="", bool showBlocks=true, bool computeProperties=true) const
Output the control flow graph.
InstructionSemantics::BaseSemantics::RiscOperatorsPtr newOperators() const
Obtain new RiscOperators.
void assumeFunctionsReturn(bool)
Property: Assume (or not) that function calls return.
std::set< rose_addr_t > functionGhostSuccessors(const FunctionPtr &) const
Returns ghost successors for a single function.
DataBlockPtr dataBlockExists(const DataBlockPtr &) const
Determine if a data block or its equivalent is attached to the CFG/AUM.
DataBlockPtr attachDataBlockToBasicBlock(const DataBlockPtr &, const BasicBlockPtr &)
Attach a data block to a basic block.
bool basicBlockSemanticsAutoDrop() const
Property: Automatically drop semantics for attached basic blocks.
std::vector< DataBlockPtr > dataBlocksOverlapping(const AddressInterval &) const
Returns data blocks that overlap with specified address interval.
Partitioner(BOOST_RV_REF(Partitioner))
Move constructor.
BasicBlockPtr detachBasicBlock(const BasicBlockPtr &basicBlock)
Detach a basic block from the CFG/AUM.
InstructionSemantics::BaseSemantics::DispatcherPtr newDispatcher(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &) const
Obtain a new instruction semantics dispatcher.
std::vector< BasicBlockPtr > basicBlocksOverlapping(const AddressInterval &) const
Returns basic blocks that overlap with specified address interval.
void attachBasicBlock(const BasicBlockPtr &)
Attach a basic block to the CFG/AUM.
SgAsmInterpretation * interpretation() const
Property: Interpretation corresponding to the memory map.
ControlFlowGraph::VertexIterator insertPlaceholder(rose_addr_t startVa)
Insert a basic-block placeholder.
std::string unparsePlain(SgAsmInstruction *) const
Unparse an instruction in a plain way.
Progress::Ptr progress() const
Property: How to report progress.
void detachFunction(const FunctionPtr &)
Detaches a function from the CFG/AUM.
Sawyer::Optional< rose_addr_t > elfGotVa() const
Returns a previously cached ELF GOT address.
static std::string vertexNameEnd(const ControlFlowGraph::Vertex &)
Name of last instruction in vertex.
void insnUnparser(const Unparser::BasePtr &)
Returns an unparser.
void detachDataBlock(const DataBlockPtr &)
Detaches a data block from the CFG/AUM.
std::string vertexName(const ControlFlowGraph::ConstVertexIterator &) const
Name of a vertex.
void showStatistics() const
Print some partitioner performance statistics.
static Ptr instance(const Architecture::BaseConstPtr &)
Default allocating constructor.
void disableSymbolicSemantics()
Use or not use symbolic semantics.
std::vector< rose_addr_t > basicBlockConcreteSuccessors(const BasicBlockPtr &, bool *isComplete=NULL) const
Determines concrete successors for a basic block.
const AddressUsageMap & aum() const
Returns the address usage map.
std::vector< FunctionPtr > functions() const
All functions attached to the CFG/AUM.
void saveAsRbaFile(const boost::filesystem::path &name, SerialIo::Format fmt) const
Save this partitioner as an RBA file.
BasicBlockPtr erasePlaceholder(const ControlFlowGraph::ConstVertexIterator &placeholder)
Remove a basic block placeholder from the CFG/AUM.
void progress(const Progress::Ptr &)
Property: How to report progress.
std::vector< FunctionPtr > functionsSpanning(const AddressInterval &) const
Returns functions that span an entire address interval.
std::vector< SgAsmInstruction * > instructionsOverlapping(const AddressInterval &) const
Returns instructions that overlap with specified address interval.
void enableSymbolicSemantics(bool=true)
Use or not use symbolic semantics.
const FunctionPrologueMatchers & functionPrologueMatchers() const
Ordered list of function prologue matchers.
size_t nInstructions() const
Returns the number of instructions attached to the CFG/AUM.
void unparser(const Unparser::BasePtr &)
Returns an unparser.
static Ptr instance(const Architecture::BaseConstPtr &, const MemoryMap::Ptr &)
Construct a partitioner.
void autoAddCallReturnEdges(bool)
Property: Insert (or not) function call return edges.
InstructionSemantics::BaseSemantics::SValuePtr basicBlockStackDeltaOut(const BasicBlockPtr &, const FunctionPtr &function) const
Return the stack delta expression.
void clear()
Reset CFG/AUM to initial state.
BasicBlockPtr discoverBasicBlock(const ControlFlowGraph::ConstVertexIterator &placeholder) const
Discover instructions for a detached basic block.
std::vector< FunctionPtr > nextFunctionPrologue(rose_addr_t startVa, rose_addr_t &lastSearchedVa)
Finds the next function by searching for a function prologue.
bool isDefaultConstructed() const
Return true if this is a default constructed partitioner.
void allFunctionMayReturn() const
Compute may-return analysis for all functions.
std::vector< FunctionPrologueMatcherPtr > FunctionPrologueMatchers
See functionPrologueMatchers.
Unparser::BasePtr insnUnparser() const
Returns an unparser.
SmtSolverPtr smtSolver() const
SMT solver.
std::vector< FunctionPtr > functionsOwningBasicBlock(const ControlFlowGraph::Vertex &, bool doSort=true) const
Finds functions that own the specified basic block.
bool isEdgeIntraProcedural(ControlFlowGraph::ConstEdgeIterator edge, const FunctionPtr &) const
Determine if an edge is intra-procedural.
BasicBlockPtr detachBasicBlock(rose_addr_t startVa)
Detach a basic block from the CFG/AUM.
FunctionPtr attachOrMergeFunction(const FunctionPtr &)
Attaches or merges a function into the CFG/AUM.
DataBlockPtr attachDataBlockToFunction(const DataBlockPtr &, const FunctionPtr &)
Attach a data block to an attached or detached function.
size_t attachFunctions(const Functions &)
Attaches a function to the CFG/AUM.
BasicBlockPtr detachBasicBlock(const ControlFlowGraph::ConstVertexIterator &placeholder)
Detach a basic block from the CFG/AUM.
void functionBasicBlockExtent(const FunctionPtr &function, AddressIntervalSet &retval) const
Returns the addresses used by a function.
size_t nBasicBlocks() const
Returns the number of basic blocks attached to the CFG/AUM.
const AddressNameMap & addressNames() const
Property: Name for address.
AddressUser instructionExists(rose_addr_t startVa) const
Determines whether an instruction is attached to the CFG/AUM.
std::string edgeNameDst(const ControlFlowGraph::ConstEdgeIterator &) const
Name of an outgoing edge.
void configureInsnUnparser(const Unparser::BasePtr &) const
Configure the single-instruction unparser.
CallingConvention::Dictionary functionCallingConventionDefinitions(const FunctionPtr &) const
Return list of matching calling conventions.
bool basicBlockPopsStack(const BasicBlockPtr &) const
Determine if the basic block pops at least one byte from the stack.
std::set< rose_addr_t > functionDataFlowConstants(const FunctionPtr &) const
Find constants in function using data-flow.
std::vector< FunctionPtr > functionsOwningBasicBlock(const ControlFlowGraph::ConstVertexIterator &, bool doSort=true) const
Finds functions that own the specified basic block.
void fixInterFunctionEdges()
Adjust inter-function edge types.
void allFunctionIsNoop() const
Analyze all functions for whether they are effectivly no-ops.
std::vector< FunctionPtr > functionsOwningBasicBlock(rose_addr_t bblockVa, bool doSort=true) const
Finds functions that own the specified basic block.
BasicBlockPtr erasePlaceholder(rose_addr_t startVa)
Remove a basic block placeholder from the CFG/AUM.
std::vector< DataBlockPtr > dataBlocks() const
Returns the list of all attached data blocks.
void functionDataBlockExtent(const FunctionPtr &function, AddressIntervalSet &retval) const
Returns the addresses used by a function.
bool isEdgeInterProcedural(ControlFlowGraph::ConstEdgeIterator edge, const FunctionPtr &sourceFunction, const FunctionPtr &targetFunction) const
Determine if an edge is inter-procedural.
const FunctionPaddingMatchers & functionPaddingMatchers() const
Ordered list of function padding matchers.
std::string edgeNameSrc(const ControlFlowGraph::ConstEdgeIterator &) const
Name of an incoming edge.
static std::string vertexName(const ControlFlowGraph::Vertex &)
Name of a vertex.
void semanticMemoryParadigm(SemanticMemoryParadigm)
Property: Whether to use map- or list-based memory states.
BasicBlockCallbacks & basicBlockCallbacks()
Callbacks for adjusting basic block during discovery.
FunctionPtr functionExists(const BasicBlockPtr &entryBlock) const
Determines whether a function exists in the CFG/AUM.
AddressIntervalSet functionDataBlockExtent(const FunctionPtr &function) const
Returns the addresses used by a function.
InstructionProvider & instructionProvider()
Returns the instruction provider.
Sawyer::Callbacks< BasicBlockCallbackPtr > BasicBlockCallbacks
See basicBlockCallbacks.
void sourceLocations(const SourceLocations &)
Property: Source locations.
size_t attachFunction(const FunctionPtr &)
Attaches a function to the CFG/AUM.
void forgetFunctionIsNoop(const FunctionPtr &) const
Clears cached function no-op analysis results.
static std::string edgeName(const ControlFlowGraph::Edge &)
Name of an edge.
static std::string edgeNameDst(const ControlFlowGraph::Edge &)
Name of an outgoing edge.
const CfgAdjustmentCallbacks & cfgAdjustmentCallbacks() const
List of all callbacks invoked when the CFG is adjusted.
void functionExtent(const FunctionPtr &function, AddressIntervalSet &retval) const
Returns the addresses used by a function.
AddressInterval instructionExtent(SgAsmInstruction *) const
Returns the address interval for an instruction.
void basicBlockSemanticsAutoDrop(bool)
Property: Automatically drop semantics for attached basic blocks.
MemoryMap::Ptr memoryMap() const
Returns the memory map.
CrossReferences instructionCrossReferences(const AddressIntervalSet &restriction) const
Cross references.
bool isEdgeInterProcedural(ControlFlowGraph::ConstEdgeIterator edge, const FunctionPtr &sourceFunction) const
Determine if an edge is inter-procedural.
std::vector< FunctionPtr > functionsContainedIn(const AddressInterval &) const
Returns functions that are fully contained in an address interval.
std::vector< FunctionPtr > discoverFunctionEntryVertices() const
Scans the CFG to find function entry basic blocks.
void allFunctionCallingConventionDefinition(const CallingConvention::Definition::Ptr &) const
Analyzes calling conventions and saves results.
SourceLocations & sourceLocations()
Property: Source locations.
bool isEdgeInterProcedural(const ControlFlowGraph::Edge &edge) const
Determine if an edge is inter-procedural.
std::vector< AddressUser > users(rose_addr_t) const
Entities that exist at a particular address.
AddressIntervalSet functionBasicBlockExtent(const FunctionPtr &function) const
Returns the addresses used by a function.
const InstructionProvider & instructionProvider() const
Returns the instruction provider.
FunctionPaddingMatchers & functionPaddingMatchers()
Ordered list of function padding matchers.
Sawyer::Optional< bool > basicBlockOptionalMayReturn(const ControlFlowGraph::ConstVertexIterator &) const
Determine if part of the CFG can pop the top stack frame.
const BasePartitionerSettings & settings() const
Partitioner settings.
static std::string edgeNameSrc(const ControlFlowGraph::Edge &)
Name of an incoming edge.
ControlFlowGraph::ConstVertexIterator undiscoveredVertex() const
Returns the special "undiscovered" vertex.
std::string unparse(SgAsmInstruction *) const
Unparse some entity.
void updateProgress(const std::string &phase, double completion) const
Update partitioner with a new progress report.
CallingConvention::Dictionary functionCallingConventionDefinitions(const FunctionPtr &, const CallingConvention::Definition::Ptr &) const
Return list of matching calling conventions.
void allFunctionCallingConventionDefinition() const
Analyzes calling conventions and saves results.
AddressInterval dataBlockExtent(const DataBlockPtr &) const
Returns the addresses used by a data block.
static PartitionerPtr instanceFromRbaFile(const boost::filesystem::path &, SerialIo::Format=SerialIo::BINARY)
Construct a partitioner by loading it and an AST from a file.
InstructionSemantics::BaseSemantics::SValuePtr basicBlockStackDeltaIn(const BasicBlockPtr &, const FunctionPtr &function) const
Return the stack delta expression.
AddressUser instructionExists(SgAsmInstruction *insn) const
Determines whether an instruction is attached to the CFG/AUM.
Format
Format of the state file.
Bidirectional mapping between addresses and source locations.
API and storage for attributes.
Container associating values with keys.
Holds a value or nothing.
Creates SharedPointer from this.
Base class for reference counted objects.
Reference-counting intrusive smart pointer.
Contiguous region of a file.
Base class for machine instructions.
Represents an interpretation of a binary container.
std::shared_ptr< const Base > BaseConstPtr
Reference counted pointer for Architecture::Base.
std::vector< DefinitionPtr > Dictionary
An ordered collection of calling convention definitions.
boost::shared_ptr< RiscOperators > RiscOperatorsPtr
Shared-ownership pointer to a RISC operators object.
boost::shared_ptr< Dispatcher > DispatcherPtr
Shared-ownership pointer to a semantics instruction dispatcher.
std::vector< BasicBlockSuccessor > BasicBlockSuccessors
All successors in no particular order.
SemanticMemoryParadigm
Organization of semantic memory.
@ LIST_BASED_MEMORY
Precise but slow.
std::shared_ptr< SmtSolver > SmtSolverPtr
Reference counting pointer.
Settings that directly control a partitioner.
Represents information about a thunk.
rose_addr_t target
The one and only successor for the basic block.
BasicBlockPtr bblock
The one and only basic block for the thunk.