disassembler.hpp

//--------------------------------------------------------------------*- C++ -*-
// Kunai-static-analyzer: library for doing analysis of dalvik files
// @author Farenain <kunai.static.analysis@gmail.com>
// @author Ernesto Java <javaernesto@gmail.com>
//
// @file disassembler.hpp
// @brief Utilities of the disassembler to use by the different disassembly
// algorithms.
 
#ifndef KUNAI_DEX_DVM_DISASSEMBLER_HPP
#define KUNAI_DEX_DVM_DISASSEMBLER_HPP
 
#include "Kunai/DEX/DVM/dalvik_instructions.hpp"
 
#include <memory>
#include <iostream>
#include <any>
 
#include <unordered_map>
#include <map>
#include <utility>
 
 
namespace KUNAI
{
namespace DEX
{
 
    class Disassembler
    {
    public:
        typedef struct _handler_data
        {
            DVMType*                handler_type;
            std::uint64_t           handler_start_addr;
        } handler_data;
 
        typedef struct _exceptions_data
        {
            std::uint64_t               try_value_start_addr;
            std::uint64_t               try_value_end_addr;
            std::vector<handler_data>   handler;
        } exceptions_data;
 
        using instructions_t = std::unordered_map
                                <EncodedMethod*,
                                std::vector<std::unique_ptr<Instruction>>>;
 
    private:
        Parser * parser;
        Instruction * last_instr;
        DVMClass throwable_class{"Ljava/lang/Throwable;"};
        
    public:
 
        Disassembler() = default;
 
        void set_parser(Parser * parser)
        {
            this->parser = parser;
        }
 
        std::unique_ptr<Instruction> disassemble_instruction(
            std::uint32_t opcode,
            std::vector<uint8_t> & bytecode,
            std::size_t index
        );
 
        std::vector<std::int64_t> determine_next(Instruction * instruction, std::uint64_t curr_idx);
    
        std::vector<std::int64_t> determine_next(std::uint64_t curr_idx);
 
        std::int16_t get_conditional_jump_target(Instruction * instr);
 
        std::int32_t get_unconditional_jump_target(Instruction * instr);
 
        std::vector<exceptions_data> determine_exception(EncodedMethod * method);
    };
} // namespace DEX
} // namespace KUNAI
 
 
#endif