[Feat] Enable LTO

Signed-off-by: ZhouGuangyuan <zhouguangyuan.xian@gmail.com>

Author: zhouguangyuan0718

_demo/embed/targetsbuild/build.sh

@@ -111,6 +111,7 @@ case "$test_dir" in
 			"riscv32"
 			"riscv64"
 			"rp2040"
+			"nintendoswitch" # undefined symbol under lto, should not work when no-lto
 		)
 		;;
 	defer)

internal/build/build.go

@@ -897,6 +897,7 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPa
 	// linkInputs contains .a archives from all packages and .o files from main module
 	var linkInputs []string
 	var linkArgs []string
+	var publicAPISymbols []string
 	var rtLinkInputs []string
 	var rtLinkArgs []string
 	linkedPkgs := make(map[string]bool) // Track linked packages by ID to avoid duplicates
@@ -929,6 +930,7 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPa
 			if aPkg.LPkg.NeedAbiInit {
 				needAbiInit = true
 			}
+			publicAPISymbols = append(publicAPISymbols, exportedSymbols(aPkg)...)
 
 			linkArgs = append(linkArgs, aPkg.LinkArgs...)
 			if aPkg.ArchiveFile != "" {
@@ -976,6 +978,7 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPa
 			}
 		}
 	}
+	linkArgs = append(linkArgs, ltoPublicAPIArgs(ctx, publicAPISymbols)...)
 
 	err = linkObjFiles(ctx, outputPath, linkInputs, linkArgs, verbose)
 	if err != nil {
@@ -985,6 +988,68 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPa
 	return nil
 }
 
+func exportedSymbols(aPkg *aPackage) []string {
+	if aPkg == nil || aPkg.LPkg == nil {
+		return nil
+	}
+	exports := aPkg.LPkg.ExportFuncs()
+	if len(exports) == 0 {
+		return nil
+	}
+	symbols := make([]string, 0, len(exports))
+	for _, symbol := range exports {
+		symbols = append(symbols, symbol)
+	}
+	return symbols
+}
+
+func ltoPublicAPIArgs(ctx *context, symbols []string) []string {
+	if !isLTOEnabled(ctx.crossCompile) {
+		return nil
+	}
+	symbols = normalizeSymbols(symbols)
+	if len(symbols) == 0 {
+		return nil
+	}
+	return []string{
+		"-mllvm",
+		"-internalize-public-api-list=" + strings.Join(symbols, ","),
+	}
+}
+
+func isLTOEnabled(cfg crosscompile.Export) bool {
+	return hasLTOFlag(cfg.CFLAGS) || hasLTOFlag(cfg.CCFLAGS) || hasLTOFlag(cfg.LDFLAGS)
+}
+
+func hasLTOFlag(flags []string) bool {
+	for _, flag := range flags {
+		if strings.Contains(flag, "lto") {
+			return true
+		}
+	}
+	return false
+}
+
+func normalizeSymbols(symbols []string) []string {
+	if len(symbols) == 0 {
+		return nil
+	}
+	seen := make(map[string]struct{}, len(symbols))
+	out := make([]string, 0, len(symbols))
+	for _, symbol := range symbols {
+		if symbol == "" {
+			continue
+		}
+		if _, ok := seen[symbol]; ok {
+			continue
+		}
+		seen[symbol] = struct{}{}
+		out = append(out, symbol)
+	}
+	slices.Sort(out)
+	return out
+}
+
 // isRuntimePkg reports whether the package path belongs to the llgo runtime tree.
 func isRuntimePkg(pkgPath string) bool {
 	rtRoot := env.LLGoRuntimePkg

internal/build/lto_exports_test.go

@@ -0,0 +1,46 @@
+//go:build !llgo
+// +build !llgo
+
+package build
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/goplus/llgo/internal/crosscompile"
+)
+
+func TestNormalizeSymbols(t *testing.T) {
+	got := normalizeSymbols([]string{"beta", "", "alpha", "beta", "alpha", "gamma"})
+	want := []string{"alpha", "beta", "gamma"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("normalizeSymbols() = %v, want %v", got, want)
+	}
+}
+
+func TestLTOPublicAPIArgs(t *testing.T) {
+	ctx := &context{
+		crossCompile: crosscompile.Export{
+			LDFLAGS: []string{"--lto-O0"},
+		},
+	}
+	got := ltoPublicAPIArgs(ctx, []string{"beta", "alpha", "beta"})
+	want := []string{
+		"-mllvm",
+		"-internalize-public-api-list=alpha,beta",
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("ltoPublicAPIArgs() = %v, want %v", got, want)
+	}
+}
+
+func TestLTOPublicAPIArgsDisabledWithoutLTO(t *testing.T) {
+	ctx := &context{
+		crossCompile: crosscompile.Export{
+			LDFLAGS: []string{"-Wl,--icf=safe"},
+		},
+	}
+	if got := ltoPublicAPIArgs(ctx, []string{"alpha"}); got != nil {
+		t.Fatalf("ltoPublicAPIArgs() = %v, want nil", got)
+	}
+}

