Disassembler.h

Go to the documentation of this file.

#ifndef ROSE_DISASSEMBLER_H
#define ROSE_DISASSEMBLER_H

#include "threadSupport.h"      /* needed for RTS_mutex_t in this header */
#include "Registers.h"
#include "MemoryMap.h"
#include "integerOps.h"
#include "Map.h"

class Disassembler {
public:
    class Exception: public std::runtime_error {
    public:
        Exception(const std::string &reason)
            : std::runtime_error(reason), ip(0), bit(0), insn(NULL)
            {}
        Exception(const std::string &reason, rose_addr_t ip)
            : std::runtime_error(reason), ip(ip), bit(0), insn(NULL)
            {}
        Exception(const std::string &reason, rose_addr_t ip, const SgUnsignedCharList &raw_data, size_t bit)
            : std::runtime_error(reason), ip(ip), bytes(raw_data), bit(bit), insn(NULL)
            {}
        Exception(const std::string &reason, SgAsmInstruction *insn)
            : std::runtime_error(reason), ip(insn->get_address()), bit(0), insn(insn)
            {}
        ~Exception() throw() {}

        void print(std::ostream&) const;
        friend std::ostream& operator<<(std::ostream &o, const Exception &e);

        rose_addr_t ip;                 
        SgUnsignedCharList bytes;       
        size_t bit;                     
        SgAsmInstruction *insn;         
    };

    enum SearchHeuristic 
        {
        SEARCH_FOLLOWING = 0x0001,      
        SEARCH_IMMEDIATE = 0x0002,      
        SEARCH_WORDS     = 0x0004,      
        SEARCH_ALLBYTES  = 0x0008,      
        SEARCH_UNUSED    = 0x0010,      
        SEARCH_NONEXE    = 0x0020,      
        SEARCH_DEADEND   = 0x0040,      
        SEARCH_UNKNOWN   = 0x0080,      
        SEARCH_FUNCSYMS  = 0x0100,      
        SEARCH_DEFAULT   = 0x0101       
    };

    static unsigned parse_switches(const std::string &s, unsigned initial=SEARCH_DEFAULT);

    typedef std::set<rose_addr_t> AddressSet;

    typedef Map<rose_addr_t, SgAsmInstruction*> InstructionMap;

    typedef Map<rose_addr_t, Exception> BadMap;

    Disassembler()
        : p_registers(NULL), p_partitioner(NULL), p_search(SEARCH_DEFAULT), p_debug(NULL),
          p_wordsize(4), p_sex(ByteOrder::ORDER_LSB), p_alignment(4), p_ndisassembled(0),
          p_protection(MemoryMap::MM_PROT_EXEC)
        {ctor();}

    Disassembler(const Disassembler& other)
        : p_registers(other.p_registers), p_partitioner(other.p_partitioner), p_search(other.p_search),
          p_debug(other.p_debug), p_wordsize(other.p_wordsize), p_sex(other.p_sex), p_alignment(other.p_alignment),
          p_ndisassembled(other.p_ndisassembled), p_protection(other.p_protection)
        {}

    virtual ~Disassembler() {}




    /***************************************************************************************************************************
     *                                  Registration and lookup methods
     ***************************************************************************************************************************/

public:
    static void register_subclass(Disassembler*);

    virtual bool can_disassemble(SgAsmGenericHeader*) const = 0;

    static Disassembler *lookup(SgAsmGenericHeader*);
    
    static Disassembler *lookup(SgAsmInterpretation*);

    virtual Disassembler *clone() const = 0;


    /***************************************************************************************************************************
     *                                  Main public disassembly methods
     ***************************************************************************************************************************/
public:
    void disassemble(SgAsmInterpretation*, AddressSet *successors=NULL, BadMap *bad=NULL);

    static void disassembleInterpretation(SgAsmInterpretation*);



    /***************************************************************************************************************************
     *                                          Disassembler properties and settings
     ***************************************************************************************************************************/
public:
    void set_registers(const RegisterDictionary *rdict) {
        p_registers = rdict;
    }

    const RegisterDictionary *get_registers() const {
        return p_registers;
    }

#ifndef USE_ROSE
  // DQ (2/11/2013): I think it is a problem to use this function (currently being evaluated using delta debug case).
  // This fails for ROSE compilign "rose.h" header file (ROSE compiling ROSE).
  // Generates error: ERROR: In parse_function_body(): (this should have been a function body) entry_kind = 0x3a4d47e8 = src-seq-sublist 

    void set_partitioner(class Partitioner *p) {
        p_partitioner = p;
    }
#else
    void set_partitioner(class Partitioner *p);
#endif

#ifndef USE_ROSE
    // DQ (2/11/2013): I think it is a problem to use this function (currently being evaluated using delta debug case).
    // This fails for ROSE compilign "rose.h" header file (ROSE compiling ROSE).

    class Partitioner *get_partitioner() const {
        return p_partitioner;
    }
#else
    class Partitioner *get_partitioner() const;
#endif

    void set_search(unsigned bits) {
        p_search = bits;
    }

    unsigned get_search() const {
        return p_search;
    }

    void set_wordsize(size_t);

    size_t get_wordsize() const {
        return p_wordsize;
    }

    void set_alignment(size_t);

    size_t get_alignment() const {
        return p_alignment;
    }

    void set_sex(ByteOrder::Endianness sex) {
        p_sex = sex;
    }

    ByteOrder::Endianness get_sex() const {
        return p_sex;
    }

    void set_debug(FILE *f) {
        p_debug = f;
    }

    FILE *get_debug() const {
        return p_debug;
    }

    size_t get_ndisassembled() const {
        return p_ndisassembled;
    }

    void set_protection(unsigned bitvec) {
        p_protection = bitvec;
    }

    unsigned get_protection() const {
        return p_protection;
    }

    void set_progress_reporting(FILE*, unsigned min_interval);


    /***************************************************************************************************************************
     *                                          Low-level disassembly functions
     ***************************************************************************************************************************/
public:
    virtual SgAsmInstruction *disassembleOne(const MemoryMap *map, rose_addr_t start_va, AddressSet *successors=NULL) = 0;

    SgAsmInstruction *disassembleOne(const unsigned char *buf, rose_addr_t buf_va, size_t buf_size, rose_addr_t start_va,
                                     AddressSet *successors=NULL);

    InstructionMap disassembleBlock(const MemoryMap *map, rose_addr_t start_va, AddressSet *successors=NULL,
                                    InstructionMap *cache=NULL);

    InstructionMap disassembleBlock(const unsigned char *buf, rose_addr_t buf_va, size_t buf_size, rose_addr_t start_va,
                                    AddressSet *successors=NULL, InstructionMap *cache=NULL);

    InstructionMap disassembleBuffer(const MemoryMap *map, size_t start_va, AddressSet *successors=NULL, BadMap *bad=NULL);

    InstructionMap disassembleBuffer(const unsigned char *buf, rose_addr_t buf_va, size_t buf_size, rose_addr_t start_va,
                                     AddressSet *successors=NULL, BadMap *bad=NULL);

    InstructionMap disassembleBuffer(const MemoryMap *map, AddressSet workset, AddressSet *successors=NULL, BadMap *bad=NULL);

    InstructionMap disassembleSection(SgAsmGenericSection *section, rose_addr_t section_va, rose_addr_t start_offset,
                                      AddressSet *successors=NULL, BadMap *bad=NULL);

    InstructionMap disassembleInterp(SgAsmInterpretation *interp, AddressSet *successors=NULL, BadMap *bad=NULL);



    /***************************************************************************************************************************
     *                                  Methods for searching for disassembly addresses.
     ***************************************************************************************************************************/
public:
    void search_following(AddressSet *worklist, const InstructionMap &bb, rose_addr_t bb_va, 
                          const MemoryMap *map, const InstructionMap &tried);

    void search_immediate(AddressSet *worklist, const InstructionMap &bb,  const MemoryMap *map, const InstructionMap &tried);

    void search_words(AddressSet *worklist, const MemoryMap *map, const InstructionMap &tried);

    void search_next_address(AddressSet *worklist, rose_addr_t start_va, const MemoryMap *map, const InstructionMap &insns,
                             const InstructionMap &tried, bool avoid_overlaps);

    void search_function_symbols(AddressSet *worklist, const MemoryMap*, SgAsmGenericHeader*);


    /***************************************************************************************************************************
     *                                          Miscellaneous methods
     ***************************************************************************************************************************/
public:
    void update_progress(SgAsmInstruction*);

    void progress(FILE*, const char *fmt, ...) const __attribute__((format(printf, 3, 4)));

    virtual SgAsmInstruction *make_unknown_instruction(const Exception&) = 0;

    void mark_referenced_instructions(SgAsmInterpretation*, const MemoryMap*, const InstructionMap&);

    AddressSet get_block_successors(const InstructionMap&, bool *complete);

private:
    static void initclass();

    void ctor();

    static SgAsmInstruction *find_instruction_containing(const InstructionMap &insns, rose_addr_t va);



    /***************************************************************************************************************************
     *                                          Data members
     ***************************************************************************************************************************/
protected:
    const RegisterDictionary *p_registers;              
    class Partitioner *p_partitioner;                   
    unsigned p_search;                                  
    FILE *p_debug;                                      
    size_t p_wordsize;                                  
    ByteOrder::Endianness p_sex;                        
    size_t p_alignment;                                 
    static std::vector<Disassembler*> disassemblers;    
    size_t p_ndisassembled;                             
    unsigned p_protection;                              
    static time_t progress_interval;                    
    static time_t progress_time;                        
    static FILE *progress_file;                         
    static RTS_mutex_t class_mutex;                     
};

#endif