127 lines · c
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-exception6//7//===----------------------------------------------------------------------===//8//9// This file includes support code use by SelectionDAGBuilder when lowering a10// statepoint sequence in SelectionDAG IR.11//12//===----------------------------------------------------------------------===//13 14#ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_STATEPOINTLOWERING_H15#define LLVM_LIB_CODEGEN_SELECTIONDAG_STATEPOINTLOWERING_H16 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 and30/// relocated) and list of gcreloc calls scheduled for visiting (this is31/// used for a debug mode consistency check only). The spill slot tracking32/// works in concert with information in FunctionLoweringInfo.33class StatepointLoweringState {34public:35 StatepointLoweringState() = default;36 37 /// Reset all state tracking for a newly encountered safepoint. Also38 /// performs some consistency checking.39 void startNewStatepoint(SelectionDAGBuilder &Builder);40 41 /// Clear the memory usage of this object. This is called from42 /// SelectionDAGBuilder::clear. We require this is never called in the43 /// midst of processing a statepoint sequence.44 void clear();45 46 /// Returns the spill location of a value incoming to the current47 /// statepoint. Will return SDValue() if this value hasn't been48 /// spilled. Otherwise, the value has already been spilled and no49 /// 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_relocate64 /// before the next statepoint. If we don't see it, we'll report65 /// 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 see73 /// before the next statepoint. If we weren't expecting to see74 /// 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 encounter86 // expected gc_result calls too.87 88 /// Get a stack slot we can use to store an value of type ValueType. This89 /// 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 to112 /// whether it has been used in the current statepoint. Since we try to113 /// preserve stack slots across safepoints, there can be gaps in which114 /// slots have been allocated.115 SmallBitVector AllocatedStackSlots;116 117 /// Points just beyond the last slot known to have been allocated118 unsigned NextSlotToAllocate = 0;119 120 /// Keep track of pending gcrelocate calls for consistency check121 SmallVector<const GCRelocateInst *, 10> PendingGCRelocateCalls;122};123 124} // end namespace llvm125 126#endif // LLVM_LIB_CODEGEN_SELECTIONDAG_STATEPOINTLOWERING_H127