blob: fb5eafb7122c00e5a02d57aba14a78967f1d7540 (
plain)
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
156
157
158
|
//===-- llvm/Use.h - Definition of the Use class ----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This defines the Use class. The Use class represents the operand of an
// instruction or some other User instance which refers to a Value. The Use
// class keeps the "use list" of the referenced value up to date.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_USE_H
#define LLVM_USE_H
#include "Support/ilist"
namespace llvm {
template<typename NodeTy> struct ilist_traits;
class Value;
class User;
//===----------------------------------------------------------------------===//
// Use Class
//===----------------------------------------------------------------------===//
// Use is here to make keeping the "use" list of a Value up-to-date really easy.
//
class Use {
Value *Val;
User *U;
Use *Prev, *Next;
friend class ilist_traits<Use>;
public:
inline Use(Value *v, User *user);
inline Use(const Use &u);
inline ~Use();
operator Value*() const { return Val; }
Value *get() const { return Val; }
User *getUser() const { return U; }
inline void set(Value *Val);
Value *operator=(Value *RHS) {
set(RHS);
return RHS;
}
const Use &operator=(const Use &RHS) {
set(RHS.Val);
return *this;
}
Value *operator->() { return Val; }
const Value *operator->() const { return Val; }
};
template<>
struct ilist_traits<Use> {
static Use *getPrev(Use *N) { return N->Prev; }
static Use *getNext(Use *N) { return N->Next; }
static const Use *getPrev(const Use *N) { return N->Prev; }
static const Use *getNext(const Use *N) { return N->Next; }
static void setPrev(Use *N, Use *Prev) { N->Prev = Prev; }
static void setNext(Use *N, Use *Next) { N->Next = Next; }
// createNode - this is used to create the end marker for the use list
static Use *createNode() { return new Use(0,0); }
void addNodeToList(Use *NTy) {}
void removeNodeFromList(Use *NTy) {}
void transferNodesFromList(iplist<Use, ilist_traits> &L2,
ilist_iterator<Use> first,
ilist_iterator<Use> last) {}
};
template<> struct simplify_type<Use> {
typedef Value* SimpleType;
static SimpleType getSimplifiedValue(const Use &Val) {
return static_cast<SimpleType>(Val.get());
}
};
template<> struct simplify_type<const Use> {
typedef Value* SimpleType;
static SimpleType getSimplifiedValue(const Use &Val) {
return static_cast<SimpleType>(Val.get());
}
};
struct UseListIteratorWrapper : public iplist<Use>::iterator {
typedef iplist<Use>::iterator Super;
UseListIteratorWrapper() {}
UseListIteratorWrapper(const Super &RHS) : Super(RHS) {}
UseListIteratorWrapper &operator=(const Super &RHS) {
Super::operator=(RHS);
return *this;
}
inline User *operator*() const;
User *operator->() const { return operator*(); }
UseListIteratorWrapper operator--() { return Super::operator--(); }
UseListIteratorWrapper operator++() { return Super::operator++(); }
UseListIteratorWrapper operator--(int) { // postdecrement operators...
UseListIteratorWrapper tmp = *this;
--*this;
return tmp;
}
UseListIteratorWrapper operator++(int) { // postincrement operators...
UseListIteratorWrapper tmp = *this;
++*this;
return tmp;
}
};
struct UseListConstIteratorWrapper : public iplist<Use>::const_iterator {
typedef iplist<Use>::const_iterator Super;
UseListConstIteratorWrapper() {}
UseListConstIteratorWrapper(const Super &RHS) : Super(RHS) {}
// Allow conversion from non-const to const iterators
UseListConstIteratorWrapper(const UseListIteratorWrapper &RHS) : Super(RHS) {}
UseListConstIteratorWrapper(const iplist<Use>::iterator &RHS) : Super(RHS) {}
UseListConstIteratorWrapper &operator=(const Super &RHS) {
Super::operator=(RHS);
return *this;
}
inline const User *operator*() const;
const User *operator->() const { return operator*(); }
UseListConstIteratorWrapper operator--() { return Super::operator--(); }
UseListConstIteratorWrapper operator++() { return Super::operator++(); }
UseListConstIteratorWrapper operator--(int) { // postdecrement operators...
UseListConstIteratorWrapper tmp = *this;
--*this;
return tmp;
}
UseListConstIteratorWrapper operator++(int) { // postincrement operators...
UseListConstIteratorWrapper tmp = *this;
++*this;
return tmp;
}
};
} // End llvm namespace
#endif
|
