[SLP] Account for phi cost in both scalar and vectors

[luke]

Summary

Use TTI::getPHICost to work out the cost of a phi instruction for
scalars and vectors, because they may not be free. Specifically, if the
phi has constant operands, there may be a cost to materializing them.

Fixes https://github.com/llvm/llvm-project/issues/62327

[luke]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

7334

I'm assuming here that all VLs must be a PHI at this point. Is this correct?

[luke]

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

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
   };
 
   switch (ShuffleOrOp) {
   case Instruction::PHI: {
     // Count reused scalars.
     InstructionCost ScalarCost = 0;
     SmallPtrSet<const TreeEntry *, 4> CountedOps;
     for (Value *V : VL) {
-      auto *PHI = dyn_cast<PHINode>(V);
-      if (!PHI)
-        continue;
+      auto *PHI = cast<PHINode>(V);
 
-      ValueList Operands(PHI->getNumIncomingValues(), nullptr);
-      for (unsigned I = 0, N = PHI->getNumIncomingValues(); I < N; ++I) {
-        Value *Op = PHI->getIncomingValue(I);
-        Operands[I] = Op;
-      }
+      ValueList Operands(PHI->incoming_values());
       if (const TreeEntry *OpTE = getTreeEntry(Operands.front()))
         if (OpTE->isSame(Operands) && CountedOps.insert(OpTE).second)
           if (!OpTE->ReuseShuffleIndices.empty())
-            ScalarCost += TTI::TCC_Basic * (OpTE->ReuseShuffleIndices.size() -
-                                            OpTE->Scalars.size());
+            ScalarCost +=
+                TTI->getPHICost(PHI->getType(), TTI::TCK_RecipThroughput) *
+                (OpTE->ReuseShuffleIndices.size() - OpTE->Scalars.size());
     }
 
-    return CommonCost - ScalarCost;
+    SmallVector<TTI::OperandValueInfo, 4> OpInfos;
+    for (unsigned I = 0; I < E->getMainOp()->getNumOperands(); I++)
+      OpInfos.push_back(getOperandInfo(VL, I));
+    InstructionCost VecCost =
+        TTI->getPHICost(VecTy, TTI::TCK_RecipThroughput, OpInfos);
+
+    return VecCost + CommonCost - ScalarCost;
   }
   case Instruction::ExtractValue:
   case Instruction::ExtractElement: {
     auto GetScalarCost = [=](unsigned Idx) {
       auto *I = cast<Instruction>(VL[Idx]);
       VectorType *SrcVecTy;
       if (ShuffleOrOp == Instruction::ExtractElement) {
         auto *EE = cast<ExtractElementInst>(I);

llvm/test/Transforms/SLPVectorizer/RISCV/phi-const.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt -passes=slp-vectorizer -S < %s -mtriple=riscv32 -mattr=+v \
 ; RUN:     -riscv-v-slp-max-vf=0 | FileCheck %s
 ; RUN: opt -passes=slp-vectorizer -S < %s -mtriple=riscv64 -mattr=+v \
 ; RUN:     -riscv-v-slp-max-vf=0 | FileCheck %s
 
 ; These shouldn't be vectorized as the cost of materializing the constants as
 ; vectors should outweigh the scalar cost
 
 define void @f(ptr %p, i1 %c) {
 ; CHECK-LABEL: define void @f
 ; CHECK-SAME: (ptr [[P:%.*]], i1 [[C:%.*]]) #[[ATTR0:[0-9]+]] {
 ; CHECK-NEXT:    [[P_0:%.*]] = getelementptr i8, ptr [[P]]
+; CHECK-NEXT:    [[P_1:%.*]] = getelementptr i8, ptr [[P]], i32 1
 ; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
 ; CHECK:       a:
 ; CHECK-NEXT:    br label [[D:%.*]]
 ; CHECK:       b:
 ; CHECK-NEXT:    br label [[D]]
 ; CHECK:       d:
-; CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x i8> [ <i8 1, i8 -1>, [[A]] ], [ <i8 -1, i8 1>, [[B]] ]
-; CHECK-NEXT:    store <2 x i8> [[TMP1]], ptr [[P_0]], align 1
+; CHECK-NEXT:    [[X:%.*]] = phi i8 [ 1, [[A]] ], [ -1, [[B]] ]
+; CHECK-NEXT:    [[Y:%.*]] = phi i8 [ -1, [[A]] ], [ 1, [[B]] ]
+; CHECK-NEXT:    store i8 [[X]], ptr [[P_0]], align 1
+; CHECK-NEXT:    store i8 [[Y]], ptr [[P_1]], align 1
 ; CHECK-NEXT:    ret void
 ;
   %p.0 = getelementptr i8, ptr %p
   %p.1 = getelementptr i8, ptr %p, i32 1
   br i1 %c, label %a, label %b
 a:
   br label %d
 b:
   br label %d
 d:
   %x = phi i8 [1, %a], [-1, %b]
   %y = phi i8 [-1, %a], [1, %b]
   store i8 %x, ptr %p.0
   store i8 %y, ptr %p.1
   ret void
 }
 
 define void @g(ptr %p, i1 %c) {
 ; CHECK-LABEL: define void @g
 ; CHECK-SAME: (ptr [[P:%.*]], i1 [[C:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[P_0:%.*]] = getelementptr i8, ptr [[P]]
+; CHECK-NEXT:    [[P_1:%.*]] = getelementptr i8, ptr [[P]], i32 1
 ; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
 ; CHECK:       a:
 ; CHECK-NEXT:    br label [[D:%.*]]
 ; CHECK:       b:
 ; CHECK-NEXT:    br label [[D]]
 ; CHECK:       d:
-; CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x i8> [ <i8 1, i8 -1>, [[A]] ], [ <i8 -1, i8 1>, [[B]] ]
-; CHECK-NEXT:    [[TMP2:%.*]] = add <2 x i8> [[TMP1]], <i8 1, i8 1>
-; CHECK-NEXT:    store <2 x i8> [[TMP2]], ptr [[P_0]], align 1
+; CHECK-NEXT:    [[X:%.*]] = phi i8 [ 1, [[A]] ], [ -1, [[B]] ]
+; CHECK-NEXT:    [[Y:%.*]] = phi i8 [ -1, [[A]] ], [ 1, [[B]] ]
+; CHECK-NEXT:    [[X_ADD:%.*]] = add i8 [[X]], 1
+; CHECK-NEXT:    [[Y_ADD:%.*]] = add i8 [[Y]], 1
+; CHECK-NEXT:    store i8 [[X_ADD]], ptr [[P_0]], align 1
+; CHECK-NEXT:    store i8 [[Y_ADD]], ptr [[P_1]], align 1
 ; CHECK-NEXT:    ret void
 ;
   %p.0 = getelementptr i8, ptr %p
   %p.1 = getelementptr i8, ptr %p, i32 1
   br i1 %c, label %a, label %b
 a:
   br label %d
 b: