[mono][wasm] Add Truncate/CopySign/ScaleB intrinsics + narrow #103347 test exemption

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/HalfTests.cs

@@ -549,13 +549,25 @@ public static IEnumerable<object[]> ExplicitConversion_FromSingle_TestData()
 
  foreach ((float original, Half expected) in data)
  {
+ // WASM on Mono lowers `float.Min` / `float.Max` through `f32.min` / `f32.max`
+ // (and `float.IsNaN(...)` branches through `f32.add`). The WebAssembly spec
+ // permits NaN-payload canonicalization on these ops but doesn't require it --
+ // arch-native targets (Arm64, xArch) don't canonicalize, at most stripping
+ // the signaling bit per IEEE 754. The V8 engine used by the CI Helix queues
+ // does canonicalize, so the bit-strict NaN cases in this theory don't round-
+ // trip through the software conversion path in that environment. Gated on
+ // Mono specifically since other WASM runtimes don't share this lowering.
+ // Tracked in https://github.com/dotnet/runtime/issues/103347; this filter can
+ // be removed once the conversion path either avoids the canonicalizing ops
+ // or the host engines start preserving NaN payloads.
+ if (PlatformDetection.IsMonoRuntime && PlatformDetection.IsWasm && float.IsNaN(original))
+ continue;
  yield return new object[] { original, expected };
  }
  }
 
  [MemberData(nameof(ExplicitConversion_FromSingle_TestData))]
  [Theory]
- [ActiveIssue("https://github.com/dotnet/runtime/issues/103347", TestPlatforms.Browser)]
  public static void ExplicitConversion_FromSingle(float f, Half expected) // Check the underlying bits for verifying NaNs
  {
  Half h = (Half)f;

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs

@@ -532,13 +532,25 @@ public static IEnumerable<object[]> ExplicitConversion_FromSingle_TestData()
 
  foreach ((float original, BFloat16 expected) in data)
  {
+ // WASM on Mono lowers `float.Min` / `float.Max` through `f32.min` / `f32.max`
+ // (and `float.IsNaN(...)` branches through `f32.add`). The WebAssembly spec
+ // permits NaN-payload canonicalization on these ops but doesn't require it --
+ // arch-native targets (Arm64, xArch) don't canonicalize, at most stripping
+ // the signaling bit per IEEE 754. The V8 engine used by the CI Helix queues
+ // does canonicalize, so the bit-strict NaN cases in this theory don't round-
+ // trip through the software conversion path in that environment. Gated on
+ // Mono specifically since other WASM runtimes don't share this lowering.
+ // Tracked in https://github.com/dotnet/runtime/issues/103347; this filter can
+ // be removed once the conversion path either avoids the canonicalizing ops
+ // or the host engines start preserving NaN payloads.
+ if (PlatformDetection.IsMonoRuntime && PlatformDetection.IsWasm && float.IsNaN(original))
+ continue;
  yield return new object[] { original, expected };
  }
  }
 
  [MemberData(nameof(ExplicitConversion_FromSingle_TestData))]
  [Theory]
- [ActiveIssue("https://github.com/dotnet/runtime/issues/103347", TestPlatforms.Browser)]
  public static void ExplicitConversion_FromSingle(float f, BFloat16 expected) // Check the underlying bits for verifying NaNs
  {
  BFloat16 b16 = (BFloat16)f;
@@ -618,13 +630,25 @@ public static IEnumerable<object[]> ExplicitConversion_FromDouble_TestData()
 
  foreach ((double original, BFloat16 expected) in data)
  {
+ // WASM on Mono lowers `double.Min` / `double.Max` through `f64.min` / `f64.max`
+ // (and `double.IsNaN(...)` branches through `f64.add`). The WebAssembly spec
+ // permits NaN-payload canonicalization on these ops but doesn't require it --
+ // arch-native targets (Arm64, xArch) don't canonicalize, at most stripping
+ // the signaling bit per IEEE 754. The V8 engine used by the CI Helix queues
+ // does canonicalize, so the bit-strict NaN cases in this theory don't round-
+ // trip through the software conversion path in that environment. Gated on
+ // Mono specifically since other WASM runtimes don't share this lowering.
+ // Tracked in https://github.com/dotnet/runtime/issues/103347; this filter can
+ // be removed once the conversion path either avoids the canonicalizing ops
+ // or the host engines start preserving NaN payloads.
+ if (PlatformDetection.IsMonoRuntime && PlatformDetection.IsWasm && double.IsNaN(original))
+ continue;
  yield return new object[] { original, expected };
  }
  }
 
  [MemberData(nameof(ExplicitConversion_FromDouble_TestData))]
  [Theory]
