diff --git a/docs/LangRef.rst b/docs/LangRef.rst index 1735a8920a5..8ab199c552c 100644 --- a/docs/LangRef.rst +++ b/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/include/llvm/CodeGen/ISDOpcodes.h b/include/llvm/CodeGen/ISDOpcodes.h index cbd1015975f..925f633c002 100644 --- a/include/llvm/CodeGen/ISDOpcodes.h +++ b/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/include/llvm/IR/Intrinsics.td b/include/llvm/IR/Intrinsics.td index 01f7cfeaefd..a1188bccdc2 100644 --- a/include/llvm/IR/Intrinsics.td +++ b/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/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 8a762555577..068a5c4eb7e 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/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/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp index 4a98b546099..e02b9e34fa6 100644 --- a/lib/IR/Verifier.cpp +++ b/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(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/lib/Target/X86/X86InstrInfo.td b/lib/Target/X86/X86InstrInfo.td index 59301f9837d..53715dc6dd3 100644 --- a/lib/Target/X86/X86InstrInfo.td +++ b/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/test/CodeGen/X86/frameallocate.ll b/test/CodeGen/X86/frameallocate.ll index 4adcf688a63..13d35b91937 100644 --- a/test/CodeGen/X86/frameallocate.ll +++ b/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/test/Verifier/frameallocate.ll b/test/Verifier/frameallocate.ll index 3a4258007fd..e3018db1527 100644 --- a/test/Verifier/frameallocate.ll +++ b/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