Make the length of VectorT accessible to the DAC

The length of VectorT is now a constant that is set on VM initialization,
and the DAC needs to be able to replicate this state without access to the
original SVE VL value.

Author: snickolls-arm

src/coreclr/inc/dacvars.h

@@ -134,6 +134,8 @@ DEFINE_DACVAR(PTR_JITNotification, dac__g_pNotificationTable, ::g_pNotificationT
 DEFINE_DACVAR(ULONG32, dac__g_dacNotificationFlags, ::g_dacNotificationFlags)
 
 DEFINE_DACVAR(DWORD, dac__g_gcNotificationFlags, g_gcNotificationFlags)
+DEFINE_DACVAR(DWORD, dac__g_vectorTByteLength, ::g_vectorTByteLength)
+DEFINE_DACVAR(BOOL,  dac__g_vectorTIsScalable, ::g_vectorTIsScalable)
 
 DEFINE_DACVAR(PTR_EEConfig, dac__g_pConfig, ::g_pConfig)
 

src/coreclr/vm/codeman.cpp

@@ -1139,6 +1139,8 @@ EECodeGenManager::EECodeGenManager()
 EEJitManager::EEJitManager()
     : m_CPUCompileFlags()
     , m_JitLoadLock( CrstSingleUseLock )
+    , m_vectorTByteLength(0)
+    , m_useScalableVectorT(false)
 {
     CONTRACTL {
         THROWS;
@@ -1546,35 +1548,49 @@ void EEJitManager::SetCpuInfo()
 #endif // TARGET_X86 || TARGET_AMD64
 
     m_CPUCompileFlags = CPUCompileFlags;
-}
 
-uint32_t EEJitManager::GetSizeOfVectorT()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    uint32_t size = 0;
+    m_useScalableVectorT = false;
+    m_vectorTByteLength = 0;
 
 #if defined(TARGET_X86) || defined(TARGET_AMD64)
     if (m_CPUCompileFlags.IsSet(InstructionSet_VectorT512))
     {
-        length = 64;
+        m_vectorTByteLength = 64;
     }
-    else if (CPUCompileFlags.IsSet(InstructionSet_VectorT256))
+    else if (m_CPUCompileFlags.IsSet(InstructionSet_VectorT256))
     {
-        length = 32;
+        m_vectorTByteLength = 32;
+    }
+    else if (m_CPUCompileFlags.IsSet(InstructionSet_VectorT128))
+    {
+        m_vectorTByteLength = 16;
     }
 #elif defined(TARGET_ARM64)
-    if (UseScalableVectorT())
+    if (m_CPUCompileFlags.IsSet(InstructionSet_VectorT128))
     {
-        size = (uint32_t) GetSveLengthFromOS();
+        m_vectorTByteLength = 16;
     }
-    else if (m_CPUCompileFlags.IsSet(InstructionSet_VectorT128))
+
+    if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_JitUseScalableVectorT)
+        && m_CPUCompileFlags.IsSet(InstructionSet_Sve_Arm64))
     {
-        size = 16;
+        uint64_t sveLengthFromOS = GetSveLengthFromOS();
+        if (sveLengthFromOS != 0)
+        {
+            m_useScalableVectorT = true;
+            m_vectorTByteLength = static_cast<uint32_t>(sveLengthFromOS);
+        }
     }
 #endif
 
-    return size;
+    g_vectorTByteLength = m_vectorTByteLength;
+    g_vectorTIsScalable = m_useScalableVectorT ? 1 : 0;
+}
+
+uint32_t EEJitManager::GetSizeOfVectorT() const
+{
+    LIMITED_METHOD_DAC_CONTRACT;
+    return m_vectorTByteLength;
 }
 
 // Define some data that we can use to get a better idea of what happened when we get a Watson dump that indicates the JIT failed to load.

src/coreclr/vm/codeman.h

@@ -2188,19 +2188,13 @@ class EEJitManager final : public EECodeGenManager
         return m_CPUCompileFlags;
     }
 
-    inline bool UseScalableVectorT()
+    inline bool UseScalableVectorT() const
     {
-        LIMITED_METHOD_CONTRACT;
-#ifdef TARGET_ARM64
-        // Vector length discovery is currently dependent on running directly on Arm64.
-        return CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_JitUseScalableVectorT)
-            && m_CPUCompileFlags.IsSet(InstructionSet_Sve_Arm64);
-#else
-        return false;
-#endif
+        LIMITED_METHOD_DAC_CONTRACT;
+        return m_useScalableVectorT;
     }
 
-    uint32_t GetSizeOfVectorT();
+    uint32_t GetSizeOfVectorT() const;
 
 private :
     Crst                m_JitLoadLock;
@@ -2239,6 +2233,9 @@ private :
     bool                m_AltJITRequired;
 #endif //ALLOW_SXS_JIT
 
+    uint32_t            m_vectorTByteLength;
+    bool                m_useScalableVectorT;
+
     friend struct ::cdac_data<EEJitManager>;
 };
 

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -1028,6 +1028,8 @@ CDAC_GLOBAL(PtrArrayOffsetToDataArray, uintptr_t, offsetof(PtrArray, m_Array))
 CDAC_GLOBAL(NumberOfTlsOffsetsNotUsedInNoncollectibleArray, uint8, NUMBER_OF_TLSOFFSETS_NOT_USED_IN_NONCOLLECTIBLE_ARRAY)
 CDAC_GLOBAL(MaxClrNotificationArgs, uint32, MAX_CLR_NOTIFICATION_ARGS)
 CDAC_GLOBAL(FieldOffsetBigRVA, uint32, FIELD_OFFSET_BIG_RVA)
+CDAC_GLOBAL_POINTER(VectorTByteLength, &::g_vectorTByteLength)
+CDAC_GLOBAL_POINTER(VectorTIsScalable, &::g_vectorTIsScalable)
 CDAC_GLOBAL_POINTER(ClrNotificationArguments, &::g_clrNotificationArguments)
 CDAC_GLOBAL_POINTER(ArrayBoundsZero, cdac_data<ArrayBase>::ArrayBoundsZero)
 CDAC_GLOBAL_POINTER(ExceptionMethodTable, &::g_pExceptionClass)

src/coreclr/vm/vars.cpp

@@ -101,6 +101,8 @@ GVAL_IMPL_INIT(DWORD, g_debuggerWordTLSIndex, TLS_OUT_OF_INDEXES);
 GVAL_IMPL_INIT(DWORD, g_TlsIndex, TLS_OUT_OF_INDEXES);
 GVAL_IMPL_INIT(DWORD, g_offsetOfCurrentThreadInfo, 0);
 GVAL_IMPL_INIT(DWORD, g_gcNotificationFlags, 0);
+GVAL_IMPL_INIT(DWORD, g_vectorTByteLength, 0);
+GVAL_IMPL_INIT(BOOL,  g_vectorTIsScalable, 0);
 
 
 MethodTable* g_pCastHelpers;

src/coreclr/vm/vars.hpp

@@ -364,6 +364,8 @@ GVAL_DECL(DWORD,            g_debuggerWordTLSIndex);
 GVAL_DECL(DWORD,            g_TlsIndex);
 GVAL_DECL(DWORD,            g_offsetOfCurrentThreadInfo);
 GVAL_DECL(DWORD,            g_gcNotificationFlags);
+GVAL_DECL(DWORD,            g_vectorTByteLength);
+GVAL_DECL(BOOL,             g_vectorTIsScalable);
 
 #ifdef FEATURE_EH_FUNCLETS
 GPTR_DECL(MethodTable,      g_pEHClass);