mips: add GOMIPS=softfloat support

Previously, the compiler would default to hardfloat. This is not
supported by some MIPS CPUs.

Author: aykevl

builder/build.go

@@ -745,6 +745,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				ldflags = append(ldflags, dependency.result)
 			}
 			ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
+			ldflags = append(ldflags, "-mllvm", "-mattr="+config.Features()) // needed for MIPS softfloat
 			if config.GOOS() == "windows" {
 				// Options for the MinGW wrapper for the lld COFF linker.
 				ldflags = append(ldflags,

builder/builder_test.go

@@ -57,8 +57,10 @@ func TestClangAttributes(t *testing.T) {
 		{GOOS: "linux", GOARCH: "arm", GOARM: "6"},
 		{GOOS: "linux", GOARCH: "arm", GOARM: "7"},
 		{GOOS: "linux", GOARCH: "arm64"},
-		{GOOS: "linux", GOARCH: "mips"},
-		{GOOS: "linux", GOARCH: "mipsle"},
+		{GOOS: "linux", GOARCH: "mips", GOMIPS: "hardfloat"},
+		{GOOS: "linux", GOARCH: "mipsle", GOMIPS: "hardfloat"},
+		{GOOS: "linux", GOARCH: "mips", GOMIPS: "softfloat"},
+		{GOOS: "linux", GOARCH: "mipsle", GOMIPS: "softfloat"},
 		{GOOS: "darwin", GOARCH: "amd64"},
 		{GOOS: "darwin", GOARCH: "arm64"},
 		{GOOS: "windows", GOARCH: "amd64"},
@@ -70,6 +72,9 @@ func TestClangAttributes(t *testing.T) {
 		if options.GOARCH == "arm" {
 			name += ",GOARM=" + options.GOARM
 		}
+		if options.GOARCH == "mips" || options.GOARCH == "mipsle" {
+			name += ",GOMIPS=" + options.GOMIPS
+		}
 		t.Run(name, func(t *testing.T) {
 			testClangAttributes(t, options)
 		})

builder/library.go

@@ -184,6 +184,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	}
 	if strings.HasPrefix(target, "mips") {
 		args = append(args, "-fno-pic")
+		if config.Target.SoftFloat {
+			args = append(args, "-msoft-float")
+		}
 	}
 
 	var once sync.Once

compileopts/config.go

@@ -72,6 +72,12 @@ func (c *Config) GOARM() string {
 	return c.Options.GOARM
 }
 
+// GOMIPS will return the GOMIPS environment variable given to the compiler when
+// building a program.
+func (c *Config) GOMIPS() string {
+	return c.Options.GOMIPS
+}
+
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
 	tags := append([]string(nil), c.Target.BuildTags...) // copy slice (avoid a race)
@@ -231,6 +237,9 @@ func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 	if c.ABI() != "" {
 		archname += "-" + c.ABI()
 	}
+	if c.Target.SoftFloat {
+		archname += "-softfloat"
+	}
 
 	// Try to load a precompiled library.
 	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, name)

compileopts/options.go

@@ -23,6 +23,7 @@ type Options struct {
 	GOOS            string // environment variable
 	GOARCH          string // environment variable
 	GOARM           string // environment variable (only used with GOARCH=arm)
+	GOMIPS          string // environment variable (only used with GOARCH=mips and GOARCH=mipsle)
 	Directory       string // working dir, leave it unset to use the current working dir
 	Target          string
 	Opt             string

compileopts/target.go

@@ -30,6 +30,7 @@ type TargetSpec struct {
 	Features         string   `json:"features,omitempty"`
 	GOOS             string   `json:"goos,omitempty"`
 	GOARCH           string   `json:"goarch,omitempty"`
+	SoftFloat        bool     // used for non-baremetal systems (GOMIPS=softfloat etc)
 	BuildTags        []string `json:"build-tags,omitempty"`
 	GC               string   `json:"gc,omitempty"`
 	Scheduler        string   `json:"scheduler,omitempty"`
@@ -86,6 +87,10 @@ func (spec *TargetSpec) overrideProperties(child *TargetSpec) error {
 			if src.Uint() != 0 {
 				dst.Set(src)
 			}
+		case reflect.Bool:
+			if src.Bool() {
+				dst.Set(src)
+			}
 		case reflect.Ptr: // for pointers, copy if not nil
 			if !src.IsNil() {
 				dst.Set(src)
@@ -228,7 +233,7 @@ func LoadTarget(options *Options) (*TargetSpec, error) {
 		} else if options.GOARCH == "arm" {
 			target += "-gnueabihf"
 		}
-		return defaultTarget(options.GOOS, options.GOARCH, target)
+		return defaultTarget(options, target)
 	}
 
 	// See whether there is a target specification for this target (e.g.
@@ -289,22 +294,22 @@ func GetTargetSpecs() (map[string]*TargetSpec, error) {
 	return maps, nil
 }
 
-func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
+func defaultTarget(options *Options, triple string) (*TargetSpec, error) {
 	// No target spec available. Use the default one, useful on most systems
 	// with a regular OS.
 	spec := TargetSpec{
 		Triple:           triple,
-		GOOS:             goos,
-		GOARCH:           goarch,
-		BuildTags:        []string{goos, goarch},
+		GOOS:             options.GOOS,
+		GOARCH:           options.GOARCH,
+		BuildTags:        []string{options.GOOS, options.GOARCH},
 		GC:               "precise",
 		Scheduler:        "tasks",
 		Linker:           "cc",
 		DefaultStackSize: 1024 * 64, // 64kB
 		GDB:              []string{"gdb"},
 		PortReset:        "false",
 	}
-	switch goarch {
+	switch options.GOARCH {
 	case "386":
 		spec.CPU = "pentium4"
 		spec.Features = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87"
@@ -324,17 +329,26 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		}
 	case "arm64":
 		spec.CPU = "generic"
-		if goos == "darwin" {
+		if options.GOOS == "darwin" {
 			spec.Features = "+fp-armv8,+neon"
-		} else if goos == "windows" {
+		} else if options.GOOS == "windows" {
 			spec.Features = "+fp-armv8,+neon,-fmv"
 		} else { // linux
 			spec.Features = "+fp-armv8,+neon,-fmv,-outline-atomics"
 		}
 	case "mips", "mipsle":
 		spec.CPU = "mips32r2"
-		spec.Features = "+fpxx,+mips32r2,+nooddspreg,-noabicalls"
 		spec.CFlags = append(spec.CFlags, "-fno-pic")
+		switch options.GOMIPS {
+		case "hardfloat":
+			spec.Features = "+fpxx,+mips32r2,+nooddspreg,-noabicalls"
+		case "softfloat":
+			spec.SoftFloat = true
+			spec.Features = "+mips32r2,+soft-float,-noabicalls"
+			spec.CFlags = append(spec.CFlags, "-msoft-float")
+		default:
+			return nil, errors.New("invalid GOMIPS: must be hardfloat or softfloat")
+		}
 	case "wasm":
 		spec.CPU = "generic"
 		spec.Features = "+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext"
@@ -345,7 +359,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			"-msign-ext",
 		)
 	}
-	if goos == "darwin" {
+	if options.GOOS == "darwin" {
 		spec.Linker = "ld.lld"
 		spec.Libc = "darwin-libSystem"
 		arch := strings.Split(triple, "-")[0]
@@ -356,12 +370,12 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			"-arch", arch,
 			"-platform_version", "macos", platformVersion, platformVersion,
 		)
-	} else if goos == "linux" {
+	} else if options.GOOS == "linux" {
 		spec.Linker = "ld.lld"
 		spec.RTLib = "compiler-rt"
 		spec.Libc = "musl"
 		spec.LDFlags = append(spec.LDFlags, "--gc-sections")
-		if goarch == "arm64" {
+		if options.GOARCH == "arm64" {
 			// Disable outline atomics. For details, see:
 			// https://cpufun.substack.com/p/atomics-in-aarch64
 			// A better way would be to fully support outline atomics, which
@@ -375,7 +389,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			// proper threading.
 			spec.CFlags = append(spec.CFlags, "-mno-outline-atomics")
 		}
-	} else if goos == "windows" {
+	} else if options.GOOS == "windows" {
 		spec.Linker = "ld.lld"
 		spec.Libc = "mingw-w64"
 		// Note: using a medium code model, low image base and no ASLR
@@ -384,7 +398,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		// normally present in Go (without explicitly opting in).
 		// For more discussion:
 		// https://groups.google.com/g/Golang-nuts/c/Jd9tlNc6jUE/m/Zo-7zIP_m3MJ?pli=1
-		switch goarch {
+		switch options.GOARCH {
 		case "amd64":
 			spec.LDFlags = append(spec.LDFlags,
 				"-m", "i386pep",
@@ -401,7 +415,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			"--no-insert-timestamp",
 			"--no-dynamicbase",
 		)
-	} else if goos == "wasip1" {
+	} else if options.GOOS == "wasip1" {
 		spec.GC = "" // use default GC
 		spec.Scheduler = "asyncify"
 		spec.Linker = "wasm-ld"
@@ -420,25 +434,25 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	} else {
 		spec.LDFlags = append(spec.LDFlags, "-no-pie", "-Wl,--gc-sections") // WARNING: clang < 5.0 requires -nopie
 	}
-	if goarch != "wasm" {
+	if options.GOARCH != "wasm" {
 		suffix := ""
-		if goos == "windows" && goarch == "amd64" {
+		if options.GOOS == "windows" && options.GOARCH == "amd64" {
 			// Windows uses a different calling convention on amd64 from other
 			// operating systems so we need separate assembly files.
 			suffix = "_windows"
 		}
-		asmGoarch := goarch
-		if goarch == "mips" || goarch == "mipsle" {
+		asmGoarch := options.GOARCH
+		if options.GOARCH == "mips" || options.GOARCH == "mipsle" {
 			asmGoarch = "mipsx"
 		}
 		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/asm_"+asmGoarch+suffix+".S")
 		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_stack_"+asmGoarch+suffix+".S")
 	}
-	if goarch != runtime.GOARCH {
+	if options.GOARCH != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
 		spec.GDB = []string{"gdb-multiarch"}
-		if goos == "linux" {
-			switch goarch {
+		if options.GOOS == "linux" {
+			switch options.GOARCH {
 			case "386":
 				// amd64 can _usually_ run 32-bit programs, so skip the emulator in that case.
 				if runtime.GOARCH != "amd64" {
@@ -457,8 +471,8 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			}
 		}
 	}
-	if goos != runtime.GOOS {
-		if goos == "windows" {
+	if options.GOOS != runtime.GOOS {
+		if options.GOOS == "windows" {
 			spec.Emulator = "wine {}"
 		}
 	}

goenv/goenv.go

@@ -128,6 +128,13 @@ func Get(name string) string {
 		// difference between ARMv6 and ARMv7. ARMv6 binaries are much smaller,
 		// especially when floating point instructions are involved.
 		return "6"
+	case "GOMIPS":
+		gomips := os.Getenv("GOMIPS")
+		if gomips == "" {
+			// Default to hardfloat (this matches the Go toolchain).
+			gomips = "hardfloat"
+		}
+		return gomips
 	case "GOROOT":
 		readGoEnvVars()
 		return goEnvVars.GOROOT

main.go

@@ -1498,6 +1498,7 @@ func main() {
 		GOOS:            goenv.Get("GOOS"),
 		GOARCH:          goenv.Get("GOARCH"),
 		GOARM:           goenv.Get("GOARM"),
+		GOMIPS:          goenv.Get("GOMIPS"),
 		Target:          *target,
 		StackSize:       stackSize,
 		Opt:             *opt,
@@ -1780,6 +1781,7 @@ func main() {
 				GOOS       string                  `json:"goos"`
 				GOARCH     string                  `json:"goarch"`
 				GOARM      string                  `json:"goarm"`
+				GOMIPS     string                  `json:"gomips"`
 				BuildTags  []string                `json:"build_tags"`
 				GC         string                  `json:"garbage_collector"`
 				Scheduler  string                  `json:"scheduler"`
@@ -1790,6 +1792,7 @@ func main() {
 				GOOS:       config.GOOS(),
 				GOARCH:     config.GOARCH(),
 				GOARM:      config.GOARM(),
+				GOMIPS:     config.GOMIPS(),
 				BuildTags:  config.BuildTags(),
 				GC:         config.GC(),
 				Scheduler:  config.Scheduler(),