567 lines
20 KiB
TypeScript
567 lines
20 KiB
TypeScript
import type { ManagedDecodeBudget } from "./ManagedDecodeBudget.js";
|
|
import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
|
|
import type {
|
|
ManagedExceptionRegion,
|
|
ManagedInstructionAnchor,
|
|
ParsedInstruction,
|
|
} from "./ManagedMemberInspectorCore.js";
|
|
|
|
const PREFIX_OPCODES = new Set([
|
|
"unaligned.",
|
|
"volatile.",
|
|
"tail.",
|
|
"constrained.",
|
|
"readonly.",
|
|
]);
|
|
|
|
const OPCODES = new Map<
|
|
number,
|
|
{ readonly name: string; readonly operand: string }
|
|
>([
|
|
[0x00, { name: "nop", operand: "none" }],
|
|
[0x01, { name: "break", operand: "none" }],
|
|
[0x02, { name: "ldarg.0", operand: "none" }],
|
|
[0x03, { name: "ldarg.1", operand: "none" }],
|
|
[0x04, { name: "ldarg.2", operand: "none" }],
|
|
[0x05, { name: "ldarg.3", operand: "none" }],
|
|
[0x06, { name: "ldloc.0", operand: "none" }],
|
|
[0x07, { name: "ldloc.1", operand: "none" }],
|
|
[0x08, { name: "ldloc.2", operand: "none" }],
|
|
[0x09, { name: "ldloc.3", operand: "none" }],
|
|
[0x0a, { name: "stloc.0", operand: "none" }],
|
|
[0x0b, { name: "stloc.1", operand: "none" }],
|
|
[0x0c, { name: "stloc.2", operand: "none" }],
|
|
[0x0d, { name: "stloc.3", operand: "none" }],
|
|
[0x0e, { name: "ldarg.s", operand: "short-var" }],
|
|
[0x0f, { name: "ldarga.s", operand: "short-var" }],
|
|
[0x10, { name: "starg.s", operand: "short-var" }],
|
|
[0x11, { name: "ldloc.s", operand: "short-var" }],
|
|
[0x12, { name: "ldloca.s", operand: "short-var" }],
|
|
[0x13, { name: "stloc.s", operand: "short-var" }],
|
|
[0x14, { name: "ldnull", operand: "none" }],
|
|
[0x15, { name: "ldc.i4.m1", operand: "none" }],
|
|
[0x16, { name: "ldc.i4.0", operand: "none" }],
|
|
[0x17, { name: "ldc.i4.1", operand: "none" }],
|
|
[0x18, { name: "ldc.i4.2", operand: "none" }],
|
|
[0x19, { name: "ldc.i4.3", operand: "none" }],
|
|
[0x1a, { name: "ldc.i4.4", operand: "none" }],
|
|
[0x1b, { name: "ldc.i4.5", operand: "none" }],
|
|
[0x1c, { name: "ldc.i4.6", operand: "none" }],
|
|
[0x1d, { name: "ldc.i4.7", operand: "none" }],
|
|
[0x1e, { name: "ldc.i4.8", operand: "none" }],
|
|
[0x1f, { name: "ldc.i4.s", operand: "short-i" }],
|
|
[0x20, { name: "ldc.i4", operand: "i" }],
|
|
[0x21, { name: "ldc.i8", operand: "i8" }],
|
|
[0x22, { name: "ldc.r4", operand: "r4" }],
|
|
[0x23, { name: "ldc.r8", operand: "r8" }],
|
|
[0x25, { name: "dup", operand: "none" }],
|
|
[0x26, { name: "pop", operand: "none" }],
|
|
[0x27, { name: "jmp", operand: "method" }],
|
|
[0x28, { name: "call", operand: "method" }],
|
|
[0x29, { name: "calli", operand: "signature" }],
|
|
[0x2a, { name: "ret", operand: "none" }],
|
|
[0x2b, { name: "br.s", operand: "short-branch" }],
|
|
[0x2c, { name: "brfalse.s", operand: "short-branch" }],
|
|
[0x2d, { name: "brtrue.s", operand: "short-branch" }],
|
|
[0x2e, { name: "beq.s", operand: "short-branch" }],
|
|
[0x2f, { name: "bge.s", operand: "short-branch" }],
|
|
[0x30, { name: "bgt.s", operand: "short-branch" }],
|
|
[0x31, { name: "ble.s", operand: "short-branch" }],
|
|
[0x32, { name: "blt.s", operand: "short-branch" }],
|
|
[0x33, { name: "bne.un.s", operand: "short-branch" }],
|
|
[0x34, { name: "bge.un.s", operand: "short-branch" }],
|
|
[0x35, { name: "bgt.un.s", operand: "short-branch" }],
|
|
[0x36, { name: "ble.un.s", operand: "short-branch" }],
|
|
[0x37, { name: "blt.un.s", operand: "short-branch" }],
|
|
[0x38, { name: "br", operand: "branch" }],
|
|
[0x39, { name: "brfalse", operand: "branch" }],
|
|
[0x3a, { name: "brtrue", operand: "branch" }],
|
|
[0x3b, { name: "beq", operand: "branch" }],
|
|
[0x3c, { name: "bge", operand: "branch" }],
|
|
[0x3d, { name: "bgt", operand: "branch" }],
|
|
[0x3e, { name: "ble", operand: "branch" }],
|
|
[0x3f, { name: "blt", operand: "branch" }],
|
|
[0x40, { name: "bne.un", operand: "branch" }],
|
|
[0x41, { name: "bge.un", operand: "branch" }],
|
|
[0x42, { name: "bgt.un", operand: "branch" }],
|
|
[0x43, { name: "ble.un", operand: "branch" }],
|
|
[0x44, { name: "blt.un", operand: "branch" }],
|
|
[0x45, { name: "switch", operand: "switch" }],
|
|
[0x46, { name: "ldind.i1", operand: "none" }],
|
|
[0x47, { name: "ldind.u1", operand: "none" }],
|
|
[0x48, { name: "ldind.i2", operand: "none" }],
|
|
[0x49, { name: "ldind.u2", operand: "none" }],
|
|
[0x4a, { name: "ldind.i4", operand: "none" }],
|
|
[0x4b, { name: "ldind.u4", operand: "none" }],
|
|
[0x4c, { name: "ldind.i8", operand: "none" }],
|
|
[0x4d, { name: "ldind.i", operand: "none" }],
|
|
[0x4e, { name: "ldind.r4", operand: "none" }],
|
|
[0x4f, { name: "ldind.r8", operand: "none" }],
|
|
[0x50, { name: "ldind.ref", operand: "none" }],
|
|
[0x51, { name: "stind.ref", operand: "none" }],
|
|
[0x52, { name: "stind.i1", operand: "none" }],
|
|
[0x53, { name: "stind.i2", operand: "none" }],
|
|
[0x54, { name: "stind.i4", operand: "none" }],
|
|
[0x55, { name: "stind.i8", operand: "none" }],
|
|
[0x56, { name: "stind.r4", operand: "none" }],
|
|
[0x57, { name: "stind.r8", operand: "none" }],
|
|
[0x58, { name: "add", operand: "none" }],
|
|
[0x59, { name: "sub", operand: "none" }],
|
|
[0x5a, { name: "mul", operand: "none" }],
|
|
[0x5b, { name: "div", operand: "none" }],
|
|
[0x5c, { name: "div.un", operand: "none" }],
|
|
[0x5d, { name: "rem", operand: "none" }],
|
|
[0x5e, { name: "rem.un", operand: "none" }],
|
|
[0x5f, { name: "and", operand: "none" }],
|
|
[0x60, { name: "or", operand: "none" }],
|
|
[0x61, { name: "xor", operand: "none" }],
|
|
[0x62, { name: "shl", operand: "none" }],
|
|
[0x63, { name: "shr", operand: "none" }],
|
|
[0x64, { name: "shr.un", operand: "none" }],
|
|
[0x65, { name: "neg", operand: "none" }],
|
|
[0x66, { name: "not", operand: "none" }],
|
|
[0x67, { name: "conv.i1", operand: "none" }],
|
|
[0x68, { name: "conv.i2", operand: "none" }],
|
|
[0x69, { name: "conv.i4", operand: "none" }],
|
|
[0x6a, { name: "conv.i8", operand: "none" }],
|
|
[0x6b, { name: "conv.r4", operand: "none" }],
|
|
[0x6c, { name: "conv.r8", operand: "none" }],
|
|
[0x6d, { name: "conv.u4", operand: "none" }],
|
|
[0x6e, { name: "conv.u8", operand: "none" }],
|
|
[0x6f, { name: "callvirt", operand: "method" }],
|
|
[0x70, { name: "cpobj", operand: "type" }],
|
|
[0x71, { name: "ldobj", operand: "type" }],
|
|
[0x72, { name: "ldstr", operand: "string" }],
|
|
[0x73, { name: "newobj", operand: "method" }],
|
|
[0x74, { name: "castclass", operand: "type" }],
|
|
[0x75, { name: "isinst", operand: "type" }],
|
|
[0x76, { name: "conv.r.un", operand: "none" }],
|
|
[0x79, { name: "unbox", operand: "type" }],
|
|
[0x7a, { name: "throw", operand: "none" }],
|
|
[0x7b, { name: "ldfld", operand: "field" }],
|
|
[0x7c, { name: "ldflda", operand: "field" }],
|
|
[0x7d, { name: "stfld", operand: "field" }],
|
|
[0x7e, { name: "ldsfld", operand: "field" }],
|
|
[0x7f, { name: "ldsflda", operand: "field" }],
|
|
[0x80, { name: "stsfld", operand: "field" }],
|
|
[0x81, { name: "stobj", operand: "type" }],
|
|
[0x82, { name: "conv.ovf.i1.un", operand: "none" }],
|
|
[0x83, { name: "conv.ovf.i2.un", operand: "none" }],
|
|
[0x84, { name: "conv.ovf.i4.un", operand: "none" }],
|
|
[0x85, { name: "conv.ovf.i8.un", operand: "none" }],
|
|
[0x86, { name: "conv.ovf.u1.un", operand: "none" }],
|
|
[0x87, { name: "conv.ovf.u2.un", operand: "none" }],
|
|
[0x88, { name: "conv.ovf.u4.un", operand: "none" }],
|
|
[0x89, { name: "conv.ovf.u8.un", operand: "none" }],
|
|
[0x8a, { name: "conv.ovf.i.un", operand: "none" }],
|
|
[0x8b, { name: "conv.ovf.u.un", operand: "none" }],
|
|
[0x8c, { name: "box", operand: "type" }],
|
|
[0x8d, { name: "newarr", operand: "type" }],
|
|
[0x8e, { name: "ldlen", operand: "none" }],
|
|
[0x8f, { name: "ldelema", operand: "type" }],
|
|
[0x90, { name: "ldelem.i1", operand: "none" }],
|
|
[0x91, { name: "ldelem.u1", operand: "none" }],
|
|
[0x92, { name: "ldelem.i2", operand: "none" }],
|
|
[0x93, { name: "ldelem.u2", operand: "none" }],
|
|
[0x94, { name: "ldelem.i4", operand: "none" }],
|
|
[0x95, { name: "ldelem.u4", operand: "none" }],
|
|
[0x96, { name: "ldelem.i8", operand: "none" }],
|
|
[0x97, { name: "ldelem.i", operand: "none" }],
|
|
[0x98, { name: "ldelem.r4", operand: "none" }],
|
|
[0x99, { name: "ldelem.r8", operand: "none" }],
|
|
[0x9a, { name: "ldelem.ref", operand: "none" }],
|
|
[0x9b, { name: "stelem.i", operand: "none" }],
|
|
[0x9c, { name: "stelem.i1", operand: "none" }],
|
|
[0x9d, { name: "stelem.i2", operand: "none" }],
|
|
[0x9e, { name: "stelem.i4", operand: "none" }],
|
|
[0x9f, { name: "stelem.i8", operand: "none" }],
|
|
[0xa0, { name: "stelem.r4", operand: "none" }],
|
|
[0xa1, { name: "stelem.r8", operand: "none" }],
|
|
[0xa2, { name: "stelem.ref", operand: "none" }],
|
|
[0xa3, { name: "ldelem", operand: "type" }],
|
|
[0xa4, { name: "stelem", operand: "type" }],
|
|
[0xa5, { name: "unbox.any", operand: "type" }],
|
|
[0xb3, { name: "conv.ovf.i1", operand: "none" }],
|
|
[0xb4, { name: "conv.ovf.u1", operand: "none" }],
|
|
[0xb5, { name: "conv.ovf.i2", operand: "none" }],
|
|
[0xb6, { name: "conv.ovf.u2", operand: "none" }],
|
|
[0xb7, { name: "conv.ovf.i4", operand: "none" }],
|
|
[0xb8, { name: "conv.ovf.u4", operand: "none" }],
|
|
[0xb9, { name: "conv.ovf.i8", operand: "none" }],
|
|
[0xba, { name: "conv.ovf.u8", operand: "none" }],
|
|
[0xc2, { name: "refanyval", operand: "type" }],
|
|
[0xc3, { name: "ckfinite", operand: "none" }],
|
|
[0xc6, { name: "mkrefany", operand: "type" }],
|
|
[0xd0, { name: "ldtoken", operand: "token" }],
|
|
[0xd1, { name: "conv.u2", operand: "none" }],
|
|
[0xd2, { name: "conv.u1", operand: "none" }],
|
|
[0xd3, { name: "conv.i", operand: "none" }],
|
|
[0xd4, { name: "conv.ovf.i", operand: "none" }],
|
|
[0xd5, { name: "conv.ovf.u", operand: "none" }],
|
|
[0xd6, { name: "add.ovf", operand: "none" }],
|
|
[0xd7, { name: "add.ovf.un", operand: "none" }],
|
|
[0xd8, { name: "mul.ovf", operand: "none" }],
|
|
[0xd9, { name: "mul.ovf.un", operand: "none" }],
|
|
[0xda, { name: "sub.ovf", operand: "none" }],
|
|
[0xdb, { name: "sub.ovf.un", operand: "none" }],
|
|
[0xdc, { name: "endfinally", operand: "none" }],
|
|
[0xdd, { name: "leave", operand: "branch" }],
|
|
[0xde, { name: "leave.s", operand: "short-branch" }],
|
|
[0xdf, { name: "stind.i", operand: "none" }],
|
|
[0xe0, { name: "conv.u", operand: "none" }],
|
|
[0xfe00, { name: "arglist", operand: "none" }],
|
|
[0xfe01, { name: "ceq", operand: "none" }],
|
|
[0xfe02, { name: "cgt", operand: "none" }],
|
|
[0xfe03, { name: "cgt.un", operand: "none" }],
|
|
[0xfe04, { name: "clt", operand: "none" }],
|
|
[0xfe05, { name: "clt.un", operand: "none" }],
|
|
[0xfe06, { name: "ldftn", operand: "method" }],
|
|
[0xfe07, { name: "ldvirtftn", operand: "method" }],
|
|
[0xfe09, { name: "ldarg", operand: "var" }],
|
|
[0xfe0a, { name: "ldarga", operand: "var" }],
|
|
[0xfe0b, { name: "starg", operand: "var" }],
|
|
[0xfe0c, { name: "ldloc", operand: "var" }],
|
|
[0xfe0d, { name: "ldloca", operand: "var" }],
|
|
[0xfe0e, { name: "stloc", operand: "var" }],
|
|
[0xfe0f, { name: "localloc", operand: "none" }],
|
|
[0xfe11, { name: "endfilter", operand: "none" }],
|
|
[0xfe12, { name: "unaligned.", operand: "short-i" }],
|
|
[0xfe13, { name: "volatile.", operand: "none" }],
|
|
[0xfe14, { name: "tail.", operand: "none" }],
|
|
[0xfe15, { name: "initobj", operand: "type" }],
|
|
[0xfe16, { name: "constrained.", operand: "type" }],
|
|
[0xfe17, { name: "cpblk", operand: "none" }],
|
|
[0xfe18, { name: "initblk", operand: "none" }],
|
|
[0xfe1a, { name: "rethrow", operand: "none" }],
|
|
[0xfe1c, { name: "sizeof", operand: "type" }],
|
|
[0xfe1d, { name: "refanytype", operand: "none" }],
|
|
[0xfe1e, { name: "readonly.", operand: "none" }],
|
|
]);
|
|
|
|
const tokenKind = (token: string): ManagedInstructionAnchor["operand_kind"] => {
|
|
if (
|
|
token.startsWith("0x06") ||
|
|
token.startsWith("0x0a") ||
|
|
token.startsWith("0x2b")
|
|
)
|
|
return "method";
|
|
if (token.startsWith("0x04")) return "field";
|
|
if (token.startsWith("0x70")) return "string";
|
|
if (token.startsWith("0x11")) return "signature";
|
|
if (
|
|
token.startsWith("0x01") ||
|
|
token.startsWith("0x02") ||
|
|
token.startsWith("0x1b")
|
|
)
|
|
return "type";
|
|
return "token";
|
|
};
|
|
|
|
type OperandResult = {
|
|
readonly next: number;
|
|
readonly anchorKind: ManagedInstructionAnchor["operand_kind"];
|
|
readonly value: string | null;
|
|
};
|
|
|
|
type OperandReader = (il: Buffer, offset: number) => OperandResult;
|
|
|
|
// String(-0) loses a CIL constant's sign in both anchors and normalized hashes.
|
|
const floatingPointOperand = (value: number): string =>
|
|
Object.is(value, -0) ? "-0" : String(value);
|
|
|
|
const FIXED_OPERAND_READERS = new Map<string, OperandReader>([
|
|
[
|
|
"none",
|
|
(_il, offset) => ({ next: offset, anchorKind: "none", value: null }),
|
|
],
|
|
[
|
|
"short-var",
|
|
(il, offset) => ({
|
|
next: offset + 1,
|
|
anchorKind: "variable",
|
|
value: String(il.readUInt8(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"var",
|
|
(il, offset) => ({
|
|
next: offset + 2,
|
|
anchorKind: "variable",
|
|
value: String(il.readUInt16LE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"short-i",
|
|
(il, offset) => ({
|
|
next: offset + 1,
|
|
anchorKind: "constant",
|
|
value: String(il.readInt8(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"i",
|
|
(il, offset) => ({
|
|
next: offset + 4,
|
|
anchorKind: "constant",
|
|
value: String(il.readInt32LE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"i8",
|
|
(il, offset) => ({
|
|
next: offset + 8,
|
|
anchorKind: "constant",
|
|
value: il.readBigInt64LE(offset).toString(),
|
|
}),
|
|
],
|
|
[
|
|
"r4",
|
|
(il, offset) => ({
|
|
next: offset + 4,
|
|
anchorKind: "constant",
|
|
value: floatingPointOperand(il.readFloatLE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"r8",
|
|
(il, offset) => ({
|
|
next: offset + 8,
|
|
anchorKind: "constant",
|
|
value: floatingPointOperand(il.readDoubleLE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"short-branch",
|
|
(il, offset) => ({
|
|
next: offset + 1,
|
|
anchorKind: "branch",
|
|
value: String(offset + 1 + il.readInt8(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"branch",
|
|
(il, offset) => ({
|
|
next: offset + 4,
|
|
anchorKind: "branch",
|
|
value: String(offset + 4 + il.readInt32LE(offset)),
|
|
}),
|
|
],
|
|
]);
|
|
|
|
const TOKEN_OPERAND_KINDS = new Map<
|
|
string,
|
|
ManagedInstructionAnchor["operand_kind"]
|
|
>([
|
|
["method", "method"],
|
|
["field", "field"],
|
|
["type", "type"],
|
|
["string", "string"],
|
|
["signature", "signature"],
|
|
]);
|
|
|
|
const readOperand = (
|
|
il: Buffer,
|
|
offset: number,
|
|
kind: string,
|
|
): OperandResult => {
|
|
const fixed = FIXED_OPERAND_READERS.get(kind);
|
|
if (fixed !== undefined) return fixed(il, offset);
|
|
if (kind === "switch") {
|
|
const count = il.readUInt32LE(offset);
|
|
return {
|
|
next: offset + 4 + count * 4,
|
|
anchorKind: "switch",
|
|
value: String(count),
|
|
};
|
|
}
|
|
const raw = il.readUInt32LE(offset);
|
|
const token = `0x${raw.toString(16).padStart(8, "0")}`;
|
|
const tokenOperandKind = TOKEN_OPERAND_KINDS.get(kind);
|
|
if (tokenOperandKind !== undefined)
|
|
return { next: offset + 4, anchorKind: tokenOperandKind, value: token };
|
|
if (kind === "token")
|
|
return { next: offset + 4, anchorKind: tokenKind(token), value: token };
|
|
return { next: offset, anchorKind: "unknown", value: null };
|
|
};
|
|
|
|
export const decodeInstructions = (
|
|
il: Buffer,
|
|
admitInstruction?: (offset: number) => void,
|
|
): {
|
|
readonly parsed: readonly ParsedInstruction[];
|
|
readonly instructionStarts: readonly number[];
|
|
readonly count: number;
|
|
readonly truncated: number;
|
|
readonly issue: string | null;
|
|
} => {
|
|
const parsed: ParsedInstruction[] = [];
|
|
const instructionStarts: number[] = [];
|
|
let offset = 0;
|
|
let prefixStart: number | null = null;
|
|
let issue: string | null = null;
|
|
try {
|
|
while (offset < il.length) {
|
|
const start = offset;
|
|
const first = il.readUInt8(offset);
|
|
offset += 1;
|
|
const code = first === 0xfe ? 0xfe00 + il.readUInt8(offset++) : first;
|
|
const descriptor = OPCODES.get(code);
|
|
if (descriptor === undefined) {
|
|
issue = `Unsupported CIL opcode 0x${code.toString(16)} at IL offset ${String(start)}`;
|
|
break;
|
|
}
|
|
const operand = readOperand(il, offset, descriptor.operand);
|
|
if (operand.next < offset || operand.next > il.length) {
|
|
issue = `Instruction ${descriptor.name} at IL offset ${String(start)} leaves method body`;
|
|
break;
|
|
}
|
|
// Charge each actual instruction before growing the decoded arrays.
|
|
// A multi-byte operand must not consume a full record per raw IL byte.
|
|
admitInstruction?.(start);
|
|
offset = operand.next;
|
|
if (PREFIX_OPCODES.has(descriptor.name)) {
|
|
prefixStart ??= start;
|
|
} else {
|
|
instructionStarts.push(prefixStart ?? start);
|
|
prefixStart = null;
|
|
}
|
|
parsed.push({
|
|
offset: start,
|
|
opcode: descriptor.name,
|
|
operandKind: operand.anchorKind,
|
|
operand: operand.value,
|
|
});
|
|
}
|
|
} catch (cause: unknown) {
|
|
if (cause instanceof ManagedReaderFailure) throw cause;
|
|
issue =
|
|
cause instanceof Error ? cause.message : "Instruction decode failed";
|
|
}
|
|
const truncated = offset < il.length && issue === null ? 1 : 0;
|
|
return { parsed, instructionStarts, count: parsed.length, truncated, issue };
|
|
};
|
|
|
|
export const parseExceptionRegions = (
|
|
bytes: Buffer,
|
|
offset: number,
|
|
methodEnd: number,
|
|
budget?: ManagedDecodeBudget,
|
|
): ExceptionRegionParseResult => {
|
|
const regions: ManagedExceptionRegion[] = [];
|
|
let sectionOffset = offset;
|
|
let hasMoreSections = true;
|
|
while (hasMoreSections) {
|
|
if (
|
|
!Number.isSafeInteger(sectionOffset) ||
|
|
sectionOffset < 0 ||
|
|
sectionOffset > methodEnd - 4 ||
|
|
sectionOffset > bytes.length - 4
|
|
)
|
|
return malformedExceptionRegions(
|
|
"Exception section header leaves artifact",
|
|
regions,
|
|
);
|
|
|
|
const kind = bytes.readUInt8(sectionOffset);
|
|
if ((kind & 0x3f) !== 1)
|
|
return malformedExceptionRegions(
|
|
`Unsupported method data section kind ${String(kind & 0x3f)}`,
|
|
regions,
|
|
);
|
|
const fat = (kind & 0x40) !== 0;
|
|
const size = fat
|
|
? bytes.readUInt8(sectionOffset + 1) |
|
|
(bytes.readUInt8(sectionOffset + 2) << 8) |
|
|
(bytes.readUInt8(sectionOffset + 3) << 16)
|
|
: bytes.readUInt8(sectionOffset + 1);
|
|
const clauseSize = fat ? 24 : 12;
|
|
if (
|
|
size < 4 ||
|
|
sectionOffset > methodEnd - size ||
|
|
sectionOffset > bytes.length - size
|
|
)
|
|
return malformedExceptionRegions(
|
|
"Exception section size leaves artifact",
|
|
regions,
|
|
);
|
|
if ((size - 4) % clauseSize !== 0)
|
|
return malformedExceptionRegions(
|
|
"Exception section size does not contain whole clauses",
|
|
regions,
|
|
);
|
|
if (
|
|
!fat &&
|
|
(bytes[sectionOffset + 2] !== 0 || bytes[sectionOffset + 3] !== 0)
|
|
)
|
|
return malformedExceptionRegions(
|
|
"Small exception section reserved bytes are nonzero",
|
|
regions,
|
|
);
|
|
|
|
const count = (size - 4) / clauseSize;
|
|
// Accumulates with the method IL bound; the body reserves what it retains.
|
|
budget?.admitTransient(count * 256, sectionOffset);
|
|
for (const region of readExceptionClauses(
|
|
bytes,
|
|
sectionOffset + 4,
|
|
count,
|
|
fat,
|
|
))
|
|
regions.push(region);
|
|
|
|
hasMoreSections = (kind & 0x80) !== 0;
|
|
sectionOffset += size;
|
|
}
|
|
return { status: "complete", regions };
|
|
};
|
|
|
|
export type ExceptionRegionParseResult =
|
|
| {
|
|
readonly status: "complete";
|
|
readonly regions: ManagedExceptionRegion[];
|
|
}
|
|
| {
|
|
readonly status: "malformed";
|
|
readonly regions: ManagedExceptionRegion[];
|
|
readonly issue: string;
|
|
};
|
|
|
|
const malformedExceptionRegions = (
|
|
issue: string,
|
|
regions: ManagedExceptionRegion[] = [],
|
|
): ExceptionRegionParseResult => ({ status: "malformed", regions, issue });
|
|
|
|
const readExceptionClauses = (
|
|
bytes: Buffer,
|
|
start: number,
|
|
count: number,
|
|
fat: boolean,
|
|
): ManagedExceptionRegion[] => {
|
|
const regions: ManagedExceptionRegion[] = [];
|
|
const clauseSize = fat ? 24 : 12;
|
|
for (let index = 0; index < count; index += 1) {
|
|
const clause = start + index * clauseSize;
|
|
const flags = fat ? bytes.readUInt32LE(clause) : bytes.readUInt16LE(clause);
|
|
const extra = bytes.readUInt32LE(clause + (fat ? 20 : 8));
|
|
regions.push({
|
|
flags,
|
|
try_offset: fat
|
|
? bytes.readUInt32LE(clause + 4)
|
|
: bytes.readUInt16LE(clause + 2),
|
|
try_length: fat
|
|
? bytes.readUInt32LE(clause + 8)
|
|
: bytes.readUInt8(clause + 4),
|
|
handler_offset: fat
|
|
? bytes.readUInt32LE(clause + 12)
|
|
: bytes.readUInt16LE(clause + 5),
|
|
handler_length: fat
|
|
? bytes.readUInt32LE(clause + 16)
|
|
: bytes.readUInt8(clause + 7),
|
|
class_token:
|
|
flags === 0 ? `0x${extra.toString(16).padStart(8, "0")}` : null,
|
|
filter_offset: flags === 1 ? extra : null,
|
|
});
|
|
}
|
|
return regions;
|
|
};
|