LLVM 17.0.0git
NativeTypeEnum.cpp
Go to the documentation of this file.
1//===- NativeTypeEnum.cpp - info about enum type ----------------*- 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
10
21
22#include <cassert>
23#include <optional>
24
25using namespace llvm;
26using namespace llvm::codeview;
27using namespace llvm::pdb;
28
29namespace {
30// Yea, this is a pretty terrible class name. But if we have an enum:
31//
32// enum Foo {
33// A,
34// B
35// };
36//
37// then A and B are the "enumerators" of the "enum" Foo. And we need
38// to enumerate them.
39class NativeEnumEnumEnumerators : public IPDBEnumSymbols, TypeVisitorCallbacks {
40public:
41 NativeEnumEnumEnumerators(NativeSession &Session,
42 const NativeTypeEnum &ClassParent);
43
44 uint32_t getChildCount() const override;
45 std::unique_ptr<PDBSymbol> getChildAtIndex(uint32_t Index) const override;
46 std::unique_ptr<PDBSymbol> getNext() override;
47 void reset() override;
48
49private:
51 EnumeratorRecord &Record) override;
54
55 NativeSession &Session;
57 std::vector<EnumeratorRecord> Enumerators;
58 std::optional<TypeIndex> ContinuationIndex;
59 uint32_t Index = 0;
60};
61} // namespace
62
63NativeEnumEnumEnumerators::NativeEnumEnumEnumerators(
65 : Session(Session), ClassParent(ClassParent) {
66 TpiStream &Tpi = cantFail(Session.getPDBFile().getPDBTpiStream());
68
69 ContinuationIndex = ClassParent.getEnumRecord().FieldList;
70 while (ContinuationIndex) {
71 CVType FieldListCVT = Types.getType(*ContinuationIndex);
72 assert(FieldListCVT.kind() == LF_FIELDLIST);
73 ContinuationIndex.reset();
75 cantFail(TypeDeserializer::deserializeAs<FieldListRecord>(FieldListCVT,
76 FieldList));
78 }
79}
80
81Error NativeEnumEnumEnumerators::visitKnownMember(CVMemberRecord &CVM,
83 Enumerators.push_back(Record);
84 return Error::success();
85}
86
87Error NativeEnumEnumEnumerators::visitKnownMember(
89 ContinuationIndex = Record.ContinuationIndex;
90 return Error::success();
91}
92
93uint32_t NativeEnumEnumEnumerators::getChildCount() const {
94 return Enumerators.size();
95}
96
97std::unique_ptr<PDBSymbol>
98NativeEnumEnumEnumerators::getChildAtIndex(uint32_t Index) const {
99 if (Index >= getChildCount())
100 return nullptr;
101
102 SymIndexId Id = Session.getSymbolCache()
104 ClassParent.getEnumRecord().FieldList, Index,
105 ClassParent, Enumerators[Index]);
106 return Session.getSymbolCache().getSymbolById(Id);
107}
108
109std::unique_ptr<PDBSymbol> NativeEnumEnumEnumerators::getNext() {
110 if (Index >= getChildCount())
111 return nullptr;
112
113 return getChildAtIndex(Index++);
114}
115
116void NativeEnumEnumEnumerators::reset() { Index = 0; }
117
120 : NativeRawSymbol(Session, PDB_SymType::Enum, Id), Index(Index),
121 Record(std::move(Record)) {}
122
126 : NativeRawSymbol(Session, PDB_SymType::Enum, Id),
127 UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
128
130
132 PdbSymbolIdField ShowIdFields,
133 PdbSymbolIdField RecurseIdFields) const {
134 NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
135
136 dumpSymbolField(OS, "baseType", static_cast<uint32_t>(getBuiltinType()),
137 Indent);
138 dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,
140 RecurseIdFields);
141 dumpSymbolField(OS, "name", getName(), Indent);
142 dumpSymbolIdField(OS, "typeId", getTypeId(), Indent, Session,
143 PdbSymbolIdField::Type, ShowIdFields, RecurseIdFields);
144 if (Modifiers)
145 dumpSymbolIdField(OS, "unmodifiedTypeId", getUnmodifiedTypeId(), Indent,
147 RecurseIdFields);
148 dumpSymbolField(OS, "length", getLength(), Indent);
149 dumpSymbolField(OS, "constructor", hasConstructor(), Indent);
150 dumpSymbolField(OS, "constType", isConstType(), Indent);
151 dumpSymbolField(OS, "hasAssignmentOperator", hasAssignmentOperator(), Indent);
152 dumpSymbolField(OS, "hasCastOperator", hasCastOperator(), Indent);
153 dumpSymbolField(OS, "hasNestedTypes", hasNestedTypes(), Indent);
154 dumpSymbolField(OS, "overloadedOperator", hasOverloadedOperator(), Indent);
155 dumpSymbolField(OS, "isInterfaceUdt", isInterfaceUdt(), Indent);
156 dumpSymbolField(OS, "intrinsic", isIntrinsic(), Indent);
157 dumpSymbolField(OS, "nested", isNested(), Indent);
158 dumpSymbolField(OS, "packed", isPacked(), Indent);
159 dumpSymbolField(OS, "isRefUdt", isRefUdt(), Indent);
160 dumpSymbolField(OS, "scoped", isScoped(), Indent);
161 dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
162 dumpSymbolField(OS, "isValueUdt", isValueUdt(), Indent);
163 dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
164}
165
166std::unique_ptr<IPDBEnumSymbols>
168 if (Type != PDB_SymType::Data)
169 return std::make_unique<NullEnumerator<PDBSymbol>>();
170
171 const NativeTypeEnum *ClassParent = nullptr;
172 if (!Modifiers)
173 ClassParent = this;
174 else
176 return std::make_unique<NativeEnumEnumEnumerators>(Session, *ClassParent);
177}
178
180
182 if (UnmodifiedType)
184
185 Session.getSymbolCache().findSymbolByTypeIndex(Record->getUnderlyingType());
186
187 codeview::TypeIndex Underlying = Record->getUnderlyingType();
188
189 // This indicates a corrupt record.
190 if (!Underlying.isSimple() ||
191 Underlying.getSimpleMode() != SimpleTypeMode::Direct) {
193 }
194
195 switch (Underlying.getSimpleKind()) {
196 case SimpleTypeKind::Boolean128:
197 case SimpleTypeKind::Boolean64:
198 case SimpleTypeKind::Boolean32:
199 case SimpleTypeKind::Boolean16:
200 case SimpleTypeKind::Boolean8:
202 case SimpleTypeKind::NarrowCharacter:
203 case SimpleTypeKind::UnsignedCharacter:
204 case SimpleTypeKind::SignedCharacter:
206 case SimpleTypeKind::WideCharacter:
208 case SimpleTypeKind::Character16:
210 case SimpleTypeKind::Character32:
212 case SimpleTypeKind::Character8:
214 case SimpleTypeKind::Int128:
215 case SimpleTypeKind::Int128Oct:
216 case SimpleTypeKind::Int16:
217 case SimpleTypeKind::Int16Short:
218 case SimpleTypeKind::Int32:
219 case SimpleTypeKind::Int32Long:
220 case SimpleTypeKind::Int64:
221 case SimpleTypeKind::Int64Quad:
223 case SimpleTypeKind::UInt128:
224 case SimpleTypeKind::UInt128Oct:
225 case SimpleTypeKind::UInt16:
226 case SimpleTypeKind::UInt16Short:
227 case SimpleTypeKind::UInt32:
228 case SimpleTypeKind::UInt32Long:
229 case SimpleTypeKind::UInt64:
230 case SimpleTypeKind::UInt64Quad:
232 case SimpleTypeKind::HResult:
234 case SimpleTypeKind::Complex16:
235 case SimpleTypeKind::Complex32:
236 case SimpleTypeKind::Complex32PartialPrecision:
237 case SimpleTypeKind::Complex64:
238 case SimpleTypeKind::Complex80:
239 case SimpleTypeKind::Complex128:
241 case SimpleTypeKind::Float16:
242 case SimpleTypeKind::Float32:
243 case SimpleTypeKind::Float32PartialPrecision:
244 case SimpleTypeKind::Float48:
245 case SimpleTypeKind::Float64:
246 case SimpleTypeKind::Float80:
247 case SimpleTypeKind::Float128:
249 default:
251 }
252 llvm_unreachable("Unreachable");
253}
254
257}
258
260 if (UnmodifiedType)
262
263 return bool(Record->getOptions() &
265}
266
268 if (UnmodifiedType)
270
271 return bool(Record->getOptions() &
273}
274
276 if (UnmodifiedType)
278
279 return bool(Record->getOptions() &
281}
282
284 if (UnmodifiedType)
285 return UnmodifiedType->isIntrinsic();
286
287 return bool(Record->getOptions() & codeview::ClassOptions::Intrinsic);
288}
289
291 if (UnmodifiedType)
293
294 return bool(Record->getOptions() &
296}
297
299 if (UnmodifiedType)
300 return UnmodifiedType->getLength();
301
303 Record->getUnderlyingType());
304 const auto UnderlyingType =
306 return UnderlyingType ? UnderlyingType->getLength() : 0;
307}
308
309std::string NativeTypeEnum::getName() const {
310 if (UnmodifiedType)
311 return UnmodifiedType->getName();
312
313 return std::string(Record->getName());
314}
315
317 if (UnmodifiedType)
318 return UnmodifiedType->isNested();
319
320 return bool(Record->getOptions() & codeview::ClassOptions::Nested);
321}
322
324 if (UnmodifiedType)
326
327 return bool(Record->getOptions() &
329}
330
332 if (UnmodifiedType)
333 return UnmodifiedType->isPacked();
334
335 return bool(Record->getOptions() & codeview::ClassOptions::Packed);
336}
337
339 if (UnmodifiedType)
340 return UnmodifiedType->isScoped();
341
342 return bool(Record->getOptions() & codeview::ClassOptions::Scoped);
343}
344
346 if (UnmodifiedType)
347 return UnmodifiedType->getTypeId();
348
350 Record->getUnderlyingType());
351}
352
353bool NativeTypeEnum::isRefUdt() const { return false; }
354
355bool NativeTypeEnum::isValueUdt() const { return false; }
356
357bool NativeTypeEnum::isInterfaceUdt() const { return false; }
358
360 if (!Modifiers)
361 return false;
362 return ((Modifiers->getModifiers() & ModifierOptions::Const) !=
363 ModifierOptions::None);
364}
365
367 if (!Modifiers)
368 return false;
369 return ((Modifiers->getModifiers() & ModifierOptions::Volatile) !=
370 ModifierOptions::None);
371}
372
374 if (!Modifiers)
375 return false;
376 return ((Modifiers->getModifiers() & ModifierOptions::Unaligned) !=
377 ModifierOptions::None);
378}
379
381 if (UnmodifiedType)
383
385 getTypeId());
386}
static Error visitKnownMember(CVMemberRecord &Record, TypeVisitorCallbacks &Callbacks)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
StringRef getName() const
Definition: Record.h:1648
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Kind kind() const
Definition: CVRecord.h:42
Provides amortized O(1) random access to a CodeView type stream.
LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records together.
Definition: TypeRecord.h:915
A 32-bit type reference.
Definition: TypeIndex.h:96
virtual uint32_t getChildCount() const=0
virtual ChildTypePtr getChildAtIndex(uint32_t Index) const=0
std::unique_ptr< T > getConcreteSymbolById(SymIndexId SymbolId) const
Definition: IPDBSession.h:41
SymIndexId getSymIndexId() const override
void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields, PdbSymbolIdField RecurseIdFields) const override
SymbolCache & getSymbolCache()
bool isVolatileType() const override
bool isScoped() const override
bool hasOverloadedOperator() const override
bool isIntrinsic() const override
bool isPacked() const override
std::string getName() const override
void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields, PdbSymbolIdField RecurseIdFields) const override
bool hasAssignmentOperator() const override
bool isNested() const override
bool isValueUdt() const override
bool isUnalignedType() const override
bool isInterfaceUdt() const override
std::unique_ptr< IPDBEnumSymbols > findChildren(PDB_SymType Type) const override
bool hasCastOperator() const override
PDB_BuiltinType getBuiltinType() const override
bool hasConstructor() const override
SymIndexId getTypeId() const override
bool isConstType() const override
const NativeTypeBuiltin & getUnderlyingBuiltinType() const
bool hasNestedTypes() const override
PDB_SymType getSymTag() const override
SymIndexId getUnmodifiedTypeId() const override
std::optional< codeview::ModifierRecord > Modifiers
NativeTypeEnum * UnmodifiedType
uint64_t getLength() const override
bool isRefUdt() const override
NativeTypeEnum(NativeSession &Session, SymIndexId Id, codeview::TypeIndex TI, codeview::EnumRecord Record)
Expected< TpiStream & > getPDBTpiStream()
Definition: PDBFile.cpp:301
SymIndexId getOrCreateFieldListMember(codeview::TypeIndex FieldListTI, uint32_t Index, Args &&... ConstructorArgs)
Definition: SymbolCache.h:157
std::unique_ptr< PDBSymbol > getSymbolById(SymIndexId SymbolId) const
SymIndexId findSymbolByTypeIndex(codeview::TypeIndex TI) const
NativeRawSymbol & getNativeSymbolById(SymIndexId SymbolId) const
codeview::LazyRandomTypeCollection & typeCollection()
Definition: TpiStream.h:59
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Error visitMemberRecordStream(ArrayRef< uint8_t > FieldList, TypeVisitorCallbacks &Callbacks)
uint32_t SymIndexId
Definition: PDBTypes.h:26
void dumpSymbolField(raw_ostream &OS, StringRef Name, T Value, int Indent)
Definition: PDBExtras.h:47
PDB_BuiltinType
These values correspond to the Basictype enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:335
PDB_SymType
These values correspond to the SymTagEnum enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:243
void dumpSymbolIdField(raw_ostream &OS, StringRef Name, SymIndexId Value, int Indent, const IPDBSession &Session, PdbSymbolIdField FieldId, PdbSymbolIdField ShowFlags, PdbSymbolIdField RecurseFlags)
Definition: PDBSymbol.cpp:202
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:745
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1862
Definition: BitVector.h:851