Home | History | Annotate | Line # | Download | only in SelectionDAG 
      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
    127