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