fix(lib): opt+llc native codegen, pkgIRs, unified @llvm.used, stacktrace frame names

Author: Azer0s

backend.go

@@ -69,6 +69,36 @@ func optThinLtoPreLinkPass(optLevel string) string {
 	}
 }
 
+// compileIRToNativeObj compiles an LLVM IR `.ll` to a native ELF/Mach-O
+// relocatable object without LTO. Used by --lib mode where the caller
+// wants a plain .o for ld -r, not ThinLTO bitcode.
+// Pipeline: opt <optLevel> (middle-end) -> llc -filetype=obj (codegen).
+func compileIRToNativeObj(llPath, outPath, optLevel string) error {
+	bcFile, err := os.CreateTemp("", "tin-lib-*.bc")
+	if err != nil {
+		return fmt.Errorf("cannot create temp bitcode file: %w", err)
+	}
+	bcPath := bcFile.Name()
+	_ = bcFile.Close()
+	defer func() { _ = os.Remove(bcPath) }()
+
+	optCmd := exec.Command("opt", optLevel, llPath, "-o", bcPath)
+	optCmd.Stdout = os.Stdout
+	optCmd.Stderr = os.Stderr
+	if err := optCmd.Run(); err != nil {
+		return fmt.Errorf("opt %s: %w", llPath, err)
+	}
+
+	llcCmd := exec.Command("llc", "-filetype=obj", "--relocation-model=pic", bcPath, "-o", outPath)
+	llcCmd.Stdout = os.Stdout
+	llcCmd.Stderr = os.Stderr
+	if err := llcCmd.Run(); err != nil {
+		return fmt.Errorf("llc %s: %w", bcPath, err)
+	}
+
+	return nil
+}
+
 // compileIRToObj compiles an LLVM IR `.ll` input into ThinLTO bitcode.
 // The actual codegen happens in ld.lld at link time -- matches what
 // `clang -c -flto=thin` does internally, just bypassing the clang

codegen/codegen.go

