compiler: fix ARMv8 regression introduced in #2345 (#2365)

Signed-off-by: Nuno Cruces <ncruces@users.noreply.github.com>

Author: ncruces

config.go

@@ -12,8 +12,6 @@ import (
 
 	"github.com/tetratelabs/wazero/api"
 	experimentalsys "github.com/tetratelabs/wazero/experimental/sys"
-	"github.com/tetratelabs/wazero/internal/engine/interpreter"
-	"github.com/tetratelabs/wazero/internal/engine/wazevo"
 	"github.com/tetratelabs/wazero/internal/filecache"
 	"github.com/tetratelabs/wazero/internal/internalapi"
 	"github.com/tetratelabs/wazero/internal/platform"
@@ -175,7 +173,9 @@ type RuntimeConfig interface {
 // NewRuntimeConfig returns a RuntimeConfig using the compiler if it is supported in this environment,
 // or the interpreter otherwise.
 func NewRuntimeConfig() RuntimeConfig {
-	return newRuntimeConfig()
+	ret := engineLessConfig.clone()
+	ret.engineKind = engineKindAuto
+	return ret
 }
 
 type newEngine func(context.Context, api.CoreFeatures, filecache.Cache) wasm.Engine
@@ -203,7 +203,8 @@ var engineLessConfig = &runtimeConfig{
 type engineKind int
 
 const (
-	engineKindCompiler engineKind = iota
+	engineKindAuto engineKind = iota - 1
+	engineKindCompiler
 	engineKindInterpreter
 	engineKindCount
 )
@@ -234,15 +235,13 @@ const (
 func NewRuntimeConfigCompiler() RuntimeConfig {
 	ret := engineLessConfig.clone()
 	ret.engineKind = engineKindCompiler
-	ret.newEngine = wazevo.NewEngine
 	return ret
 }
 
 // NewRuntimeConfigInterpreter interprets WebAssembly modules instead of compiling them into assembly.
 func NewRuntimeConfigInterpreter() RuntimeConfig {
 	ret := engineLessConfig.clone()
 	ret.engineKind = engineKindInterpreter
-	ret.newEngine = interpreter.NewEngine
 	return ret
 }
 

config_supported.go

@@ -670,9 +670,5 @@ func TestNewRuntimeConfig(t *testing.T) {
 	// Should be cloned from the source.
 	require.NotEqual(t, engineLessConfig, c)
 	// Ensures if the correct engine is selected.
-	if platform.CompilerSupported() {
-		require.Equal(t, engineKindCompiler, c.engineKind)
-	} else {
-		require.Equal(t, engineKindInterpreter, c.engineKind)
-	}
+	require.Equal(t, engineKindAuto, c.engineKind)
 }

config_test.go

@@ -22,7 +22,7 @@ import (
 )
 
 func TestMain(m *testing.M) {
-	if !platform.CompilerSupported() {
+	if !platform.CompilerSupports(api.CoreFeaturesV2 | experimental.CoreFeaturesThreads) {
 		os.Exit(0)
 	}
 	os.Exit(m.Run())

config_unsupported.go

@@ -54,7 +54,7 @@ func TestThreadsNotEnabled(t *testing.T) {
 }
 
 func TestThreadsCompiler_hammer(t *testing.T) {
-	if !platform.CompilerSupported() {
+	if !platform.CompilerSupports(api.CoreFeaturesV2 | experimental.CoreFeaturesThreads) {
 		t.Skip()
 	}
 	runAllTests(t, threadTests, wazero.NewRuntimeConfigCompiler().WithCoreFeatures(api.CoreFeaturesV2|experimental.CoreFeaturesThreads), false)

internal/engine/wazevo/backend/backend_test.go

@@ -6,18 +6,28 @@ package platform
 
 import (
 	"runtime"
-)
 
-// archRequirementsVerified is set by platform-specific init to true if the platform is supported
-var archRequirementsVerified bool
+	"github.com/tetratelabs/wazero/api"
+	"github.com/tetratelabs/wazero/experimental"
+)
 
 // CompilerSupported includes constraints here and also the assembler.
 func CompilerSupported() bool {
+	return CompilerSupports(api.CoreFeaturesV2)
+}
+
+func CompilerSupports(features api.CoreFeatures) bool {
 	switch runtime.GOOS {
 	case "linux", "darwin", "freebsd", "netbsd", "dragonfly", "windows":
-		return archRequirementsVerified
+		if runtime.GOARCH == "arm64" {
+			if features.IsEnabled(experimental.CoreFeaturesThreads) {
+				return CpuFeatures.Has(CpuFeatureArm64Atomic)
+			}
+			return true
+		}
+		fallthrough
 	case "solaris", "illumos":
-		return runtime.GOARCH == "amd64" && archRequirementsVerified
+		return runtime.GOARCH == "amd64" && CpuFeatures.Has(CpuFeatureAmd64SSE4_1)
 	default:
 		return false
 	}

internal/integration_test/engine/threads_test.go

@@ -7,7 +7,10 @@ import (
 
 	"github.com/tetratelabs/wazero/api"
 	experimentalapi "github.com/tetratelabs/wazero/experimental"
+	"github.com/tetratelabs/wazero/internal/engine/interpreter"
+	"github.com/tetratelabs/wazero/internal/engine/wazevo"
 	"github.com/tetratelabs/wazero/internal/expctxkeys"
+	"github.com/tetratelabs/wazero/internal/platform"
 	internalsock "github.com/tetratelabs/wazero/internal/sock"
 	internalsys "github.com/tetratelabs/wazero/internal/sys"
 	"github.com/tetratelabs/wazero/internal/wasm"
@@ -148,15 +151,31 @@ func NewRuntime(ctx context.Context) Runtime {
 // NewRuntimeWithConfig returns a runtime with the given configuration.
 func NewRuntimeWithConfig(ctx context.Context, rConfig RuntimeConfig) Runtime {
 	config := rConfig.(*runtimeConfig)
+	configKind := config.engineKind
+	configEngine := config.newEngine
+	if configKind == engineKindAuto {
+		if platform.CompilerSupports(config.enabledFeatures) {
+			configKind = engineKindCompiler
+		} else {
+			configKind = engineKindInterpreter
+		}
+	}
+	if configEngine == nil {
+		if configKind == engineKindCompiler {
+			configEngine = wazevo.NewEngine
+		} else {
+			configEngine = interpreter.NewEngine
+		}
+	}
 	var engine wasm.Engine
 	var cacheImpl *cache
 	if c := config.cache; c != nil {
 		// If the Cache is configured, we share the engine.
 		cacheImpl = c.(*cache)
-		engine = cacheImpl.initEngine(config.engineKind, config.newEngine, ctx, config.enabledFeatures)
+		engine = cacheImpl.initEngine(configKind, configEngine, ctx, config.enabledFeatures)
 	} else {
 		// Otherwise, we create a new engine.
-		engine = config.newEngine(ctx, config.enabledFeatures, nil)
+		engine = configEngine(ctx, config.enabledFeatures, nil)
 	}
 	store := wasm.NewStore(config.enabledFeatures, engine)
 	return &runtime{