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/CodeGen/SelectionDAG.h"
20#include "llvm/CodeGen/SelectionDAGNodes.h"
21#include <vector>
22
23namespace llvm {
24class 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.
31class StatepointLoweringState {
32public:
33  StatepointLoweringState() : NextSlotToAllocate(0) {
34  }
35
36  /// Reset all state tracking for a newly encountered safepoint.  Also
37  /// performs some consistency checking.
38  void startNewStatepoint(SelectionDAGBuilder &Builder);
39
40  /// Clear the memory usage of this object.  This is called from
41  /// SelectionDAGBuilder::clear.  We require this is never called in the
42  /// midst of processing a statepoint sequence.
43  void clear();
44
45  /// Returns the spill location of a value incoming to the current
46  /// statepoint.  Will return SDValue() if this value hasn't been
47  /// spilled.  Otherwise, the value has already been spilled and no
48  /// further action is required by the caller.
49  SDValue getLocation(SDValue val) {
50    if (!Locations.count(val))
51      return SDValue();
52    return Locations[val];
53  }
54  void setLocation(SDValue val, SDValue Location) {
55    assert(!Locations.count(val) &&
56           "Trying to allocate already allocated location");
57    Locations[val] = Location;
58  }
59
60  /// Returns the relocated value for a given input pointer. Will
61  /// return SDValue() if this value hasn't yet been reloaded from
62  /// it's stack slot after the statepoint.  Otherwise, the value
63  /// has already been reloaded and the SDValue of that reload will
64  /// be returned. Note that VMState values are spilled but not
65  /// reloaded (since they don't change at the safepoint unless
66  /// also listed in the GC pointer section) and will thus never
67  /// be in this map
68  SDValue getRelocLocation(SDValue val) {
69    if (!RelocLocations.count(val))
70      return SDValue();
71    return RelocLocations[val];
72  }
73  void setRelocLocation(SDValue val, SDValue Location) {
74    assert(!RelocLocations.count(val) &&
75           "Trying to allocate already allocated location");
76    RelocLocations[val] = Location;
77  }
78
79  /// Record the fact that we expect to encounter a given gc_relocate
80  /// before the next statepoint.  If we don't see it, we'll report
81  /// an assertion.
82  void scheduleRelocCall(const CallInst &RelocCall) {
83    PendingGCRelocateCalls.push_back(&RelocCall);
84  }
85  /// Remove this gc_relocate from the list we're expecting to see
86  /// before the next statepoint.  If we weren't expecting to see
87  /// it, we'll report an assertion.
88  void relocCallVisited(const CallInst &RelocCall) {
89    SmallVectorImpl<const CallInst *>::iterator itr =
90        std::find(PendingGCRelocateCalls.begin(), PendingGCRelocateCalls.end(),
91                  &RelocCall);
92    assert(itr != PendingGCRelocateCalls.end() &&
93           "Visited unexpected gcrelocate call");
94    PendingGCRelocateCalls.erase(itr);
95  }
96
97  // TODO: Should add consistency tracking to ensure we encounter
98  // expected gc_result calls too.
99
100  /// Get a stack slot we can use to store an value of type ValueType.  This
101  /// will hopefully be a recylced slot from another statepoint.
102  SDValue allocateStackSlot(EVT ValueType, SelectionDAGBuilder &Builder);
103
104  void reserveStackSlot(int Offset) {
105    assert(Offset >= 0 && Offset < (int)AllocatedStackSlots.size() &&
106           "out of bounds");
107    assert(!AllocatedStackSlots[Offset] && "already reserved!");
108    assert(NextSlotToAllocate <= (unsigned)Offset && "consistency!");
109    AllocatedStackSlots[Offset] = true;
110  }
111  bool isStackSlotAllocated(int Offset) {
112    assert(Offset >= 0 && Offset < (int)AllocatedStackSlots.size() &&
113           "out of bounds");
114    return AllocatedStackSlots[Offset];
115  }
116
117private:
118  /// Maps pre-relocation value (gc pointer directly incoming into statepoint)
119  /// into it's location (currently only stack slots)
120  DenseMap<SDValue, SDValue> Locations;
121  /// Map pre-relocated value into it's new relocated location
122  DenseMap<SDValue, SDValue> RelocLocations;
123
124  /// A boolean indicator for each slot listed in the FunctionInfo as to
125  /// whether it has been used in the current statepoint.  Since we try to
126  /// preserve stack slots across safepoints, there can be gaps in which
127  /// slots have been allocated.
128  SmallVector<bool, 50> AllocatedStackSlots;
129
130  /// Points just beyond the last slot known to have been allocated
131  unsigned NextSlotToAllocate;
132
133  /// Keep track of pending gcrelocate calls for consistency check
134  SmallVector<const CallInst *, 10> PendingGCRelocateCalls;
135};
136} // end namespace llvm
137
138#endif // LLVM_LIB_CODEGEN_SELECTIONDAG_STATEPOINTLOWERING_H
139