mem: implicit-context foundation + many compiler fixes

The session-long set of changes that lay the groundwork for the
Jai-literal implicit-Context-parameter refactor. Lots of accumulated
work; the new arrival is the implicit-ctx foundation (steps 1+2 of
the plan in current/CHECKPOINT-MEM.md):

  Step 1 — `CAllocator :: struct {}` stateless allocator in
    library/modules/allocators.sx, delegating directly to
    libc_malloc/libc_free. `ConstantValue` in src/ir/inst.zig gains a
    `func_ref: FuncId` leaf so nested aggregates can carry function
    pointers (the inline Allocator value's fn-ptr fields). Switch
    sites updated in emit_llvm.zig, print.zig, interp.zig.

  Step 2 — `emitDefaultContextGlobal` in src/ir/lower.zig synthesises
    a static `__sx_default_context` global with a nested-aggregate
    init_val pointing at the CAllocator → Allocator thunks. The
    second-pass `initVtableGlobals` in emit_llvm.zig is generalised
    to handle `.aggregate` init_vals (re-emits after func_map is
    populated so func_ref leaves resolve to real symbols).

Also folded in from earlier work this session:

  - Phase 1.1: `xx value` heap-copy in `buildProtocolValue` routes
    through `context.allocator` via the new `allocViaContext` helper.
  - interp.zig: `marshalForeignArg` double-offset bug fixed —
    `heapSlice` already adds `hp.offset` to the slice ptr, so the
    extra `+ hp.offset` was scribbling memcpy/memset into adjacent
    heap state, corrupting `heap.items[0]`. Symptom: `build_format`
    at comptime produced zero bytes, all `print` calls failed.
  - Lazy lowering: `lazyLowerFunction` now declares foreign-body
    functions as extern stubs in the local (comptime) module so
    cross-module foreign calls resolve.
  - Allocator API: all stdlib allocators on one-line `init() -> *T`
    (CAllocator/GPA: libc-backed; Arena/TrackingAllocator: parent-
    backed; BufAlloc: embeds state at head of user buffer).
  - issues 0038 (transitive #import), 0039 (chess + stdlib migration
    fallout), 0040 (generic struct method dot-dispatch), 0041
    (pointer types as type-arg), 0042 (alias name resolution) — all
    fixed; regression tests in examples/.
  - Diagnostic: `emitError` now embeds the lowering's
    `current_source_file` and enclosing function in the literal
    message; SX_TRACE_UNRESOLVED=1 dumps a Zig stack trace at the
    emit site so misattributed spans can't hide where the failure
    is.
  - tools/verify-step.sh (all-platforms gate) and tools/scratch.sh
    (interp/codegen parity tester) added.

Test suite: 152 example tests pass; chess builds + screenshots on
macOS / iOS sim / Android.

tests/expected/08-types.txt

@@ -1,4 +1,4 @@
-a 0 : Foo{a: 0, b: 42, c: 176, d: 17}
+a 0 : Foo{a: 0, b: 42, c: 92, d: 17}
 a 1 : Foo{a: 1, b: 42, c: 8, d: 17}
 b: Foo{a: 1, b: 1, c: 101, d: 1}
 Pack{a: 1, b: 0, c: 3, d: 5, f: 9, v: 100, x: 3.500000}

tests/expected/10-generic-struct.txt

@@ -12,5 +12,3 @@ sqrt(9): 3.000000
 4
 16
 8
-8
-8

tests/expected/125-static-method-inline-xx-protocol-arg.exit

@@ -0,0 +1 @@
+0

tests/expected/125-static-method-inline-xx-protocol-arg.txt

@@ -0,0 +1,3 @@
+Box.init (named-var):  ok
+make_box (inline-xx):  ok
+Box.init (inline-xx):  ok

tests/expected/126-xx-recover-then-dispatch.exit

@@ -0,0 +1 @@
+0

tests/expected/126-xx-recover-then-dispatch.txt

@@ -0,0 +1,4 @@
+recovered == gpa? true
+alloc count after first alloc: 1
+recovered2 == gpa? true
+alloc count after dealloc: 0

tests/expected/127-import-non-transitive.exit

@@ -0,0 +1 @@
+1

tests/expected/127-import-non-transitive.txt

@@ -0,0 +1,3 @@
+/Users/agra/projects/sx/examples/127-import-non-transitive.sx:15:37: error: 'c_only_fn' is not visible; #import the module that declares it
+/Users/agra/projects/sx/examples/127-import-non-transitive.sx:16:40: error: 'c_only_const' is not visible; #import the module that declares it
+/Users/agra/projects/sx/examples/127-import-non-transitive.sx:16:40: error: unresolved 'c_only_const' (in /Users/agra/projects/sx/examples/127-import-non-transitive.sx fn main)

tests/expected/128-import-dir-scan-order.exit

@@ -0,0 +1 @@
+0

tests/expected/128-import-dir-scan-order.txt

@@ -0,0 +1 @@
+b=42

tests/expected/129-generic-method-dot-call.exit

@@ -0,0 +1 @@
+0

tests/expected/129-generic-method-dot-call.txt

@@ -0,0 +1,5 @@
+plain: 7
+sized s32: 4
+sized s64: 8
+taking explicit: 42
+taking inferred: 99

tests/expected/130-xx-value-routes-through-context-allocator.exit

@@ -0,0 +1 @@
+0

tests/expected/130-xx-value-routes-through-context-allocator.txt

@@ -0,0 +1 @@
+Tracer.count = 1

tests/expected/50-smoke.txt

@@ -228,6 +228,10 @@ sqrt-f64: 4.000000
 sizeof-s32: 4
 sizeof-f64: 8
 sizeof-struct: 8
+alignof-u8: 1
+alignof-s32: 4
+alignof-s64: 8
+alignof-struct: 4
 typeof: int
 typeof-float: float
 typeof-string: string
@@ -385,12 +389,12 @@ bytes len: 3
 --- allocators ---
 gpa allocs: 2
 gpa final: 0
-arena chunks: 1
-arena overflow: 2
+arena chunks: 2
+arena overflow: 3
 arena a1: 42
 arena a3: 99
 arena reset idx: 0
-arena reset gpa: 1
+arena reset gpa: 2
 arena deinit: 0
 buf pos: 48
 buf overflow: 0

tests/expected/99-protocol-void-pointer-return.exit

@@ -0,0 +1 @@
+0

tests/expected/99-protocol-void-pointer-return.txt

@@ -0,0 +1,3 @@
+direct: null? false
+protocol: null? false
+alloc_count: 2

tests/expected/ffi-jni-call-03-methodid-sharing.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [5 x i8] c"noop\00", align 1
 @str.1 = private unnamed_addr constant [4 x i8] c"()V\00", align 1
 @SX_JNI_CLS_noop____V = internal global ptr null
@@ -15,14 +16,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -37,8 +62,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -62,7 +87,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -77,7 +102,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -88,6 +113,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -156,7 +196,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -164,7 +204,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -189,7 +229,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -310,6 +350,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-call-04-jint-return.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [9 x i8] c"getCount\00", align 1
 @str.1 = private unnamed_addr constant [4 x i8] c"()I\00", align 1
 @SX_JNI_CLS_getCount____I = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -285,6 +325,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-call-05-jlong-return.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [18 x i8] c"currentTimeMillis\00", align 1
 @str.1 = private unnamed_addr constant [4 x i8] c"()J\00", align 1
 @SX_JNI_CLS_currentTimeMillis____J = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -285,6 +325,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-call-06-jdouble-return.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [9 x i8] c"getValue\00", align 1
 @str.1 = private unnamed_addr constant [4 x i8] c"()D\00", align 1
 @SX_JNI_CLS_getValue____D = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -285,6 +325,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-call-07-jboolean-return.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [8 x i8] c"isShown\00", align 1
 @str.1 = private unnamed_addr constant [4 x i8] c"()Z\00", align 1
 @SX_JNI_CLS_isShown____Z = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -285,6 +325,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-call-08-jobject-return.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [10 x i8] c"getWindow\00", align 1
 @str.1 = private unnamed_addr constant [24 x i8] c"()Landroid/view/Window;\00", align 1
 @SX_JNI_CLS_getWindow____Landroid_view_Window_ = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -285,6 +325,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-call-09-static.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [4 x i8] c"max\00", align 1
 @str.1 = private unnamed_addr constant [6 x i8] c"(II)I\00", align 1
 @SX_JNI_CLS_max___II_I = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -282,6 +322,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-class-08-call.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [10 x i8] c"getWindow\00", align 1
 @str.1 = private unnamed_addr constant [21 x i8] c"()Ljava/lang/Object;\00", align 1
 @SX_JNI_CLS_getWindow____Ljava_lang_Object_ = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -285,6 +325,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-jni-env-02-lexical-direct.ir

@@ -1,6 +1,7 @@
 
 @context = internal global { { ptr, ptr, ptr }, ptr } zeroinitializer
 @g_should_call = internal global i1 false
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @str = private unnamed_addr constant [5 x i8] c"noop\00", align 1
 @str.1 = private unnamed_addr constant [4 x i8] c"()V\00", align 1
 @SX_JNI_CLS_noop____V = internal global ptr null
@@ -13,14 +14,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -35,8 +60,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -60,7 +85,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -75,7 +100,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -86,6 +111,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -154,7 +194,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -162,7 +202,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -187,7 +227,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -283,6 +323,20 @@ if.merge.1:                                       ; preds = %if.then.0, %entry
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry:

tests/expected/ffi-objc-call-03-selector-sharing.ir

@@ -3,6 +3,7 @@
 @OS = internal global i64 0
 @ARCH = internal global i64 0
 @POINTER_SIZE = internal global i64 8
+@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
 @OBJC_SELECTOR_REFERENCES_init = internal global ptr null
 @OBJC_SELECTOR_REFERENCES_release = internal global ptr null
 @str = private unnamed_addr constant [4 x i8] c"ok\0A\00", align 1
@@ -16,14 +17,38 @@ declare void @out(ptr) #0
 
 declare ptr @malloc(i64)
 
+declare void @free(ptr)
+
 declare ptr @memcpy(ptr, ptr, i64)
 
 declare ptr @memset(ptr, i32, i64)
 
-declare void @free(ptr)
+; Function Attrs: nounwind
+define internal ptr @CAllocator.alloc(ptr %0, i64 %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca i64, align 8
+  store i64 %1, ptr %allocaN, align 8
+  %load = load i64, ptr %allocaN, align 8
+  %call = call ptr @malloc(i64 %load)
+  ret ptr %call
+}
 
 ; Function Attrs: nounwind
-declare void @GPA.create(ptr sret({ ptr, ptr, ptr }), ptr) #0
+define internal void @CAllocator.dealloc(ptr %0, ptr %1) #0 {
+entry:
+  %alloca = alloca ptr, align 8
+  store ptr %0, ptr %alloca, align 8
+  %allocaN = alloca ptr, align 8
+  store ptr %1, ptr %allocaN, align 8
+  %load = load ptr, ptr %allocaN, align 8
+  call void @free(ptr %load)
+  ret void
+}
+
+; Function Attrs: nounwind
+declare ptr @GPA.init() #0
 
 ; Function Attrs: nounwind
 define internal ptr @GPA.alloc(ptr %0, i64 %1) #0 {
