[Arm64] getBaseTypeAndSizeOfSIMDType

sdmaclea · sdmaclea · commit d70e11bb0c5a · 2018-01-03T12:45:49.000-05:00
Remove XARCH platform dependencies
Disable Vector256 support on Arm64 until needed
diff --git a/src/jit/compiler.cpp b/src/jit/compiler.cpp
@@ -2126,6 +2126,7 @@ void Compiler::compInit(ArenaAllocator* pAlloc, InlineInfo* inlineInfo)
     Vector128ByteHandle   = nullptr;
     Vector128LongHandle   = nullptr;
     Vector128UIntHandle   = nullptr;
+#if defined(_TARGET_XARCH_)
     Vector256FloatHandle  = nullptr;
     Vector256DoubleHandle = nullptr;
     Vector256IntHandle    = nullptr;
@@ -2135,6 +2136,7 @@ void Compiler::compInit(ArenaAllocator* pAlloc, InlineInfo* inlineInfo)
     Vector256ByteHandle   = nullptr;
     Vector256LongHandle   = nullptr;
     Vector256UIntHandle   = nullptr;
+#endif // defined(_TARGET_XARCH_)
 #endif // FEATURE_HW_INTRINSICS
 #endif // FEATURE_SIMD
 
diff --git a/src/jit/compiler.h b/src/jit/compiler.h
@@ -7411,6 +7411,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     CORINFO_CLASS_HANDLE Vector128LongHandle;
     CORINFO_CLASS_HANDLE Vector128UIntHandle;
     CORINFO_CLASS_HANDLE Vector128ULongHandle;
+#if defined(_TARGET_XARCH_)
     CORINFO_CLASS_HANDLE Vector256FloatHandle;
     CORINFO_CLASS_HANDLE Vector256DoubleHandle;
     CORINFO_CLASS_HANDLE Vector256IntHandle;
@@ -7421,7 +7422,8 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     CORINFO_CLASS_HANDLE Vector256LongHandle;
     CORINFO_CLASS_HANDLE Vector256UIntHandle;
     CORINFO_CLASS_HANDLE Vector256ULongHandle;
-#endif
+#endif // defined(_TARGET_XARCH_)
+#endif // FEATURE_HW_INTRINSICS
 
     // Get the handle for a SIMD type.
     CORINFO_CLASS_HANDLE gtGetStructHandleForSIMD(var_types simdType, var_types simdBaseType)
