all: add support for ThinLTO

ThinLTO optimizes across LLVM modules at link time. This means that optimizations (such as inlining and const-propagation) are possible between C and Go. This makes this change especially useful for CGo, but not just for CGo. By doing some optimizations at link time, the linker can discard some unused functions and this leads to a size reduction on average. It does increase code size in some cases, but that's true for most optimizations. I've excluded a number of targets for now (wasm, avr, xtensa, windows, macos). They can probably be supported with some more work, but that should be done in separate PRs. Overall, this change results in an average 3.24% size reduction over all the tinygo.org/x/drivers smoke tests. TODO: this commit runs part of the pass pipeline twice. We should set the PrepareForThinLTO flag in the PassManagerBuilder for even further reduced code size (0.7%) and improved compilation speed.
2026-08-17 11:13:27 +00:00 · 2022-02-07 15:19:25 +01:00
parent d4b1467e4c
commit 603fff78d4
8 changed files with 121 additions and 25 deletions
@@ -105,6 +105,15 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		defer os.RemoveAll(dir)
 	}

+	// Look up the build cache directory, which is used to speed up incremental
+	// builds.
+	cacheDir := goenv.Get("GOCACHE")
+	if cacheDir == "off" {
+		// Use temporary build directory instead, effectively disabling the
+		// build cache.
+		cacheDir = dir
+	}
+
 	// Check for a libc dependency.
 	// As a side effect, this also creates the headers for the given libc, if
 	// the libc needs them.
@@ -238,12 +247,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil

 		// Determine the path of the bitcode file (which is a serialized version
 		// of a LLVM module).
-		cacheDir := goenv.Get("GOCACHE")
-		if cacheDir == "off" {
-			// Use temporary build directory instead, effectively disabling the
-			// build cache.
-			cacheDir = dir
-		}
 		bitcodePath := filepath.Join(cacheDir, "pkg-"+hex.EncodeToString(hash[:])+".bc")
 		packageBitcodePaths[pkg.ImportPath] = bitcodePath

@@ -416,7 +419,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			// Load and link all the bitcode files. This does not yet optimize
 			// anything, it only links the bitcode files together.
 			ctx := llvm.NewContext()
