Partitioner.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Partitioner_H
#define ROSE_BinaryAnalysis_Partitioner2_Partitioner_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/Partitioner2/AddressUsageMap.h>
#include <Rose/BinaryAnalysis/Partitioner2/Configuration.h>
#include <Rose/BinaryAnalysis/Partitioner2/ControlFlowGraph.h>
#include <Rose/BinaryAnalysis/Partitioner2/IndirectControlFlow.h>
#include <Rose/BinaryAnalysis/Partitioner2/Semantics.h>
 
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionProvider.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h>
#include <Rose/BinaryAnalysis/SerialIo.h>
#include <Rose/BinaryAnalysis/SourceLocations.h>
#include <Rose/BinaryAnalysis/Unparser/Settings.h>
#include <Rose/Progress.h>
 
#include <Sawyer/Attribute.h>
#include <Sawyer/Callbacks.h>
#include <Sawyer/IntervalSet.h>
#include <Sawyer/Map.h>
#include <Sawyer/Message.h>
#include <Sawyer/Optional.h>
#include <Sawyer/ProgressBar.h>
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>
 
#include <boost/filesystem.hpp>
#include <boost/format.hpp>
#include <boost/move/utility_core.hpp>
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
#ifdef ROSE_ENABLE_FLATBUFFERS
#include <Rose/BinaryAnalysis/Serialization/FlatBuffers.h>
#endif
 
