luau-obfuscator 1.0.0 → 1.0.2

package/src/passes/vmify/names.ts

@@ -0,0 +1,72 @@
+/**
+ * Vmify 런타임/청크에서 쓰는 모든 이름(전역 식별자 + Luau 테이블 필드 키)을 빌드마다
+ * 무작위로 새로 뽑는다. opcode 번호 셔플(opcodes.ts)만으로는 부족한 게, "__VM_GLOBALS",
+ * "__vm_execute", "frame.R/K/code" 같은 이름 자체가 모든 산출물에서 동일하면 그 문자열
+ * 만으로 grep 한 방에 VM 시그니처를 찾아낼 수 있기 때문. 여기서 만든 이름들은
+ * runtime.ts(핸들러 본문), serialize.ts(Proto/Instr을 Luau 테이블로 찍을 때 쓰는 키),
+ * Vmify.ts(바깥에서 __vm_execute를 부르는 wrapper 코드) 세 곳이 전부 같은 VmNames
+ * 인스턴스를 공유해야 앞뒤가 맞는다.
+ */
+export interface VmNames {
+    /** local __VM_GLOBALS = { ... } 에 해당하는 최상위 local 이름 */
+    globals: string
+    /** local __VM_PROTO = { ... } */
+    protoRoot: string
+    /** function __vm_execute(proto, upvals, ...) */
+    execute: string
+    /** local __vm_handlers = {} */
+    handlers: string
+    /** local function __vm_dispatch(frame, pc) */
+    dispatch: string
+    /** local function __vm_rk(frame, x) */
+    rk: string
+    /** __vm_execute/핸들러의 frame 파라미터 이름 */
+    frame: string
+    // frame 테이블 필드
+    R: string
+    K: string
+    code: string
+    protos: string
+    upvals: string
+    varargs: string
+    nVarargs: string
+    multiTop: string
+    // Proto 테이블 필드 (인스트럭션 자체는 이제 [op,a,b,c] 위치 기반 테이블이라 이름이 필요 없음)
+    numParams: string
+    hasVarargs: string
+    maxRegs: string
+    consts: string
+    upvalDescs: string
+    kind: string
+    index: string
+}
+
+const ID_CHARS_HEAD = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
+const ID_CHARS_TAIL = ID_CHARS_HEAD + "0123456789"
+
+function makeIdGenerator(random: () => number): () => string {
+    const used = new Set<string>()
+    return () => {
+        let id: string
+        do {
+            const len = 5 + Math.floor(random() * 5)
+            let s = ID_CHARS_HEAD[Math.floor(random() * ID_CHARS_HEAD.length)]
+            for (let i = 1; i < len; i++) s += ID_CHARS_TAIL[Math.floor(random() * ID_CHARS_TAIL.length)]
+            id = s
+        } while (used.has(id))
+        used.add(id)
+        return id
+    }
+}
+
+export function generateVmNames(random: () => number = Math.random): VmNames {
+    const id = makeIdGenerator(random)
+    return {
+        globals: id(), protoRoot: id(), execute: id(), handlers: id(), dispatch: id(), rk: id(),
+        frame: id(),
+        R: id(), K: id(), code: id(), protos: id(), upvals: id(), varargs: id(),
+        nVarargs: id(), multiTop: id(),
+        numParams: id(), hasVarargs: id(), maxRegs: id(), consts: id(), upvalDescs: id(),
+        kind: id(), index: id(),
+    }
+}

package/src/passes/vmify/opcodes.ts

