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