cil_dis.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2022 wingdeans <wingdeans@protonmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <rz_types.h>
#include <rz_asm.h>
#include <rz_endian.h>
#include <rz_util/rz_strbuf.h>
#include "cil_dis.h"
 
// Generate generic parameter types
#define DEF_READ_GENERIC(bytes, readtype, fmt) \
    static int read_generic##readtype(int *pos, CILOp *op, const ut8 *buf, int len) { \
        if (*pos + bytes > len) { \
            return -1; \
        } \
        rz_strbuf_appendf(&op->strbuf, fmt, rz_read_at_le##readtype(buf, *pos)); \
        *pos += bytes; \
        return 0; \
    }
 
DEF_READ_GENERIC(1, 8, " 0x%X")
DEF_READ_GENERIC(2, 16, " 0x%X")
DEF_READ_GENERIC(4, 32, " 0x%X")
DEF_READ_GENERIC(8, 64, " 0x%llX")
 
DEF_READ_GENERIC(4, _float, " %f")
DEF_READ_GENERIC(8, _double, " %f")
 
static int read_InlineNone(int *pos, CILOp *op, const ut8 *buf, int len) {
    return 0;
}
 
#define read_ShortInlineVar read_generic8
#define read_ShortInlineI   read_generic8
 
#define read_InlineVar read_generic16
 
#define read_InlineI      read_generic32
#define read_InlineSig    read_generic32
#define read_InlineType   read_generic32
#define read_InlineField  read_generic32
#define read_InlineString read_generic32
#define read_InlineTok    read_generic32
 
#define read_InlineI8 read_generic64
 
#define read_ShortInlineR read_generic_float
#define read_InlineR      read_generic_double
 
// Special
static int read_InlineMethod(int *pos, CILOp *op, const ut8 *buf, int len) {
    if (*pos + sizeof(ut32) > len) {
        return -1;
    }
    ut32 tok = rz_read_at_le32(buf, *pos);
    rz_strbuf_appendf(&op->strbuf, " 0x%X", tok);
    op->tok = tok;
    *pos += sizeof(ut32);
    return 0;
}
 
static int read_InlineBrTarget(int *pos, CILOp *op, const ut8 *buf, int len) {
    if (*pos + sizeof(st32) > len) {
        return -1;
    }
    st32 target = rz_read_at_le32(buf, *pos);
    rz_strbuf_appendf(&op->strbuf, " %d", target);
    op->target = target;
    *pos += sizeof(st32);
    return 0;
}
 
static int read_ShortInlineBrTarget(int *pos, CILOp *op, const ut8 *buf, int len) {
    if (*pos + sizeof(st8) > len) {
        return -1;
    }
    st8 target = rz_read_at_le8(buf, *pos);
    rz_strbuf_appendf(&op->strbuf, " %hhd", target);
    op->target = target;
    *pos += sizeof(st8);
    return 0;
}
 
static int read_InlineSwitch(int *pos, CILOp *op, const ut8 *buf, int len) {
    if (*pos + sizeof(ut32) > len) {
        return -1;
    }
 
    ut32 count = rz_read_le32(buf);
    *pos += sizeof(ut32);
    if (*pos + count * 4 > len) {
        return -1;
    }
    *pos += count * 4;
    return 0;
}
 
typedef struct {
    char *str;
    int (*read_param)(int *pos, CILOp *op, const ut8 *buf, int len);
    bool prefix;
} CILOpcodeReader;
 
#define OPCODE_SINGLE(name, string, param, byte, control) [name] = { .str = string, .read_param = read_##param },
static const CILOpcodeReader opcode_readers_single[] = {
#include "opcodes_single.def"
    [0xFF] = { 0 }
};
 
#define OPCODE_DOUBLE(name, string, param, byte, control) [name] = { .str = string, .read_param = read_##param },
#define OPCODE_PREFIX(name, string, param, byte, control) [name] = { \
    .prefix = true, \
    .str = string, \
    .read_param = read_##param \
},
static const CILOpcodeReader opcode_readers_double[] = {
#include "opcodes_double.def"
#include "opcodes_prefix.def"
    [0xFF] = { 0 }
};
 
int cil_dis(CILOp *op, const ut8 *buf, int len) {
    int pos = 0;
    if (pos >= len) { // pos + 1 > len
        return -1;
    }
 
    ut8 byte;
    rz_strbuf_init(&op->strbuf);
 
start: // Taken after a prefix opcode has been consumed
    byte = buf[pos++];
 
    CILOpcodeReader opcode_reader;
    if (byte != 0xFE) { // Single-byte
        op->byte1 = byte;
        opcode_reader = opcode_readers_single[byte];
    } else { // Double-byte
        if (pos >= len) { // pos + 1 > len
            return -1; // OOB
        }
 
        op->byte1 = byte;
        op->byte2 = byte = buf[pos++];
        opcode_reader = opcode_readers_double[byte];
    }
 
    if (!opcode_reader.str) {
        return -1; // Invalid
    }
 
    // Mnemonic
    if (!rz_strbuf_append(&op->strbuf, opcode_reader.str)) {
        return -1;
    }
 
    // Dispatch based on opcode `param`
    if (opcode_reader.read_param(&pos, op, buf, len)) {
        return -1;
    }
 
    if (opcode_reader.prefix) {
        if (!rz_strbuf_append(&op->strbuf, " ")) { // extra space
            return -1;
        }
        goto start; // continue
    }
 
    op->size = pos;
    return 0;
}