Line data Source code
1 : //===- NativeTypeUDT.cpp - info about class/struct type ---------*- 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 : #include "llvm/DebugInfo/PDB/Native/NativeTypeUDT.h"
11 :
12 : #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
13 :
14 : #include <cassert>
15 :
16 : using namespace llvm;
17 : using namespace llvm::codeview;
18 : using namespace llvm::pdb;
19 :
20 74 : NativeTypeUDT::NativeTypeUDT(NativeSession &Session, SymIndexId Id,
21 74 : codeview::TypeIndex TI, codeview::ClassRecord CR)
22 : : NativeRawSymbol(Session, PDB_SymType::UDT, Id), Index(TI),
23 74 : Class(std::move(CR)), Tag(Class.getPointer()) {}
24 :
25 2 : NativeTypeUDT::NativeTypeUDT(NativeSession &Session, SymIndexId Id,
26 2 : codeview::TypeIndex TI, codeview::UnionRecord UR)
27 : : NativeRawSymbol(Session, PDB_SymType::UDT, Id), Index(TI),
28 2 : Union(std::move(UR)), Tag(Union.getPointer()) {}
29 :
30 20 : NativeTypeUDT::NativeTypeUDT(NativeSession &Session, SymIndexId Id,
31 : NativeTypeUDT &UnmodifiedType,
32 20 : codeview::ModifierRecord Modifier)
33 : : NativeRawSymbol(Session, PDB_SymType::UDT, Id),
34 20 : UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
35 :
36 192 : NativeTypeUDT::~NativeTypeUDT() {}
37 :
38 22 : void NativeTypeUDT::dump(raw_ostream &OS, int Indent,
39 : PdbSymbolIdField ShowIdFields,
40 : PdbSymbolIdField RecurseIdFields) const {
41 :
42 22 : NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
43 :
44 22 : dumpSymbolField(OS, "name", getName(), Indent);
45 44 : dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,
46 : PdbSymbolIdField::LexicalParent, ShowIdFields,
47 : RecurseIdFields);
48 22 : if (Modifiers.hasValue())
49 4 : dumpSymbolIdField(OS, "unmodifiedTypeId", getUnmodifiedTypeId(), Indent,
50 4 : Session, PdbSymbolIdField::UnmodifiedType, ShowIdFields,
51 : RecurseIdFields);
52 22 : if (getUdtKind() != PDB_UdtType::Union)
53 21 : dumpSymbolField(OS, "virtualTableShapeId", getVirtualTableShapeId(),
54 : Indent);
55 22 : dumpSymbolField(OS, "length", getLength(), Indent);
56 22 : dumpSymbolField(OS, "udtKind", getUdtKind(), Indent);
57 22 : dumpSymbolField(OS, "constructor", hasConstructor(), Indent);
58 22 : dumpSymbolField(OS, "constType", isConstType(), Indent);
59 22 : dumpSymbolField(OS, "hasAssignmentOperator", hasAssignmentOperator(), Indent);
60 22 : dumpSymbolField(OS, "hasCastOperator", hasCastOperator(), Indent);
61 22 : dumpSymbolField(OS, "hasNestedTypes", hasNestedTypes(), Indent);
62 22 : dumpSymbolField(OS, "overloadedOperator", hasOverloadedOperator(), Indent);
63 22 : dumpSymbolField(OS, "isInterfaceUdt", isInterfaceUdt(), Indent);
64 22 : dumpSymbolField(OS, "intrinsic", isIntrinsic(), Indent);
65 22 : dumpSymbolField(OS, "nested", isNested(), Indent);
66 22 : dumpSymbolField(OS, "packed", isPacked(), Indent);
67 22 : dumpSymbolField(OS, "isRefUdt", isRefUdt(), Indent);
68 22 : dumpSymbolField(OS, "scoped", isScoped(), Indent);
69 22 : dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
70 22 : dumpSymbolField(OS, "isValueUdt", isValueUdt(), Indent);
71 22 : dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
72 22 : }
73 :
74 189 : std::string NativeTypeUDT::getName() const {
75 189 : if (UnmodifiedType)
76 24 : return UnmodifiedType->getName();
77 :
78 165 : return Tag->getName();
79 : }
80 :
81 0 : SymIndexId NativeTypeUDT::getLexicalParentId() const { return 0; }
82 :
83 46 : SymIndexId NativeTypeUDT::getUnmodifiedTypeId() const {
84 46 : if (UnmodifiedType)
85 16 : return UnmodifiedType->getSymIndexId();
86 :
87 : return 0;
88 : }
89 :
90 25 : SymIndexId NativeTypeUDT::getVirtualTableShapeId() const {
91 25 : if (UnmodifiedType)
92 4 : return UnmodifiedType->getVirtualTableShapeId();
93 :
94 21 : if (Class)
95 42 : return Session.getSymbolCache().findSymbolByTypeIndex(Class->VTableShape);
96 :
97 : return 0;
98 : }
99 :
100 70 : uint64_t NativeTypeUDT::getLength() const {
101 70 : if (UnmodifiedType)
102 8 : return UnmodifiedType->getLength();
103 :
104 62 : if (Class)
105 59 : return Class->getSize();
106 :
107 3 : return Union->getSize();
108 : }
109 :
110 98 : PDB_UdtType NativeTypeUDT::getUdtKind() const {
111 98 : if (UnmodifiedType)
112 16 : return UnmodifiedType->getUdtKind();
113 :
114 82 : switch (Tag->Kind) {
115 : case TypeRecordKind::Class:
116 : return PDB_UdtType::Class;
117 3 : case TypeRecordKind::Union:
118 3 : return PDB_UdtType::Union;
119 76 : case TypeRecordKind::Struct:
120 76 : return PDB_UdtType::Struct;
121 0 : case TypeRecordKind::Interface:
122 0 : return PDB_UdtType::Interface;
123 0 : default:
124 0 : llvm_unreachable("Unexected udt kind");
125 : }
126 : }
127 :
128 26 : bool NativeTypeUDT::hasConstructor() const {
129 26 : if (UnmodifiedType)
130 4 : return UnmodifiedType->hasConstructor();
131 :
132 22 : return (Tag->Options & ClassOptions::HasConstructorOrDestructor) !=
133 22 : ClassOptions::None;
134 : }
135 :
136 48 : bool NativeTypeUDT::isConstType() const {
137 48 : if (!Modifiers)
138 : return false;
139 12 : return (Modifiers->Modifiers & ModifierOptions::Const) !=
140 12 : ModifierOptions::None;
141 : }
142 :
143 26 : bool NativeTypeUDT::hasAssignmentOperator() const {
144 26 : if (UnmodifiedType)
145 4 : return UnmodifiedType->hasAssignmentOperator();
146 :
147 22 : return (Tag->Options & ClassOptions::HasOverloadedAssignmentOperator) !=
148 22 : ClassOptions::None;
149 : }
150 :
151 26 : bool NativeTypeUDT::hasCastOperator() const {
152 26 : if (UnmodifiedType)
153 4 : return UnmodifiedType->hasCastOperator();
154 :
155 22 : return (Tag->Options & ClassOptions::HasConversionOperator) !=
156 22 : ClassOptions::None;
157 : }
158 :
159 26 : bool NativeTypeUDT::hasNestedTypes() const {
160 26 : if (UnmodifiedType)
161 4 : return UnmodifiedType->hasNestedTypes();
162 :
163 22 : return (Tag->Options & ClassOptions::ContainsNestedClass) !=
164 22 : ClassOptions::None;
165 : }
166 :
167 26 : bool NativeTypeUDT::hasOverloadedOperator() const {
168 26 : if (UnmodifiedType)
169 4 : return UnmodifiedType->hasOverloadedOperator();
170 :
171 22 : return (Tag->Options & ClassOptions::HasOverloadedOperator) !=
172 22 : ClassOptions::None;
173 : }
174 :
175 22 : bool NativeTypeUDT::isInterfaceUdt() const { return false; }
176 :
177 26 : bool NativeTypeUDT::isIntrinsic() const {
178 26 : if (UnmodifiedType)
179 4 : return UnmodifiedType->isIntrinsic();
180 :
181 44 : return (Tag->Options & ClassOptions::Intrinsic) != ClassOptions::None;
182 : }
183 :
184 26 : bool NativeTypeUDT::isNested() const {
185 26 : if (UnmodifiedType)
186 4 : return UnmodifiedType->isNested();
187 :
188 44 : return (Tag->Options & ClassOptions::Nested) != ClassOptions::None;
189 : }
190 :
191 26 : bool NativeTypeUDT::isPacked() const {
192 26 : if (UnmodifiedType)
193 4 : return UnmodifiedType->isPacked();
194 :
195 44 : return (Tag->Options & ClassOptions::Packed) != ClassOptions::None;
196 : }
197 :
198 22 : bool NativeTypeUDT::isRefUdt() const { return false; }
199 :
200 26 : bool NativeTypeUDT::isScoped() const {
201 26 : if (UnmodifiedType)
202 4 : return UnmodifiedType->isScoped();
203 :
204 44 : return (Tag->Options & ClassOptions::Scoped) != ClassOptions::None;
205 : }
206 :
207 22 : bool NativeTypeUDT::isValueUdt() const { return false; }
208 :
209 48 : bool NativeTypeUDT::isUnalignedType() const {
210 48 : if (!Modifiers)
211 : return false;
212 12 : return (Modifiers->Modifiers & ModifierOptions::Unaligned) !=
213 12 : ModifierOptions::None;
214 : }
215 :
216 48 : bool NativeTypeUDT::isVolatileType() const {
217 48 : if (!Modifiers)
218 : return false;
219 12 : return (Modifiers->Modifiers & ModifierOptions::Volatile) !=
220 12 : ModifierOptions::None;
221 : }
|
