RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 11:02:59 +02:00
Code Issues Projects Releases Wiki Activity

Teach gcroot how to handle dynamically realigned frames

Browse Source 
I'm playing with supporting custom stack map formats with statepoints.  While 
doing so, I noticed that the existing implementation didn't indicate inherently 
unsized frames.  This change essentially just ports the functionality that already 
exists for the default StackMaps section to custom stackmaps.

llvm-svn: 233891
This commit is contained in:
Philip Reames 2015-04-02 05:00:40 +00:00
parent 29c7d72cfb
commit d3d2df55e2
2 changed files with 38 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
lib/CodeGen/GCRootLowering.cpp
View File

@ -332,19 +332,22 @@ bool GCMachineCodeAnalysis::runOnMachineFunction(MachineFunction &MF) {
return false;
FI = &getAnalysis<GCModuleInfo>().getFunctionInfo(*MF.getFunction());
if (!FI->getStrategy().needsSafePoints())
return false;
MMI = &getAnalysis<MachineModuleInfo>();
TII = MF.getSubtarget().getInstrInfo();
// Find the size of the stack frame.
FI->setFrameSize(MF.getFrameInfo()->getStackSize());
// Find the size of the stack frame. There may be no correct static frame
// size, we use UINT64_MAX to represent this.
const MachineFrameInfo *MFI = MF.getFrameInfo();
const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
const bool DynamicFrameSize = MFI->hasVarSizedObjects() ||
RegInfo->needsStackRealignment(MF);
FI->setFrameSize(DynamicFrameSize ? UINT64_MAX : MFI->getStackSize());
// Find all safe points.
FindSafePoints(MF);
if (FI->getStrategy().needsSafePoints())
FindSafePoints(MF);
// Find the stack offsets for all roots.
// Find the concrete stack offsets for all roots (stack slots)
FindStackOffsets(MF);
return false;

28
test/CodeGen/X86/GC/dynamic-frame-size.ll Normal file
View File

@ -0,0 +1,28 @@
; RUN: llc < %s | FileCheck %s
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
declare void @use(<4 x i8*>*)
; Test that a frame which requires dynamic relocation produces a stack map
; with a size of UINT64_MAX.
define void @test(i8* %ptr) gc "erlang" {
; 32 byte alignment (for the alloca) is larger than the default
; 16 byte alignment
%slot = alloca <4 x i8*>
call void @use(<4 x i8*>* %slot);
ret void
}
; CHECK: .note.gc
; CHECK-NEXT: .align 8
; safe point count
; CHECK .short 1
; CHECK .long .Ltmp0
; stack frame size (in words)
; CHECK .short -1
; stack arity (arguments on the stack)
; CHECK .short 0
; live root count
; CHECK .short 0