-			mod = ctx.NewModule("")
+			mod = ctx.NewModule("main")
 			for _, pkg := range lprogram.Sorted() {
 				pkgMod, err := ctx.ParseBitcodeFile(packageBitcodePaths[pkg.ImportPath])
 				if err != nil {
@@ -512,8 +515,14 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			}
 			return ioutil.WriteFile(outpath, llvmBuf.Bytes(), 0666)
 		case ".bc":
-			data := llvm.WriteBitcodeToMemoryBuffer(mod).Bytes()
-			return ioutil.WriteFile(outpath, data, 0666)
+			var buf llvm.MemoryBuffer
+			if config.UseThinLTO() {
+				buf = llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+			} else {
+				buf = llvm.WriteBitcodeToMemoryBuffer(mod)
+			}
+			defer buf.Dispose()
+			return ioutil.WriteFile(outpath, buf.Bytes(), 0666)
 		case ".ll":
 			data := []byte(mod.String())
 			return ioutil.WriteFile(outpath, data, 0666)
@@ -533,10 +542,17 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		dependencies: []*compileJob{programJob},
 		result:       objfile,
 		run: func(*compileJob) error {
-			llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
-			if err != nil {
-				return err
+			var llvmBuf llvm.MemoryBuffer
+			if config.UseThinLTO() {
+				llvmBuf = llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+			} else {
+				var err error
+				llvmBuf, err = machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+				if err != nil {
+					return err
+				}
 			}
+			defer llvmBuf.Dispose()
 			return ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
 		},
 	}
@@ -569,7 +585,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		job := &compileJob{
 			description: "compile extra file " + path,
 			run: func(job *compileJob) error {
-				result, err := compileAndCacheCFile(abspath, dir, config.CFlags(), config.Options.PrintCommands)
+				result, err := compileAndCacheCFile(abspath, dir, config.CFlags(), config.UseThinLTO(), config.Options.PrintCommands)
 				job.result = result
 				return err
 			},
@@ -587,7 +603,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			job := &compileJob{
 				description: "compile CGo file " + abspath,
 				run: func(job *compileJob) error {
-					result, err := compileAndCacheCFile(abspath, dir, pkg.CFlags, config.Options.PrintCommands)
+					result, err := compileAndCacheCFile(abspath, dir, pkg.CFlags, config.UseThinLTO(), config.Options.PrintCommands)
 					job.result = result
 					return err
 				},
@@ -656,6 +672,24 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			if config.Options.PrintCommands != nil {
 				config.Options.PrintCommands(config.Target.Linker, ldflags...)
 			}
+			if config.UseThinLTO() {
+				ldflags = append(ldflags,
+					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"),
+					"-plugin-opt=mcpu="+config.CPU(),
+					"-plugin-opt=O"+strconv.Itoa(optLevel),
+					"-plugin-opt=thinlto")
+				if config.CodeModel() != "default" {
+					ldflags = append(ldflags,
+						"-mllvm", "-code-model="+config.CodeModel())
+				}
+				if sizeLevel >= 2 {
+					// Workaround with roughly the same effect as
+					// https://reviews.llvm.org/D119342.
+					// Can hopefully be removed in LLVM 15.
+					ldflags = append(ldflags,
+						"-mllvm", "--rotation-max-header-size=0")
+				}
+			}
 			err = link(config.Target.Linker, ldflags...)
 			if err != nil {
 				return &commandError{"failed to link", executable, err}
@@ -846,7 +880,7 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 		}
 	}

-	if config.GOOS() != "darwin" {
+	if config.GOOS() != "darwin" && !config.UseThinLTO() {
 		transform.ApplyFunctionSections(mod) // -ffunction-sections
 	}

@@ -56,7 +56,7 @@ import (
 //   depfile but without invalidating its name. For this reason, the depfile is
 //   written on each new compilation (even when it seems unnecessary). However, it
 //   could in rare cases lead to a stale file fetched from the cache.
-func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands func(string, ...string)) (string, error) {
+func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool, printCommands func(string, ...string)) (string, error) {
 	// Hash input file.
 	fileHash, err := hashFile(abspath)
 	if err != nil {
@@ -67,6 +67,11 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), fileHash+".c.lock"))
 	defer unlock()

+	ext := ".o"
+	if thinlto {
+		ext = ".bc"
+	}
+
 	// Create cache key for the dependencies file.
 	buf, err := json.Marshal(struct {
 		Path        string
@@ -99,7 +104,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		}

 		// Obtain hashes of all the files listed as a dependency.
-		outpath, err := makeCFileCachePath(dependencies, depfileNameHash)
+		outpath, err := makeCFileCachePath(dependencies, depfileNameHash, ext)
 		if err == nil {
 			if _, err := os.Stat(outpath); err == nil {
 				return outpath, nil
@@ -112,7 +117,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		return "", err
 	}

-	objTmpFile, err := ioutil.TempFile(goenv.Get("GOCACHE"), "tmp-*.o")
+	objTmpFile, err := ioutil.TempFile(goenv.Get("GOCACHE"), "tmp-*"+ext)
 	if err != nil {
 		return "", err
 	}
@@ -124,6 +129,9 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	depTmpFile.Close()
 	flags := append([]string{}, cflags...)                                   // copy cflags
 	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name()) // autogenerate dependencies
+	if thinlto {
+		flags = append(flags, "-flto=thin")
+	}
 	flags = append(flags, "-c", "-o", objTmpFile.Name(), abspath)
 	if strings.ToLower(filepath.Ext(abspath)) == ".s" {
 		// If this is an assembly file (.s or .S, lowercase or uppercase), then
@@ -181,7 +189,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	}

 	// Move temporary object file to final location.
-	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash)
+	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash, ext)
 	if err != nil {
 		return "", err
 	}
@@ -196,7 +204,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 // Create a cache path (a path in GOCACHE) to store the output of a compiler
 // job. This path is based on the dep file name (which is a hash of metadata
 // including compiler flags) and the hash of all input files in the paths slice.
-func makeCFileCachePath(paths []string, depfileNameHash string) (string, error) {
+func makeCFileCachePath(paths []string, depfileNameHash, ext string) (string, error) {
 	// Hash all input files.
 	fileHashes := make(map[string]string, len(paths))
 	for _, path := range paths {
@@ -221,7 +229,7 @@ func makeCFileCachePath(paths []string, depfileNameHash string) (string, error)
 	outFileNameBuf := sha512.Sum512_224(buf)
 	cacheKey := hex.EncodeToString(outFileNameBuf[:])

-	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+".o")
+	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+ext)
 	return outpath, nil
 }