change the structure of regMaskTP for performance

Author: kunalspathak

src/coreclr/jit/lsrabuild.cpp

@@ -2847,7 +2847,7 @@ void LinearScan::buildIntervals()
 #endif
     else
     {
-        actualRegistersMask = regMaskTP(~RBM_NONE, ~RBM_NONE);
+        actualRegistersMask = regMaskTP(~RBM_NONE, ~0);
     }
 
 #ifdef DEBUG

src/coreclr/jit/regMaskTPOps.cpp

@@ -5,6 +5,36 @@
 
 struct regMaskTP;
 
+
+//------------------------------------------------------------------------
+// encodeForRegisterIndex: Shifts the high-32 bits of float to low-32 bits
+//      and return. For gpr and predicate registers, it returns the same value.
+//
+// Parameters:
+//  index - Register type index
+//  value - value to encode
+//
+/* static */ RegSet32 regMaskTP::encodeForRegisterIndex(int index, regMaskSmall value)
+{
+    int shiftAmount = 32 * (index == 1);
+    return (RegSet32)(value >> shiftAmount);
+}
+
+//------------------------------------------------------------------------
+// decodeForRegisterIndex: Shifts the low-32 bits of float to high-32 bits
+//      and return. For gpr and predicate registers, it returns the same value.
+//
+// Parameters:
+//  index - Register type index
+//  value - value to encode
+//
+/* static */ regMaskSmall regMaskTP::decodeForRegisterIndex(int index, RegSet32 value)
+{
+    int shiftAmount = 32 * (index == 1);
+    return ((regMaskSmall)value << shiftAmount);
+}
+
+
 //------------------------------------------------------------------------
 // RemoveRegNumFromMask: Removes `reg` from the mask
 //
@@ -13,7 +43,13 @@ struct regMaskTP;
 //
 void regMaskTP::RemoveRegNumFromMask(regNumber reg)
 {
-    low &= ~genSingleTypeRegMask(reg);
+    SingleTypeRegSet value = genSingleTypeRegMask(reg);
+#ifdef HAS_MORE_THAN_64_REGISTERS
+    int index = getRegisterTypeIndex(reg);
+    _registers[index] &= ~encodeForRegisterIndex(index, value);
+#else
+    low &= ~value;
+#endif
 }
 
 //------------------------------------------------------------------------
@@ -24,10 +60,16 @@ void regMaskTP::RemoveRegNumFromMask(regNumber reg)
 //
 bool regMaskTP::IsRegNumInMask(regNumber reg)
 {
-    return (low & genRegMask(reg)) != 0;
+    SingleTypeRegSet value = genSingleTypeRegMask(reg);
+#ifdef HAS_MORE_THAN_64_REGISTERS
+    int index = getRegisterTypeIndex(reg);
+    return (_registers[index] & encodeForRegisterIndex(index, value)) != RBM_NONE;
+#else
+    return (low & value) != RBM_NONE;
+#endif
 }
 
-/* static */ const int regMaskTP::getRegisterTypeIndex(regNumber reg)
+/* static */ int regMaskTP::getRegisterTypeIndex(regNumber reg)
 {
     static const BYTE _registerTypeIndex[] = {
 #ifdef TARGET_ARM64

src/coreclr/jit/target.h

@@ -236,21 +236,46 @@ typedef uint64_t regMaskSmall;
 #define MORE_THAN_64_REGISTERS_ARG(x)
 #endif // TARGET_ARM64
 
+//TODO: Rename regMaskSmall as RegSet64 (at least for 64-bit)
 typedef regMaskSmall    SingleTypeRegSet;
+typedef unsigned RegSet32;
 inline SingleTypeRegSet genSingleTypeRegMask(regNumber reg);
 
 struct regMaskTP
 {
 private:
-    regMaskSmall low;
 #ifdef HAS_MORE_THAN_64_REGISTERS
-    regMaskSmall high;
+    union
+    {
+        RegSet32 _registers[3];
+        struct
+        {
+            union
+            {
+                // Represents combined registers bitset including gpr/float
+                regMaskSmall low;
+                struct
+                {
+                    RegSet32 gprRegs;
+                    RegSet32 floatRegs;
+                };
+            };
+            RegSet32 high;
+        };
+    };
+#else
+    // Represents combined registers bitset including gpr/float and on some platforms
+    // mask or predicate registers
+    regMaskSmall low;
 #endif
-    inline static const int getRegisterTypeIndex(regNumber reg);
+
+    FORCEINLINE static int getRegisterTypeIndex(regNumber reg);
+    FORCEINLINE static RegSet32 encodeForRegisterIndex(int index, regMaskSmall value);
+    FORCEINLINE static regMaskSmall decodeForRegisterIndex(int index, RegSet32 value);
 
 public:
 
-    regMaskTP(regMaskSmall lowMask, regMaskSmall highMask)
+    regMaskTP(regMaskSmall lowMask, RegSet32 highMask)
         : low(lowMask)
 #ifdef HAS_MORE_THAN_64_REGISTERS
         , high(highMask)
@@ -308,12 +333,15 @@ struct regMaskTP
     }
 
 #ifdef HAS_MORE_THAN_64_REGISTERS
-    regMaskSmall getHigh() const
+    RegSet32 getHigh() const
     {
         return high;
     }
 #endif
 
+    void RemoveRegNumFromMask(regNumber reg);
+    bool IsRegNumInMask(regNumber reg);
+
     bool IsEmpty() const
     {
         return low == RBM_NONE;
@@ -344,10 +372,6 @@ struct regMaskTP
         return getLow();
     }
 
-    void RemoveRegNumFromMask(regNumber reg);
-
-    bool IsRegNumInMask(regNumber reg);
-
     void operator|=(const regMaskTP& second)
     {
         low |= second.getLow();