diff --git a/src/jit/simd.cpp b/src/jit/simd.cpp
@@ -351,124 +351,133 @@ var_types Compiler::getBaseTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, u
 #if FEATURE_HW_INTRINSICS
     else if (isIntrinsicType(typeHnd))
     {
+        const size_t Vector128SizeBytes = 128 / 8;
+        const size_t Vector256SizeBytes = 256 / 8;
+
+#if defined(_TARGET_XARCH_)
+        static_assert_no_msg(YMM_REGSIZE_BYTES == Vector256SizeBytes);
+        static_assert_no_msg(XMM_REGSIZE_BYTES == Vector128SizeBytes);
+
         if (typeHnd == Vector256FloatHandle)
         {
             simdBaseType = TYP_FLOAT;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<float>\n");
         }
         else if (typeHnd == Vector256DoubleHandle)
         {
             simdBaseType = TYP_DOUBLE;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<double>\n");
         }
         else if (typeHnd == Vector256IntHandle)
         {
             simdBaseType = TYP_INT;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<int>\n");
         }
         else if (typeHnd == Vector256UIntHandle)
         {
             simdBaseType = TYP_UINT;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<uint>\n");
         }
         else if (typeHnd == Vector256ShortHandle)
         {
             simdBaseType = TYP_SHORT;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<short>\n");
         }
         else if (typeHnd == Vector256UShortHandle)
         {
             simdBaseType = TYP_USHORT;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<ushort>\n");
         }
         else if (typeHnd == Vector256ByteHandle)
         {
             simdBaseType = TYP_BYTE;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<sbyte>\n");
         }
         else if (typeHnd == Vector256UByteHandle)
         {
             simdBaseType = TYP_UBYTE;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<byte>\n");
         }
         else if (typeHnd == Vector256LongHandle)
         {
             simdBaseType = TYP_LONG;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<long>\n");
         }
         else if (typeHnd == Vector256ULongHandle)
         {
             simdBaseType = TYP_ULONG;
-            size         = YMM_REGSIZE_BYTES;
+            size         = Vector256SizeBytes;
             JITDUMP("  Known type Vector256<ulong>\n");
         }
         else if (typeHnd == Vector256FloatHandle)
         {
             simdBaseType = TYP_FLOAT;
-            size         = YMM_REGSIZE_BYTES;
-            JITDUMP("  Known type Vector128<float>\n");
+            size         = Vector256SizeBytes;
+            JITDUMP("  Known type Vector256<float>\n");
         }
-        else if (typeHnd == Vector128DoubleHandle)
+        else
+#endif // defined(_TARGET_XARCH)
+            if (typeHnd == Vector128DoubleHandle)
         {
             simdBaseType = TYP_DOUBLE;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<double>\n");
         }
         else if (typeHnd == Vector128IntHandle)
         {
             simdBaseType = TYP_INT;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<int>\n");
         }
         else if (typeHnd == Vector128UIntHandle)
         {
             simdBaseType = TYP_UINT;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<uint>\n");
         }
         else if (typeHnd == Vector128ShortHandle)
         {
             simdBaseType = TYP_SHORT;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<short>\n");
         }
         else if (typeHnd == Vector128UShortHandle)
         {
             simdBaseType = TYP_USHORT;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<ushort>\n");
         }
         else if (typeHnd == Vector128ByteHandle)
         {
             simdBaseType = TYP_BYTE;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<sbyte>\n");
         }
         else if (typeHnd == Vector128UByteHandle)
         {
             simdBaseType = TYP_UBYTE;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<byte>\n");
         }
         else if (typeHnd == Vector128LongHandle)
         {
             simdBaseType = TYP_LONG;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<long>\n");
         }
         else if (typeHnd == Vector128ULongHandle)
         {
             simdBaseType = TYP_ULONG;
-            size         = XMM_REGSIZE_BYTES;
+            size         = Vector128SizeBytes;
             JITDUMP("  Known type Vector128<ulong>\n");
         }
 
@@ -486,9 +495,10 @@ var_types Compiler::getBaseTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, u
                 JITDUMP("HW Intrinsic SIMD Candidate Type %s with Base Type %s\n", className,
                         getClassNameFromMetadata(baseTypeHnd, nullptr));
 
+#if defined(_TARGET_XARCH_)
                 if (strcmp(className, "Vector256`1") == 0)
                 {
-                    size = YMM_REGSIZE_BYTES;
+                    size = Vector256SizeBytes;
                     switch (type)
                     {
                         case CORINFO_TYPE_FLOAT:
@@ -546,9 +556,11 @@ var_types Compiler::getBaseTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, u
                             JITDUMP("  Unknown Hardware Intrinsic SIMD Type Vector256<T>\n");
                     }
                 }
-                else if (strcmp(className, "Vector128`1") == 0)
+                else
+#endif // defined(_TARGET_XARCH_)
+                    if (strcmp(className, "Vector128`1") == 0)
                 {
-                    size = XMM_REGSIZE_BYTES;
+                    size = Vector128SizeBytes;
                     switch (type)
                     {
                         case CORINFO_TYPE_FLOAT:

Original file line number	Diff line number	Diff line change
`@@ -351,124 +351,133 @@ var_types Compiler::getBaseTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, u`
`351`	`351`	`#if FEATURE_HW_INTRINSICS`
`352`	`352`	`else if (isIntrinsicType(typeHnd))`
`353`	`353`	`{`
	`354`	`+ const size_t Vector128SizeBytes = 128 / 8;`
	`355`	`+ const size_t Vector256SizeBytes = 256 / 8;`
	`356`	`+`
	`357`	`+#if defined(_TARGET_XARCH_)`
	`358`	`+ static_assert_no_msg(YMM_REGSIZE_BYTES == Vector256SizeBytes);`
	`359`	`+ static_assert_no_msg(XMM_REGSIZE_BYTES == Vector128SizeBytes);`
	`360`	`+`
`354`	`361`	`if (typeHnd == Vector256FloatHandle)`
`355`	`362`	`{`
`356`	`363`	`simdBaseType = TYP_FLOAT;`
`357`		`- size = YMM_REGSIZE_BYTES;`
	`364`	`+ size = Vector256SizeBytes;`
`358`	`365`	`JITDUMP(" Known type Vector256<float>\n");`
`359`	`366`	`}`
`360`	`367`	`else if (typeHnd == Vector256DoubleHandle)`
`361`	`368`	`{`
`362`	`369`	`simdBaseType = TYP_DOUBLE;`
`363`		`- size = YMM_REGSIZE_BYTES;`
	`370`	`+ size = Vector256SizeBytes;`
`364`	`371`	`JITDUMP(" Known type Vector256<double>\n");`
`365`	`372`	`}`
`366`	`373`	`else if (typeHnd == Vector256IntHandle)`
`367`	`374`	`{`
`368`	`375`	`simdBaseType = TYP_INT;`
`369`		`- size = YMM_REGSIZE_BYTES;`
	`376`	`+ size = Vector256SizeBytes;`
`370`	`377`	`JITDUMP(" Known type Vector256<int>\n");`
`371`	`378`	`}`
`372`	`379`	`else if (typeHnd == Vector256UIntHandle)`
`373`	`380`	`{`
`374`	`381`	`simdBaseType = TYP_UINT;`
`375`		`- size = YMM_REGSIZE_BYTES;`
	`382`	`+ size = Vector256SizeBytes;`
`376`	`383`	`JITDUMP(" Known type Vector256<uint>\n");`
`377`	`384`	`}`
`378`	`385`	`else if (typeHnd == Vector256ShortHandle)`
`379`	`386`	`{`
`380`	`387`	`simdBaseType = TYP_SHORT;`
`381`		`- size = YMM_REGSIZE_BYTES;`
	`388`	`+ size = Vector256SizeBytes;`
`382`	`389`	`JITDUMP(" Known type Vector256<short>\n");`
`383`	`390`	`}`
`384`	`391`	`else if (typeHnd == Vector256UShortHandle)`
`385`	`392`	`{`
`386`	`393`	`simdBaseType = TYP_USHORT;`
`387`		`- size = YMM_REGSIZE_BYTES;`
	`394`	`+ size = Vector256SizeBytes;`
`388`	`395`	`JITDUMP(" Known type Vector256<ushort>\n");`
`389`	`396`	`}`
`390`	`397`	`else if (typeHnd == Vector256ByteHandle)`
`391`	`398`	`{`
`392`	`399`	`simdBaseType = TYP_BYTE;`
`393`		`- size = YMM_REGSIZE_BYTES;`
	`400`	`+ size = Vector256SizeBytes;`
`394`	`401`	`JITDUMP(" Known type Vector256<sbyte>\n");`
`395`	`402`	`}`
`396`	`403`	`else if (typeHnd == Vector256UByteHandle)`
`397`	`404`	`{`
`398`	`405`	`simdBaseType = TYP_UBYTE;`
`399`		`- size = YMM_REGSIZE_BYTES;`
	`406`	`+ size = Vector256SizeBytes;`
`400`	`407`	`JITDUMP(" Known type Vector256<byte>\n");`
`401`	`408`	`}`
`402`	`409`	`else if (typeHnd == Vector256LongHandle)`
`403`	`410`	`{`
`404`	`411`	`simdBaseType = TYP_LONG;`
`405`		`- size = YMM_REGSIZE_BYTES;`
	`412`	`+ size = Vector256SizeBytes;`
`406`	`413`	`JITDUMP(" Known type Vector256<long>\n");`
`407`	`414`	`}`
`408`	`415`	`else if (typeHnd == Vector256ULongHandle)`
`409`	`416`	`{`
`410`	`417`	`simdBaseType = TYP_ULONG;`
`411`		`- size = YMM_REGSIZE_BYTES;`
	`418`	`+ size = Vector256SizeBytes;`
`412`	`419`	`JITDUMP(" Known type Vector256<ulong>\n");`
`413`	`420`	`}`
`414`	`421`	`else if (typeHnd == Vector256FloatHandle)`
`415`	`422`	`{`
`416`	`423`	`simdBaseType = TYP_FLOAT;`
`417`		`- size = YMM_REGSIZE_BYTES;`
`418`		`- JITDUMP(" Known type Vector128<float>\n");`
	`424`	`+ size = Vector256SizeBytes;`
	`425`	`+ JITDUMP(" Known type Vector256<float>\n");`
`419`	`426`	`}`
`420`		`- else if (typeHnd == Vector128DoubleHandle)`
	`427`	`+ else`
	`428`	`+#endif // defined(_TARGET_XARCH)`
	`429`	`+ if (typeHnd == Vector128DoubleHandle)`
`421`	`430`	`{`
`422`	`431`	`simdBaseType = TYP_DOUBLE;`
`423`		`- size = XMM_REGSIZE_BYTES;`
	`432`	`+ size = Vector128SizeBytes;`
`424`	`433`	`JITDUMP(" Known type Vector128<double>\n");`
`425`	`434`	`}`
`426`	`435`	`else if (typeHnd == Vector128IntHandle)`
`427`	`436`	`{`
`428`	`437`	`simdBaseType = TYP_INT;`
`429`		`- size = XMM_REGSIZE_BYTES;`
	`438`	`+ size = Vector128SizeBytes;`
`430`	`439`	`JITDUMP(" Known type Vector128<int>\n");`
`431`	`440`	`}`
`432`	`441`	`else if (typeHnd == Vector128UIntHandle)`
`433`	`442`	`{`
`434`	`443`	`simdBaseType = TYP_UINT;`
`435`		`- size = XMM_REGSIZE_BYTES;`
	`444`	`+ size = Vector128SizeBytes;`
`436`	`445`	`JITDUMP(" Known type Vector128<uint>\n");`
`437`	`446`	`}`
`438`	`447`	`else if (typeHnd == Vector128ShortHandle)`
`439`	`448`	`{`
`440`	`449`	`simdBaseType = TYP_SHORT;`
`441`		`- size = XMM_REGSIZE_BYTES;`
	`450`	`+ size = Vector128SizeBytes;`
`442`	`451`	`JITDUMP(" Known type Vector128<short>\n");`
`443`	`452`	`}`
`444`	`453`	`else if (typeHnd == Vector128UShortHandle)`
`445`	`454`	`{`
`446`	`455`	`simdBaseType = TYP_USHORT;`
`447`		`- size = XMM_REGSIZE_BYTES;`
	`456`	`+ size = Vector128SizeBytes;`
`448`	`457`	`JITDUMP(" Known type Vector128<ushort>\n");`
`449`	`458`	`}`
`450`	`459`	`else if (typeHnd == Vector128ByteHandle)`
`451`	`460`	`{`
`452`	`461`	`simdBaseType = TYP_BYTE;`
`453`		`- size = XMM_REGSIZE_BYTES;`
	`462`	`+ size = Vector128SizeBytes;`
`454`	`463`	`JITDUMP(" Known type Vector128<sbyte>\n");`
`455`	`464`	`}`
`456`	`465`	`else if (typeHnd == Vector128UByteHandle)`
`457`	`466`	`{`
`458`	`467`	`simdBaseType = TYP_UBYTE;`
`459`		`- size = XMM_REGSIZE_BYTES;`
	`468`	`+ size = Vector128SizeBytes;`
`460`	`469`	`JITDUMP(" Known type Vector128<byte>\n");`
`461`	`470`	`}`
`462`	`471`	`else if (typeHnd == Vector128LongHandle)`
`463`	`472`	`{`
`464`	`473`	`simdBaseType = TYP_LONG;`
`465`		`- size = XMM_REGSIZE_BYTES;`
	`474`	`+ size = Vector128SizeBytes;`
`466`	`475`	`JITDUMP(" Known type Vector128<long>\n");`
`467`	`476`	`}`
`468`	`477`	`else if (typeHnd == Vector128ULongHandle)`
`469`	`478`	`{`
`470`	`479`	`simdBaseType = TYP_ULONG;`
`471`		`- size = XMM_REGSIZE_BYTES;`
	`480`	`+ size = Vector128SizeBytes;`
`472`	`481`	`JITDUMP(" Known type Vector128<ulong>\n");`
`473`	`482`	`}`
`474`	`483`
`@@ -486,9 +495,10 @@ var_types Compiler::getBaseTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, u`
`486`	`495`	`JITDUMP("HW Intrinsic SIMD Candidate Type %s with Base Type %s\n", className,`
`487`	`496`	`getClassNameFromMetadata(baseTypeHnd, nullptr));`
`488`	`497`
	`498`	`+#if defined(_TARGET_XARCH_)`
`489`	`499`	if (strcmp(className, "Vector256`1") == 0)
`490`	`500`	`{`
`491`		`- size = YMM_REGSIZE_BYTES;`
	`501`	`+ size = Vector256SizeBytes;`
`492`	`502`	`switch (type)`
`493`	`503`	`{`
`494`	`504`	`case CORINFO_TYPE_FLOAT:`
`@@ -546,9 +556,11 @@ var_types Compiler::getBaseTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, u`
`546`	`556`	`JITDUMP(" Unknown Hardware Intrinsic SIMD Type Vector256<T>\n");`
`547`	`557`	`}`
`548`	`558`	`}`
`549`		- else if (strcmp(className, "Vector128`1") == 0)
	`559`	`+ else`
	`560`	`+#endif // defined(_TARGET_XARCH_)`
	`561`	+ if (strcmp(className, "Vector128`1") == 0)
`550`	`562`	`{`
`551`		`- size = XMM_REGSIZE_BYTES;`
	`563`	`+ size = Vector128SizeBytes;`
`552`	`564`	`switch (type)`
`553`	`565`	`{`
`554`	`566`	`case CORINFO_TYPE_FLOAT:`