@@ -38,8 +63,8 @@ entry:
   %add = add i64 %loadN, 1
   store i64 %add, ptr %gep, align 8
   %loadN = load i64, ptr %allocaN, align 8
-  %malloc = call ptr @malloc(i64 %loadN)
-  ret ptr %malloc
+  %call = call ptr @malloc(i64 %loadN)
+  ret ptr %call
 }
 
 ; Function Attrs: nounwind
@@ -63,7 +88,7 @@ entry:
 declare void @Arena.add_chunk(ptr, i64) #0
 
 ; Function Attrs: nounwind
-declare void @Arena.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @Arena.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @Arena.reset(ptr) #0
@@ -78,7 +103,7 @@ declare ptr @Arena.alloc(ptr, i64) #0
 declare void @Arena.dealloc(ptr, ptr) #0
 
 ; Function Attrs: nounwind
-declare void @BufAlloc.create(ptr sret({ ptr, ptr, ptr }), ptr, ptr, i64) #0
+declare ptr @BufAlloc.init(ptr, i64) #0
 
 ; Function Attrs: nounwind
 declare void @BufAlloc.reset(ptr) #0
@@ -89,6 +114,21 @@ declare ptr @BufAlloc.alloc(ptr, i64) #0
 ; Function Attrs: nounwind
 declare void @BufAlloc.dealloc(ptr, ptr) #0
 
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.init(ptr) #0
+
+; Function Attrs: nounwind
+declare i64 @TrackingAllocator.leak_count(ptr) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.report(ptr) #0
+
+; Function Attrs: nounwind
+declare ptr @TrackingAllocator.alloc(ptr, i64) #0
+
+; Function Attrs: nounwind
+declare void @TrackingAllocator.dealloc(ptr, ptr) #0
+
 ; Function Attrs: nounwind
 define internal { ptr, i64 } @cstring(i64 %0) #0 {
 entry:
@@ -157,7 +197,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %alloca, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %2 = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
   %loadN = load i64, ptr %allocaN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
@@ -165,7 +205,7 @@ entry:
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   %dptrN = extractvalue { ptr, i64 } %loadN, 0
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -190,7 +230,7 @@ entry:
   %igp.data = extractvalue { ptr, i64 } %loadN, 0
   %igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
   %loadN = load i64, ptr %allocaN, align 8
-  %3 = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
+  %callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
 }
@@ -359,6 +399,20 @@ entry:
   ret i32 0
 }
 
+; Function Attrs: nounwind
+define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, i64 %1) #0 {
+entry:
+  %call = call ptr @CAllocator.alloc(ptr %0, i64 %1)
+  ret ptr %call
+}
+
+; Function Attrs: nounwind
+define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1) #0 {
+entry:
+  call void @CAllocator.dealloc(ptr %0, ptr %1)
+  ret void
+}
+
 ; Function Attrs: nounwind
 define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, i64 %1) #0 {
 entry: