diff options
Diffstat (limited to 'capstone/arch/WASM/WASMDisassembler.c')
| -rw-r--r-- | capstone/arch/WASM/WASMDisassembler.c | 1009 |
1 files changed, 1009 insertions, 0 deletions
diff --git a/capstone/arch/WASM/WASMDisassembler.c b/capstone/arch/WASM/WASMDisassembler.c new file mode 100644 index 000000000..a05ee0c75 --- /dev/null +++ b/capstone/arch/WASM/WASMDisassembler.c @@ -0,0 +1,1009 @@ +/* Capstone Disassembly Engine */ +/* By Spike, xwings 2019 */ + +#include <string.h> +#include <stddef.h> // offsetof macro +// alternatively #include "../../utils.h" like everyone else + +#include "WASMDisassembler.h" +#include "WASMMapping.h" +#include "../../cs_priv.h" + +static const short opcodes[256] = { + WASM_INS_UNREACHABLE, + WASM_INS_NOP, + WASM_INS_BLOCK, + WASM_INS_LOOP, + WASM_INS_IF, + WASM_INS_ELSE, + -1, + -1, + -1, + -1, + -1, + WASM_INS_END, + WASM_INS_BR, + WASM_INS_BR_IF, + WASM_INS_BR_TABLE, + WASM_INS_RETURN, + WASM_INS_CALL, + WASM_INS_CALL_INDIRECT, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + WASM_INS_DROP, + WASM_INS_SELECT, + -1, + -1, + -1, + -1, + WASM_INS_GET_LOCAL, + WASM_INS_SET_LOCAL, + WASM_INS_TEE_LOCAL, + WASM_INS_GET_GLOBAL, + WASM_INS_SET_GLOBAL, + -1, + -1, + -1, + WASM_INS_I32_LOAD, + WASM_INS_I64_LOAD, + WASM_INS_F32_LOAD, + WASM_INS_F64_LOAD, + WASM_INS_I32_LOAD8_S, + WASM_INS_I32_LOAD8_U, + WASM_INS_I32_LOAD16_S, + WASM_INS_I32_LOAD16_U, + WASM_INS_I64_LOAD8_S, + WASM_INS_I64_LOAD8_U, + WASM_INS_I64_LOAD16_S, + WASM_INS_I64_LOAD16_U, + WASM_INS_I64_LOAD32_S, + WASM_INS_I64_LOAD32_U, + WASM_INS_I32_STORE, + WASM_INS_I64_STORE, + WASM_INS_F32_STORE, + WASM_INS_F64_STORE, + WASM_INS_I32_STORE8, + WASM_INS_I32_STORE16, + WASM_INS_I64_STORE8, + WASM_INS_I64_STORE16, + WASM_INS_I64_STORE32, + WASM_INS_CURRENT_MEMORY, + WASM_INS_GROW_MEMORY, + WASM_INS_I32_CONST, + WASM_INS_I64_CONST, + WASM_INS_F32_CONST, + WASM_INS_F64_CONST, + WASM_INS_I32_EQZ, + WASM_INS_I32_EQ, + WASM_INS_I32_NE, + WASM_INS_I32_LT_S, + WASM_INS_I32_LT_U, + WASM_INS_I32_GT_S, + WASM_INS_I32_GT_U, + WASM_INS_I32_LE_S, + WASM_INS_I32_LE_U, + WASM_INS_I32_GE_S, + WASM_INS_I32_GE_U, + WASM_INS_I64_EQZ, + WASM_INS_I64_EQ, + WASM_INS_I64_NE, + WASM_INS_I64_LT_S, + WASM_INS_I64_LT_U, + WASN_INS_I64_GT_S, + WASM_INS_I64_GT_U, + WASM_INS_I64_LE_S, + WASM_INS_I64_LE_U, + WASM_INS_I64_GE_S, + WASM_INS_I64_GE_U, + WASM_INS_F32_EQ, + WASM_INS_F32_NE, + WASM_INS_F32_LT, + WASM_INS_F32_GT, + WASM_INS_F32_LE, + WASM_INS_F32_GE, + WASM_INS_F64_EQ, + WASM_INS_F64_NE, + WASM_INS_F64_LT, + WASM_INS_F64_GT, + WASM_INS_F64_LE, + WASM_INS_F64_GE, + WASM_INS_I32_CLZ, + WASM_INS_I32_CTZ, + WASM_INS_I32_POPCNT, + WASM_INS_I32_ADD, + WASM_INS_I32_SUB, + WASM_INS_I32_MUL, + WASM_INS_I32_DIV_S, + WASM_INS_I32_DIV_U, + WASM_INS_I32_REM_S, + WASM_INS_I32_REM_U, + WASM_INS_I32_AND, + WASM_INS_I32_OR, + WASM_INS_I32_XOR, + WASM_INS_I32_SHL, + WASM_INS_I32_SHR_S, + WASM_INS_I32_SHR_U, + WASM_INS_I32_ROTL, + WASM_INS_I32_ROTR, + WASM_INS_I64_CLZ, + WASM_INS_I64_CTZ, + WASM_INS_I64_POPCNT, + WASM_INS_I64_ADD, + WASM_INS_I64_SUB, + WASM_INS_I64_MUL, + WASM_INS_I64_DIV_S, + WASM_INS_I64_DIV_U, + WASM_INS_I64_REM_S, + WASM_INS_I64_REM_U, + WASM_INS_I64_AND, + WASM_INS_I64_OR, + WASM_INS_I64_XOR, + WASM_INS_I64_SHL, + WASM_INS_I64_SHR_S, + WASM_INS_I64_SHR_U, + WASM_INS_I64_ROTL, + WASM_INS_I64_ROTR, + WASM_INS_F32_ABS, + WASM_INS_F32_NEG, + WASM_INS_F32_CEIL, + WASM_INS_F32_FLOOR, + WASM_INS_F32_TRUNC, + WASM_INS_F32_NEAREST, + WASM_INS_F32_SQRT, + WASM_INS_F32_ADD, + WASM_INS_F32_SUB, + WASM_INS_F32_MUL, + WASM_INS_F32_DIV, + WASM_INS_F32_MIN, + WASM_INS_F32_MAX, + WASM_INS_F32_COPYSIGN, + WASM_INS_F64_ABS, + WASM_INS_F64_NEG, + WASM_INS_F64_CEIL, + WASM_INS_F64_FLOOR, + WASM_INS_F64_TRUNC, + WASM_INS_F64_NEAREST, + WASM_INS_F64_SQRT, + WASM_INS_F64_ADD, + WASM_INS_F64_SUB, + WASM_INS_F64_MUL, + WASM_INS_F64_DIV, + WASM_INS_F64_MIN, + WASM_INS_F64_MAX, + WASM_INS_F64_COPYSIGN, + WASM_INS_I32_WARP_I64, + WASP_INS_I32_TRUNC_S_F32, + WASM_INS_I32_TRUNC_U_F32, + WASM_INS_I32_TRUNC_S_F64, + WASM_INS_I32_TRUNC_U_F64, + WASM_INS_I64_EXTEND_S_I32, + WASM_INS_I64_EXTEND_U_I32, + WASM_INS_I64_TRUNC_S_F32, + WASM_INS_I64_TRUNC_U_F32, + WASM_INS_I64_TRUNC_S_F64, + WASM_INS_I64_TRUNC_U_F64, + WASM_INS_F32_CONVERT_S_I32, + WASM_INS_F32_CONVERT_U_I32, + WASM_INS_F32_CONVERT_S_I64, + WASM_INS_F32_CONVERT_U_I64, + WASM_INS_F32_DEMOTE_F64, + WASM_INS_F64_CONVERT_S_I32, + WASM_INS_F64_CONVERT_U_I32, + WASM_INS_F64_CONVERT_S_I64, + WASM_INS_F64_CONVERT_U_I64, + WASM_INS_F64_PROMOTE_F32, + WASM_INS_I32_REINTERPRET_F32, + WASM_INS_I64_REINTERPRET_F64, + WASM_INS_F32_REINTERPRET_I32, + WASM_INS_F64_REINTERPRET_I64, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, +}; + +// input | code: code pointer start from varuint32 +// | code_len: real code len count from varint +// | leng: return value, means length of varint. -1 means error +// return | varint +static uint32_t get_varuint32(const uint8_t *code, size_t code_len, size_t *leng) +{ + uint32_t data = 0; + int i; + + for(i = 0;; i++) { + if (code_len < i + 1) { + *leng = -1; + return 0; + } + + + if (i > 4 || (i == 4 && (code[i] & 0x7f) > 0x0f)) { + *leng = -1; + return 0; + } + + data = data + (((uint32_t) code[i] & 0x7f) << (i * 7)); + if (code[i] >> 7 == 0) { + break; + } + } + + *leng = i + 1; + + return data; +} + +// input | code : code pointer start from varuint64 +// | code_len : real code len count from varint +// | leng: return value, means length of varint. -1 means error +// return | varint +static uint64_t get_varuint64(const uint8_t *code, size_t code_len, size_t *leng) +{ + uint64_t data; + int i; + + data = 0; + for(i = 0;; i++){ + if (code_len < i + 1) { + *leng = -1; + return 0; + } + + if (i > 9 || (i == 9 && (code[i] & 0x7f) > 0x01)) { + *leng = -1; + return 0; + } + + data = data + (((uint64_t) code[i] & 0x7f) << (i * 7)); + if (code[i] >> 7 == 0) { + break; + } + } + + *leng = i + 1; + + return data; +} + +// input | code : code pointer start from uint32 +// | dest : the pointer where we store the uint32 +// return | None +static void get_uint32(const uint8_t *code, uint32_t *dest) +{ + memcpy(dest, code, 4); +} + +// input | code : code pointer start from uint32 +// | dest : the pointer where we store the uint64 +// return | None +static void get_uint64(const uint8_t *code, uint64_t *dest) +{ + memcpy(dest, code, 8); +} + +// input | code : code pointer start from varint7 +// | code_len : start from the code pointer to the end, how long is it +// | leng : length of the param , -1 means error +// return | data of varint7 +static int8_t get_varint7(const uint8_t *code, size_t code_len, size_t *leng) +{ + int8_t data; + + if (code_len < 1) { + *leng = -1; + return -1; + } + + *leng = 1; + + if (code[0] == 0x40) { + return -1; + } + + data = code[0] & 0x7f; + + return data; +} + +// input | code : code pointer start from varuint32 +// | code_len : start from the code pointer to the end, how long is it +// | param_size : pointer of the param size +// | MI : Mcinst handler in this round of disasm +// return | true/false if the function successfully finished +static bool read_varuint32(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) +{ + size_t len = 0; + uint32_t data; + + data = get_varuint32(code, code_len, &len); + if (len == -1) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_VARUINT32; + MI->flat_insn->detail->wasm.operands[0].size= len; + MI->flat_insn->detail->wasm.operands[0].varuint32= data; + } + + MI->wasm_data.size = len; + MI->wasm_data.type = WASM_OP_VARUINT32; + MI->wasm_data.uint32 = data; + *param_size = len; + + return true; +} + +// input | code : code pointer start from varuint64 +// | code_len : start from the code pointer to the end, how long is it +// | param_size : pointer of the param size +// | MI : Mcinst handler in this round of disasm +// return | true/false if the function successfully finished +static bool read_varuint64(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) +{ + size_t len = 0; + uint64_t data; + + data = get_varuint64(code, code_len, &len); + if (len == -1) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_VARUINT64; + MI->flat_insn->detail->wasm.operands[0].size = len; + MI->flat_insn->detail->wasm.operands[0].varuint64 = data; + } + + MI->wasm_data.size = len; + MI->wasm_data.type = WASM_OP_VARUINT64; + MI->wasm_data.uint64 = data; + *param_size = len; + + return true; +} + +// input | code : code pointer start from memoryimmediate +// | code_len : start from the code pointer to the end, how long is it +// | param_size : pointer of the param size (sum of two params) +// | MI : Mcinst handler in this round of disasm +// return | true/false if the function successfully finished +static bool read_memoryimmediate(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) +{ + size_t tmp, len = 0; + uint32_t data[2]; + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 2; + } + + data[0] = get_varuint32(code, code_len, &tmp); + if (tmp == -1) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_VARUINT32; + MI->flat_insn->detail->wasm.operands[0].size = tmp; + MI->flat_insn->detail->wasm.operands[0].varuint32 = data[0]; + } + + len = tmp; + data[1] = get_varuint32(&code[len], code_len - len, &tmp); + if (len == -1) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.operands[1].type = WASM_OP_VARUINT32; + MI->flat_insn->detail->wasm.operands[1].size = tmp; + MI->flat_insn->detail->wasm.operands[1].varuint32 = data[1]; + } + + len += tmp; + MI->wasm_data.size = len; + MI->wasm_data.type = WASM_OP_IMM; + MI->wasm_data.immediate[0] = data[0]; + MI->wasm_data.immediate[1] = data[1]; + *param_size = len; + + return true; +} + +// input | code : code pointer start from uint32 +// | code_len : start from the code pointer to the end, how long is it +// | param_size : pointer of the param size +// | MI : Mcinst handler in this round of disasm +// return | true/false if the function successfully finished +static bool read_uint32(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) +{ + if (code_len < 4) { + return false; + } + + get_uint32(code, &(MI->wasm_data.uint32)); + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_UINT32; + MI->flat_insn->detail->wasm.operands[0].size = 4; + get_uint32(code, &(MI->flat_insn->detail->wasm.operands[0].uint32)); + } + + MI->wasm_data.size = 4; + MI->wasm_data.type = WASM_OP_UINT32; + *param_size = 4; + + return true; +} + +// input | code : code pointer start from uint64 +// | code_len : start from the code pointer to the end, how long is it +// | param_size : pointer of the param size +// | MI : Mcinst handler in this round of disasm +// return | true/false if the function successfully finished +static bool read_uint64(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) +{ + if (code_len < 8) { + return false; + } + + get_uint64(code, &(MI->wasm_data.uint64)); + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_UINT64; + MI->flat_insn->detail->wasm.operands[0].size = 8; + get_uint64(code, &(MI->flat_insn->detail->wasm.operands[0].uint64)); + } + + MI->wasm_data.size = 8; + MI->wasm_data.type = WASM_OP_UINT64; + *param_size = 8; + + return true; +} + +// input | code : code pointer start from brtable +// | code_len : start from the code pointer to the end, how long is it +// | param_size : pointer of the param size (sum of all param) +// | MI : Mcinst handler in this round of disasm +// return | true/false if the function successfully finished +static bool read_brtable(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) +{ + uint32_t length, default_target; + int tmp_len = 0, i; + size_t var_len; + + // read length + length = get_varuint32(code, code_len, &var_len); + if (var_len == -1) { + return false; + } + + tmp_len += var_len; + MI->wasm_data.brtable.length = length; + if (length >= UINT32_MAX - tmp_len) { + // integer overflow check + return false; + } + if (code_len < tmp_len + length) { + // safety check that we have minimum enough data to read + return false; + } + // base address + 1 byte opcode + tmp_len for number of cases = start of targets + MI->wasm_data.brtable.address = MI->address + 1 + tmp_len; + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_BRTABLE; + MI->flat_insn->detail->wasm.operands[0].brtable.length = MI->wasm_data.brtable.length; + MI->flat_insn->detail->wasm.operands[0].brtable.address = MI->wasm_data.brtable.address; + } + + // read data + for(i = 0; i < length; i++){ + if (code_len < tmp_len) { + return false; + } + + get_varuint32(code + tmp_len, code_len - tmp_len, &var_len); + if (var_len == -1) { + return false; + } + + tmp_len += var_len; + } + + // read default target + default_target = get_varuint32(code + tmp_len, code_len - tmp_len, &var_len); + if (var_len == -1) { + return false; + } + + MI->wasm_data.brtable.default_target = default_target; + MI->wasm_data.type = WASM_OP_BRTABLE; + *param_size = tmp_len + var_len; + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.operands[0].size = *param_size; + MI->flat_insn->detail->wasm.operands[0].brtable.default_target = MI->wasm_data.brtable.default_target; + } + + return true; +} + +// input | code : code pointer start from varint7 +// | code_len : start from the code pointer to the end, how long is it +// | param_size : pointer of the param size +// | MI : Mcinst handler in this round of disasm +// return | true/false if the function successfully finished +static bool read_varint7(const uint8_t *code, size_t code_len, uint16_t *param_size, MCInst *MI) +{ + size_t len = 0; + + MI->wasm_data.type = WASM_OP_INT7; + MI->wasm_data.int7 = get_varint7(code, code_len, &len); + if (len == -1) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->wasm.operands[0].type = WASM_OP_INT7; + MI->flat_insn->detail->wasm.operands[0].size = 1; + MI->flat_insn->detail->wasm.operands[0].int7 = MI->wasm_data.int7; + } + + *param_size = len; + + return true; +} + +bool WASM_getInstruction(csh ud, const uint8_t *code, size_t code_len, + MCInst *MI, uint16_t *size, uint64_t address, void *inst_info) +{ + unsigned char opcode; + uint16_t param_size; + + if (code_len == 0) + return false; + + opcode = code[0]; + if (opcodes[opcode] == -1) { + // invalid opcode + return false; + } + + // valid opcode + MI->address = address; + MI->OpcodePub = MI->Opcode = opcode; + + if (MI->flat_insn->detail) { + memset(MI->flat_insn->detail, 0, offsetof(cs_detail, wasm)+sizeof(cs_wasm)); + WASM_get_insn_id((cs_struct *)ud, MI->flat_insn, opcode); + } + + // setup groups + switch(opcode) { + default: + return false; + + case WASM_INS_I32_CONST: + if (code_len == 1 || !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_I64_CONST: + if (code_len == 1 || !read_varuint64(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_F32_CONST: + if (code_len == 1 || !read_uint32(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_F64_CONST: + if (code_len == 1 || !read_uint64(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_I32_EQZ: + case WASM_INS_I32_EQ: + case WASM_INS_I32_NE: + case WASM_INS_I32_LT_S: + case WASM_INS_I32_LT_U: + case WASM_INS_I32_GT_S: + case WASM_INS_I32_GT_U: + case WASM_INS_I32_LE_S: + case WASM_INS_I32_LE_U: + case WASM_INS_I32_GE_S: + case WASM_INS_I32_GE_U: + case WASM_INS_I64_EQZ: + case WASM_INS_I64_EQ: + case WASM_INS_I64_NE: + case WASM_INS_I64_LT_S: + case WASM_INS_I64_LT_U: + case WASN_INS_I64_GT_S: + case WASM_INS_I64_GT_U: + case WASM_INS_I64_LE_S: + case WASM_INS_I64_LE_U: + case WASM_INS_I64_GE_S: + case WASM_INS_I64_GE_U: + case WASM_INS_F32_EQ: + case WASM_INS_F32_NE: + case WASM_INS_F32_LT: + case WASM_INS_F32_GT: + case WASM_INS_F32_LE: + case WASM_INS_F32_GE: + case WASM_INS_F64_EQ: + case WASM_INS_F64_NE: + case WASM_INS_F64_LT: + case WASM_INS_F64_GT: + case WASM_INS_F64_LE: + case WASM_INS_F64_GE: + case WASM_INS_I32_CLZ: + case WASM_INS_I32_CTZ: + case WASM_INS_I32_POPCNT: + case WASM_INS_I32_ADD: + case WASM_INS_I32_SUB: + case WASM_INS_I32_MUL: + case WASM_INS_I32_DIV_S: + case WASM_INS_I32_DIV_U: + case WASM_INS_I32_REM_S: + case WASM_INS_I32_REM_U: + case WASM_INS_I32_AND: + case WASM_INS_I32_OR: + case WASM_INS_I32_XOR: + case WASM_INS_I32_SHL: + case WASM_INS_I32_SHR_S: + case WASM_INS_I32_SHR_U: + case WASM_INS_I32_ROTL: + case WASM_INS_I32_ROTR: + case WASM_INS_I64_CLZ: + case WASM_INS_I64_CTZ: + case WASM_INS_I64_POPCNT: + case WASM_INS_I64_ADD: + case WASM_INS_I64_SUB: + case WASM_INS_I64_MUL: + case WASM_INS_I64_DIV_S: + case WASM_INS_I64_DIV_U: + case WASM_INS_I64_REM_S: + case WASM_INS_I64_REM_U: + case WASM_INS_I64_AND: + case WASM_INS_I64_OR: + case WASM_INS_I64_XOR: + case WASM_INS_I64_SHL: + case WASM_INS_I64_SHR_S: + case WASM_INS_I64_SHR_U: + case WASM_INS_I64_ROTL: + case WASM_INS_I64_ROTR: + case WASM_INS_F32_ABS: + case WASM_INS_F32_NEG: + case WASM_INS_F32_CEIL: + case WASM_INS_F32_FLOOR: + case WASM_INS_F32_TRUNC: + case WASM_INS_F32_NEAREST: + case WASM_INS_F32_SQRT: + case WASM_INS_F32_ADD: + case WASM_INS_F32_SUB: + case WASM_INS_F32_MUL: + case WASM_INS_F32_DIV: + case WASM_INS_F32_MIN: + case WASM_INS_F32_MAX: + case WASM_INS_F32_COPYSIGN: + case WASM_INS_F64_ABS: + case WASM_INS_F64_NEG: + case WASM_INS_F64_CEIL: + case WASM_INS_F64_FLOOR: + case WASM_INS_F64_TRUNC: + case WASM_INS_F64_NEAREST: + case WASM_INS_F64_SQRT: + case WASM_INS_F64_ADD: + case WASM_INS_F64_SUB: + case WASM_INS_F64_MUL: + case WASM_INS_F64_DIV: + case WASM_INS_F64_MIN: + case WASM_INS_F64_MAX: + case WASM_INS_F64_COPYSIGN: + case WASM_INS_I32_WARP_I64: + case WASP_INS_I32_TRUNC_S_F32: + case WASM_INS_I32_TRUNC_U_F32: + case WASM_INS_I32_TRUNC_S_F64: + case WASM_INS_I32_TRUNC_U_F64: + case WASM_INS_I64_EXTEND_S_I32: + case WASM_INS_I64_EXTEND_U_I32: + case WASM_INS_I64_TRUNC_S_F32: + case WASM_INS_I64_TRUNC_U_F32: + case WASM_INS_I64_TRUNC_S_F64: + case WASM_INS_I64_TRUNC_U_F64: + case WASM_INS_F32_CONVERT_S_I32: + case WASM_INS_F32_CONVERT_U_I32: + case WASM_INS_F32_CONVERT_S_I64: + case WASM_INS_F32_CONVERT_U_I64: + case WASM_INS_F32_DEMOTE_F64: + case WASM_INS_F64_CONVERT_S_I32: + case WASM_INS_F64_CONVERT_U_I32: + case WASM_INS_F64_CONVERT_S_I64: + case WASM_INS_F64_CONVERT_U_I64: + case WASM_INS_F64_PROMOTE_F32: + case WASM_INS_I32_REINTERPRET_F32: + case WASM_INS_I64_REINTERPRET_F64: + case WASM_INS_F32_REINTERPRET_I32: + case WASM_INS_F64_REINTERPRET_I64: + MI->wasm_data.type = WASM_OP_NONE; + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 0; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_NUMBERIC; + MI->flat_insn->detail->groups_count++; + } + + *size = 1; + + break; + + case WASM_INS_DROP: + case WASM_INS_SELECT: + MI->wasm_data.type = WASM_OP_NONE; + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 0; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_PARAMETRIC; + MI->flat_insn->detail->groups_count++; + } + + *size = 1; + + break; + + case WASM_INS_GET_LOCAL: + case WASM_INS_SET_LOCAL: + case WASM_INS_TEE_LOCAL: + case WASM_INS_GET_GLOBAL: + case WASM_INS_SET_GLOBAL: + if (code_len == 1 || !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_VARIABLE; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_I32_LOAD: + case WASM_INS_I64_LOAD: + case WASM_INS_F32_LOAD: + case WASM_INS_F64_LOAD: + case WASM_INS_I32_LOAD8_S: + case WASM_INS_I32_LOAD8_U: + case WASM_INS_I32_LOAD16_S: + case WASM_INS_I32_LOAD16_U: + case WASM_INS_I64_LOAD8_S: + case WASM_INS_I64_LOAD8_U: + case WASM_INS_I64_LOAD16_S: + case WASM_INS_I64_LOAD16_U: + case WASM_INS_I64_LOAD32_S: + case WASM_INS_I64_LOAD32_U: + case WASM_INS_I32_STORE: + case WASM_INS_I64_STORE: + case WASM_INS_F32_STORE: + case WASM_INS_F64_STORE: + case WASM_INS_I32_STORE8: + case WASM_INS_I32_STORE16: + case WASM_INS_I64_STORE8: + case WASM_INS_I64_STORE16: + case WASM_INS_I64_STORE32: + if (code_len == 1 || !read_memoryimmediate(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 2; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_MEMORY; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_CURRENT_MEMORY: + case WASM_INS_GROW_MEMORY: + MI->wasm_data.type = WASM_OP_NONE; + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 0; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_MEMORY; + MI->flat_insn->detail->groups_count++; + } + + *size = 1; + + break; + + case WASM_INS_UNREACHABLE: + case WASM_INS_NOP: + case WASM_INS_ELSE: + case WASM_INS_END: + case WASM_INS_RETURN: + MI->wasm_data.type = WASM_OP_NONE; + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 0; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; + MI->flat_insn->detail->groups_count++; + } + + *size = 1; + + break; + + case WASM_INS_BLOCK: + case WASM_INS_LOOP: + case WASM_INS_IF: + if (code_len == 1 || !read_varint7(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_BR: + case WASM_INS_BR_IF: + case WASM_INS_CALL: + case WASM_INS_CALL_INDIRECT: + if (code_len == 1 || !read_varuint32(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + + case WASM_INS_BR_TABLE: + if (code_len == 1 || !read_brtable(&code[1], code_len - 1, ¶m_size, MI)) { + return false; + } + + if (MI->flat_insn->detail) { + MI->flat_insn->detail->wasm.op_count = 1; + MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = WASM_GRP_CONTROL; + MI->flat_insn->detail->groups_count++; + } + + *size = param_size + 1; + + break; + } + + return true; +} |