Optimize Vector128/256.Equals via TestZ

src/coreclr/jit/importer.cpp

@@ -20219,8 +20219,33 @@ GenTree* Compiler::impInlineFetchArg(unsigned lclNum, InlArgInfo* inlArgInfo, In
  // TODO-1stClassStructs: We currently do not reuse an existing lclVar
  // if it is a struct, because it requires some additional handling.
 
- if (!varTypeIsStruct(lclTyp) && !argInfo.argHasSideEff && !argInfo.argHasGlobRef &&
- !argInfo.argHasCallerLocalRef)
+ bool substitute = false;
+ switch (argNode->OperGet())
+ {
+#ifdef FEATURE_HW_INTRINSICS
+ case GT_HWINTRINSIC:
+ {
+ // Enable for all parameterless (=invariant) hw intrinsics such as
+ // Vector128<>.Empty and Vector256<>.AllBitSets. We might consider
+ // doing that for Vector.Create(cns) as well.
+ if ((argNode->gtGetOp1() == nullptr) && (argNode->gtGetOp2() == nullptr))
+ {
+ substitute = true;
+ }
+ break;
+ }
+#endif
+
+ // TODO: Enable substitution for CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE (typeof(T))
+ // but in order to benefit from that, we need to move various "typeof + IsValueType"
+ // optimizations from importer to morph.
+
+ default:
+ break;
+ }
+
+ if (substitute || (!varTypeIsStruct(lclTyp) && !argInfo.argHasSideEff && !argInfo.argHasGlobRef &&
+ !argInfo.argHasCallerLocalRef))
  {
  /* Get a *LARGE* LCL_VAR node */
  op1 = gtNewLclLNode(tmpNum, genActualType(lclTyp) DEBUGARG(lclNum));

src/coreclr/jit/morph.cpp

@@ -14290,6 +14290,55 @@ GenTree* Compiler::fgMorphSmpOpOptional(GenTreeOp* tree)
  }
  break;
 
+#if defined(FEATURE_HW_INTRINSICS) && defined(TARGET_XARCH)
+ case GT_HWINTRINSIC:
+ {
+ GenTreeHWIntrinsic* hw = tree->AsHWIntrinsic();
+ switch (hw->gtHWIntrinsicId)
+ {
+ case NI_SSE_Xor:
+ case NI_SSE2_Xor:
+ case NI_AVX_Xor:
+ case NI_AVX2_Xor:
+ {
+ // Optimize Xor(x, Vector_.Zero) to just x
+ GenTree* op1 = hw->gtGetOp1();
+ GenTree* op2 = hw->gtGetOp2();
+
+ // Is node - Vector_.Zero ?
+ auto isHwZero = [](GenTree* node) -> bool {
+ if (node->OperIs(GT_HWINTRINSIC))
+ {
+ NamedIntrinsic ni = node->AsHWIntrinsic()->gtHWIntrinsicId;
+ return (ni == NI_Vector128_get_Zero) || (ni == NI_Vector256_get_Zero);
+ }
+ return false;
+ };
+
+ if (isHwZero(op1))
+ {
+ DEBUG_DESTROY_NODE(tree);
+ DEBUG_DESTROY_NODE(op1);
+ INDEBUG(op2->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED);
+ return op2;
+ }
+ if (isHwZero(op2))
+ {
+ DEBUG_DESTROY_NODE(tree);
+ DEBUG_DESTROY_NODE(op2);
+ INDEBUG(op1->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED);
+ return op1;
+ }
+ break;
+ }
+
+ default:
+ break;
+ }
+ break;
+ }
+#endif // defined(FEATURE_HW_INTRINSICS) && defined(TARGET_XARCH)
+
  default:
  break;
  }

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs

@@ -116,6 +116,15 @@ public bool Equals(Vector128<T> other)
  return Sse.MoveMask(result) == 0b1111; // We have one bit per element
  }
 
+ if (Sse41.IsSupported && (typeof(T) != typeof(double)))
+ {
+ Debug.Assert(typeof(T) != typeof(float));
+
+ // xor + testz is slightly better for integer types
+ Vector128<byte> xored = Sse2.Xor(this.AsByte(), other.AsByte());
+ return Sse41.TestZ(xored, xored);
+ }
+
  if (Sse2.IsSupported)
  {
  if (typeof(T) == typeof(double))

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs

@@ -134,8 +134,9 @@ public bool Equals(Vector256<T> other)
  // bytes are exactly the same.
 
  Debug.Assert((typeof(T) != typeof(float)) && (typeof(T) != typeof(double)));
- Vector256<byte> result = Avx2.CompareEqual(this.AsByte(), other.AsByte());
- return Avx2.MoveMask(result) == unchecked((int)(0b1111_1111_1111_1111_1111_1111_1111_1111)); // We have one bit per element
+
+ Vector256<byte> xored = Avx2.Xor(this.AsByte(), other.AsByte());
+ return Avx.TestZ(xored, xored);
  }
 
  return SoftwareFallback(in this, other);