Materialize Vector128<T> as a wasm v128 in the codegen ABI

src/coreclr/jit/codegenwasm.cpp

@@ -103,18 +103,6 @@ void CodeGen::genMarkLabelsForCodegen()
 //
 void CodeGen::genBeginFnProlog()
 {
-    // SIMD (Vector2/3/4, Vector128) parameters are lowered to i32 in the wasm signature, so any
-    // vector operation performed on them produces an invalid module (e.g. a v128/f64 op with
-    // an i32 operand). Bail such methods to the interpreter until SIMD parameters are
-    // properly supported in the wasm calling convention.
-    for (unsigned lclNum = 0; lclNum < m_compiler->info.compArgsCount; lclNum++)
-    {
-        if (varTypeIsSIMD(m_compiler->lvaGetDesc(lclNum)->TypeGet()))
-        {
-            NYI_WASM_SIMD("SIMD parameter");
-        }
-    }
-
     GetEmitter()->emitIns(INS_code_size);
 
     FuncInfoDsc* const func = m_compiler->funGetFunc(ROOT_FUNC_IDX);
@@ -2592,11 +2580,6 @@ void CodeGen::genCodeForLclFld(GenTreeLclFld* tree)
     LclVarDsc* varDsc = m_compiler->lvaGetDesc(tree);
     var_types  type   = tree->TypeGet();
 
-    if (type == TYP_SIMD16)
-    {
-        NYI_WASM_SIMD("SIMD16 local field load");
-    }
-
     if (type == TYP_SIMD12)
     {
         genLoadLclTypeSimd12(tree);
@@ -2862,8 +2845,7 @@ void CodeGen::genCodeForStoreInd(GenTreeStoreInd* tree)
     }
     else // A normal store, not a WriteBarrier store
     {
-        var_types   type = tree->TypeGet();
-        instruction ins  = ins_Store(type);
+        var_types type = tree->TypeGet();
 
         // TODO-WASM: Memory barriers
 
@@ -2974,13 +2956,6 @@ void CodeGen::genCallInstruction(GenTreeCall* call)
             assert(seg.IsPassedInRegister());
             WasmValueType wvt = WasmRegToType(seg.GetRegister());
             assert(wvt < WasmValueType::Count);
-            if (wvt == WasmValueType::V128)
-            {
-                // Passing a 16-byte SIMD value by value through a call is not yet correctly
-                // implemented: the argument is materialized as an i32 (by-ref) while the call
-                // signature requires v128, producing an invalid module. Bail for now.
-                NYI_WASM_SIMD("SIMD16 call argument");
-            }
             typeStack.Push((CorInfoWasmType)emitter::GetWasmValueTypeCode(wvt));
         }
     }
@@ -3905,10 +3880,6 @@ void CodeGen::genLoadLocalIntoReg(regNumber targetReg, unsigned lclNum)
 {
     LclVarDsc* varDsc = m_compiler->lvaGetDesc(lclNum);
     var_types  type   = varDsc->GetRegisterType();
-    if (type == TYP_SIMD16)
-    {
-        NYI_WASM_SIMD("SIMD16 local load");
-    }
 
     GetEmitter()->emitIns_I(INS_local_get, EA_PTRSIZE, GetFramePointerRegIndex());
     GetEmitter()->emitIns_S(ins_Load(type), emitTypeSize(type), lclNum, 0);

src/coreclr/jit/targetwasm.cpp

@@ -46,8 +46,7 @@ var_types WasmClassifier::ToJitType(CorInfoWasmType wasmType)
         case CORINFO_WASM_TYPE_F64:
             return TYP_DOUBLE;
         case CORINFO_WASM_TYPE_V128:
-            // TODO-WASM: Simd support
-            unreached();
+            return TYP_SIMD16;
         default:
             unreached();
     }

src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Wasm.cs

@@ -12,6 +12,21 @@ public partial class CompilerTypeSystemContext
         private readonly object _structCacheLock = new object();
         private readonly Dictionary<int, TypeDesc> _structsBySize = new Dictionary<int, TypeDesc>();
         private volatile TypeDesc _cachedEmptyStruct;
