iter embedding-abi-m3.1 (PARTIAL 5/7 + Boss spec-defect repair): single-ctor scalar record crosses the C ABI, ownership follows declared mode

Tasks 1-5 GREEN. T1 baseline pins (re-point annotation + @ailang_rc_alloc heap-box byte-pin: size=8+n*8, tag@0, fields@8/16). T2 export gate widened (is_c_scalar -> two-level is_c_abi_type: single-ctor all-Int/Float record; multi-ctor/Str/List/nested still RED; gate suite 10/10; M1 adt-ret must-fail re-pointed to multi-ctor+Str Reading). T3 codegen forwarder widened (llvm_scalar record Type::Con -> ptr; M2 forwarder body byte-unchanged; 3/3 staticlib pins). T4/T5 E2E record round-trip own+borrow, global leak-freedom. Boss spec-consistency repair (M2.1-precedent class): orchestrator correctly BLOCKED Task 5 on a genuine spec defect -- the single-ctx-readback allocs==frees proof model is unsatisfiable for borrow (and only coincidentally passes for own) because M2's TLS-ctx is bound only during the synchronous forwarder call, so host-side decs land on g_rc_*, not ctx. Boss-verified globally leak-free + value-correct both modes. Spec + plan + harness amended to the stronger global model (sum all ailang_rc_stats: lines; the M2-TLS cross-attribution documented as correct behaviour). No fresh grounding-check (removes an over-strong measurement assumption). Tasks 6 (DESIGN.md frozen-layout SSOT + lockstep pointers + freeze wording + enforceability demo) and 7 (workspace-green gate) re-dispatched on the amended plan. Bench/architect milestone-close is audit-owned. iter embedding-abi-m3.1 (PARTIAL); INDEX.md line deferred to the DONE commit
2026-05-18 21:16:41 +02:00
parent 15ee3c5c8f
commit d5c565d48d
19 changed files with 893 additions and 51 deletions
@@ -0,0 +1,53 @@
+/* Embedding-ABI M3 record round-trip C host (own + borrow via a
+ * compile-time -DBORROW switch). Frozen value layout (DESIGN.md
+ * §"Embedding ABI" > "Frozen value layout"):
+ *   p - 8 .. p   uint64_t refcount header (set to 1 by ailang_rc_alloc)
+ *   p + 0        int64_t  constructor tag (single ctor → 0)
+ *   p + 8        IEEE-754 double  field 0 = Float acc
+ *   p + 16       int64_t          field 1 = Int   n
+ * Total payload = 8 + 2*8 = 24.
+ *
+ * own  : the kernel consumes each `(own (con State))` input (drop at
+ *        return); the host must NOT touch/dec it after the call.
+ * borrow: the kernel does NOT consume the `(borrow (con State))`
+ *        input; the host retains it and dec's it itself each iter.
+ * In both modes the return is host-owned and host-freed.
+ */
+#include <stdint.h>
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+
+typedef struct ailang_ctx ailang_ctx_t;
+extern ailang_ctx_t *ailang_ctx_new(void);
+extern void          ailang_ctx_free(ailang_ctx_t *);
+extern void *ailang_rc_alloc(size_t);
+extern void  ailang_rc_dec(void *);
+extern void *backtest_step(ailang_ctx_t *ctx, void *st, double sample);
+
+static void *make_state(double acc, int64_t n) {
+    void *p = ailang_rc_alloc(8 + 2 * 8);   /* header=1 set by runtime */
+    *(int64_t *)((char *)p + 0)  = 0;       /* single-ctor tag = 0     */
+    memcpy((char *)p + 8,  &acc, 8);        /* Float acc @ 8           */
+    *(int64_t *)((char *)p + 16) = n;       /* Int   n   @ 16          */
+    return p;
+}
+
+int main(void) {
+    ailang_ctx_t *ctx = ailang_ctx_new();
+    void *st = make_state(0.0, 0);
+    for (int i = 0; i < 1000000; i++) {
+        void *next = backtest_step(ctx, st, (double)(i & 7));
+#ifdef BORROW
+        ailang_rc_dec(st);   /* borrow: host retained input, frees it */
+#endif
+        /* own: kernel consumed `st`; do NOT touch/dec it here.        */
+        st = next;           /* return is host-owned                   */
+    }
+    double acc; memcpy(&acc, (char *)st + 8, 8);
+    int64_t n = *(int64_t *)((char *)st + 16);
+    assert(n == 1000000);
+    ailang_rc_dec(st);       /* host frees the final return            */
+    ailang_ctx_free(ctx);    /* AILANG_RC_STATS readback fires here    */
+    return 0;
+}