1 //===-- StatepointLowering.h - SDAGBuilder's statepoint code -*- C++ -*---===// 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 includes support code use by SelectionDAGBuilder when lowering a 11 // statepoint sequence in SelectionDAG IR. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_STATEPOINTLOWERING_H 16 #define LLVM_LIB_CODEGEN_SELECTIONDAG_STATEPOINTLOWERING_H 17 18 #include "llvm/ADT/DenseMap.h" 19 #include "llvm/ADT/SmallBitVector.h" 20 #include "llvm/CodeGen/SelectionDAG.h" 21 #include "llvm/CodeGen/SelectionDAGNodes.h" 22 23 namespace llvm { 24 class SelectionDAGBuilder; 25 26 /// This class tracks both per-statepoint and per-selectiondag information. 27 /// For each statepoint it tracks locations of it's gc valuess (incoming and 28 /// relocated) and list of gcreloc calls scheduled for visiting (this is 29 /// used for a debug mode consistency check only). The spill slot tracking 30 /// works in concert with information in FunctionLoweringInfo. 31 class StatepointLoweringState { 32 public: StatepointLoweringState()33 StatepointLoweringState() : NextSlotToAllocate(0) {} 34 35 /// Reset all state tracking for a newly encountered safepoint. Also 36 /// performs some consistency checking. 37 void startNewStatepoint(SelectionDAGBuilder &Builder); 38 39 /// Clear the memory usage of this object. This is called from 40 /// SelectionDAGBuilder::clear. We require this is never called in the 41 /// midst of processing a statepoint sequence. 42 void clear(); 43 44 /// Returns the spill location of a value incoming to the current 45 /// statepoint. Will return SDValue() if this value hasn't been 46 /// spilled. Otherwise, the value has already been spilled and no 47 /// further action is required by the caller. getLocation(SDValue Val)48 SDValue getLocation(SDValue Val) { 49 auto I = Locations.find(Val); 50 if (I == Locations.end()) 51 return SDValue(); 52 return I->second; 53 } 54 setLocation(SDValue Val,SDValue Location)55 void setLocation(SDValue Val, SDValue Location) { 56 assert(!Locations.count(Val) && 57 "Trying to allocate already allocated location"); 58 Locations[Val] = Location; 59 } 60 61 /// Record the fact that we expect to encounter a given gc_relocate 62 /// before the next statepoint. If we don't see it, we'll report 63 /// an assertion. scheduleRelocCall(const CallInst & RelocCall)64 void scheduleRelocCall(const CallInst &RelocCall) { 65 PendingGCRelocateCalls.push_back(&RelocCall); 66 } 67 68 /// Remove this gc_relocate from the list we're expecting to see 69 /// before the next statepoint. If we weren't expecting to see 70 /// it, we'll report an assertion. relocCallVisited(const CallInst & RelocCall)71 void relocCallVisited(const CallInst &RelocCall) { 72 auto I = find(PendingGCRelocateCalls, &RelocCall); 73 assert(I != PendingGCRelocateCalls.end() && 74 "Visited unexpected gcrelocate call"); 75 PendingGCRelocateCalls.erase(I); 76 } 77 78 // TODO: Should add consistency tracking to ensure we encounter 79 // expected gc_result calls too. 80 81 /// Get a stack slot we can use to store an value of type ValueType. This 82 /// will hopefully be a recylced slot from another statepoint. 83 SDValue allocateStackSlot(EVT ValueType, SelectionDAGBuilder &Builder); 84 reserveStackSlot(int Offset)85 void reserveStackSlot(int Offset) { 86 assert(Offset >= 0 && Offset < (int)AllocatedStackSlots.size() && 87 "out of bounds"); 88 assert(!AllocatedStackSlots.test(Offset) && "already reserved!"); 89 assert(NextSlotToAllocate <= (unsigned)Offset && "consistency!"); 90 AllocatedStackSlots.set(Offset); 91 } 92 isStackSlotAllocated(int Offset)93 bool isStackSlotAllocated(int Offset) { 94 assert(Offset >= 0 && Offset < (int)AllocatedStackSlots.size() && 95 "out of bounds"); 96 return AllocatedStackSlots.test(Offset); 97 } 98 99 private: 100 /// Maps pre-relocation value (gc pointer directly incoming into statepoint) 101 /// into it's location (currently only stack slots) 102 DenseMap<SDValue, SDValue> Locations; 103 104 /// A boolean indicator for each slot listed in the FunctionInfo as to 105 /// whether it has been used in the current statepoint. Since we try to 106 /// preserve stack slots across safepoints, there can be gaps in which 107 /// slots have been allocated. 108 SmallBitVector AllocatedStackSlots; 109 110 /// Points just beyond the last slot known to have been allocated 111 unsigned NextSlotToAllocate; 112 113 /// Keep track of pending gcrelocate calls for consistency check 114 SmallVector<const CallInst *, 10> PendingGCRelocateCalls; 115 }; 116 } // end namespace llvm 117 118 #endif // LLVM_LIB_CODEGEN_SELECTIONDAG_STATEPOINTLOWERING_H 119