@@ -0,0 +1,80 @@
+/**
+ * Lua 5.1 스타일 레지스터 기반 opcode 세트 (Prometheus VM 모듈과 동일한 접근).
+ * 각 opcode의 "구현"은 런타임 인터프리터(runtime.ts)에서 실제 Luau 연산자로
+ * 그대로 매핑되므로, 여기서는 opcode 자체의 의미와 A/B/C 피연산자 규약만 정의한다.
+ *
+ * 규약 (Lua 5.1 바이트코드와 동일):
+ *   A = 목적 레지스터
+ *   B, C = 소스 레지스터 또는 상수 인덱스(RK) 또는 즉시값(점프 오프셋 등)
+ *   RK(x): x >= 0 이면 레지스터 R[x], x < 0 이면 상수 K[-x-1] (상수/레지스터 구분을
+ *   비트 하나로 안 하고 부호로 하는 이유: 구현 단순화. 실제 Lua는 비트 플래그를 씀)
+ */
+export enum Opcode {
+    MOVE,        // R[A] = R[B]
+    LOADK,       // R[A] = K[B]
+    LOADBOOL,    // R[A] = (B != 0);  C != 0 이면 다음 명령 skip (조건부 분기 최적화용, 지금은 미사용)
+    LOADNIL,     // R[A..B] = nil
+    GETUPVAL,    // R[A] = U[B]
+    SETUPVAL,    // U[B] = R[A]
+    GETGLOBAL,   // R[A] = _G-equivalent[K[B]]  (아래 GlobalMapping 참고: 실제로는 GLOBAL 테이블 인덱싱)
+    SETGLOBAL,   // GLOBAL[K[B]] = R[A]
+    GETTABLE,    // R[A] = R[B][RK(C)]
+    SETTABLE,    // R[A][RK(B)] = RK(C)
+    NEWTABLE,    // R[A] = {}
+    SELF,        // R[A+1] = R[B]; R[A] = R[B][RK(C)]   (메서드 호출 준비, TODO: 아직 컴파일러 미구현)
+    ADD, SUB, MUL, DIV, MOD, POW,   // R[A] = RK(B) <op> RK(C)
+    CONCAT,      // R[A] = R[B] .. .. R[C] (B..C 레지스터 범위 전부 이어붙임)
+    UNM,         // R[A] = -R[B]
+    NOT,         // R[A] = not R[B]
+    LEN,         // R[A] = #R[B]
+    JMP,         // pc += A  (무조건 점프, A는 부호 있는 오프셋)
+    EQ, LT, LE,  // if (RK(B) <op> RK(C)) != A then pc++  (다음 명령은 보통 JMP)
+    TEST,        // if (not R[A]) != C then pc++          (and/or 단락 평가, if 조건 등)
+    CALL,        // R[A], ..., R[A+C-2] = R[A](R[A+1], ..., R[A+B-1])
+                 //   B=0: 인자 전부 스택 끝까지(가변인자 호출), C=0: 반환값 전부 받음(가변반환)
+    RETURN,      // return R[A], ..., R[A+B-2]   (B=0: R[A]부터 스택 끝까지 전부 반환)
+    FORPREP,     // numeric for 초기화 + 조건 미충족 시 FORLOOP 뒤로 점프
+    FORLOOP,     // numeric for 증분 + 조건 충족 시 루프 헤더로 점프
+    CLOSURE,     // R[A] = 클로저(protos[B], 캡처된 upvalue 목록은 뒤따르는 pseudo-instr로 인코딩)
+    VARARG,      // R[A..A+B-2] = ...   (B=0: 가변인자 전부)
+    SETLIST,     // R[A][C], R[A][C+1], ... = R[B], R[B+1], ... (frame.multiTop까지) — 테이블
+                 //   생성자 마지막 필드가 Call/MethodCall/Vararg로 다중값을 낼 때 씀 (`{f()}`, `{...}`)
+    IDIV,        // R[A] = RK(B) // RK(C)  (Luau 바닥 나눗셈 연산자, 뒤에 추가되어 기존 opcode
+                 //   번호를 안 건드림 — enum 중간에 끼워넣으면 runtime.ts의 숫자 인덱스가 전부 밀림)
+}
+
+export interface Instr {
+    op: Opcode
+    a: number
+    b: number
+    c: number
+    /** JMP/EQ/LT/LE/TEST/CALL 등에서 사람이 읽을 디버깅용 주석. 런타임엔 안 쓰임. */
+    comment?: string
+}
+
+/** RK 인코딩 헬퍼: 상수는 음수(-idx-1), 레지스터는 그대로 양수. */
+export function RK(regOrConstIdx: number, isConst: boolean): number {
+    return isConst ? -(regOrConstIdx + 1) : regOrConstIdx
+}
+
+/** 논리 opcode(Opcode enum) -> 실제 바이트코드 숫자. 빌드마다 무작위로 재배치된다. */
+export type OpcodeMap = number[]
+
+const OPCODE_COUNT = Object.keys(Opcode).filter((k) => Number.isNaN(Number(k))).length
+
+/**
+ * opcode 번호를 빌드마다 무작위로 섞는다. 이게 없으면 "MOVE=0, LOADK=1, ..." 같은
+ * 고정 번호가 모든 산출물에서 동일해서, 한 번 리버싱해두면 opcode 핸들러 배열 인덱스만
+ * 보고 바로 어떤 명령인지 알 수 있는 상수 시그니처가 되어버린다(디컴파일러가 제일
+ * 먼저 노리는 지점). random을 주입받게 해서 테스트에서는 결정적 시퀀스도 쓸 수 있게 함.
+ */
+export function createOpcodeMap(random: () => number = Math.random): OpcodeMap {
+    const perm = Array.from({ length: OPCODE_COUNT }, (_, i) => i)
+    for (let i = perm.length - 1; i > 0; i--) {
+        const j = Math.floor(random() * (i + 1))
+        const tmp = perm[i]
+        perm[i] = perm[j]
+        perm[j] = tmp
+    }
+    return perm
+}

