AsmUnparser.h

#ifndef ROSE_AsmUnparser_H
#define ROSE_AsmUnparser_H

#include <ostream>

#include "callbacks.h"                                  // Needed for Rose::Callbacks::List<>
#include "BinaryControlFlow.h"
#include "BinaryFunctionCall.h"
#include "BaseSemantics2.h"

class SgAsmInstruction;
class SgAsmBlock;
class SgAsmFunction;
class SgAsmInterpretation;

namespace Rose {
namespace BinaryAnalysis {

class Disassembler;

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:
        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? */

        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 *disassembler;
        AsmUnparser *unparser;
        bool unparser_allocated_here;
        StaticDataDisassembler(): disassembler(NULL), unparser(NULL), unparser_allocated_here(false) {}
        ~StaticDataDisassembler() { reset(); }
        virtual void reset();
        virtual void init(Disassembler *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(): user_registers(NULL), interp_registers(NULL) {
        init();
    }

    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 const RegisterDictionary *get_registers() const;
    virtual void set_registers(const RegisterDictionary *registers) { user_registers = 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(), ' '); }
    static std::string invalid_register(SgAsmInstruction*, RegisterDescriptor, const RegisterDictionary*);

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;

    const RegisterDictionary *user_registers;           // registers set by set_registers()
    const RegisterDictionary *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