llvm/lib/CodeGen/SelectionDAG/StatepointLowering.h

   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
  24 namespace llvm {
  25
  26 class 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.
  33 class StatepointLoweringState {
  34 public:
  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
 106 private:
 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