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
|
//===-- llvm/Metadata.h - Metadata definitions ------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
/// @file
/// This file contains the declarations for metadata subclasses.
/// They represent the different flavors of metadata that live in LLVM.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_MDNODE_H
#define LLVM_MDNODE_H
#include "llvm/Constant.h"
#include "llvm/Type.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ValueHandle.h"
namespace llvm {
//===----------------------------------------------------------------------===//
// MetadataBase - A base class for MDNode and MDString.
class MetadataBase : public Value {
protected:
MetadataBase(const Type *Ty, unsigned scid)
: Value(Ty, scid) {}
public:
/// getType() specialization - Type is always MetadataTy.
///
inline const Type *getType() const {
return Type::MetadataTy;
}
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue. This always returns false because getNullValue will never
/// produce metadata.
virtual bool isNullValue() const {
return false;
}
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const MDString *) { return true; }
static bool classof(const Value *V) {
return V->getValueID() == MDStringVal || V->getValueID() == MDNodeVal;
}
};
//===----------------------------------------------------------------------===//
/// MDString - a single uniqued string.
/// These are used to efficiently contain a byte sequence for metadata.
///
class MDString : public MetadataBase {
MDString(const MDString &); // DO NOT IMPLEMENT
StringRef Str;
friend class LLVMContextImpl;
protected:
explicit MDString(const char *begin, unsigned l)
: MetadataBase(Type::MetadataTy, Value::MDStringVal), Str(begin, l) {}
public:
StringRef getString() const { return Str; }
unsigned length() const { return Str.size(); }
/// begin() - Pointer to the first byte of the string.
///
const char *begin() const { return Str.begin(); }
/// end() - Pointer to one byte past the end of the string.
///
const char *end() const { return Str.end(); }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const MDString *) { return true; }
static bool classof(const Value *V) {
return V->getValueID() == MDStringVal;
}
};
//===----------------------------------------------------------------------===//
/// MDNode - a tuple of other values.
/// These contain a list of the values that represent the metadata.
///
class MDNode : public MetadataBase, public FoldingSetNode {
MDNode(const MDNode &); // DO NOT IMPLEMENT
friend class LLVMContextImpl;
SmallVector<WeakVH, 4> Node;
typedef SmallVectorImpl<WeakVH>::iterator elem_iterator;
protected:
explicit MDNode(Value*const* Vals, unsigned NumVals);
public:
typedef SmallVectorImpl<WeakVH>::const_iterator const_elem_iterator;
Value *getElement(unsigned i) const {
return Node[i];
}
unsigned getNumElements() const {
return Node.size();
}
bool elem_empty() const {
return Node.empty();
}
const_elem_iterator elem_begin() const {
return Node.begin();
}
const_elem_iterator elem_end() const {
return Node.end();
}
/// getType() specialization - Type is always MetadataTy.
///
inline const Type *getType() const {
return Type::MetadataTy;
}
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue. This always returns false because getNullValue will never
/// produce metadata.
virtual bool isNullValue() const {
return false;
}
/// Profile - calculate a unique identifier for this MDNode to collapse
/// duplicates
void Profile(FoldingSetNodeID &ID) const;
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) {
llvm_unreachable("This should never be called because MDNodes have no ops");
}
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const MDNode *) { return true; }
static bool classof(const Value *V) {
return V->getValueID() == MDNodeVal;
}
};
} // end llvm namespace
#endif
|
