[TTI] Add getPHICost to better cost phi operands. NFCI

[luke]

Summary

In order to better account for the cost of constant materialization in phis, specifically in the SLP vectorizer, we would like to start providing targets information about their operands via OperandValueInfo.

This patch separates out phi instructions from getCFInstrCost so we can pass the type as well as information about the incoming values, i.e. if they are constant or not.

[luke]

llvm/include/llvm/Analysis/TargetTransformInfo.h

1256–1269

I split out PHIs from getCFInstrCost here because it didn't seem to make any sense for return/branch/switch to have Type and OperandValueInfo arguments

[ABataev]

LG with a nit

llvm/include/llvm/Analysis/TargetTransformInfo.h

1267

std::nullopt instead of {}

[asb]

Does it make sense to copy across the "branches are assumed to be predicted" comment as you currently do?

[luke]

After discussing offline with @reames, we're not sure if D149169 is the most accurate way to model constant costs in phi nodes. Moving it off the review queue for the meantime

llvm/include/llvm/Analysis/TargetTransformInfo.h

 
   /// \return The expected cost of a sign- or zero-extended vector extract. Use
   /// Index = -1 to indicate that there is no information about the index value.
   InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                            VectorType *VecTy,
                                            unsigned Index) const;
 
   /// \return The expected cost of control-flow related instructions such as
-  /// Phi, Ret, Br, Switch.
+  /// Ret, Br, Switch.
   InstructionCost
   getCFInstrCost(unsigned Opcode,
                  TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency,
                  const Instruction *I = nullptr) const;
 
+  /// \return The expected cost of a phi node. \p Ty is the type of the phi node
+  /// and its incoming values, and \OpInfos is any extra information about the
+  /// incoming values.
+  InstructionCost
+  getPHICost(Type *Ty, TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency,
+             ArrayRef<OperandValueInfo> OpInfos = {},
+             const Instruction *I = nullptr) const;
+
   /// \returns The expected cost of compare and select instructions. If there
   /// is an existing instruction that holds Opcode, it may be passed in the
   /// 'I' parameter. The \p VecPred parameter can be used to indicate the select
   /// is using a compare with the specified predicate as condition. When vector
   /// types are passed, \p VecPred must be used for all lanes.
   InstructionCost
   getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
                      CmpInst::Predicate VecPred,
virtual InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst,
                                            TTI::TargetCostKind CostKind,
                                            const Instruction *I) = 0;
   virtual InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                                    VectorType *VecTy,
                                                    unsigned Index) = 0;
   virtual InstructionCost getCFInstrCost(unsigned Opcode,
                                          TTI::TargetCostKind CostKind,
                                          const Instruction *I = nullptr) = 0;
+  virtual InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                                     ArrayRef<OperandValueInfo> OpInfos,
+                                     const Instruction *I = nullptr) = 0;
   virtual InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
                                              Type *CondTy,
                                              CmpInst::Predicate VecPred,
                                              TTI::TargetCostKind CostKind,
                                              const Instruction *I) = 0;
   virtual InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val,
                                              TTI::TargetCostKind CostKind,
                                              unsigned Index, Value *Op0,
InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                            VectorType *VecTy,
                                            unsigned Index) override {
     return Impl.getExtractWithExtendCost(Opcode, Dst, VecTy, Index);
   }
   InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
                                  const Instruction *I = nullptr) override {
     return Impl.getCFInstrCost(Opcode, CostKind, I);
   }
+  InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                             ArrayRef<OperandValueInfo> OpInfos,
+                             const Instruction *I = nullptr) override {
+    return Impl.getPHICost(Ty, CostKind, OpInfos, I);
+  }
   InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
                                      CmpInst::Predicate VecPred,
                                      TTI::TargetCostKind CostKind,
                                      const Instruction *I) override {
     return Impl.getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
   }
   InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val,
                                      TTI::TargetCostKind CostKind,

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

public:
   InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                            VectorType *VecTy,
                                            unsigned Index) const {
     return 1;
   }
 
   InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
                                  const Instruction *I = nullptr) const {
+    return 1;
+  }
+
+  InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                             ArrayRef<TTI::OperandValueInfo> OpInfos,
+                             const Instruction *I) const {
     // A phi would be free, unless we're costing the throughput because it
     // will require a register.
-    if (Opcode == Instruction::PHI && CostKind != TTI::TCK_RecipThroughput)
-      return 0;
-    return 1;
+    return CostKind != TTI::TCK_RecipThroughput ? 0 : 1;
   }
 
   InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
                                      CmpInst::Predicate VecPred,
                                      TTI::TargetCostKind CostKind,
                                      const Instruction *I) const {
     return 1;
   }
