ERR/E3.0 (slice 3a): embedded Frame trace resolution

Return-trace frames now resolve to real `func at file:line:col`
in-process — no DWARF, no symbolizer.

- New niladic, span-stamped `.trace_frame` IR op (mirrors is_comptime):
  carries no operands; each backend derives the frame from context.
  lower.zig's placeholderTraceFrame emits it; the existing
  sx_trace_push call consumes it.
- emit_llvm: resolve the op's span + current function to
  {file(basename), line, col, func}, build an interned Frame global
  ({string,i32,i32,string}, strings cached by content), push its
  address (ptrtoint).
- interp: pack (func_id << 32 | span.start) for the comptime resolver
  (slice 3b); never a pointer.
- sx_trace.c report_unhandled derefs SxFrame; trace.sx gains the Frame
  struct, frame_at -> *Frame, and field-reading to_string. Layout
  mirrored in 3 places with cross-ref comments.

Verified JIT + AOT. Snapshots 243/244/247 regenerated (placeholder ->
func at file:line:col). Gates: zig build, zig build test,
run_examples.sh -> 290 passed.

library/modules/trace.sx

@@ -11,22 +11,30 @@
 // `catch` handler (the clear fires when the handler completes, so the body
 // still sees the chain) or the (future) failable-`main` wrapper.
 //
-// Frame resolution: a frame is an opaque u64. Resolving it to `file:line:col`
-// needs DWARF line-info (ERR E3.0), which sx does not emit yet — so for now
-// each frame prints as "<location pending DWARF>". The frame COUNT, ordering,
-// and overflow note are already meaningful; once E3.0 lands, only the
-// per-frame location string changes. (The comptime path — resolving a packed
-// `(func_id, ir_offset)` via the interpreter's IR tables — also lands with the
-// resolver in E3.0/E3.3-full.)
+// Frame resolution (ERR E3.0 slice 3a): in compiled code a frame is a pointer
+// to an interned `Frame` the compiler stamped in at the push site, so the
+// location resolves in-process with no DWARF and no symbolizer. (The comptime
+// path — a packed `(func_id, ir_offset)` resolved via the interpreter's IR
+// tables — lands with slice 3b.)
 // =====================================================================
 
 libc :: #library "c";
 
+// The compiled return-trace frame. Layout MUST match `getFrameStructType` in
+// src/ir/emit_llvm.zig and `SxFrame` in library/vendors/sx_trace_runtime/sx_trace.c.
+Frame :: struct {
+    file: string;
+    line: s32;
+    col: s32;
+    func: string;
+}
+
 // The error-trace buffer C API (library/vendors/sx_trace_runtime/sx_trace.c),
 // linked in for the JIT and auto-injected for AOT when traces are used.
+// `frame_at` hands back the stamped `*Frame` (the compiler stored its address).
 sx_trace_len       :: () -> u32 #foreign;
 sx_trace_truncated :: () -> u32 #foreign;
-sx_trace_frame_at  :: (i: u32) -> u64 #foreign;
+sx_trace_frame_at  :: (i: u32) -> *Frame #foreign;
 
 write :: (fd: s32, buf: [*]u8, count: usize) -> isize #foreign libc;
 
@@ -43,10 +51,8 @@ to_string :: () -> string {
 
     i : u32 = 0;
     while i < n {
-        frame := sx_trace_frame_at(i);
-        // DWARF (E3.0) will resolve `frame` to file:line:col + function name.
-        // Until then the raw frame value is shown (a placeholder, not a PC yet).
-        line := format("  frame {}: <location pending DWARF> (raw {})\n", i, xx frame);
+        f := sx_trace_frame_at(i);
+        line := format("  {} at {}:{}:{}\n", f.func, f.file, f.line, f.col);
         result = concat(result, line);
         i = i + 1;
     }

library/vendors/sx_trace_runtime/sx_trace.c

@@ -69,14 +69,20 @@ uint64_t sx_trace_frame_at(uint32_t i) {
     return sx_trace_frames[(base + i) % SX_TRACE_CAP];
 }
 
+// A compiled trace frame (ERR E3.0 slice 3a) is a pointer to an interned
+// `Frame { string file; i32 line; i32 col; string func; }`, where an sx
+// `string` is `{ const char* ptr; int64_t len; }`. This mirror MUST stay in
+// lockstep with `getFrameStructType` in emit_llvm.zig and `Frame` in trace.sx.
+typedef struct { const char *ptr; int64_t len; } SxStr;
+typedef struct { SxStr file; int32_t line; int32_t col; SxStr func; } SxFrame;
+
 // The failable-`main` entry-point reporter (ERR step E4.2). Called by the
 // emitted main wrapper when an error reaches the function boundary: prints the
 // unhandled-error header (with the tag name passed in — the compiler resolves
 // it from the always-linked tag-name table) followed by the surviving trace
 // frames, all to stderr. `name` is borrowed (a `string` slice, not NUL-
 // terminated), so `name_len` bounds the print. The frame format mirrors
-// trace.sx's `to_string`; both stay placeholder ("<location pending DWARF>")
-// until DWARF line-info (E3.0) lands, after which both gain real file:line:col.
+// trace.sx's `to_string` — `func at file:line:col`.
 void sx_trace_report_unhandled(uint32_t tag, const char *name, size_t name_len) {
     (void)tag;
     dprintf(2, "error: unhandled error reached main: error.%.*s\n",
@@ -88,8 +94,10 @@ void sx_trace_report_unhandled(uint32_t tag, const char *name, size_t name_len)
         dprintf(2, "  ... older frames omitted (buffer full)\n");
     }
     for (uint32_t i = 0u; i < n; i++) {
-        uint64_t frame = sx_trace_frame_at(i);
-        dprintf(2, "  frame %u: <location pending DWARF> (raw %llu)\n",
-                i, (unsigned long long)frame);
+        const SxFrame *f = (const SxFrame *)(uintptr_t)sx_trace_frame_at(i);
+        dprintf(2, "  %.*s at %.*s:%d:%d\n",
+                (int)f->func.len, f->func.ptr,
+                (int)f->file.len, f->file.ptr,
+                f->line, f->col);
     }
 }