apply comment

Author: HanKuanChen

llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp

@@ -343,50 +343,26 @@ RISCVTTIImpl::getConstantPoolLoadCost(Type *Ty,  TTI::TargetCostKind CostKind) {
                              /*AddressSpace=*/0, CostKind);
 }
 
-InstructionCost
-RISCVTTIImpl::isMultipleInsertSubvector(VectorType *Tp, ArrayRef<int> Mask,
-                                        TTI::TargetCostKind CostKind) {
-  if (!isa<FixedVectorType>(Tp))
-    return InstructionCost::getInvalid();
-  std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Tp);
-  if (LT.second.getScalarSizeInBits() == 1)
-    return InstructionCost::getInvalid();
+static bool isRepeatedConcatMaskImpl(ArrayRef<int> Mask, int &SubVectorSize) {
   unsigned Size = Mask.size();
   if (!isPowerOf2_32(Size))
-    return InstructionCost::getInvalid();
-  // Try to guess subvector size.
-  unsigned SubVecSize;
+    return false;
   for (unsigned I = 0; I != Size; ++I) {
     if (static_cast<unsigned>(Mask[I]) == I)
       continue;
-    if (Mask[I] == 0) {
-      SubVecSize = I;
-      break;
-    }
-    return InstructionCost::getInvalid();
-  }
-  if (Size % SubVecSize != 0)
-    return InstructionCost::getInvalid();
-  for (unsigned I = 0; I != Size; ++I)
-    if (static_cast<unsigned>(Mask[I]) != I % SubVecSize)
-      return InstructionCost::getInvalid();
-  InstructionCost Cost = 0;
-  unsigned NumSlides = Log2_32(Size / SubVecSize);
-  // The cost of extraction from a subvector is 0 if the index is 0.
-  for (unsigned I = 0; I != NumSlides; ++I) {
-    unsigned InsertIndex = SubVecSize * (1 << I);
-    FixedVectorType *SubTp =
-        FixedVectorType::get(Tp->getElementType(), InsertIndex);
-    FixedVectorType *DestTp =
-        FixedVectorType::getDoubleElementsVectorType(SubTp);
-    std::pair<InstructionCost, MVT> DestLT = getTypeLegalizationCost(DestTp);
-    // Add the cost of whole vector register move because the destination vector
-    // register group for vslideup cannot overlap the source.
-    Cost += DestLT.first * TLI->getLMULCost(DestLT.second);
-    Cost += getShuffleCost(TTI::SK_InsertSubvector, DestTp, {}, CostKind,
-                           InsertIndex, SubTp);
+    if (Mask[I] != 0)
+      return false;
+    if (Size % I != 0)
+      return false;
+    for (unsigned J = 0; J != Size; ++J)
+      // Check the pattern is repeated.
+      if (static_cast<unsigned>(Mask[J]) != J % I)
+        return false;
+    SubVectorSize = I;
+    return true;
   }
-  return Cost;
+  // That means Mask is <0, 1, 2, 3>. This is not a concatenation.
+  return false;
 }
 
 static VectorType *getVRGatherIndexType(MVT DataVT, const RISCVSubtarget &ST,
@@ -440,10 +416,29 @@ InstructionCost RISCVTTIImpl::getShuffleCost(TTI::ShuffleKind Kind,
                                                         LT.second, CostKind);
           }
         }
-        if (InstructionCost Cost =
-                isMultipleInsertSubvector(Tp, Mask, CostKind);
-            Cost.isValid())
+        int SubVectorSize;
+        if (LT.second.getScalarSizeInBits() != 1 &&
+            isRepeatedConcatMaskImpl(Mask, SubVectorSize)) {
+          InstructionCost Cost = 0;
+          unsigned NumSlides = Log2_32(Mask.size() / SubVectorSize);
+          // The cost of extraction from a subvector is 0 if the index is 0.
+          for (unsigned I = 0; I != NumSlides; ++I) {
+            unsigned InsertIndex = SubVectorSize * (1 << I);
+            FixedVectorType *SubTp =
+                FixedVectorType::get(Tp->getElementType(), InsertIndex);
+            FixedVectorType *DestTp =
+                FixedVectorType::getDoubleElementsVectorType(SubTp);
+            std::pair<InstructionCost, MVT> DestLT =
+                getTypeLegalizationCost(DestTp);
+            // Add the cost of whole vector register move because the
+            // destination vector register group for vslideup cannot overlap the
+            // source.
+            Cost += DestLT.first * TLI->getLMULCost(DestLT.second);
+            Cost += getShuffleCost(TTI::SK_InsertSubvector, DestTp, {},
+                                   CostKind, InsertIndex, SubTp);
+          }
           return Cost;
+        }
       }
       // vrgather + cost of generating the mask constant.
       // We model this for an unknown mask with a single vrgather.

llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h

@@ -55,12 +55,6 @@ class RISCVTTIImpl : public BasicTTIImplBase<RISCVTTIImpl> {
   /// type.
   InstructionCost getConstantPoolLoadCost(Type *Ty,
                                           TTI::TargetCostKind CostKind);
-
-  /// Return the cost if a shufflevector can be consist of multiple vslideup.
-  /// Otherwise, return InstructionCost::getInvalid().
-  InstructionCost isMultipleInsertSubvector(VectorType *Tp, ArrayRef<int> Mask,
-                                            TTI::TargetCostKind CostKind);
-
 public:
   explicit RISCVTTIImpl(const RISCVTargetMachine *TM, const Function &F)
       : BaseT(TM, F.getDataLayout()), ST(TM->getSubtargetImpl(F)),