[Instructions] cache computed shufflevector properties

- Cache computed properties of a shufflevector mask.
- Merge several shuffle mask property analyses into a single analysis
  and introduce ShuffleMaskAttrs.
- Compute the properties on shufflevector construction.

Author: Prince781

llvm/include/llvm/IR/Instructions.h

@@ -1883,6 +1883,76 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)
 
 constexpr int PoisonMaskElem = -1;
 
+/// Attributes of a shufflevector mask.
+struct ShuffleMaskAttrs {
+  /// If the shuffle chooses elements from exactly one source vector without
+  /// changing the length of that vector.
+  /// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
+  /// TODO: Optionally allow length-changing shuffles.
+  bool SingleSource : 1;
+
+  /// If the shuffle chooses elements from exactly one source vector without
+  /// lane crossings and does not change the number of elements from its input
+  /// vectors.
+  /// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
+  bool Identity : 1;
+
+  /// If the shuffle lengthens exactly one source vector with undefs in the
+  /// high elements.
+  bool IdentityWithPadding : 1;
+
+  /// If the shuffle extracts the first N elements of exactly one source
+  /// vector.
+  bool IdentityWithExtract : 1;
+
+  /// If the shuffle concatenates the two source vectors. This is false if either
+  /// input is undefined. In that case, the shuffle is better classified as an
+  /// identity with padding operation.
+  bool Concat : 1;
+
+  /// If the shuffle swaps the order of elements from exactly one source vector.
+  /// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
+  /// TODO: Optionally allow length-changing shuffles.
+  bool Reverse : 1;
+
+  /// If all elements of the shuffle are the same value as the first element of
+  /// exactly one source vector without changing the length of that vector.
+  /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
+  /// TODO: Optionally allow length-changing shuffles.
+  /// TODO: Optionally allow splats from other elements.
+  bool ZeroEltSplat : 1;
+
+  /// Return true if this shuffle chooses elements from its source vectors
+  /// without lane crossings and all operands have the same number of elements.
+  /// In other words, this shuffle is equivalent to a vector select with a
+  /// constant condition operand.
+  /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
+  /// This returns false if the mask does not choose from both input vectors.
+  /// In that case, the shuffle is better classified as an identity shuffle.
+  /// TODO: Optionally allow length-changing shuffles.
+  bool Select : 1;
+
+  /// If the shuffle transposes the elements of its inputs without changing the
+  /// length of the vectors. This operation may also be known as a merge or
+  /// interleave. See the description for isTransposeMask() for the exact
+  /// specification.
+  /// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
+  bool Transpose : 1;
+
+  /// If the shuffle splices two inputs without changing the length of the
+  /// vectors. This operation concatenates the two inputs together and then
+  /// extracts an original width vector starting from the splice index.
+  /// Example: shufflevector <4 x n> A, <4 x n> B, <1,2,3,4>
+  bool Splice : 1;
+
+  /// The starting index of the splice.
+  /// Example: 1, from the previous example
+  int SpliceIndex;
+};
+
+static_assert(sizeof(ShuffleMaskAttrs) <= sizeof(uint64_t),
+              "ShuffleMaskAttrs is too large!");
+
 /// This instruction constructs a fixed permutation of two
 /// input vectors.
 ///