InstructionCost getInstructionCost(const User *U,
     case Instruction::Call: {
       assert(isa<IntrinsicInst>(U) && "Unexpected non-intrinsic call");
       auto *Intrinsic = cast<IntrinsicInst>(U);
       IntrinsicCostAttributes CostAttrs(Intrinsic->getIntrinsicID(), *CB);
       return TargetTTI->getIntrinsicInstrCost(CostAttrs, CostKind);
     }
     case Instruction::Br:
     case Instruction::Ret:
-    case Instruction::PHI:
     case Instruction::Switch:
       return TargetTTI->getCFInstrCost(Opcode, CostKind, I);
+    case Instruction::PHI: {
+      SmallVector<TTI::OperandValueInfo, 4> OpInfos;
+      transform(I->operand_values(), std::back_inserter(OpInfos),
+                TTI::getOperandInfo);
+      return TargetTTI->getPHICost(I->getType(), CostKind, OpInfos, I);
+    }
     case Instruction::ExtractValue:
     case Instruction::Freeze:
       return TTI::TCC_Free;
     case Instruction::Alloca:
       if (cast<AllocaInst>(U)->isStaticAlloca())
         return TTI::TCC_Free;
       break;
     case Instruction::GetElementPtr: {

llvm/include/llvm/CodeGen/BasicTTIImpl.h

if (VariableMask) {
       ConditionalCost =
           VT->getNumElements() *
           (getVectorInstrCost(
                Instruction::ExtractElement,
                FixedVectorType::get(Type::getInt1Ty(DataTy->getContext()),
                                     VT->getNumElements()),
                CostKind, -1, nullptr, nullptr) +
            getCFInstrCost(Instruction::Br, CostKind) +
-           getCFInstrCost(Instruction::PHI, CostKind));
+           getPHICost(VT->getElementType(), CostKind));
     }
 
     return LoadCost + PackingCost + ConditionalCost;
   }
 
 protected:
   explicit BasicTTIImplBase(const TargetMachine *TM, const DataLayout &DL)
       : BaseT(DL) {}
return thisT()->getVectorInstrCost(Instruction::ExtractElement, VecTy,
                                      TTI::CastContextHint::None, CostKind);
   }
 
   InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
                                  const Instruction *I = nullptr) {
     return BaseT::getCFInstrCost(Opcode, CostKind, I);
   }
 
+  InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                             ArrayRef<TTI::OperandValueInfo> OpInfos = {},
+                             const Instruction *I = nullptr) {
+    return BaseT::getPHICost(Ty, CostKind, OpInfos, I);
+  }
+
   InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
                                      CmpInst::Predicate VecPred,
                                      TTI::TargetCostKind CostKind,
                                      const Instruction *I = nullptr) {
     const TargetLoweringBase *TLI = getTLI();
     int ISD = TLI->InstructionOpcodeToISD(Opcode);
     assert(ISD && "Invalid opcode");
 

llvm/lib/Analysis/TargetTransformInfo.cpp

InstructionCost TargetTransformInfo::getExtractWithExtendCost(
   assert(Cost >= 0 && "TTI should not produce negative costs!");
   return Cost;
 }
 
 InstructionCost TargetTransformInfo::getCFInstrCost(
     unsigned Opcode, TTI::TargetCostKind CostKind, const Instruction *I) const {
   assert((I == nullptr || I->getOpcode() == Opcode) &&
          "Opcode should reflect passed instruction.");
+  assert((Opcode == Instruction::Br || Opcode == Instruction::Ret ||
+          Opcode == Instruction::Switch) &&
+         "Opcode should be one of Br, Ret or Switch");
   InstructionCost Cost = TTIImpl->getCFInstrCost(Opcode, CostKind, I);
   assert(Cost >= 0 && "TTI should not produce negative costs!");
   return Cost;
 }
 
+InstructionCost
+TargetTransformInfo::getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                                ArrayRef<TTI::OperandValueInfo> OpInfos,
+                                const Instruction *I) const {
+  assert((I == nullptr || I->getOpcode() == Instruction::PHI) &&
+         "Opcode should reflect passed instruction.");
+  InstructionCost Cost = TTIImpl->getPHICost(Ty, CostKind, OpInfos, I);
+  assert(Cost >= 0 && "TTI should not produce negative costs!");
+  return Cost;
+}
+
 InstructionCost TargetTransformInfo::getCmpSelInstrCost(
     unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred,
     TTI::TargetCostKind CostKind, const Instruction *I) const {
   assert((I == nullptr || I->getOpcode() == Opcode) &&
          "Opcode should reflect passed instruction.");
   InstructionCost Cost =
       TTIImpl->getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
   assert(Cost >= 0 && "TTI should not produce negative costs!");

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h

InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
                                    TTI::TargetCostKind CostKind,
                                    const Instruction *I = nullptr);
 
   InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                            VectorType *VecTy, unsigned Index);
 
   InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
                                  const Instruction *I = nullptr);
