/* 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, &param_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, &param_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, &param_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, &param_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, &param_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, &param_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++;

      }