internal/build/plan9asm.go

@@ -254,6 +254,10 @@ func filterPlan9AsmFuncs(pkgPath, goos, goarch string, funcs []plan9asm.Func, re
 		if pkgPath == "syscall" && goos == "linux" && (goarch == "arm64" || goarch == "amd64") && strings.HasSuffix(resolved, "rawVforkSyscall") {
 			continue
 		}
+		if pkgPath == "syscall" && goos == "darwin" && (goarch == "arm64" || goarch == "amd64") &&
+			(strings.HasSuffix(resolved, "RawSyscall") || strings.HasSuffix(resolved, "RawSyscall6")) {
+			continue
+		}
 		keep = append(keep, fn)
 	}
 	return keep

internal/crosscompile/crosscompile.go

@@ -225,8 +225,9 @@ func use(goos, goarch string, wasiThreads, forceEspClang bool) (export Export, e
 			"-Wl,--error-limit=0",
 			"-fuse-ld=lld",
 			// Enable ICF (Identical Code Folding) to reduce binary size
-			"-Xlinker",
-			"--icf=safe",
+			"-Wl,--icf=safe",
+			// Enable ThinLTO, Using default lto kind(thinlto).
+			"-Wl,--lto-O0",
 		}
 		if clangRoot != "" {
 			clangLib := filepath.Join(clangRoot, "lib")
@@ -249,6 +250,7 @@ func use(goos, goarch string, wasiThreads, forceEspClang bool) (export Export, e
 		export.CCFLAGS = []string{
 			"-Qunused-arguments",
 			"-Wno-unused-command-line-argument",
+			"-flto=thin",
 		}
 
 		// Add sysroot for macOS only
@@ -499,6 +501,13 @@ func UseTarget(targetName string) (export Export, err error) {
 	expandedCFlags := env.ExpandEnvSlice(config.CFlags, envs)
 	cflags = append(cflags, expandedCFlags...)
 
+	if config.Linker == "ld.lld" {
+		// Enable ThinLTO, Using default lto kind(thinlto).
+		ldflags = append(ldflags, "--lto-O0")
+		cflags = append(cflags, "-flto=thin")
+		ccflags = append(ccflags, "-flto=thin")
+	}
+
 	// The following parameters are inspired by tinygo/builder/library.go
 	// Handle CPU configuration
 	if cpu != "" {
@@ -545,6 +554,8 @@ func UseTarget(targetName string) (export Export, err error) {
 		ccflags = append(ccflags, "-fforce-enable-int128")
 	case "riscv64":
 		ccflags = append(ccflags, "-march=rv64gc")
+		// codegen option should be added to ldflags for lto
+		ldflags = append(ldflags, "-mllvm", "-march=rv64gc")
 	case "mips":
 		ccflags = append(ccflags, "-fno-pic")
 	}
@@ -574,9 +585,13 @@ func UseTarget(targetName string) (export Export, err error) {
 	// Handle code generation configuration
 	if config.CodeModel != "" {
 		ccflags = append(ccflags, "-mcmodel="+config.CodeModel)
+		// codegen option should be added to ldflags for lto
+		ldflags = append(ldflags, "-mllvm", "-code-model="+config.CodeModel)
 	}
 	if config.TargetABI != "" {
 		ccflags = append(ccflags, "-mabi="+config.TargetABI)
+		// codegen option should be added to ldflags for lto
+		ldflags = append(ldflags, "-mllvm", "-target-abi="+config.TargetABI)
 	}
 	if config.RelocationModel != "" {
 		switch config.RelocationModel {

ssa/datastruct.go

@@ -342,6 +342,10 @@ func (b Builder) Slice(x, low, high, max Expr) (ret Expr) {
 	if lowIsNil {
 		low = prog.IntVal(0, prog.Int())
 	}
+	low = b.fitIntSize(low)
+	if !high.IsNil() {
+		high = b.fitIntSize(high)
+	}
 	switch t := x.raw.Type.Underlying().(type) {
 	case *types.Basic:
 		if t.Kind() != types.String {
@@ -382,6 +386,7 @@ func (b Builder) Slice(x, low, high, max Expr) (ret Expr) {
 	if max.IsNil() {
 		max = nCap
 	}
+	max = b.fitIntSize(max)
 	ret.impl = b.InlineCall(b.Pkg.rtFunc("NewSlice3"), base, nEltSize, nCap, low, high, max).impl
 	return
 }

ssa/decl.go

@@ -211,6 +211,10 @@ func (p Package) NewFuncEx(name string, sig *types.Signature, bg Background, has
 	if instantiated {
 		fn.SetLinkage(llvm.LinkOnceAnyLinkage)
 	}
+	if p.Prog.requiresFramePointer() {
+		attr := p.mod.Context().CreateStringAttribute("frame-pointer", "non-leaf")
+		fn.AddFunctionAttr(attr)
+	}
 	ret := newFunction(fn, t, p, p.Prog, hasFreeVars)
 	p.fns[name] = ret
 	return ret
@@ -342,6 +346,10 @@ func (p Function) Block(idx int) BasicBlock {
 	return p.blks[idx]
 }
 
+func (p Program) requiresFramePointer() bool {
+	return p.target != nil && p.target.GOOS == "darwin" && p.target.GOARCH == "arm64"
+}
+
 // SetRecover sets the recover block for the function.
 func (p Function) SetRecover(blk BasicBlock) {
 	p.recov = blk

ssa/ssa_test.go

@@ -145,6 +145,37 @@ func TestClosureCtx(t *testing.T) {
 	f.closureCtx(nil)
 }
 
+
+func TestNewFuncExFramePointerAttrOnDarwinArm64(t *testing.T) {
+	prog := NewProgram(&Target{GOOS: "darwin", GOARCH: "arm64"})
+	pkg := prog.NewPackage("main", "main")
+	sig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+
+	fn := pkg.NewFunc("Foo", sig, InGo)
+	attr := fn.impl.GetStringAttributeAtIndex(-1, "frame-pointer")
+	if attr.IsNil() {
+		t.Fatal("missing frame-pointer function attribute")
+	}
+	if got := pkg.String(); !strings.Contains(got, `"frame-pointer"="non-leaf"`) {
+		t.Fatalf("module missing frame-pointer attribute:\n%s", got)
+	}
+}
+
+func TestNewFuncExFramePointerAttrNotForcedOnOtherTargets(t *testing.T) {
+	prog := NewProgram(&Target{GOOS: "linux", GOARCH: "amd64"})
+	pkg := prog.NewPackage("main", "main")
+	sig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+
+	fn := pkg.NewFunc("Foo", sig, InGo)
+	attr := fn.impl.GetStringAttributeAtIndex(-1, "frame-pointer")
+	if !attr.IsNil() {
+		t.Fatal("unexpected frame-pointer function attribute")
+	}
+	if got := pkg.String(); strings.Contains(got, `"frame-pointer"="non-leaf"`) {
+		t.Fatalf("unexpected frame-pointer attribute in module:\n%s", got)
+	}
+}
+
 func TestClosureNoCtxValue(t *testing.T) {
 	prog := NewProgram(nil)
 	pkg := prog.NewPackage("bar", "foo/bar")