[FuncSpec] Use std::pow instead of operator^

[ChuanqiXu]

Summary

The original implementation uses operator ^, which means XOR in C++ language.
At the first glance of reviewing, I thought it should be power, my bad.
It doesn't make sense to use XOR here. So I believe it should be a carelessness as I made.

Test Plan: check-all

[ChuanqiXu]

llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll

41–42

Now it couldn't specialize recursiveFunc due to the change of cost model. I would try to fix it by considering branch condition in getUserBonus.

[ChuanqiXu]

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

274

Converting to double here is to reduce the ambitious reloading.

[SjoerdMeijer]

llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll

3

Just checking, this test didn't trigger before, and now it does?
If so, would be good to precommit the test, then we can also see the differences better here.

llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll

41–42

I don't think it was able to specialise recursive (see also comment at the top).
I haven't looked very long at this, but something else must have led to different codegen.

[ChuanqiXu]

llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll

3

Yeah, I had checked that.

llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll

41–42

Yeah, I think the title is confusing. Function Specialization only did simple specialization without considering recursiveness (I don't know the noun form). Then the change in this test case looks good to me.

[ChuanqiXu]

llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll

3

Do you mean that send a NFC patch which contains the test case only? Then we tried to update this one, is it?

[SjoerdMeijer]

llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll

3

Yeah, I mean committing just the test first, then rebase this on top of that.
But with your confirmation that this now triggers and it didn't before, perhaps that's extra work we don't need, so you can commit this in one go.

This looks like a good fix to me.

[SjoerdMeijer]

llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll

4

Perhaps before committing rephrase this a bit:

check -> Check

and say something along the lines of:

Check that the loop depth results in a larger specialization bonus.

[ChuanqiXu]

Address the comments.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

 #include "llvm/Analysis/DomTreeUpdater.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Transforms/Scalar/SCCP.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/SizeOpts.h"
+#include <cmath>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "function-specialization"
 
 STATISTIC(NumFuncSpecialized, "Number of Functions Specialized");
 
 static cl::opt<bool> ForceFunctionSpecialization(
InstructionCost getUserBonus(User *U, llvm::TargetTransformInfo &TTI,
 
     // Traverse recursively if there are more uses.
     // TODO: Any other instructions to be added here?
     if (I->mayReadFromMemory() || I->isCast())
       for (auto *User : I->users())
         Cost += getUserBonus(User, TTI, LI);
 
     // Increase the cost if it is inside the loop.
-    auto LoopDepth = LI.getLoopDepth(I->getParent()) + 1;
-    Cost *= (AvgLoopIterationCount ^ LoopDepth);
+    auto LoopDepth = LI.getLoopDepth(I->getParent());
+    Cost *= std::pow((double)AvgLoopIterationCount, LoopDepth);
     return Cost;
   }
 
   /// Compute a bonus for replacing argument \p A with constant \p C.
   InstructionCost getSpecializationBonus(Argument *A, Constant *C) {
     Function *F = A->getParent();
     DominatorTree DT(*F);
     LoopInfo LI(DT);

llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll

+; RUN: opt -function-specialization -func-specialization-avg-iters-cost=3 -S < %s | FileCheck %s
+
+; Check that the loop depth results in a larger specialization bonus.
+; CHECK: @foo.1(
+; CHECK: @foo.2(
+
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+
+@A = external dso_local constant i32, align 4
+@B = external dso_local constant i32, align 4
+@C = external dso_local constant i32, align 4
+@D = external dso_local constant i32, align 4
+
+declare i1 @cond_begin()
+declare i1 @cond_end()
+declare i1 @getCond()
+
+define internal i32 @foo(i32 %x, i32* %b, i32* %c) {
+entry:
+  br label %loop.entry
+
+loop.entry:
+  br label %loop2.entry
+
+loop2.entry:
+  br label %loop2.body
+
+loop2.body:
+  %0 = load i32, i32* %b, align 4
+  %1 = load i32, i32* %c, align 4
+  %add.0 = add nsw i32 %0, %1
+  %add = add nsw i32 %add.0, %x
+  br label %loop2.end
+
+loop2.end:
+  %cond.end = call i1 @cond_end()
+  br i1 %cond.end, label %loop2.entry, label %loop.end
+
+loop.end:
+  %cond2.end = call i1 @getCond()
+  br i1 %cond2.end, label %loop.entry, label %return
+
+return:
+  ret i32 %add
+}
+
+define dso_local i32 @bar(i32 %x, i32 %y) {
+entry:
+  %tobool = icmp ne i32 %x, 0
+  br i1 %tobool, label %if.then, label %if.else
+
+if.then:
+  %call = call i32 @foo(i32 %x, i32* @A, i32* @C)
+  br label %return
+
+if.else:
+  %call1 = call i32 @foo(i32 %y, i32* @B, i32* @D)
+  br label %return
+
+return:
+  %retval.0 = phi i32 [ %call, %if.then ], [ %call1, %if.else ]
+  ret i32 %retval.0
+}
 No newline at end of file

llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll

block6:
   call void @recursiveFunc(i32* nonnull %temp)
   br label %ret.block
 
 ret.block:
   ret void
 }
 
 define i32 @main() {
 ; CHECK-LABEL: @main(
-; CHECK-NEXT:    [[TEMP_I:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[TEMP_I]] to i8*
-; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[TMP1]])
-; CHECK-NEXT:    call void @print_val(i32 1)
-; CHECK-NEXT:    store i32 2, i32* [[TEMP_I]], align 4
-; CHECK-NEXT:    call void @recursiveFunc(i32* nonnull [[TEMP_I]])
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i32* [[TEMP_I]] to i8*
-; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[TMP2]])
+; CHECK-NEXT:    call void @recursiveFunc(i32* nonnull @Global)
 ; CHECK-NEXT:    ret i32 0
 ;
   call void @recursiveFunc(i32* nonnull @Global)
   ret i32 0
 }
 
 declare dso_local void @print_val(i32)

llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll

 ; RUN: opt -function-specialization -func-specialization-avg-iters-cost=3 -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,DISABLED
-; RUN: opt -function-specialization -func-specialization-avg-iters-cost=4 -S < %s | \
-; RUN:   FileCheck %s --check-prefixes=COMMON,FORCE
 ; RUN: opt -function-specialization -force-function-specialization -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,FORCE
 ; RUN: opt -function-specialization -func-specialization-avg-iters-cost=3 -force-function-specialization -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,FORCE
 
 ; Test for specializing a constant global.
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"