CodeGen: allow a `musttail` call to be followed by `unreachable`

[t.p.northover]

Summary

If the function being called is noreturn it's functionally correct to have a tail call followed by unreachable. It appears to be avoided for normal tail calls for performance reasons, but it's allowed in other guaranteed TCO cases, so I don't think there's any reason to restrict musttail.

[t.p.northover]

Ping.

[efriedma]

Missing LangRef update.

It's hard for me to imagine this significantly helps optimizations, but I don't think it will cause any problems.

llvm/lib/CodeGen/Analysis.cpp

bool llvm::isInTailCallPosition(const CallBase &Call, const TargetMachine &TM) {
   //
   // FIXME: Decline tailcall if it's not guaranteed and if the block ends in
   // an unreachable, for now. The way tailcall optimization is currently
   // implemented means it will add an epilogue followed by a jump. That is
   // not profitable. Also, if the callee is a special function (e.g.
   // longjmp on x86), it can end up causing miscompilation that has not
   // been fully understood.
   if (!Ret && ((!TM.Options.GuaranteedTailCallOpt &&
+                !Call.isMustTailCall() &&
                 Call.getCallingConv() != CallingConv::Tail &&
                 Call.getCallingConv() != CallingConv::SwiftTail) ||
                !isa<UnreachableInst>(Term)))
     return false;
 
   // If I will have a chain, make sure no other instruction that will have a
   // chain interposes between I and the return.
   // Check for all calls including speculatable functions.

llvm/lib/IR/Verifier.cpp

void Verifier::verifyMustTailCall(CallInst &CI) {
   if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
     Check(BI->getOperand(0) == RetVal,
           "bitcast following musttail call must use the call", BI);
     RetVal = BI;
     Next = BI->getNextNode();
   }
 
   // Check the return.
-  ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
-  Check(Ret, "musttail call must precede a ret with an optional bitcast", &CI);
+  if (ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next)) {
     Check(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal ||
             isa<UndefValue>(Ret->getReturnValue()),
         "musttail call result must be returned", Ret);
+  } else if (!Next || !isa<UnreachableInst>(Next))
+    CheckFailed("musttail call must precede a ret or unreachable with an "
+                "optional bitcast");
 
   AttributeList CallerAttrs = F->getAttributes();
   AttributeList CalleeAttrs = CI.getAttributes();
   if (CI.getCallingConv() == CallingConv::SwiftTail ||
       CI.getCallingConv() == CallingConv::Tail) {
     StringRef CCName =
         CI.getCallingConv() == CallingConv::Tail ? "tailcc" : "swifttailcc";
 

llvm/test/CodeGen/AArch64/musttail-noreturn.ll

+; RUN: llc -mtriple=aarch64-linux-gnu %s -o  - | FileCheck %s
+
+define void @caller() {
+; CHECK: caller:
+; CHECK:     b callee
+  musttail call void @callee() noreturn
+  unreachable
+}
+
+declare void @callee() noreturn

llvm/test/CodeGen/ARM/musttail-noreturn.ll

+; RUN: llc -mtriple=thumbv7k-apple-watchos4 %s -o  - | FileCheck %s
+
+define void @caller() {
+; CHECK: caller:
+; CHECK:     b.w _callee
+  musttail call void @callee() noreturn
+  unreachable
+}
+
+declare void @callee() noreturn

llvm/test/CodeGen/X86/musttail-noreturn.ll

+; RUN: llc -mtriple=x86_64-linux-gnu %s -o  - | FileCheck %s
+
+define void @caller() {
+; CHECK: caller:
+; CHECK:     jmp callee
+  musttail call void @callee() noreturn
+  unreachable
+}
+
+declare void @callee() noreturn

llvm/test/Verifier/musttail-invalid.ll

 define void @mismatched_alignment(i32* byval(i32) align 4 %a) {
 ; CHECK: mismatched ABI impacting function attributes
   musttail call void @mismatched_alignment_callee(i32* byval(i32) align 8 %a)
   ret void
 }
 
 declare i32 @not_tail_pos_callee()
 define i32 @not_tail_pos() {
-; CHECK: musttail call must precede a ret with an optional bitcast
+; CHECK: musttail call must precede a ret or unreachable with an optional bitcast
   %v = musttail call i32 @not_tail_pos_callee()
   %w = add i32 %v, 1
   ret i32 %w
 }
 
 define void @inline_asm() {
 ; CHECK: cannot use musttail call with inline asm
   musttail call void asm "ret", ""()
   ret void
 }

llvm/test/Verifier/musttail-valid.ll

 }
 
 define x86_thiscallcc void @varargs_thiscall_ret_unreachable(i8* %this, ...) {
   musttail call x86_thiscallcc void (i8*, ...) @varargs_thiscall(i8* %this, ...)
   ret void
 bb1:
   ret void
 }
+
+define void @noreturn_caller() {
+  musttail call void @noreturn_callee() noreturn
+  unreachable
+}
+declare void @noreturn_callee() noreturn