AsmUnparser.h

#ifndef ROSE_AsmUnparser_H
#define ROSE_AsmUnparser_H
 
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <ostream>
 
#include "callbacks.h"                                  // Needed for Rose::Callbacks::List<>
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/ControlFlow.h>
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/FunctionCall.h>
#include <Rose/BinaryAnalysis/Hexdump.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
 
class SgAsmInstruction;
class SgAsmBlock;
class SgAsmFunction;
class SgAsmInterpretation;
 
namespace Rose {
namespace BinaryAnalysis {
 
namespace Disassembler {
class Base;
} // namespace
 
class ROSE_DLL_API AsmUnparser {
public:
    enum Organization {
        ORGANIZED_BY_AST,               
        ORGANIZED_BY_ADDRESS            
    };
 
    typedef Rose::BinaryAnalysis::ControlFlow::Graph CFG;
    typedef boost::graph_traits<CFG>::vertex_descriptor CFG_Vertex;
    typedef std::map<SgAsmBlock*, CFG_Vertex> CFG_BlockMap;
    typedef Rose::BinaryAnalysis::FunctionCall::Graph CG;
    typedef boost::graph_traits<CG>::vertex_descriptor CG_Vertex;
    typedef std::map<SgAsmFunction*, CG_Vertex> CG_FunctionMap;
 
    class UnparserCallback {
    public:
        struct GeneralArgs {
            GeneralArgs(AsmUnparser *unparser, std::ostream &output)
                : unparser(unparser), output(output) {}
            AsmUnparser *unparser;      
            std::ostream &output;       
        };
 
        struct InsnArgs: public GeneralArgs {
            InsnArgs(AsmUnparser *unparser, std::ostream &output, SgAsmInstruction *insn, size_t position_in_block)
                : GeneralArgs(unparser, output), insn(insn), position_in_block(position_in_block) {}
            SgAsmInstruction *get_node() const { return insn; } 
            SgAsmInstruction *insn;     
            size_t position_in_block;   
        };
 
        struct BasicBlockArgs: public GeneralArgs {
            BasicBlockArgs(AsmUnparser *unparser, std::ostream &output, SgAsmBlock *block,
                           const std::vector<SgAsmInstruction*> &insns)
                : GeneralArgs(unparser, output), block(block), insns(insns) {}
            SgAsmBlock *get_node() const { return block; } 
            SgAsmBlock *block;          
            const std::vector<SgAsmInstruction*> &insns; 
        };
 
        struct StaticDataArgs: public GeneralArgs {
            StaticDataArgs(AsmUnparser *unparser, std::ostream &output, SgAsmStaticData *data, size_t position_in_block)
                : GeneralArgs(unparser, output), data(data), position_in_block(position_in_block) {}
            SgAsmStaticData *get_node() const { return data; } 
            SgAsmStaticData *data;      
            size_t position_in_block;   
        };
 
        struct DataBlockArgs: public GeneralArgs {
            DataBlockArgs(AsmUnparser *unparser, std::ostream &output, SgAsmBlock *block,
                          const std::vector<SgAsmStaticData*> &datalist)
                : GeneralArgs(unparser, output), block(block), datalist(datalist) {}
            SgAsmBlock *get_node() const { return block; } 
            SgAsmBlock *block;          
            const std::vector<SgAsmStaticData*> &datalist; 
        };
 
        struct FunctionArgs: public GeneralArgs {
            FunctionArgs(AsmUnparser *unparser, std::ostream &output, SgAsmFunction *func)
                : GeneralArgs(unparser, output), func(func) {}
            SgAsmFunction *get_node() const { return func; } 
            SgAsmFunction *func;        
        };
 
        struct InterpretationArgs: public GeneralArgs {
            InterpretationArgs(AsmUnparser *unparser, std::ostream &output, SgAsmInterpretation *interp)
                : GeneralArgs(unparser, output), interp(interp) {}
            SgAsmInterpretation *get_node() const { return interp; } 
            SgAsmInterpretation *interp; 
        };
        
