maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[StatepointLowering] Support of the gc.relocates for invoke statepoints. 

This change implements support for lowering of the gc.relocates tied to the invoke statepoint.
This is acomplished by storing frame indices of the lowered values in "StatepointRelocatedValues" map inside FunctionLoweringInfo instead of storing them in per-basic block structure StatepointLowering.
After this change StatepointLowering is used only during "LowerStatepoint" call and it is not necessary to store it as a field in SelectionDAGBuilder anymore.

Differential Revision: http://reviews.llvm.org/D7798

llvm-svn: 237786
This commit is contained in:
Igor Laevsky 2015-05-20 11:37:25 +00:00
parent 5db5d2da13
commit 423bc9ec4c
5 changed files with 252 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
llvm/include/llvm/CodeGen/FunctionLoweringInfo.h
View File

@ -18,6 +18,7 @@
#include "llvm/ADT/APInt.h" #include "llvm/ADT/APInt.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/IndexedMap.h" #include "llvm/ADT/IndexedMap.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/CodeGen/ISDOpcodes.h" #include "llvm/CodeGen/ISDOpcodes.h"
@ -73,6 +74,16 @@ public:
/// cross-basic-block values. /// cross-basic-block values.
DenseMap<const Value*, unsigned> ValueMap; DenseMap<const Value*, unsigned> ValueMap;
// Keep track of frame indices allocated for statepoints as they could be used
// across basic block boundaries.
// Key of the map is statepoint instruction, value is a map from spilled
// llvm Value to the optional stack stack slot index.
// If optional is unspecified it means that we have visited this value
// but didn't spill it.
typedef DenseMap<const Value*, Optional<int>> StatepointSpilledValueMapTy;
DenseMap<const Instruction*, StatepointSpilledValueMapTy>
StatepointRelocatedValues;
/// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
/// the entry block. This allows the allocas to be efficiently referenced /// the entry block. This allows the allocas to be efficiently referenced
/// anywhere in the function. /// anywhere in the function.

1
llvm/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
View File

@ -579,6 +579,7 @@ void FunctionLoweringInfo::clear() {
ByValArgFrameIndexMap.clear(); ByValArgFrameIndexMap.clear();
RegFixups.clear(); RegFixups.clear();
StatepointStackSlots.clear(); StatepointStackSlots.clear();
StatepointRelocatedValues.clear();
PreferredExtendType.clear(); PreferredExtendType.clear();
} }

109
llvm/lib/CodeGen/SelectionDAG/StatepointLowering.cpp
View File

