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&);
 
// Margins containing arrows
 
class ArrowMargin {
public:
    enum Flags {
        POINTABLE_ENTITY_START = 0x00000001,
 
        POINTABLE_ENTITY_END    = 0x00000002,
 
        POINTABLE_ENTITY_INSIDE = 0x00000004,
 
        ALWAYS_RENDER           = 0x00000008
    };
 
    EdgeArrows arrows;                                  
    BitFlags<Flags> flags;                              
    Sawyer::Optional<EdgeArrows::VertexId> latestEntity;
    void reset() {
        arrows.reset();
        flags = 0;
        latestEntity = Sawyer::Nothing();
    }
 
    std::string render(Sawyer::Optional<EdgeArrows::VertexId> currentEntity);
};
 
// 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 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 &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& previous() const {
        return previous_;
    }
};
 
// State of the unparser (the unparser itself is const during unparsing)
 
class State {
public:
    typedef Sawyer::Container::Map<rose_addr_t, std::string> AddrString; 
private:
    Partitioner2::PartitionerConstPtr partitioner_;
    Partitioner2::FunctionCallGraph cg_;
    Partitioner2::FunctionPtr currentFunction_;
    Partitioner2::BasicBlockPtr currentBasicBlock_;
    Sawyer::Optional<EdgeArrows::VertexId> currentPredSuccId_;
    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
    bool cfgArrowsPointToInsns_;                                      // arrows point to insns? else predecessor/successor lines
    StyleStack styleStack_;                                           // styles
 
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();
 
    Sawyer::Optional<EdgeArrows::VertexId> currentPredSuccId() const { return currentPredSuccId_; }
    void currentPredSuccId(Sawyer::Optional<EdgeArrows::VertexId> id) { currentPredSuccId_ = id; }
    bool cfgArrowsPointToInsns() const { return cfgArrowsPointToInsns_; }
    void cfgArrowsPointToInsns(bool b) { cfgArrowsPointToInsns_ = b; }
    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&);
 
    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();
 
    const Base& frontUnparser() const;
};
 
// 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;
    }
    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&, 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&, 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&, 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*/;
 
    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&, 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*/;
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 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 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;
    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&, rose_addr_t, 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&);
};
 
// 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