Define @llvm.ret.popless intrinsic, a ret that doesn't restore SP.

Marks the following ret instruction as a "popless" return, one that does
not not restore SP to its function-entry value (i.e., does not
deallocate the stack frame), allowing allocations made in the function
to be accessible by the caller.

The function must be annotated with an appropriate target-specific
calling convention, so the caller can generate stack accesses
accordingly, generally by treating the call as a variably-sized alloca,
so using FP-based addressing for its own frame rather than relying on
statically known SP offsets.

The single argument is forwarded as a return value, that must then be
used as the operand to the following ret instruction.

Calls to this intrinsic need to be musttail, but don't follow the other
ABI requirements for musttail calls, since this is really annotating the
ret.

This doesn't implement any lowering, but only adds the intrinsic
definition, basic verifier checks, and an inliner opt-out.

rdar://135984630

Author: ahmedbougacha

llvm/include/llvm/IR/Intrinsics.td

@@ -838,6 +838,20 @@ def int_localrecover : DefaultAttrsIntrinsic<[llvm_ptr_ty],
                                  [llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty],
                                  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
+// Marks the following ret instruction as a "popless" return, one that does not
+// not restore SP to its function-entry value (i.e., does not deallocate the
+// stack frame), allowing allocations made in the function to be accessible
+// by the caller.
+//
+// The function must be annotated with an appropriate target-specific calling
+// convention, so the caller can generate stack accesses accordingly, generally
+// by treating the call as a variably-sized alloca, so using FP-based addressing
+// for its own frame rather than relying on statically known SP offsets.
+//
+// Calls to this intrinsic need to be musttail, but don't follow the other ABI
+// requirements for musttail calls, since this is really annotating the ret.
+def int_ret_popless : DefaultAttrsIntrinsic<[], [], [IntrNoMem]>;
+
 // Given the frame pointer passed into an SEH filter function, returns a
 // pointer to the local variable area suitable for use with llvm.localrecover.
 def int_eh_recoverfp : DefaultAttrsIntrinsic<[llvm_ptr_ty],

llvm/lib/Analysis/InlineCost.cpp

@@ -2363,6 +2363,7 @@ bool CallAnalyzer::visitCallBase(CallBase &Call) {
       return false;
     case Intrinsic::icall_branch_funnel:
     case Intrinsic::localescape:
+    case Intrinsic::ret_popless:
       HasUninlineableIntrinsic = true;
       return false;
     case Intrinsic::vastart:

llvm/lib/IR/BasicBlock.cpp

@@ -306,6 +306,14 @@ const CallInst *BasicBlock::getTerminatingMustTailCall() const {
   if (!Prev)
     return nullptr;
 
+  // Some musttail intrinsic calls are special in being really simply ret
+  // annotations, and only need to be the last instruction before the ret.
+  // We don't need to look through the return value in those cases.
+  // FIXME: we should generalize getTerminatingDeoptimizeCall for this case.
+  if (auto *CI = dyn_cast<CallInst>(Prev))
+    if (CI->isMustTailCall() && CI->getIntrinsicID() == Intrinsic::ret_popless)
+      return CI;
+
   if (Value *RV = RI->getReturnValue()) {
     if (RV != Prev)
       return nullptr;

llvm/lib/IR/Verifier.cpp

@@ -3912,6 +3912,15 @@ void Verifier::verifyMustTailCall(CallInst &CI) {
             &CI);
     }
 #endif
+    Check(CI.getIntrinsicID() != Intrinsic::ret_popless,
+          "llvm.ret.popless call must be musttail", &CI);
+    return;
+  }
+
+  // Some musttail intrinsic calls are special, and don't have all the rules.
+  if (CI.getIntrinsicID() == Intrinsic::ret_popless) {
+    ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(CI.getNextNode());
+    Check(Ret, "musttail intrinsic call must precede a ret", &CI);
     return;
   }
 

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

@@ -1481,6 +1481,12 @@ static bool isSafeToHoistInstr(Instruction *I, unsigned Flags) {
     if (CB->getIntrinsicID() == Intrinsic::experimental_deoptimize)
       return false;
 
+  // Similarly for llvm.ret.popless (and likely generalizable to all musttail
+  // intrinsics).
+  if (auto *CB = dyn_cast<CallBase>(I))
+    if (CB->getIntrinsicID() == Intrinsic::ret_popless)
+      return false;
+
   // It's also unsafe/illegal to hoist an instruction above its instruction
   // operands
   BasicBlock *BB = I->getParent();

llvm/test/Verifier/ret_popless.ll

@@ -0,0 +1,14 @@
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
+
+define void @test_ret_popless_not_musttail() {
+; CHECK: llvm.ret.popless call must be musttail
+  call void @llvm.ret.popless()
+  ret void
+}
+
+define i64 @test_ret_popless_not_returned(i64 %a) {
+; CHECK: musttail intrinsic call must precede a ret
+  musttail call void @llvm.ret.popless()
+  %res = bitcast i64 %a to i64
+  ret i64 %res
+}