- [ActiveIssue("https://github.com/dotnet/runtime/issues/103347", TestPlatforms.Browser)]
  public static void ExplicitConversion_FromDouble(double d, BFloat16 expected) // Check the underlying bits for verifying NaNs
  {
  BFloat16 b16 = (BFloat16)d;

src/mono/browser/browser.proj

@@ -164,10 +164,12 @@
  <EmccExportedFunction Include="_atan2" />
  <EmccExportedFunction Include="_fma" />
  <EmccExportedFunction Include="_pow" />
+ <EmccExportedFunction Include="_scalbn" />
  <EmccExportedFunction Include="_fmodf" />
  <EmccExportedFunction Include="_atan2f" />
  <EmccExportedFunction Include="_fmaf" />
  <EmccExportedFunction Include="_powf" />
+ <EmccExportedFunction Include="_scalbnf" />
 
  <EmccExportedFunction Include="_asin" />
  <EmccExportedFunction Include="_asinh" />

src/mono/browser/runtime/jiterpreter-tables.ts

@@ -282,6 +282,8 @@ export const mathIntrinsicTable: { [opcode: number]: [isUnary: boolean, isF32: b
  [MintOpcode.MINT_FLOORF]: [true, true, WasmOpcode.f32_floor],
  [MintOpcode.MINT_ABS]: [true, false, WasmOpcode.f64_abs],
  [MintOpcode.MINT_ABSF]: [true, true, WasmOpcode.f32_abs],
+ [MintOpcode.MINT_TRUNC]: [true, false, WasmOpcode.f64_trunc],
+ [MintOpcode.MINT_TRUNCF]: [true, true, WasmOpcode.f32_trunc],
 
  [MintOpcode.MINT_ACOS]: [true, false, "acos"],
  [MintOpcode.MINT_ACOSF]: [true, true, "acosf"],
@@ -316,6 +318,8 @@ export const mathIntrinsicTable: { [opcode: number]: [isUnary: boolean, isF32: b
  [MintOpcode.MINT_MINF]: [false, true, WasmOpcode.f32_min],
  [MintOpcode.MINT_MAX]: [false, false, WasmOpcode.f64_max],
  [MintOpcode.MINT_MAXF]: [false, true, WasmOpcode.f32_max],
+ [MintOpcode.MINT_COPYSIGN]: [false, false, WasmOpcode.f64_copysign],
+ [MintOpcode.MINT_COPYSIGNF]:[false, true, WasmOpcode.f32_copysign],
 
  [MintOpcode.MINT_ATAN2]: [false, false, "atan2"],
  [MintOpcode.MINT_ATAN2F]: [false, true, "atan2f"],

src/mono/browser/runtime/jiterpreter-trace-generator.ts

@@ -1617,6 +1617,27 @@ export function generateWasmBody (
  break;
  }
 
+ case MintOpcode.MINT_SCALEB:
+ case MintOpcode.MINT_SCALEBF: {
+ // Math.ScaleB / MathF.ScaleB. Signature is (double, int) -> double
+ // and (float, int) -> float, so we can't go through mathIntrinsicTable
+ // (which assumes a uniform float-only shape). Mirror the FMA special
+ // case instead and call libm scalbn / scalbnf directly.
+ const isF32 = (opcode === MintOpcode.MINT_SCALEBF),
+ loadOp = isF32 ? WasmOpcode.f32_load : WasmOpcode.f64_load,
+ storeOp = isF32 ? WasmOpcode.f32_store : WasmOpcode.f64_store;
+
+ builder.local("pLocals");
+
+ append_ldloc(builder, getArgU16(ip, 2), loadOp);
+ append_ldloc(builder, getArgU16(ip, 3), WasmOpcode.i32_load);
+
+ builder.callImport(isF32 ? "scalbnf" : "scalbn");
+
+ append_stloc_tail(builder, getArgU16(ip, 1), storeOp);
+ break;
+ }
+
  default:
  if (
  (
@@ -1689,7 +1710,7 @@ export function generateWasmBody (
  } else if (
  // math intrinsics
  (opcode >= MintOpcode.MINT_ASIN) &&
- (opcode <= MintOpcode.MINT_MAXF)
+ (opcode <= MintOpcode.MINT_COPYSIGNF)
  ) {
  if (!emit_math_intrinsic(builder, ip, opcode))
  ip = abort;

src/mono/browser/runtime/jiterpreter.ts

@@ -289,6 +289,8 @@ function getTraceImports () {
  ["stelemr_tc", "stelemr", getRawCwrap("mono_jiterp_stelem_ref")],
  importDef("fma", getRawCwrap("fma")),
  importDef("fmaf", getRawCwrap("fmaf")),
+ importDef("scalbn", getRawCwrap("scalbn")),
+ importDef("scalbnf", getRawCwrap("scalbnf")),
  ];
 
  if (instrumentedMethodNames.length > 0) {
@@ -449,6 +451,22 @@ function initialize_builder (builder: WasmBuilder) {
  },
  WasmValtype.f64, true
  );
+ builder.defineType(
+ "scalbnf",
+ {
+ "x": WasmValtype.f32,
+ "n": WasmValtype.i32,
+ },
+ WasmValtype.f32, true
+ );
+ builder.defineType(
+ "scalbn",
+ {
+ "x": WasmValtype.f64,
+ "n": WasmValtype.i32,
+ },
+ WasmValtype.f64, true
+ );
  builder.defineType(
  "trace_eip",
  {

src/mono/mono/mini/interp/interp.c

@@ -7976,11 +7976,13 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_TAN) MATH_UNOP(tan); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_TANH) MATH_UNOP(tanh); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_ABS) MATH_UNOP(fabs); MINT_IN_BREAK;
+ MINT_IN_CASE(MINT_TRUNC) MATH_UNOP(trunc); MINT_IN_BREAK;
 
  MINT_IN_CASE(MINT_ATAN2) MATH_BINOP(atan2); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_POW) MATH_BINOP(pow); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_MIN) MATH_BINOP(min_d); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_MAX) MATH_BINOP(max_d); MINT_IN_BREAK;
+ MINT_IN_CASE(MINT_COPYSIGN) MATH_BINOP(copysign); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_FMA)
  LOCAL_VAR (ip [1], double) = fma (LOCAL_VAR (ip [2], double), LOCAL_VAR (ip [3], double), LOCAL_VAR (ip [4], double));
  ip += 5;
@@ -8018,11 +8020,13 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_TANF) MATH_UNOPF(tanf); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_TANHF) MATH_UNOPF(tanhf); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_ABSF) MATH_UNOPF(fabsf); MINT_IN_BREAK;
+ MINT_IN_CASE(MINT_TRUNCF) MATH_UNOPF(truncf); MINT_IN_BREAK;
 
  MINT_IN_CASE(MINT_ATAN2F) MATH_BINOPF(atan2f); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_POWF) MATH_BINOPF(powf); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_MINF) MATH_BINOPF(min_f); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_MAXF) MATH_BINOPF(max_f); MINT_IN_BREAK;
