Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
import { expect, it } from "vitest";
import { readPtxKernels, readPtxTarget } from "./PtxKernels.js";
it("recognizes directives outside comments and strings and preserves UTF-8 byte coordinates", () => {
expect(readPtxTarget('".version 8.8\n.target sm_80\n"')).toBeNull();
const prefix = "// 雪 .entry fake() {}\n.version 8.8\n.target sm_80\n";
const text =
prefix + ".visible .entry real(.param .u64 x) { .reg .b32 %r<3>; ret; }";
expect(readPtxTarget(text)).toBe("sm_80");
const rows = [...readPtxKernels(text, "object")];
expect(rows).toHaveLength(1);
expect(rows[0]!.coverage).toBe("complete");
expect(rows[0]!.kernel.location.offset).toBe(
Buffer.byteLength(prefix + ".visible "),
);
expect(rows[0]!.kernel.registers.virtual).toEqual([
{ type: ".b32", count: 3 },
]);
});
it("derives vector/array and pointer parameters while preserving their names", () => {
const rows = [
...readPtxKernels(
".entry k(.param .v2 .u32 x, .param .align 16 .b8 a[32], .param .u64 .ptr .global y) {ret;}",
"object",
),
];
expect(
rows[0]!.kernel.parameters.map(({ offset, size }) => [offset, size]),
).toEqual([
[0, 8],
[16, 32],
[48, 8],
]);
expect(rows[0]!.kernel.parameters[2]!.name).toBe("y");
expect(rows[0]!.kernel.parameter_bytes).toBe(56);
expect(rows[0]!.coverage).toBe("complete");
expect(rows[0]!.kernel.parameter_count).toBe(3);
});
it("retains a parameter name when a qualifier is unknown", () => {
const [row] = [
...readPtxKernels(
".entry k(.param .u64 .vendor_specific value) { ret; }",
"object",
),
];
expect(row!.kernel.parameters).toEqual([
expect.objectContaining({ name: "value", size: null, offset: null }),
]);
expect(row!.coverage).toBe("partial");
});
it("keeps external declarations bodyless and resource values unknown", () => {
const [row] = [
...readPtxKernels(".extern .entry k(.param .u32 input);", "object"),
];
expect(row!.kernel.parameter_count).toBe(1);
expect(row!.kernel.shared_bytes).toBeNull();
expect(row!.coverage).toBe("partial");
});
it.each([".ptr .global .align 4", ".ptr .align 1", ".ptr.global.align 4"])(
"parses PTX pointer qualifiers %s without treating pointee alignment as parameter alignment",
(qualifiers) => {
const [row] = [
...readPtxKernels(
`.entry k(.param .u64 ${qualifiers} ptr_arg) { ret; }`,
"object",
),
];
expect(row!.kernel.parameters).toEqual([
expect.objectContaining({ name: "ptr_arg", offset: 0, size: 8 }),
]);
expect(row!.kernel.parameter_bytes).toBe(8);
expect(row!.coverage).toBe("complete");
},
);
it("preserves pointer names but withholds layout for unknown pointer qualifiers", () => {
const [row] = [
...readPtxKernels(
".entry k(.param .u64 .ptr .mystery .align 4 ptr_arg) { ret; }",
"object",
),
];
expect(row!.kernel.parameters).toEqual([
expect.objectContaining({ name: "ptr_arg", offset: null, size: null }),
]);
expect(row!.coverage).toBe("partial");
});
it("does not mistake an unsupported array extent identifier for the parameter name", () => {
const [row] = [
...readPtxKernels(".entry k(.param .b32 values[index]) { ret; }", "object"),
];
expect(row!.kernel.parameters).toEqual([
expect.objectContaining({ name: "values", offset: null, size: null }),
]);
expect(row!.coverage).toBe("partial");
});
it("excludes call-prototype formals from entry virtual register counts", () => {
const [row] = [
...readPtxKernels(
".entry k() { .reg .b32 %r<4>; F: .callprototype _ (.reg .b32 _); ret; }",
"object",
),
];
expect(row!.kernel.registers.virtual).toEqual([{ type: ".b32", count: 4 }]);
expect(row!.coverage).toBe("complete");
});
it("keeps dynamic and compound shared declarations unknown", () => {
const [row] = [
...readPtxKernels(
".entry k() {.shared .u32 a,b; .shared .b8 dynamic[]; ret;}",
"object",
),
];
expect(row!.kernel.shared_bytes).toBeNull();
expect(row!.coverage).toBe("partial");
expect(row!.kernel.representation).toBe("ptx-declarations");
});
it("sums bare names and every register range while preserving unsupported totals as unknown", () => {
const [row] = [
...readPtxKernels(
".entry k() { .reg .b32 r0, r1; .reg .b32 %r<4>, %s<8>; .reg .u32 %x; .reg .u32 unsupported[2]; .reg .u32 %y; .reg .pred p, %p<2>; ret; }",
"object",
),
];
expect(row!.kernel.registers.virtual).toEqual([
{ type: ".b32", count: 14 },
{ type: ".u32", count: null },
{ type: ".pred", count: 3 },
]);
expect(row!.kernel.limitations.join(" ")).toContain("count unknown");
});
it("does not round overflowing register totals or accept truncated ranges", () => {
for (const declaration of [
"%r<9007199254740991>, %s",
"%r<4",
"%r<2><3>",
"%r<0>",
"%r,",
]) {
const [row] = [
...readPtxKernels(
`.entry k() { .reg .b32 ${declaration}; ret; }`,
"object",
),
];
expect(row!.kernel.registers.virtual).toEqual([
{ type: ".b32", count: null },
]);
}
});
it("retains overlong unsupported register type prefixes within the PTX text", () => {
const [row] = [
...readPtxKernels(".entry k() { .reg .v2 .u32 .extra %r; ret; }", "object"),
];
expect(row!.kernel.registers.virtual).toEqual([
{ type: ".v2 .u32 .extra", count: null },
]);
expect(row!.coverage).toBe("partial");
});
it.each([
"/* unfinished",
".entry broken(",
".entry k",
".entry k ) { ret; }",
".entry k() {",
".entry k() .pragma; { ret; }",
".entry k() {.reg .u32 %x}",
".entry k() {.reg %x;}",
])("rejects incomplete PTX %s", (text) => {
expect(() => [...readPtxKernels(text, "object")]).toThrow();
});
it("does not label unrelated malformed quoted text as a recognized PTX artifact", () => {
expect(readPtxTarget('unrelated "unterminated')).toBeNull();
expect(readPtxTarget("/* unrelated unterminated")).toBeNull();
});