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

This reverts commit 39998ff.

Author: ahmedbougacha

llvm/include/llvm/IR/Intrinsics.td

@@ -838,20 +838,6 @@ 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,7 +2363,6 @@ 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,14 +306,6 @@ 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,15 +3912,6 @@ 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,12 +1481,6 @@ 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();