        virtual ~UnparserCallback() {}
 
        virtual bool operator()(bool /*enabled*/, const InsnArgs&)           { abort(); return false; }
        virtual bool operator()(bool /*enabled*/, const BasicBlockArgs&)     { abort(); return false; }
        virtual bool operator()(bool /*enabled*/, const StaticDataArgs&)     { abort(); return false; }
        virtual bool operator()(bool /*enabled*/, const DataBlockArgs&)      { abort(); return false; }
        virtual bool operator()(bool /*enabled*/, const FunctionArgs&)       { abort(); return false; }
        virtual bool operator()(bool /*enabled*/, const InterpretationArgs&) { abort(); return false; }
    };
 
    /**************************************************************************************************************************
     *                                  Instruction Callbacks
     **************************************************************************************************************************/
 
    class InsnSkipBackBegin: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnBlockSeparation: public UnparserCallback {
    public:
        SgAsmBlock *prev_block;
        InsnBlockSeparation(): prev_block(NULL) {}
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnFuncEntry: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnAddress: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnRawBytes: public UnparserCallback {
    public:
        Rose::BinaryAnalysis::HexdumpFormat fmt;
        InsnRawBytes() {
            fmt.width = 8;              /* Max instruction bytes per line of output. */
            fmt.pad_chars = true;       /* Show ASCII characters as well as bytes. */
        }
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnBlockEntry: public UnparserCallback {
    public:
        bool show_function;             
        bool show_reasons;              
        InsnBlockEntry(): show_function(true), show_reasons(true) {}
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnStackDelta: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
    
    class InsnBody: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnNoEffect: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnComment: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnLineTermination: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    class InsnSkipBackEnd: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InsnArgs &args);
    };
 
    /**************************************************************************************************************************
     *                                  Basic Block Callbacks
     **************************************************************************************************************************/
 
    class BasicBlockReasons: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
 
    class BasicBlockPredecessors: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
 
    class BasicBlockNoopUpdater: public UnparserCallback {
    public:
        bool debug;             
        BasicBlockNoopUpdater(): debug(false) {}
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
 
    class BasicBlockNoopWarning: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
 
    class BasicBlockBody: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
 
    class BasicBlockOutgoingStackDelta: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
    
    class BasicBlockSuccessors: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
 
    class BasicBlockLineTermination: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const BasicBlockArgs &args);
    };
 
    class BasicBlockCleanup: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled/*ignored*/, const BasicBlockArgs &args);
    };
 
    /**************************************************************************************************************************
     *                                  Static Data Callbacks
     **************************************************************************************************************************/
 
    class StaticDataSkipBackBegin: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataBlockSeparation: public UnparserCallback {
    public:
        SgAsmBlock *prev_block;
        StaticDataBlockSeparation(): prev_block(NULL) {}
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataRawBytes: public UnparserCallback {
    public:
        bool show_address;              /* Should we show the address in the left margin? */
        bool show_offset;               /* If show_address is true, then should we display START+OFFSET or just an address? */
 
        Rose::BinaryAnalysis::HexdumpFormat fmt;
        StaticDataRawBytes() {
            show_address = true;
            show_offset = false;
            fmt.prefix = "";            /* Adjusted by the callback each time called. */
            fmt.multiline = false;      /* Do not emit prefix before first line and linefeed after last line. */
            fmt.width = 8;              /* Max data bytes per line of output. */
            fmt.pad_chars = true;       /* Show ASCII characters as well as bytes. */
        }
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataBlockEntry: public UnparserCallback {
    public:
        bool show_function;             
        bool show_reasons;              
        StaticDataBlockEntry(): show_function(true), show_reasons(true) {}
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataDetails: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataComment: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataLineTermination: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataDisassembler: public UnparserCallback {
    public:
        class DataNote: public UnparserCallback {
        public:
            virtual bool operator()(bool enabled, const InsnArgs &args) {
                if (enabled)
                    args.output <<" (data)";
                return enabled;
            }
        };
 
        DataNote data_note;
        Disassembler::BasePtr disassembler;
        AsmUnparser *unparser = nullptr;
        bool unparser_allocated_here = false;
        StaticDataDisassembler();
        ~StaticDataDisassembler();
        virtual void reset();
        virtual void init(const Disassembler::BasePtr &disassembler, AsmUnparser *unparser=NULL);
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class StaticDataSkipBackEnd: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    /**************************************************************************************************************************
     *                                  Data Block Callbacks
     **************************************************************************************************************************/
 
    class DataBlockTitle: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const StaticDataArgs &args);
    };
 
    class DataBlockBody: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const DataBlockArgs &args);
    };
 
