Revert TTI changes, customize getScalarizationOverhead instead

Author: peterbell10

llvm/include/llvm/Analysis/TargetTransformInfo.h

@@ -1482,12 +1482,6 @@ class TargetTransformInfo {
   InstructionCost getInsertExtractValueCost(unsigned Opcode,
                                             TTI::TargetCostKind CostKind) const;
 
-  /// \return The cost of ISD::BUILD_VECTOR, or nullopt if the cost should be
-  /// inferred from insert element and shuffle ops.
-  std::optional<InstructionCost>
-  getBuildVectorCost(VectorType *VecTy, ArrayRef<Value *> Operands,
-                     TargetCostKind CostKind) const;
-
   /// \return The cost of replication shuffle of \p VF elements typed \p EltTy
   /// \p ReplicationFactor times.
   ///
@@ -2225,10 +2219,6 @@ class TargetTransformInfo::Concept {
                                              TTI::TargetCostKind CostKind,
                                              unsigned Index) = 0;
 
-  virtual std::optional<InstructionCost>
-  getBuildVectorCost(VectorType *VecTy, ArrayRef<Value *> Operands,
-                     TargetCostKind CostKind) = 0;
-
   virtual InstructionCost
   getReplicationShuffleCost(Type *EltTy, int ReplicationFactor, int VF,
                             const APInt &DemandedDstElts,
@@ -2957,12 +2947,6 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
                                      unsigned Index) override {
     return Impl.getVectorInstrCost(I, Val, CostKind, Index);
   }
-  std::optional<InstructionCost>
-  getBuildVectorCost(VectorType *VecTy, ArrayRef<Value *> Operands,
-                     TTI::TargetCostKind CostKind) override {
-    return Impl.getBuildVectorCost(VecTy, Operands, CostKind);
-  }
-
   InstructionCost
   getReplicationShuffleCost(Type *EltTy, int ReplicationFactor, int VF,
                             const APInt &DemandedDstElts,

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

@@ -741,12 +741,6 @@ class TargetTransformInfoImplBase {
     return 1;
   }
 
-  std::optional<InstructionCost>
-  getBuildVectorCost(VectorType *Val, ArrayRef<Value *> Operands,
-                     TTI::TargetCostKind CostKind) const {
-    return std::nullopt;
-  }
-
   unsigned getReplicationShuffleCost(Type *EltTy, int ReplicationFactor, int VF,
                                      const APInt &DemandedDstElts,
                                      TTI::TargetCostKind CostKind) {

llvm/include/llvm/CodeGen/BasicTTIImpl.h

@@ -1432,12 +1432,6 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
                                        Op1);
   }
 
-  std::optional<InstructionCost>
-  getBuildVectorCost(VectorType *VecTy, ArrayRef<Value *> Operands,
-                     TTI::TargetCostKind CostKind) {
-    return std::nullopt;
-  }
-
   InstructionCost getReplicationShuffleCost(Type *EltTy, int ReplicationFactor,
                                             int VF,
                                             const APInt &DemandedDstElts,

llvm/lib/Analysis/TargetTransformInfo.cpp

@@ -1124,13 +1124,6 @@ InstructionCost TargetTransformInfo::getInsertExtractValueCost(
   return Cost;
 }
 
-std::optional<InstructionCost>
-TargetTransformInfo::getBuildVectorCost(VectorType *VecTy,
-                                        ArrayRef<Value *> Operands,
-                                        TargetCostKind CostKind) const {
-  return TTIImpl->getBuildVectorCost(VecTy, Operands, CostKind);
-}
-
 InstructionCost TargetTransformInfo::getReplicationShuffleCost(
     Type *EltTy, int ReplicationFactor, int VF, const APInt &DemandedDstElts,
     TTI::TargetCostKind CostKind) const {

llvm/lib/Target/NVPTX/NVPTXTargetTransformInfo.h

@@ -105,24 +105,40 @@ class NVPTXTTIImpl : public BasicTTIImplBase<NVPTXTTIImpl> {
       TTI::OperandValueInfo Op2Info = {TTI::OK_AnyValue, TTI::OP_None},
       ArrayRef<const Value *> Args = {}, const Instruction *CxtI = nullptr);
 
-  std::optional<InstructionCost>
-  getBuildVectorCost(VectorType *VecTy, ArrayRef<Value *> Operands,
-                     TTI::TargetCostKind CostKind) {
-    if (CostKind != TTI::TCK_RecipThroughput)
-      return std::nullopt;
-    auto VT = getTLI()->getValueType(DL, VecTy);
-    if (all_of(Operands, [](Value *Op) { return isa<Constant>(Op); }))
-      return TTI::TCC_Free;
-    if (Isv2x16VT(VT))
-      return 1; // Single vector mov
-    if (VT == MVT::v4i8) {
+  InstructionCost getScalarizationOverhead(VectorType *InTy,
+                                           const APInt &DemandedElts,
+                                           bool Insert, bool Extract,
+                                           TTI::TargetCostKind CostKind,
+                                           ArrayRef<Value *> VL = {}) {
+    if (!InTy->getElementCount().isFixed())
+      return InstructionCost::getInvalid();
+
+    auto VT = getTLI()->getValueType(DL, InTy);
+    auto NumElements = InTy->getElementCount().getFixedValue();
+    InstructionCost Cost = 0;
+    if (Insert && !VL.empty()) {
+      bool AllConstant = all_of(seq(NumElements), [&](int Idx) {
+        return !DemandedElts[Idx] || isa<Constant>(VL[Idx]);
+      });
+      if (AllConstant) {
+        Cost += TTI::TCC_Free;
+        Insert = false;
+      }
+    }
+    if (Insert && Isv2x16VT(VT)) {
+      // Can be built in a single mov
+      Cost += 1;
+      Insert = false;
+    }
+    if (Insert && VT == MVT::v4i8) {
       InstructionCost Cost = 3; // 3 x PRMT
-      for (auto *Op : Operands)
-        if (!isa<Constant>(Op))
+      for (auto Idx : seq(NumElements))
+        if (DemandedElts[Idx])
           Cost += 1; // zext operand to i32
-      return Cost;
+      Insert = false;
     }
-    return std::nullopt;
+    return Cost + BaseT::getScalarizationOverhead(InTy, DemandedElts, Insert,
+                                                  Extract, CostKind, VL);
   }
 
   void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

@@ -11096,9 +11096,6 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {
     if ((!Root && allConstant(VL)) || all_of(VL, IsaPred<UndefValue>))
       return TTI::TCC_Free;
     auto *VecTy = getWidenedType(ScalarTy, VL.size());
-    if (auto Cost = TTI.getBuildVectorCost(VecTy, VL, CostKind);
-        Cost.has_value())
-      return *Cost;
     InstructionCost GatherCost = 0;
     SmallVector<Value *> Gathers(VL);
     if (!Root && isSplat(VL)) {