+  InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                             ArrayRef<TTI::OperandValueInfo> OpInfos,
+                             const Instruction *I = nullptr);
 
   InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val,
                                      TTI::TargetCostKind CostKind,
                                      unsigned Index, Value *Op0, Value *Op1);
   InstructionCost getVectorInstrCost(const Instruction &I, Type *Val,
                                      TTI::TargetCostKind CostKind,
                                      unsigned Index);
 

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

InstructionCost AArch64TTIImpl::getExtractWithExtendCost(unsigned Opcode,
   return Cost + getCastInstrCost(Opcode, Dst, Src, TTI::CastContextHint::None,
                                  CostKind);
 }
 
 InstructionCost AArch64TTIImpl::getCFInstrCost(unsigned Opcode,
                                                TTI::TargetCostKind CostKind,
                                                const Instruction *I) {
   if (CostKind != TTI::TCK_RecipThroughput)
-    return Opcode == Instruction::PHI ? 0 : 1;
+    return 1;
   assert(CostKind == TTI::TCK_RecipThroughput && "unexpected CostKind");
   // Branches are assumed to be predicted.
   return 0;
 }
 
+InstructionCost
+AArch64TTIImpl::getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                           ArrayRef<TTI::OperandValueInfo> OpInfos,
+                           const Instruction *I) {
+  // Branches are assumed to be predicted.
+  return 0;
+}
+
 InstructionCost AArch64TTIImpl::getVectorInstrCostHelper(const Instruction *I,
                                                          Type *Val,
                                                          unsigned Index,
                                                          bool HasRealUse) {
   assert(Val->isVectorTy() && "This must be a vector type");
 
   if (Index != -1U) {
     // Legalize the type.

llvm/lib/Target/AMDGPU/R600TargetTransformInfo.cpp

unsigned R600TTIImpl::getMaxInterleaveFactor(ElementCount VF) {
 
   return 8;
 }
 
 InstructionCost R600TTIImpl::getCFInstrCost(unsigned Opcode,
                                             TTI::TargetCostKind CostKind,
                                             const Instruction *I) {
   if (CostKind == TTI::TCK_CodeSize || CostKind == TTI::TCK_SizeAndLatency)
-    return Opcode == Instruction::PHI ? 0 : 1;
+    return 1;
 
   // XXX - For some reason this isn't called for switch.
   switch (Opcode) {
   case Instruction::Br:
   case Instruction::Ret:
     return 10;
   default:
     return BaseT::getCFInstrCost(Opcode, CostKind, I);

llvm/lib/Target/ARM/ARMTargetTransformInfo.h

public:
   bool preferPredicatedReductionSelect(unsigned Opcode, Type *Ty,
                                        TTI::ReductionFlags Flags) const;
 
   bool shouldExpandReduction(const IntrinsicInst *II) const { return false; }
 
   InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
                                  const Instruction *I = nullptr);
 
+  InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                             ArrayRef<TTI::OperandValueInfo> OpInfos,
+                             const Instruction *I = nullptr);
+
   InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
                                    TTI::CastContextHint CCH,
                                    TTI::TargetCostKind CostKind,
                                    const Instruction *I = nullptr);
 
   InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
                                      CmpInst::Predicate VecPred,
                                      TTI::TargetCostKind CostKind,

llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp

if (CostKind == TTI::TCK_RecipThroughput &&
     // instructions, which suggests that it may be using the costs incorrectly.
     // But, for now, just make them free to avoid performance regressions for
     // vector targets.
     return 0;
   }
   return BaseT::getCFInstrCost(Opcode, CostKind, I);
 }
 
