all: add -unwind= flag to select unwinder

The current options are:

  - simple: a setjmp/longjmp like unwinder strategy
  - none: no unwinding supported at all (recover() is a no-op)

This can be useful to control binary size. The default stays at
-unwind=simple for supported architectures but it's now possible to
disable unwinding (and therefore recover) using -unwind=none.

Author: aykevl

builder/build.go

@@ -139,6 +139,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		SizeLevel:       sizeLevel,
 
 		Scheduler:          config.Scheduler(),
+		Unwinder:           config.Unwinder(),
 		FuncImplementation: config.FuncImplementation(),
 		AutomaticStackSize: config.AutomaticStackSize(),
 		DefaultStackSize:   config.Target.DefaultStackSize,

compileopts/config.go

@@ -191,6 +191,30 @@ func (c *Config) PanicStrategy() string {
 	return c.Options.PanicStrategy
 }
 
+// Unwinder returns the unwinder used. It can be "simple" or "none".
+// If no unwinder has been specified on the command line, an appropriate unwind
+// strategy for the target architecture is chosen.
+func (c *Config) Unwinder() string {
+	unwinder := c.Options.Unwinder
+	if unwinder == "" {
+		arch := strings.Split(c.Triple(), "-")[0]
+		switch arch {
+		case "wasm32":
+			// Probably needs to be implemented using the exception handling
+			// proposal of WebAssembly:
+			// https://github.com/WebAssembly/exception-handling
+			unwinder = "none"
+		case "avr", "riscv64", "xtensa":
+			// TODO: add support for these architectures
+			unwinder = "none"
+		default:
+			unwinder = "simple"
+		}
+
+	}
+	return unwinder
+}
+
 // AutomaticStackSize returns whether goroutine stack sizes should be determined
 // automatically at compile time, if possible. If it is false, no attempt is
 // made.

compileopts/options.go

@@ -9,6 +9,7 @@ import (
 var (
 	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
 	validSchedulerOptions     = []string{"none", "tasks", "coroutines", "asyncify"}
+	validUnwinderOptions      = []string{"none", "simple"}
 	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
@@ -27,6 +28,7 @@ type Options struct {
 	GC              string
 	PanicStrategy   string
 	Scheduler       string
+	Unwinder        string
 	Serial          string
 	PrintIR         bool
 	DumpSSA         bool
@@ -93,6 +95,14 @@ func (o *Options) Verify() error {
 		}
 	}
 
+	if o.Unwinder != "" {
+		if !isInArray(validUnwinderOptions, o.Unwinder) {
+			return fmt.Errorf("invalid flag -unwind=%#v: valid values are %s",
+				o.Unwinder,
+				strings.Join(validUnwinderOptions, ", "))
+		}
+	}
+
 	if o.Opt != "" {
 		if !isInArray(validOptOptions, o.Opt) {
 			return fmt.Errorf("invalid -opt=%s: valid values are %s", o.Opt, strings.Join(validOptOptions, ", "))

compiler/compiler.go

@@ -52,6 +52,7 @@ type Config struct {
 
 	// Various compiler options that determine how code is generated.
 	Scheduler          string
+	Unwinder           string
 	FuncImplementation string
 	AutomaticStackSize bool
 	DefaultStackSize   uint64

compiler/compiler_test.go

@@ -108,6 +108,7 @@ func TestCompiler(t *testing.T) {
 				CodeModel:          config.CodeModel(),
 				RelocationModel:    config.RelocationModel(),
 				Scheduler:          config.Scheduler(),
+				Unwinder:           config.Unwinder(),
 				FuncImplementation: config.FuncImplementation(),
 				AutomaticStackSize: config.AutomaticStackSize(),
 				DefaultStackSize:   config.Target.DefaultStackSize,

compiler/defer.go

@@ -25,18 +25,7 @@ import (
 // supportsRecover returns whether the compiler supports the recover() builtin
 // for the current architecture.
 func (b *builder) supportsRecover() bool {
-	switch b.archFamily() {
-	case "wasm32":
-		// Probably needs to be implemented using the exception handling
-		// proposal of WebAssembly:
-		// https://github.com/WebAssembly/exception-handling
-		return false
-	case "avr", "riscv64", "xtensa":
-		// TODO: add support for these architectures
-		return false
-	default:
-		return true
-	}
+	return b.Unwinder != "none"
 }
 
 // hasDeferFrame returns whether the current function needs to catch panics and

main.go

@@ -1141,6 +1141,7 @@ func main() {
 	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, conservative)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
 	scheduler := flag.String("scheduler", "", "which scheduler to use (none, coroutines, tasks, asyncify)")
+	unwinder := flag.String("unwind", "", "which unwind strategy to use (none, simple)")
 	serial := flag.String("serial", "", "which serial output to use (none, uart, usb)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")
 	dumpSSA := flag.Bool("dumpssa", false, "dump internal Go SSA")
@@ -1223,6 +1224,7 @@ func main() {
 		GC:              *gc,
 		PanicStrategy:   *panicStrategy,
 		Scheduler:       *scheduler,
+		Unwinder:        *unwinder,
 		Serial:          *serial,
 		PrintIR:         *printIR,
 		DumpSSA:         *dumpSSA,
@@ -1431,6 +1433,7 @@ func main() {
 		fmt.Printf("build tags:        %s\n", strings.Join(config.BuildTags(), " "))
 		fmt.Printf("garbage collector: %s\n", config.GC())
 		fmt.Printf("scheduler:         %s\n", config.Scheduler())
+		fmt.Printf("unwinder:          %s\n", config.Unwinder())
 		fmt.Printf("cached GOROOT:     %s\n", cachedGOROOT)
 	case "list":
 		config, err := builder.NewConfig(options)