[InstSimplify][AArch64] Eliminate vector reverse of ptrue/dupx intrinsics

[mnadeem]

Summary

After D107793 reverse of a splat vector is eliminated.
Added a few more cases that should be simplified.
https://godbolt.org/z/6oc1dPdE9

Not sure if it is appropriate to do this here or better to move this to the target backend.

[david-arm]

llvm/lib/Analysis/VectorUtils.cpp

417

To be honest, I'm not sure if this is the right place to be putting AArch64 specific intrinsics. Perhaps lib/Target/AArch64/SVEIntrinsicsOpt.cpp is a better location on this occasion?

[paulwalker-arm]

llvm/lib/Analysis/VectorUtils.cpp

417

Rather than SVEIntrinsicsOpts I recommend extending AArch64TTIImpl::instCombineIntrinsic() to canonicalise these idioms to normal LLVM splat operations. That way we don't need to teach existing code about target specific variants of splats.

[mnadeem]

dup.x is now canonicalized to IR splat so reverse shouldn't be an issue now.
Reverses of ptrue can still be optimized, will get back to it when I get time.

llvm/lib/Analysis/VectorUtils.cpp

 #include "llvm/Analysis/LoopIterator.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/IntrinsicsAArch64.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/CommandLine.h"
 
 #define DEBUG_TYPE "vectorutils"
 
 using namespace llvm;
 using namespace llvm::PatternMatch;
bool llvm::isSplatValue(const Value *V, int Index, unsigned Depth) {
   if (match(V, m_BinOp(m_Value(X), m_Value(Y))))
     return isSplatValue(X, Index, Depth) && isSplatValue(Y, Index, Depth);
 
   // If all operands of a select are splats, the result is a splat.
   if (match(V, m_Select(m_Value(X), m_Value(Y), m_Value(Z))))
     return isSplatValue(X, Index, Depth) && isSplatValue(Y, Index, Depth) &&
            isSplatValue(Z, Index, Depth);
 
+  // aarch64_sve_ptrue(31) is an all true predicate i.e. splat(i1 1).
+  if (match(V, m_Intrinsic<Intrinsic::aarch64_sve_ptrue>(m_SpecificInt(31))))
+    return true;
+
+  // aarch64_sve_dup_x is splat operation.
+  if (match(V, m_Intrinsic<Intrinsic::aarch64_sve_dup_x>()))
+    return true;
+
   // TODO: Add support for unary ops (fneg), casts, intrinsics (overflow ops).
 
   return false;
 }
 
 void llvm::narrowShuffleMaskElts(int Scale, ArrayRef<int> Mask,
                                  SmallVectorImpl<int> &ScaledMask) {
   assert(Scale > 0 && "Unexpected scaling factor");

llvm/test/Transforms/InstSimplify/named-vector-shuffle-reverse.ll

 ; CHECK-NEXT:    ret <vscale x 4 x i32> [[SPLAT]]
 ;
   %splat_insert = insertelement <vscale x 4 x i32> poison, i32 %a, i32 0
   %splat = shufflevector <vscale x 4 x i32> %splat_insert, <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
   %rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %splat)
   ret <vscale x 4 x i32> %rev
 }
 
+define <vscale x 4 x i1> @splat_ptrue_intr_reverse() {
+; CHECK-LABEL: @splat_ptrue_intr_reverse(
+; CHECK-NEXT:    [[SPLAT:%.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.ptrue.nxv4i1(i32 31)
+; CHECK-NEXT:    ret <vscale x 4 x i1> [[SPLAT]]
+;
+  %splat = call <vscale x 4 x i1> @llvm.aarch64.sve.ptrue.nxv4i1(i32 31)
+  %rev = tail call <vscale x 4 x i1> @llvm.experimental.vector.reverse.nxv4i1(<vscale x 4 x i1> %splat)
+  ret <vscale x 4 x i1> %rev
+}
+
+define <vscale x 4 x i32> @splat_dupx_intr_reverse(i32 %a) {
+; CHECK-LABEL: @splat_dupx_intr_reverse(
+; CHECK-NEXT:    [[SPLAT:%.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 [[A:%.*]])
+; CHECK-NEXT:    ret <vscale x 4 x i32> [[SPLAT]]
+;
+  %splat= call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 %a)
+  %rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %splat)
+  ret <vscale x 4 x i32> %rev
+}
+
+declare <vscale x 4 x i1> @llvm.aarch64.sve.ptrue.nxv4i1(i32 %pattern)
+declare <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32)
+declare <vscale x 4 x i1> @llvm.experimental.vector.reverse.nxv4i1(<vscale x 4 x i1>)
 declare <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32>)