Rename llvm.recoverframeallocation to llvm.framerecover

This name is less descriptive, but it sort of puts things in the
'llvm.frame...' namespace, relating it to frameallocate and
frameaddress. It also avoids using "allocate" and "allocation" together.

llvm-svn: 225752

8 files changed, 24 insertions, 24 deletions

diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index 1735a8920a5..8ab199c552c 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -7281,7 +7281,7 @@ Note that calling this intrinsic does not prevent function inlining or
 other aggressive transformations, so the value returned may not be that
 of the obvious source-language caller.
 
-'``llvm.frameallocate``' and '``llvm.recoverframeallocation``' Intrinsics
+'``llvm.frameallocate``' and '``llvm.framerecover``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
@@ -7290,13 +7290,13 @@ Syntax:
 ::
 
       declare i8* @llvm.frameallocate(i32 %size)
-      declare i8* @llvm.recoverframeallocation(i8* %func, i8* %fp)
+      declare i8* @llvm.framerecover(i8* %func, i8* %fp)
 
 Overview:
 """""""""
 
 The '``llvm.frameallocate``' intrinsic allocates stack memory at some fixed
-offset from the frame pointer, and the '``llvm.recoverframeallocation``'
+offset from the frame pointer, and the '``llvm.framerecover``'
 intrinsic applies that offset to a live frame pointer to recover the address of
 the allocation. The offset is computed during frame layout of the caller of
 ``llvm.frameallocate``.
@@ -7308,12 +7308,12 @@ The ``size`` argument to '``llvm.frameallocate``' must be a constant integer
 indicating the amount of stack memory to allocate. As with allocas, allocating
 zero bytes is legal, but the result is undefined.
 
-The ``func`` argument to '``llvm.recoverframeallocation``' must be a constant
+The ``func`` argument to '``llvm.framerecover``' must be a constant
 bitcasted pointer to a function defined in the current module. The code
 generator cannot determine the frame allocation offset of functions defined in
 other modules.
 
-The ``fp`` argument to '``llvm.recoverframeallocation``' must be a frame
+The ``fp`` argument to '``llvm.framerecover``' must be a frame
 pointer of a call frame that is currently live. The return value of
 '``llvm.frameaddress``' is one way to produce such a value, but most platforms
 also expose the frame pointer through stack unwinding mechanisms.
@@ -7328,7 +7328,7 @@ memory is only aligned to the ABI-required stack alignment.  Each function may
 only call '``llvm.frameallocate``' one or zero times from the function entry
 block.  The frame allocation intrinsic inhibits inlining, as any frame
 allocations in the inlined function frame are likely to be at a different
-offset from the one used by '``llvm.recoverframeallocation``' called with the
+offset from the one used by '``llvm.framerecover``' called with the
 uninlined function.
 
 .. _int_read_register:
diff --git a/llvm/include/llvm/CodeGen/ISDOpcodes.h b/llvm/include/llvm/CodeGen/ISDOpcodes.h
index cbd1015975f..925f633c002 100644
--- a/llvm/include/llvm/CodeGen/ISDOpcodes.h
+++ b/llvm/include/llvm/CodeGen/ISDOpcodes.h
@@ -72,10 +72,10 @@ namespace ISD {
     /// the parent's frame or return address, and so on.
     FRAMEADDR, RETURNADDR,
 
-    /// RECOVER_FRAME_ALLOC - Represents the llvm.recoverframeallocation
+    /// FRAME_ALLOC_RECOVER - Represents the llvm.framerecover
     /// intrinsic. Materializes the offset from the frame pointer of another
     /// function to the result of llvm.frameallocate.
-    RECOVER_FRAME_ALLOC,
+    FRAME_ALLOC_RECOVER,
 
     /// READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on
     /// the DAG, which implements the named register global variables extension.
diff --git a/llvm/include/llvm/IR/Intrinsics.td b/llvm/include/llvm/IR/Intrinsics.td
index 01f7cfeaefd..a1188bccdc2 100644
--- a/llvm/include/llvm/IR/Intrinsics.td
+++ b/llvm/include/llvm/IR/Intrinsics.td
@@ -260,7 +260,7 @@ def int_gcwrite : Intrinsic<[],
 def int_returnaddress : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty], [IntrNoMem]>;
 def int_frameaddress  : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty], [IntrNoMem]>;
 def int_frameallocate : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty]>;
-def int_recoverframeallocation : Intrinsic<[llvm_ptr_ty],
+def int_framerecover : Intrinsic<[llvm_ptr_ty],
                                              [llvm_ptr_ty, llvm_ptr_ty],
                                              [IntrNoMem]>;
 def int_read_register  : Intrinsic<[llvm_anyint_ty], [llvm_metadata_ty],
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
index 8a762555577..068a5c4eb7e 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
@@ -5608,8 +5608,8 @@ SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I, unsigned Intrinsic) {
     return nullptr;
   }
 
-  case Intrinsic::recoverframeallocation: {
-    // i8* @llvm.recoverframeallocation(i8* %fn, i8* %fp)
+  case Intrinsic::framerecover: {
+    // i8* @llvm.framerecover(i8* %fn, i8* %fp)
     MachineFunction &MF = DAG.getMachineFunction();
     MVT PtrVT = TLI.getPointerTy(0);
 
@@ -5624,7 +5624,7 @@ SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I, unsigned Intrinsic) {
     assert(Name.size() == strlen(Name.data()) && "not null terminated");
     SDValue OffsetSym = DAG.getTargetExternalSymbol(Name.data(), PtrVT);
     SDValue OffsetVal =
-        DAG.getNode(ISD::RECOVER_FRAME_ALLOC, sdl, PtrVT, OffsetSym);
+        DAG.getNode(ISD::FRAME_ALLOC_RECOVER, sdl, PtrVT, OffsetSym);
 
     // Add the offset to the FP.
     Value *FP = I.getArgOperand(1);
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index 4a98b546099..e02b9e34fa6 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -2617,10 +2617,10 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
             "llvm.frameallocate argument must be constant integer size", &CI);
     break;
   }
-  case Intrinsic::recoverframeallocation: {
+  case Intrinsic::framerecover: {
     Value *FnArg = CI.getArgOperand(0)->stripPointerCasts();
     Function *Fn = dyn_cast<Function>(FnArg);
-    Assert1(Fn && !Fn->isDeclaration(), "llvm.recoverframeallocation first "
+    Assert1(Fn && !Fn->isDeclaration(), "llvm.framerecover first "
             "argument must be function defined in this module", &CI);
     break;
   }
diff --git a/llvm/lib/Target/X86/X86InstrInfo.td b/llvm/lib/Target/X86/X86InstrInfo.td
index 59301f9837d..53715dc6dd3 100644
--- a/llvm/lib/Target/X86/X86InstrInfo.td
+++ b/llvm/lib/Target/X86/X86InstrInfo.td
@@ -194,7 +194,7 @@ def X86rdpmc   : SDNode<"X86ISD::RDPMC_DAG", SDTX86Void,
 def X86Wrapper    : SDNode<"X86ISD::Wrapper",     SDTX86Wrapper>;
 def X86WrapperRIP : SDNode<"X86ISD::WrapperRIP",  SDTX86Wrapper>;
 
-def X86RecoverFrameAlloc : SDNode<"ISD::RECOVER_FRAME_ALLOC",
+def X86RecoverFrameAlloc : SDNode<"ISD::FRAME_ALLOC_RECOVER",
                                   SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
                                                        SDTCisInt<1>]>>;
 
diff --git a/llvm/test/CodeGen/X86/frameallocate.ll b/llvm/test/CodeGen/X86/frameallocate.ll
index 4adcf688a63..13d35b91937 100644
--- a/llvm/test/CodeGen/X86/frameallocate.ll
+++ b/llvm/test/CodeGen/X86/frameallocate.ll
@@ -2,13 +2,13 @@
 
 declare i8* @llvm.frameallocate(i32)
 declare i8* @llvm.frameaddress(i32)
-declare i8* @llvm.recoverframeallocation(i8*, i8*)
+declare i8* @llvm.framerecover(i8*, i8*)
 declare i32 @printf(i8*, ...)
 
 @str = internal constant [10 x i8] c"asdf: %d\0A\00"
 
 define void @print_framealloc_from_fp(i8* %fp) {
-  %alloc = call i8* @llvm.recoverframeallocation(i8* bitcast (void(i32*, i32*)* @alloc_func to i8*), i8* %fp)
+  %alloc = call i8* @llvm.framerecover(i8* bitcast (void(i32*, i32*)* @alloc_func to i8*), i8* %fp)
   %alloc_i32 = bitcast i8* %alloc to i32*
   %r = load i32* %alloc_i32
   call i32 (i8*, ...)* @printf(i8* getelementptr ([10 x i8]* @str, i32 0, i32 0), i32 %r)
diff --git a/llvm/test/Verifier/frameallocate.ll b/llvm/test/Verifier/frameallocate.ll
index 3a4258007fd..e3018db1527 100644
--- a/llvm/test/Verifier/frameallocate.ll
+++ b/llvm/test/Verifier/frameallocate.ll
@@ -1,7 +1,7 @@
 ; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
 
 declare i8* @llvm.frameallocate(i32)
-declare i8* @llvm.recoverframeallocation(i8*, i8*)
+declare i8* @llvm.framerecover(i8*, i8*)
 
 define internal void @f() {
   call i8* @llvm.frameallocate(i32 4)
@@ -26,23 +26,23 @@ not_entry:
 ; CHECK: llvm.frameallocate used outside of entry block
 
 define internal void @h() {
-  call i8* @llvm.recoverframeallocation(i8* null, i8* null)
+  call i8* @llvm.framerecover(i8* null, i8* null)
   ret void
 }
-; CHECK: llvm.recoverframeallocation first argument must be function defined in this module
+; CHECK: llvm.framerecover first argument must be function defined in this module
 
 @global = constant i8 0
 
 declare void @declaration()
 
 define internal void @i() {
-  call i8* @llvm.recoverframeallocation(i8* @global, i8* null)
+  call i8* @llvm.framerecover(i8* @global, i8* null)
   ret void
 }
-; CHECK: llvm.recoverframeallocation first argument must be function defined in this module
+; CHECK: llvm.framerecover first argument must be function defined in this module
 
 define internal void @j() {
-  call i8* @llvm.recoverframeallocation(i8* bitcast(void()* @declaration to i8*), i8* null)
+  call i8* @llvm.framerecover(i8* bitcast(void()* @declaration to i8*), i8* null)
   ret void
 }
-; CHECK: llvm.recoverframeallocation first argument must be function defined in this module
+; CHECK: llvm.framerecover first argument must be function defined in this module