1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
//===-- llvm/CodeGen/SDNodeDbgValue.h - SelectionDAG dbg_value --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the SDDbgValue class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_SDNODEDBGVALUE_H
#define LLVM_LIB_CODEGEN_SELECTIONDAG_SDNODEDBGVALUE_H
#include "llvm/IR/DebugLoc.h"
#include "llvm/Support/DataTypes.h"
#include <utility>
namespace llvm {
class DIVariable;
class DIExpression;
class SDNode;
class Value;
/// Holds the information from a dbg_value node through SDISel.
/// We do not use SDValue here to avoid including its header.
class SDDbgValue {
public:
enum DbgValueKind {
SDNODE = 0, ///< Value is the result of an expression.
CONST = 1, ///< Value is a constant.
FRAMEIX = 2, ///< Value is contents of a stack location.
VREG = 3 ///< Value is a virtual register.
};
private:
union {
struct {
SDNode *Node; ///< Valid for expressions.
unsigned ResNo; ///< Valid for expressions.
} s;
const Value *Const; ///< Valid for constants.
unsigned FrameIx; ///< Valid for stack objects.
unsigned VReg; ///< Valid for registers.
} u;
DIVariable *Var;
DIExpression *Expr;
DebugLoc DL;
unsigned Order;
enum DbgValueKind kind;
bool IsIndirect;
bool Invalid = false;
public:
/// Constructor for non-constants.
SDDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N, unsigned R,
bool indir, DebugLoc dl, unsigned O)
: Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(indir) {
kind = SDNODE;
u.s.Node = N;
u.s.ResNo = R;
}
/// Constructor for constants.
SDDbgValue(DIVariable *Var, DIExpression *Expr, const Value *C, DebugLoc dl,
unsigned O)
: Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(false) {
kind = CONST;
u.Const = C;
}
/// Constructor for frame indices.
SDDbgValue(DIVariable *Var, DIExpression *Expr, unsigned FI, DebugLoc dl,
unsigned O)
: Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(false) {
kind = FRAMEIX;
u.FrameIx = FI;
}
/// Constructor for virtual registers.
SDDbgValue(DIVariable *Var, DIExpression *Expr, unsigned VReg, bool indir,
DebugLoc dl, unsigned O)
: Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(indir) {
kind = VREG;
u.VReg = VReg;
}
/// Returns the kind.
DbgValueKind getKind() const { return kind; }
/// Returns the DIVariable pointer for the variable.
DIVariable *getVariable() const { return Var; }
/// Returns the DIExpression pointer for the expression.
DIExpression *getExpression() const { return Expr; }
/// Returns the SDNode* for a register ref
SDNode *getSDNode() const { assert (kind==SDNODE); return u.s.Node; }
/// Returns the ResNo for a register ref
unsigned getResNo() const { assert (kind==SDNODE); return u.s.ResNo; }
/// Returns the Value* for a constant
const Value *getConst() const { assert (kind==CONST); return u.Const; }
/// Returns the FrameIx for a stack object
unsigned getFrameIx() const { assert (kind==FRAMEIX); return u.FrameIx; }
/// Returns the Virtual Register for a VReg
unsigned getVReg() const { assert (kind==VREG); return u.VReg; }
/// Returns whether this is an indirect value.
bool isIndirect() const { return IsIndirect; }
/// Returns the DebugLoc.
DebugLoc getDebugLoc() const { return DL; }
/// Returns the SDNodeOrder. This is the order of the preceding node in the
/// input.
unsigned getOrder() const { return Order; }
/// setIsInvalidated / isInvalidated - Setter / getter of the "Invalidated"
/// property. A SDDbgValue is invalid if the SDNode that produces the value is
/// deleted.
void setIsInvalidated() { Invalid = true; }
bool isInvalidated() const { return Invalid; }
};
/// Holds the information from a dbg_label node through SDISel.
/// We do not use SDValue here to avoid including its header.
class SDDbgLabel {
MDNode *Label;
DebugLoc DL;
unsigned Order;
public:
SDDbgLabel(MDNode *Label, DebugLoc dl, unsigned O)
: Label(Label), DL(std::move(dl)), Order(O) {}
/// Returns the MDNode pointer for the label.
MDNode *getLabel() const { return Label; }
/// Returns the DebugLoc.
DebugLoc getDebugLoc() const { return DL; }
/// Returns the SDNodeOrder. This is the order of the preceding node in the
/// input.
unsigned getOrder() const { return Order; }
};
} // end llvm namespace
#endif
|
