[FuncSpec] Add Freeze and CallBase to the InstCostVisitor.

[labrinea]

Summary

Allows constant folding of such instructions when estimating user bonus.

[labrinea]

This is useful for SPEC2017:548.exchange2_r.

[labrinea]

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

237

This could perhaps be I.getNumOperands() - 1 but I see no harm as is in case NumOperands == 1 (call with no parameters, operands[0] is the calledOperand). Thinking more about it I believe that's an impossible scenario since we got here (visitCallBase) becase the call must have at least one parameter, so in total at least two operands. Unless the use which brought us here is the calledOperand operand itself. Hmm, don't know. Anyhow too much thinking for such a minor detail. Ignore me.

[ChuanqiXu]

LGTM with comments.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

241–243

nit:

llvm/unittests/Transforms/IPO/FunctionSpecializationTest.cpp

239–245

It will be better to test the invalid case. e.g., the freeze inst may be position or undef. And the call inst may not be constant. We can test that everything is still fine.

llvm/include/llvm/Transforms/IPO/FunctionSpecialization.h

 
 private:
   friend class InstVisitor<InstCostVisitor, Constant *>;
 
   Cost estimateSwitchInst(SwitchInst &I);
   Cost estimateBranchInst(BranchInst &I);
 
   Constant *visitInstruction(Instruction &I) { return nullptr; }
+  Constant *visitFreezeInst(FreezeInst &I);
+  Constant *visitCallBase(CallBase &I);
   Constant *visitLoadInst(LoadInst &I);
   Constant *visitGetElementPtrInst(GetElementPtrInst &I);
   Constant *visitSelectInst(SelectInst &I);
   Constant *visitCastInst(CastInst &I);
   Constant *visitCmpInst(CmpInst &I);
   Constant *visitUnaryOperator(UnaryOperator &I);
   Constant *visitBinaryOperator(BinaryOperator &I);
 };

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

Cost InstCostVisitor::estimateBranchInst(BranchInst &I) {
   SmallVector<BasicBlock *> WorkList;
   if (Solver.isBlockExecutable(Succ) &&
       Succ->getUniquePredecessor() == I.getParent())
     WorkList.push_back(Succ);
 
   return estimateBasicBlocks(WorkList, KnownConstants, Solver, BFI, TTI);
 }
 
+Constant *InstCostVisitor::visitFreezeInst(FreezeInst &I) {
+  if (isGuaranteedNotToBeUndefOrPoison(LastVisited->second))
+    return LastVisited->second;
+  return nullptr;
+}
+
+Constant *InstCostVisitor::visitCallBase(CallBase &I) {
+  Function *F = I.getCalledFunction();
+  if (!F || !canConstantFoldCallTo(&I, F))
+    return nullptr;
+
+  SmallVector<Constant *, 8> Operands;
+  Operands.reserve(I.getNumOperands());
+
+  for (unsigned Idx = 0, E = I.getNumOperands() - 1; Idx != E; ++Idx) {
+    Value *V = I.getOperand(Idx);
+    auto *C = dyn_cast<Constant>(V);
+    if (!C)
+      C = findConstantFor(V, KnownConstants);
+    if (!C)
+      return nullptr;
+    Operands.push_back(C);
+  }
+
+  auto Ops = ArrayRef(Operands.begin(), Operands.end());
+  return ConstantFoldCall(&I, F, Ops);
+}
+
 Constant *InstCostVisitor::visitLoadInst(LoadInst &I) {
   if (isa<ConstantPointerNull>(LastVisited->second))
     return nullptr;
   return ConstantFoldLoadFromConstPtr(LastVisited->second, I.getType(), DL);
 }
 
 Constant *InstCostVisitor::visitGetElementPtrInst(GetElementPtrInst &I) {
   SmallVector<Value *, 8> Operands;

llvm/unittests/Transforms/IPO/FunctionSpecializationTest.cpp

TEST_F(FunctionSpecializationTest, BranchInst) {
   EXPECT_EQ(Bonus, Ref);
   EXPECT_TRUE(Bonus > 0);
 }
 
 TEST_F(FunctionSpecializationTest, Misc) {
   const char *ModuleString = R"(
     @g = constant [2 x i32] zeroinitializer, align 4
 
-    define i32 @foo(i8 %a, i1 %cond, ptr %b) {
+    declare i32 @llvm.smax.i32(i32, i32)
+    declare i32 @bar(i32)
+
+    define i32 @foo(i8 %a, i1 %cond, ptr %b, i32 %c) {
       %cmp = icmp eq i8 %a, 10
       %ext = zext i1 %cmp to i32
       %sel = select i1 %cond, i32 %ext, i32 1
       %gep = getelementptr i32, ptr %b, i32 %sel
       %ld = load i32, ptr %gep
-      ret i32 %ld
+      %fr = freeze i32 %ld
+      %smax = call i32 @llvm.smax.i32(i32 %fr, i32 1)
+      %call = call i32 @bar(i32 %smax)
+      %fr2 = freeze i32 %c
+      %add = add i32 %call, %fr2
+      ret i32 %add
     }
   )";
 
   Module &M = parseModule(ModuleString);
   Function *F = M.getFunction("foo");
   FunctionSpecializer Specializer = getSpecializerFor(F);
   InstCostVisitor Visitor = Specializer.getInstCostVisitorFor(F);
 
   GlobalVariable *GV = M.getGlobalVariable("g");
   Constant *One = ConstantInt::get(IntegerType::getInt8Ty(M.getContext()), 1);
   Constant *True = ConstantInt::getTrue(M.getContext());
+  Constant *Undef = UndefValue::get(IntegerType::getInt32Ty(M.getContext()));
 
   auto BlockIter = F->front().begin();
   Instruction &Icmp = *BlockIter++;
   Instruction &Zext = *BlockIter++;
   Instruction &Select = *BlockIter++;
   Instruction &Gep = *BlockIter++;
   Instruction &Load = *BlockIter++;
+  Instruction &Freeze = *BlockIter++;
+  Instruction &Smax = *BlockIter++;
 
   // icmp + zext
   Cost Ref = getInstCost(Icmp) + getInstCost(Zext);
   Cost Bonus = Specializer.getSpecializationBonus(F->getArg(0), One, Visitor);
   EXPECT_EQ(Bonus, Ref);
   EXPECT_TRUE(Bonus > 0);
 
   // select
   Ref = getInstCost(Select);
   Bonus = Specializer.getSpecializationBonus(F->getArg(1), True, Visitor);
   EXPECT_EQ(Bonus, Ref);
   EXPECT_TRUE(Bonus > 0);
 
-  // gep + load
-  Ref = getInstCost(Gep) + getInstCost(Load);
+  // gep + load + freeze + smax
+  Ref = getInstCost(Gep) + getInstCost(Load) + getInstCost(Freeze) +
+        getInstCost(Smax);
   Bonus = Specializer.getSpecializationBonus(F->getArg(2), GV, Visitor);
   EXPECT_EQ(Bonus, Ref);
   EXPECT_TRUE(Bonus > 0);
+
+  Bonus = Specializer.getSpecializationBonus(F->getArg(3), Undef, Visitor);
+  EXPECT_TRUE(Bonus == 0);
 }