@ -51,7 +51,6 @@ void StatepointLoweringState::startNewStatepoint(SelectionDAGBuilder &Builder) {
assert(PendingGCRelocateCalls.empty() && assert(PendingGCRelocateCalls.empty() &&
"Trying to visit statepoint before finished processing previous one"); "Trying to visit statepoint before finished processing previous one");
Locations.clear(); Locations.clear();
RelocLocations.clear();
NextSlotToAllocate = 0; NextSlotToAllocate = 0;
// Need to resize this on each safepoint - we need the two to stay in // Need to resize this on each safepoint - we need the two to stay in
// sync and the clear patterns of a SelectionDAGBuilder have no relation // sync and the clear patterns of a SelectionDAGBuilder have no relation
@ -61,9 +60,9 @@ void StatepointLoweringState::startNewStatepoint(SelectionDAGBuilder &Builder) {
AllocatedStackSlots[i] = false; AllocatedStackSlots[i] = false;
} }
} }
void StatepointLoweringState::clear() { void StatepointLoweringState::clear() {
Locations.clear(); Locations.clear();
RelocLocations.clear();
AllocatedStackSlots.clear(); AllocatedStackSlots.clear();
assert(PendingGCRelocateCalls.empty() && assert(PendingGCRelocateCalls.empty() &&
"cleared before statepoint sequence completed"); "cleared before statepoint sequence completed");
@ -527,6 +526,41 @@ static void lowerStatepointMetaArgs(SmallVectorImpl<SDValue> &Ops,
Incoming.getValueType())); Incoming.getValueType()));
} }
} }
// Record computed locations for all lowered values.
// This can not be embedded in lowering loops as we need to record *all*
// values, while previous loops account only values with unique SDValues.
const Instruction *StatepointInstr =
StatepointSite.getCallSite().getInstruction();
FunctionLoweringInfo::StatepointSpilledValueMapTy &SpillMap =
Builder.FuncInfo.StatepointRelocatedValues[StatepointInstr];
for (GCRelocateOperands RelocateOpers :
StatepointSite.getRelocates(StatepointSite)) {
const Value *V = RelocateOpers.getDerivedPtr();
SDValue SDV = Builder.getValue(V);
SDValue Loc = Builder.StatepointLowering.getLocation(SDV);
if (Loc.getNode()) {
SpillMap[V] = cast<FrameIndexSDNode>(Loc)->getIndex();
} else {
// Record value as visited, but not spilled. This is case for allocas
// and constants. For this values we can avoid emiting spill load while
// visiting corresponding gc_relocate.
// Actually we do not need to record them in this map at all.
// We do this only to check that we are not relocating any unvisited value.
SpillMap[V] = None;
// Default llvm mechanisms for exporting values which are used in
// different basic blocks does not work for gc relocates.
// Note that it would be incorrect to teach llvm that all relocates are
// uses of the corresponging values so that it would automatically
// export them. Relocates of the spilled values does not use original
// value.
if (StatepointSite.getCallSite().isInvoke())
Builder.ExportFromCurrentBlock(V);
}
}
} }
void SelectionDAGBuilder::visitStatepoint(const CallInst &CI) { void SelectionDAGBuilder::visitStatepoint(const CallInst &CI) {
@ -550,11 +584,14 @@ void SelectionDAGBuilder::LowerStatepoint(
ImmutableCallSite CS(ISP.getCallSite()); ImmutableCallSite CS(ISP.getCallSite());
#ifndef NDEBUG #ifndef NDEBUG
// Consistency check // Consistency check. Don't do this for invokes. It would be too
for (const User *U : CS->users()) { // expensive to preserve this information across different basic blocks
const CallInst *Call = cast<CallInst>(U); if (!CS.isInvoke()) {
if (isGCRelocate(Call)) for (const User *U : CS->users()) {
StatepointLowering.scheduleRelocCall(*Call); const CallInst *Call = cast<CallInst>(U);
if (isGCRelocate(Call))
StatepointLowering.scheduleRelocCall(*Call);
}
} }
#endif #endif
@ -756,42 +793,50 @@ void SelectionDAGBuilder::visitGCResult(const CallInst &CI) {
} }
void SelectionDAGBuilder::visitGCRelocate(const CallInst &CI) { void SelectionDAGBuilder::visitGCRelocate(const CallInst &CI) {
GCRelocateOperands RelocateOpers(&CI);
#ifndef NDEBUG #ifndef NDEBUG
// Consistency check // Consistency check
StatepointLowering.relocCallVisited(CI); // We skip this check for invoke statepoints. It would be too expensive to
// preserve validation info through different basic blocks.
if (!RelocateOpers.isTiedToInvoke()) {
StatepointLowering.relocCallVisited(CI);
}
#endif #endif
GCRelocateOperands relocateOpers(&CI); const Value *DerivedPtr = RelocateOpers.getDerivedPtr();
SDValue SD = getValue(relocateOpers.getDerivedPtr()); SDValue SD = getValue(DerivedPtr);
if (isa<ConstantSDNode>(SD) || isa<FrameIndexSDNode>(SD)) { FunctionLoweringInfo::StatepointSpilledValueMapTy &SpillMap =
// We didn't need to spill these special cases (constants and allocas). FuncInfo.StatepointRelocatedValues[RelocateOpers.getStatepoint()];
// See the handling in spillIncomingValueForStatepoint for detail.
// We should have recorded location for this pointer
assert(SpillMap.count(DerivedPtr) && "Relocating not lowered gc value");
Optional<int> DerivedPtrLocation = SpillMap[DerivedPtr];
// We didn't need to spill these special cases (constants and allocas).
// See the handling in spillIncomingValueForStatepoint for detail.
if (!DerivedPtrLocation) {
setValue(&CI, SD); setValue(&CI, SD);
return; return;
} }
SDValue Loc = StatepointLowering.getRelocLocation(SD); SDValue SpillSlot = DAG.getTargetFrameIndex(*DerivedPtrLocation,
// Emit new load if we did not emit it before SD.getValueType());
if (!Loc.getNode()) {
SDValue SpillSlot = StatepointLowering.getLocation(SD);
int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
// Be conservative: flush all pending loads // Be conservative: flush all pending loads
// TODO: Probably we can be less restrictive on this, // TODO: Probably we can be less restrictive on this,
// it may allow more scheduling opprtunities // it may allow more scheduling opprtunities
SDValue Chain = getRoot(); SDValue Chain = getRoot();
Loc = DAG.getLoad(SpillSlot.getValueType(), getCurSDLoc(), Chain, SpillSlot, SDValue SpillLoad =
MachinePointerInfo::getFixedStack(FI), false, false, DAG.getLoad(SpillSlot.getValueType(), getCurSDLoc(), Chain, SpillSlot,
false, 0); MachinePointerInfo::getFixedStack(*DerivedPtrLocation),
false, false, false, 0);
StatepointLowering.setRelocLocation(SD, Loc); // Again, be conservative, don't emit pending loads
DAG.setRoot(SpillLoad.getValue(1));
// Again, be conservative, don't emit pending loads assert(SpillLoad.getNode());
DAG.setRoot(Loc.getValue(1)); setValue(&CI, SpillLoad);
}
assert(Loc.getNode());
setValue(&CI, Loc);
} }

21
llvm/lib/CodeGen/SelectionDAG/StatepointLowering.h
View File

@ -56,25 +56,6 @@ public:
Locations[val] = Location; Locations[val] = Location;
} }
/// Returns the relocated value for a given input pointer. Will
/// return SDValue() if this value hasn't yet been reloaded from
/// it's stack slot after the statepoint. Otherwise, the value
/// has already been reloaded and the SDValue of that reload will
/// be returned. Note that VMState values are spilled but not
/// reloaded (since they don't change at the safepoint unless
/// also listed in the GC pointer section) and will thus never
/// be in this map
SDValue getRelocLocation(SDValue val) {
if (!RelocLocations.count(val))
return SDValue();
return RelocLocations[val];
}
void setRelocLocation(SDValue val, SDValue Location) {
assert(!RelocLocations.count(val) &&
"Trying to allocate already allocated location");
RelocLocations[val] = Location;
}
/// Record the fact that we expect to encounter a given gc_relocate /// Record the fact that we expect to encounter a given gc_relocate
/// before the next statepoint. If we don't see it, we'll report /// before the next statepoint. If we don't see it, we'll report
/// an assertion. /// an assertion.
@ -117,8 +98,6 @@ private:
/// Maps pre-relocation value (gc pointer directly incoming into statepoint) /// Maps pre-relocation value (gc pointer directly incoming into statepoint)
/// into it's location (currently only stack slots) /// into it's location (currently only stack slots)
DenseMap<SDValue, SDValue> Locations; DenseMap<SDValue, SDValue> Locations;
/// Map pre-relocated value into it's new relocated location
DenseMap<SDValue, SDValue> RelocLocations;
/// A boolean indicator for each slot listed in the FunctionInfo as to /// A boolean indicator for each slot listed in the FunctionInfo as to
/// whether it has been used in the current statepoint. Since we try to /// whether it has been used in the current statepoint. Since we try to

168
llvm/test/CodeGen/X86/statepoint-invoke.ll
View File

@ -2,11 +2,49 @@
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
declare void @"some_call"(i64 addrspace(1)*)
declare i64 addrspace(1)* @"some_other_call"(i64 addrspace(1)*) declare i64 addrspace(1)* @"some_other_call"(i64 addrspace(1)*)
declare i32 @"personality_function"() declare i32 @"personality_function"()
define i64 addrspace(1)* @test_result(i64 addrspace(1)* %obj, define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj,
i64 addrspace(1)* %obj1)
gc "statepoint-example" {
entry:
; CHECK: Ltmp{{[0-9]+}}:
; CHECK: callq some_call
; CHECK: Ltmp{{[0-9]+}}:
%0 = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
to label %invoke_safepoint_normal_dest unwind label %exceptional_return
invoke_safepoint_normal_dest:
; CHECK: movq
%obj.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %0, i32 13, i32 13)
%obj1.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %0, i32 14, i32 14)
br label %normal_return
normal_return:
; CHECK: retq
ret i64 addrspace(1)* %obj.relocated
exceptional_return:
; CHECK: Ltmp{{[0-9]+}}:
; CHECK: movq
; CHECK: retq
%landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
cleanup
%relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
%obj.relocated1 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
%obj1.relocated1 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 14, i32 14)
ret i64 addrspace(1)* %obj1.relocated1
}
; CHECK-LABEL: GCC_except_table{{[0-9]+}}:
; CHECK: .long .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
; CHECK: .long .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
; CHECK: .byte 0
; CHECK: .align 4
define i64 addrspace(1)* @test_result(i64 addrspace(1)* %obj,
i64 addrspace(1)* %obj1) i64 addrspace(1)* %obj1)
gc "statepoint-example" { gc "statepoint-example" {
entry: entry:
@ -24,11 +62,12 @@ normal_return:
exceptional_return: exceptional_return:
; CHECK: .Ltmp{{[0-9]+}}: ; CHECK: .Ltmp{{[0-9]+}}:
; CHECK: popq ; CHECK: movq
; CHECK: retq
%landing_pad = landingpad { i8*, i32 } personality i32 ()* @personality_function %landing_pad = landingpad { i8*, i32 } personality i32 ()* @personality_function
cleanup cleanup
ret i64 addrspace(1)* %obj %relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
%obj.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
ret i64 addrspace(1)* %obj.relocated
} }
; CHECK-LABEL: GCC_except_table{{[0-9]+}}: ; CHECK-LABEL: GCC_except_table{{[0-9]+}}:
; CHECK: .long .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}} ; CHECK: .long .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
@ -36,5 +75,124 @@ exceptional_return:
; CHECK: .byte 0 ; CHECK: .byte 0
; CHECK: .align 4 ; CHECK: .align 4
define i64 addrspace(1)* @test_same_val(i1 %cond, i64 addrspace(1)* %val1, i64 addrspace(1)* %val2, i64 addrspace(1)* %val3)
gc "statepoint-example" {
entry:
br i1 %cond, label %left, label %right
left:
; CHECK-LABEL: %left
; CHECK: movq %rdx, 8(%rsp)
; CHECK: movq
; CHECK: callq some_call
%sp1 = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %val1, i64 addrspace(1)* %val2)
to label %left.relocs unwind label %exceptional_return.left
left.relocs:
; CHECK: movq (%rsp),
; CHECK: movq 8(%rsp), [[REGVAL2:%[a-z]+]]
%val1.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp1, i32 13, i32 13)
%val2.relocated_left = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp1, i32 14, i32 14)
br label %normal_return
right:
; CHECK-LABEL: %right
; CHECK: movq
; CHECK: movq %rdx, (%rsp)
; CHECK: callq some_call
%sp2 = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %val2, i64 addrspace(1)* %val3)
to label %right.relocs unwind label %exceptional_return.right
right.relocs:
; CHECK: movq (%rsp), [[REGVAL2]]
; CHECK: movq
%val2.relocated_right = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp2, i32 13, i32 13)
%val3.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp2, i32 14, i32 14)
br label %normal_return
normal_return:
; CHECK-LABEL: %normal_return
; CHECK: cmoveq {{.*}}[[REGVAL2]]{{.*}}
; CHECK retq
%a1 = phi i64 addrspace(1)* [%val1.relocated, %left.relocs], [%val3.relocated, %right.relocs]
%a2 = phi i64 addrspace(1)* [%val2.relocated_left, %left.relocs], [%val2.relocated_right, %right.relocs]
%ret = select i1 %cond, i64 addrspace(1)* %a1, i64 addrspace(1)* %a2
ret i64 addrspace(1)* %ret
exceptional_return.left:
%landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
cleanup
%relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
%val.relocated2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
ret i64 addrspace(1)* %val.relocated2
exceptional_return.right:
%landing_pad1 = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
cleanup
%relocate_token1 = extractvalue { i8*, i32 } %landing_pad1, 1
%val.relocated3 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token1, i32 13, i32 13)
ret i64 addrspace(1)* %val.relocated3
}
define i64 addrspace(1)* @test_null_undef(i64 addrspace(1)* %val1)
gc "statepoint-example" {
; CHECK-LABEL: test_null_undef:
entry:
; CHECK: callq some_call
%sp1 = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* null, i64 addrspace(1)* undef)
to label %normal_return unwind label %exceptional_return
normal_return:
; CHECK-LABEL: %normal_return
; CHECK: xorl %eax, %eax
; CHECK-NEXT: popq
; CHECK-NEXT: retq
%null.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp1, i32 13, i32 13)
%undef.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp1, i32 14, i32 14)
ret i64 addrspace(1)* %null.relocated
exceptional_return:
%landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
cleanup
%relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
%null.relocated2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
%undef.relocated2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 14, i32 14)
ret i64 addrspace(1)* %null.relocated2
}
define i64 addrspace(1)* @test_alloca_and_const(i64 addrspace(1)* %val1)
gc "statepoint-example" {
; CHECK-LABEL: test_alloca_and_const:
entry:
%a = alloca i32
%aa = addrspacecast i32* %a to i32 addrspace(1)*
%c = inttoptr i64 15 to i64 addrspace(1)*
; CHECK: callq
%sp = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %aa, i64 addrspace(1)* %c)
to label %normal_return unwind label %exceptional_return
normal_return:
; CHECK: leaq
; CHECK-NEXT: popq
; CHECK-NEXT: retq
%aa.rel = call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %sp, i32 13, i32 13)
%aa.converted = bitcast i32 addrspace(1)* %aa.rel to i64 addrspace(1)*
ret i64 addrspace(1)* %aa.converted
exceptional_return:
; CHECK: movl $15
; CHECK-NEXT: popq
; CHECK-NEXT: retq
%landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
cleanup
%relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
%aa.rel2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 14, i32 14)
ret i64 addrspace(1)* %aa.rel2
}
declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...)
declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...)
declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32)
declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32, i32, i32)
declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)
declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32)