    class DataBlockLineTermination: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const DataBlockArgs &args);
    };
 
    /**************************************************************************************************************************
     *                                  Function Callbacks
     **************************************************************************************************************************/
 
    class FunctionEntryAddress: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionSeparator: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionReasons: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionName: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionLineTermination: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionComment: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionPredecessors: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionSuccessors: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionAttributes: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    class FunctionBody: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const FunctionArgs &args);
    };
 
    /**************************************************************************************************************************
     *                                  Interpretation Callbacks
     **************************************************************************************************************************/
 
    class InterpName: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InterpretationArgs &args);
    };
 
    class InterpBody: public UnparserCallback {
    public:
        virtual bool operator()(bool enabled, const InterpretationArgs &args);
    };
 
    /**************************************************************************************************************************
     *                                  Built-in Callbacks
     * Don't forget to modify init() to actually add these to callback lists if desired.
     **************************************************************************************************************************/
 
    InsnSkipBackBegin insnSkipBackBegin;
    InsnBlockSeparation insnBlockSeparation;
    InsnFuncEntry insnFuncEntry;
    InsnAddress insnAddress;
    InsnRawBytes insnRawBytes;
    InsnBlockEntry insnBlockEntry;
    InsnStackDelta insnStackDelta;
    InsnBody insnBody;
    InsnNoEffect insnNoEffect;
    InsnComment insnComment;
    InsnLineTermination insnLineTermination;
    InsnSkipBackEnd insnSkipBackEnd;
 
    BasicBlockReasons basicBlockReasons;
    BasicBlockPredecessors basicBlockPredecessors;
    BasicBlockNoopUpdater basicBlockNoopUpdater;
    BasicBlockNoopWarning basicBlockNoopWarning;
    BasicBlockBody basicBlockBody;
    BasicBlockOutgoingStackDelta basicBlockOutgoingStackDelta;
    BasicBlockSuccessors basicBlockSuccessors;
    BasicBlockLineTermination basicBlockLineTermination;
    BasicBlockCleanup basicBlockCleanup;
 
    StaticDataSkipBackBegin staticDataSkipBackBegin;
    StaticDataBlockSeparation staticDataBlockSeparation;
    StaticDataRawBytes staticDataRawBytes;
    StaticDataBlockEntry staticDataBlockEntry;
    StaticDataDetails staticDataDetails;
    StaticDataComment staticDataComment;
    StaticDataLineTermination staticDataLineTermination;
    StaticDataDisassembler staticDataDisassembler;
    StaticDataSkipBackEnd staticDataSkipBackEnd;
 
    DataBlockBody dataBlockBody;
    DataBlockLineTermination dataBlockLineTermination;
 
    FunctionEntryAddress functionEntryAddress;
    FunctionSeparator functionSeparator;
    FunctionReasons functionReasons;
    FunctionName functionName;
    FunctionLineTermination functionLineTermination;
    FunctionComment functionComment;
    FunctionPredecessors functionPredecessors;
    FunctionSuccessors functionSuccessors;
    FunctionAttributes functionAttributes;
    FunctionBody functionBody;
 
    InterpName interpName;
    InterpBody interpBody;
    /**************************************************************************************************************************
     *                                  Public methods
     **************************************************************************************************************************/
 
    AsmUnparser();
    virtual ~AsmUnparser();
 
    virtual Organization get_organization() const { return organization; }
    virtual void set_organization(Organization organization) { this->organization = organization; }
    virtual bool is_unparsable_node(SgNode *node);
 
    virtual SgNode *find_unparsable_node(SgNode *ast);
 
    virtual std::vector<SgNode*> find_unparsable_nodes(SgNode *ast);
 
    virtual RegisterDictionaryPtr get_registers() const;
    virtual void set_registers(const RegisterDictionaryPtr &registers);
    std::vector<bool> insn_is_noop;
 
    virtual size_t unparse(std::ostream&, SgNode *ast);
 
    std::string to_string(SgNode *ast);
 
    virtual bool unparse_one_node(std::ostream&, SgNode*);
 
    virtual bool unparse_insn(bool enabled, std::ostream&, SgAsmInstruction*, size_t position_in_block=(size_t)-1);
    virtual bool unparse_basicblock(bool enabled, std::ostream&, SgAsmBlock*);
    virtual bool unparse_staticdata(bool enabled, std::ostream&, SgAsmStaticData*, size_t position_in_block=(size_t)-1);
    virtual bool unparse_datablock(bool enabled, std::ostream&, SgAsmBlock*);
    virtual bool unparse_function(bool enabled, std::ostream&, SgAsmFunction*);
    virtual bool unparse_interpretation(bool enabled, std::ostream&, SgAsmInterpretation*);
    typedef std::map<uint64_t, std::string> LabelMap;
 
    void add_function_labels(SgNode *ast);
 
    void add_control_flow_graph(const Rose::BinaryAnalysis::ControlFlow::Graph &cfg);
 
    void set_skipback_reporting(bool b=true) { skipback.active=b; skipback.triggered=false; }
    void clear_skipback_reporting() { set_skipback_reporting(false); }
    bool get_skipback_reporting() const { return skipback.active; }
    void reset_skipback() { skipback.triggered=false; skipback.va=0; }
    void start_of_object(rose_addr_t, std::ostream&);
    void end_of_object(rose_addr_t);
    virtual void set_prefix_format(const std::string &format) { lineprefix.format = format; }
    virtual const std::string& get_prefix_format() const { return lineprefix.format; }
    virtual void set_prefix_address(rose_addr_t va) { lineprefix.address = va; }
    virtual rose_addr_t get_prefix_address() const { return lineprefix.address; }
    virtual std::string line_prefix() const;
    virtual std::string blank_prefix() const { return std::string(line_prefix().size(), ' '); }