package/src/passes/vmify/registers.ts

@@ -0,0 +1,63 @@
+/**
+ * Lua 레퍼런스 컴파일러와 동일한 방식의 레지스터 할당기.
+ * - 지역변수는 선언 시점에 고정 슬롯을 받고, 그 슬롯은 스코프가 끝날 때까지 유지.
+ * - 표현식 평가용 임시 레지스터는 `freereg`(다음으로 쓸 수 있는 첫 슬롯) 하나로 관리:
+ *   필요하면 freereg 위치를 하나 배정하고 freereg++, 다 쓰면 다시 freereg--.
+ *   "스택처럼" 위에서부터 빌렸다 반납하기 때문에, 지역변수 슬롯보다 아래로는
+ *   절대 freereg가 내려가지 않는다(지역변수 보호).
+ */
+export class RegisterAllocator {
+    /** 현재 스코프에서 지역변수가 차지하고 있는, 즉 "보호된" 레지스터 개수. */
+    private localCount = 0
+    /** 다음에 할당할 임시 레지스터 인덱스. */
+    private freereg = 0
+    /** 지금까지 이 함수에서 동시에 살아있었던 최대 레지스터 수(Proto.maxRegs에 기록). */
+    maxUsed = 0
+
+    /** 지역변수 하나를 위한 슬롯을 새로 확정한다. 반환값이 그 변수의 레지스터 번호. */
+    declareLocal(): number {
+        const slot = this.localCount
+        this.localCount++
+        if (this.freereg < this.localCount) this.freereg = this.localCount
+        this.track()
+        return slot
+    }
+
+    /** 블록/함수 스코프가 끝날 때, 그 스코프에서 선언된 지역변수 슬롯들을 반납. */
+    releaseLocalsTo(savedLocalCount: number): void {
+        this.localCount = savedLocalCount
+        // 무조건 리셋(위로도 아래로도) — 스코프가 끝나면 그 안에서 쓴 지역/임시 레지스터는
+        // 전부 죽은 값이다. freereg가 이미 더 높았다고 해서 그대로 두면(예전 버그), 그
+        // 누수가 이후 모든 문장의 "top()" 기준점을 계속 밀어 올려서 눈덩이처럼 커진다.
+        this.freereg = savedLocalCount
+    }
+
+    saveLocalCount(): number {
+        return this.localCount
+    }
+
+    /** 표현식 평가용 임시 레지스터 하나 할당. */
+    allocTemp(): number {
+        const r = this.freereg
+        this.freereg++
+        this.track()
+        return r
+    }
+
+    /**
+     * 임시 레지스터 n개를 반납(freereg를 내림). 지역변수 보호 슬롯 밑으로는
+     * 절대 안 내려가도록 clamp — 호출 순서가 꼬여도 지역변수는 항상 안전.
+     */
+    freeTemp(toReg: number): void {
+        this.freereg = Math.max(toReg, this.localCount)
+    }
+
+    /** 지금 이 시점의 freereg. 임시 레지스터 블록 할당 전 저장해뒀다가 freeTemp에 씀. */
+    top(): number {
+        return this.freereg
+    }
+
+    private track(): void {
+        if (this.freereg > this.maxUsed) this.maxUsed = this.freereg
+    }
+}

