all: add the Boehm-Demers-Weiser GC on Linux

This adds support for the well-known Boehm GC. It's significantly faster
than our own naive GC and could be used as an alternative on bigger
systems.

In the future, this GC might also be supported on WebAssembly with some
extra work. Right now it's Linux only (though Windows/MacOS shouldn't be
too difficult to add).

.gitmodules

@@ -42,3 +42,6 @@
 [submodule "lib/wasi-cli"]
 	path = lib/wasi-cli
 	url = https://github.com/WebAssembly/wasi-cli
+[submodule "lib/bdwgc"]
+	path = lib/bdwgc
+	url = https://github.com/ivmai/bdwgc.git

GNUmakefile

@@ -852,6 +852,7 @@ wasmtest:
 
 build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN)),,binaryen)
 	@mkdir -p build/release/tinygo/bin
+	@mkdir -p build/release/tinygo/lib/bdwgc
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
 	@mkdir -p build/release/tinygo/lib/macos-minimal-sdk
@@ -876,6 +877,7 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
 ifneq ($(USE_SYSTEM_BINARYEN),1)
 	@cp -p  build/wasm-opt$(EXE)         build/release/tinygo/bin
 endif
+	@cp -rp lib/bdwgc/*                  build/release/tinygo/lib/bdwgc
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS

builder/bdwgc.go

@@ -0,0 +1,71 @@
+package builder
+
+// The well-known conservative Boehm-Demers-Weiser GC.
+// This file provides a way to compile this GC for use with TinyGo.
+
+import (
+	"path/filepath"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+var BoehmGC = Library{
+	name: "bdwgc",
+	cflags: func(target, headerPath string) []string {
+		libdir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/bdwgc")
+		return []string{
+			// use a modern environment
+			"-DUSE_MMAP",              // mmap is available
+			"-DUSE_MUNMAP",            // return memory to the OS using munmap
+			"-DGC_BUILTIN_ATOMIC",     // use compiler intrinsics for atomic operations
+			"-DNO_EXECUTE_PERMISSION", // don't make the heap executable
+
+			// specific flags for TinyGo
+			"-DALL_INTERIOR_POINTERS",  // scan interior pointers (needed for Go)
+			"-DIGNORE_DYNAMIC_LOADING", // we don't support dynamic loading at the moment
+			"-DNO_GETCONTEXT",          // musl doesn't support getcontext()
+
+			// Special flag to work around the lack of __data_start in ld.lld.
+			// TODO: try to fix this in LLVM/lld directly so we don't have to
+			// work around it anymore.
+			"-DGC_DONT_REGISTER_MAIN_STATIC_DATA",
+
+			// Do not scan the stack. We have our own mechanism to do this.
+			"-DSTACK_NOT_SCANNED",
+
+			// Assertions can be enabled while debugging GC issues.
+			//"-DGC_ASSERTIONS",
+
+			// Threading is not yet supported, so these are disabled.
+			//"-DGC_THREADS",
+			//"-DTHREAD_LOCAL_ALLOC",
+
+			"-I" + libdir + "/include",
+		}
+	},
+	sourceDir: func() string {
+		return filepath.Join(goenv.Get("TINYGOROOT"), "lib/bdwgc")
+	},
+	librarySources: func(target string) ([]string, error) {
+		return []string{
+			"allchblk.c",
+			"alloc.c",
+			"blacklst.c",
+			"dbg_mlc.c",
+			"dyn_load.c",
+			"finalize.c",
+			"headers.c",
+			"mach_dep.c",
+			"malloc.c",
+			"mark.c",
+			"mark_rts.c",
+			"misc.c",
+			"new_hblk.c",
+			"obj_map.c",
+			"os_dep.c",
+			"pthread_stop_world.c",
+			"pthread_support.c",
+			"reclaim.c",
+		}, nil
+	},
+}

builder/build.go

@@ -143,20 +143,22 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	// the libc needs them.
 	root := goenv.Get("TINYGOROOT")
 	var libcDependencies []*compileJob
+	var libcJob *compileJob
 	switch config.Target.Libc {
 	case "darwin-libSystem":
 		job := makeDarwinLibSystemJob(config, tmpdir)
 		libcDependencies = append(libcDependencies, job)
 	case "musl":
-		job, unlock, err := Musl.load(config, tmpdir)
+		var unlock func()
+		libcJob, unlock, err = Musl.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
-		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
-		libcDependencies = append(libcDependencies, job)
+		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(libcJob.result), "crt1.o")))
+		libcDependencies = append(libcDependencies, libcJob)
 	case "picolibc":
-		libcJob, unlock, err := Picolibc.load(config, tmpdir)
+		libcJob, unlock, err := Picolibc.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
@@ -169,14 +171,14 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		}
 		libcDependencies = append(libcDependencies, dummyCompileJob(path))
 	case "wasmbuiltins":
-		libcJob, unlock, err := WasmBuiltins.load(config, tmpdir)
+		libcJob, unlock, err := WasmBuiltins.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
 		libcDependencies = append(libcDependencies, libcJob)
 	case "mingw-w64":
-		job, unlock, err := MinGW.load(config, tmpdir)
+		job, unlock, err := MinGW.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
@@ -652,14 +654,27 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	// Add compiler-rt dependency if needed. Usually this is a simple load from
 	// a cache.
 	if config.Target.RTLib == "compiler-rt" {
-		job, unlock, err := CompilerRT.load(config, tmpdir)
+		job, unlock, err := CompilerRT.load(config, tmpdir, nil)
 		if err != nil {
 			return result, err
 		}
 		defer unlock()
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
+	// The Boehm collector is stored in a separate C library.
+	if config.GC() == "boehm" {
+		if libcJob == nil {
+			return BuildResult{}, fmt.Errorf("boehm GC isn't supported with libc %s", config.Target.Libc)
+		}
+		job, unlock, err := BoehmGC.load(config, tmpdir, libcJob)
+		if err != nil {
+			return BuildResult{}, err
+		}
+		defer unlock()
+		linkerDependencies = append(linkerDependencies, job)
+	}
+
 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.

builder/library.go

@@ -39,7 +39,7 @@ type Library struct {
 // The resulting directory may be stored in the provided tmpdir, which is
 // expected to be removed after the Load call.
 func (l *Library) Load(config *compileopts.Config, tmpdir string) (dir string, err error) {
-	job, unlock, err := l.load(config, tmpdir)
+	job, unlock, err := l.load(config, tmpdir, nil)
 	if err != nil {
 		return "", err
 	}
@@ -56,7 +56,11 @@ func (l *Library) Load(config *compileopts.Config, tmpdir string) (dir string, e
 // output archive file, it is expected to be removed after use.
 // As a side effect, this call creates the library header files if they didn't
 // exist yet.
-func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, abortLock func(), err error) {
+// The provided libc job (if not null) will cause this libc to be added as a
+// dependency for all C compiler jobs, and adds libc headers for the given
+// target config. In other words, pass this libc if the library needs a libc to
+// compile.
+func (l *Library) load(config *compileopts.Config, tmpdir string, libc *compileJob) (job *compileJob, abortLock func(), err error) {
 	outdir, precompiled := config.LibcPath(l.name)
 	archiveFilePath := filepath.Join(outdir, "lib.a")
 	if precompiled {
@@ -185,6 +189,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	if strings.HasPrefix(target, "mips") {
 		args = append(args, "-fno-pic")
 	}
+	if libc != nil {
+		args = append(args, config.LibcCFlags()...)
+	}
 
 	var once sync.Once
 
@@ -237,7 +244,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		objpath := filepath.Join(dir, cleanpath+".o")
 		os.MkdirAll(filepath.Dir(objpath), 0o777)
 		objs = append(objs, objpath)
-		job.dependencies = append(job.dependencies, &compileJob{
+		objfile := &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
@@ -252,7 +259,11 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return nil
 			},
-		})
+		}
+		if libc != nil {
+			objfile.dependencies = append(objfile.dependencies, libc)
+		}
+		job.dependencies = append(job.dependencies, objfile)
 	}
 
 	// Create crt1.o job, if needed.
@@ -261,7 +272,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// won't make much of a difference in speed).
 	if l.crt1Source != "" {
 		srcpath := filepath.Join(sourceDir, l.crt1Source)
-		job.dependencies = append(job.dependencies, &compileJob{
+		crt1Job := &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
@@ -281,7 +292,11 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return os.Rename(tmpfile.Name(), filepath.Join(outdir, "crt1.o"))
 			},
-		})
+		}
+		if libc != nil {
+			crt1Job.dependencies = append(crt1Job.dependencies, libc)
+		}
+		job.dependencies = append(job.dependencies, crt1Job)
 	}
 
 	ok = true

compileopts/config.go

@@ -231,6 +231,10 @@ func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 	if c.ABI() != "" {
 		archname += "-" + c.ABI()
 	}
+	if name == "bdwgc" {
+		// Boehm GC is compiled against a particular libc.
+		archname += "-" + c.Target.Libc
+	}
 
 	// Try to load a precompiled library.
 	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, name)
@@ -285,81 +289,92 @@ func (c *Config) CFlags(libclang bool) []string {
 			"-resource-dir="+resourceDir,
 		)
 	}
+	cflags = append(cflags, c.LibcCFlags()...)
+	// Always emit debug information. It is optionally stripped at link time.
+	cflags = append(cflags, "-gdwarf-4")
+	// Use the same optimization level as TinyGo.
+	cflags = append(cflags, "-O"+c.Options.Opt)
+	// Set the LLVM target triple.
+	cflags = append(cflags, "--target="+c.Triple())
+	// Set the -mcpu (or similar) flag.
+	if c.Target.CPU != "" {
+		if c.GOARCH() == "amd64" || c.GOARCH() == "386" {
+			// x86 prefers the -march flag (-mcpu is deprecated there).
+			cflags = append(cflags, "-march="+c.Target.CPU)
+		} else if strings.HasPrefix(c.Triple(), "avr") {
+			// AVR MCUs use -mmcu instead of -mcpu.
+			cflags = append(cflags, "-mmcu="+c.Target.CPU)
+		} else {
+			// The rest just uses -mcpu.
+			cflags = append(cflags, "-mcpu="+c.Target.CPU)
+		}
+	}
+	// Set the -mabi flag, if needed.
+	if c.ABI() != "" {
+		cflags = append(cflags, "-mabi="+c.ABI())
+	}
+	return cflags
+}
+
+// LibcCFlags returns the C compiler flags for the configured libc.
+// It only uses flags that are part of the libc path (triple, cpu, abi, libc
+// name) so it can safely be used to compile another C library.
+func (c *Config) LibcCFlags() []string {
 	switch c.Target.Libc {
 	case "darwin-libSystem":
 		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(root, "lib/macos-minimal-sdk/src/usr/include"),
-		)
+		}
 	case "picolibc":
 		root := goenv.Get("TINYGOROOT")
 		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
 		path, _ := c.LibcPath("picolibc")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(picolibcDir, "include"),
 			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
-		)
+		}
 	case "musl":
 		root := goenv.Get("TINYGOROOT")
 		path, _ := c.LibcPath("musl")
 		arch := MuslArchitecture(c.Triple())
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
+			"-isystem", filepath.Join(root, "lib", "musl", "arch", "generic"),
 			"-isystem", filepath.Join(root, "lib", "musl", "include"),
-		)
+		}
 	case "wasi-libc":
 		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
-			"-isystem", root+"/lib/wasi-libc/sysroot/include")
+			"-isystem", root + "/lib/wasi-libc/sysroot/include",
+		}
 	case "wasmbuiltins":
 		// nothing to add (library is purely for builtins)
+		return nil
 	case "mingw-w64":
 		root := goenv.Get("TINYGOROOT")
 		path, _ := c.LibcPath("mingw-w64")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
 			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
 			"-D_UCRT",
-		)
+		}
 	case "":
 		// No libc specified, nothing to add.
+		return nil
 	default:
 		// Incorrect configuration. This could be handled in a better way, but
 		// usually this will be found by developers (not by TinyGo users).
 		panic("unknown libc: " + c.Target.Libc)
 	}
-	// Always emit debug information. It is optionally stripped at link time.
-	cflags = append(cflags, "-gdwarf-4")
-	// Use the same optimization level as TinyGo.
-	cflags = append(cflags, "-O"+c.Options.Opt)
-	// Set the LLVM target triple.
-	cflags = append(cflags, "--target="+c.Triple())
-	// Set the -mcpu (or similar) flag.
-	if c.Target.CPU != "" {
-		if c.GOARCH() == "amd64" || c.GOARCH() == "386" {
-			// x86 prefers the -march flag (-mcpu is deprecated there).
-			cflags = append(cflags, "-march="+c.Target.CPU)
-		} else if strings.HasPrefix(c.Triple(), "avr") {
-			// AVR MCUs use -mmcu instead of -mcpu.
-			cflags = append(cflags, "-mmcu="+c.Target.CPU)
-		} else {
-			// The rest just uses -mcpu.
-			cflags = append(cflags, "-mcpu="+c.Target.CPU)
-		}
-	}
-	// Set the -mabi flag, if needed.
-	if c.ABI() != "" {
-		cflags = append(cflags, "-mabi="+c.ABI())
-	}
-	return cflags
 }
 
 // LDFlags returns the flags to pass to the linker. A few more flags are needed

compileopts/options.go

@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise"}
+	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise", "boehm"}
 	validSchedulerOptions     = []string{"none", "tasks", "asyncify"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}