Don't insert lifetime.end markers between a musttail call and ret

[rnk]

Summary

The allocas going out of scope are immediately killed by the return
instruction.

[rnk]

• move llvm.stackrestore change here

[rnk]

Closed by commit rL208912 (authored by @rnk).

lib/Transforms/Utils/InlineFunction.cpp

for (unsigned ai = 0, ae = IFI.StaticAllocas.size(); ai != ae; ++ai) {
               UINT64_MAX / AllocaArraySize >= AllocaTypeSize) {
             AllocaSize = ConstantInt::get(Type::getInt64Ty(AI->getContext()),
                                           AllocaArraySize * AllocaTypeSize);
           }
         }
       }
 
       builder.CreateLifetimeStart(AI, AllocaSize);
-      for (ReturnInst *RI : Returns)
+      for (ReturnInst *RI : Returns) {
+        // Don't insert llvm.lifetime.end calls between a musttail call and a
+        // return.  The return kills all local allocas.
+        if (InlinedMustTailCalls && getPrecedingMustTailCall(RI))
+          continue;
         IRBuilder<>(RI).CreateLifetimeEnd(AI, AllocaSize);
       }
     }
+  }
 
   // If the inlined code contained dynamic alloca instructions, wrap the inlined
   // code with llvm.stacksave/llvm.stackrestore intrinsics.
   if (InlinedFunctionInfo.ContainsDynamicAllocas) {
     Module *M = Caller->getParent();
     // Get the two intrinsics we care about.
     Function *StackSave = Intrinsic::getDeclaration(M, Intrinsic::stacksave);
     Function *StackRestore=Intrinsic::getDeclaration(M,Intrinsic::stackrestore);
 
     // Insert the llvm.stacksave.
     CallInst *SavedPtr = IRBuilder<>(FirstNewBlock, FirstNewBlock->begin())
       .CreateCall(StackSave, "savedstack");
 
     // Insert a call to llvm.stackrestore before any return instructions in the
     // inlined function.
-    for (ReturnInst *RI : Returns)
+    for (ReturnInst *RI : Returns) {
+      // Don't insert llvm.stackrestore calls between a musttail call and a
+      // return.  The return will restore the stack pointer.
+      if (InlinedMustTailCalls && getPrecedingMustTailCall(RI))
+        continue;
       IRBuilder<>(RI).CreateCall(StackRestore, SavedPtr);
     }
+  }
 
   // If we are inlining for an invoke instruction, we must make sure to rewrite
   // any call instructions into invoke instructions.
   if (InvokeInst *II = dyn_cast<InvokeInst>(TheCall))
     HandleInlinedInvoke(II, FirstNewBlock, InlinedFunctionInfo);
 
   // Handle any inlined musttail call sites.  In order for a new call site to be
   // musttail, the source of the clone and the inlined call site must have been

test/Transforms/Inline/inline-tail.ll

define internal void @test_musttail_basic_b(i32* %p) {
   musttail call void @test_musttail_basic_c(i32* %p)
   ret void
 }
 define void @test_musttail_basic_a(i32* %p) {
   musttail call void @test_musttail_basic_b(i32* %p)
   ret void
 }
 
+; Don't insert lifetime end markers here, the lifetime is trivially over due
+; the return.
+; CHECK: define void @test_byval_a(
+; CHECK: musttail call void @test_byval_c(
+; CHECK-NEXT: ret void
+
+declare void @test_byval_c(i32* byval %p)
+define internal void @test_byval_b(i32* byval %p) {
+  musttail call void @test_byval_c(i32* byval %p)
+  ret void
+}
+define void @test_byval_a(i32* byval %p) {
+  musttail call void @test_byval_b(i32* byval %p)
+  ret void
+}
+
+; Don't insert a stack restore, we're about to return.
+; CHECK: define void @test_dynalloca_a(
+; CHECK: call i8* @llvm.stacksave(
+; CHECK: alloca i8, i32 %n
+; CHECK: musttail call void @test_dynalloca_c(
+; CHECK-NEXT: ret void
+
+declare void @escape(i8* %buf)
+declare void @test_dynalloca_c(i32* byval %p, i32 %n)
+define internal void @test_dynalloca_b(i32* byval %p, i32 %n) alwaysinline {
+  %buf = alloca i8, i32 %n              ; dynamic alloca
+  call void @escape(i8* %buf)           ; escape it
+  musttail call void @test_dynalloca_c(i32* byval %p, i32 %n)
+  ret void
+}
+define void @test_dynalloca_a(i32* byval %p, i32 %n) {
+  musttail call void @test_dynalloca_b(i32* byval %p, i32 %n)
+  ret void
+}
+
 ; We can't merge the returns.
 ; CHECK: define void @test_multiret_a(
 ; CHECK: musttail call void @test_multiret_c(
 ; CHECK-NEXT: ret void
 ; CHECK: musttail call void @test_multiret_d(
 ; CHECK-NEXT: ret void
 
 declare void @test_multiret_c(i1 zeroext %b)