jsilnet 0.0.0-stage → 0.1.0

package/src/binary/reader.js

@@ -0,0 +1,206 @@
+import { FormatError } from "./errors.js";
+
+export class BinaryReader {
+  constructor(input, { start = 0, length, baseOffset = 0, context } = {}) {
+    const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+    const available = bytes.byteLength - start;
+    const size = length ?? available;
+    if (!Number.isInteger(start) || !Number.isInteger(size) || start < 0 || size < 0 || size > available) {
+      throw new RangeError("Invalid binary reader range");
+    }
+    this.bytes = bytes.subarray(start, start + size);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+    this.baseOffset = baseOffset;
+    this.context = context;
+    this.position = 0;
+  }
+
+  get remaining() {
+    return this.bytes.length - this.position;
+  }
+
+  get absoluteOffset() {
+    return this.baseOffset + this.position;
+  }
+
+  ensure(size) {
+    if (!Number.isInteger(size) || size < 0 || size > this.remaining) {
+      throw new FormatError(`Read of ${size} byte(s) exceeds the available ${this.remaining}`, {
+        offset: this.absoluteOffset,
+        context: this.context
+      });
+    }
+  }
+
+  seek(position) {
+    if (!Number.isInteger(position) || position < 0 || position > this.bytes.length) {
+      throw new FormatError(`Invalid seek position ${position}`, {
+        offset: this.baseOffset + Math.max(0, position || 0),
+        context: this.context
+      });
+    }
+    this.position = position;
+  }
+
+  skip(size) {
+    this.ensure(size);
+    this.position += size;
+  }
+
+  align(alignment) {
+    if (!Number.isInteger(alignment) || alignment < 1 || (alignment & (alignment - 1)) !== 0) {
+      throw new RangeError("Alignment must be a positive power of two");
+    }
+    this.skip((-this.position) & (alignment - 1));
+  }
+
+  u1() {
+    this.ensure(1);
+    return this.view.getUint8(this.position++);
+  }
+
+  i1() {
+    this.ensure(1);
+    return this.view.getInt8(this.position++);
+  }
+
+  u2() {
+    this.ensure(2);
+    const value = this.view.getUint16(this.position, true);
+    this.position += 2;
+    return value;
+  }
+
+  i2() {
+    this.ensure(2);
+    const value = this.view.getInt16(this.position, true);
+    this.position += 2;
+    return value;
+  }
+
+  u4() {
+    this.ensure(4);
+    const value = this.view.getUint32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+
+  i4() {
+    this.ensure(4);
+    const value = this.view.getInt32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+
+  u8() {
+    this.ensure(8);
+    const value = this.view.getBigUint64(this.position, true);
+    this.position += 8;
+    return value;
+  }
+
+  f4() {
+    this.ensure(4);
+    const value = this.view.getFloat32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+
+  f8() {
+    this.ensure(8);
+    const value = this.view.getFloat64(this.position, true);
+    this.position += 8;
+    return value;
+  }
+
+  take(size) {
+    this.ensure(size);
+    const result = this.bytes.subarray(this.position, this.position + size);
+    this.position += size;
+    return result;
+  }
+
+  slice(size, context = this.context) {
+    const start = this.position;
+    this.ensure(size);
+    this.position += size;
+    return new BinaryReader(this.bytes, {
+      start,
+      length: size,
+      baseOffset: this.baseOffset + start,
+      context
+    });
+  }
+}
+
+export function readCompressedUInt(reader) {
+  const first = reader.u1();
+  if ((first & 0x80) === 0) return first;
+  const offset = reader.absoluteOffset - 1;
+  let value;
+  if ((first & 0xc0) === 0x80) {
+    value = ((first & 0x3f) << 8) | reader.u1();
+    if (value < 0x80) {
+      throw new FormatError("Non-canonical compressed unsigned integer", {
+        offset,
+        context: reader.context
+      });
+    }
+    return value;
+  }
+  if ((first & 0xe0) === 0xc0) {
+    value = ((first & 0x1f) * 0x1000000) +
+      (reader.u1() << 16) +
+      (reader.u1() << 8) +
+      reader.u1();
+    if (value < 0x4000) {
+      throw new FormatError("Non-canonical compressed unsigned integer", {
+        offset,
+        context: reader.context
+      });
+    }
+    return value;
+  }
+  throw new FormatError("Invalid compressed unsigned integer prefix", {
+    offset,
+    context: reader.context
+  });
+}
+
+export function readCompressedInt(reader) {
+  const first = reader.u1();
+  let encoded;
+  let signOffset;
+  let width;
+  if ((first & 0x80) === 0) {
+    encoded = first;
+    signOffset = 0x40;
+    width = 1;
+  } else if ((first & 0xc0) === 0x80) {
+    encoded = ((first & 0x3f) << 8) | reader.u1();
+    signOffset = 0x2000;
+    width = 2;
+  } else if ((first & 0xe0) === 0xc0) {
+    encoded = (first & 0x1f) * 0x1000000 +
+      reader.u1() * 0x10000 +
+      reader.u1() * 0x100 +
+      reader.u1();
+    signOffset = 0x10000000;
+    width = 4;
+  } else {
+    throw new FormatError("Invalid compressed signed integer prefix", {
+      offset: reader.absoluteOffset - 1,
+      context: reader.context
+    });
+  }
+  const value = Math.floor(encoded / 2);
+  const signedValue = (encoded & 1) === 0 ? value : value - signOffset;
+  if ((width === 2 && signedValue >= -64 && signedValue <= 63) ||
+      (width === 4 && signedValue >= -0x2000 && signedValue <= 0x1fff)) {
+    throw new FormatError("Non-canonical compressed signed integer", {
+      offset: reader.absoluteOffset - width,
+      context: reader.context
+    });
+  }
+  return signedValue;
+}

package/src/il/body.js

@@ -0,0 +1,165 @@
+import { BinaryReader } from "../binary/reader.js";
+import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
+import { decodeInstructions } from "./instructions.js";
+
+function parseExceptionSection(bytes, fileOffset, sectionRva) {
+  const reader = new BinaryReader(bytes, {
+    start: fileOffset,
+    baseOffset: fileOffset,
+    context: "method data section"
+  });
+  const kind = reader.u1();
+  const fat = (kind & 0x40) !== 0;
+  const moreSections = (kind & 0x80) !== 0;
+  if ((kind & 0x3f) !== 0x01) {
+    throw new UnsupportedFormatError(`Unsupported method data section kind 0x${kind.toString(16)}`, {
+      offset: fileOffset,
+      context: "method body"
+    });
+  }
+  let dataSize;
+  if (fat) {
+    dataSize = reader.u1() | (reader.u1() << 8) | (reader.u1() << 16);
+  } else {
+    dataSize = reader.u1();
+    reader.u2();
+  }
+  const clauseSize = fat ? 24 : 12;
+  if (dataSize < 4 || (dataSize - 4) % clauseSize !== 0 || dataSize > bytes.length - fileOffset) {
+    throw new FormatError("Invalid exception-handler section size", { offset: fileOffset, context: "method body" });
+  }
+  const clauses = [];
+  const clauseReader = new BinaryReader(bytes, {
+    start: fileOffset + 4,
+    length: dataSize - 4,
+    baseOffset: fileOffset + 4,
+    context: "exception clauses"
+  });
+  while (clauseReader.remaining > 0) {
+    if (fat) {
+      const flags = clauseReader.u4();
+      const tryOffset = clauseReader.u4();
+      const tryLength = clauseReader.u4();
+      const handlerOffset = clauseReader.u4();
+      const handlerLength = clauseReader.u4();
+      const classTokenOrFilterOffset = clauseReader.u4();
+      clauses.push({ flags, tryOffset, tryLength, handlerOffset, handlerLength, classTokenOrFilterOffset });
+    } else {
+      const flags = clauseReader.u2();
+      const tryOffset = clauseReader.u2();
+      const tryLength = clauseReader.u1();
+      const handlerOffset = clauseReader.u2();
+      const handlerLength = clauseReader.u1();
+      const classTokenOrFilterOffset = clauseReader.u4();
+      clauses.push({ flags, tryOffset, tryLength, handlerOffset, handlerLength, classTokenOrFilterOffset });
+    }
+  }
+  return {
+    offset: fileOffset,
+    rva: sectionRva,
+    size: dataSize,
+    fat,
+    moreSections,
+    clauses
+  };
+}
+
+export function parseMethodBody(input, fileOffset, methodRva = fileOffset) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (fileOffset < 0 || fileOffset >= bytes.length) {
+    throw new FormatError("Method body offset is outside the file", { offset: fileOffset, context: "method body" });
+  }
+  const first = bytes[fileOffset];
+  let headerSize;
+  let codeSize;
+  let maxStack;
+  let localVarSigToken;
+  let flags;
+  let format;
+  if ((first & 0x03) === 0x02) {
+    format = "tiny";
+    headerSize = 1;
+    codeSize = first >>> 2;
+    maxStack = 8;
+    localVarSigToken = 0;
+    flags = 0x02;
+  } else if ((first & 0x03) === 0x03) {
+    format = "fat";
+    const header = new BinaryReader(bytes, { start: fileOffset, baseOffset: fileOffset, context: "fat method header" });
+    const flagsAndSize = header.u2();
+    const headerDwords = flagsAndSize >>> 12;
+    headerSize = headerDwords * 4;
+    if (headerSize < 12 || fileOffset + headerSize > bytes.length) {
+      throw new FormatError(`Invalid fat method header size ${headerSize}`, { offset: fileOffset, context: "method body" });
+    }
+    flags = flagsAndSize & 0x0fff;
+    maxStack = header.u2();
+    codeSize = header.u4();
+    localVarSigToken = header.u4();
+  } else {
+    throw new FormatError(`Invalid method header format 0x${(first & 0x03).toString(16)}`, {
+      offset: fileOffset,
+      context: "method body"
+    });
+  }
+
+  const codeOffset = fileOffset + headerSize;
+  if (!Number.isSafeInteger(codeSize) || codeOffset + codeSize > bytes.length) {
+    throw new FormatError("Method code exceeds the file", { offset: codeOffset, context: "method body" });
+  }
+  const instructions = decodeInstructions(bytes.subarray(codeOffset, codeOffset + codeSize), {
+    baseOffset: codeOffset
+  });
+  let sections = [];
+  let endOffset = codeOffset + codeSize;
+  const hasSections = format === "fat" && (flags & 0x08) !== 0;
+  if (hasSections) {
+    let sectionRva = (methodRva + headerSize + codeSize + 3) & ~3;
+    let sectionOffset = fileOffset + (sectionRva - methodRva);
+    let more = true;
+    while (more) {
+      if (sectionOffset >= bytes.length) {
+        throw new FormatError("Method data section exceeds the file", { offset: sectionOffset, context: "method body" });
+      }
+      const section = parseExceptionSection(bytes, sectionOffset, sectionRva);
+      sections.push(section);
+      endOffset = sectionOffset + section.size;
+      more = section.moreSections;
+      if (more) {
+        sectionRva = (sectionRva + section.size + 3) & ~3;
+        sectionOffset = fileOffset + (sectionRva - methodRva);
+      }
+    }
+  }
+  for (const section of sections) {
+    for (const clause of section.clauses) {
+      if (clause.tryOffset + clause.tryLength > codeSize ||
+          clause.handlerOffset + clause.handlerLength > codeSize) {
+        throw new FormatError("Exception-handler region exceeds the method code", {
+          offset: section.offset,
+          context: "method body"
+        });
+      }
+      if ((clause.flags & 1) !== 0 && clause.classTokenOrFilterOffset >= codeSize) {
+        throw new FormatError("Exception filter offset exceeds the method code", {
+          offset: section.offset,
+          context: "method body"
+        });
+      }
+    }
+  }
+
+  return {
+    format,
+    flags,
+    maxStack,
+    codeSize,
+    localVarSigToken,
+    headerOffset: fileOffset,
+    headerSize,
+    codeOffset,
+    endOffset,
+    instructions,
+    sections
+  };
+}

package/src/il/instructions.js

@@ -0,0 +1,217 @@
+import { BinaryReader } from "../binary/reader.js";
+import { FormatError } from "../binary/errors.js";
+import { getOpcode } from "./opcodes.js";
+
+const operandReaders = {
+  none: () => undefined,
+  u1: (reader) => reader.u1(),
+  i1: (reader) => reader.i1(),
+  u2: (reader) => reader.u2(),
+  i4: (reader) => reader.i4(),
+  i8: (reader) => reader.u8(),
+  f4: (reader) => reader.f4(),
+  f8: (reader) => reader.f8(),
+  token: (reader) => reader.u4()
+};
+
+export function decodeInstructions(input, { baseOffset = 0, ilOffset = 0 } = {}) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const reader = new BinaryReader(bytes, { baseOffset, context: "CIL instructions" });
+  const instructions = [];
+  while (reader.remaining > 0) {
+    const start = reader.position;
+    const first = reader.u1();
+    const code = first === 0xfe ? 0xfe00 | reader.u1() : first;
+    const opcode = getOpcode(code);
+    if (!opcode) {
+      throw new FormatError(`Unknown CIL opcode 0x${code.toString(16)}`, {
+        offset: baseOffset + start,
+        context: "CIL instructions"
+      });
+    }
+    const operandOffset = baseOffset + reader.position;
+    let operand;
+    let patchOffsets = [];
+    if (opcode.operand === "branch1" || opcode.operand === "branch4") {
+      const displacement = opcode.operand === "branch1" ? reader.i1() : reader.i4();
+      operand = { kind: "branch", targetOffset: reader.position + displacement + ilOffset };
+      patchOffsets = [operandOffset];
+    } else if (opcode.operand === "switch") {
+      const count = reader.u4();
+      if (count > Math.floor(reader.remaining / 4)) {
+        throw new FormatError("Switch target count exceeds remaining method body", {
+          offset: baseOffset + start,
+          context: "CIL switch operand"
+        });
+      }
+      const offsetsStart = reader.position;
+      const displacements = Array.from({ length: count }, () => reader.i4());
+      const base = reader.position + ilOffset;
+      operand = {
+        kind: "switch",
+        targetOffsets: displacements.map((value) => base + value)
+      };
+      patchOffsets = displacements.map((_, index) => baseOffset + offsetsStart + index * 4);
+    } else {
+      const read = operandReaders[opcode.operand];
+      if (!read) throw new FormatError(`Unsupported operand kind ${opcode.operand}`, { offset: baseOffset + start });
+      const value = read(reader);
+      operand = value === undefined ? null : { kind: opcode.operand, value };
+      if (opcode.operand !== "none") patchOffsets = [operandOffset];
+    }
+    instructions.push({
+      opcode,
+      offset: start + ilOffset,
+      size: reader.position - start,
+      opcodeOffset: baseOffset + start,
+      opcodeSize: first === 0xfe ? 2 : 1,
+      operandOffset,
+      patchOffsets,
+      operand
+    });
+  }
+  const boundaries = new Set(instructions.map((instruction) => instruction.offset));
+  for (const instruction of instructions) {
+    const targets = instruction.operand?.kind === "branch"
+      ? [instruction.operand.targetOffset]
+      : instruction.operand?.kind === "switch"
+        ? instruction.operand.targetOffsets
+        : [];
+    for (const target of targets) {
+      if (!boundaries.has(target)) {
+        throw new FormatError(`Branch target IL_${target.toString(16)} is not an instruction boundary`, {
+          offset: instruction.operandOffset,
+          context: "CIL branch operand"
+        });
+      }
+    }
+  }
+  return instructions;
+}
+
+export function encodeOpcode(opcode) {
+  if (!opcode || !Number.isInteger(opcode.code) || opcode.code < 0 || opcode.code > 0xffff) {
+    throw new TypeError("Invalid CIL opcode");
+  }
+  return opcode.code > 0xff
+    ? Uint8Array.from([0xfe, opcode.code & 0xff])
+    : Uint8Array.from([opcode.code]);
+}
+
+export function getInstructionSize(opcode, operand) {
+  const opcodeSize = opcode.code > 0xff ? 2 : 1;
+  const operandSize = {
+    none: 0,
+    u1: 1,
+    i1: 1,
+    u2: 2,
+    i4: 4,
+    i8: 8,
+    f4: 4,
+    f8: 8,
+    token: 4,
+    branch1: 1,
+    branch4: 4,
+    switch: 4 + 4 * (operand?.targetOffsets?.length ?? 0)
+  }[opcode.operand];
+  if (operandSize === undefined) throw new FormatError(`Unsupported operand kind ${opcode.operand}`);
+  return opcodeSize + operandSize;
+}
+
+export function encodeInstruction(instruction) {
+  const opcodeBytes = encodeOpcode(instruction.opcode);
+  let operandBytes = new Uint8Array();
+  if (instruction.operand) {
+    const value = instruction.operand.kind === "branch"
+      ? instruction.operand.targetOffset
+      : instruction.operand.kind === "switch"
+        ? instruction.operand.targetOffsets
+        : instruction.operand.value;
+    operandBytes = encodeOperand(instruction, value);
+    if (instruction.operand.kind === "switch") {
+      const count = new Uint8Array(4);
+      new DataView(count.buffer).setUint32(0, instruction.operand.targetOffsets.length, true);
+      const combined = new Uint8Array(count.length + operandBytes.length);
+      combined.set(count);
+      combined.set(operandBytes, count.length);
+      operandBytes = combined;
+    }
+  }
+  if (opcodeBytes.length + operandBytes.length !== instruction.size) {
+    throw new FormatError("Encoded instruction size does not match the layout");
+  }
+  const result = new Uint8Array(instruction.size);
+  result.set(opcodeBytes);
+  result.set(operandBytes, opcodeBytes.length);
+  return result;
+}
+
+export function formatInstruction(instruction) {
+  const operand = instruction.operand;
+  if (!operand) return `${instruction.opcode.name}`;
+  if (operand.kind === "branch") return `${instruction.opcode.name} IL_${operand.targetOffset.toString(16).padStart(4, "0")}`;
+  if (operand.kind === "switch") {
+    return `${instruction.opcode.name} (${operand.targetOffsets.map((target) => `IL_${target.toString(16).padStart(4, "0")}`).join(", ")})`;
+  }
+  const value = typeof operand.value === "bigint" ? `${operand.value}n` : String(operand.value);
+  return `${instruction.opcode.name} ${value}`;
+}
+
+export function encodeOperand(instruction, value) {
+  const kind = instruction.operand?.kind;
+  const buffer = new ArrayBuffer(instruction.size);
+  const view = new DataView(buffer);
+  if (kind === "branch") {
+    const width = instruction.opcode.operand === "branch1" ? 1 : 4;
+    const displacement = value - (instruction.offset + instruction.size);
+    if (width === 1) {
+      if (!Number.isInteger(displacement) || displacement < -128 || displacement > 127) {
+        throw new RangeError("Branch target does not fit the existing short-branch operand");
+      }
+      view.setInt8(0, displacement);
+      return new Uint8Array(buffer, 0, 1);
+    }
+    if (!Number.isInteger(displacement) || displacement < -0x80000000 || displacement > 0x7fffffff) {
+      throw new RangeError("Branch target does not fit the existing branch operand");
+    }
+    view.setInt32(0, displacement, true);
+    return new Uint8Array(buffer, 0, 4);
+  }
+  if (kind === "switch") {
+    if (!Array.isArray(value) || value.length !== instruction.operand.targetOffsets.length) {
+      throw new RangeError("A fixed-size edit must preserve the switch target count");
+    }
+    const baseOffset = instruction.offset + instruction.size;
+    const result = new Uint8Array(value.length * 4);
+    const switchView = new DataView(result.buffer);
+    value.forEach((target, index) => {
+      const displacement = target - baseOffset;
+      if (!Number.isInteger(target) || displacement < -0x80000000 || displacement > 0x7fffffff) {
+        throw new RangeError("Switch target does not fit its 32-bit displacement");
+      }
+      switchView.setInt32(index * 4, displacement, true);
+    });
+    return result;
+  }
+  const operandInfo = {
+    u1: ["setUint8", 1], i1: ["setInt8", 1], u2: ["setUint16", 2], i4: ["setInt32", 4],
+    i8: ["setBigInt64", 8], f4: ["setFloat32", 4], f8: ["setFloat64", 8], token: ["setUint32", 4]
+  }[kind];
+  if (!operandInfo) throw new TypeError("Instruction does not have a patchable fixed-size operand");
+  const [setter, width] = operandInfo;
+  if (kind === "token" || kind === "u1" || kind === "u2") {
+    const max = width === 1 ? 0xff : width === 2 ? 0xffff : 0xffffffff;
+    if (!Number.isInteger(value) || value < 0 || value > max) throw new RangeError(`Value does not fit ${kind}`);
+  } else if (kind === "i1" && (!Number.isInteger(value) || value < -128 || value > 127)) {
+    throw new RangeError("Value does not fit i1");
+  } else if (kind === "i4" && (!Number.isInteger(value) || value < -0x80000000 || value > 0x7fffffff)) {
+    throw new RangeError("Value does not fit i4");
+  } else if (kind === "i8" && (typeof value !== "bigint" || value < -(1n << 63n) || value > (1n << 63n) - 1n)) {
+    throw new RangeError("Value does not fit i8");
+  } else if ((kind === "f4" || kind === "f8") && typeof value !== "number") {
+    throw new TypeError("Floating-point operands must be numbers");
+  }
+  const result = new Uint8Array(width);
+  new DataView(result.buffer)[setter](0, value, true);
+  return result;
+}

package/src/il/opcodes.js

@@ -0,0 +1,102 @@
+function descriptor(code, name, operand = "none", shortBranch = null, longBranch = null) {
+  return { code, name, operand, shortBranch, longBranch };
+}
+
+const opcodes = new Map();
+const add = (...args) => {
+  const entry = descriptor(...args);
+  opcodes.set(entry.code, entry);
+};
+
+add(0x00, "nop");
+add(0x01, "break");
+for (let i = 0; i < 4; i++) {
+  add(0x02 + i, `ldarg.${i}`);
+  add(0x06 + i, `ldloc.${i}`);
+  add(0x0a + i, `stloc.${i}`);
+}
+add(0x0e, "ldarg.s", "u1");
+add(0x0f, "ldarga.s", "u1");
+add(0x10, "starg.s", "u1");
+add(0x11, "ldloc.s", "u1");
+add(0x12, "ldloca.s", "u1");
+add(0x13, "stloc.s", "u1");
+add(0x14, "ldnull");
+add(0x15, "ldc.i4.m1");
+for (let i = 0; i <= 8; i++) add(0x16 + i, `ldc.i4.${i}`);
+add(0x1f, "ldc.i4.s", "i1");
+add(0x20, "ldc.i4", "i4");
+add(0x21, "ldc.i8", "i8");
+add(0x22, "ldc.r4", "f4");
+add(0x23, "ldc.r8", "f8");
+add(0x25, "dup");
+add(0x26, "pop");
+add(0x27, "jmp", "token");
+add(0x28, "call", "token");
+add(0x29, "calli", "token");
+add(0x2a, "ret");
+
+const branchNames = ["br", "brfalse", "brtrue", "beq", "bge", "bgt", "ble", "blt", "bne.un", "bge.un", "bgt.un", "ble.un", "blt.un"];
+for (let i = 0; i < branchNames.length; i++) {
+  add(0x2b + i, `${branchNames[i]}.s`, "branch1", null, 0x38 + i);
+  add(0x38 + i, branchNames[i], "branch4", 0x2b + i);
+}
+add(0x45, "switch", "switch");
+
+const simpleNames = [
+  "ldind.i1", "ldind.u1", "ldind.i2", "ldind.u2", "ldind.i4", "ldind.u4", "ldind.i8", "ldind.i",
+  "ldind.r4", "ldind.r8", "ldind.ref", "stind.ref", "stind.i1", "stind.i2", "stind.i4", "stind.i8",
+  "stind.r4", "stind.r8", "add", "sub", "mul", "div", "div.un", "rem", "rem.un", "and", "or", "xor",
+  "shl", "shr", "shr.un", "neg", "not", "conv.i1", "conv.i2", "conv.i4", "conv.i8", "conv.r4",
+  "conv.r8", "conv.u4", "conv.u8"
+];
+for (let i = 0; i < simpleNames.length; i++) add(0x46 + i, simpleNames[i]);
+
+[
+  [0x6f, "callvirt", "token"], [0x70, "cpobj", "token"], [0x71, "ldobj", "token"],
+  [0x72, "ldstr", "token"], [0x73, "newobj", "token"], [0x74, "castclass", "token"],
+  [0x75, "isinst", "token"], [0x76, "conv.r.un"], [0x79, "unbox", "token"],
+  [0x7a, "throw"], [0x7b, "ldfld", "token"], [0x7c, "ldflda", "token"],
+  [0x7d, "stfld", "token"], [0x7e, "ldsfld", "token"], [0x7f, "ldsflda", "token"],
+  [0x80, "stsfld", "token"], [0x81, "stobj", "token"], [0x8c, "box", "token"],
+  [0x8d, "newarr", "token"], [0x8e, "ldlen"], [0x8f, "ldelema", "token"],
+  [0xa3, "ldelem", "token"], [0xa4, "stelem", "token"], [0xa5, "unbox.any", "token"],
+  [0xc2, "refanyval", "token"], [0xc3, "ckfinite"], [0xc6, "mkrefany", "token"],
+  [0xd0, "ldtoken", "token"], [0xdc, "endfinally"], [0xdd, "leave", "branch4", 0xde],
+  [0xde, "leave.s", "branch1", null, 0xdd], [0xdf, "stind.i"], [0xe0, "conv.u"]
+].forEach((item) => add(...item));
+
+const conversionNames = [
+  "conv.ovf.i1.un", "conv.ovf.i2.un", "conv.ovf.i4.un", "conv.ovf.i8.un", "conv.ovf.u1.un",
+  "conv.ovf.u2.un", "conv.ovf.u4.un", "conv.ovf.u8.un", "conv.ovf.i.un", "conv.ovf.u.un"
+];
+for (let i = 0; i < conversionNames.length; i++) add(0x82 + i, conversionNames[i]);
+for (let i = 0; i < 11; i++) add(0x90 + i, `ldelem.${["i1", "u1", "i2", "u2", "i4", "u4", "i8", "i", "r4", "r8", "ref"][i]}`);
+for (let i = 0; i < 7; i++) add(0x9b + i, `stelem.${["i", "i1", "i2", "i4", "i8", "r4", "r8"][i]}`);
+add(0xa2, "stelem.ref");
+for (const [code, name] of [
+  [0xb3, "conv.ovf.i1"], [0xb4, "conv.ovf.u1"], [0xb5, "conv.ovf.i2"], [0xb6, "conv.ovf.u2"],
+  [0xb7, "conv.ovf.i4"], [0xb8, "conv.ovf.u4"], [0xb9, "conv.ovf.i8"], [0xba, "conv.ovf.u8"],
+  [0xd1, "conv.i"], [0xd2, "conv.ovf.i"],
+  [0xd3, "conv.ovf.u"], [0xd4, "add.ovf"], [0xd5, "add.ovf.un"], [0xd6, "mul.ovf"],
+  [0xd7, "mul.ovf.un"], [0xd8, "sub.ovf"], [0xd9, "sub.ovf.un"]
+]) add(code, name);
+
+for (const [code, name, operand] of [
+  [0xfe00, "arglist"], [0xfe01, "ceq"], [0xfe02, "cgt"], [0xfe03, "cgt.un"],
+  [0xfe04, "clt"], [0xfe05, "clt.un"], [0xfe06, "ldftn", "token"], [0xfe07, "ldvirtftn", "token"],
+  [0xfe09, "ldarg", "u2"], [0xfe0a, "ldarga", "u2"], [0xfe0b, "starg", "u2"],
+  [0xfe0c, "ldloc", "u2"], [0xfe0d, "ldloca", "u2"], [0xfe0e, "stloc", "u2"],
+  [0xfe0f, "localloc"], [0xfe11, "endfilter"], [0xfe12, "unaligned.", "u1"],
+  [0xfe13, "volatile."], [0xfe14, "tail."], [0xfe15, "initobj", "token"],
+  [0xfe16, "constrained.", "token"], [0xfe17, "cpblk"], [0xfe18, "initblk"],
+  [0xfe1a, "rethrow"], [0xfe1c, "sizeof", "token"], [0xfe1d, "refanytype"], [0xfe1e, "readonly."]
+]) add(code, name, operand ?? "none");
+
+export function getOpcode(code) {
+  return opcodes.get(code) ?? null;
+}
+
+export function listOpcodes() {
+  return [...opcodes.values()];
+}