llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

   1 //===-- llvm/CodeGen/SDNodeDbgValue.h - SelectionDAG dbg_value --*- 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 declares the SDDbgValue class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_SDNODEDBGVALUE_H
  14 #define LLVM_LIB_CODEGEN_SELECTIONDAG_SDNODEDBGVALUE_H
  15
  16 #include "llvm/IR/DebugLoc.h"
  17 #include "llvm/Support/Allocator.h"
  18 #include "llvm/Support/DataTypes.h"
  19 #include <utility>
  20
  21 namespace llvm {
  22
  23 class DIVariable;
  24 class DIExpression;
  25 class SDNode;
  26 class Value;
  27 class raw_ostream;
  28
  29 /// Holds the information for a single machine location through SDISel; either
  30 /// an SDNode, a constant, a stack location, or a virtual register.
  31 class SDDbgOperand {
  32 public:
  33   enum Kind {
  34     SDNODE = 0,  ///< Value is the result of an expression.
  35     CONST = 1,   ///< Value is a constant.
  36     FRAMEIX = 2, ///< Value is contents of a stack location.
  37     VREG = 3     ///< Value is a virtual register.
  38   };
  39   Kind getKind() const { return kind; }
  40
  41   /// Returns the SDNode* for a register ref
  42   SDNode *getSDNode() const {
  43     assert(kind == SDNODE);
  44     return u.s.Node;
  45   }
  46
  47   /// Returns the ResNo for a register ref
  48   unsigned getResNo() const {
  49     assert(kind == SDNODE);
  50     return u.s.ResNo;
  51   }
  52
  53   /// Returns the Value* for a constant
  54   const Value *getConst() const {
  55     assert(kind == CONST);
  56     return u.Const;
  57   }
  58
  59   /// Returns the FrameIx for a stack object
  60   unsigned getFrameIx() const {
  61     assert(kind == FRAMEIX);
  62     return u.FrameIx;
  63   }
  64
  65   /// Returns the Virtual Register for a VReg
  66   unsigned getVReg() const {
  67     assert(kind == VREG);
  68     return u.VReg;
  69   }
  70
  71   static SDDbgOperand fromNode(SDNode *Node, unsigned ResNo) {
  72     return SDDbgOperand(Node, ResNo);
  73   }
  74   static SDDbgOperand fromFrameIdx(unsigned FrameIdx) {
  75     return SDDbgOperand(FrameIdx, FRAMEIX);
  76   }
  77   static SDDbgOperand fromVReg(unsigned VReg) {
  78     return SDDbgOperand(VReg, VREG);
  79   }
  80   static SDDbgOperand fromConst(const Value *Const) {
  81     return SDDbgOperand(Const);
  82   }
  83
  84   bool operator!=(const SDDbgOperand &Other) const { return !(*this == Other); }
  85   bool operator==(const SDDbgOperand &Other) const {
  86     if (kind != Other.kind)
  87       return false;
  88     switch (kind) {
  89     case SDNODE:
  90       return getSDNode() == Other.getSDNode() && getResNo() == Other.getResNo();
  91     case CONST:
  92       return getConst() == Other.getConst();
  93     case VREG:
  94       return getVReg() == Other.getVReg();
  95     case FRAMEIX:
  96       return getFrameIx() == Other.getFrameIx();
  97     }
  98     return false;
  99   }
 100
 101 private:
 102   Kind kind;
 103   union {
 104     struct {
 105       SDNode *Node;   ///< Valid for expressions.
 106       unsigned ResNo; ///< Valid for expressions.
 107     } s;
 108     const Value *Const; ///< Valid for constants.
 109     unsigned FrameIx;   ///< Valid for stack objects.
 110     unsigned VReg;      ///< Valid for registers.
 111   } u;
 112
 113   /// Constructor for non-constants.
 114   SDDbgOperand(SDNode *N, unsigned R) : kind(SDNODE) {
 115     u.s.Node = N;
 116     u.s.ResNo = R;
 117   }
 118   /// Constructor for constants.
 119   SDDbgOperand(const Value *C) : kind(CONST) { u.Const = C; }
 120   /// Constructor for virtual registers and frame indices.
 121   SDDbgOperand(unsigned VRegOrFrameIdx, Kind Kind) : kind(Kind) {
 122     assert((Kind == VREG || Kind == FRAMEIX) &&
 123            "Invalid SDDbgValue constructor");
 124     if (kind == VREG)
 125       u.VReg = VRegOrFrameIdx;
 126     else
 127       u.FrameIx = VRegOrFrameIdx;
 128   }
 129 };
 130
 131 /// Holds the information from a dbg_value node through SDISel.
 132 /// We do not use SDValue here to avoid including its header.
 133 class SDDbgValue {
 134 public:
 135
 136 private:
 137   // SDDbgValues are allocated by a BumpPtrAllocator, which means the destructor
 138   // may not be called; therefore all member arrays must also be allocated by
 139   // that BumpPtrAllocator, to ensure that they are correctly freed.
 140   size_t NumLocationOps;
 141   SDDbgOperand *LocationOps;
 142   // SDNode dependencies will be calculated as SDNodes that appear in
 143   // LocationOps plus these AdditionalDependencies.
 144   size_t NumAdditionalDependencies;
 145   SDNode **AdditionalDependencies;
 146   DIVariable *Var;
 147   DIExpression *Expr;
 148   DebugLoc DL;
 149   unsigned Order;
 150   bool IsIndirect;
 151   bool IsVariadic;
 152   bool Invalid = false;
 153   bool Emitted = false;
 154
 155 public:
 156   SDDbgValue(BumpPtrAllocator &Alloc, DIVariable *Var, DIExpression *Expr,
 157              ArrayRef<SDDbgOperand> L, ArrayRef<SDNode *> Dependencies,
 158              bool IsIndirect, DebugLoc DL, unsigned O, bool IsVariadic)
 159       : NumLocationOps(L.size()),
 160         LocationOps(Alloc.Allocate<SDDbgOperand>(L.size())),
 161         NumAdditionalDependencies(Dependencies.size()),
 162         AdditionalDependencies(Alloc.Allocate<SDNode *>(Dependencies.size())),
 163         Var(Var), Expr(Expr), DL(DL), Order(O), IsIndirect(IsIndirect),
 164         IsVariadic(IsVariadic) {
 165     assert(IsVariadic || L.size() == 1);
 166     assert(!(IsVariadic && IsIndirect));
 167     std::copy(L.begin(), L.end(), LocationOps);
 168     std::copy(Dependencies.begin(), Dependencies.end(), AdditionalDependencies);
 169   }
 170
 171   // We allocate arrays with the BumpPtrAllocator and never free or copy them,
 172   // for LocationOps and AdditionalDependencies, as we never expect to copy or
 173   // destroy an SDDbgValue. If we ever start copying or destroying instances, we
 174   // should manage the allocated memory appropriately.
 175   SDDbgValue(const SDDbgValue &Other) = delete;
 176   SDDbgValue &operator=(const SDDbgValue &Other) = delete;
 177   ~SDDbgValue() = delete;
 178
 179   /// Returns the DIVariable pointer for the variable.
 180   DIVariable *getVariable() const { return Var; }
 181
 182   /// Returns the DIExpression pointer for the expression.
 183   DIExpression *getExpression() const { return Expr; }
 184
 185   ArrayRef<SDDbgOperand> getLocationOps() const {
 186     return ArrayRef<SDDbgOperand>(LocationOps, NumLocationOps);
 187   }
 188
 189   SmallVector<SDDbgOperand> copyLocationOps() const {
 190     return SmallVector<SDDbgOperand>(LocationOps, LocationOps + NumLocationOps);
 191   }
 192
 193   // Returns the SDNodes which this SDDbgValue depends on.
 194   SmallVector<SDNode *> getSDNodes() const {
 195     SmallVector<SDNode *> Dependencies;
 196     for (const SDDbgOperand &DbgOp : getLocationOps())
 197       if (DbgOp.getKind() == SDDbgOperand::SDNODE)
 198         Dependencies.push_back(DbgOp.getSDNode());
 199     for (SDNode *Node : getAdditionalDependencies())
 200       Dependencies.push_back(Node);
 201     return Dependencies;
 202   }
 203
 204   ArrayRef<SDNode *> getAdditionalDependencies() const {
 205     return ArrayRef<SDNode *>(AdditionalDependencies,
 206                               NumAdditionalDependencies);
 207   }
 208
 209   /// Returns whether this is an indirect value.
 210   bool isIndirect() const { return IsIndirect; }
 211
 212   bool isVariadic() const { return IsVariadic; }
 213
 214   /// Returns the DebugLoc.
 215   const DebugLoc &getDebugLoc() const { return DL; }
 216
 217   /// Returns the SDNodeOrder.  This is the order of the preceding node in the
 218   /// input.
 219   unsigned getOrder() const { return Order; }
 220
 221   /// setIsInvalidated / isInvalidated - Setter / getter of the "Invalidated"
 222   /// property. A SDDbgValue is invalid if the SDNode that produces the value is
 223   /// deleted.
 224   void setIsInvalidated() { Invalid = true; }
 225   bool isInvalidated() const { return Invalid; }
 226
 227   /// setIsEmitted / isEmitted - Getter/Setter for flag indicating that this
 228   /// SDDbgValue has been emitted to an MBB.
 229   void setIsEmitted() { Emitted = true; }
 230   bool isEmitted() const { return Emitted; }
 231
 232   /// clearIsEmitted - Reset Emitted flag, for certain special cases where
 233   /// SDDbgValue is emitted twice. DBG_INSTR_REF depends on this behaviour.
 234   void clearIsEmitted() { Emitted = false; }
 235
 236   LLVM_DUMP_METHOD void dump() const;
 237   LLVM_DUMP_METHOD void print(raw_ostream &OS) const;
 238 };
 239
 240 /// Holds the information from a dbg_label node through SDISel.
 241 /// We do not use SDValue here to avoid including its header.
 242 class SDDbgLabel {
 243   MDNode *Label;
 244   DebugLoc DL;
 245   unsigned Order;
 246
 247 public:
 248   SDDbgLabel(MDNode *Label, DebugLoc dl, unsigned O)
 249       : Label(Label), DL(std::move(dl)), Order(O) {}
 250
 251   /// Returns the MDNode pointer for the label.
 252   MDNode *getLabel() const { return Label; }
 253
 254   /// Returns the DebugLoc.
 255   const DebugLoc &getDebugLoc() const { return DL; }
 256
 257   /// Returns the SDNodeOrder.  This is the order of the preceding node in the
 258   /// input.
 259   unsigned getOrder() const { return Order; }
 260 };
 261
 262 } // end llvm namespace
 263
 264 #endif