@@ -370,6 +370,10 @@ type CodeGen struct {
 	// end of Generate materializes one global per module.
 	llvmUsedRoots map[*ir.Module][]*ir.Global
 
+	// llvmUsedFuncs is the per-module list of functions to include in
+	// the same combined @llvm.used emission (alongside llvmUsedRoots).
+	llvmUsedFuncs map[*ir.Module][]*ir.Func
+
 	// monoMods holds dedicated content-addressed modules carrying
 	// monomorphized fn bodies (step 5 of incremental compilation).
 	// Keyed by mono_hash; populated by extractMonoModules during

codegen/interop.go

@@ -471,23 +471,9 @@ func (cg *CodeGen) emitInteropWrappers(stmts []ast.Node) error {
 // passes. The user's contract is "this function is callable from C";
 // linker DCE breaks that contract.
 func (cg *CodeGen) pinInteropWrappers(wrappers []*ir.Func) {
-	if len(wrappers) == 0 {
-		return
+	for _, f := range wrappers {
+		cg.registerLlvmUsedFunc(cg.mod, f)
 	}
-
-	i8Ptr := irtypes.I8Ptr
-
-	entries := make([]constant.Constant, len(wrappers))
-	for i, f := range wrappers {
-		entries[i] = constant.NewBitCast(f, i8Ptr)
-	}
-
-	arrTy := irtypes.NewArray(uint64(len(wrappers)), i8Ptr)
-	init := constant.NewArray(arrTy, entries...)
-
-	used := cg.mod.NewGlobalDef("llvm.used", init)
-	used.Linkage = enum.LinkageAppending
-	used.Section = "llvm.metadata"
 }
 
 // emitInteropWrapperFor emits a single wrapper. Assumes the validation
@@ -521,6 +507,16 @@ func (cg *CodeGen) emitInteropWrapperWithName(fn *ast.FuncDecl, wrapperName stri
 		return cg.nodeErr(fn, "fn %s: #interop entry resolved to non-function value", fn.Name)
 	}
 
+	// Override the pclntab display name so stacktrace() reports the
+	// C-visible symbol (__tin_interop_<name>) rather than the Tin source
+	// name. The heuristic would already return the IR name unchanged
+	// (it starts with __tin_), but recordFnDisplayName stored the Tin
+	// source name earlier; override it here.
+	if cg.fnDisplayNames == nil {
+		cg.fnDisplayNames = map[string]string{}
+	}
+	cg.fnDisplayNames[internalFn.Name()] = internalFn.Name()
+
 	// When the active emit target is a sibling module (CTFE shimMod),
 	// internalFn lives in cg.mod and is unreachable from the wrapper's
 	// blocks. Mirror it as a `declare` in the active module so calls
@@ -706,6 +702,7 @@ func (cg *CodeGen) emitInteropWrapperWithName(fn *ast.FuncDecl, wrapperName stri
 	}
 
 	wrapper := cg.activeModule().NewFunc(wrapperName, retType, wrapperParams...)
+	wrapper.FuncAttrs = append(wrapper.FuncAttrs, ir.AttrString("noinline"))
 	block := wrapper.NewBlock("entry")
 	// Skip the tin_runtime_init bootstrap when emitting into the CTFE
 	// shim module: the dispatcher (Tin compiler) doesn't link the runtime

codegen/reflect_table.go

@@ -137,20 +137,47 @@ func (cg *CodeGen) registerLlvmUsed(mod *ir.Module, g *ir.Global) {
 	cg.llvmUsedRoots[mod] = append(cg.llvmUsedRoots[mod], g)
 }
 
+// registerLlvmUsedFunc appends f to mod's pending llvm.used funcs. Idempotent
+// per (module, function).
+func (cg *CodeGen) registerLlvmUsedFunc(mod *ir.Module, f *ir.Func) {
+	if cg.llvmUsedFuncs == nil {
+		cg.llvmUsedFuncs = map[*ir.Module][]*ir.Func{}
+	}
+
+	for _, existing := range cg.llvmUsedFuncs[mod] {
+		if existing == f {
+			return
+		}
+	}
+
+	cg.llvmUsedFuncs[mod] = append(cg.llvmUsedFuncs[mod], f)
+}
+
 // emitLlvmUsedRoots materializes the per-module @llvm.used global from
-// every root collected via registerLlvmUsed. Must be the LAST step in
-// codegen (after every emitter that would call registerLlvmUsed) so
-// nothing is missed and no two @llvm.used collide in the same module.
+// every root collected via registerLlvmUsed / registerLlvmUsedFunc. Must be
+// the LAST step in codegen so nothing is missed and no two @llvm.used collide
+// in the same module.
 func (cg *CodeGen) emitLlvmUsedRoots() {
-	for mod, roots := range cg.llvmUsedRoots {
-		if len(roots) == 0 {
-			continue
-		}
+	mods := map[*ir.Module]struct{}{}
+	for mod := range cg.llvmUsedRoots {
+		mods[mod] = struct{}{}
+	}
+	for mod := range cg.llvmUsedFuncs {
+		mods[mod] = struct{}{}
+	}
 
-		used := make([]constant.Constant, 0, len(roots))
-		for _, g := range roots {
+	for mod := range mods {
+		used := make([]constant.Constant, 0)
+		for _, g := range cg.llvmUsedRoots[mod] {
 			used = append(used, constant.NewBitCast(g, irtypes.I8Ptr))
 		}
+		for _, f := range cg.llvmUsedFuncs[mod] {
+			used = append(used, constant.NewBitCast(f, irtypes.I8Ptr))
+		}
+
+		if len(used) == 0 {
+			continue
+		}
 
 		usedArrTy := irtypes.NewArray(uint64(len(used)), irtypes.I8Ptr)
 		usedInit := constant.NewArray(usedArrTy, used...)

main.go

@@ -1628,20 +1628,48 @@ func compileIRWithPkgs(ir string, pkgIRs []namedIR, outBin string, libMode bool,
 
 		defer func() { _ = os.Remove(irObjName) }()
 
-		irArgs := append([]string{optLevel, "-c"}, clangTargetFlag()...)
-		irArgs = append(irArgs, llInputFile, "-o", irObjName)
-		clangIR := exec.Command("clang", irArgs...)
-		clangIR.Stdout = os.Stdout
-		clangIR.Stderr = os.Stderr
-
-		if err := clangIR.Run(); err != nil {
+		if err := compileIRToNativeObj(llInputFile, irObjName, optLevel); err != nil {
 			return err
 		}
 
 		objs := []string{irObjName}
 
 		var tmpObjs []string
 
+		for _, pkg := range pkgIRs {
+			pkgLL, err := os.CreateTemp("", "tin-pkg-*.ll")
+			if err != nil {
+				return fmt.Errorf("cannot create temp IR file: %w", err)
+			}
+			pkgLLName := pkgLL.Name()
+			if _, err := pkgLL.WriteString(pkg.irText); err != nil {
+				_ = pkgLL.Close()
+				_ = os.Remove(pkgLLName)
+				return err
+			}
+			_ = pkgLL.Close()
+
+			pkgObj, err := os.CreateTemp("", "tin-pkg-*.o")
+			if err != nil {
+				_ = os.Remove(pkgLLName)
+				return fmt.Errorf("cannot create temp object file: %w", err)
+			}
+			pkgObjName := pkgObj.Name()
+			_ = pkgObj.Close()
+
+			tmpObjs = append(tmpObjs, pkgLLName, pkgObjName)
+
+			if err := compileIRToNativeObj(pkgLLName, pkgObjName, optLevel); err != nil {
+				for _, f := range tmpObjs {
+					_ = os.Remove(f)
+				}
+				_ = os.Remove(pkgLLName)
+				return err
+			}
+
+			objs = append(objs, pkgObjName)
+		}
+
 		for _, cs := range cSources {
 			cObj, err := os.CreateTemp("", "tin-c-*.o")
 			if err != nil {

runtime/stacktrace.c

@@ -381,11 +381,20 @@ static int32_t resolve_frame(uintptr_t ip, int spawn_of, int32_t flags) {
                 written = snprintf(buf, sizeof buf, "\"%s%s:%s+0x%lx\"",
                     spawn_pfx, lib, sym_name, off);
             }
-        } else if (off == 0 && !spawn_of) {
-            written = snprintf(buf, sizeof buf, "%s", sym_name);
         } else {
-            written = snprintf(buf, sizeof buf, "\"%s%s+0x%lx\"",
-                spawn_pfx, sym_name, off);
+            // Main binary: include the binary name after @ so callers can
+            // tell which binary the symbol belongs to without DWARF.
+            // Produces "sym@binary+0x<off>" (analogous to pclntab's "sym@file:line").
+            const char *fname = (have_dli && info.dli_fname) ? info.dli_fname : "";
+            const char *fbase = strrchr(fname, '/');
+            const char *bin   = fbase ? fbase + 1 : fname;
+            if (off == 0 && !spawn_of) {
+                written = snprintf(buf, sizeof buf, "\"%s%s@%s\"",
+                    spawn_pfx, sym_name, bin);
+            } else {
+                written = snprintf(buf, sizeof buf, "\"%s%s@%s+0x%lx\"",
+                    spawn_pfx, sym_name, bin, off);
+            }
         }
     } else {
         written = snprintf(buf, sizeof buf, "\"%s??+0x%lx\"",