@@ -1898,6 +1968,7 @@ class ShuffleVectorInst : public Instruction {
 
   SmallVector<int, 4> ShuffleMask;
   Constant *ShuffleMaskForBitcode;
+  ShuffleMaskAttrs MaskAttrs;
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
@@ -1924,6 +1995,12 @@ class ShuffleVectorInst : public Instruction {
   /// of the instruction.
   void commute();
 
+  // Analyze mask of fixed vector. NumOpElts is number of known elements in
+  // operand1/operand2. Scalable is set if any operands are scalable vectors.
+  // HasUndefOp is set if there are any undef operands.
+  static ShuffleMaskAttrs analyzeMask(ArrayRef<int> Mask, int NumOpElts,
+                                      bool Scalable, bool HasUndefOp);
+
   /// Return true if a shufflevector instruction can be
   /// formed with the specified operands.
   static bool isValidOperands(const Value *V1, const Value *V2,
@@ -2004,13 +2081,8 @@ class ShuffleVectorInst : public Instruction {
     return isSingleSourceMask(MaskAsInts, NumSrcElts);
   }
 
-  /// Return true if this shuffle chooses elements from exactly one source
-  /// vector without changing the length of that vector.
-  /// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
-  /// TODO: Optionally allow length-changing shuffles.
   bool isSingleSource() const {
-    return !changesLength() &&
-           isSingleSourceMask(ShuffleMask, ShuffleMask.size());
+    return MaskAttrs.SingleSource;
   }
 
   /// Return true if this shuffle mask chooses elements from exactly one source
@@ -2032,31 +2104,21 @@ class ShuffleVectorInst : public Instruction {
     return isIdentityMask(MaskAsInts, NumSrcElts);
   }
 
-  /// Return true if this shuffle chooses elements from exactly one source
-  /// vector without lane crossings and does not change the number of elements
-  /// from its input vectors.
-  /// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
   bool isIdentity() const {
-    // Not possible to express a shuffle mask for a scalable vector for this
-    // case.
-    if (isa<ScalableVectorType>(getType()))
-      return false;
-
-    return !changesLength() && isIdentityMask(ShuffleMask, ShuffleMask.size());
+    return MaskAttrs.Identity;
   }
 
-  /// Return true if this shuffle lengthens exactly one source vector with
-  /// undefs in the high elements.
-  bool isIdentityWithPadding() const;
+  bool isIdentityWithPadding() const {
+    return MaskAttrs.IdentityWithPadding;
+  }
 
-  /// Return true if this shuffle extracts the first N elements of exactly one
-  /// source vector.
-  bool isIdentityWithExtract() const;
+  bool isIdentityWithExtract() const {
+    return MaskAttrs.IdentityWithExtract;
+  }
 
-  /// Return true if this shuffle concatenates its 2 source vectors. This
-  /// returns false if either input is undefined. In that case, the shuffle is
-  /// is better classified as an identity with padding operation.
-  bool isConcat() const;
+  bool isConcat() const {
+    return MaskAttrs.Concat;
+  }
 
   /// Return true if this shuffle mask chooses elements from its source vectors
   /// without lane crossings. A shuffle using this mask would be
@@ -2074,16 +2136,8 @@ class ShuffleVectorInst : public Instruction {
     return isSelectMask(MaskAsInts, NumSrcElts);
   }
 
-  /// Return true if this shuffle chooses elements from its source vectors
-  /// without lane crossings and all operands have the same number of elements.
-  /// In other words, this shuffle is equivalent to a vector select with a
-  /// constant condition operand.
-  /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
-  /// This returns false if the mask does not choose from both input vectors.
-  /// In that case, the shuffle is better classified as an identity shuffle.
-  /// TODO: Optionally allow length-changing shuffles.
   bool isSelect() const {
-    return !changesLength() && isSelectMask(ShuffleMask, ShuffleMask.size());
+    return MaskAttrs.Select;
   }
 
   /// Return true if this shuffle mask swaps the order of elements from exactly
@@ -2099,12 +2153,8 @@ class ShuffleVectorInst : public Instruction {
     return isReverseMask(MaskAsInts, NumSrcElts);
   }
 
-  /// Return true if this shuffle swaps the order of elements from exactly
-  /// one source vector.
-  /// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
-  /// TODO: Optionally allow length-changing shuffles.
   bool isReverse() const {
-    return !changesLength() && isReverseMask(ShuffleMask, ShuffleMask.size());
+    return MaskAttrs.Reverse;
   }
 
   /// Return true if this shuffle mask chooses all elements with the same value
@@ -2120,15 +2170,8 @@ class ShuffleVectorInst : public Instruction {
     return isZeroEltSplatMask(MaskAsInts, NumSrcElts);
   }
 
-  /// Return true if all elements of this shuffle are the same value as the
-  /// first element of exactly one source vector without changing the length
-  /// of that vector.
-  /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
-  /// TODO: Optionally allow length-changing shuffles.
-  /// TODO: Optionally allow splats from other elements.
   bool isZeroEltSplat() const {
-    return !changesLength() &&
-           isZeroEltSplatMask(ShuffleMask, ShuffleMask.size());
+    return MaskAttrs.ZeroEltSplat;
   }
 
   /// Return true if this shuffle mask is a transpose mask.
@@ -2171,13 +2214,8 @@ class ShuffleVectorInst : public Instruction {
     return isTransposeMask(MaskAsInts, NumSrcElts);
   }
 
-  /// Return true if this shuffle transposes the elements of its inputs without
-  /// changing the length of the vectors. This operation may also be known as a
-  /// merge or interleave. See the description for isTransposeMask() for the
-  /// exact specification.
-  /// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
   bool isTranspose() const {
-    return !changesLength() && isTransposeMask(ShuffleMask, ShuffleMask.size());
+    return MaskAttrs.Transpose;
   }
 
   /// Return true if this shuffle mask is a splice mask, concatenating the two
@@ -2194,13 +2232,9 @@ class ShuffleVectorInst : public Instruction {
     return isSpliceMask(MaskAsInts, NumSrcElts, Index);
   }
 
-  /// Return true if this shuffle splices two inputs without changing the length
-  /// of the vectors. This operation concatenates the two inputs together and
-  /// then extracts an original width vector starting from the splice index.
-  /// Example: shufflevector <4 x n> A, <4 x n> B, <1,2,3,4>
   bool isSplice(int &Index) const {
-    return !changesLength() &&
-           isSpliceMask(ShuffleMask, ShuffleMask.size(), Index);
+    Index = MaskAttrs.SpliceIndex;
+    return MaskAttrs.Splice;
   }
 
   /// Return true if this shuffle mask is an extract subvector mask.