Apply formatting patch

tannergooding · tannergooding · commit 49088f6d05b1 · 2024-06-06T15:02:31.000-07:00
diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
@@ -18823,8 +18823,8 @@ void GenTreeVecCon::EvaluateUnaryInPlace(genTreeOps oper, bool scalar, var_types
 //    baseType - the base type of the constant being checked
 //    other    - the other vector constant to use in the evaluation
 //
-void GenTreeVecCon::EvaluateBinaryInPlace(genTreeOps oper, bool scalar, var_types simdType, var_types baseType,
-                                          GenTreeVecCon* other)
+void GenTreeVecCon::EvaluateBinaryInPlace(
+    genTreeOps oper, bool scalar, var_types simdType, var_types baseType, GenTreeVecCon* other)
 {
     switch (simdType)
     {
@@ -27614,8 +27614,8 @@ bool GenTreeHWIntrinsic::OperIsCreateScalarUnsafe() const
 //
 bool GenTreeHWIntrinsic::OperIsBitwiseHWIntrinsic() const
 {
-    bool isScalar = false;
-    genTreeOps oper = HWOperGet(&isScalar);
+    bool       isScalar = false;
+    genTreeOps oper     = HWOperGet(&isScalar);
     return (oper == GT_AND) || (oper == GT_AND_NOT) || (oper == GT_NOT) || (oper == GT_OR) || (oper == GT_XOR);
 }
 
@@ -28973,7 +28973,7 @@ uint8_t GenTreeHWIntrinsic::GetTernaryControlByte(GenTreeHWIntrinsic* second) co
 
     bool isScalar = false;
 
-    genTreeOps firstOper  = HWOperGet(&isScalar);
+    genTreeOps firstOper = HWOperGet(&isScalar);
     assert(!isScalar);
 
     genTreeOps secondOper = second->HWOperGet(&isScalar);
diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h
@@ -6877,8 +6877,8 @@ struct GenTreeVecCon : public GenTree
 #endif // FEATURE_HW_INTRINSICS
 
     void EvaluateUnaryInPlace(genTreeOps oper, bool scalar, var_types simdType, var_types baseType);
-    void EvaluateBinaryInPlace(genTreeOps oper, bool scalar, var_types simdType, var_types baseType,
-                               GenTreeVecCon* other);
+    void EvaluateBinaryInPlace(
+        genTreeOps oper, bool scalar, var_types simdType, var_types baseType, GenTreeVecCon* other);
 
     bool IsAllBitsSet() const
     {
diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp
@@ -11338,6 +11338,11 @@ GenTree* Compiler::fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node)
             }
             break;
         }
+
+        default:
+        {
+            break;
+        }
     }
 
     return node;
diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp
@@ -7235,20 +7235,17 @@ ValueNum EvaluateSimdGetElement(ValueNumStore* vns, var_types type, var_types ba
     }
 }
 
