LLVM  3.7.0
GCRootLowering.cpp
Go to the documentation of this file.
1 //===-- GCRootLowering.cpp - Garbage collection infrastructure ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the lowering for the gc.root mechanism.
11 //
12 //===----------------------------------------------------------------------===//
13 
20 #include "llvm/CodeGen/Passes.h"
21 #include "llvm/IR/Dominators.h"
22 #include "llvm/IR/IntrinsicInst.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/Support/Debug.h"
32 
33 using namespace llvm;
34 
35 namespace {
36 
37 /// LowerIntrinsics - This pass rewrites calls to the llvm.gcread or
38 /// llvm.gcwrite intrinsics, replacing them with simple loads and stores as
39 /// directed by the GCStrategy. It also performs automatic root initialization
40 /// and custom intrinsic lowering.
41 class LowerIntrinsics : public FunctionPass {
42  bool PerformDefaultLowering(Function &F, GCStrategy &Coll);
43 
44 public:
45  static char ID;
46 
47  LowerIntrinsics();
48  const char *getPassName() const override;
49  void getAnalysisUsage(AnalysisUsage &AU) const override;
50 
51  bool doInitialization(Module &M) override;
52  bool runOnFunction(Function &F) override;
53 };
54 
55 /// GCMachineCodeAnalysis - This is a target-independent pass over the machine
56 /// function representation to identify safe points for the garbage collector
57 /// in the machine code. It inserts labels at safe points and populates a
58 /// GCMetadata record for each function.
59 class GCMachineCodeAnalysis : public MachineFunctionPass {
60  GCFunctionInfo *FI;
61  MachineModuleInfo *MMI;
62  const TargetInstrInfo *TII;
63 
64  void FindSafePoints(MachineFunction &MF);
65  void VisitCallPoint(MachineBasicBlock::iterator MI);
67  DebugLoc DL) const;
68 
69  void FindStackOffsets(MachineFunction &MF);
70 
71 public:
72  static char ID;
73 
74  GCMachineCodeAnalysis();
75  void getAnalysisUsage(AnalysisUsage &AU) const override;
76 
77  bool runOnMachineFunction(MachineFunction &MF) override;
78 };
79 }
80 
81 // -----------------------------------------------------------------------------
82 
83 INITIALIZE_PASS_BEGIN(LowerIntrinsics, "gc-lowering", "GC Lowering", false,
84  false)
86 INITIALIZE_PASS_END(LowerIntrinsics, "gc-lowering", "GC Lowering", false, false)
87 
88 FunctionPass *llvm::createGCLoweringPass() { return new LowerIntrinsics(); }
89 
90 char LowerIntrinsics::ID = 0;
91 
92 LowerIntrinsics::LowerIntrinsics() : FunctionPass(ID) {
93  initializeLowerIntrinsicsPass(*PassRegistry::getPassRegistry());
94 }
95 
96 const char *LowerIntrinsics::getPassName() const {
97  return "Lower Garbage Collection Instructions";
98 }
99 
100 void LowerIntrinsics::getAnalysisUsage(AnalysisUsage &AU) const {
101  FunctionPass::getAnalysisUsage(AU);
104 }
105 
106 static bool NeedsDefaultLoweringPass(const GCStrategy &C) {
107  // Default lowering is necessary only if read or write barriers have a default
108  // action. The default for roots is no action.
109  return !C.customWriteBarrier() || !C.customReadBarrier() ||
110  C.initializeRoots();
111 }
112 
113 /// doInitialization - If this module uses the GC intrinsics, find them now.
114 bool LowerIntrinsics::doInitialization(Module &M) {
115  GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
116  assert(MI && "LowerIntrinsics didn't require GCModuleInfo!?");
117  for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
118  if (!I->isDeclaration() && I->hasGC())
119  MI->getFunctionInfo(*I); // Instantiate the GC strategy.
120 
121  return false;
122 }
123 
124 /// CouldBecomeSafePoint - Predicate to conservatively determine whether the
125 /// instruction could introduce a safe point.
127  // The natural definition of instructions which could introduce safe points
128  // are:
129  //
130  // - call, invoke (AfterCall, BeforeCall)
131  // - phis (Loops)
132  // - invoke, ret, unwind (Exit)
133  //
134  // However, instructions as seemingly inoccuous as arithmetic can become
135  // libcalls upon lowering (e.g., div i64 on a 32-bit platform), so instead
136  // it is necessary to take a conservative approach.
137 
138  if (isa<AllocaInst>(I) || isa<GetElementPtrInst>(I) || isa<StoreInst>(I) ||
139  isa<LoadInst>(I))
140  return false;
141 
142  // llvm.gcroot is safe because it doesn't do anything at runtime.
143  if (CallInst *CI = dyn_cast<CallInst>(I))
144  if (Function *F = CI->getCalledFunction())
145  if (Intrinsic::ID IID = F->getIntrinsicID())
146  if (IID == Intrinsic::gcroot)
147  return false;
148 
149  return true;
150 }
151 
153  unsigned Count) {
154  // Scroll past alloca instructions.
156  while (isa<AllocaInst>(IP))
157  ++IP;
158 
159  // Search for initializers in the initial BB.
160  SmallPtrSet<AllocaInst *, 16> InitedRoots;
161  for (; !CouldBecomeSafePoint(IP); ++IP)
162  if (StoreInst *SI = dyn_cast<StoreInst>(IP))
163  if (AllocaInst *AI =
164  dyn_cast<AllocaInst>(SI->getOperand(1)->stripPointerCasts()))
165  InitedRoots.insert(AI);
166 
167  // Add root initializers.
168  bool MadeChange = false;
169 
170  for (AllocaInst **I = Roots, **E = Roots + Count; I != E; ++I)
171  if (!InitedRoots.count(*I)) {
172  StoreInst *SI = new StoreInst(
173  ConstantPointerNull::get(cast<PointerType>(
174  cast<PointerType>((*I)->getType())->getElementType())),
175  *I);
176  SI->insertAfter(*I);
177  MadeChange = true;
178  }
179 
180  return MadeChange;
181 }
182 
183 /// runOnFunction - Replace gcread/gcwrite intrinsics with loads and stores.
184 /// Leave gcroot intrinsics; the code generator needs to see those.
185 bool LowerIntrinsics::runOnFunction(Function &F) {
186  // Quick exit for functions that do not use GC.
187  if (!F.hasGC())
188  return false;
189 
190  GCFunctionInfo &FI = getAnalysis<GCModuleInfo>().getFunctionInfo(F);
191  GCStrategy &S = FI.getStrategy();
192 
193  bool MadeChange = false;
194 
196  MadeChange |= PerformDefaultLowering(F, S);
197 
198  return MadeChange;
199 }
200 
201 bool LowerIntrinsics::PerformDefaultLowering(Function &F, GCStrategy &S) {
202  bool LowerWr = !S.customWriteBarrier();
203  bool LowerRd = !S.customReadBarrier();
204  bool InitRoots = S.initializeRoots();
205 
207 
208  bool MadeChange = false;
209  for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
210  for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E;) {
211  if (IntrinsicInst *CI = dyn_cast<IntrinsicInst>(II++)) {
212  Function *F = CI->getCalledFunction();
213  switch (F->getIntrinsicID()) {
214  case Intrinsic::gcwrite:
215  if (LowerWr) {
216  // Replace a write barrier with a simple store.
217  Value *St =
218  new StoreInst(CI->getArgOperand(0), CI->getArgOperand(2), CI);
219  CI->replaceAllUsesWith(St);
220  CI->eraseFromParent();
221  }
222  break;
223  case Intrinsic::gcread:
224  if (LowerRd) {
225  // Replace a read barrier with a simple load.
226  Value *Ld = new LoadInst(CI->getArgOperand(1), "", CI);
227  Ld->takeName(CI);
228  CI->replaceAllUsesWith(Ld);
229  CI->eraseFromParent();
230  }
231  break;
232  case Intrinsic::gcroot:
233  if (InitRoots) {
234  // Initialize the GC root, but do not delete the intrinsic. The
235  // backend needs the intrinsic to flag the stack slot.
236  Roots.push_back(
237  cast<AllocaInst>(CI->getArgOperand(0)->stripPointerCasts()));
238  }
239  break;
240  default:
241  continue;
242  }
243 
244  MadeChange = true;
245  }
246  }
247  }
248 
249  if (Roots.size())
250  MadeChange |= InsertRootInitializers(F, Roots.begin(), Roots.size());
251 
252  return MadeChange;
253 }
254 
255 // -----------------------------------------------------------------------------
256 
259 
260 INITIALIZE_PASS(GCMachineCodeAnalysis, "gc-analysis",
261  "Analyze Machine Code For Garbage Collection", false, false)
262 
263 GCMachineCodeAnalysis::GCMachineCodeAnalysis() : MachineFunctionPass(ID) {}
264 
265 void GCMachineCodeAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
266  MachineFunctionPass::getAnalysisUsage(AU);
267  AU.setPreservesAll();
270 }
271 
272 MCSymbol *GCMachineCodeAnalysis::InsertLabel(MachineBasicBlock &MBB,
274  DebugLoc DL) const {
276  BuildMI(MBB, MI, DL, TII->get(TargetOpcode::GC_LABEL)).addSym(Label);
277  return Label;
278 }
279 
280 void GCMachineCodeAnalysis::VisitCallPoint(MachineBasicBlock::iterator CI) {
281  // Find the return address (next instruction), too, so as to bracket the call
282  // instruction.
284  ++RAI;
285 
287  MCSymbol *Label = InsertLabel(*CI->getParent(), CI, CI->getDebugLoc());
288  FI->addSafePoint(GC::PreCall, Label, CI->getDebugLoc());
289  }
290 
292  MCSymbol *Label = InsertLabel(*CI->getParent(), RAI, CI->getDebugLoc());
293  FI->addSafePoint(GC::PostCall, Label, CI->getDebugLoc());
294  }
295 }
296 
297 void GCMachineCodeAnalysis::FindSafePoints(MachineFunction &MF) {
298  for (MachineFunction::iterator BBI = MF.begin(), BBE = MF.end(); BBI != BBE;
299  ++BBI)
300  for (MachineBasicBlock::iterator MI = BBI->begin(), ME = BBI->end();
301  MI != ME; ++MI)
302  if (MI->isCall()) {
303  // Do not treat tail or sibling call sites as safe points. This is
304  // legal since any arguments passed to the callee which live in the
305  // remnants of the callers frame will be owned and updated by the
306  // callee if required.
307  if (MI->isTerminator())
308  continue;
309  VisitCallPoint(MI);
310  }
311 }
312 
313 void GCMachineCodeAnalysis::FindStackOffsets(MachineFunction &MF) {
315  assert(TFI && "TargetRegisterInfo not available!");
316 
318  RI != FI->roots_end();) {
319  // If the root references a dead object, no need to keep it.
320  if (MF.getFrameInfo()->isDeadObjectIndex(RI->Num)) {
321  RI = FI->removeStackRoot(RI);
322  } else {
323  RI->StackOffset = TFI->getFrameIndexOffset(MF, RI->Num);
324  ++RI;
325  }
326  }
327 }
328 
329 bool GCMachineCodeAnalysis::runOnMachineFunction(MachineFunction &MF) {
330  // Quick exit for functions that do not use GC.
331  if (!MF.getFunction()->hasGC())
332  return false;
333 
334  FI = &getAnalysis<GCModuleInfo>().getFunctionInfo(*MF.getFunction());
335  MMI = &getAnalysis<MachineModuleInfo>();
336  TII = MF.getSubtarget().getInstrInfo();
337 
338  // Find the size of the stack frame. There may be no correct static frame
339  // size, we use UINT64_MAX to represent this.
340  const MachineFrameInfo *MFI = MF.getFrameInfo();
341  const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
342  const bool DynamicFrameSize = MFI->hasVarSizedObjects() ||
343  RegInfo->needsStackRealignment(MF);
344  FI->setFrameSize(DynamicFrameSize ? UINT64_MAX : MFI->getStackSize());
345 
346  // Find all safe points.
347  if (FI->getStrategy().needsSafePoints())
348  FindSafePoints(MF);
349 
350  // Find the concrete stack offsets for all roots (stack slots)
351  FindStackOffsets(MF);
352 
353  return false;
354 }
const MachineFunction * getParent() const
getParent - Return the MachineFunction containing this basic block.
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
iterator end()
Definition: Function.h:459
CallInst - This class represents a function call, abstracting a target machine's calling convention...
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:276
INITIALIZE_PASS(GCMachineCodeAnalysis,"gc-analysis","Analyze Machine Code For Garbage Collection", false, false) GCMachineCodeAnalysis
static bool CouldBecomeSafePoint(Instruction *I)
CouldBecomeSafePoint - Predicate to conservatively determine whether the instruction could introduce ...
A debug info location.
Definition: DebugLoc.h:34
F(f)
const Function * getFunction() const
getFunction - Return the LLVM function that this machine code represents
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
INITIALIZE_PASS_BEGIN(LowerIntrinsics,"gc-lowering","GC Lowering", false, false) FunctionPass *llvm
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects...
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
const HexagonInstrInfo * TII
FunctionPass * createGCLoweringPass()
GCLowering Pass - Used by gc.root to perform its default lowering operations.
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
GCFunctionInfo & getFunctionInfo(const Function &F)
get - Look up function metadata.
Definition: GCMetadata.cpp:61
void initializeLowerIntrinsicsPass(PassRegistry &)
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
An analysis pass which caches information about the entire Module.
Definition: GCMetadata.h:154
shadow stack gc lowering
#define false
Definition: ConvertUTF.c:65
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
MCContext & getContext() const
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:256
iterator begin()
Definition: Function.h:457
bool customReadBarrier() const
By default, read barriers are replaced with simple load instructions.
Definition: GCStrategy.h:111
TargetInstrInfo - Interface to description of machine instruction set.
bundle_iterator< MachineInstr, instr_iterator > iterator
roots_iterator roots_end()
Definition: GCMetadata.h:141
MCSymbol * createTempSymbol(bool CanBeUnnamed=true)
Create and return a new assembler temporary symbol with a unique but unspecified name.
Definition: MCContext.cpp:222
virtual bool needsStackRealignment(const MachineFunction &MF) const
needsStackRealignment - true if storage within the function requires the stack pointer to be aligned ...
bool initializeRoots() const
If set, gcroot intrinsics should initialize their allocas to null before the first use...
Definition: GCStrategy.h:153
Instr is the return address of a call.
Definition: GCStrategy.h:69
roots_iterator removeStackRoot(roots_iterator position)
removeStackRoot - Removes a root.
Definition: GCMetadata.h:116
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
GCStrategy & getStrategy()
getStrategy - Return the GC strategy for the function.
Definition: GCMetadata.h:106
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
bool needsSafePoint(GC::PointKind Kind) const
True if the given kind of safe point is required.
Definition: GCStrategy.h:141
rewrite statepoints for gc
MachineInstrBuilder BuildMI(MachineFunction &MF, DebugLoc DL, const MCInstrDesc &MCID)
BuildMI - Builder interface.
bool needsSafePoints() const
True if safe points of any kind are required.
Definition: GCStrategy.h:137
roots_iterator roots_begin()
roots_begin/roots_end - Iterators for all roots in the function.
Definition: GCMetadata.h:140
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
virtual const TargetFrameLowering * getFrameLowering() const
virtual int getFrameIndexOffset(const MachineFunction &MF, int FI) const
getFrameIndexOffset - Returns the displacement from the frame register to the stack frame of the spec...
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
shadow stack gc Shadow Stack GC Lowering
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Information about stack frame layout on the target.
MachineFrameInfo * getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
const BasicBlock & getEntryBlock() const
Definition: Function.h:442
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:159
static bool NeedsDefaultLoweringPass(const GCStrategy &C)
void setPreservesAll()
Set by analyses that do not transform their input at all.
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.cpp:379
static bool InsertRootInitializers(Function &F, AllocaInst **Roots, unsigned Count)
GCStrategy describes a garbage collector algorithm's code generation requirements, and provides overridable hooks for those needs which cannot be abstractly described.
Definition: GCStrategy.h:78
char & GCMachineCodeAnalysisID
GCMachineCodeAnalysis - Target-independent pass to mark safe points in machine code.
iterator end()
Definition: Module.h:571
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
Definition: Instruction.cpp:82
bool customWriteBarrier() const
By default, write barriers are replaced with simple store instructions.
Definition: GCStrategy.h:106
#define I(x, y, z)
Definition: MD5.cpp:54
iterator begin()
Definition: Module.h:569
Instr is a call instruction.
Definition: GCStrategy.h:68
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
void setFrameSize(uint64_t S)
Definition: GCMetadata.h:130
virtual const TargetInstrInfo * getInstrInfo() const
LLVM Value Representation.
Definition: Value.h:69
BasicBlockListType::iterator iterator
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
Garbage collection metadata for a single function.
Definition: GCMetadata.h:73
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
void addSafePoint(GC::PointKind Kind, MCSymbol *Label, DebugLoc DL)
addSafePoint - Notes the existence of a safe point.
Definition: GCMetadata.h:123
std::vector< GCRoot >::iterator roots_iterator
Definition: GCMetadata.h:76
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:37
MachineModuleInfo - This class contains meta information specific to a module.
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76