#include <ostream>
#include <set>
#include <string>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
class ROSE_DLL_API Partitioner /*final*/
    : public Sawyer::SharedObject, public Sawyer::SharedFromThis<Partitioner>, public Sawyer::Attribute::Storage<> {
    BOOST_MOVABLE_BUT_NOT_COPYABLE(Partitioner)
 
    
    //
    //                                  Types
    //
public:
    using Ptr = PartitionerPtr;
    using ConstPtr = PartitionerConstPtr;
    // Callback list types
    typedef Sawyer::Callbacks<CfgAdjustmentCallback::Ptr> CfgAdjustmentCallbacks; 
    typedef Sawyer::Callbacks<BasicBlockCallbackPtr> BasicBlockCallbacks; 
    typedef std::vector<FunctionPrologueMatcherPtr> FunctionPrologueMatchers; 
    typedef std::vector<FunctionPaddingMatcherPtr> FunctionPaddingMatchers; 
    struct Thunk {
        BasicBlockPtr bblock;                           
        Address target;                                 
        Thunk(const BasicBlockPtr&, Address target);
        ~Thunk();
    };
 
    typedef Sawyer::Container::Map<Address, std::string> AddressNameMap;
 
    //
    //                                  Data members
    //
private:
    friend class Rose::BinaryAnalysis::Serialization::FlatBuffers::Deserializer;
 
    BasePartitionerSettings settings_;                  // settings adjustable from the command-line
    Configuration config_;                              // configuration information about functions, blocks, etc.
    Architecture::BaseConstPtr architecture_;           // architecture information such as the ISA, word size, etc.
    InstructionProvider::Ptr instructionProvider_;      // cache for all disassembled instructions
    MemoryMap::Ptr memoryMap_;                          // description of memory, especially insns and non-writable
    SgAsmInterpretation *interpretation_ = nullptr;     // Interpretation corresponding to the memory map
    ControlFlowGraph cfg_;                              // basic blocks that will become part of the ROSE AST
    CfgVertexIndex vertexIndex_;                        // Vertex-by-address index for the CFG
    AddressUsageMap aum_;                               // How addresses are used for each address represented by the CFG
    SmtSolverPtr solver_;                               // Satisfiable modulo theory solver used by semantic expressions
    Functions functions_;                               // List of all attached functions by entry address
    bool autoAddCallReturnEdges_ = false;               // Add E_CALL_RETURN edges when blocks are attached to CFG?
    bool assumeFunctionsReturn_ = true;                 // Assume that unproven functions return to caller?
    size_t stackDeltaInterproceduralLimit_ = 1;         // Max depth of call stack when computing stack deltas
    AddressNameMap addressNames_;                       // Names for various addresses
    SourceLocations sourceLocations_;                   // Mapping between source locations and addresses
    SemanticMemoryParadigm semanticMemoryParadigm_ = LIST_BASED_MEMORY; // Slow and precise, or fast and imprecise?
    Unparser::BasePtr unparser_;                        // For unparsing things to pseudo-assembly
    Unparser::BasePtr insnUnparser_;                    // For unparsing single instructions in diagnostics
    Unparser::BasePtr insnPlainUnparser_;               // For unparsing just instruction mnemonic and operands
    IndirectControlFlow::State icf_;                    // State for various indirect control flow recovery analyses
 
    // Callback lists
    CfgAdjustmentCallbacks cfgAdjustmentCallbacks_;
    BasicBlockCallbacks basicBlockCallbacks_;
    FunctionPrologueMatchers functionPrologueMatchers_;
    FunctionPaddingMatchers functionPaddingMatchers_;
 
    // Special CFG vertices.
    ControlFlowGraph::VertexIterator undiscoveredVertex_;
    ControlFlowGraph::VertexIterator indeterminateVertex_;
    ControlFlowGraph::VertexIterator nonexistingVertex_;
    static const size_t nSpecialVertices = 3;
 
    // Optional cached information
    Sawyer::Optional<Address> elfGotVa_;                // address of ELF GOT, set by findElfGotVa
 
    // Protects the following data members
    mutable SAWYER_THREAD_TRAITS::Mutex mutex_;
    Progress::Ptr progress_;                            // Progress reporter to update, or null
    mutable size_t cfgProgressTotal_ = 0;               // Expected total for the CFG progress bar; initialized at first report
 
    //
    //                                  Serialization
    //
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class Archive> void serializeCommon(Archive&, unsigned);
    template<class Archive> void save(Archive&, unsigned) const;
    template<class Archive> void load(Archive&, unsigned);
    BOOST_SERIALIZATION_SPLIT_MEMBER();
#endif
 
#ifdef ROSE_ENABLE_FLATBUFFERS
private:
    friend class Rose::BinaryAnalysis::Serialization::FlatBuffers::Deserializer;
#endif
 
    //
    //                                  Constructors
    //
private:
    Partitioner();                                      // needed for Boost serialization
 
    // Partitioner objects are reference counted and always allocated on the heap. Use the `instance` methods to construct
    // these objects.  Also, since the Partitioner class is final, we make the constructors private instead of the usual
    // protected constructors elsewhere in ROSE.
    Partitioner(const Architecture::BaseConstPtr&);
    Partitioner(const Architecture::BaseConstPtr&, const MemoryMap::Ptr&);
public:
    ~Partitioner();
 
public:
    static Ptr instance(const Architecture::BaseConstPtr&);
 
    static Ptr instance(const Architecture::BaseConstPtr&, const MemoryMap::Ptr&);
 
    static PartitionerPtr instanceFromRbaFile(const boost::filesystem::path&, Serialization::Format = Serialization::BINARY);
 
    void saveAsRbaFile(const boost::filesystem::path &name, Serialization::Format fmt) const;
 
    Partitioner(BOOST_RV_REF(Partitioner));
 
    Partitioner& operator=(BOOST_RV_REF(Partitioner));
 
    bool isDefaultConstructed() const;
 
    void clear();
 
    Configuration& configuration();
    const Configuration& configuration() const;
    Architecture::BaseConstPtr architecture() const;
 
    InstructionProvider& instructionProvider();
    const InstructionProvider& instructionProvider() const;
    MemoryMap::Ptr memoryMap() const;
 
    SgAsmInterpretation *interpretation() const;
    void interpretation(SgAsmInterpretation*);
    bool addressIsExecutable(Address) const;
 
 
    //
    //                                  Unparsing
    //
public:
    Unparser::BasePtr unparser() const;
    void unparser(const Unparser::BasePtr&);
    Unparser::BasePtr insnUnparser() const;
    void insnUnparser(const Unparser::BasePtr&);
    void configureInsnUnparser(const Unparser::BasePtr&) const;
 
    void configureInsnPlainUnparser(const Unparser::BasePtr&) const;
 
    std::string unparse(SgAsmInstruction*) const;
    void unparse(std::ostream&, SgAsmInstruction*) const;
    void unparse(std::ostream&, const BasicBlockPtr&) const;
    void unparse(std::ostream&, const DataBlockPtr&) const;
    void unparse(std::ostream&, const FunctionPtr&) const;
    void unparse(std::ostream&) const;
    std::string unparsePlain(SgAsmInstruction*) const;
 
    //
    //                                  Partitioner CFG queries
    //
public:
    size_t nBytes() const;
 
    ControlFlowGraph::VertexIterator undiscoveredVertex();
    ControlFlowGraph::ConstVertexIterator undiscoveredVertex() const;
    ControlFlowGraph::VertexIterator indeterminateVertex();
    ControlFlowGraph::ConstVertexIterator indeterminateVertex() const;
    ControlFlowGraph::VertexIterator nonexistingVertex();
    ControlFlowGraph::ConstVertexIterator nonexistingVertex() const;
    const ControlFlowGraph& cfg() const;
 
    const AddressUsageMap& aum() const;
 
    AddressUsageMap aum(const FunctionPtr&) const;
 
    std::vector<AddressUser> users(Address) const;
 
    std::set<Address> ghostSuccessors() const;
 
    bool isEdgeIntraProcedural(ControlFlowGraph::ConstEdgeIterator edge, const FunctionPtr&) const;
    bool isEdgeIntraProcedural(const ControlFlowGraph::Edge &edge, const FunctionPtr&) const;
    bool isEdgeIntraProcedural(ControlFlowGraph::ConstEdgeIterator edge) const;
    bool isEdgeIntraProcedural(const ControlFlowGraph::Edge &edge) const;
    bool isEdgeInterProcedural(ControlFlowGraph::ConstEdgeIterator edge) const;
    bool isEdgeInterProcedural(ControlFlowGraph::ConstEdgeIterator edge, const FunctionPtr &sourceFunction) const;
    bool isEdgeInterProcedural(ControlFlowGraph::ConstEdgeIterator edge, const FunctionPtr &sourceFunction,
                               const FunctionPtr &targetFunction) const;
 
    bool isEdgeInterProcedural(const ControlFlowGraph::Edge &edge) const;
    bool isEdgeInterProcedural(const ControlFlowGraph::Edge &edge, const FunctionPtr &sourceFunction) const;
    bool isEdgeInterProcedural(const ControlFlowGraph::Edge &edge, const FunctionPtr &sourceFunction,
                               const FunctionPtr &targetFunction) const;
    //
    //                                  Partitioner instruction operations
    //
public:
    size_t nInstructions() const;
 
    AddressUser instructionExists(Address startVa) const;
    AddressUser instructionExists(SgAsmInstruction *insn) const;
    ControlFlowGraph::ConstVertexIterator instructionVertex(Address insnVa) const;
 
    std::vector<SgAsmInstruction*> instructionsOverlapping(const AddressInterval&) const;
 
    std::vector<SgAsmInstruction*> instructionsSpanning(const AddressInterval&) const;
 
    std::vector<SgAsmInstruction*> instructionsContainedIn(const AddressInterval&) const;
 
    AddressInterval instructionExtent(SgAsmInstruction*) const;
 
    SgAsmInstruction* discoverInstruction(Address startVa) const;
 
    CrossReferences instructionCrossReferences(const AddressIntervalSet &restriction) const;
 
 
 
    //
    //                                  Partitioner basic block placeholder operations
    //
public:
     size_t nPlaceholders() const;
 
    bool placeholderExists(Address startVa) const;
 
    ControlFlowGraph::VertexIterator findPlaceholder(Address startVa);
    ControlFlowGraph::ConstVertexIterator findPlaceholder(Address startVa) const;
    ControlFlowGraph::VertexIterator insertPlaceholder(Address startVa);
 
    BasicBlockPtr erasePlaceholder(const ControlFlowGraph::ConstVertexIterator &placeholder) /*final*/;
    BasicBlockPtr erasePlaceholder(Address startVa) /*final*/;
    //
    //                                  Partitioner basic block operations
    //
public:
    bool basicBlockSemanticsAutoDrop() const;
    void basicBlockSemanticsAutoDrop(bool);
    void basicBlockDropSemantics() const;
 
    size_t nBasicBlocks() const;
 
    std::vector<BasicBlockPtr> basicBlocks() const;
 
    BasicBlockPtr basicBlockExists(Address startVa) const;
    BasicBlockPtr basicBlockExists(const BasicBlockPtr&) const;
    std::vector<BasicBlockPtr> basicBlocksOverlapping(const AddressInterval&) const;
 
    std::vector<BasicBlockPtr> basicBlocksSpanning(const AddressInterval&) const;
 
    std::vector<BasicBlockPtr> basicBlocksContainedIn(const AddressInterval&) const;
 
    BasicBlockPtr basicBlockContainingInstruction(Address insnVa) const;
 
    AddressIntervalSet basicBlockInstructionExtent(const BasicBlockPtr&) const;
 
    AddressIntervalSet basicBlockDataExtent(const BasicBlockPtr&) const;
 
    BasicBlockPtr detachBasicBlock(Address startVa);
    BasicBlockPtr detachBasicBlock(const BasicBlockPtr &basicBlock);
    BasicBlockPtr detachBasicBlock(const ControlFlowGraph::ConstVertexIterator &placeholder);
    ControlFlowGraph::VertexIterator truncateBasicBlock(const ControlFlowGraph::ConstVertexIterator &basicBlock,
                                                        SgAsmInstruction *insn);
 
    void attachBasicBlock(const BasicBlockPtr&);
    void attachBasicBlock(const ControlFlowGraph::ConstVertexIterator &placeholder, const BasicBlockPtr&);
    BasicBlockPtr discoverBasicBlock(Address startVa) const;
    BasicBlockPtr discoverBasicBlock(const ControlFlowGraph::ConstVertexIterator &placeholder) const;
    BasicBlockSuccessors basicBlockSuccessors(const BasicBlockPtr&, Precision::Level precision = Precision::HIGH) const;
 
    std::vector<Address> basicBlockConcreteSuccessors(const BasicBlockPtr&, bool *isComplete=NULL) const;
 
    std::set<Address> basicBlockGhostSuccessors(const BasicBlockPtr&) const;
 
    bool basicBlockIsFunctionCall(const BasicBlockPtr&, Precision::Level precision = Precision::HIGH) const;
 
    bool basicBlockIsFunctionReturn(const BasicBlockPtr&) const;
 
     bool basicBlockPopsStack(const BasicBlockPtr&) const;
 
    InstructionSemantics::BaseSemantics::SValuePtr
    basicBlockStackDeltaIn(const BasicBlockPtr&, const FunctionPtr &function) const;
 
    InstructionSemantics::BaseSemantics::SValuePtr
    basicBlockStackDeltaOut(const BasicBlockPtr&, const FunctionPtr &function) const;
    void forgetStackDeltas() const;
    void forgetStackDeltas(const FunctionPtr&) const;
    size_t stackDeltaInterproceduralLimit() const;
    void stackDeltaInterproceduralLimit(size_t);
    Sawyer::Optional<bool> basicBlockOptionalMayReturn(const BasicBlockPtr&) const;
    Sawyer::Optional<bool> basicBlockOptionalMayReturn(const ControlFlowGraph::ConstVertexIterator&) const;
    void basicBlockMayReturnReset() const;
 
private:
    // Per-vertex data used during may-return analysis
    struct MayReturnVertexInfo {
        enum State {INIT, CALCULATING, FINISHED};
        State state;                                        // current state of vertex
        bool processedCallees;                              // have we processed BBs this vertex calls?
        boost::logic::tribool anyCalleesReturn;             // do any of those called BBs have a true may-return value?
        boost::logic::tribool result;                       // final result (eventually cached in BB)
        MayReturnVertexInfo(): state(INIT), processedCallees(false), anyCalleesReturn(false), result(boost::indeterminate) {}
    };
 
    // Is edge significant for analysis? See .C file for full documentation.
    bool mayReturnIsSignificantEdge(const ControlFlowGraph::ConstEdgeIterator &edge,
                                    std::vector<MayReturnVertexInfo> &vertexInfo) const;
 
    // Determine (and cache in vertexInfo) whether any callees return.
    boost::logic::tribool mayReturnDoesCalleeReturn(const ControlFlowGraph::ConstVertexIterator &vertex,
                                                    std::vector<MayReturnVertexInfo> &vertexInfo) const;
 
    // Maximum may-return result from significant successors including phantom call-return edge.
    boost::logic::tribool mayReturnDoesSuccessorReturn(const ControlFlowGraph::ConstVertexIterator &vertex,
                                                       std::vector<MayReturnVertexInfo> &vertexInfo) const;
 
    // The guts of the may-return analysis
    Sawyer::Optional<bool> basicBlockOptionalMayReturn(const ControlFlowGraph::ConstVertexIterator &start,
                                                       std::vector<MayReturnVertexInfo> &vertexInfo) const;
 
 
 
    //
    //                                  Partitioner data block operations
    //
public:
    size_t nDataBlocks() const;
 
    DataBlockPtr dataBlockExists(const DataBlockPtr&) const;
 
    DataBlockPtr findBestDataBlock(const AddressInterval&) const;
 
    DataBlockPtr attachDataBlock(const DataBlockPtr&);
 
    void detachDataBlock(const DataBlockPtr&);
 
    DataBlockPtr attachDataBlockToFunction(const DataBlockPtr&, const FunctionPtr&);
 
    DataBlockPtr attachDataBlockToBasicBlock(const DataBlockPtr&, const BasicBlockPtr&);
 
    std::vector<DataBlockPtr> dataBlocksOverlapping(const AddressInterval&) const;
 
    std::vector<DataBlockPtr> dataBlocksSpanning(const AddressInterval&) const;
 
    std::vector<DataBlockPtr> dataBlocksContainedIn(const AddressInterval&) const;
 
    AddressInterval dataBlockExtent(const DataBlockPtr&) const;
 
    std::vector<DataBlockPtr> dataBlocks() const;
 
 
 
    //
    //                                  Partitioner function operations
    //
public:
    size_t nFunctions() const;
 
    FunctionPtr functionExists(Address entryVa) const;
    FunctionPtr functionExists(const BasicBlockPtr &entryBlock) const;
    FunctionPtr functionExists(const FunctionPtr &function) const;
    std::vector<FunctionPtr> functions() const;
 
    std::vector<FunctionPtr> functionsOverlapping(const AddressInterval&) const;
 
    std::vector<FunctionPtr> functionsSpanning(const AddressInterval&) const;
 
    std::vector<FunctionPtr> functionsContainedIn(const AddressInterval&) const;
 
    AddressIntervalSet functionExtent(const FunctionPtr&) const;
    void functionExtent(const FunctionPtr &function, AddressIntervalSet &retval /*in,out*/) const;
    AddressIntervalSet functionBasicBlockExtent(const FunctionPtr &function) const;
    void functionBasicBlockExtent(const FunctionPtr &function, AddressIntervalSet &retval /*in,out*/) const;
    AddressIntervalSet functionDataBlockExtent(const FunctionPtr &function) const;
    void functionDataBlockExtent(const FunctionPtr &function, AddressIntervalSet &retval /*in,out*/) const;
    size_t attachFunction(const FunctionPtr&);
    size_t attachFunctions(const Functions&);
    FunctionPtr attachOrMergeFunction(const FunctionPtr&);
 
    size_t attachFunctionBasicBlocks(const Functions&);
    size_t attachFunctionBasicBlocks(const FunctionPtr&);
    void detachFunction(const FunctionPtr&);
 
    std::vector<Function::Ptr> entryFunctions();
 
    std::vector<FunctionPtr>
    functionsOwningBasicBlock(const ControlFlowGraph::Vertex&, bool doSort = true) const;
 
    std::vector<FunctionPtr>
    functionsOwningBasicBlock(const ControlFlowGraph::ConstVertexIterator&, bool doSort = true) const;
 
    std::vector<FunctionPtr>
    functionsOwningBasicBlock(Address bblockVa, bool doSort = true) const;
 
    std::vector<FunctionPtr>
    functionsOwningBasicBlock(const BasicBlockPtr&, bool doSort = true) const;
 
    template<class Container> // container can hold any type accepted by functionsOwningBasicBlock
    std::vector<FunctionPtr>
    functionsOwningBasicBlocks(const Container &bblocks) const {
        std::vector<FunctionPtr> retval;
        for (const typename Container::value_type& bblock: bblocks) {
            for (const FunctionPtr &function: functionsOwningBasicBlock(bblock, false))
                insertUnique(retval, function, sortFunctionsByAddress);
        }
        return retval;
    }
    std::vector<FunctionPtr> discoverCalledFunctions() const;
 
    std::vector<FunctionPtr> discoverFunctionEntryVertices() const;
 
    Sawyer::Optional<Thunk> functionIsThunk(const FunctionPtr&) const;
 
    void discoverFunctionBasicBlocks(const FunctionPtr &function) const;
 
    std::set<Address> functionGhostSuccessors(const FunctionPtr&) const;
 
    FunctionCallGraph functionCallGraph(AllowParallelEdges::Type allowParallelEdges) const;
 
    InstructionSemantics::BaseSemantics::SValuePtr functionStackDelta(const FunctionPtr &function) const;
 
    void allFunctionStackDelta() const;
 
    Sawyer::Optional<bool> functionOptionalMayReturn(const FunctionPtr &function) const;
 
    void allFunctionMayReturn() const;
 
    const CallingConvention::Analysis& functionCallingConvention(const FunctionPtr&) const;
    const CallingConvention::Analysis& functionCallingConvention(const FunctionPtr&,
                                                                 const CallingConvention::Definition::Ptr &dflt) const;
    void allFunctionCallingConvention() const;
    void allFunctionCallingConvention(const CallingConvention::Definition::Ptr &dflt) const;
 
    CallingConvention::Dictionary functionCallingConventionDefinitions(const FunctionPtr&) const;
    CallingConvention::Dictionary functionCallingConventionDefinitions(const FunctionPtr&,
                                                                       const CallingConvention::Definition::Ptr&) const;
    void allFunctionCallingConventionDefinition() const;
    void allFunctionCallingConventionDefinition(const CallingConvention::Definition::Ptr&) const;
    void fixInterFunctionEdges();
    void fixInterFunctionEdge(const ControlFlowGraph::ConstEdgeIterator&);
    bool functionIsNoop(const FunctionPtr&) const;
 
    void allFunctionIsNoop() const;
 
    void forgetFunctionIsNoop() const;
    void forgetFunctionIsNoop(const FunctionPtr&) const;
    std::set<Address> functionDataFlowConstants(const FunctionPtr&) const;
 
 
 
    //
    //                                  Callbacks
    //
public:
    CfgAdjustmentCallbacks& cfgAdjustmentCallbacks();
    const CfgAdjustmentCallbacks& cfgAdjustmentCallbacks() const;
    BasicBlockCallbacks& basicBlockCallbacks();
    const BasicBlockCallbacks& basicBlockCallbacks() const;
public:
    FunctionPrologueMatchers& functionPrologueMatchers();
    const FunctionPrologueMatchers& functionPrologueMatchers() const;
    std::vector<FunctionPtr> nextFunctionPrologue(Address startVa);
    std::vector<FunctionPtr> nextFunctionPrologue(Address startVa, Address &lastSearchedVa /*out*/);
public:
    FunctionPaddingMatchers& functionPaddingMatchers();
    const FunctionPaddingMatchers& functionPaddingMatchers() const;
    DataBlockPtr matchFunctionPadding(const FunctionPtr&);
 
 
 
    //
    //                                  Partitioner miscellaneous
    //
public:
    void dumpCfg(std::ostream&, const std::string &prefix="", bool showBlocks=true, bool computeProperties=true) const;
 
    void cfgGraphViz(std::ostream&, const AddressInterval &restrict = AddressInterval::whole(), bool showNeighbors=true) const;
 
    static std::string vertexName(const ControlFlowGraph::Vertex&);
    std::string vertexName(const ControlFlowGraph::ConstVertexIterator&) const;
    static std::string vertexNameEnd(const ControlFlowGraph::Vertex&);
 
    static std::string edgeNameSrc(const ControlFlowGraph::Edge&);
    std::string edgeNameSrc(const ControlFlowGraph::ConstEdgeIterator&) const;
    static std::string edgeNameDst(const ControlFlowGraph::Edge&);
    std::string edgeNameDst(const ControlFlowGraph::ConstEdgeIterator&) const;
    static std::string edgeName(const ControlFlowGraph::Edge&);
    std::string edgeName(const ControlFlowGraph::ConstEdgeIterator&) const;
    static std::string basicBlockName(const BasicBlockPtr&);
 
    static std::string dataBlockName(const DataBlockPtr&);
 
    static std::string functionName(const FunctionPtr&);
 
    void expandIndeterminateCalls();
 
    Progress::Ptr progress() const;
    void progress(const Progress::Ptr&);
    void updateProgress(const std::string &phase, double completion) const;
 
    void showStatistics() const;
 
    // Checks consistency of internal data structures when debugging is enable (when NDEBUG is not defined).
    void checkConsistency() const;
 
    SgAsmGenericSection* elfGot(SgAsmElfFileHeader*);
 
    Sawyer::Optional<Address> elfGotVa() const;
 
    const IndirectControlFlow::State& icf() const;
    IndirectControlFlow::State& icf();
    //
    //                                  Settings
    //
public:
 
    const BasePartitionerSettings& settings() const;
    void settings(const BasePartitionerSettings&);
    void enableSymbolicSemantics(bool = true);
    void disableSymbolicSemantics();
    bool usingSymbolicSemantics() const;
    void autoAddCallReturnEdges(bool);
    bool autoAddCallReturnEdges() const;
    void assumeFunctionsReturn(bool);
    bool assumeFunctionsReturn() const;
    void addressName(Address, const std::string&);
    const std::string& addressName(Address) const;
    const AddressNameMap& addressNames() const;
    const SourceLocations& sourceLocations() const;
    SourceLocations& sourceLocations();
    void sourceLocations(const SourceLocations&);
    bool checkingCallBranch() const;
    void checkingCallBranch(bool);
    //
    //                                  Instruction semantics
    //
public:
    SemanticMemoryParadigm semanticMemoryParadigm() const;
    void semanticMemoryParadigm(SemanticMemoryParadigm);
    SmtSolverPtr smtSolver() const;
 
    InstructionSemantics::BaseSemantics::RiscOperatorsPtr newOperators() const;
    InstructionSemantics::BaseSemantics::RiscOperatorsPtr newOperators(SemanticMemoryParadigm) const;
    InstructionSemantics::BaseSemantics::DispatcherPtr
    newDispatcher(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) const;
 
 
 
    //
    //                                  Python API support functions
    //
#ifdef ROSE_ENABLE_PYTHON_API
    void pythonUnparse() const;
#endif
 
 
 
    //
    //                                  Partitioner internal utilities
    //
private:
    void init(const MemoryMap::Ptr&);
    void init(const Partitioner&);
    void updateCfgProgress();
 
private:
    // Convert a CFG vertex iterator from one partitioner to another.  This is called during copy construction when the source
    // and destination CFGs are identical.
    ControlFlowGraph::VertexIterator convertFrom(const Partitioner &other,
                                                 ControlFlowGraph::ConstVertexIterator otherIter);
 
    // Adjusts edges for a placeholder vertex. This method erases all outgoing edges for the specified placeholder vertex and
    // then inserts a single edge from the placeholder to the special "undiscovered" vertex. */
    ControlFlowGraph::EdgeIterator adjustPlaceholderEdges(const ControlFlowGraph::VertexIterator &placeholder);
 
    // Adjusts edges for a non-existing basic block.  This method erases all outgoing edges for the specified vertex and
    // then inserts a single edge from the vertex to the special "non-existing" vertex. */
    ControlFlowGraph::EdgeIterator adjustNonexistingEdges(const ControlFlowGraph::VertexIterator &vertex);
 
    // Implementation for the discoverBasicBlock methods.  The startVa must not be the address of an existing placeholder.
    BasicBlockPtr discoverBasicBlockInternal(Address startVa) const;
 
    // This method is called whenever a new placeholder is inserted into the CFG or a new basic block is attached to the
    // CFG/AUM. The call happens immediately after the CFG/AUM are updated.
    void bblockAttached(const ControlFlowGraph::VertexIterator &newVertex);
 
    // This method is called whenever a basic block is detached from the CFG/AUM or when a placeholder is erased from the CFG.
    // The call happens immediately after the CFG/AUM are updated.
    void bblockDetached(Address startVa, const BasicBlockPtr &removedBlock);
 
    // Rebuild the vertexIndex_ and other cache-like data members from the control flow graph
    void rebuildVertexIndices();
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif