Unparser/Base.h

#ifndef ROSE_BinaryAnalysis_Unparser_Base_H
#define ROSE_BinaryAnalysis_Unparser_Base_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/ControlFlowGraph.h>
#include <Rose/BinaryAnalysis/Partitioner2/FunctionCallGraph.h>
#include <Rose/BinaryAnalysis/Reachability.h>
#include <Rose/BinaryAnalysis/RegisterNames.h>
#include <Rose/BinaryAnalysis/Unparser/EdgeArrows.h>
#include <Rose/BinaryAnalysis/Unparser/Settings.h>
#include <Rose/BitFlags.h>
#include <Rose/Progress.h>
 
#include <Sawyer/Map.h>
#include <Sawyer/Message.h>
#include <Sawyer/SharedObject.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Unparser {
 
typedef std::map<uint64_t, std::string> LabelMap;
 
extern Sawyer::Message::Facility mlog;
 
// used internally to initialize mlog
void initDiagnostics();
 
// Supporting functions
 
std::string invalidRegister(SgAsmInstruction*, RegisterDescriptor, const RegisterDictionaryPtr&)
    ROSE_DEPRECATED("not called by anything");
 
// Margins containing arrows
 
class ArrowMargin {
public:
 
    // An arrow endpoint from the assembly listing's perspective is either a line describing the source or target of a CFG edge, or
    // a line corresponding to the first or last instruction from a CFG basic block vertex.
    class CfgEndpoint {
    public:
        enum class End {Source, Target};
        enum class Type {CfgEdge, CfgVertex};
        End end;                                        // which end of the arrow is this?
        Type type;                                      // is this endpoint at a CFG edge output line, or an instruction?
        size_t cfgId;                                   // an CFG edge ID or a CFG vertex ID, depending on type
    public:
        CfgEndpoint() = delete;
        CfgEndpoint(const End end, const Type type, const size_t cfgId)
            : end(end), type(type), cfgId(cfgId) {}
        bool operator<(const CfgEndpoint&) const;
    };
    class CfgEndpoint {…};
 
private:
    CfgEndpoint::Type srcType_;                                
    CfgEndpoint::Type tgtType_;                                
    std::map<CfgEndpoint, EdgeArrows::EndpointId> cfgToArrow_; 
    std::vector<EdgeArrows::EndpointId> orderedEndpoints_;     
    EdgeArrows::Graph arrowGraph_;                             
    EdgeArrows arrows_;                                        
    Sawyer::Optional<EdgeArrows::EndpointId> atEndpoint_;      
    Sawyer::Optional<EdgeArrows::EndpointId> latestEndpoint_;  
    EdgeArrows::OutputPart nextPart_;                          
public:
    ~ArrowMargin();
    ArrowMargin() = delete;
    ArrowMargin(const ArrowMargin&) = delete;
    ArrowMargin& operator=(const ArrowMargin&) = delete;
    ArrowMargin(CfgEndpoint::Type srcEndpointType, CfgEndpoint::Type dstEndpointType);
 
    void arrowStyle(EdgeArrows::ArrowStylePreset, EdgeArrows::ArrowSide);
 
    void reset();
 
    CfgEndpoint makeCfgEndpoint(CfgEndpoint::End, const Partitioner2::ControlFlowGraph::Edge&);
    EdgeArrows::EndpointId getEndpoint(CfgEndpoint::End, const Partitioner2::ControlFlowGraph::Edge&);
    void maybeInsertArrow(EdgeArrows::EndpointId src, EdgeArrows::EndpointId tgt, size_t arrowId);
 
    void maybeInsertEndpoint(EdgeArrows::EndpointId);
 
    bool haveEndpointId(EdgeArrows::EndpointId) const;
 
    Sawyer::Optional<EdgeArrows::EndpointId> findEndpoint(CfgEndpoint::End, const Partitioner2::ControlFlowGraph::Edge&) const;
    Sawyer::Optional<EdgeArrows::EndpointId> findEndpoint(CfgEndpoint::End, const Partitioner2::ControlFlowGraph::Vertex&) const;
    CfgEndpoint::End whichEnd(EdgeArrows::EndpointId) const;
 
    void computeLayout();
 
    void atPossibleEndpoint(CfgEndpoint::End, const Partitioner2::ControlFlowGraph::Edge&);
    void atPossibleEndpoint(CfgEndpoint::End, const Partitioner2::ControlFlowGraph::Vertex&);
    std::string render();
 
    void debug(std::ostream&, const Partitioner2::PartitionerConstPtr&) const;
};
class ArrowMargin {…};
 
// Output style
 
class StyleStack {
    std::vector<Style> stack_;
    Style current_;
    Color::Colorization colorization_;
 
public:
    StyleStack() {}
 
    Color::Colorization colorization() const { return colorization_; }
    void colorization(const Color::Colorization c) { colorization_ = c; }
    size_t push(const Style&);
 
    void pop();
 
    void popTo(size_t);
 
    void reset();
 
    size_t size() const;
 
    const Style& current() const;
 
private:
    void merge(const Style &style);                     // merge style into current_
    void mergeAll();                                    // recalculate current_ based on stack_
};
class StyleStack {…};
 
class StyleGuard {
    StyleStack &stack_;
    size_t n_;
    Style current_;
    Style previous_;
public:
    StyleGuard(StyleStack &stack, const Style &style)
        : stack_(stack) {
        previous_ = stack_.current();
        n_ = stack_.push(style);
        current_ = stack_.current();
    }
    StyleGuard(StyleStack &stack, const Style &style) {…}
 
    StyleGuard(StyleStack &stack, const Style &first, const Style &second)
        : stack_(stack) {
        previous_ = stack_.current();
        n_ = stack_.push(first);
        stack_.push(second);
        current_ = stack_.current();
    }
 
    ~StyleGuard() {
        stack_.popTo(n_);
    }
 
    std::string render() const;
 
    std::string restore() const;
 
    const Style& current() const {
        return current_;
    }
    const Style& current() const  {…}
 
    const Style& previous() const {
        return previous_;
    }
    const Style& previous() const  {…}
};
class StyleGuard {…};
 
// State of the unparser (the unparser itself is const during unparsing)
 
class State {
public:
    typedef Sawyer::Container::Map<Address, std::string> AddrString; 
private:
    Partitioner2::PartitionerConstPtr partitioner_;
    Partitioner2::FunctionCallGraph cg_;
    Partitioner2::FunctionPtr currentFunction_;
    Partitioner2::BasicBlockPtr previousBasicBlock_, currentBasicBlock_, nextBasicBlock_;
    SgAsmExpression *currentExpression_;
    std::string nextInsnLabel_;
    AddrString basicBlockLabels_;
    RegisterNames registerNames_;
    const Base &frontUnparser_;
    std::vector<Reachability::ReasonFlags> cfgVertexReachability_;
    Sawyer::Container::Map<Reachability::ReasonFlags::Vector, std::string> reachabilityNames_; // map reachability value to name
    ArrowMargin intraFunctionCfgArrows_;                              // arrows for the intra-function control flow graphs
    ArrowMargin intraFunctionBlockArrows_;                            // user-defined intra-function arrows to/from blocks
    ArrowMargin globalBlockArrows_;                                   // user-defined global arrows to/from blocks
    StyleStack styleStack_;                                           // styles
    bool isPostInstruction_ = false;                                  // show extra information appearing after an instruction
 
public:
    State(const Partitioner2::PartitionerConstPtr&, const Architecture::BaseConstPtr&, const Settings&, const Base &frontUnparser);
    virtual ~State();
 
    Partitioner2::PartitionerConstPtr partitioner() const;
 
    const Partitioner2::FunctionCallGraph& cg() const;
 
    const std::vector<Reachability::ReasonFlags> cfgVertexReachability() const;
    void cfgVertexReachability(const std::vector<Reachability::ReasonFlags>&);
    Reachability::ReasonFlags isCfgVertexReachable(size_t vertexId) const;
 
    const ArrowMargin& intraFunctionCfgArrows() const { return intraFunctionCfgArrows_; }
    ArrowMargin& intraFunctionCfgArrows() { return intraFunctionCfgArrows_; }
    const ArrowMargin& intraFunctionBlockArrows() const { return intraFunctionBlockArrows_; }
    ArrowMargin& intraFunctionBlockArrows() { return intraFunctionBlockArrows_; }
    const ArrowMargin& globalBlockArrows() const { return globalBlockArrows_; }
    ArrowMargin& globalBlockArrows() { return globalBlockArrows_; }
    void thisIsBasicBlockFirstInstruction();
 
    void thisIsBasicBlockLastInstruction();
 
    const StyleStack& styleStack() const { return styleStack_; }
    StyleStack& styleStack() { return styleStack_; }
    void reachabilityName(Reachability::Reason value, const std::string &name);
    std::string reachabilityName(Reachability::ReasonFlags value) const;
    Partitioner2::FunctionPtr currentFunction() const;
    void currentFunction(const Partitioner2::FunctionPtr&);
 
    Partitioner2::BasicBlockPtr currentBasicBlock() const;
    void currentBasicBlock(const Partitioner2::BasicBlockPtr&);
    Partitioner2::BasicBlockPtr previousBasicBlock() const;
    void previousBasicBlock(const Partitioner2::BasicBlockPtr&);
    Partitioner2::BasicBlockPtr nextBasicBlock() const;
    void nextBasicBlock(const Partitioner2::BasicBlockPtr&);
    void rotateBasicBlocks(const Partitioner2::BasicBlockPtr &current, const Partitioner2::BasicBlockPtr &next);
 
    SgAsmExpression* currentExpression() const;
    void currentExpression(SgAsmExpression*);
 
    const std::string& nextInsnLabel() const;
    void nextInsnLabel(const std::string&);
 
    const RegisterNames& registerNames() const;
    void registerNames(const RegisterNames &r);
 
    const AddrString& basicBlockLabels() const;
    AddrString& basicBlockLabels();
 
    bool isPostInstruction() const;
    void isPostInstruction(bool);
 
    const Base& frontUnparser() const;
};
class State {…};
 
// Base unparser
 
class Base: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<Base> Ptr;
 
private:
    Architecture::BaseConstPtr architecture_;           // non-null architecture
    Ptr nextUnparser_;
 
protected:
    explicit Base(const Architecture::BaseConstPtr&);
    explicit Base(const Ptr &nextUnparser);
 
public:
    virtual Ptr copy() const = 0;
    virtual ~Base();
 
    virtual const Settings& settings() const = 0;
    virtual Settings& settings() = 0;
    void settings(const Settings &s) {
        settings() = s;
    }
    void settings(const Settings &s) {…}
    Ptr nextUnparser() const { return nextUnparser_; }
    void nextUnparser(Ptr next) { nextUnparser_ = next; }
    Architecture::BaseConstPtr architecture() const;
 
    void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&) const /*final*/;
    void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
    void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, SgAsmExpression*) const /*final*/;
    void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
    void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
    void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
    void operator()(std::ostream&, SgAsmInstruction*) const /*final*/;
    std::string operator()(const Partitioner2::PartitionerConstPtr&, const Progress::Ptr& = Progress::Ptr()) const /*final*/;
    std::string operator()(const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
    std::string operator()(const Partitioner2::PartitionerConstPtr&, SgAsmExpression*) const /*final*/;
    std::string operator()(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
    std::string operator()(const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
    std::string operator()(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
    std::string operator()(SgAsmInstruction*) const /*final*/;
public:
    void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Progress::Ptr& = Progress::Ptr()) const /*final*/;
    void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
    void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, SgAsmExpression*) const /*final*/;
    void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
    void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
    void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
    void unparse(std::ostream&, SgAsmInstruction*) const /*final*/;
    void unparse(std::ostream&, SgAsmExpression*) const /*final*/;
 
    std::string unparse(const Partitioner2::PartitionerConstPtr&, const Progress::Ptr& = Progress::Ptr()) const /*final*/;
    std::string unparse(const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
    std::string unparse(const Partitioner2::PartitionerConstPtr&, SgAsmExpression*) const /*final*/;
    std::string unparse(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
    std::string unparse(const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
    std::string unparse(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
    std::string unparse(SgAsmInstruction*) const /*final*/;
    std::string unparse(SgAsmExpression*) const /*final*/;
public:
    virtual void emitFunction(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionPrologue(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionBody(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionEpilogue(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
 
    virtual void emitFunctionSourceLocation(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionReasons(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionCallers(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionCallees(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionComment(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionStackDelta(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionCallingConvention(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionNoopAnalysis(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
    virtual void emitFunctionMayReturn(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
 
    virtual void emitDataBlockSourceLocation(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
    virtual void emitDataBlock(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
    virtual void emitDataBlockPrologue(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
    virtual void emitDataBlockBody(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
    virtual void emitDataBlockEpilogue(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
 
    virtual void emitBasicBlock(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockPrologue(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockBody(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockEpilogue(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockSeparator(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
 
    virtual void emitBasicBlockSourceLocation(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockComment(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockSharing(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockPredecessors(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockSuccessors(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
    virtual void emitBasicBlockReachability(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
 
    virtual void emitInstruction(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionPrologue(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionBody(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionEpilogue(std::ostream&, SgAsmInstruction*, State&) const;
 
    virtual void emitInstructionAddress(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionBytes(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionStackDelta(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionFrameDelta(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionMnemonic(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionOperands(std::ostream&, SgAsmInstruction*, State&) const;
    virtual void emitInstructionComment(std::ostream&, SgAsmInstruction*, State&) const;
 
    virtual void emitInstructionSemantics(std::ostream&, SgAsmInstruction*, State&) const;
 
    virtual void emitOperand(std::ostream&, SgAsmExpression*, State&) const;
    virtual void emitOperandPrologue(std::ostream&, SgAsmExpression*, State&) const;
    virtual void emitOperandBody(std::ostream&, SgAsmExpression*, State&) const;
    virtual void emitOperandEpilogue(std::ostream&, SgAsmExpression*, State&) const;
 
    virtual void emitExpression(std::ostream&, SgAsmExpression*, State&) const;
#ifdef ROSE_ENABLE_ASM_AARCH32
    virtual std::vector<std::string> emitAarch32Coprocessor(std::ostream&, SgAsmAarch32Coprocessor*, State&) const;
#endif
#ifdef ROSE_ENABLE_ASM_AARCH64
    virtual std::vector<std::string> emitAarch64AtOperand(std::ostream&, SgAsmAarch64AtOperand*, State&) const;
    virtual std::vector<std::string> emitAarch64BarrierOperand(std::ostream&, SgAsmAarch64BarrierOperand*, State&) const;
    virtual std::vector<std::string> emitAarch64CImmediateOperand(std::ostream&, SgAsmAarch64CImmediateOperand*, State&) const;
    virtual std::vector<std::string> emitAarch64PrefetchOperand(std::ostream&, SgAsmAarch64PrefetchOperand*, State&) const;
    virtual std::vector<std::string> emitAarch64PState(std::ostream&, SgAsmAarch64PState*, State&) const;
    virtual std::vector<std::string> emitAarch64SysMoveOperand(std::ostream&, SgAsmAarch64SysMoveOperand*, State&) const;
#endif
    virtual std::vector<std::string> emitBinaryAdd(std::ostream&, SgAsmBinaryAdd*, State&) const;
    virtual std::vector<std::string> emitBinaryAsr(std::ostream&, SgAsmBinaryAsr*, State&) const;
    virtual std::vector<std::string> emitBinaryConcat(std::ostream&, SgAsmBinaryConcat*, State&) const;
    virtual std::vector<std::string> emitBinaryDivide(std::ostream&, SgAsmBinaryDivide*, State&) const;
    virtual std::vector<std::string> emitBinaryLsl(std::ostream&, SgAsmBinaryLsl*, State&) const;
    virtual std::vector<std::string> emitBinaryLsr(std::ostream&, SgAsmBinaryLsr*, State&) const;
    virtual std::vector<std::string> emitBinaryMsl(std::ostream&, SgAsmBinaryMsl*, State&) const;
    virtual std::vector<std::string> emitBinaryMultiply(std::ostream&, SgAsmBinaryMultiply*, State&) const;
    virtual std::vector<std::string> emitBinaryMod(std::ostream&, SgAsmBinaryMod*, State&) const;
    virtual std::vector<std::string> emitBinaryPreupdate(std::ostream&, SgAsmBinaryPreupdate*, State&) const;
    virtual std::vector<std::string> emitBinaryPostupdate(std::ostream&, SgAsmBinaryPostupdate*, State&) const;
    virtual std::vector<std::string> emitBinaryRor(std::ostream&, SgAsmBinaryRor*, State&) const;
    virtual std::vector<std::string> emitBinarySubtract(std::ostream&, SgAsmBinarySubtract*, State&) const;
    virtual std::vector<std::string> emitByteOrder(std::ostream&, SgAsmByteOrder*, State&) const;
    virtual std::vector<std::string> emitDirectRegisterExpression(std::ostream&, SgAsmDirectRegisterExpression*, State&) const;
    virtual std::vector<std::string> emitExprListExp(std::ostream&, SgAsmExprListExp*, State&) const;
    virtual std::vector<std::string> emitFloatValueExpression(std::ostream&, SgAsmFloatValueExpression*, State&) const;
    virtual std::vector<std::string> emitIndirectRegisterExpression(std::ostream&, SgAsmIndirectRegisterExpression*, State&) const;
    virtual std::vector<std::string> emitIntegerValueExpression(std::ostream&, SgAsmIntegerValueExpression*, State&) const;
    virtual std::vector<std::string> emitMemoryReferenceExpression(std::ostream&, SgAsmMemoryReferenceExpression*, State&) const;
    virtual std::vector<std::string> emitRegisterNames(std::ostream&, SgAsmRegisterNames*, State&) const;
    virtual std::vector<std::string> emitRiscOperation(std::ostream&, SgAsmRiscOperation*, State&) const;
    virtual std::vector<std::string> emitStackExpression(std::ostream&, SgAsmStackExpression*, State&) const;
    virtual std::vector<std::string> emitUnaryMinus(std::ostream&, SgAsmUnaryMinus*, State&) const;
    virtual std::vector<std::string> emitUnaryPlus(std::ostream&, SgAsmUnaryPlus*, State&) const;
    virtual std::vector<std::string> emitUnarySignedExtend(std::ostream&, SgAsmUnarySignedExtend*, State&) const;
    virtual std::vector<std::string> emitUnaryTruncate(std::ostream&, SgAsmUnaryTruncate*, State&) const;
    virtual std::vector<std::string> emitUnaryUnsignedExtend(std::ostream&, SgAsmUnaryUnsignedExtend*, State&) const;
 
    virtual void emitRegister(std::ostream&, RegisterDescriptor, State&) const;
    virtual std::vector<std::string> emitUnsignedInteger(std::ostream&, const Sawyer::Container::BitVector&, State&) const;
    virtual std::vector<std::string> emitSignedInteger(std::ostream&, const Sawyer::Container::BitVector&, State&) const;
    virtual std::vector<std::string> emitInteger(std::ostream&, const Sawyer::Container::BitVector&, State&,
                                                 bool isSigned) const;
    virtual bool emitAddress(std::ostream&, Address, State&, bool always=true) const;
    virtual bool emitAddress(std::ostream&, const Sawyer::Container::BitVector&, State&, bool always=true) const;
    virtual void emitCommentBlock(std::ostream&, const std::string&, State&, const std::string &prefix = ";;; ") const;
    virtual void emitTypeName(std::ostream&, SgAsmType*, State&) const;
 
    virtual void emitLinePrefix(std::ostream&, State&) const;
    //----- Other overrridable things -----
public:
    virtual void initializeState(State&) const;
 
    virtual void updateIntraFunctionArrows(State&) const;
 
    //-----  Utility functions -----
public:
    static std::string leftJustify(const std::string&, size_t nchars);
 
    static std::string juxtaposeColumns(const std::vector<std::string> &content, const std::vector<size_t> &minWidths,
                                        const std::vector<std::pair<std::string, std::string> > &colorEscapes,
                                        const std::string &columnSeparator = " ");
 
    static bool ascendingSourceAddress(Partitioner2::ControlFlowGraph::ConstEdgeIterator a,
                                       Partitioner2::ControlFlowGraph::ConstEdgeIterator b);
 
    static bool ascendingTargetAddress(Partitioner2::ControlFlowGraph::ConstEdgeIterator a,
                                       Partitioner2::ControlFlowGraph::ConstEdgeIterator b);
 
    static std::vector<Partitioner2::ControlFlowGraph::ConstEdgeIterator>
    orderedBlockPredecessors(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&);
 
    static std::vector<Partitioner2::ControlFlowGraph::ConstEdgeIterator>
    orderedBlockSuccessors(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&);
 
    virtual bool
    suppressFallThroughEdge(const Partitioner2::ControlFlowGraph::Edge&, const Partitioner2::BasicBlockPtr &src,
                                const Partitioner2::BasicBlockPtr &tgt, State&) const;
 
    bool
    hasSuppressedFallThroughEdge(const Partitioner2::BasicBlockPtr &src, const Partitioner2::BasicBlockPtr &dst, State&) const;
 
    void computeGutterArrows(const Partitioner2::FunctionPtr&, State&) const;
};
class Base: public Sawyer::SharedObject {…};
 
// Python API wrappers and functions
 
#ifdef ROSE_ENABLE_PYTHON_API
class PythonBase {
    Base::Ptr base_;
 
public:
    PythonBase() {}
 
    explicit PythonBase(const Base::Ptr &base)
        : base_(base) {
        ASSERT_not_null(base);
    }
 
    std::string unparse(const Partitioner2::PartitionerConstPtr &p) const {
        return base_->unparse(p);
    }
 
    void print(const Partitioner2::PartitionerConstPtr &p) const {
        base_->unparse(std::cout, p);
    }
};
#endif
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif