dalvik_instructions.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 dalvik_instructions.hpp
// @brief Definition of all the instructions available on the Dalvik
// Virtual Machine
#ifndef KUNAI_DEX_DVM_DALVIK_INSTRUCTIONS_HPP
#define KUNAI_DEX_DVM_DALVIK_INSTRUCTIONS_HPP
 
#include "Kunai/Utils/kunaistream.hpp"
#include "Kunai/DEX/parser/parser.hpp"
#include "Kunai/DEX/DVM/dvm_types.hpp"
#include "Kunai/DEX/DVM/dalvik_opcodes.hpp"
 
#include <iostream>
#include <span>
#include <string>
#include <variant>
 
namespace KUNAI
{
namespace DEX
{
    enum class dexinsttype_t
    {
        DEX_INSTRUCTION00X,
        DEX_INSTRUCTION10X,
        DEX_INSTRUCTION12X,
        DEX_INSTRUCTION11N,
        DEX_INSTRUCTION11X,
        DEX_INSTRUCTION10T,
        DEX_INSTRUCTION20T,
        DEX_INSTRUCTION20BC,
        DEX_INSTRUCTION22X,
        DEX_INSTRUCTION21T,
        DEX_INSTRUCTION21S,
        DEX_INSTRUCTION21H,
        DEX_INSTRUCTION21C,
        DEX_INSTRUCTION23X,
        DEX_INSTRUCTION22B,
        DEX_INSTRUCTION22T,
        DEX_INSTRUCTION22S,
        DEX_INSTRUCTION22C,
        DEX_INSTRUCTION22CS,
        DEX_INSTRUCTION30T,
        DEX_INSTRUCTION32X,
        DEX_INSTRUCTION31I,
        DEX_INSTRUCTION31T,
        DEX_INSTRUCTION31C,
        DEX_INSTRUCTION35C,
        DEX_INSTRUCTION3RC,
        DEX_INSTRUCTION45CC,
        DEX_INSTRUCTION4RCC,
        DEX_INSTRUCTION51L,
        DEX_PACKEDSWITCH,
        DEX_SPARSESWITCH,
        DEX_FILLARRAYDATA,
        DEX_DALVIKINCORRECT,
        DEX_NONE_OP = 99,
    };
 
    class Instruction
    {
        dexinsttype_t instruction_type;
 
    protected:
        std::span<std::uint8_t> op_codes;
        std::uint32_t length;
        std::uint32_t op;
        std::uint64_t address;
 
    public:
        Instruction(std::vector<uint8_t> &bytecode, std::size_t index, dexinsttype_t instruction_type)
            : instruction_type(instruction_type), length(0), op(0), op_codes({})
        {
        }
 
        Instruction(std::vector<uint8_t> &bytecode, std::size_t index, dexinsttype_t instruction_type, std::uint32_t length)
            : instruction_type(instruction_type), length(length), op(0)
        {
            op_codes = {bytecode.begin() + index, bytecode.begin() + index + length};
        }
 
        virtual ~Instruction() = default;
 
        virtual TYPES::Kind get_kind() const
        {
            return DalvikOpcodes::get_instruction_type(op);
        }
        virtual dexinsttype_t get_instruction_type() const
        {
            return instruction_type;
        }
 
        virtual std::uint32_t get_instruction_length() const
        {
            return length;
        }
 
        virtual std::uint32_t get_instruction_opcode() const
        {
            return op;
        }
 
        virtual void set_address(std::uint64_t address)
        {
            this->address = address;
        }
 
        virtual std::uint64_t get_address() const
        {
            return address;
        }
 
        virtual std::string print_instruction()
        {
            return "";
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << "";
        }
 
        virtual const std::span<std::uint8_t> &get_opcodes()
        {
            return op_codes;
        }
 
        virtual bool is_terminator()
        {
            auto operation = DalvikOpcodes::get_instruction_operation(op);
 
            if (operation == TYPES::Operation::CONDITIONAL_BRANCH_DVM_OPCODE ||
                operation == TYPES::Operation::UNCONDITIONAL_BRANCH_DVM_OPCODE ||
                operation == TYPES::Operation::RET_BRANCH_DVM_OPCODE ||
                operation == TYPES::Operation::MULTI_BRANCH_DVM_OPCODE)
                return true;
            return false;
        }
 
        virtual bool has_side_effects() const;
 
        virtual bool may_throw() const;
    };
 
    class Instruction00x : public Instruction
    {
    public:
        Instruction00x(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser) : Instruction(bytecode, index, dexinsttype_t::DEX_INSTRUCTION00X)
        {
        }
    };
 
    class Instruction10x : public Instruction
    {
    public:
        Instruction10x(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op);
        }
    };
 
    class Instruction12x : public Instruction
    {
        std::uint8_t vA;
        std::uint8_t vB;
 
    public:
        Instruction12x(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vA;
        }
 
        std::uint8_t get_source() const
        {
            return vB;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " " +
                    "v" + std::to_string(vA) + ", " +
                    "v" + std::to_string(vB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " " +
                        "v" + std::to_string(vA) + ", " +
                        "v" + std::to_string(vB);
        }
    };
 
    class Instruction11n : public Instruction
    {
        std::uint8_t vA;
        std::int8_t nB;
 
    public:
        Instruction11n(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vA;
        }
 
        std::int8_t get_source() const
        {
            return nB;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " " +
                    "v" + std::to_string(vA) + ", " +
                    std::to_string(nB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " " +
                        "v" + std::to_string(vA) + ", " +
                        std::to_string(nB);
        }
    };
 
    class Instruction11x : public Instruction
    {
        std::uint8_t vAA;
 
    public:
        Instruction11x(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " " +
                    "v" + std::to_string(vAA);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " " +
                        "v" + std::to_string(vAA);
        }
    };
 
    class Instruction10t : public Instruction
    {
        std::int8_t nAA;
 
    public:
        Instruction10t(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::int8_t get_jump_offset() const
        {
            return nAA;
        }
 
        TYPES::Operand get_operand_type() const
        {
            return TYPES::Operand::OFFSET;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " " +
                    std::to_string((nAA*2) + static_cast<std::int64_t>(address));
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " " +
                        std::to_string((nAA*2) + static_cast<std::int64_t>(address));
        }
    };
 
    class Instruction20t : public Instruction
    {
        std::int16_t nAAAA;
 
    public:
        Instruction20t(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::int16_t get_offset() const
        {
            return nAAAA;
        }
 
        TYPES::Operand get_operand_type() const
        {
            return TYPES::Operand::OFFSET;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " " +
                    std::to_string((nAAAA*2) + static_cast<std::int64_t>(address));
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " " +
                        std::to_string((nAAAA*2) + static_cast<std::int64_t>(address));
        }
    };
 
    class Instruction20bc : public Instruction
    {
        std::uint8_t nAA;
        std::uint16_t nBBBB;
 
    public:
        Instruction20bc(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_type_of_error_data() const
        {
            return nAA;
        }
 
        TYPES::Operand get_error_operand_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        std::uint16_t get_index_into_table() const
        {
            return nBBBB;
        }
 
        TYPES::Operand get_index_operand_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " " +
                    std::to_string(nAA) + ", kind@" + std::to_string(nBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " " +
                        std::to_string(nAA) + ", kind@" + std::to_string(nBBBB);
        }
    };
 
    class Instruction22x : public Instruction
    {
        std::uint8_t vAA;
        std::uint16_t vBBBB;
 
    public:
        Instruction22x(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint16_t get_source() const
        {
            return vBBBB;
        }
 
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " " +
                    "v" + std::to_string(vAA) + ", v" +
                    std::to_string(vBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " " +
                        "v" + std::to_string(vAA) + ", v" +
                        std::to_string(vBBBB);
        }
    };
 
    class Instruction21t : public Instruction
    {
        std::uint8_t vAA;
        std::int16_t nBBBB;
 
    public:
        Instruction21t(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_check_reg() const
        {
            return vAA;
        }
 
        TYPES::Operand get_check_reg_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int16_t get_jump_offset() const
        {
            return nBBBB;
        }
 
        TYPES::Operand get_offset_type() const
        {
            return TYPES::Operand::OFFSET;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vAA) + ", " +
                    std::to_string(nBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vAA) + ", " +
                        std::to_string(nBBBB);
        }
    };
 
    class Instruction21s : public Instruction
    {
        std::uint8_t vAA;
        std::int16_t nBBBB;
 
    public:
        Instruction21s(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int16_t get_source() const
        {
            return nBBBB;
        }
 
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vAA) + ", " +
                    std::to_string(nBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vAA) + ", " +
                        std::to_string(nBBBB);
        }
    };
 
    class Instruction21h : public Instruction
    {
        std::uint8_t vAA;
        std::int64_t nBBBB;
 
    public:
        Instruction21h(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int64_t get_source() const
        {
            return nBBBB;
        }
 
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vAA) + ", " +
                    std::to_string(nBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vAA) + ", " +
                        std::to_string(nBBBB);
        }
    };
 
    class Instruction21c : public Instruction
    {
        bool is_str = false;
        bool is_type = false;
        bool is_fundamental = false;
        bool is_array = false;
        bool is_class = false;
        bool is_unknown = false;
 
        bool is_field = false;
        bool is_method = false;
        bool is_proto = false;
 
        std::uint8_t vAA;
        std::uint16_t iBBBB;
        std::string source_str;
 
        Parser *parser;
 
    public:
        Instruction21c(std::vector<uint8_t> &bytecode, std::size_t index, Parser *parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint16_t get_source() const
        {
            return iBBBB;
        }
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::KIND;
        }
 
        const std::string &pretty_print_source() const
        {
            return source_str;
        }
 
        bool is_source_string() const
        {
            return is_str;
        }
 
        std::string &get_source_str()
        {
            return source_str;
        }
 
        DVMType *get_source_dvmtype() const
        {
            if (is_type)
                return parser->get_types().get_type_from_order(iBBBB);
            return nullptr;
        }
 
        DVMFundamental *get_source_dvmfundamental() const
        {
            if (is_fundamental)
                return reinterpret_cast<DVMFundamental *>(
                    parser->get_types().get_type_from_order(iBBBB));
            return nullptr;
        }
 
        DVMClass *get_source_dvmclass() const
        {
            if (is_class)
                return reinterpret_cast<DVMClass *>(
                    parser->get_types().get_type_from_order(iBBBB));
            return nullptr;
        }
 
        DVMArray *get_source_dvmarray() const
        {
            if (is_array)
                return reinterpret_cast<DVMArray *>(
                    parser->get_types().get_type_from_order(iBBBB));
            return nullptr;
        }
 
        FieldID *get_source_field() const
        {
            if (is_field)
                return parser->get_fields().get_field(iBBBB);
            return nullptr;
        }
 
        ProtoID *get_source_proto() const
        {
            if (is_proto)
                return parser->get_protos().get_proto_by_order(iBBBB);
            return nullptr;
        }
 
        MethodID *get_source_method() const
        {
            if (is_method)
                return parser->get_methods().get_method(iBBBB);
            return nullptr;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vAA) + ", " +
                    source_str + " (" + std::to_string(iBBBB) + ")";
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vAA) + ", " +
                        source_str + " (" + std::to_string(iBBBB) + ")";
        }
    };
 
    class Instruction23x : public Instruction
    {
        std::uint8_t vAA;
        std::uint8_t vBB;
        std::uint8_t vCC;
 
    public:
        Instruction23x(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_first_source() const
        {
            return vBB;
        }
 
        TYPES::Operand get_first_source_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_second_source() const
        {
            return vCC;
        }
 
        TYPES::Operand get_second_source_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vAA) + ", v" +
                    std::to_string(vBB) + ", v" +
                    std::to_string(vCC);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vAA) + ", v" +
                        std::to_string(vBB) + ", v" +
                        std::to_string(vCC);
        }
    };
 
    class Instruction22b : public Instruction
    {
        std::uint8_t vAA;
        std::uint8_t vBB;
        std::int8_t nCC;
 
