[CodeGen/Analysis] Intrinsic llvm.assume should not block tail call optimization

[Carrot]

Summary

In function Analysis.cpp:isInTailCallPosition, instructions between call and ret are checked to see if they block tail call optimization. If an instruction is an intrinsic call, only llvm.lifetime_end is allowed and other intrinsic functions block tail call. When compiling tcmalloc, we found llvm.assume between a hot function call and ret, it blocks the optimization. But llvm.assume doesn't generate instructions, it should not block tail call.

[xbolva00]

lib/CodeGen/Analysis.cpp

539 ↗

(On Diff #214663)

Update comment

[xbolva00]

Makes sense

[Carrot]

Will commit this version.

[xbolva00]

Ok

[xbolva00]

https://bugs.llvm.org/show_bug.cgi?id=43007 should be fixed too

[jdoerfert]

In D66096#1631800, @xbolva00 wrote:

https://bugs.llvm.org/show_bug.cgi?id=43007 should be fixed too

I'm pretty sure it will not fix the issue. A possible test case would look like:

define i8* @foo() {
  %1 = tail call i8* @bar()
  %2 = icmp eq i8* %1, null
  tail call void @llvm.assume(i1 %2)
  ret i8* null
}

[xbolva00]

Yes! There is a new PR and I just realized how big issue we have here (we may call functions which are never called in source code) :[

We need to remove all llvm.assumes in CGP.

[xbolva00]

(That issue needs a separate patch anyway).

Please go ahead with this patch.

llvm/trunk/lib/CodeGen/Analysis.cpp

bool llvm::isInTailCallPosition(ImmutableCallSite CS, const TargetMachine &TM) {
   if (I->mayHaveSideEffects() || I->mayReadFromMemory() ||
       !isSafeToSpeculativelyExecute(I))
     for (BasicBlock::const_iterator BBI = std::prev(ExitBB->end(), 2);; --BBI) {
       if (&*BBI == I)
         break;
       // Debug info intrinsics do not get in the way of tail call optimization.
       if (isa<DbgInfoIntrinsic>(BBI))
         continue;
-      // A lifetime end intrinsic should not stop tail call optimization.
+      // A lifetime end or assume intrinsic should not stop tail call
+      // optimization.
       if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(BBI))
-        if (II->getIntrinsicID() == Intrinsic::lifetime_end)
+        if (II->getIntrinsicID() == Intrinsic::lifetime_end ||
+            II->getIntrinsicID() == Intrinsic::assume)
           continue;
       if (BBI->mayHaveSideEffects() || BBI->mayReadFromMemory() ||
           !isSafeToSpeculativelyExecute(&*BBI))
         return false;
     }
 
   const Function *F = ExitBB->getParent();
   return returnTypeIsEligibleForTailCall(

llvm/trunk/test/CodeGen/X86/tailcall-assume.ll

+; RUN: llc -mtriple=x86_64-linux < %s | FileCheck %s
+
+; Intrinsic call to @llvm.assume should not prevent tail call optimization.
+; CHECK-LABEL: foo:
+; CHECK:       jmp bar # TAILCALL
+define i8* @foo() {
+  %1 = tail call i8* @bar()
+  %2 = icmp ne i8* %1, null
+  tail call void @llvm.assume(i1 %2)
+  ret i8* %1
+}
+
+declare i8* @bar()
+declare void @llvm.assume(i1)
+