Create a WASM-targeting RyuJit

Notable build system changes:
 1) Not included in clr.alljits yet. Build with clr.wasmjit.

Notable factoring choices:
 1) Introduce some new target defines for features which WASM won't need,
    like fixed size register mask support and GCInfo based on code metadata.
 2) For this initial commit, the amount of changes has been intentionally
    minimized. In the future, more things will be moved around and ifdefed
    out.

Author: SingleAccretion

eng/Subsets.props

@@ -219,6 +219,7 @@
     <SubsetName Include="Clr.PalTestList" OnDemand="true" Description="Generate the list of the CoreCLR PAL tests. When using the command line, use Clr.PalTests instead." />
     <SubsetName Include="Clr.Hosts" Description="The CoreCLR corerun test host." />
     <SubsetName Include="Clr.Jit" Description="The JIT for the CoreCLR .NET runtime." />
+    <SubsetName Include="Clr.WasmJit" Description="The cross-targeting WebAssembly JIT compiler for the CoreCLR .NET runtime." />
     <SubsetName Include="Clr.AllJits" Description="All of the cross-targeting JIT compilers for the CoreCLR .NET runtime." />
     <SubsetName Include="Clr.AllJitsCommunity" Description="All of the cross-targeting JIT compilers for the CoreCLR .NET runtime, including community targets." />
     <SubsetName Include="Clr.Spmi" Description="SuperPMI, a tool for CoreCLR JIT testing." />
@@ -322,6 +323,10 @@
     <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrJitSubset=true</ClrRuntimeBuildSubsets>
   </PropertyGroup>
 
+  <PropertyGroup Condition="$(_subset.Contains('+clr.wasmjit+'))">
+    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrWasmJitSubset=true</ClrRuntimeBuildSubsets>
+  </PropertyGroup>
+
   <PropertyGroup Condition="$(_subset.Contains('+clr.paltests+'))">
     <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrPalTestsSubset=true</ClrRuntimeBuildSubsets>
   </PropertyGroup>

src/coreclr/build-runtime.cmd

@@ -329,6 +329,9 @@ for /f "delims=" %%a in ("-%__RequestedBuildComponents%-") do (
     if not "!string:-jit-=!"=="!string!" (
         set __CMakeTarget=!__CMakeTarget! jit
     )
+    if not "!string:-wasmjit-=!"=="!string!" (
+        set __CMakeTarget=!__CMakeTarget! wasmjit
+    )
     if not "!string:-alljits-=!"=="!string!" (
         set __CMakeTarget=!__CMakeTarget! alljits
     )

src/coreclr/clrdefinitions.cmake

@@ -283,6 +283,9 @@ function(set_target_definitions_to_custom_os_and_arch)
     target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE TARGET_64BIT)
     target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE TARGET_RISCV64)
     target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE FEATURE_MULTIREG_RETURN)
+  elseif(TARGETDETAILS_ARCH STREQUAL "wasm")
+    target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE TARGET_WASM32)
+    target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE TARGET_WASM)
   endif()
 
   if (TARGETDETAILS_ARCH STREQUAL "armel")

src/coreclr/components.cmake

@@ -1,5 +1,6 @@
 # Define all the individually buildable components of the CoreCLR build and their respective targets
 add_component(jit)
+add_component(wasmjit)
 add_component(alljits)
 add_component(hosts)
 add_component(runtime)

src/coreclr/inc/cordebuginfo.h

@@ -213,7 +213,7 @@ class ICorDebugInfo
         REGNUM_T5,
         REGNUM_T6,
         REGNUM_PC,
-#elif TARGET_WASM
+#elif defined(TARGET_WASM)
         REGNUM_PC, // wasm doesn't have registers
 #else
         PORTABILITY_WARNING("Register numbers not defined on this platform")

src/coreclr/jit/CMakeLists.txt

@@ -22,7 +22,7 @@ function(create_standalone_jit)
 
   if(TARGETDETAILS_OS STREQUAL "unix_osx" OR TARGETDETAILS_OS STREQUAL "unix_anyos")
     set(JIT_ARCH_LINK_LIBRARIES gcinfo_unix_${TARGETDETAILS_ARCH})
-  else()
+  elseif(NOT ${TARGETDETAILS_ARCH} MATCHES "wasm")
     set(JIT_ARCH_LINK_LIBRARIES gcinfo_${TARGETDETAILS_OS}_${TARGETDETAILS_ARCH})
   endif()
 
@@ -53,6 +53,9 @@ function(create_standalone_jit)
   elseif(TARGETDETAILS_ARCH STREQUAL "riscv64")
     set(JIT_ARCH_SOURCES ${JIT_RISCV64_SOURCES})
     set(JIT_ARCH_HEADERS ${JIT_RISCV64_HEADERS})
