Implement buildmode=c-archive

builder/build.go

@@ -785,7 +785,9 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	}
 
 	// Add libc dependencies, if they exist.
-	linkerDependencies = append(linkerDependencies, libcDependencies...)
+	if config.BuildMode() != "c-archive" {
+		linkerDependencies = append(linkerDependencies, libcDependencies...)
+	}
 
 	// Add embedded files.
 	linkerDependencies = append(linkerDependencies, embedFileObjects...)
@@ -828,6 +830,84 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				}
 				ldflags = append(ldflags, dependency.result)
 			}
+
+			if config.BuildMode() == "c-archive" {
+				ctx := llvm.NewContext()
+				mod = ctx.NewModule("main")
+				for _, dependency := range job.dependencies {
+					if strings.HasSuffix(dependency.description, ".S") ||
+						strings.HasSuffix(dependency.result, ".a") {
+						continue
+					}
+					depMod, err := ctx.ParseBitcodeFile(dependency.result)
+					if err != nil {
+						return err
+					}
+					err = llvm.LinkModules(mod, depMod)
+					if err != nil {
+						return err
+					}
+				}
+				for _, name := range []string{"main", "malloc", "calloc", "free"} {
+					if fn := mod.NamedFunction(name); !fn.IsNil() {
+						fn2 := llvm.AddFunction(mod, name, fn.Type())
+						fn.ReplaceAllUsesWith(fn2)
+						fn.EraseFromParentAsFunction()
+						fn2.SetName(name)
+					}
+				}
+				if config.Triple() == "xtensa" {
+					for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+						if strings.HasPrefix(fn.Name(), "__atomic_") ||
+							strings.HasPrefix(fn.Name(), "__sync_") {
+							fn.SetLinkage(llvm.InternalLinkage)
+						}
+						fn.SetSection(".text." + fn.Name())
+						if fn.Name() == "tinygo_scanstack" {
+							fn.SetSection(".text.tinygo_scanCurrentStack")
+						}
+					}
+				}
+				buf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+				if err != nil {
+					return err
+				}
+				defer buf.Dispose()
+				err = os.WriteFile(result.Executable, buf.Bytes(), 0666)
+				if err != nil {
+					return err
+				}
+				objs := []string{result.Executable}
+				for _, dependency := range job.dependencies {
+					if strings.HasSuffix(dependency.description, ".S") {
+						objs = append(objs, dependency.result)
+					}
+				}
+				if config.Triple() == "xtensa" {
+					obj := result.Executable + ".o"
+					err = link(config.Target.Linker, append(objs, "-r", "-o", obj)...)
+					if err != nil {
+						return err
+					}
+					objs = []string{obj}
+					name, err := LookupCommand("llvm-objcopy")
+					if err != nil {
+						return err
+					}
+					err = exec.Command(name, "--strip-symbol", "call_start_cpu0", obj).Run()
+					if err != nil {
+						return err
+					}
+				}
+				result.Binary = result.Executable + ".a"
+				f, err := os.Create(result.Binary)
+				if err != nil {
+					return err
+				}
+				defer f.Close()
+				return makeArchive(f, objs)
+			}
+
 			ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
 			ldflags = append(ldflags, "-mllvm", "-mattr="+config.Features()) // needed for MIPS softfloat
 			if config.GOOS() == "windows" {

builder/commands.go

@@ -22,6 +22,7 @@ func init() {
 	commands["ld.lld"] = []string{"ld.lld-" + llvmMajor, "ld.lld"}
 	commands["wasm-ld"] = []string{"wasm-ld-" + llvmMajor, "wasm-ld"}
 	commands["lldb"] = []string{"lldb-" + llvmMajor, "lldb"}
+	commands["llvm-objcopy"] = []string{"llvm-objcopy-" + llvmMajor, "llvm-objcopy"}
 	// Add the path to a Homebrew-installed LLVM for ease of use (no need to
 	// manually set $PATH).
 	if runtime.GOOS == "darwin" {
@@ -39,6 +40,7 @@ func init() {
 		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
 		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
 		commands["lldb"] = append(commands["lldb"], prefix+"lldb")
+		commands["llvm-objcopy"] = append(commands["llvm-objcopy"], prefix+"llvm-objcopy")
 	}
 	// Add the path for when LLVM was installed with the installer from
 	// llvm.org, which by default doesn't add LLVM to the $PATH environment

compileopts/config.go

@@ -325,6 +325,9 @@ func (c *Config) DefaultBinaryExtension() string {
 		// I think it's a good tradition, so let's keep it.
 		return ".elf"
 	}
+	if c.BuildMode() == "c-archive" {
+		return ".a"
+	}
 	// Linux, MacOS, etc, don't use a file extension. Use it as a fallback.
 	return ""
 }

compileopts/options.go

@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	validBuildModeOptions     = []string{"default", "c-shared", "wasi-legacy"}
+	validBuildModeOptions     = []string{"default", "c-archive", "c-shared", "wasi-legacy"}
 	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise", "boehm"}
 	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads", "cores"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}

compileopts/target.go

@@ -398,7 +398,9 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 	llvmvendor := "unknown"
 	switch options.GOOS {
 	case "darwin":
-		spec.GC = "boehm"
+		if options.GC == "boehm" {
+			spec.GC = "boehm"
+		}
 		platformVersion := "10.12.0"
 		if options.GOARCH == "arm64" {
 			platformVersion = "11.0.0" // first macosx platform with arm64 support
@@ -418,10 +420,13 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		)
 		spec.ExtraFiles = append(spec.ExtraFiles,
 			"src/internal/futex/futex_darwin.c",
-			"src/internal/task/task_threads.c",
 			"src/runtime/os_darwin.c",
 			"src/runtime/runtime_unix.c",
 			"src/runtime/signal.c")
+		if options.Scheduler == "threads" {
+			spec.ExtraFiles = append(spec.ExtraFiles,
+				"src/internal/task/task_threads.c")
+		}
 	case "linux":
 		spec.GC = "boehm"
 		spec.Scheduler = "threads"

src/runtime/baremetal.go

@@ -30,6 +30,16 @@ var (
 	stackTop     = uintptr(unsafe.Pointer(&stackTopSymbol))
 )
 
+//export tinygo_init
+func tinygo_init(p, n, bss, bssEnd, sp uintptr) {
+	heapStart, heapEnd = p, p+n
+	globalsStart, globalsEnd = bss, bssEnd
+	stackTop = sp
+	initRand()
+	initHeap()
+	initAll()
+}
+
 // growHeap tries to grow the heap size. It returns true if it succeeds, false
 // otherwise.
 func growHeap() bool {