+        private volatile TypeDesc _cachedV128Type;
+
+        /// <summary>
+        /// Gets the first SIMD v128 type encountered during lowering, or null if none has been seen.
+        /// Used by RaiseSignature to produce a roundtrippable type for the 'V' encoding.
+        /// </summary>
+        public TypeDesc CachedV128Type => _cachedV128Type;
+
+        /// <summary>
+        /// Caches a SIMD v128 type discovered during lowering. Only the first one is retained.
+        /// </summary>
+        public void CacheV128Type(TypeDesc type)
+        {
+            _cachedV128Type ??= type;
+        }
 
         /// <summary>
         /// Gets the first empty struct type encountered during lowering, or null if none has been seen.

src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs

@@ -147,7 +147,7 @@ public override bool ComputeIsUnsafeValueType(DefType type)
         public override ValueTypeShapeCharacteristics ComputeValueTypeShapeCharacteristics(DefType type)
         {
             if (type.Context.Target.Architecture == TargetArchitecture.ARM64 &&
-                type.Instantiation[0].IsPrimitiveNumeric)
+                IsSupportedVectorBaseType(type.Instantiation[0]))
             {
                 return type.InstanceFieldSize.AsInt switch
                 {
@@ -170,5 +170,14 @@ public static bool IsVectorType(DefType type)
                  type.Name == "Vector256`1"u8 ||
                  type.Name == "Vector512`1"u8);
         }
+
+        /// <summary>
+        /// Determines whether <paramref name="elementType"/> is supported as the base (element)
+        /// type of an intrinsic vector, mirroring the set the JIT recognizes as a SIMD base type.
+        /// </summary>
+        public static bool IsSupportedVectorBaseType(TypeDesc elementType)
+        {
+            return elementType.IsPrimitiveNumeric;
+        }
     }
 }

src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

@@ -3907,6 +3907,8 @@ private CorInfoWasmType getWasmLowering(CORINFO_CLASS_STRUCT_* structHnd)
                     return CorInfoWasmType.CORINFO_WASM_TYPE_F32;
                 case WasmValueType.F64:
                     return CorInfoWasmType.CORINFO_WASM_TYPE_F64;
+                case WasmValueType.V128:
+                    return CorInfoWasmType.CORINFO_WASM_TYPE_V128;
                 default:
                     ThrowHelper.ThrowInvalidProgramException();
                     return CorInfoWasmType.CORINFO_WASM_TYPE_I32; // unreachable

src/coreclr/tools/Common/JitInterface/WasmLowering.cs

