go/ssa/interp: use the actual GOOS and GOARCH to interpret tests

This incidentally uncovered a bug in the `fitsInt` helper function,
which was computing the wrong bounds on 32-bit platforms (as if int
were 4 bits instead of 4 bytes), which is also fixed.

Fixes golang/go#60226 (hopefully).

Change-Id: I56afdd3063dce233696f1e7a873dac4ee9ca231f
Reviewed-on: https://go-review.googlesource.com/c/tools/+/495255
Reviewed-by: Robert Findley <[email protected]>
Auto-Submit: Bryan Mills <[email protected]>
Run-TryBot: Bryan Mills <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: Bryan C. Mills

go/ssa/interp/interp_test.go

@@ -23,9 +23,11 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 	"time"
+	"unsafe"
 
 	"golang.org/x/tools/go/loader"
 	"golang.org/x/tools/go/ssa"
@@ -138,13 +140,7 @@ func init() {
 	}
 }
 
-// Specific GOARCH to use for a test case in go.tools/go/ssa/interp/testdata/.
-// Defaults to amd64 otherwise.
-var testdataArchs = map[string]string{
-	"width32.go": "386",
-}
-
-func run(t *testing.T, input string) bool {
+func run(t *testing.T, input string) {
 	// The recover2 test case is broken on Go 1.14+. See golang/go#34089.
 	// TODO(matloob): Fix this.
 	if filepath.Base(input) == "recover2.go" {
@@ -157,16 +153,15 @@ func run(t *testing.T, input string) bool {
 
 	ctx := build.Default    // copy
 	ctx.GOROOT = "testdata" // fake goroot
-	ctx.GOOS = "linux"
-	ctx.GOARCH = "amd64"
-	if arch, ok := testdataArchs[filepath.Base(input)]; ok {
-		ctx.GOARCH = arch
+	ctx.GOOS = runtime.GOOS
+	ctx.GOARCH = runtime.GOARCH
+	if filepath.Base(input) == "width32.go" && unsafe.Sizeof(int(0)) > 4 {
+		t.Skipf("skipping: width32.go checks behavior for a 32-bit int")
 	}
 
 	conf := loader.Config{Build: &ctx}
 	if _, err := conf.FromArgs([]string{input}, true); err != nil {
-		t.Errorf("FromArgs(%s) failed: %s", input, err)
-		return false
+		t.Fatalf("FromArgs(%s) failed: %s", input, err)
 	}
 
 	conf.Import("runtime")
@@ -188,8 +183,7 @@ func run(t *testing.T, input string) bool {
 
 	iprog, err := conf.Load()
 	if err != nil {
-		t.Errorf("conf.Load(%s) failed: %s", input, err)
-		return false
+		t.Fatalf("conf.Load(%s) failed: %s", input, err)
 	}
 
 	bmode := ssa.InstantiateGenerics | ssa.SanityCheckFunctions
@@ -205,6 +199,9 @@ func run(t *testing.T, input string) bool {
 	interp.CapturedOutput = new(bytes.Buffer)
 
 	sizes := types.SizesFor("gc", ctx.GOARCH)
+	if sizes.Sizeof(types.Typ[types.Int]) < 4 {
+		panic("bogus SizesFor")
+	}
 	hint = fmt.Sprintf("To trace execution, run:\n%% go build golang.org/x/tools/cmd/ssadump && ./ssadump -build=C -test -run --interp=T %s\n", input)
 	var imode interp.Mode // default mode
 	// imode |= interp.DisableRecover // enable for debugging
@@ -223,17 +220,6 @@ func run(t *testing.T, input string) bool {
 	if false {
 		t.Log(input, time.Since(start)) // test profiling
 	}
-
-	return true
-}
-
-func printFailures(failures []string) {
-	if failures != nil {
-		fmt.Println("The following tests failed:")
-		for _, f := range failures {
-			fmt.Printf("\t%s\n", f)
-		}
-	}
 }
 
 // TestTestdataFiles runs the interpreter on testdata/*.go.
@@ -242,25 +228,20 @@ func TestTestdataFiles(t *testing.T) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	var failures []string
 	for _, input := range testdataTests {
-		if !run(t, filepath.Join(cwd, "testdata", input)) {
-			failures = append(failures, input)
-		}
+		t.Run(input, func(t *testing.T) {
+			run(t, filepath.Join(cwd, "testdata", input))
+		})
 	}
-	printFailures(failures)
 }
 
 // TestGorootTest runs the interpreter on $GOROOT/test/*.go.
 func TestGorootTest(t *testing.T) {
-	var failures []string
-
 	for _, input := range gorootTestTests {
-		if !run(t, filepath.Join(build.Default.GOROOT, "test", input)) {
-			failures = append(failures, input)
-		}
+		t.Run(input, func(t *testing.T) {
+			run(t, filepath.Join(build.Default.GOROOT, "test", input))
+		})
 	}
-	printFailures(failures)
 }
 
 // TestTypeparamTest runs the interpreter on runnable examples
@@ -274,54 +255,47 @@ func TestTypeparamTest(t *testing.T) {
 	// Skip known failures for the given reason.
 	// TODO(taking): Address these.
 	skip := map[string]string{
-		"chans.go":       "interp tests do not support runtime.SetFinalizer",
-		"issue23536.go":  "unknown reason",
-		"issue376214.go": "unknown issue with variadic cast on bytes",
-		"issue48042.go":  "interp tests do not handle reflect.Value.SetInt",
-		"issue47716.go":  "interp tests do not handle unsafe.Sizeof",
-		"issue50419.go":  "interp tests do not handle dispatch to String() correctly",
-		"issue51733.go":  "interp does not handle unsafe casts",
-		"ordered.go":     "math.NaN() comparisons not being handled correctly",
-		"orderedmap.go":  "interp tests do not support runtime.SetFinalizer",
-		"stringer.go":    "unknown reason",
-		"issue48317.go":  "interp tests do not support encoding/json",
-		"issue48318.go":  "interp tests do not support encoding/json",
-		"issue58513.go":  "interp tests do not support runtime.Caller",
+		"chans.go":      "interp tests do not support runtime.SetFinalizer",
+		"issue23536.go": "unknown reason",
+		"issue48042.go": "interp tests do not handle reflect.Value.SetInt",
+		"issue47716.go": "interp tests do not handle unsafe.Sizeof",
+		"issue50419.go": "interp tests do not handle dispatch to String() correctly",
+		"issue51733.go": "interp does not handle unsafe casts",
+		"ordered.go":    "math.NaN() comparisons not being handled correctly",
+		"orderedmap.go": "interp tests do not support runtime.SetFinalizer",
+		"stringer.go":   "unknown reason",
+		"issue48317.go": "interp tests do not support encoding/json",
+		"issue48318.go": "interp tests do not support encoding/json",
+		"issue58513.go": "interp tests do not support runtime.Caller",
 	}
 	// Collect all of the .go files in dir that are runnable.
 	dir := filepath.Join(build.Default.GOROOT, "test", "typeparam")
 	list, err := os.ReadDir(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
-	var inputs []string
 	for _, entry := range list {
 		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".go") {
 			continue // Consider standalone go files.
 		}
-		if reason := skip[entry.Name()]; reason != "" {
-			t.Logf("skipping %q due to %s.", entry.Name(), reason)
-			continue
-		}
-		input := filepath.Join(dir, entry.Name())
-		src, err := os.ReadFile(input)
-		if err != nil {
-			t.Fatal(err)
-		}
-		// Only build test files that can be compiled, or compiled and run.
-		if bytes.HasPrefix(src, []byte("// run")) && !bytes.HasPrefix(src, []byte("// rundir")) {
-			inputs = append(inputs, input)
-		} else {
-			t.Logf("Not a `// run` file: %s", entry.Name())
-		}
-	}
-
-	var failures []string
-	for _, input := range inputs {
-		t.Log("running", input)
-		if !run(t, input) {
-			failures = append(failures, input)
-		}
+		t.Run(entry.Name(), func(t *testing.T) {
+			input := filepath.Join(dir, entry.Name())
+			src, err := os.ReadFile(input)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// Only build test files that can be compiled, or compiled and run.
+			if !bytes.HasPrefix(src, []byte("// run")) || bytes.HasPrefix(src, []byte("// rundir")) {
+				t.Logf("Not a `// run` file: %s", entry.Name())
+				return
+			}
+
+			if reason := skip[entry.Name()]; reason != "" {
+				t.Skipf("skipping: %s", reason)
+			}
+
+			run(t, input)
+		})
 	}
-	printFailures(failures)
 }

go/ssa/interp/ops.go

@@ -92,8 +92,8 @@ func constValue(c *ssa.Const) value {
 func fitsInt(x int64, sizes types.Sizes) bool {
 	intSize := sizes.Sizeof(types.Typ[types.Int])
 	if intSize < sizes.Sizeof(types.Typ[types.Int64]) {
-		maxInt := int64(1)<<(intSize-1) - 1
-		minInt := -int64(1) << (intSize - 1)
+		maxInt := int64(1)<<((intSize*8)-1) - 1
+		minInt := -int64(1) << ((intSize * 8) - 1)
 		return minInt <= x && x <= maxInt
 	}
 	return true