public:
    static void initDiagnostics();                      
    static Sawyer::Message::Facility mlog;              
protected:
    struct CallbackLists {
        Callbacks::List<UnparserCallback> unparse;      
        Callbacks::List<UnparserCallback> pre;          
        Callbacks::List<UnparserCallback> post;         
        void clear() {
            unparse.clear();
            pre.clear();
            post.clear();
        }
    };
 
    CallbackLists insn_callbacks;                       
    CallbackLists basicblock_callbacks;                 
    CallbackLists staticdata_callbacks;                 
    CallbackLists datablock_callbacks;                  
    CallbackLists function_callbacks;                   
    CallbackLists interp_callbacks;                     
    LabelMap labels;
 
    Organization organization;
 
    RegisterDictionaryPtr user_registers;               // registers set by set_registers()
    RegisterDictionaryPtr interp_registers;             // registers obtained from the SgAsmInterpretation
 
    virtual void init();
 
    CFG cfg;
 
    CFG_BlockMap cfg_blockmap;
 
    CG cg;
 
    CG_FunctionMap cg_functionmap;
 
    struct SkipBack {
        SkipBack(): active(true), triggered(false), va(0) {}
        bool active;                    
        bool triggered;                 
        rose_addr_t va;                 
    } skipback;
 
    struct LinePrefix {
        LinePrefix(): format("0x%08" PRIx64 ": "), address(0) {}
        std::string format;             
        rose_addr_t address;            
    } lineprefix;
};
 
} // namespace
} // namespace
 
#endif
#endif