LLVM  7.0.0svn
TypeIndex.h
Go to the documentation of this file.
1 //===- TypeIndex.h ----------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPEINDEX_H
11 #define LLVM_DEBUGINFO_CODEVIEW_TYPEINDEX_H
12 
13 #include "llvm/ADT/DenseMapInfo.h"
14 #include "llvm/Support/Endian.h"
15 #include <cassert>
16 #include <cinttypes>
17 #include <functional>
18 
19 namespace llvm {
20 
21 class ScopedPrinter;
22 
23 namespace codeview {
24 
25 class TypeCollection;
26 
27 enum class SimpleTypeKind : uint32_t {
28  None = 0x0000, // uncharacterized type (no type)
29  Void = 0x0003, // void
30  NotTranslated = 0x0007, // type not translated by cvpack
31  HResult = 0x0008, // OLE/COM HRESULT
32 
33  SignedCharacter = 0x0010, // 8 bit signed
34  UnsignedCharacter = 0x0020, // 8 bit unsigned
35  NarrowCharacter = 0x0070, // really a char
36  WideCharacter = 0x0071, // wide char
37  Character16 = 0x007a, // char16_t
38  Character32 = 0x007b, // char32_t
39 
40  SByte = 0x0068, // 8 bit signed int
41  Byte = 0x0069, // 8 bit unsigned int
42  Int16Short = 0x0011, // 16 bit signed
43  UInt16Short = 0x0021, // 16 bit unsigned
44  Int16 = 0x0072, // 16 bit signed int
45  UInt16 = 0x0073, // 16 bit unsigned int
46  Int32Long = 0x0012, // 32 bit signed
47  UInt32Long = 0x0022, // 32 bit unsigned
48  Int32 = 0x0074, // 32 bit signed int
49  UInt32 = 0x0075, // 32 bit unsigned int
50  Int64Quad = 0x0013, // 64 bit signed
51  UInt64Quad = 0x0023, // 64 bit unsigned
52  Int64 = 0x0076, // 64 bit signed int
53  UInt64 = 0x0077, // 64 bit unsigned int
54  Int128Oct = 0x0014, // 128 bit signed int
55  UInt128Oct = 0x0024, // 128 bit unsigned int
56  Int128 = 0x0078, // 128 bit signed int
57  UInt128 = 0x0079, // 128 bit unsigned int
58 
59  Float16 = 0x0046, // 16 bit real
60  Float32 = 0x0040, // 32 bit real
61  Float32PartialPrecision = 0x0045, // 32 bit PP real
62  Float48 = 0x0044, // 48 bit real
63  Float64 = 0x0041, // 64 bit real
64  Float80 = 0x0042, // 80 bit real
65  Float128 = 0x0043, // 128 bit real
66 
67  Complex16 = 0x0056, // 16 bit complex
68  Complex32 = 0x0050, // 32 bit complex
69  Complex32PartialPrecision = 0x0055, // 32 bit PP complex
70  Complex48 = 0x0054, // 48 bit complex
71  Complex64 = 0x0051, // 64 bit complex
72  Complex80 = 0x0052, // 80 bit complex
73  Complex128 = 0x0053, // 128 bit complex
74 
75  Boolean8 = 0x0030, // 8 bit boolean
76  Boolean16 = 0x0031, // 16 bit boolean
77  Boolean32 = 0x0032, // 32 bit boolean
78  Boolean64 = 0x0033, // 64 bit boolean
79  Boolean128 = 0x0034, // 128 bit boolean
80 };
81 
82 enum class SimpleTypeMode : uint32_t {
83  Direct = 0x00000000, // Not a pointer
84  NearPointer = 0x00000100, // Near pointer
85  FarPointer = 0x00000200, // Far pointer
86  HugePointer = 0x00000300, // Huge pointer
87  NearPointer32 = 0x00000400, // 32 bit near pointer
88  FarPointer32 = 0x00000500, // 32 bit far pointer
89  NearPointer64 = 0x00000600, // 64 bit near pointer
90  NearPointer128 = 0x00000700 // 128 bit near pointer
91 };
92 
93 /// A 32-bit type reference. Types are indexed by their order of appearance in
94 /// .debug$T plus 0x1000. Type indices less than 0x1000 are "simple" types,
95 /// composed of a SimpleTypeMode byte followed by a SimpleTypeKind byte.
96 class TypeIndex {
97 public:
98  static const uint32_t FirstNonSimpleIndex = 0x1000;
99  static const uint32_t SimpleKindMask = 0x000000ff;
100  static const uint32_t SimpleModeMask = 0x00000700;
101  static const uint32_t DecoratedItemIdMask = 0x80000000;
102 
103 public:
104  TypeIndex() : Index(static_cast<uint32_t>(SimpleTypeKind::None)) {}
105  explicit TypeIndex(uint32_t Index) : Index(Index) {}
107  : Index(static_cast<uint32_t>(Kind)) {}
109  : Index(static_cast<uint32_t>(Kind) | static_cast<uint32_t>(Mode)) {}
110 
111  uint32_t getIndex() const { return Index; }
112  void setIndex(uint32_t I) { Index = I; }
113  bool isSimple() const { return Index < FirstNonSimpleIndex; }
114  bool isDecoratedItemId() const { return !!(Index & DecoratedItemIdMask); }
115 
116  bool isNoneType() const { return *this == None(); }
117 
119  assert(!isSimple());
120  return getIndex() - FirstNonSimpleIndex;
121  }
122 
124  return TypeIndex(Index + FirstNonSimpleIndex);
125  }
126 
128  assert(isSimple());
129  return static_cast<SimpleTypeKind>(Index & SimpleKindMask);
130  }
131 
133  assert(isSimple());
134  return static_cast<SimpleTypeMode>(Index & SimpleModeMask);
135  }
136 
141  }
144  }
145 
148  }
151  }
154  }
157  }
160  }
163  }
169  }
175  }
176 
179 
180  TypeIndex &operator+=(unsigned N) {
181  Index += N;
182  return *this;
183  }
184 
186  Index += 1;
187  return *this;
188  }
189 
191  TypeIndex Copy = *this;
192  operator++();
193  return Copy;
194  }
195 
196  TypeIndex &operator-=(unsigned N) {
197  assert(Index >= N);
198  Index -= N;
199  return *this;
200  }
201 
203  Index -= 1;
204  return *this;
205  }
206 
208  TypeIndex Copy = *this;
209  operator--();
210  return Copy;
211  }
212 
213  friend inline bool operator==(const TypeIndex &A, const TypeIndex &B) {
214  return A.getIndex() == B.getIndex();
215  }
216 
217  friend inline bool operator!=(const TypeIndex &A, const TypeIndex &B) {
218  return A.getIndex() != B.getIndex();
219  }
220 
221  friend inline bool operator<(const TypeIndex &A, const TypeIndex &B) {
222  return A.getIndex() < B.getIndex();
223  }
224 
225  friend inline bool operator<=(const TypeIndex &A, const TypeIndex &B) {
226  return A.getIndex() <= B.getIndex();
227  }
228 
229  friend inline bool operator>(const TypeIndex &A, const TypeIndex &B) {
230  return A.getIndex() > B.getIndex();
231  }
232 
233  friend inline bool operator>=(const TypeIndex &A, const TypeIndex &B) {
234  return A.getIndex() >= B.getIndex();
235  }
236 
237  friend inline TypeIndex operator+(const TypeIndex &A, uint32_t N) {
238  TypeIndex Result(A);
239  Result += N;
240  return Result;
241  }
242 
243  friend inline TypeIndex operator-(const TypeIndex &A, uint32_t N) {
244  assert(A.getIndex() >= N);
245  TypeIndex Result(A);
246  Result -= N;
247  return Result;
248  }
249 
250  friend inline uint32_t operator-(const TypeIndex &A, const TypeIndex &B) {
251  assert(A >= B);
252  return A.toArrayIndex() - B.toArrayIndex();
253  }
254 
255  static StringRef simpleTypeName(TypeIndex TI);
256 
257 private:
259 };
260 
261 // Used for pseudo-indexing an array of type records. An array of such records
262 // sorted by TypeIndex can allow log(N) lookups even though such a type record
263 // stream does not provide random access.
267 };
268 
270  TypeCollection &Types);
271 }
272 
273 template <> struct DenseMapInfo<codeview::TypeIndex> {
276  }
279  }
280  static unsigned getHashValue(const codeview::TypeIndex &TI) {
282  }
283  static bool isEqual(const codeview::TypeIndex &LHS,
284  const codeview::TypeIndex &RHS) {
285  return LHS == RHS;
286  }
287 };
288 
289 } // namespace llvm
290 
291 #endif
TypeIndex & operator-=(unsigned N)
Definition: TypeIndex.h:196
static TypeIndex UInt64Quad()
Definition: TypeIndex.h:173
TypeIndex & operator++()
Definition: TypeIndex.h:185
static TypeIndex UInt64()
Definition: TypeIndex.h:171
friend bool operator!=(const TypeIndex &A, const TypeIndex &B)
Definition: TypeIndex.h:217
friend bool operator>=(const TypeIndex &A, const TypeIndex &B)
Definition: TypeIndex.h:233
SI Whole Quad Mode
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static TypeIndex Float32()
Definition: TypeIndex.h:177
SimpleTypeKind getSimpleKind() const
Definition: TypeIndex.h:127
support::ulittle32_t Offset
Definition: TypeIndex.h:266
static TypeIndex UInt32()
Definition: TypeIndex.h:165
TypeIndex(SimpleTypeKind Kind)
Definition: TypeIndex.h:106
print alias Alias Set Printer
static codeview::TypeIndex getTombstoneKey()
Definition: TypeIndex.h:277
SimpleTypeMode getSimpleMode() const
Definition: TypeIndex.h:132
TypeIndex(SimpleTypeKind Kind, SimpleTypeMode Mode)
Definition: TypeIndex.h:108
static TypeIndex Int16Short()
Definition: TypeIndex.h:158
void setIndex(uint32_t I)
Definition: TypeIndex.h:112
bool isNoneType() const
Definition: TypeIndex.h:116
TypeIndex & operator+=(unsigned N)
Definition: TypeIndex.h:180
static TypeIndex UInt16Short()
Definition: TypeIndex.h:161
static bool isSimple(Instruction *I)
friend bool operator==(const TypeIndex &A, const TypeIndex &B)
Definition: TypeIndex.h:213
A 32-bit type reference.
Definition: TypeIndex.h:96
uint32_t toArrayIndex() const
Definition: TypeIndex.h:118
TypeIndex & operator--()
Definition: TypeIndex.h:202
static TypeIndex NarrowCharacter()
Definition: TypeIndex.h:152
static TypeIndex fromArrayIndex(uint32_t Index)
Definition: TypeIndex.h:123
bool isDecoratedItemId() const
Definition: TypeIndex.h:114
static TypeIndex VoidPointer64()
Definition: TypeIndex.h:142
void printTypeIndex(ScopedPrinter &Printer, StringRef FieldName, TypeIndex TI, TypeCollection &Types)
Definition: TypeIndex.cpp:90
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
TypeIndex(uint32_t Index)
Definition: TypeIndex.h:105
static TypeIndex Int64()
Definition: TypeIndex.h:170
static TypeIndex Int64Quad()
Definition: TypeIndex.h:172
static bool isEqual(const codeview::TypeIndex &LHS, const codeview::TypeIndex &RHS)
Definition: TypeIndex.h:283
static unsigned getHashValue(const codeview::TypeIndex &TI)
Definition: TypeIndex.h:280
friend TypeIndex operator-(const TypeIndex &A, uint32_t N)
Definition: TypeIndex.h:243
static TypeIndex Int32()
Definition: TypeIndex.h:164
friend uint32_t operator-(const TypeIndex &A, const TypeIndex &B)
Definition: TypeIndex.h:250
static TypeIndex UInt32Long()
Definition: TypeIndex.h:167
static TypeIndex Float64()
Definition: TypeIndex.h:178
uint32_t getIndex() const
Definition: TypeIndex.h:111
TypeIndex operator--(int)
Definition: TypeIndex.h:207
static TypeIndex WideCharacter()
Definition: TypeIndex.h:155
static TypeIndex Int32Long()
Definition: TypeIndex.h:166
friend bool operator>(const TypeIndex &A, const TypeIndex &B)
Definition: TypeIndex.h:229
friend bool operator<(const TypeIndex &A, const TypeIndex &B)
Definition: TypeIndex.h:221
static TypeIndex Void()
Definition: TypeIndex.h:138
static TypeIndex UnsignedCharacter()
Definition: TypeIndex.h:149
friend TypeIndex operator+(const TypeIndex &A, uint32_t N)
Definition: TypeIndex.h:237
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
static TypeIndex VoidPointer32()
Definition: TypeIndex.h:139
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
friend bool operator<=(const TypeIndex &A, const TypeIndex &B)
Definition: TypeIndex.h:225
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
static codeview::TypeIndex getEmptyKey()
Definition: TypeIndex.h:274
static TypeIndex None()
Definition: TypeIndex.h:137
static TypeIndex SignedCharacter()
Definition: TypeIndex.h:146
TypeIndex operator++(int)
Definition: TypeIndex.h:190