[Wasm RyuJit] Wasm abi classifier

src/coreclr/inc/corinfo.h

@@ -3185,6 +3185,10 @@ class ICorStaticInfo
     // Returns lowering info for fields of a RISC-V/LoongArch struct passed in registers according to
     // hardware floating-point calling convention.
     virtual void getFpStructLowering(CORINFO_CLASS_HANDLE structHnd, CORINFO_FPSTRUCT_LOWERING* pLowering) = 0;
+
+    // Returns the primitive type for passing/returning a Wasm struct by value,
+    // or CORINFO_WASM_TYPE_VOID if passing/returning must be by reference.
+    virtual CorInfoWasmType getWasmLowering(CORINFO_CLASS_HANDLE structHnd) = 0;
 };
 
 /*****************************************************************************

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -535,6 +535,9 @@ void getFpStructLowering(
           CORINFO_CLASS_HANDLE structHnd,
           CORINFO_FPSTRUCT_LOWERING* pLowering) override;
 
+CorInfoWasmType getWasmLowering(
+          CORINFO_CLASS_HANDLE structHnd) override;
+
 uint32_t getThreadTLSIndex(
           void** ppIndirection) override;
 

src/coreclr/inc/jiteeversionguid.h

@@ -37,11 +37,11 @@
 
 #include <minipal/guid.h>
 
-constexpr GUID JITEEVersionIdentifier = { /* 868b8ae2-0000-410b-a9dc-38d9eda37d66 */
-    0x868b8ae2,
-    0x0000,
-    0x410b,
-    {0xa9, 0xdc, 0x38, 0xd9, 0xed, 0xa3, 0x7d, 0x66}
+constexpr GUID JITEEVersionIdentifier = { /* 1774da53-2dcd-42cd-bb0f-ae7f66c79e8e */
+    0x1774da53,
+    0x2dcd,
+    0x42cd,
+    {0xbb, 0x0f, 0xae, 0x7f, 0x66, 0xc7, 0x9e, 0x8e}
   };
 
 #endif // JIT_EE_VERSIONING_GUID_H

src/coreclr/jit/ICorJitInfo_names_generated.h

@@ -132,6 +132,7 @@ DEF_CLR_API(getMethodHash)
 DEF_CLR_API(getSystemVAmd64PassStructInRegisterDescriptor)
 DEF_CLR_API(getSwiftLowering)
 DEF_CLR_API(getFpStructLowering)
+DEF_CLR_API(getWasmLowering)
 DEF_CLR_API(getThreadTLSIndex)
 DEF_CLR_API(getAddrOfCaptureThreadGlobal)
 DEF_CLR_API(getHelperFtn)

src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp

@@ -1262,6 +1262,15 @@ void WrapICorJitInfo::getFpStructLowering(
     API_LEAVE(getFpStructLowering);
 }
 
+CorInfoWasmType WrapICorJitInfo::getWasmLowering(
+          CORINFO_CLASS_HANDLE structHnd)
+{
+    API_ENTER(getWasmLowering);
+    CorInfoWasmType temp = wrapHnd->getWasmLowering(structHnd);
+    API_LEAVE(getWasmLowering);
+    return temp;
+}
+
 uint32_t WrapICorJitInfo::getThreadTLSIndex(
           void** ppIndirection)
 {

src/coreclr/jit/abi.h

@@ -343,6 +343,8 @@ class WasmClassifier
         return 0;
     }
 