-ValueNum ValueNumStore::EvalHWIntrinsicFunUnary(GenTreeHWIntrinsic* tree,
-                                                VNFunc              func,
-                                                ValueNum            arg0VN,
-                                                bool                encodeResultType,
-                                                ValueNum            resultTypeVN)
+ValueNum ValueNumStore::EvalHWIntrinsicFunUnary(
+    GenTreeHWIntrinsic* tree, VNFunc func, ValueNum arg0VN, bool encodeResultType, ValueNum resultTypeVN)
 {
     var_types      type     = tree->TypeGet();
     var_types      baseType = tree->GetSimdBaseType();
     NamedIntrinsic ni       = tree->GetHWIntrinsicId();
 
     if (IsVNConstant(arg0VN))
     {
-        bool isScalar = false;
-        genTreeOps oper = tree->HWOperGet(&isScalar);
+        bool       isScalar = false;
+        genTreeOps oper     = tree->HWOperGet(&isScalar);
 
         if (oper != GT_NONE)
         {
@@ -7447,11 +7444,11 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunUnary(GenTreeHWIntrinsic* tree,
 }
 
 ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,
-                                                 VNFunc         func,
-                                                 ValueNum       arg0VN,
-                                                 ValueNum       arg1VN,
-                                                 bool           encodeResultType,
-                                                 ValueNum       resultTypeVN)
+                                                 VNFunc              func,
+                                                 ValueNum            arg0VN,
+                                                 ValueNum            arg1VN,
+                                                 bool                encodeResultType,
+                                                 ValueNum            resultTypeVN)
 {
     var_types      type     = tree->TypeGet();
     var_types      baseType = tree->GetSimdBaseType();
@@ -7483,8 +7480,8 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,
     {
         assert(IsVNConstant(arg0VN) && IsVNConstant(arg1VN));
 
-        bool isScalar = false;
-        genTreeOps oper = tree->HWOperGet(&isScalar);
+        bool       isScalar = false;
+        genTreeOps oper     = tree->HWOperGet(&isScalar);
 
         if (oper != GT_NONE)
         {
@@ -7673,8 +7670,8 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,
     }
     else if (cnsVN != NoVN)
     {
-        bool isScalar = false;
-        genTreeOps oper = tree->HWOperGet(&isScalar);
+        bool       isScalar = false;
+        genTreeOps oper     = tree->HWOperGet(&isScalar);
 
         if (isScalar)
         {
@@ -7937,8 +7934,8 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,
     }
     else if (arg0VN == arg1VN)
     {
-        bool isScalar = false;
-        genTreeOps oper = tree->HWOperGet(&isScalar);
+        bool       isScalar = false;
+        genTreeOps oper     = tree->HWOperGet(&isScalar);
 
         if (isScalar)
         {
@@ -11834,8 +11831,8 @@ void Compiler::fgValueNumberHWIntrinsic(GenTreeHWIntrinsic* tree)
 
             if (opCount == 1)
             {
-                ValueNum normalLVN = vnStore->EvalHWIntrinsicFunUnary(tree, func, op1vnp.GetLiberal(),
-                                                                      encodeResultType, resultTypeVNPair.GetLiberal());
+                ValueNum normalLVN = vnStore->EvalHWIntrinsicFunUnary(tree, func, op1vnp.GetLiberal(), encodeResultType,
+                                                                      resultTypeVNPair.GetLiberal());
                 ValueNum normalCVN =
                     vnStore->EvalHWIntrinsicFunUnary(tree, func, op1vnp.GetConservative(), encodeResultType,
                                                      resultTypeVNPair.GetConservative());
@@ -11854,10 +11851,9 @@ void Compiler::fgValueNumberHWIntrinsic(GenTreeHWIntrinsic* tree)
                     ValueNum normalLVN =
                         vnStore->EvalHWIntrinsicFunBinary(tree, func, op1vnp.GetLiberal(), op2vnp.GetLiberal(),
                                                           encodeResultType, resultTypeVNPair.GetLiberal());
-                    ValueNum normalCVN =
-                        vnStore->EvalHWIntrinsicFunBinary(tree, func, op1vnp.GetConservative(),
-                                                          op2vnp.GetConservative(), encodeResultType,
-                                                          resultTypeVNPair.GetConservative());
+                    ValueNum normalCVN = vnStore->EvalHWIntrinsicFunBinary(tree, func, op1vnp.GetConservative(),
+                                                                           op2vnp.GetConservative(), encodeResultType,
+                                                                           resultTypeVNPair.GetConservative());
 
                     normalPair = ValueNumPair(normalLVN, normalCVN);
                     excSetPair = vnStore->VNPExcSetUnion(op1Xvnp, op2Xvnp);
diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h
@@ -1212,11 +1212,8 @@ class ValueNumStore
     }
 
 #if defined(FEATURE_HW_INTRINSICS)
-    ValueNum EvalHWIntrinsicFunUnary(GenTreeHWIntrinsic* tree,
-                                     VNFunc              func,
-                                     ValueNum            arg0VN,
-                                     bool                encodeResultType,
-                                     ValueNum            resultTypeVN);
+    ValueNum EvalHWIntrinsicFunUnary(
+        GenTreeHWIntrinsic* tree, VNFunc func, ValueNum arg0VN, bool encodeResultType, ValueNum resultTypeVN);
 
     ValueNum EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,
                                       VNFunc              func,

Original file line number	Diff line number	Diff line change
`@@ -6877,8 +6877,8 @@ struct GenTreeVecCon : public GenTree`
`6877`	`6877`	`#endif // FEATURE_HW_INTRINSICS`
`6878`	`6878`
`6879`	`6879`	`void EvaluateUnaryInPlace(genTreeOps oper, bool scalar, var_types simdType, var_types baseType);`
`6880`		`- void EvaluateBinaryInPlace(genTreeOps oper, bool scalar, var_types simdType, var_types baseType,`
`6881`		`- GenTreeVecCon* other);`
	`6880`	`+ void EvaluateBinaryInPlace(`
	`6881`	`+ genTreeOps oper, bool scalar, var_types simdType, var_types baseType, GenTreeVecCon* other);`
`6882`	`6882`
`6883`	`6883`	`bool IsAllBitsSet() const`
`6884`	`6884`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11338,6 +11338,11 @@ GenTree* Compiler::fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node)`
`11338`	`11338`	`}`
`11339`	`11339`	`break;`
`11340`	`11340`	`}`
	`11341`	`+`
	`11342`	`+ default:`
	`11343`	`+ {`
	`11344`	`+ break;`
	`11345`	`+ }`
`11341`	`11346`	`}`
`11342`	`11347`
`11343`	`11348`	`return node;`
Original file line number	Diff line number	Diff line change
`@@ -7235,20 +7235,17 @@ ValueNum EvaluateSimdGetElement(ValueNumStore* vns, var_types type, var_types ba`
`7235`	`7235`	`}`
`7236`	`7236`	`}`
`7237`	`7237`
`7238`		`-ValueNum ValueNumStore::EvalHWIntrinsicFunUnary(GenTreeHWIntrinsic* tree,`
`7239`		`- VNFunc func,`
`7240`		`- ValueNum arg0VN,`
`7241`		`- bool encodeResultType,`
`7242`		`- ValueNum resultTypeVN)`
	`7238`	`+ValueNum ValueNumStore::EvalHWIntrinsicFunUnary(`
	`7239`	`+ GenTreeHWIntrinsic* tree, VNFunc func, ValueNum arg0VN, bool encodeResultType, ValueNum resultTypeVN)`
`7243`	`7240`	`{`
`7244`	`7241`	`var_types type = tree->TypeGet();`
`7245`	`7242`	`var_types baseType = tree->GetSimdBaseType();`
`7246`	`7243`	`NamedIntrinsic ni = tree->GetHWIntrinsicId();`
`7247`	`7244`
`7248`	`7245`	`if (IsVNConstant(arg0VN))`
`7249`	`7246`	`{`
`7250`		`- bool isScalar = false;`
`7251`		`- genTreeOps oper = tree->HWOperGet(&isScalar);`
	`7247`	`+ bool isScalar = false;`
	`7248`	`+ genTreeOps oper = tree->HWOperGet(&isScalar);`
`7252`	`7249`
`7253`	`7250`	`if (oper != GT_NONE)`
`7254`	`7251`	`{`
`@@ -7447,11 +7444,11 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunUnary(GenTreeHWIntrinsic* tree,`
`7447`	`7444`	`}`
`7448`	`7445`
`7449`	`7446`	`ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,`
`7450`		`- VNFunc func,`
`7451`		`- ValueNum arg0VN,`
`7452`		`- ValueNum arg1VN,`
`7453`		`- bool encodeResultType,`
`7454`		`- ValueNum resultTypeVN)`
	`7447`	`+ VNFunc func,`
	`7448`	`+ ValueNum arg0VN,`
	`7449`	`+ ValueNum arg1VN,`
	`7450`	`+ bool encodeResultType,`
	`7451`	`+ ValueNum resultTypeVN)`
`7455`	`7452`	`{`
`7456`	`7453`	`var_types type = tree->TypeGet();`
`7457`	`7454`	`var_types baseType = tree->GetSimdBaseType();`
`@@ -7483,8 +7480,8 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,`
`7483`	`7480`	`{`
`7484`	`7481`	`assert(IsVNConstant(arg0VN) && IsVNConstant(arg1VN));`
`7485`	`7482`
`7486`		`- bool isScalar = false;`
`7487`		`- genTreeOps oper = tree->HWOperGet(&isScalar);`
	`7483`	`+ bool isScalar = false;`
	`7484`	`+ genTreeOps oper = tree->HWOperGet(&isScalar);`
`7488`	`7485`
`7489`	`7486`	`if (oper != GT_NONE)`
`7490`	`7487`	`{`
`@@ -7673,8 +7670,8 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,`
`7673`	`7670`	`}`
`7674`	`7671`	`else if (cnsVN != NoVN)`
`7675`	`7672`	`{`
`7676`		`- bool isScalar = false;`
`7677`		`- genTreeOps oper = tree->HWOperGet(&isScalar);`
	`7673`	`+ bool isScalar = false;`
	`7674`	`+ genTreeOps oper = tree->HWOperGet(&isScalar);`
`7678`	`7675`
`7679`	`7676`	`if (isScalar)`
`7680`	`7677`	`{`
`@@ -7937,8 +7934,8 @@ ValueNum ValueNumStore::EvalHWIntrinsicFunBinary(GenTreeHWIntrinsic* tree,`
`7937`	`7934`	`}`
`7938`	`7935`	`else if (arg0VN == arg1VN)`
`7939`	`7936`	`{`
`7940`		`- bool isScalar = false;`
`7941`		`- genTreeOps oper = tree->HWOperGet(&isScalar);`
	`7937`	`+ bool isScalar = false;`
	`7938`	`+ genTreeOps oper = tree->HWOperGet(&isScalar);`
`7942`	`7939`
`7943`	`7940`	`if (isScalar)`
`7944`	`7941`	`{`
`@@ -11834,8 +11831,8 @@ void Compiler::fgValueNumberHWIntrinsic(GenTreeHWIntrinsic* tree)`
`11834`	`11831`
`11835`	`11832`	`if (opCount == 1)`
`11836`	`11833`	`{`
`11837`		`- ValueNum normalLVN = vnStore->EvalHWIntrinsicFunUnary(tree, func, op1vnp.GetLiberal(),`
`11838`		`- encodeResultType, resultTypeVNPair.GetLiberal());`
	`11834`	`+ ValueNum normalLVN = vnStore->EvalHWIntrinsicFunUnary(tree, func, op1vnp.GetLiberal(), encodeResultType,`
	`11835`	`+ resultTypeVNPair.GetLiberal());`
`11839`	`11836`	`ValueNum normalCVN =`
`11840`	`11837`	`vnStore->EvalHWIntrinsicFunUnary(tree, func, op1vnp.GetConservative(), encodeResultType,`
`11841`	`11838`	`resultTypeVNPair.GetConservative());`
`@@ -11854,10 +11851,9 @@ void Compiler::fgValueNumberHWIntrinsic(GenTreeHWIntrinsic* tree)`
`11854`	`11851`	`ValueNum normalLVN =`
`11855`	`11852`	`vnStore->EvalHWIntrinsicFunBinary(tree, func, op1vnp.GetLiberal(), op2vnp.GetLiberal(),`
`11856`	`11853`	`encodeResultType, resultTypeVNPair.GetLiberal());`
`11857`		`- ValueNum normalCVN =`
`11858`		`- vnStore->EvalHWIntrinsicFunBinary(tree, func, op1vnp.GetConservative(),`
`11859`		`- op2vnp.GetConservative(), encodeResultType,`
`11860`		`- resultTypeVNPair.GetConservative());`
	`11854`	`+ ValueNum normalCVN = vnStore->EvalHWIntrinsicFunBinary(tree, func, op1vnp.GetConservative(),`
	`11855`	`+ op2vnp.GetConservative(), encodeResultType,`
	`11856`	`+ resultTypeVNPair.GetConservative());`
`11861`	`11857`
`11862`	`11858`	`normalPair = ValueNumPair(normalLVN, normalCVN);`
`11863`	`11859`	`excSetPair = vnStore->VNPExcSetUnion(op1Xvnp, op2Xvnp);`