ssa: use defer selectors on all targets (superseded by #2208)

cl/_testgo/deferdispatch-wasm-target/flags.txt

@@ -0,0 +1,3 @@
+# Wasm named targets currently use GOOS/GOARCH for toolchain selection.
+GOOS=js GOARCH=wasm
+-target=wasm

cl/_testgo/deferdispatch-wasm-target/in.go

@@ -0,0 +1,20 @@
+// LITTEST
+package main
+
+func run() {
+	defer println("first")
+	defer println("second")
+}
+
+func main() {
+	run()
+}
+
+// CHECK-LABEL: define void @main.run()
+// CHECK-NOT: blockaddress
+// CHECK: switch i32
+// CHECK-NOT: blockaddress
+// CHECK: switch i32
+// CHECK-NOT: blockaddress
+// CHECK-NOT: indirectbr
+// CHECK: }

cl/_testgo/deferdispatch-wasm/flags.txt

@@ -0,0 +1 @@
+GOOS=wasip1 GOARCH=wasm

cl/_testgo/deferdispatch-wasm/in.go

@@ -0,0 +1,20 @@
+// LITTEST
+package main
+
+func run() {
+	defer println("first")
+	defer println("second")
+}
+
+func main() {
+	run()
+}
+
+// CHECK-LABEL: define void @main.run()
+// CHECK-NOT: blockaddress
+// CHECK: switch i32
+// CHECK-NOT: blockaddress
+// CHECK: switch i32
+// CHECK-NOT: blockaddress
+// CHECK-NOT: indirectbr
+// CHECK: }

cl/_testgo/deferdispatch/in.go

@@ -0,0 +1,17 @@
+// LITTEST
+package main
+
+func run() {
+	defer println("first")
+	defer println("second")
+}
+
+func main() {
+	run()
+}
+
+// CHECK-LABEL: define void @main.run()
+// CHECK: blockaddress
+// CHECK: indirectbr ptr
+// CHECK: indirectbr ptr
+// CHECK: }

internal/build/testdata/wasm-runtime/main.go

@@ -3,5 +3,40 @@ package main
 import "runtime"
 
 func main() {
+	exerciseDeferContinuations()
 	println(runtime.GOOS)
 }
+
+func exerciseDeferContinuations() {
+	if got := normalLoopDefers(); got != 321 {
+		panic("normal loop defer order")
+	}
+	order, recovered := panicWhileDrainingLoopDefers()
+	if order != 321 || recovered != "wasm-loop-defer-boom" {
+		panic("panic loop defer order")
+	}
+}
+
+func normalLoopDefers() (order int) {
+	for i := 1; i <= 3; i++ {
+		value := i
+		defer func() { order = order*10 + value }()
+	}
+	return
+}
+
+func panicWhileDrainingLoopDefers() (order int, recovered any) {
+	defer func() { recovered = recover() }()
+	func() {
+		for i := 1; i <= 3; i++ {
+			value := i
+			defer func() {
+				order = order*10 + value
+				if value == 2 {
+					panic("wasm-loop-defer-boom")
+				}
+			}()
+		}
+	}()
+	return
+}

internal/llgen/llgenf.go

@@ -44,7 +44,7 @@ func genFrom(pkgPath string, abiMode build.AbiMode) (build.Package, error) {
 		AbiMode: abiMode,
 		GenLL:   true,
 	}
-	if err := applyGoBuildFlagsFile(conf, filepath.Join(pkgPath, "flags.txt")); err != nil {
+	if err := applyFlagsFile(conf, filepath.Join(pkgPath, "flags.txt")); err != nil {
 		return nil, err
 	}
 	pkgs, err := build.Do([]string{pkgPath}, conf)
@@ -60,7 +60,7 @@ func DoFile(fileOrPkg, outFile string) {
 	check(err)
 }
 
-func readGoBuildFlags(flagsFile string) ([]string, error) {
+func readFlags(flagsFile string) ([]string, error) {
 	data, err := os.ReadFile(flagsFile)
 	if os.IsNotExist(err) {
 		return nil, nil
@@ -75,14 +75,38 @@ func readGoBuildFlags(flagsFile string) ([]string, error) {
 	return flags, nil
 }
 
-func applyGoBuildFlagsFile(conf *build.Config, flagsFile string) error {
-	flags, err := readGoBuildFlags(flagsFile)
+func applyFlagsFile(conf *build.Config, flagsFile string) error {
+	flags, err := readFlags(flagsFile)
 	if err != nil {
 		return err
 	}
-	if err := goflags.ApplyBuildFlags(conf, flags); err != nil {
+	next := *conf
+	goFlags := make([]string, 0, len(flags))
+	for i := 0; i < len(flags); i++ {
+		flag := flags[i]
+		switch {
+		case strings.HasPrefix(flag, "GOOS="):
+			next.Goos = strings.TrimPrefix(flag, "GOOS=")
+		case strings.HasPrefix(flag, "GOARCH="):
+			next.Goarch = strings.TrimPrefix(flag, "GOARCH=")
+		case flag == "-target" || flag == "--target":
+			if i+1 == len(flags) {
+				return fmt.Errorf("apply %s: %s requires a value", flagsFile, flag)
+			}
+			i++
+			next.Target = flags[i]
+		case strings.HasPrefix(flag, "-target="):
+			next.Target = strings.TrimPrefix(flag, "-target=")
+		case strings.HasPrefix(flag, "--target="):
+			next.Target = strings.TrimPrefix(flag, "--target=")
+		default:
+			goFlags = append(goFlags, flag)
+		}
+	}
+	if err := goflags.ApplyBuildFlags(&next, goFlags); err != nil {
 		return fmt.Errorf("apply %s: %w", flagsFile, err)
 	}
+	*conf = next
 	return nil
 }
 

internal/llgen/llgenf_test.go

@@ -26,22 +26,25 @@ import (
 	"github.com/goplus/llgo/internal/optlevel"
 )
 
-func TestApplyGoBuildFlagsFile(t *testing.T) {
+func TestApplyFlagsFile(t *testing.T) {
 	dir := t.TempDir()
 	missing := filepath.Join(dir, "missing.txt")
-	if err := applyGoBuildFlagsFile(new(build.Config), missing); err != nil {
+	if err := applyFlagsFile(new(build.Config), missing); err != nil {
 		t.Fatalf("missing flags file: %v", err)
 	}
 
 	path := filepath.Join(dir, "flags.txt")
-	data := "--gcflags 'all=-N -l'\n-ldflags=--s --w=false # keep DWARF\n"
+	data := "GOOS=wasip1 GOARCH=wasm\n-target=wasm\n--gcflags 'all=-N -l'\n-ldflags=--s --w=false # keep DWARF\n"
 	if err := os.WriteFile(path, []byte(data), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	conf := new(build.Config)
-	if err := applyGoBuildFlagsFile(conf, path); err != nil {
+	if err := applyFlagsFile(conf, path); err != nil {
 		t.Fatal(err)
 	}
+	if conf.Goos != "wasip1" || conf.Goarch != "wasm" || conf.Target != "wasm" {
+		t.Fatalf("target config = %s/%s, target %q", conf.Goos, conf.Goarch, conf.Target)
+	}
 	if conf.OptLevel != optlevel.O0 {
 		t.Fatalf("OptLevel = %v, want O0", conf.OptLevel)
 	}
@@ -50,15 +53,44 @@ func TestApplyGoBuildFlagsFile(t *testing.T) {
 	}
 }
 
-func TestApplyGoBuildFlagsFileErrorIncludesPath(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "flags.txt")
-	data := "-ldflags='unterminated\n"
-	if err := os.WriteFile(path, []byte(data), 0o644); err != nil {
-		t.Fatal(err)
+func TestApplyFlagsFileErrorIncludesPath(t *testing.T) {
+	tests := []string{
+		"-ldflags='unterminated\n",
+		"-ldflags=-w=invalid\n",
+		"-target\n",
+	}
+	for _, data := range tests {
+		t.Run(strings.TrimSpace(data), func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "flags.txt")
+			if err := os.WriteFile(path, []byte(data), 0o644); err != nil {
+				t.Fatal(err)
+			}
+			conf := &build.Config{Target: "original"}
+			err := applyFlagsFile(conf, path)
+			if err == nil || !strings.Contains(err.Error(), path) {
+				t.Fatalf("applyFlagsFile(%q) error = %v, want path", data, err)
+			}
+			if conf.Target != "original" {
+				t.Fatalf("failed application changed target to %q", conf.Target)
+			}
+		})
 	}
-	err := applyGoBuildFlagsFile(new(build.Config), path)
-	if err == nil || !strings.Contains(err.Error(), path) {
-		t.Fatalf("applyGoBuildFlagsFile(%q) error = %v, want path", data, err)
+}
+
+func TestApplyFlagsFileTargetForms(t *testing.T) {
+	for _, data := range []string{"-target wasi", "--target wasi", "--target=wasi"} {
+		t.Run(data, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "flags.txt")
+			if err := os.WriteFile(path, []byte(data), 0o644); err != nil {
+				t.Fatal(err)
+			}
+			conf := new(build.Config)
+			if err := applyFlagsFile(conf, path); err != nil {
+				t.Fatal(err)
+			}
+			if conf.Target != "wasi" {
+				t.Fatalf("Target = %q, want wasi", conf.Target)
+			}
+		})
 	}
 }

runtime/internal/runtime/z_rt.go

@@ -30,8 +30,8 @@ type Defer struct {
 	Addr unsafe.Pointer // sigjmpbuf
 	Bits uintptr
 	Link *Defer
-	Reth unsafe.Pointer // block address after Rethrow
-	Rund unsafe.Pointer // block address after RunDefers
+	Reth unsafe.Pointer // native block address or wasm continuation selector
+	Rund unsafe.Pointer // native block address or wasm continuation selector
 	Args unsafe.Pointer // defer func and args links
 }