@@ -38,6 +38,12 @@ public static MethodSignature GetStringCtorActualSignature(MethodSignature signa
 
         public static TypeDesc LowerToAbiType(TypeDesc type)
         {
+            // Vector128<T> and a 128-bit Vector<T> are wasm v128 ABI primitives passed by value.
+            if (IsWasmV128Type(type))
+            {
+                return type;
+            }
+
             if (!(type.IsValueType && !type.IsPrimitive))
             {
                 return type;
@@ -65,6 +71,10 @@ public static TypeDesc LowerToAbiType(TypeDesc type)
 
                 if (numIntroducedFields != 1)
                 {
+                    // Multi-field aggregates (including a homogeneous 2x v128) use the generic by-ref
+                    // struct ABI; the wasm C ABI has no HFA/HVA concept. Only emscripten's opt-in
+                    // experimental multivalue ABI expands these into per-field registers, which we
+                    // don't target.
                     return null;
                 }
 
@@ -78,6 +88,13 @@ public static TypeDesc LowerToAbiType(TypeDesc type)
 
                 type = firstFieldElementType;
 
+                // A single-field wrapper struct around a v128 lowers to the v128 primitive, matching
+                // emscripten, which passes a struct wrapping a v128 as a v128.
+                if (IsWasmV128Type(type))
+                {
+                    return type;
+                }
+
                 if (type.IsValueType && !type.IsPrimitive)
                 {
                     continue;
@@ -87,10 +104,47 @@ public static TypeDesc LowerToAbiType(TypeDesc type)
             }
         }
 
+        /// <summary>
+        /// Determines whether a type is passed and returned by value as a wasm <c>v128</c>, matching
+        /// the SIMD types the JIT recognizes as <c>TYP_SIMD16</c> on wasm. This is
+        /// <see cref="System.Runtime.Intrinsics.Vector128{T}"/> and a 128-bit
+        /// <see cref="System.Numerics.Vector{T}"/>, in both cases only when <c>T</c> is a supported
+        /// primitive numeric base type. Other SIMD types (Vector2/3/4, Vector64/256/512&lt;T&gt;, ...)
+        /// and non-primitive instantiations (e.g. the shared <c>__Canon</c> form) are not ABI
+        /// primitives and continue to use the generic struct ABI.
+        /// </summary>
+        private static bool IsWasmV128Type(TypeDesc type)
+        {
+            if (!type.IsIntrinsic ||
+                type.Instantiation.Length != 1 ||
+                !VectorFieldLayoutAlgorithm.IsSupportedVectorBaseType(type.Instantiation[0]))
+            {
+                return false;
+            }
+
+            // Vector128<T> is always a 16-byte v128.
+            if (Internal.TypeSystem.Interop.InteropTypes.IsSystemRuntimeIntrinsicsVector128T(type.Context, type))
+            {
+                return true;
+            }
+
+            // Vector<T> is target-sized, so it is only a v128 when the target's maximum SIMD width is
+            // 128-bit (i.e. it is exactly 16 bytes). This matches the JIT recognizing it as TYP_SIMD16
+            // via getVectorTByteLength() and keeps the ABI correct should wasm later gain wider vectors.
+            return type is DefType vectorOfT &&
+                   VectorOfTFieldLayoutAlgorithm.IsVectorOfTType(vectorOfT) &&
+                   type.GetElementSize().AsInt == 16;
+        }
+
         public static WasmValueType LowerType(TypeDesc type)
         {
             WasmValueType pointerType = (type.Context.Target.PointerSize == 4) ? WasmValueType.I32 : WasmValueType.I64;
 
+            if (IsWasmV128Type(type))
+            {
+                return WasmValueType.V128;
+            }
+
             TypeDesc abiType = LowerToAbiType(type);
 
             if (abiType == null)
@@ -165,7 +219,8 @@ public static WasmValueType LowerType(TypeDesc type)
             'l' => context.GetWellKnownType(WellKnownType.Int64),
             'f' => context.GetWellKnownType(WellKnownType.Single),
             'd' => context.GetWellKnownType(WellKnownType.Double),
-            'V' => throw new NotSupportedException("SIMD types are not supported in this version of the compiler"),
+            'V' => ((CompilerTypeSystemContext)context).CachedV128Type
+                   ?? throw new InvalidOperationException("Encountered 'V' in signature but no v128 type was cached during lowering"),
             _ => throw new InvalidOperationException($"Unknown signature char: {c}")
         };
 
@@ -347,7 +402,12 @@ public static WasmSignature GetSignature(MethodSignature signature, LoweringFlag
             }
             else
             {
-                sigBuilder.Append(WasmValueTypeToSigChar(LowerType(loweredReturnType)));
+                WasmValueType returnWasmType = LowerType(loweredReturnType);
+                if (returnWasmType == WasmValueType.V128)
+                {
+                    ((CompilerTypeSystemContext)returnType.Context).CacheV128Type(loweredReturnType);
+                }
+                sigBuilder.Append(WasmValueTypeToSigChar(returnWasmType));
             }
 
             // Reserve space for potential implicit this, stack pointer parameter, portable entrypoint parameter,
@@ -423,7 +483,11 @@ public static WasmSignature GetSignature(MethodSignature signature, LoweringFlag
                 }
                 else
                 {
-                    WasmValueType paramWasmType = LowerType(paramType);
+                    WasmValueType paramWasmType = LowerType(loweredParamType);
+                    if (paramWasmType == WasmValueType.V128)
+                    {
+                        ((CompilerTypeSystemContext)paramType.Context).CacheV128Type(loweredParamType);
+                    }
                     sigBuilder.Append(WasmValueTypeToSigChar(paramWasmType));
                     result.Add(paramWasmType);
                 }

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/VectorOfTFieldLayoutAlgorithm.cs

@@ -78,7 +78,7 @@ public override bool ComputeContainsByRefs(DefType type)
         public override ValueTypeShapeCharacteristics ComputeValueTypeShapeCharacteristics(DefType type)
         {
             if (type.Context.Target.Architecture == TargetArchitecture.ARM64 &&
-                            type.Instantiation[0].IsPrimitiveNumeric)
+                            VectorFieldLayoutAlgorithm.IsSupportedVectorBaseType(type.Instantiation[0]))
             {
                 return type.InstanceFieldSize.AsInt switch
                 {

src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/R2RTestSuites.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection.PortableExecutable;
 using ILCompiler.ReadyToRun.Tests.TestCasesRunner;
 using ILCompiler.Reflection.ReadyToRun;
@@ -120,6 +121,87 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
+    [Fact]
+    public void WasmSimdModule()
+    {
+        var wasmSimdModule = new CompiledAssembly
+        {
+            AssemblyName = nameof(WasmSimdModule),
+            SourceResourceNames = ["Webcil/WasmSimdModule.cs"],
+        };
+
+        new R2RTestRunner(_output).Run(new R2RTestCase(
+            nameof(WasmSimdModule),
+            [
+                new(nameof(WasmSimdModule), [new CrossgenAssembly(wasmSimdModule)])
+                {
+                    OutputFileExtension = ".wasm",
+                    AdditionalArgs =
+                    {
+                        "--targetarch",
+                        "wasm",
+                        "--targetos",
+                        "browser",
+                    },
+                    Validate = Validate,
+                },
+            ]));
+
+        static void Validate(ReadyToRunReader reader)
+        {
+            var webcilReader = Assert.IsType<WebcilImageReader>(reader.CompositeReader);
+            Assert.True(webcilReader.IsWasmWrapped);
+            Assert.Equal(WasmMachine.Wasm32, reader.Machine);
+
+            List<ReadyToRunMethod> methods = R2RAssert.GetAllMethods(reader);
+
+            // Each method's compiled body must actually use the wasm v128 (0x7B) valtype for its
+            // Vector128<int> parameter, and for its return when it returns one. A regression that
+            // reverts to the by-ref i32 ABI would produce no v128 in the signature at all.
+            const byte WasmV128 = 0x7B;
+
+            // (method name, expects v128 return). All take a v128-classified value by value (a
+            // Vector128<int>, a 128-bit Vector<int>, or a single-field struct wrapping one); Store
+            // returns void (its 'ref Vector128<int>' destination is an i32 pointer).
+            foreach ((string name, bool expectsV128Return) in
+                     new[]
+                     {
+                         ("Echo", true), ("ThroughLocal", true), ("Store", false), ("CallEcho", true),
+                         ("EchoVectorT", true), ("CallEchoVectorT", true),
+                         ("EchoWrapped", true), ("CallEchoWrapped", true),
+                         ("EchoWrappedVectorT", true), ("CallEchoWrappedVectorT", true),
+                     })
+            {
+                ReadyToRunMethod method = Assert.Single(
+                    methods, m => m.SignatureString.Contains($".{name}(", StringComparison.Ordinal));
+
+                WebcilImageReader.WasmFunctionInfo body = ResolveWasmBody(reader, webcilReader, method);
+
+                Assert.True(
+                    body.ParamTypes.Count(b => b == WasmV128) == 1,
+                    $"'{name}' should have exactly one wasm v128 parameter; params were {Format(body.ParamTypes)}.");
+                Assert.True(
+                    body.ResultTypes.Contains(WasmV128) == expectsV128Return,
+                    $"'{name}' v128 return expectation was {expectsV128Return}; results were {Format(body.ResultTypes)}.");
+            }
+
+            static string Format(IReadOnlyList<byte> valTypes) =>
+                $"[{string.Join(",", valTypes.Select(b => $"0x{b:X2}"))}]";
+        }
+
+        static WebcilImageReader.WasmFunctionInfo ResolveWasmBody(
+            ReadyToRunReader reader, WebcilImageReader webcilReader, ReadyToRunMethod method)
+        {
+            uint tableIndex = checked(reader.WasmMinFunctionTableIndex + (uint)method.EntryPointRuntimeFunctionId);
+            int functionIndex = webcilReader.GetFunctionIndexFromTableIndex(tableIndex);
+            Assert.True(functionIndex >= 0, $"Could not resolve wasm table index {tableIndex} to a function body.");
+
+            WebcilImageReader.WasmFunctionInfo? body = webcilReader.GetWasmFunctionBody(functionIndex);
+            Assert.True(body is not null, $"Wasm function body {functionIndex} was not found.");
+            return body.Value;
+        }
+    }
+
     [Fact]
     public void RuntimeFunctionsSectionSizeExcludesSentinel()
     {