compiler: support panic recovery without exceptions

Add unwind modes for propagating panic and Goexit without relying on
exception handling. Keep setjmp unwinding on existing native targets and
use Asyncify automatically when the Asyncify scheduler is selected.

Stop Asyncify panic unwinding at the nearest defer frame, then run its
deferred calls. Allow ordinary scheduler suspension to pass through the
same frame, preserving aggregate results across rewind and nested or
concurrent task execution.

Add -panic-unwind=auto|explicit. Auto leaves targets without setjmp or
Asyncify unchanged, while explicit opts wasm32, riscv64, and Xtensa into
return-based unwinding. The trap panic strategy still traps panics
immediately, but unwind support remains available for Goexit.

Enable recovery, Goexit, and testing package coverage on WebAssembly and
WASI targets that use Asyncify.

Author: jakebailey

GNUmakefile

@@ -510,15 +510,14 @@ TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_WINDOWS)
 TEST_IOFS := false
 endif
 
-TEST_SKIP_FLAG := -skip='TestExtraMethods|TestParseAndBytesRoundTrip/P256/Generic|TestAsValidation'
+TEST_SKIP_FLAG := -skip='TestExtraMethods|TestAsValidation'
 TEST_ADDITIONAL_FLAGS ?=
 
 # Test known-working standard library packages.
 # TODO: parallelize, and only show failing tests (no implied -v flag).
 .PHONY: tinygo-test
 tinygo-test:
 	@# TestExtraMethods: used by many crypto packages and uses reflect.Type.Method which is not implemented.
-	@# TestParseAndBytesRoundTrip/P256/Generic: needs Goexit to run defers on wasm.
 	$(TINYGO) test $(TEST_ADDITIONAL_FLAGS) $(TEST_SKIP_FLAG) $(filter-out encoding/xml,$(TEST_PACKAGES_HOST)) $(TEST_PACKAGES_SLOW)
 ifeq ($(TEST_ENCODING_XML),true)
 	$(TINYGO) test $(TEST_ADDITIONAL_FLAGS) $(TEST_SKIP_FLAG) -stack-size=16MB encoding/xml

builder/build.go

@@ -216,6 +216,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		Debug:              !config.Options.SkipDWARF, // emit DWARF except when -internal-nodwarf is passed
 		Nobounds:           config.Options.Nobounds,
 		PanicStrategy:      config.PanicStrategy(),
+		PanicUnwind:        config.PanicUnwind(),
 	}
 
 	// Load the target machine, which is the LLVM object that contains all

builder/config.go

@@ -1,6 +1,7 @@
 package builder
 
 import (
+	"errors"
 	"fmt"
 	"runtime"
 
@@ -54,10 +55,24 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 		return nil, fmt.Errorf("cannot compile with Go toolchain version go%d.%d (TinyGo was built using toolchain version %s)", gorootMajor, gorootMinor, runtime.Version())
 	}
 
-	return &compileopts.Config{
+	config := &compileopts.Config{
 		Options:        options,
 		Target:         spec,
 		GoMinorVersion: gorootMinor,
 		TestConfig:     options.TestConfig,
-	}, nil
+	}
+	requestedPanicUnwind := options.PanicUnwind
+	if requestedPanicUnwind == "" {
+		requestedPanicUnwind = spec.PanicUnwind
+	}
+	if requestedPanicUnwind == "explicit" && config.Scheduler() == "asyncify" {
+		return nil, errors.New("explicit panic unwinding cannot be used with the asyncify scheduler")
+	}
+	if config.PanicUnwind() == "explicit" && !config.SupportsExplicitUnwind() {
+		return nil, fmt.Errorf("explicit panic unwinding is not supported on %s", config.Triple())
+	}
+	if config.PanicUnwind() == "explicit" && config.Scheduler() == "threads" {
+		return nil, errors.New("explicit panic unwinding is not supported with the threads scheduler")
+	}
+	return config, nil
 }

builder/sizes_test.go