+    static var_types ToJitType(CorInfoWasmType wasmType);
+
     ABIPassingInformation Classify(Compiler*    comp,
                                    var_types    type,
                                    ClassLayout* structLayout,

src/coreclr/jit/codegencommon.cpp

@@ -1915,6 +1915,10 @@ void CodeGen::genGenerateMachineCode()
         printf("generic LOONGARCH64");
 #elif defined(TARGET_RISCV64)
         printf("generic RISCV64");
+#elif defined(TARGET_WASM32)
+        printf("wasm32");
+#elif defined(TARGET_WASM64)
+        printf("wasm64");
 #else
         printf("unknown architecture");
 #endif

src/coreclr/jit/compiler.cpp

@@ -756,6 +756,38 @@ var_types Compiler::getReturnTypeForStruct(CORINFO_CLASS_HANDLE     clsHnd,
     }
     assert(structSize > 0);
 
+#if defined(TARGET_WASM)
+    CorInfoWasmType abiType = info.compCompHnd->getWasmLowering(clsHnd);
+
+    if (abiType == CORINFO_WASM_TYPE_VOID)
+    {
+        howToReturnStruct = SPK_ByReference;
+        useType           = TYP_UNKNOWN;
+    }
+    else
+    {
+        howToReturnStruct = SPK_ByValue;
+        useType           = WasmClassifier::ToJitType(abiType);
+    }
+
+    if (wbReturnStruct != nullptr)
+    {
+        *wbReturnStruct = howToReturnStruct;
+    }
+
+    return useType;
+#else
+#ifdef DEBUG
+    // Extra query to facilitate wasm replay of native collections.
+    // TODO-WASM: delete once we can get a wasm collection.
+    //
+    if (JitConfig.EnableExtraSuperPmiQueries() && IsReadyToRun())
+    {
+        info.compCompHnd->getWasmLowering(clsHnd);
+    }
+#endif // DEBUG
+#endif // defined(TARGET_WASM)
+
 #ifdef SWIFT_SUPPORT
     if (callConv == CorInfoCallConvExtension::Swift)
     {

src/coreclr/jit/lclvars.cpp

@@ -951,6 +951,20 @@ void Compiler::lvaClassifyParameterABI(Classifier& classifier)
 
         dsc->lvIsRegArg      = numRegisters > 0;
         dsc->lvIsMultiRegArg = numRegisters > 1;
+
+#ifdef DEBUG
+        // Extra query to facilitate wasm replay of native collections.
+        // TODO-WASM: delete once we can get a wasm collection.
+        //
+        if (JitConfig.EnableExtraSuperPmiQueries() && IsReadyToRun() && (structLayout != nullptr))
+        {
+            CORINFO_CLASS_HANDLE clsHnd = structLayout->GetClassHandle();
+            if (clsHnd != NO_CLASS_HANDLE)
+            {
+                info.compCompHnd->getWasmLowering(clsHnd);
+            }
+        }
+#endif // DEBUG
     }
 
     lvaParameterStackSize = classifier.StackSize();

src/coreclr/jit/targetwasm.cpp

@@ -27,6 +27,32 @@ WasmClassifier::WasmClassifier(const ClassifierInfo& info)
 {
 }
 
+//-----------------------------------------------------------------------------
+// ToJitType: translate CorInfoWasmType to var_types
+//
+// Parameters:
+//   wasmType -- wasm type to translate
+//
+var_types WasmClassifier::ToJitType(CorInfoWasmType wasmType)
+{
+    switch (wasmType)
+    {
+        case CORINFO_WASM_TYPE_I32:
+            return TYP_INT;
+        case CORINFO_WASM_TYPE_I64:
+            return TYP_LONG;
+        case CORINFO_WASM_TYPE_F32:
+            return TYP_FLOAT;
+        case CORINFO_WASM_TYPE_F64:
+            return TYP_DOUBLE;
+        case CORINFO_WASM_TYPE_V128:
+            // TODO-WASM: Simd support
+            unreached();
+        default:
+            unreached();
+    }
+}
+
 //-----------------------------------------------------------------------------
 // Classify:
 //   Classify a parameter for the Wasm ABI.
@@ -48,7 +74,25 @@ ABIPassingInformation WasmClassifier::Classify(Compiler*    comp,
 {
     if (type == TYP_STRUCT)
     {
-        NYI_WASM("WasmClassifier::Classify - structs");
+        CORINFO_CLASS_HANDLE clsHnd = structLayout->GetClassHandle();
+        assert(clsHnd != NO_CLASS_HANDLE);
+        CorInfoWasmType wasmAbiType = comp->info.compCompHnd->getWasmLowering(clsHnd);
+        bool            passByRef   = false;
+        var_types       abiType     = TYP_UNDEF;
+
+        if (wasmAbiType == CORINFO_WASM_TYPE_VOID)
+        {
+            abiType   = TYP_I_IMPL;
+            passByRef = true;
+        }
+        else
+        {
+            abiType = ToJitType(wasmAbiType);
+        }
+
+        regNumber         reg = MakeWasmReg(m_localIndex++, genActualType(abiType));
+        ABIPassingSegment seg = ABIPassingSegment::InRegister(reg, 0, genTypeSize(abiType));
+        return ABIPassingInformation::FromSegment(comp, passByRef, seg);
     }
 
     regNumber         reg = MakeWasmReg(m_localIndex++, genActualType(type));

src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs

@@ -385,15 +385,21 @@ private protected override void EmitSymbolTable(IDictionary<Utf8String, SymbolDe
         }
     }
 
-    // TODO-WASM: The logic here isn't comprehensive yet. It should cover primitive types and references,
-    // but by-value structs + nullable types aren't handled yet.
     public static class WasmAbiContext
     {
         private static WasmValueType LowerType(TypeDesc type)
         {
-            if ((type.IsValueType && !type.IsPrimitive) || type.IsNullable)
+            WasmValueType pointerType = (type.Context.Target.PointerSize == 4) ? WasmValueType.I32 : WasmValueType.I64;
+
+            if (type.IsValueType && !type.IsPrimitiveNumeric)
             {
-                throw new NotImplementedException($"By-value struct types are not yet supported: {type}");
+                type = Internal.JitInterface.WasmLowering.LowerTypeForWasm(type);
+
+                if (type == null)
+                {
+                    // pass by-ref
+                    return pointerType;
+                }
             }
 
             switch (type.UnderlyingType.Category)
@@ -428,7 +434,7 @@ private static WasmValueType LowerType(TypeDesc type)
                 case TypeFlags.ByRef:
                 case TypeFlags.Pointer:
                 case TypeFlags.FunctionPointer:
-                    return WasmValueType.I32;
+                    return pointerType;
 
                 default:
                     throw new NotSupportedException($"Unknown wasm mapping for type: {type.UnderlyingType.Category}");
@@ -449,7 +455,6 @@ private static WasmValueType LowerType(TypeDesc type)
         public static WasmFuncType GetSignature(MethodDesc method)
         {
             // TODO-WASM: handle struct by-value return (extra parameter pointing to buffer must be in signature)
-            // TODO-WASM: handle seemingly by-value struct arguments that are actually passed implicitly by reference
 
             MethodSignature signature = method.Signature;
             TypeDesc returnType = signature.ReturnType;

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

@@ -3638,6 +3638,25 @@ private void getFpStructLowering(CORINFO_CLASS_STRUCT_* structHnd, ref CORINFO_F
             }
         }
 
+        private CorInfoWasmType getWasmLowering(CORINFO_CLASS_STRUCT_* structHnd)
+        {
+            // Call getClassSize to make sure we record the proper dependence
+            _ = getClassSize(structHnd);
+
+            TypeDesc type = HandleToObject(structHnd);
+            CorInfoType corType = asCorInfoType(type);
+            Debug.Assert(corType == CorInfoType.CORINFO_TYPE_VALUECLASS);
+            TypeDesc abiType = WasmLowering.LowerTypeForWasm(type);
+
+            if (abiType == null)
+            {
+                // Indicate type should be passed by-ref.
+                return CorInfoWasmType.CORINFO_WASM_TYPE_VOID;
+            }
+
+            return WasmLowering.WasmTypeClassification(abiType);
+        }
+
         private uint getThreadTLSIndex(ref void* ppIndirection)
         { throw new NotImplementedException("getThreadTLSIndex"); }
 

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

@@ -148,6 +148,7 @@ static ICorJitInfoCallbacks()
                 s_callbacks.getSystemVAmd64PassStructInRegisterDescriptor = &_getSystemVAmd64PassStructInRegisterDescriptor;
                 s_callbacks.getSwiftLowering = &_getSwiftLowering;
                 s_callbacks.getFpStructLowering = &_getFpStructLowering;
+                s_callbacks.getWasmLowering = &_getWasmLowering;
                 s_callbacks.getThreadTLSIndex = &_getThreadTLSIndex;
                 s_callbacks.getAddrOfCaptureThreadGlobal = &_getAddrOfCaptureThreadGlobal;
                 s_callbacks.getHelperFtn = &_getHelperFtn;
@@ -328,6 +329,7 @@ static ICorJitInfoCallbacks()
             public delegate* unmanaged<IntPtr, IntPtr*, CORINFO_CLASS_STRUCT_*, SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR*, byte> getSystemVAmd64PassStructInRegisterDescriptor;
             public delegate* unmanaged<IntPtr, IntPtr*, CORINFO_CLASS_STRUCT_*, CORINFO_SWIFT_LOWERING*, void> getSwiftLowering;
             public delegate* unmanaged<IntPtr, IntPtr*, CORINFO_CLASS_STRUCT_*, CORINFO_FPSTRUCT_LOWERING*, void> getFpStructLowering;
+            public delegate* unmanaged<IntPtr, IntPtr*, CORINFO_CLASS_STRUCT_*, CorInfoWasmType> getWasmLowering;
             public delegate* unmanaged<IntPtr, IntPtr*, void**, uint> getThreadTLSIndex;
             public delegate* unmanaged<IntPtr, IntPtr*, void**, int*> getAddrOfCaptureThreadGlobal;
             public delegate* unmanaged<IntPtr, IntPtr*, CorInfoHelpFunc, CORINFO_CONST_LOOKUP*, CORINFO_METHOD_STRUCT_**, void> getHelperFtn;
@@ -2273,6 +2275,21 @@ private static void _getFpStructLowering(IntPtr thisHandle, IntPtr* ppException,
             }
         }
 
+        [UnmanagedCallersOnly]
+        private static CorInfoWasmType _getWasmLowering(IntPtr thisHandle, IntPtr* ppException, CORINFO_CLASS_STRUCT_* structHnd)
+        {
+            var _this = GetThis(thisHandle);
+            try
+            {
+                return _this.getWasmLowering(structHnd);
+            }
+            catch (Exception ex)
+            {
+                *ppException = _this.AllocException(ex);
+                return default;
+            }
+        }
+
         [UnmanagedCallersOnly]
         private static uint _getThreadTLSIndex(IntPtr thisHandle, IntPtr* ppException, void** ppIndirection)
         {

src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt

@@ -301,6 +301,7 @@ FUNCTIONS
     bool getSystemVAmd64PassStructInRegisterDescriptor(CORINFO_CLASS_HANDLE  structHnd, SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr);
     void getSwiftLowering(CORINFO_CLASS_HANDLE structHnd, CORINFO_SWIFT_LOWERING* pLowering);
     void getFpStructLowering(CORINFO_CLASS_HANDLE structHnd, CORINFO_FPSTRUCT_LOWERING* pLowering);
+    CorInfoWasmType getWasmLowering(CORINFO_CLASS_HANDLE structHnd);
     uint32_t getThreadTLSIndex(void                  **ppIndirection);
     int32_t * getAddrOfCaptureThreadGlobal(void                  **ppIndirection);
     void getHelperFtn (CorInfoHelpFunc ftnNum, CORINFO_CONST_LOOKUP* pNativeEntrypoint, CORINFO_METHOD_HANDLE *pMethod);