63565e41ff
Three stacked compiler bugs were causing iOS-sim chess to crash inside [MTLTexture replaceRegion:...]. Fixing them lets every replaceRegion call site succeed (1×1 RGBA8, 1MB R8 atlas, 440×440 chess pieces). Path B for callconv(.c) fn-pointer casts: - FunctionInfo now carries call_conv: CallConv (TypeInfo.CallConv) so function-type interning distinguishes sx-CC from C-CC. Inst.zig's Function.CallingConvention aliases the same enum. - Parser accepts an optional `callconv(.c)` suffix on fn-pointer type spellings (factored into parseOptionalCallConv() shared with parseFnDecl and parseLambda). - resolveFunctionType passes the parsed CC through functionTypeCC(). - .call_indirect reads fp.call_conv == .c and applies the C-ABI alloca+materialize for >16B aggregate args (Path A's behaviour at .call). Apple ARM64 ABI (drop LLVM byval): - Side-by-side asm diff vs clang's emission for the equivalent C call site showed LLVM's `byval` attribute lowers Apple-arm64 byval on the stack, while clang passes the struct via a pointer in the next int register (x2 for replaceRegion:). The runtime objc_msgSend dispatch path expects clang's convention. - Dropped the byval attribute from the function-signature emission and from both call sites (.call and .call_indirect). The materialize-into- alloca + pass-plain-ptr pattern stays — the call site now matches clang's `mov x2, sp` exactly. - Path A's sx-to-sx case continues to work since both ends use plain ptr (caller does alloca+store+pass, callee loads from the ptr in prologue). Protocol dispatch (emitProtocolDispatch): - Untargeted `null` lowers as const_null with type .void (per target_type orelse .void). The "wrap-value-in-alloca-pass-pointer" branch alloca'd a void slot, which LLVM's IRBuilder asserts on — EXC_BREAKPOINT in getTypeSizeInBits, manifesting as exit 133 / SIGTRAP when building the chess game. Fixed by re-emitting as constNull(void_ptr) when arg_ty == .void && expected_ty == void_ptr. - is_pointer_ty only recognized .pointer, so [*]T (many_pointer) was alloca-wrapped — the heap pixels pointer from stbi_load was stored into a stack slot and the slot's address was passed as the *void arg. Fixed by extending the check to `.pointer or .many_pointer`. metal.sx call sites + lifecycle guards: - msg_replace (replaceRegion:, MTLRegion = 48B) and the two setScissorRect: sites (MTLScissorRect = 32B) now spell their fn-pointer types with by-value params + callconv(.c) — the *MTLRegion/@local workaround is gone. - metal_begin_frame_ios bails before nextDrawable when pixel_w/h are 0 (drawableSize 0×0 makes nextDrawable abort via XPC). - metal_init_ios only sets drawableSize when dims are positive. - begin_frame's encoder/cmd_buffer failure paths now clear self.drawable so a partial failure doesn't leak a drawable back into the pool. Examples + tests: - examples/86-callconv-c-fnptr-large-aggregate.sx — new, covers Path B with C-CC fn-ptr cast. - examples/87-fnptr-cast-large-aggregate.sx — renamed from issue-0025.sx, covers Path B with default sx-CC (the negative case). - examples/85-cc-c-large-aggregate.sx — from Session 60, covers Path A. - examples/issue-0014.sx, issue-0024.sx, issue-0025.sx — removed (resolved earlier this work). 71 regression tests pass, 0 failed. Chess game builds clean for iOS sim and reaches its frame loop without aborting. Runtime: chess UI still doesn't render — remaining issue is in the UIKit lifecycle / CAMetalLayer setup (legacy-app vs scene-API hybrid), not a compiler bug. See current/CHECKPOINT.md "Next step" for the diagnosis + options.
38 lines
1.2 KiB
Plaintext
38 lines
1.2 KiB
Plaintext
// Regression test for issue-0025 path B.
|
|
//
|
|
// When a fn-pointer's type is spelled with `callconv(.c)`, the indirect
|
|
// call must apply the same C-ABI byval coercion that direct C-ABI calls
|
|
// do at the call site (path A): >16-byte non-HFA aggregates are passed
|
|
// as `ptr byval(<T>)`. Without the fix, the indirect call site builds
|
|
// an LLVM function type whose param slot is the raw struct, which the
|
|
// AArch64/x86_64 backend tries to lay out across registers + stack in
|
|
// ways that don't match the byval-attributed callee signature — the
|
|
// callee then reads garbage out of the wrong machine-state slots.
|
|
//
|
|
// The opt-in is the `callconv(.c)` on the fn-pointer type spelling.
|
|
// Pure-sx fn-pointer casts (no callconv suffix) keep their default
|
|
// calling convention — verified by examples/87-fnptr-cast-large-aggregate.sx.
|
|
|
|
#import "modules/std.sx";
|
|
|
|
Wide :: struct {
|
|
a: s64;
|
|
b: s64;
|
|
c: s64;
|
|
d: s64;
|
|
}
|
|
|
|
accept_c :: (w: Wide) -> s64 callconv(.c) {
|
|
w.a + w.b + w.c + w.d;
|
|
}
|
|
|
|
main :: () -> s32 {
|
|
w := Wide.{ a = 1, b = 10, c = 100, d = 1000 };
|
|
if accept_c(w) != 1111 { return 1; }
|
|
|
|
fn_ptr : (Wide) -> s64 callconv(.c) = xx accept_c;
|
|
if fn_ptr(w) != 1111 { return 2; }
|
|
|
|
0;
|
|
}
|