@@ -42,9 +42,9 @@ func TestBinarySize(t *testing.T) {
 	// This is a small number of very diverse targets that we want to test.
 	tests := []sizeTest{
 		// microcontrollers
-		{"hifive1b", "examples/echo", 4313, 323, 0, 2260},
-		{"microbit", "examples/serial", 2838, 382, 8, 2256},
-		{"wioterminal", "examples/pininterrupt", 8027, 1665, 132, 7488},
+		{"hifive1b", "examples/echo", 4301, 323, 0, 2260},
+		{"microbit", "examples/serial", 2834, 382, 8, 2256},
+		{"wioterminal", "examples/pininterrupt", 7991, 1665, 132, 7488},
 
 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the

compileopts/config.go

@@ -113,6 +113,7 @@ func (c *Config) BuildTags() []string {
 		"osusergo",                                   // to get os/user to work
 		"math_big_pure_go",                           // to get math/big to work
 		"gc." + c.GC(), "scheduler." + c.Scheduler(), // used inside the runtime package
+		"tinygo.unwind." + c.PanicUnwind(),
 		"serial." + c.Serial()}...) // used inside the machine package
 	switch c.Scheduler() {
 	case "threads", "cores":
@@ -202,6 +203,42 @@ func (c *Config) PanicStrategy() string {
 	return c.Options.PanicStrategy
 }
 
+// PanicUnwind returns the mechanism used to unwind panics and Goexit. Asyncify
+// provides unwinding whenever that scheduler is selected. Explicit
+// return-based unwinding must be requested by the command line or target
+// specification.
+func (c *Config) PanicUnwind() string {
+	if c.Scheduler() == "asyncify" {
+		return "asyncify"
+	}
+	requested := c.Target.PanicUnwind
+	if c.Options.PanicUnwind != "" {
+		requested = c.Options.PanicUnwind
+	}
+	if requested == "explicit" {
+		return "explicit"
+	}
+	arch, _, _ := strings.Cut(c.Triple(), "-")
+	switch arch {
+	case "wasm32", "xtensa":
+		return "none"
+	default:
+		return "setjmp"
+	}
+}
+
+// SupportsExplicitUnwind reports whether the target can use return-based
+// panic unwinding.
+func (c *Config) SupportsExplicitUnwind() bool {
+	arch, _, _ := strings.Cut(c.Triple(), "-")
+	switch arch {
+	case "wasm32", "riscv64", "xtensa":
+		return true
+	default:
+		return false
+	}
+}
+
 // 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

@@ -15,6 +15,7 @@ var (
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full", "html"}
 	validPanicStrategyOptions = []string{"print", "trap"}
+	validPanicUnwindOptions   = []string{"auto", "explicit"}
 	validOptOptions           = []string{"none", "0", "1", "2", "s", "z"}
 )
 
@@ -32,6 +33,7 @@ type Options struct {
 	Opt                     string
 	GC                      string
 	PanicStrategy           string
+	PanicUnwind             string
 	Scheduler               string
 	StackSize               uint64 // goroutine stack size (if none could be automatically determined)
 	Serial                  string
@@ -120,6 +122,15 @@ func (o *Options) Verify() error {
 		}
 	}
 
+	if o.PanicUnwind != "" {
+		valid := slices.Contains(validPanicUnwindOptions, o.PanicUnwind)
+		if !valid {
+			return fmt.Errorf(`invalid panic-unwind option '%s': valid values are %s`,
+				o.PanicUnwind,
+				strings.Join(validPanicUnwindOptions, ", "))
+		}
+	}
+
 	if o.Opt != "" {
 		if !slices.Contains(validOptOptions, o.Opt) {
 			return fmt.Errorf("invalid -opt=%s: valid values are %s", o.Opt, strings.Join(validOptOptions, ", "))

compileopts/options_test.go

@@ -13,6 +13,7 @@ func TestVerifyOptions(t *testing.T) {
 	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify, threads, cores`)
 	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full, html`)
 	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
+	expectedPanicUnwindError := errors.New(`invalid panic-unwind option 'incorrect': valid values are auto, explicit`)
 
 	testCases := []struct {
 		name          string
@@ -117,6 +118,25 @@ func TestVerifyOptions(t *testing.T) {
 				PanicStrategy: "trap",
 			},
 		},
+		{
+			name: "InvalidPanicUnwindOption",
+			opts: compileopts.Options{
+				PanicUnwind: "incorrect",
+			},
+			expectedError: expectedPanicUnwindError,
+		},
+		{
+			name: "PanicUnwindOptionAuto",
+			opts: compileopts.Options{
+				PanicUnwind: "auto",
+			},
+		},
+		{
+			name: "PanicUnwindOptionExplicit",
+			opts: compileopts.Options{
+				PanicUnwind: "explicit",
+			},
+		},
 	}
 
 	for _, tc := range testCases {

compileopts/target.go

@@ -35,6 +35,7 @@ type TargetSpec struct {
 	BuildTags        []string `json:"build-tags,omitempty"`
 	BuildMode        string   `json:"buildmode,omitempty"` // default build mode (if nothing specified)
 	GC               string   `json:"gc,omitempty"`
+	PanicUnwind      string   `json:"panic-unwind,omitempty"`
 	Scheduler        string   `json:"scheduler,omitempty"`
 	Serial           string   `json:"serial,omitempty"` // which serial output to use (uart, usb, none)
 	Linker           string   `json:"linker,omitempty"`
@@ -224,6 +225,11 @@ func LoadTarget(options *Options) (*TargetSpec, error) {
 	if err != nil {
 		return nil, fmt.Errorf("%s : %w", options.Target, err)
 	}
+	switch spec.PanicUnwind {
+	case "", "auto", "explicit":
+	default:
+		return nil, fmt.Errorf("%s: invalid panic-unwind option %q", options.Target, spec.PanicUnwind)
+	}
 
 	if spec.Scheduler == "asyncify" {
 		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_asyncify_wasm.S")

compileopts/target_test.go

@@ -161,3 +161,49 @@ func TestConfigLinkerFlavor(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigPanicUnwind(t *testing.T) {
+	tests := []struct {
+		name    string
+		options Options
+		target  TargetSpec
+		want    string
+	}{
+		{
+			name:   "native defaults to setjmp",
+			target: TargetSpec{Triple: "x86_64-unknown-linux"},
+			want:   "setjmp",
+		},
+		{
+			name:   "riscv64 defaults to setjmp",
+			target: TargetSpec{Triple: "riscv64-unknown-unknown"},
+			want:   "setjmp",
+		},
+		{
+			name:    "explicit command line opt in",
+			options: Options{PanicUnwind: "explicit"},
+			target:  TargetSpec{Triple: "riscv64-unknown-unknown"},
+			want:    "explicit",
+		},
+		{
+			name:    "auto overrides target opt in",
+			options: Options{PanicUnwind: "auto"},
+			target:  TargetSpec{Triple: "riscv64-unknown-unknown", PanicUnwind: "explicit"},
+			want:    "setjmp",
+		},
+		{
+			name:    "asyncify enables unwinding",
+			options: Options{Scheduler: "asyncify"},
+			target:  TargetSpec{Triple: "wasm32-unknown-unknown", PanicUnwind: "auto"},
+			want:    "asyncify",
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			config := Config{Options: &tc.options, Target: &tc.target}
+			if got := config.PanicUnwind(); got != tc.want {
+				t.Fatalf("got %q, want %q", got, tc.want)
+			}
+		})
+	}
+}

compiler/asserts.go

@@ -263,11 +263,13 @@ func (b *builder) getRuntimeAssertBlock(blockPrefix, assertFunc string) llvm.Bas
 	block := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".throw")
 	b.runtimeAssertBlocks[assertFunc] = block
 	b.SetInsertPointAtEnd(block)
+	b.inFaultBlock = true
 	if b.hasDeferFrame() {
 		b.createFaultCheckpoint()
 	}
-	b.createRuntimeCall(assertFunc, nil, "")
-	b.CreateUnreachable()
+	b.createRuntimeInvoke(assertFunc, nil, "")
+	b.createUnwindReturnOrUnreachable()
+	b.inFaultBlock = false
 	b.SetInsertPointAtEnd(savedBlock)
 	return block
 }