+ MINT_IN_CASE(MINT_COPYSIGNF) MATH_BINOPF(copysignf); MINT_IN_BREAK;
  MINT_IN_CASE(MINT_FMAF)
  LOCAL_VAR (ip [1], float) = fmaf (LOCAL_VAR (ip [2], float), LOCAL_VAR (ip [3], float), LOCAL_VAR (ip [4], float));
  ip += 5;

src/mono/mono/mini/interp/jiterpreter-opcode-values.h

@@ -48,7 +48,7 @@ OPRANGE(MINT_ADD1_I4, MINT_CEQ0_I4, NORMAL)
 // Some superinsns that will be faster in jiterp due to inline constants
 OPRANGE(MINT_ADD_I4_IMM, MINT_ADD_MUL_I8_IMM, HIGH)
 // Math intrinsics. We implement most of these by calling libc or using wasm opcodes
-OPRANGE(MINT_ASIN, MINT_MAXF, NORMAL)
+OPRANGE(MINT_ASIN, MINT_COPYSIGNF, NORMAL)
 // Field operations. Null check optimization makes these more efficient than interp
 OPRANGE(MINT_LDFLD_I1, MINT_LDTSFLDA, HIGH)
 // Indirect operations. Some of these are complex or more efficient than interp

src/mono/mono/mini/interp/mintops.def

@@ -763,6 +763,8 @@ OPDEF(MINT_TANH, "tanh", 3, 1, 1, MintOpNoArgs)
 OPDEF(MINT_ABS, "abs_d", 3, 1, 1, MintOpNoArgs)
 OPDEF(MINT_MIN, "min_d", 4, 1, 2, MintOpNoArgs)
 OPDEF(MINT_MAX, "max_d", 4, 1, 2, MintOpNoArgs)
+OPDEF(MINT_TRUNC, "trunc_d", 3, 1, 1, MintOpNoArgs)
+OPDEF(MINT_COPYSIGN, "copysign_d", 4, 1, 2, MintOpNoArgs)
 
 // float. These must be kept in the same order as their double counterpart
 OPDEF(MINT_ASINF, "asinf", 3, 1, 1, MintOpNoArgs)
@@ -792,6 +794,8 @@ OPDEF(MINT_TANHF, "tanhf", 3, 1, 1, MintOpNoArgs)
 OPDEF(MINT_ABSF, "abs_f", 3, 1, 1, MintOpNoArgs)
 OPDEF(MINT_MINF, "min_f", 4, 1, 2, MintOpNoArgs)
 OPDEF(MINT_MAXF, "max_f", 4, 1, 2, MintOpNoArgs)
+OPDEF(MINT_TRUNCF, "trunc_f", 3, 1, 1, MintOpNoArgs)
+OPDEF(MINT_COPYSIGNF, "copysign_f", 4, 1, 2, MintOpNoArgs)
 
 OPDEF(MINT_PROF_ENTER, "prof_enter", 2, 0, 0, MintOpShortInt)
 OPDEF(MINT_PROF_SAMPLEPOINT, "prof_samplepoint", 2, 0, 0, MintOpShortInt)

src/mono/mono/mini/interp/transform.c

@@ -2090,6 +2090,8 @@ interp_handle_intrinsics (TransformData *td, MonoMethod *target_method, MonoClas
  *op = MINT_TAN;
  } else if (strcmp (tm, "Tanh") == 0){
  *op = MINT_TANH;
+ } else if (strcmp (tm, "Truncate") == 0) {
+ *op = MINT_TRUNC;
  }
  }
  } else if (csignature->param_count == 2 && csignature->params [0]->type == param_type && csignature->params [1]->type == param_type) {
@@ -2101,6 +2103,8 @@ interp_handle_intrinsics (TransformData *td, MonoMethod *target_method, MonoClas
  *op = MINT_MIN;
  else if (strcmp (tm, "Max") == 0)
  *op = MINT_MAX;
+ else if (strcmp (tm, "CopySign") == 0)
+ *op = MINT_COPYSIGN;
  } else if (csignature->param_count == 3 && csignature->params [0]->type == param_type && csignature->params [1]->type == param_type && csignature->params [2]->type == param_type) {
  if (strcmp (tm, "FusedMultiplyAdd") == 0)
  *op = MINT_FMA;