package/src/passes/vmify/runtime.ts

@@ -0,0 +1,334 @@
+import { Opcode, type OpcodeMap } from "./opcodes"
+import type { VmNames } from "./names"
+
+/**
+ * VM 런타임 v3 — opcode마다 독립된 핸들러 함수를 만들고 서로 tail call로 이어지는
+ * 구조는 v2와 동일하다. 다만 이제 모든 전역 식별자(__vm_execute, __vm_handlers, ...)와
+ * frame/Instr/Proto의 테이블 필드 키가 고정 문자열이 아니라, 빌드마다 무작위로 뽑힌
+ * names(names.ts)와 opcode 번호 재배치 opcodeMap(opcodes.ts)을 받아 그때그때
+ * 소스를 새로 찍어낸다.
+ *
+ * 왜 이렇게 하나:
+ *  - Luau는 proper tail call을 보장하므로(스택 안 쌓임, 성능도 loop와 동급),
+ *    "재귀처럼 보이지만 실제론 loop"인 구조를 공짜로 얻을 수 있다.
+ *  - "거대한 while+if-chain" 자체가 디컴파일러가 제일 먼저 찾는 VM 시그니처인데,
+ *    이 구조는 그 패턴이 아예 없다.
+ *  - opcode 번호 + 식별자 이름을 빌드마다 다르게 뽑기 때문에, 한 번 리버싱해서
+ *    "MOVE=0, __vm_execute라는 함수가 진입점" 같은 지식을 얻어도 다음 산출물에는
+ *    그대로 안 먹힌다 — 매번 새로 분석해야 함.
+ *
+ * opcode 번호는 opcodeMap[Opcode.X]로 이 빌드에서 실제로 쓰인 숫자를 얻는다
+ * (compiler.ts가 emit() 시점에 같은 opcodeMap으로 인스트럭션에 번호를 박아 넣으므로
+ * 반드시 컴파일과 런타임 생성에 동일한 opcodeMap 인스턴스를 넘겨야 함).
+ */
+export function buildVmRuntimeSource(names: VmNames, opcodeMap: OpcodeMap): string {
+    const N = names
+    const op = (o: Opcode) => opcodeMap[o]
+
+    return `
+local ${N.handlers} = {}
+
+local function ${N.dispatch}(${N.frame}, pc)
+    local instr = ${N.frame}.${N.code}[pc]
+    return ${N.handlers}[instr[1]](${N.frame}, pc, instr)
+end
+
+local function ${N.rk}(${N.frame}, x)
+    if x < 0 then
+        return ${N.frame}.${N.K}[-x - 1 + 1]
+    else
+        return ${N.frame}.${N.R}[x]
+    end
+end
+
+-- MOVE
+${N.handlers}[${op(Opcode.MOVE)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- LOADK
+${N.handlers}[${op(Opcode.LOADK)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.K}[instr[3] + 1]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- LOADBOOL
+${N.handlers}[${op(Opcode.LOADBOOL)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = (instr[3] ~= 0)
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- LOADNIL
+${N.handlers}[${op(Opcode.LOADNIL)}] = function(${N.frame}, pc, instr)
+    for i = instr[2], instr[3] do ${N.frame}.${N.R}[i] = nil end
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- GETUPVAL
+${N.handlers}[${op(Opcode.GETUPVAL)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.upvals}[instr[3] + 1]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- SETUPVAL
+${N.handlers}[${op(Opcode.SETUPVAL)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.upvals}[instr[3] + 1] = ${N.frame}.${N.R}[instr[2]]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- GETGLOBAL (b는 RK가 아니라 상수풀 순수 인덱스)
+${N.handlers}[${op(Opcode.GETGLOBAL)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.globals}[${N.frame}.${N.K}[instr[3] + 1]]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- SETGLOBAL
+${N.handlers}[${op(Opcode.SETGLOBAL)}] = function(${N.frame}, pc, instr)
+    ${N.globals}[${N.frame}.${N.K}[instr[3] + 1]] = ${N.frame}.${N.R}[instr[2]]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- GETTABLE
+${N.handlers}[${op(Opcode.GETTABLE)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]][${N.rk}(${N.frame}, instr[4])]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- SETTABLE
+${N.handlers}[${op(Opcode.SETTABLE)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]][${N.rk}(${N.frame}, instr[3])] = ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- NEWTABLE
+${N.handlers}[${op(Opcode.NEWTABLE)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = {}
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- SELF  (R[a] = R[b][key]; R[a+1] = R[b])
+${N.handlers}[${op(Opcode.SELF)}] = function(${N.frame}, pc, instr)
+    local obj = ${N.frame}.${N.R}[instr[3]]
+    ${N.frame}.${N.R}[instr[2]] = obj[${N.rk}(${N.frame}, instr[4])]
+    ${N.frame}.${N.R}[instr[2] + 1] = obj
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- ADD SUB MUL DIV MOD POW
+${N.handlers}[${op(Opcode.ADD)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) + ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+${N.handlers}[${op(Opcode.SUB)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) - ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+${N.handlers}[${op(Opcode.MUL)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) * ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+${N.handlers}[${op(Opcode.DIV)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) / ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+${N.handlers}[${op(Opcode.MOD)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) % ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+${N.handlers}[${op(Opcode.POW)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) ^ ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- IDIV (Luau 바닥 나눗셈)
+${N.handlers}[${op(Opcode.IDIV)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) // ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- CONCAT
+${N.handlers}[${op(Opcode.CONCAT)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) .. ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- UNM
+${N.handlers}[${op(Opcode.UNM)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = -${N.frame}.${N.R}[instr[3]]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- NOT
+${N.handlers}[${op(Opcode.NOT)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = not ${N.frame}.${N.R}[instr[3]]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- LEN
+${N.handlers}[${op(Opcode.LEN)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = #${N.frame}.${N.R}[instr[3]]
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- JMP (pc += a)
+${N.handlers}[${op(Opcode.JMP)}] = function(${N.frame}, pc, instr)
+    return ${N.dispatch}(${N.frame}, pc + instr[2])
+end
+
+-- EQ LT LE (값 생성형 비교)
+${N.handlers}[${op(Opcode.EQ)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) == ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+${N.handlers}[${op(Opcode.LT)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) < ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+${N.handlers}[${op(Opcode.LE)}] = function(${N.frame}, pc, instr)
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) <= ${N.rk}(${N.frame}, instr[4])
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- TEST (if (not R[a]) != (c!=0) then pc += 2 else pc += 1 — 보통 다음 명령은 JMP)
+${N.handlers}[${op(Opcode.TEST)}] = function(${N.frame}, pc, instr)
+    if (not ${N.frame}.${N.R}[instr[2]]) ~= (instr[4] ~= 0) then
+        return ${N.dispatch}(${N.frame}, pc + 2)
+    end
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- CALL
+${N.handlers}[${op(Opcode.CALL)}] = function(${N.frame}, pc, instr)
+    local a, b, c = instr[2], instr[3], instr[4]
+    local fn = ${N.frame}.${N.R}[a]
+    local nargs
+    if b == 0 then
+        nargs = (${N.frame}.${N.multiTop} or (a + 1)) - (a + 1)
+    else
+        nargs = b - 1
+    end
+    local args = table.create(nargs)
+    for i = 1, nargs do args[i] = ${N.frame}.${N.R}[a + i] end
+    local rets = table.pack(fn(table.unpack(args, 1, nargs)))
+    if c == 1 then
+        -- discard
+    elseif c == 0 then
+        for i = 1, rets.n do ${N.frame}.${N.R}[a + i - 1] = rets[i] end
+        ${N.frame}.${N.multiTop} = a + rets.n
+    else
+        local want = c - 1
+        for i = 1, want do ${N.frame}.${N.R}[a + i - 1] = rets[i] end
+    end
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- RETURN
+${N.handlers}[${op(Opcode.RETURN)}] = function(${N.frame}, pc, instr)
+    local a, b = instr[2], instr[3]
+    if b == 0 then
+        return table.unpack(${N.frame}.${N.R}, a, (${N.frame}.${N.multiTop} or (a + 1)) - 1)
+    end
+    return table.unpack(${N.frame}.${N.R}, a, a + b - 2)
+end
+
+-- FORPREP
+${N.handlers}[${op(Opcode.FORPREP)}] = function(${N.frame}, pc, instr)
+    local a = instr[2]
+    ${N.frame}.${N.R}[a] = ${N.frame}.${N.R}[a] - ${N.frame}.${N.R}[a + 2]
+    return ${N.dispatch}(${N.frame}, pc + instr[3])
+end
+
+-- FORLOOP
+${N.handlers}[${op(Opcode.FORLOOP)}] = function(${N.frame}, pc, instr)
+    local a = instr[2]
+    local step = ${N.frame}.${N.R}[a + 2]
+    ${N.frame}.${N.R}[a] = ${N.frame}.${N.R}[a] + step
+    local ok
+    if step > 0 then
+        ok = ${N.frame}.${N.R}[a] <= ${N.frame}.${N.R}[a + 1]
+    else
+        ok = ${N.frame}.${N.R}[a] >= ${N.frame}.${N.R}[a + 1]
+    end
+    if ok then
+        ${N.frame}.${N.R}[a + 3] = ${N.frame}.${N.R}[a]
+        return ${N.dispatch}(${N.frame}, pc + instr[3])
+    end
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- CLOSURE
+${N.handlers}[${op(Opcode.CLOSURE)}] = function(${N.frame}, pc, instr)
+    local childProto = ${N.frame}.${N.protos}[instr[3] + 1]
+    local n = #childProto.${N.upvalDescs}
+    local capturedUpvals = table.create(n)
+    for i = 1, n do
+        local desc = childProto.${N.upvalDescs}[i]
+        local captureInstr = ${N.frame}.${N.code}[pc + i]
+        if desc.${N.kind} == "local" then
+            capturedUpvals[i] = ${N.frame}.${N.R}[captureInstr[3]]
+        else
+            capturedUpvals[i] = ${N.frame}.${N.upvals}[captureInstr[3] + 1]
+        end
+    end
+    ${N.frame}.${N.R}[instr[2]] = function(...)
+        return ${N.execute}(childProto, capturedUpvals, ...)
+    end
+    return ${N.dispatch}(${N.frame}, pc + 1 + n)
+end
+
+-- VARARG
+${N.handlers}[${op(Opcode.VARARG)}] = function(${N.frame}, pc, instr)
+    local count = instr[3] == 0 and ${N.frame}.${N.nVarargs} or (instr[3] - 1)
+    for i = 1, count do
+        ${N.frame}.${N.R}[instr[2] + i - 1] = ${N.frame}.${N.varargs}[i]
+    end
+    if instr[3] == 0 then
+        ${N.frame}.${N.multiTop} = instr[2] + count
+    end
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+-- SETLIST
+${N.handlers}[${op(Opcode.SETLIST)}] = function(${N.frame}, pc, instr)
+    local tbl = ${N.frame}.${N.R}[instr[2]]
+    local valuesBase = instr[3]
+    local top = ${N.frame}.${N.multiTop} or (valuesBase + 1)
+    local startIdx = instr[4]
+    local n = top - valuesBase
+    for i = 0, n - 1 do
+        tbl[startIdx + i] = ${N.frame}.${N.R}[valuesBase + i]
+    end
+    return ${N.dispatch}(${N.frame}, pc + 1)
+end
+
+function ${N.execute}(proto, upvals, ...)
+    local nArgs = select("#", ...)
+    local packedArgs = table.pack(...)
+    local R = table.create(proto.${N.maxRegs} + 8)
+    for i = 1, proto.${N.numParams} do
+        R[i - 1] = packedArgs[i]
+    end
+    local nVarargs = 0
+    local varargs = {}
+    if proto.${N.hasVarargs} and nArgs > proto.${N.numParams} then
+        nVarargs = nArgs - proto.${N.numParams}
+        for i = 1, nVarargs do
+            varargs[i] = packedArgs[proto.${N.numParams} + i]
+        end
+    end
+
+    local ${N.frame} = {
+        ${N.R} = R,
+        ${N.K} = proto.${N.consts},
+        ${N.code} = proto.${N.code},
+        ${N.protos} = proto.${N.protos},
+        ${N.upvals} = upvals,
+        ${N.varargs} = varargs,
+        ${N.nVarargs} = nVarargs,
+    }
+
+    return ${N.dispatch}(${N.frame}, 1)
+end
+`
+}