+  elseif(TARGETDETAILS_ARCH STREQUAL "wasm")
+    set(JIT_ARCH_SOURCES ${JIT_WASM_SOURCES})
+    set(JIT_ARCH_HEADERS ${JIT_WASM_HEADERS})
   else()
     clr_unknown_arch()
   endif()
@@ -94,7 +97,6 @@ set( JIT_SOURCES
   block.cpp
   buildstring.cpp
   codegencommon.cpp
-  codegenlinear.cpp
   compiler.cpp
   copyprop.cpp
   debuginfo.cpp
@@ -115,8 +117,6 @@ set( JIT_SOURCES
   fgstmt.cpp
   flowgraph.cpp
   forwardsub.cpp
-  gcdecode.cpp
-  gcencode.cpp
   gcinfo.cpp
   gentree.cpp
   gschecks.cpp
@@ -145,8 +145,6 @@ set( JIT_SOURCES
   liveness.cpp
   loopcloning.cpp
   lower.cpp
-  lsra.cpp
-  lsrabuild.cpp
   morph.cpp
   morphblock.cpp
   objectalloc.cpp
@@ -163,8 +161,6 @@ set( JIT_SOURCES
   rangecheckcloning.cpp
   rationalize.cpp
   redundantbranchopts.cpp
-  regalloc.cpp
-  regMaskTPOps.cpp
   regset.cpp
   scev.cpp
   scopeinfo.cpp
@@ -178,11 +174,21 @@ set( JIT_SOURCES
   stacklevelsetter.cpp
   switchrecognition.cpp
   treelifeupdater.cpp
-  unwind.cpp
   utils.cpp
   valuenum.cpp
 )
 
+set ( JIT_PHYSICAL_TARGET_SOURCES
+  lsra.cpp
+  lsrabuild.cpp
+  regalloc.cpp
+  regMaskTPOps.cpp
+  codegenlinear.cpp
+  gcdecode.cpp
+  gcencode.cpp
+  unwind.cpp
+)
+
 if (CLR_CMAKE_TARGET_WIN32)
   # Append clrjit.natvis file
   list (APPEND JIT_SOURCES
@@ -192,6 +198,7 @@ endif(CLR_CMAKE_TARGET_WIN32)
 # Define all the architecture-specific source files
 
 set( JIT_AMD64_SOURCES
+  ${JIT_PHYSICAL_TARGET_SOURCES}
   codegenxarch.cpp
   emitxarch.cpp
   lowerxarch.cpp
@@ -205,6 +212,7 @@ set( JIT_AMD64_SOURCES
 )
 
 set( JIT_ARM_SOURCES
+  ${JIT_PHYSICAL_TARGET_SOURCES}
   codegenarmarch.cpp
   codegenarm.cpp
   decomposelongs.cpp
@@ -217,6 +225,7 @@ set( JIT_ARM_SOURCES
 )
 
 set( JIT_I386_SOURCES
+  ${JIT_PHYSICAL_TARGET_SOURCES}
   codegenxarch.cpp
   decomposelongs.cpp
   emitxarch.cpp
@@ -231,6 +240,7 @@ set( JIT_I386_SOURCES
 )
 
 set( JIT_ARM64_SOURCES
+  ${JIT_PHYSICAL_TARGET_SOURCES}
   codegenarmarch.cpp
   codegenarm64.cpp
   codegenarm64test.cpp
@@ -260,6 +270,7 @@ set( JIT_POWERPC64_SOURCES
 )
 
 set( JIT_LOONGARCH64_SOURCES
+  ${JIT_PHYSICAL_TARGET_SOURCES}
   codegenloongarch64.cpp
   emitloongarch64.cpp
   lowerloongarch64.cpp
@@ -269,6 +280,7 @@ set( JIT_LOONGARCH64_SOURCES
 )
 
 set( JIT_RISCV64_SOURCES
+  ${JIT_PHYSICAL_TARGET_SOURCES}
   codegenriscv64.cpp
   emitriscv64.cpp
   lowerriscv64.cpp
@@ -277,6 +289,14 @@ set( JIT_RISCV64_SOURCES
   unwindriscv64.cpp
 )
 
+set( JIT_WASM_SOURCES
+  codegenwasm.cpp
+  emitwasm.cpp
+  lowerwasm.cpp
+  regallocwasm.cpp
+  targetwasm.cpp
+)
+
 # We include the headers here for better experience in IDEs.
 set( JIT_HEADERS
   ../inc/corinfo.h
@@ -448,6 +468,15 @@ set( JIT_RISCV64_HEADERS
     registerriscv64.h
 )
 
+set( JIT_WASM_HEADERS
+    regallocwasm.h
+    targetwasm.h
+    emitwasm.h
+    emitfmtswasm.h
+    instrswasm.h
+    registerwasm.h
+)
+
 convert_to_absolute_path(JIT_SOURCES ${JIT_SOURCES})
 convert_to_absolute_path(JIT_HEADERS ${JIT_HEADERS})
 convert_to_absolute_path(JIT_RESOURCES ${JIT_RESOURCES})
@@ -470,6 +499,8 @@ convert_to_absolute_path(JIT_LOONGARCH64_SOURCES ${JIT_LOONGARCH64_SOURCES})
 convert_to_absolute_path(JIT_LOONGARCH64_HEADERS ${JIT_LOONGARCH64_HEADERS})
 convert_to_absolute_path(JIT_RISCV64_SOURCES ${JIT_RISCV64_SOURCES})
 convert_to_absolute_path(JIT_RISCV64_HEADERS ${JIT_RISCV64_HEADERS})
+convert_to_absolute_path(JIT_WASM_SOURCES ${JIT_WASM_SOURCES})
+convert_to_absolute_path(JIT_WASM_HEADERS ${JIT_WASM_HEADERS})
 
 if(CLR_CMAKE_TARGET_ARCH_AMD64)
   set(JIT_ARCH_SOURCES ${JIT_AMD64_SOURCES})
@@ -499,13 +530,12 @@ elseif(CLR_CMAKE_TARGET_ARCH_RISCV64)
   set(JIT_ARCH_SOURCES ${JIT_RISCV64_SOURCES})
   set(JIT_ARCH_HEADERS ${JIT_RISCV64_HEADERS})
 elseif(CLR_CMAKE_TARGET_ARCH_WASM)
-  set(JIT_ARCH_SOURCES ${JIT_WASM32_SOURCES})
-  set(JIT_ARCH_HEADERS ${JIT_WASM32_HEADERS})
+  set(JIT_ARCH_SOURCES ${JIT_WASM_SOURCES})
+  set(JIT_ARCH_HEADERS ${JIT_WASM_HEADERS})
 else()
   clr_unknown_arch()
 endif()
 
-
 set(JIT_DLL_MAIN_FILE ${CMAKE_CURRENT_LIST_DIR}/dllmain.cpp)
 
 if(CLR_CMAKE_HOST_WIN32)
@@ -623,7 +653,12 @@ function(add_jit jitName)
     target_compile_definitions(${jitName} PRIVATE JIT_STANDALONE_BUILD)
 
     # add the install targets
-    install_clr(TARGETS ${jitName} DESTINATIONS . COMPONENT alljits)
+    if (${jitName} MATCHES "clrjit_universal_wasm")
+        # TODO-WASM: add the WASM Jit to alljits once that becomes necessary.
+        install_clr(TARGETS ${jitName} DESTINATIONS . COMPONENT wasmjit)
+    else()
+        install_clr(TARGETS ${jitName} DESTINATIONS . COMPONENT alljits)
+    endif()
 endfunction()
 
 set(JIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
@@ -653,6 +688,7 @@ add_pgo(clrjit)
 
 if (CLR_CMAKE_TARGET_ARCH_ARM64 OR CLR_CMAKE_TARGET_ARCH_AMD64)
   create_standalone_jit(TARGET clrjit_universal_arm64_${ARCH_HOST_NAME} OS universal ARCH arm64)
+  create_standalone_jit(TARGET clrjit_universal_wasm_${ARCH_HOST_NAME} OS universal ARCH wasm)
   create_standalone_jit(TARGET clrjit_unix_x64_${ARCH_HOST_NAME} OS unix_anyos ARCH x64)
   create_standalone_jit(TARGET clrjit_win_x64_${ARCH_HOST_NAME} OS win ARCH x64)
   if (CLR_CMAKE_BUILD_COMMUNITY_ALTJITS EQUAL 1)
@@ -678,7 +714,7 @@ if (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
 endif (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
 
 if (CLR_CMAKE_TARGET_UNIX)
-    if (NOT ARCH_TARGET_NAME STREQUAL s390x AND NOT ARCH_TARGET_NAME STREQUAL armv6 AND NOT ARCH_TARGET_NAME STREQUAL ppc64le AND NOT ARCH_TARGET_NAME STREQUAL riscv64)
+    if (NOT ARCH_TARGET_NAME STREQUAL s390x AND NOT ARCH_TARGET_NAME STREQUAL armv6 AND NOT ARCH_TARGET_NAME STREQUAL ppc64le AND NOT ARCH_TARGET_NAME STREQUAL riscv64 AND NOT ARCH_TARGET_NAME STREQUAL wasm)
       if(CLR_CMAKE_TARGET_ARCH_ARM OR CLR_CMAKE_TARGET_ARCH_ARM64)
         install_clr(TARGETS clrjit_universal_${ARCH_TARGET_NAME}_${ARCH_HOST_NAME} DESTINATIONS . COMPONENT jit)
       else()

src/coreclr/jit/abi.cpp

@@ -41,6 +41,7 @@ regNumber ABIPassingSegment::GetRegister() const
     return static_cast<regNumber>(m_register);
 }
 
+#if HAS_FIXED_REGISTER_SET
 //-----------------------------------------------------------------------------
 // GetRegisterMask:
 //   Get the mask of registers that this segment is passed in.
@@ -62,6 +63,7 @@ regMaskTP ABIPassingSegment::GetRegisterMask() const
 
     return mask;
 }
+#endif // HAS_FIXED_REGISTER_SET
 
 //-----------------------------------------------------------------------------
 // GetStackOffset:
@@ -739,3 +741,103 @@ ABIPassingInformation SwiftABIClassifier::Classify(Compiler*    comp,
     return m_classifier.Classify(comp, type, structLayout, wellKnownParam);
 }
 #endif
+
+//-----------------------------------------------------------------------------------
+// IsMultiRegReturnedType: Returns true if the type is returned in multiple registers
+//
+// Arguments:
+//     hClass   -  type handle
+//
+// Return Value:
+//     true if type is returned in multiple registers, false otherwise.
+//
+bool Compiler::IsMultiRegReturnedType(CORINFO_CLASS_HANDLE hClass, CorInfoCallConvExtension callConv)
+{
+    if (hClass == NO_CLASS_HANDLE)
+    {
+        return false;
+    }
+
+    structPassingKind howToReturnStruct;
+    var_types         returnType = getReturnTypeForStruct(hClass, callConv, &howToReturnStruct);
+
+#if defined(TARGET_ARM64) || defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
+    return (varTypeIsStruct(returnType) && (howToReturnStruct != SPK_PrimitiveType));
+#else
+    return (varTypeIsStruct(returnType));
+#endif
+}
+
+//------------------------------------------------------------------------
+// IsHfa: Is this an HFA type?
+//
+// HFAs are an ARM/ARM64 ABI concept, where structs like { float, float }
+// (up to 4 same-type (including vector) FP fiels) can be passed in multiple
+// registers.
+//
+// Arguments:
+//    hClass - The type in question
+//
+// Return Value:
+//    Whether "hClass" represents an HFA.
+//
+bool Compiler::IsHfa(CORINFO_CLASS_HANDLE hClass)
+{
+    return varTypeIsValidHfaType(GetHfaType(hClass));
+}
+
+//------------------------------------------------------------------------
+// GetHfaType: Get the field type for an HFA struct.
+//
+// Arguments:
+//    hClass - The type in question
+//
+// Return Value:
+//    If "hClass" represents an HFA, return the field type, otherwise TYP_UNDEF.
+//
+var_types Compiler::GetHfaType(CORINFO_CLASS_HANDLE hClass)
+{
+    if (GlobalJitOptions::compFeatureHfa)
+    {
+        if (hClass != NO_CLASS_HANDLE)
+        {
+            CorInfoHFAElemType elemKind = info.compCompHnd->getHFAType(hClass);
+            if (elemKind != CORINFO_HFA_ELEM_NONE)
+            {
+                // This type may not appear elsewhere, but it will occupy a floating point register.
+                compFloatingPointUsed = true;
+            }
+            return HfaTypeFromElemKind(elemKind);
+        }
+    }
+    return TYP_UNDEF;
+}
+
+//------------------------------------------------------------------------
+// GetHfaCount: Given a  class handle for an HFA struct
+//    return the number of registers needed to hold the HFA
+//
+//    Note that on ARM32 the single precision registers overlap with
+//        the double precision registers and for that reason each
+//        double register is considered to be two single registers.
+//        Thus for ARM32 an HFA of 4 doubles this function will return 8.
+//    On ARM64 given an HFA of 4 singles or 4 doubles this function will
+//         will return 4 for both.
+// Arguments:
+//    hClass: the class handle of a HFA struct
+//
+unsigned Compiler::GetHfaCount(CORINFO_CLASS_HANDLE hClass)
+{
+    assert(IsHfa(hClass));
+#ifdef TARGET_ARM
+    // A HFA of doubles is twice as large as an HFA of singles for ARM32
+    // (i.e. uses twice the number of single precision registers)
+    return info.compCompHnd->getClassSize(hClass) / REGSIZE_BYTES;
+#else  // TARGET_ARM64
+    var_types hfaType = GetHfaType(hClass);
+    unsigned  classSize = info.compCompHnd->getClassSize(hClass);
+    // Note that the retail build issues a warning about a potential division by zero without the Max function
+    unsigned elemSize = Max((unsigned)1, EA_SIZE_IN_BYTES(emitActualTypeSize(hfaType)));
+    return classSize / elemSize;
+#endif // TARGET_ARM64
+}