lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ffi 0.3: large struct baseline (Big24, Big48) through sret return path

Browse Source 
90/90 regression tests pass (+ffi-03-large-struct).

vendors/ffi_large_struct/{.h,.c} defines:
  Big24 — 24 B, three s64    (byval params + sret return)
  Big48 — 48 B, six s64      (same path, larger)

`make / rotate-or-reverse / sum` helpers per shape. The sx-side
example imports via `#source` only and declares matching structs +
hand-written #foreign decls.

Snapshot pins today's >16-byte aggregate ABI now that the
emit_llvm.zig sret-return transform is in place (previous commit).
That gives us a regression net for all four C-ABI aggregate slots
in one place:

  ≤8 B int       — i64 coercion          (ffi-01 vec-likes)
  9..16 B int    — [2 x i64] coercion    (ffi-02 Pair64/Quad32, 101)
  16 B HFA       — struct, no coercion    (ffi-02 Vec2/Vec4f)
  >16 B          — byval params + sret    (this commit)
This commit is contained in:
agra
2026-05-19 11:41:06 +03:00
parent 7fd6decdc9
commit 2463eea1d4
5 changed files with 112 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
examples/ffi-03-large-struct.sx Normal file
View File

@@ -0,0 +1,53 @@
// Phase 0 baseline (PLAN-FFI.md step 0.3): structs >16 bytes passed
// by value into a C `#foreign` fn and returned by value. Exercises
// the byval-pointer ABI path — the caller copies the struct onto its
// stack and hands a pointer to the callee; on AAPCS64 the return
// uses the indirect `x8` register; on SysV AMD64 the return is a
// hidden first arg pointer that the caller allocates.
//
// Distinct from the register-pair / [2 x i64] / HFA paths the
// small-struct baseline (ffi-02) covers. The two relevant emit_llvm
// helpers are `needsByval` (returns true when size > 16) and
// `materializeByvalArg` (alloca + store + pass pointer).
//
// Big24 — 24 B, three s64
// Big48 — 48 B, six s64
#import "modules/std.sx";
#import c {
#source "vendors/ffi_large_struct/ffi_large_struct.c";
};
Big24 :: struct { a: s64; b: s64; c: s64; }
Big48 :: struct {
a: s64; b: s64; c: s64;
d: s64; e: s64; f: s64;
}
ffi_big24_make :: (a: s64, b: s64, c: s64) -> Big24 #foreign;
ffi_big24_rotate :: (v: Big24) -> Big24 #foreign;
ffi_big24_sum :: (v: Big24) -> s64 #foreign;
ffi_big48_make :: (a: s64, b: s64, c: s64,
d: s64, e: s64, f: s64) -> Big48 #foreign;
ffi_big48_reverse :: (v: Big48) -> Big48 #foreign;
ffi_big48_sum :: (v: Big48) -> s64 #foreign;
main :: () -> s32 {
// ── Big24 (24 bytes, byval pointer) ────────────────────────────
v := ffi_big24_make(1, 2, 3);
print("big24 make = ({}, {}, {})\n", v.a, v.b, v.c);
w := ffi_big24_rotate(v);
print("big24 rotate = ({}, {}, {})\n", w.a, w.b, w.c);
print("big24 sum = {}\n", ffi_big24_sum(v));
// ── Big48 (48 bytes, byval pointer) ────────────────────────────
x := ffi_big48_make(10, 20, 30, 40, 50, 60);
print("big48 make = ({}, {}, {}, {}, {}, {})\n", x.a, x.b, x.c, x.d, x.e, x.f);
y := ffi_big48_reverse(x);
print("big48 reverse = ({}, {}, {}, {}, {}, {})\n", y.a, y.b, y.c, y.d, y.e, y.f);
print("big48 sum = {}\n", ffi_big48_sum(x));
0;
}