+InstructionCost ARMTTIImpl::getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                                       ArrayRef<TTI::OperandValueInfo> OpInfos,
+                                       const Instruction *I) {
+  if (CostKind == TTI::TCK_RecipThroughput &&
+      (ST->hasNEON() || ST->hasMVEIntegerOps())) {
+    // FIXME: The vectorizer is highly sensistive to the cost of these
+    // instructions, which suggests that it may be using the costs incorrectly.
+    // But, for now, just make them free to avoid performance regressions for
+    // vector targets.
+    return 0;
+  }
+  return BaseT::getPHICost(Ty, CostKind, OpInfos, I);
+}
+
 InstructionCost ARMTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst,
                                              Type *Src,
                                              TTI::CastContextHint CCH,
                                              TTI::TargetCostKind CostKind,
                                              const Instruction *I) {
   int ISD = TLI->InstructionOpcodeToISD(Opcode);
   assert(ISD && "Invalid opcode");
 

llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h

InstructionCost getShuffleCost(TTI::ShuffleKind Kind, Type *Tp,
                                  Type *SubTp,
                                  ArrayRef<const Value *> Args = std::nullopt);
   InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
                                    TTI::CastContextHint CCH,
                                    TTI::TargetCostKind CostKind,
                                    const Instruction *I = nullptr);
   InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
                                  const Instruction *I = nullptr);
+  InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                             ArrayRef<TTI::OperandValueInfo> OpInfos,
+                             const Instruction *I = nullptr);
   InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
                                      CmpInst::Predicate VecPred,
                                      TTI::TargetCostKind CostKind,
                                      const Instruction *I = nullptr);
   using BaseT::getVectorInstrCost;
   InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val,
                                      TTI::TargetCostKind CostKind,
                                      unsigned Index, Value *Op0, Value *Op1);

llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp

InstructionCost PPCTTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp,
   // structured types of shuffles covered by TTI::ShuffleKind).
   return LT.first * CostFactor;
 }
 
 InstructionCost PPCTTIImpl::getCFInstrCost(unsigned Opcode,
                                            TTI::TargetCostKind CostKind,
                                            const Instruction *I) {
   if (CostKind != TTI::TCK_RecipThroughput)
-    return Opcode == Instruction::PHI ? 0 : 1;
+    return 1;
+  // Branches are assumed to be predicted.
+  return 0;
+}
+
+InstructionCost PPCTTIImpl::getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                                       ArrayRef<TTI::OperandValueInfo> OpInfos,
+                                       const Instruction *I) {
   // Branches are assumed to be predicted.
   return 0;
 }
 
 InstructionCost PPCTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst,
                                              Type *Src,
                                              TTI::CastContextHint CCH,
                                              TTI::TargetCostKind CostKind,

llvm/lib/Target/X86/X86TargetTransformInfo.h

public:
 
   InstructionCost getIntImmCost(int64_t);
 
   InstructionCost getIntImmCost(const APInt &Imm, Type *Ty,
                                 TTI::TargetCostKind CostKind);
 
   InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind,
                                  const Instruction *I = nullptr);
+  InstructionCost getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                             ArrayRef<TTI::OperandValueInfo> OpInfos,
+                             const Instruction *I = nullptr);
 
   InstructionCost getIntImmCostInst(unsigned Opcode, unsigned Idx,
                                     const APInt &Imm, Type *Ty,
                                     TTI::TargetCostKind CostKind,
                                     Instruction *Inst = nullptr);
   InstructionCost getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx,
                                       const APInt &Imm, Type *Ty,
                                       TTI::TargetCostKind CostKind);

llvm/lib/Target/X86/X86TargetTransformInfo.cpp

InstructionCost X86TTIImpl::getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx,
   }
   return X86TTIImpl::getIntImmCost(Imm, Ty, CostKind);
 }
 
 InstructionCost X86TTIImpl::getCFInstrCost(unsigned Opcode,
                                            TTI::TargetCostKind CostKind,
                                            const Instruction *I) {
   if (CostKind != TTI::TCK_RecipThroughput)
-    return Opcode == Instruction::PHI ? 0 : 1;
+    return 1;
+  // Branches are assumed to be predicted.
+  return 0;
+}
+
+InstructionCost X86TTIImpl::getPHICost(Type *Ty, TTI::TargetCostKind CostKind,
+                                       ArrayRef<TTI::OperandValueInfo> OpInfos,
+                                       const Instruction *I) {
   // Branches are assumed to be predicted.
   return 0;
 }
 
 int X86TTIImpl::getGatherOverhead() const {
   // Some CPUs have more overhead for gather. The specified overhead is relative
   // to the Load operation. "2" is the number provided by Intel architects. This
   // parameter is used for cost estimation of Gather Op and comparison with

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

if (!VF.isScalable()) {
     // executing the predicated block. If the instruction is not predicated,
     // we fall through to the next case.
     ScalarizationCost = 0;
 
     // These instructions have a non-void type, so account for the phi nodes
     // that we will create. This cost is likely to be zero. The phi node
     // cost, if any, should be scaled by the block probability because it
     // models a copy at the end of each predicated block.
-    ScalarizationCost += VF.getKnownMinValue() *
-      TTI.getCFInstrCost(Instruction::PHI, CostKind);
+    ScalarizationCost +=
+        VF.getKnownMinValue() * TTI.getPHICost(I->getType(), CostKind);
 
     // The cost of the non-predicated instruction.
     ScalarizationCost += VF.getKnownMinValue() *
       TTI.getArithmeticInstrCost(I->getOpcode(), I->getType(), CostKind);
 
     // The cost of insertelement and extractelement instructions needed for
     // scalarization.
     ScalarizationCost += getScalarizationOverhead(I, VF, CostKind);
while (!Worklist.empty()) {
     // Compute the scalarization overhead of needed insertelement instructions
     // and phi nodes.
     TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput;
     if (isScalarWithPredication(I, VF) && !I->getType()->isVoidTy()) {
       ScalarCost += TTI.getScalarizationOverhead(
           cast<VectorType>(ToVectorTy(I->getType(), VF)),
           APInt::getAllOnes(VF.getFixedValue()), /*Insert*/ true,
           /*Extract*/ false, CostKind);
-      ScalarCost +=
-          VF.getFixedValue() * TTI.getCFInstrCost(Instruction::PHI, CostKind);
+      ScalarCost += VF.getFixedValue() * TTI.getPHICost(I->getType(), CostKind);
     }
 
     // Compute the scalarization overhead of needed extractelement
     // instructions. For each of the instruction's operands, if the operand can
     // be scalarized, add it to the worklist; otherwise, account for the
     // overhead.
     for (Use &U : I->operands())
       if (auto *J = dyn_cast<Instruction>(U.get())) {
case Instruction::PHI: {
     if (VF.isVector() && Legal->isFixedOrderRecurrence(Phi)) {
       SmallVector<int> Mask(VF.getKnownMinValue());
       std::iota(Mask.begin(), Mask.end(), VF.getKnownMinValue() - 1);
       return TTI.getShuffleCost(TargetTransformInfo::SK_Splice,
                                 cast<VectorType>(VectorTy), Mask, CostKind,
                                 VF.getKnownMinValue() - 1);
     }
 
+    Type *VecTy = ToVectorTy(Phi->getType(), VF);
+
     // Phi nodes in non-header blocks (not inductions, reductions, etc.) are
     // converted into select instructions. We require N - 1 selects per phi
     // node, where N is the number of incoming values.
     if (VF.isVector() && Phi->getParent() != TheLoop->getHeader())
       return (Phi->getNumIncomingValues() - 1) *
              TTI.getCmpSelInstrCost(
-                 Instruction::Select, ToVectorTy(Phi->getType(), VF),
+                 Instruction::Select, VecTy,
                  ToVectorTy(Type::getInt1Ty(Phi->getContext()), VF),
                  CmpInst::BAD_ICMP_PREDICATE, CostKind);
 
-    return TTI.getCFInstrCost(Instruction::PHI, CostKind);
+    SmallVector<TTI::OperandValueInfo, 4> OpInfos;
+    transform(I->operand_values(), std::back_inserter(OpInfos),
+              TTI::getOperandInfo);
+    return TTI.getPHICost(VecTy, CostKind, OpInfos);
   }
   case Instruction::UDiv:
   case Instruction::SDiv:
   case Instruction::URem:
   case Instruction::SRem:
     if (VF.isVector() && isPredicatedInst(I)) {
       const auto [ScalarCost, SafeDivisorCost] = getDivRemSpeculationCost(I, VF);
       return isDivRemScalarWithPredication(ScalarCost, SafeDivisorCost) ?