Changes to IsValidForShuffle & jit format

- Ensure we use IsValidForShuffle correctly (i.e., ensure all cases that could be emittet at some point, are able to be done)
- jit format changes

Author: hamarb123

src/coreclr/jit/compiler.h

@@ -4796,7 +4796,7 @@ class Compiler
                                         bool                  mustExpand);
 
 #ifdef FEATURE_HW_INTRINSICS
-    bool IsValidForShuffle(GenTree* indices, unsigned simdSize, var_types simdBaseType) const;
+    bool IsValidForShuffle(GenTree* indices, unsigned simdSize, var_types simdBaseType, bool* canBecomeValid) const;
 
     GenTree* impHWIntrinsic(NamedIntrinsic        intrinsic,
                             CORINFO_CLASS_HANDLE  clsHnd,

src/coreclr/jit/gentree.cpp

@@ -18444,9 +18444,13 @@ unsigned GenTreeVecCon::ElementCount(unsigned simdSize, var_types simdBaseType)
     return simdSize / genTypeSize(simdBaseType);
 }
 
-bool Compiler::IsValidForShuffle(GenTree* indices, unsigned simdSize, var_types simdBaseType) const
+bool Compiler::IsValidForShuffle(GenTree* indices, unsigned simdSize, var_types simdBaseType, bool* canBecomeValid) const
 {
 #if defined(TARGET_XARCH)
+    if (canBecomeValid)
+    {
+        *canBecomeValid = false;
+    }
     size_t elementSize  = genTypeSize(simdBaseType);
     size_t elementCount = simdSize / elementSize;
 
@@ -18480,11 +18484,20 @@ bool Compiler::IsValidForShuffle(GenTree* indices, unsigned simdSize, var_types
         if (!indices->IsCnsVec() && !compOpportunisticallyDependsOn(InstructionSet_SSSE3))
         {
             // the variable implementation for Vector128 Shuffle always needs SSSE3
+            // however, this can become valid later if it becomes constant
+            if (canBecomeValid)
+            {
+                *canBecomeValid = true;
+            }
             return false;
         }
     }
 #endif // TARGET_XARCH
 
+    if (canBecomeValid)
+    {
+        *canBecomeValid = true;
+    }
     return true;
 }
 
@@ -25501,14 +25514,14 @@ GenTree* Compiler::gtNewSimdShuffleNodeVariable(
     else if (elementSize == 8 && simdSize == 16 && compOpportunisticallyDependsOn(InstructionSet_AVX512F_VL))
     {
         GenTree* op1Copy = fgMakeMultiUse(&op1); // just use op1 again for the other variable
-        retNode = gtNewSimdHWIntrinsicNode(type, op1, op2, op1Copy, NI_AVX512F_VL_PermuteVar2x64x2, simdBaseJitType,
-                                           simdSize);
+        retNode
+            = gtNewSimdHWIntrinsicNode(type, op1, op2, op1Copy, NI_AVX512F_VL_PermuteVar2x64x2, simdBaseJitType,
+                                       simdSize);
     }
     else if (elementSize == 8 && simdSize == 16 && compOpportunisticallyDependsOn(InstructionSet_AVX10v1))
     {
         GenTree* op1Copy = fgMakeMultiUse(&op1); // just use op1 again for the other variable
-        retNode = gtNewSimdHWIntrinsicNode(type, op1, op2, op1Copy, NI_AVX10v1_PermuteVar2x64x2, simdBaseJitType,
-                                           simdSize);
+        retNode = gtNewSimdHWIntrinsicNode(type, op1, op2, op1Copy, NI_AVX10v1_PermuteVar2x64x2, simdBaseJitType, simdSize);
     }
     else
     {

src/coreclr/jit/hwintrinsicarm64.cpp

@@ -2259,11 +2259,13 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
 
             GenTree* indices = impStackTop(0).val;
 
-            if (!IsValidForShuffle(indices, simdSize, simdBaseType))
+            // Check if the required intrinsics to emit are available.
+            if (!IsValidForShuffle(indices, simdSize, simdBaseType, nullptr))
             {
                 break;
             }
 
+            // If the indices might become constant later, then we don't emit for now, delay until later.
             if (!indices->IsCnsVec())
             {
                 assert(sig->numArgs == 2);

src/coreclr/jit/hwintrinsicxarch.cpp

@@ -3650,12 +3650,14 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
 
             GenTree* indices = impStackTop(0).val;
 
-            if (!IsValidForShuffle(indices, simdSize, simdBaseType))
-            {
-                break;
-            }
+            // Check if the required intrinsics are available to emit now (validForShuffle). If we have variable
+            // indices that might become possible to emit later (due to them becoming constant), this will be
+            // indicated in canBecomeValidForShuffle; otherwise, it's just the same as validForShuffle.
+            bool canBecomeValidForShuffle = false;
+            bool validForShuffle = !IsValidForShuffle(indices, simdSize, simdBaseType, &canBecomeValidForShuffle);
 
-            if (!indices->IsCnsVec())
+            // If the indices might become constant later, then we don't emit for now, delay until later.
+            if (canBecomeValidForShuffle && ((!validForShuffle && canBecomeValidForShuffle) || !indices->IsCnsVec()))
             {
                 assert(sig->numArgs == 2);
 
@@ -3673,6 +3675,12 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
                 }
             }
 
+            // If it isn't valid for shuffle (and can't become valid later, due to above block), then give up now.
+            if (!validForShuffle)
+            {
+                return nullptr;
+            }
+
             if (sig->numArgs == 2)
             {
                 op2 = impSIMDPopStack();

src/coreclr/jit/rationalize.cpp

@@ -344,7 +344,8 @@ void Rationalizer::RewriteHWIntrinsicAsUserCall(GenTree** use, ArrayStack<GenTre
             GenTree* op1 = operands[0];
             GenTree* op2 = operands[1];
 
-            if (!comp->IsValidForShuffle(op2, simdSize, simdBaseType))
+            // Check if the required intrinsics to emit are available.
+            if (!comp->IsValidForShuffle(op2, simdSize, simdBaseType, nullptr))
             {
                 break;
             }