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
265