LLVM 20.0.0git
NativeTypeUDT.cpp
Go to the documentation of this file.
1//===- NativeTypeUDT.cpp - info about class/struct 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
15
16using namespace llvm;
17using namespace llvm::codeview;
18using namespace llvm::pdb;
19
22 : NativeRawSymbol(Session, PDB_SymType::UDT, Id), Index(TI),
23 Class(std::move(CR)), Tag(&*Class) {}
24
27 : NativeRawSymbol(Session, PDB_SymType::UDT, Id), Index(TI),
28 Union(std::move(UR)), Tag(&*Union) {}
29
33 : NativeRawSymbol(Session, PDB_SymType::UDT, Id),
34 UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
35
37
39 PdbSymbolIdField ShowIdFields,
40 PdbSymbolIdField RecurseIdFields) const {
41
42 NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
43
44 dumpSymbolField(OS, "name", getName(), Indent);
45 dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,
47 RecurseIdFields);
48 if (Modifiers)
49 dumpSymbolIdField(OS, "unmodifiedTypeId", getUnmodifiedTypeId(), Indent,
51 RecurseIdFields);
53 dumpSymbolField(OS, "virtualTableShapeId", getVirtualTableShapeId(),
54 Indent);
55 dumpSymbolField(OS, "length", getLength(), Indent);
56 dumpSymbolField(OS, "udtKind", getUdtKind(), Indent);
57 dumpSymbolField(OS, "constructor", hasConstructor(), Indent);
58 dumpSymbolField(OS, "constType", isConstType(), Indent);
59 dumpSymbolField(OS, "hasAssignmentOperator", hasAssignmentOperator(), Indent);
60 dumpSymbolField(OS, "hasCastOperator", hasCastOperator(), Indent);
61 dumpSymbolField(OS, "hasNestedTypes", hasNestedTypes(), Indent);
62 dumpSymbolField(OS, "overloadedOperator", hasOverloadedOperator(), Indent);
63 dumpSymbolField(OS, "isInterfaceUdt", isInterfaceUdt(), Indent);
64 dumpSymbolField(OS, "intrinsic", isIntrinsic(), Indent);
65 dumpSymbolField(OS, "nested", isNested(), Indent);
66 dumpSymbolField(OS, "packed", isPacked(), Indent);
67 dumpSymbolField(OS, "isRefUdt", isRefUdt(), Indent);
68 dumpSymbolField(OS, "scoped", isScoped(), Indent);
69 dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
70 dumpSymbolField(OS, "isValueUdt", isValueUdt(), Indent);
71 dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
72}
73
74std::string NativeTypeUDT::getName() const {
76 return UnmodifiedType->getName();
77
78 return std::string(Tag->getName());
79}
80
82
86
87 return 0;
88}
89
93
94 if (Class)
96
97 return 0;
98}
99
101 if (UnmodifiedType)
102 return UnmodifiedType->getLength();
103
104 if (Class)
105 return Class->getSize();
106
107 return Union->getSize();
108}
109
111 if (UnmodifiedType)
112 return UnmodifiedType->getUdtKind();
113
114 switch (Tag->Kind) {
115 case TypeRecordKind::Class:
116 return PDB_UdtType::Class;
117 case TypeRecordKind::Union:
118 return PDB_UdtType::Union;
119 case TypeRecordKind::Struct:
120 return PDB_UdtType::Struct;
121 case TypeRecordKind::Interface:
123 default:
124 llvm_unreachable("Unexpected udt kind");
125 }
126}
127
129 if (UnmodifiedType)
131
132 return (Tag->Options & ClassOptions::HasConstructorOrDestructor) !=
133 ClassOptions::None;
134}
135
137 if (!Modifiers)
138 return false;
139 return (Modifiers->Modifiers & ModifierOptions::Const) !=
140 ModifierOptions::None;
141}
142
144 if (UnmodifiedType)
146
147 return (Tag->Options & ClassOptions::HasOverloadedAssignmentOperator) !=
148 ClassOptions::None;
149}
150
152 if (UnmodifiedType)
154
155 return (Tag->Options & ClassOptions::HasConversionOperator) !=
156 ClassOptions::None;
157}
158
160 if (UnmodifiedType)
162
163 return (Tag->Options & ClassOptions::ContainsNestedClass) !=
164 ClassOptions::None;
165}
166
168 if (UnmodifiedType)
170
171 return (Tag->Options & ClassOptions::HasOverloadedOperator) !=
172 ClassOptions::None;
173}
174
175bool NativeTypeUDT::isInterfaceUdt() const { return false; }
176
178 if (UnmodifiedType)
179 return UnmodifiedType->isIntrinsic();
180
181 return (Tag->Options & ClassOptions::Intrinsic) != ClassOptions::None;
182}
183
185 if (UnmodifiedType)
186 return UnmodifiedType->isNested();
187
188 return (Tag->Options & ClassOptions::Nested) != ClassOptions::None;
189}
190
192 if (UnmodifiedType)
193 return UnmodifiedType->isPacked();
194
195 return (Tag->Options & ClassOptions::Packed) != ClassOptions::None;
196}
197
198bool NativeTypeUDT::isRefUdt() const { return false; }
199
201 if (UnmodifiedType)
202 return UnmodifiedType->isScoped();
203
204 return (Tag->Options & ClassOptions::Scoped) != ClassOptions::None;
205}
206
207bool NativeTypeUDT::isValueUdt() const { return false; }
208
210 if (!Modifiers)
211 return false;
212 return (Modifiers->Modifiers & ModifierOptions::Unaligned) !=
213 ModifierOptions::None;
214}
215
217 if (!Modifiers)
218 return false;
219 return (Modifiers->Modifiers & ModifierOptions::Volatile) !=
220 ModifierOptions::None;
221}
raw_pwrite_stream & OS
A 32-bit type reference.
Definition: TypeIndex.h:96
SymIndexId getSymIndexId() const override
void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields, PdbSymbolIdField RecurseIdFields) const override
SymbolCache & getSymbolCache()
PDB_UdtType getUdtKind() const override
SymIndexId getVirtualTableShapeId() const override
bool hasNestedTypes() const override
bool isPacked() const override
bool isRefUdt() const override
bool isUnalignedType() const override
uint64_t getLength() const override
bool isVolatileType() const override
bool isValueUdt() const override
void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields, PdbSymbolIdField RecurseIdFields) const override
bool isScoped() const override
NativeTypeUDT * UnmodifiedType
Definition: NativeTypeUDT.h:68
SymIndexId getUnmodifiedTypeId() const override
NativeTypeUDT(NativeSession &Session, SymIndexId Id, codeview::TypeIndex TI, codeview::ClassRecord Class)
SymIndexId getLexicalParentId() const override
std::optional< codeview::UnionRecord > Union
Definition: NativeTypeUDT.h:67
std::optional< codeview::ClassRecord > Class
Definition: NativeTypeUDT.h:66
bool hasAssignmentOperator() const override
bool hasCastOperator() const override
std::optional< codeview::ModifierRecord > Modifiers
Definition: NativeTypeUDT.h:70
bool hasConstructor() const override
std::string getName() const override
bool isConstType() const override
bool hasOverloadedOperator() const override
bool isNested() const override
bool isIntrinsic() const override
bool isInterfaceUdt() const override
SymIndexId findSymbolByTypeIndex(codeview::TypeIndex TI) const
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.
void dumpSymbolField(raw_ostream &OS, StringRef Name, T Value, int Indent)
Definition: PDBExtras.h:47
PDB_UdtType
These values correspond to the UdtKind enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:310
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
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:1849
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858