    public:
        Instruction22b(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_first_operand() const
        {
            return vBB;
        }
 
        TYPES::Operand get_first_operand_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int8_t get_second_operand() const
        {
            return nCC;
        }
 
        TYPES::Operand get_second_operand_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vAA) + ", v" +
                    std::to_string(vBB) + ", " +
                    std::to_string(nCC);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vAA) + ", v" +
                        std::to_string(vBB) + ", " +
                        std::to_string(nCC);
        }
    };
 
    class Instruction22t : public Instruction
    {
        std::uint8_t vA;
        std::uint8_t vB;
        std::int16_t nCCCC;
 
    public:
        Instruction22t(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_first_operand() const
        {
            return vA;
        }
 
        TYPES::Operand get_first_operand_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_second_operand() const
        {
            return vB;
        }
 
        TYPES::Operand get_second_operand_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int16_t get_offset() const
        {
            return nCCCC;
        }
 
        TYPES::Operand get_offset_type() const
        {
            return TYPES::Operand::OFFSET;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vA) + ", v" +
                    std::to_string(vB) + ", " +
                    std::to_string(nCCCC);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vA) + ", v" +
                        std::to_string(vB) + ", " +
                        std::to_string(nCCCC);
        }
    };
 
    class Instruction22s : public Instruction
    {
        std::uint8_t vA;
        std::uint8_t vB;
        std::int16_t nCCCC;
 
    public:
        Instruction22s(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_first_operand() const
        {
            return vB;
        }
 
        TYPES::Operand get_first_operand_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int16_t get_second_operand() const
        {
            return nCCCC;
        }
 
        TYPES::Operand get_second_operand_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vA) + ", v" +
                    std::to_string(vB) + ", " +
                    std::to_string(nCCCC);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vA) + ", v" +
                        std::to_string(vB) + ", " +
                        std::to_string(nCCCC);
        }
    };
 
    class Instruction22c : public Instruction
    {
        std::uint8_t vA;
        std::uint8_t vB;
        std::uint16_t iCCCC;
        std::string iCCCC_str;
        Parser *parser;
        bool is_type = false;
        bool is_field = false;
 
    public:
        Instruction22c(std::vector<uint8_t> &bytecode, std::size_t index, Parser *parser);
 
        std::uint8_t get_destination() const
        {
            return vA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_operand() const
        {
            return vB;
        }
 
        TYPES::Operand get_operand_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint16_t get_checked_id() const
        {
            return iCCCC;
        }
 
        TYPES::Operand get_checked_id_type() const
        {
            return TYPES::Operand::KIND;
        }
 
        const std::string &get_checked_value_str() const
        {
            return iCCCC_str;
        }
 
        DVMType *get_checked_dvmtype() const
        {
            if (is_type)
                return parser->get_types().get_type_from_order(iCCCC);
            return nullptr;
        }
 
        FieldID *get_checked_field()
        {
            if (is_field)
                return parser->get_fields().get_field(iCCCC);
            return nullptr;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vA) + ", v" + std::to_string(vB) + ", " +
                    iCCCC_str + " (" + std::to_string(iCCCC) + ")";
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vA) + ", v" + std::to_string(vB) + ", " +
                        iCCCC_str + " (" + std::to_string(iCCCC) + ")";
        }
    };
 
    class Instruction22cs : public Instruction
    {
        std::uint8_t vA;
        std::uint8_t vB;
        std::uint16_t iCCCC;
        std::string iCCCC_str;
        bool is_field = false;
        Parser *parser;
 
    public:
        Instruction22cs(std::vector<uint8_t> &bytecode, std::size_t index, Parser *parser);
 
        std::uint8_t get_register_A() const
        {
            return vA;
        }
 
        TYPES::Operand get_register_A_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_register_B() const
        {
            return vB;
        }
 
        TYPES::Operand get_register_B_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint16_t get_field_offset() const
        {
            return iCCCC;
        }
 
        TYPES::Operand get_field_offset_type() const
        {
            return TYPES::Operand::KIND;
        }
 
        const std::string &get_field_string() const
        {
            return iCCCC_str;
        }
 
        FieldID *get_field() const
        {
            if (is_field)
                return parser->get_fields().get_field(iCCCC);
            return nullptr;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" +
                    std::to_string(vA) + ", v" + std::to_string(vB) + ", " +
                    iCCCC_str + " (" + std::to_string(iCCCC) + ")";
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" +
                        std::to_string(vA) + ", v" + std::to_string(vB) + ", " +
                        iCCCC_str + " (" + std::to_string(iCCCC) + ")";
        }
    };
 
    class Instruction30t : public Instruction
    {
        std::int32_t nAAAAAAAA;
 
    public:
        Instruction30t(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::int32_t get_offset() const
        {
            return nAAAAAAAA;
        }
 
        TYPES::Operand get_offset_type() const
        {
            return TYPES::Operand::OFFSET;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + std::to_string((nAAAAAAAA*2) + static_cast<std::int64_t>(address));
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + std::to_string((nAAAAAAAA*2) + static_cast<std::int64_t>(address));
        }
    };
 
    class Instruction32x : public Instruction
    {
        std::uint16_t vAAAA;
        std::uint16_t vBBBB;
    public:
        Instruction32x(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint16_t get_destination() const
        {
            return vAAAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint16_t get_source() const
        {
            return vBBBB;
        }
 
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAAAA) + ", v" + std::to_string(vBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAAAA) + ", v" + std::to_string(vBBBB);
        }
    };
 
    class Instruction31i : public Instruction
    {
        std::uint8_t vAA;
        std::uint32_t nBBBBBBBB;
    public:
        Instruction31i(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint32_t get_source() const
        {
            return nBBBBBBBB;
        }
 
        TYPES::Operand get_source_type() const
        {
            return TYPES::Operand::LITERAL;
        }
        
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAA) + ", " + std::to_string(nBBBBBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAA) + ", " + std::to_string(nBBBBBBBB);
        }
    };
 
    class PackedSwitch;
    class SparseSwitch;
 
    class Instruction31t : public Instruction
    {
    public:
        enum type_of_switch_t
        {
            PACKED_SWITCH = 0,
            SPARSE_SWITCH,
            NONE_SWITCH
        };
    private:
        std::uint8_t vAA;
        std::int32_t nBBBBBBBB;
        
        type_of_switch_t type_of_switch;
 
        PackedSwitch * packed_switch = nullptr;
        SparseSwitch * sparse_switch = nullptr;
    public:
        Instruction31t(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_ref_register() const
        {
            return vAA;
        }
 
        TYPES::Operand get_ref_register_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int32_t get_offset() const
        {
            return nBBBBBBBB;
        }
 
        TYPES::Operand get_offset_type() const
        {
            return TYPES::Operand::OFFSET;
        }
 
        type_of_switch_t get_type_of_switch() const
        {
            return type_of_switch;
        }
 
        PackedSwitch * get_packed_switch()
        {
            return packed_switch;
        }
 
        SparseSwitch * get_sparse_switch()
        {
            return sparse_switch;
        }
 
        void set_packed_switch(PackedSwitch * packed_switch)
        {
            this->packed_switch = packed_switch;
        }
 
        void set_sparse_switch(SparseSwitch * sparse_switch)
        {
            this->sparse_switch = sparse_switch;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAA) + ", " + std::to_string(nBBBBBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAA) + ", " + std::to_string(nBBBBBBBB);
        }
    };
 
    class Instruction31c : public Instruction
    {
        std::uint8_t vAA;
        std::uint32_t iBBBBBBBB;
        std::string str_value;
    public:
        Instruction31c(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_destination() const
        {
            return vAA;
        }
 
        TYPES::Operand get_destination_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint32_t get_string_idx() const
        {
            return iBBBBBBBB;
        }
 
        TYPES::Operand get_string_idx_type() const
        {
            return TYPES::Operand::OFFSET;
        }
 
        const std::string& get_string_value() const
        {
            return str_value;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAA) + ", \"" + str_value + "\" (" + std::to_string(iBBBBBBBB) + ")";
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " v" + 
                    std::to_string(vAA) + ", " + str_value + " (" + std::to_string(iBBBBBBBB) + ")";
        }
    };
    
    class Instruction35c : public Instruction
    {
        std::uint8_t array_size;
        std::uint16_t type_index;
        bool is_type = false;
        bool is_method = false;
        std::string type_str;
        std::vector<std::uint8_t> registers;
        Parser * parser;
    public:
        Instruction35c(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
        
        std::uint8_t get_number_of_registers() const
        {
            return array_size;
        }
 
        const std::vector<std::uint8_t>& get_registers() const
        {
            return registers;
        }
 
        TYPES::Operand get_registers_type()
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::vector<std::uint8_t>& get_registers()
        {
            return registers;
        }
 
        std::uint16_t get_type_idx() const
        {
            return type_index;
        }
 
        TYPES::Operand get_array_type() const
        {
            return TYPES::Operand::KIND;
        }
 
        DVMType * get_dvmtype()
        {
            if (is_type)
                return parser->get_types().get_type_from_order(type_index);
            return nullptr;
        }
 
        MethodID * get_method()
        {
            if (is_method)
                return parser->get_methods().get_method(type_index);
            return nullptr;
        }
        
        virtual std::string print_instruction()
        {
            std::string instruction = DalvikOpcodes::get_instruction_name(op) + " {";
 
            for(const auto reg : registers)
            {
                instruction += "v" + std::to_string(reg) + ", ";
            }
 
            if (registers.size() > 0)
                instruction = instruction.substr(0, instruction.size()-2);
            
            instruction += "}, " + type_str;
 
            return instruction;
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << print_instruction();
        }
    };
 
    class Instruction3rc : public Instruction
    {
        std::uint8_t array_size;
        std::uint16_t index;
        bool is_method = false;
        bool is_type = false;
        std::string index_str;
        std::vector<std::uint16_t> registers;
        Parser * parser;
    public:
        Instruction3rc(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_registers_size() const
        {
            return array_size;
        }
 
        std::uint16_t get_index_value() const
        {
            return index;
        }
 
        TYPES::Operand get_index_type() const
        {
            return TYPES::Operand::KIND;
        }
 
        const std::vector<std::uint16_t>& get_registers() const
        {
            return registers;
        }
 
        std::vector<std::uint16_t>& get_registers()
        {
            return registers;
        }
 
        DVMType * get_operand_dvmtype()
        {
            if (is_type)
                return parser->get_types().get_type_from_order(index);
            return nullptr;
        }
 
        MethodID * get_operand_method()
        {
            if (is_method)
                return parser->get_methods().get_method(index);
            return nullptr;
        }
 
        std::variant<
            DVMType*,
            MethodID*,
            std::uint16_t> get_operand()
        {
            if (is_type)
                return parser->get_types().get_type_from_order(index);
            else if (is_method)
                return parser->get_methods().get_method(index);
            else
                return index;
        }
 
        const std::string& get_operand_str() const
        {
            return index_str;
        }
 
        virtual std::string print_instruction()
        {
            std::string instruction = DalvikOpcodes::get_instruction_name(op) + " {";
 
            for(const auto reg : registers)
            {
                instruction += "v" + std::to_string(reg) + ", ";
            }
 
            if (registers.size() > 0)
                instruction = instruction.substr(0, instruction.size()-2);
            
            instruction += "}, " + index_str;
 
            return instruction;
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << print_instruction();
        }
 
    };
 
    class Instruction45cc : public Instruction
    {
        std::uint8_t reg_count;
        std::vector<std::uint8_t> registers;
        std::uint16_t method_reference;
        MethodID * method_id;
        std::uint16_t prototype_reference;
        ProtoID * proto_id;
    public:
        Instruction45cc(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_number_of_registers() const
        {
            return reg_count;
        }
 
        const std::vector<std::uint8_t>& get_registers() const
        {
            return registers;
        }
 
        std::vector<std::uint8_t>& get_registers()
        {
            return registers;
        }
 
        std::uint16_t get_method_reference() const
        {
            return method_reference;
        }
 
        std::uint16_t get_prototype_reference() const
        {
            return prototype_reference;
        }
 
        MethodID * get_method()
        {
            return method_id;
        }
 
        ProtoID * get_prototype()
        {
            return proto_id;
        }
 
        virtual std::string print_instruction()
        {
            std::string instruction = DalvikOpcodes::get_instruction_name(op) + " {";
 
            for(const auto reg : registers)
            {
                instruction += "v" + std::to_string(reg) + ", ";
            }
 
            if (registers.size() > 0)
                instruction = instruction.substr(0, instruction.size()-2);
            
            instruction += "}, ";
 
            if (method_id)
                instruction += method_id->pretty_method() + ", ";
            if (proto_id)
                instruction += proto_id->get_shorty_idx();
 
            return instruction;
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << print_instruction();
        }
    };
 
    class Instruction4rcc : public Instruction
    {
        std::uint8_t reg_count;
        std::vector<std::uint16_t> registers;
        std::uint16_t method_reference;
        MethodID * method_id;
        std::uint16_t prototype_reference;
        ProtoID * prototype_id;
    public:
        Instruction4rcc(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_number_of_registers() const
        {
            return reg_count;
        }
 
        const std::vector<std::uint16_t>& get_registers() const
        {
            return registers;
        }
 
        std::vector<std::uint16_t>& get_registers()
        {
            return registers;
        }
        
        std::uint16_t get_method_reference() const
        {
            return method_reference;
        }
 
        MethodID * get_method()
        {
            return method_id;
        }
 
        std::uint16_t get_prototype_reference() const
        {
            return prototype_reference;
        }
 
        ProtoID * get_prototype()
        {
            return prototype_id;
        }
 
        virtual std::string print_instruction()
        {
            std::string instruction = DalvikOpcodes::get_instruction_name(op) + " {";
 
            for(const auto reg : registers)
            {
                instruction += "v" + std::to_string(reg) + ", ";
            }
 
            if (registers.size() > 0)
                instruction = instruction.substr(0, instruction.size()-2);
            
            instruction += "}, ";
 
            if (method_id)
                instruction += method_id->pretty_method() + ", ";
            if (prototype_id)
                instruction += prototype_id->get_shorty_idx();
 
            return instruction;
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << print_instruction();
        }
    };
    
    class Instruction51l : public Instruction
    {
        std::uint8_t vAA;
        std::uint8_t vBB;
        std::int64_t nBBBBBBBBBBBBBBBB;
    public:
        Instruction51l(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint8_t get_first_register() const
        {
            return vAA;
        }
 
        TYPES::Operand get_first_register_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::uint8_t get_second_register() const
        {
            return vBB;
        }
 
        TYPES::Operand get_second_register_type() const
        {
            return TYPES::Operand::REGISTER;
        }
 
        std::int64_t get_wide_value() const
        {
            return nBBBBBBBBBBBBBBBB;
        }
 
        TYPES::Operand get_wide_value_type() const
        {
            return TYPES::Operand::LITERAL;
        }
 
        virtual std::string print_instruction()
        {
            return DalvikOpcodes::get_instruction_name(op) + ", {v" + std::to_string(vAA) + 
                    ", v" + std::to_string(vBB) + "}, " + std::to_string(nBBBBBBBBBBBBBBBB);
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + ", {v" + std::to_string(vAA) + 
                    ", v" + std::to_string(vBB) + "}, " + std::to_string(nBBBBBBBBBBBBBBBB);
        }
    };
 
    class PackedSwitch : public Instruction
    {
        std::uint16_t size;
        std::int32_t first_key;
        std::vector<std::int32_t> targets;
    public:
        PackedSwitch(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint16_t get_number_of_targets() const
        {
            return size;
        }
 
        std::int32_t get_first_key() const
        {
            return first_key;
        }
 
        const std::vector<std::int32_t>& get_targets() const
        {
            return targets;
        }
 
        std::vector<std::int32_t>& get_targets()
        {
            return targets;
        }
 
        virtual std::string print_instruction()
        {
            std::stringstream output;
            
            output << DalvikOpcodes::get_instruction_name(op) + " (size)" + 
                std::to_string(size) + " (first/last key)" + std::to_string(first_key) + "[";
 
            for (const auto target : targets)
                output << "0x" << std::hex << target << ",";
            
            if (size > 0)
                output.seekp(-1, output.cur);
            
            output << "]";
            return output.str();
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) + " (size)" + 
                std::to_string(size) + " (first/last key)" + std::to_string(first_key) + "[";
 
            for (const auto target : targets)
                os << "0x" << std::hex << target << ",";
            
            if (size > 0)
                os.seekp(-1, os.cur);
            
            os << "]";
        }
    };
 
    class SparseSwitch : public Instruction
    {
        std::uint16_t size;
        std::vector<std::tuple<std::int32_t, std::int32_t>> keys_targets;
    public:
        SparseSwitch(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
        
        std::uint16_t get_size_of_targets() const
        {
            return size;
        }
 
        const std::vector<std::tuple<std::int32_t, std::int32_t>>& get_keys_targets() const
        {
            return keys_targets;
        }
 
        std::vector<std::tuple<std::int32_t, std::int32_t>>& get_keys_targets()
        {
            return keys_targets;
        }
 
        virtual std::string print_instruction()
        {
            std::stringstream output;
            
            output << DalvikOpcodes::get_instruction_name(op) << " (size)" << size << "[";
 
            for (const auto& key_target : keys_targets)
            {
                auto key = std::get<0>(key_target);
                auto target = std::get<1>(key_target);
 
                if (key < 0)
                    output << "-0x" << std::hex << key << ":";
                else
                    output << "0x" << std::hex << key << ":";
 
                if (target < 0)
                    output << "-0x" << std::hex << target << ":";
                else
                    output << "0x" << std::hex << target << ":";
                
                output << ",";
            }
 
            if (size > 0)
                output.seekp(-1, output.cur);
 
            output << "]";
 
            return output.str();
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << DalvikOpcodes::get_instruction_name(op) << " (size)" << size << "[";
 
            for (const auto& key_target : keys_targets)
            {
                auto key = std::get<0>(key_target);
                auto target = std::get<1>(key_target);
 
                if (key < 0)
                    os << "-0x" << std::hex << key << ":";
                else
                    os << "0x" << std::hex << key << ":";
 
                if (target < 0)
                    os << "-0x" << std::hex << target << ":";
                else
                    os << "0x" << std::hex << target << ":";
            }
 
            if (size > 0)
                os.seekp(-1, os.cur);
 
            os << "]";
        }
    };
 
    class FillArrayData : public Instruction
    {
        std::uint16_t element_width;
        std::uint32_t size;
        std::vector<std::uint8_t> data;
    public:
        FillArrayData(std::vector<uint8_t> &bytecode, std::size_t index, Parser * parser);
 
        std::uint16_t get_element_width() const
        {
            return element_width;
        }
 
        std::uint32_t get_size_of_data() const
        {
            return size;
        }
 
        const std::vector<std::uint8_t>& get_data() const
        {
            return data;
        }
 
        std::vector<std::uint8_t>& get_data()
        {
            return data;
        }
 
        virtual std::string print_instruction()
        {
            std::stringstream output;
 
            output << "(width)" << element_width << " (size)" << size << " [";
 
            for (auto byte : data)
            {
                output << "0x" << std::hex << static_cast<std::uint32_t>(byte) << ",";
            }
 
            if (size > 0)
                output.seekp(-1, output.cur);
 
            output << "]";
 
            return output.str();
        }        
 
        virtual void print_instruction(std::ostream &os)
        {
            os << "(width)" << element_width << " (size)" << size << " [";
 
            for (auto byte : data)
            {
                os << "0x" << std::hex << static_cast<std::uint32_t>(byte) << ",";
            }
 
            if (size > 0)
                os.seekp(-1, os.cur);
 
            os << "]";
        }
    };
 
    class DalvikIncorrectInstruction : public Instruction
    {
    public:
        DalvikIncorrectInstruction(std::vector<uint8_t> &bytecode, std::size_t index, std::uint32_t length)
            : Instruction(bytecode, index, dexinsttype_t::DEX_DALVIKINCORRECT, length)
        {
        }
        
        virtual std::string print_instruction()
        {
            std::stringstream stream;
 
            stream << "DalvikInvalidInstruction [length: " << length << "][Opcodes: ";
 
            for (const auto val : op_codes)
                stream << std::hex << val << " ";
            
            stream.seekp(-1, stream.cur);
 
            stream << "]";
 
            return stream.str();
        }
 
        virtual void print_instruction(std::ostream &os)
        {
            os << "DalvikInvalidInstruction [length: " << length << "][Opcodes: ";
 
            for (const auto val : op_codes)
                os << std::hex << val << " ";
            
            os.seekp(-1, os.cur);
 
            os << "]";
        }
    };
} // namespace DEX
} // namespace KUNAI
 
#endif