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:
::
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``.
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.
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:
/// 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.
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],
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);
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);
"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;
}
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>]>>;
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)
; 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)
; 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