LLVM 20.0.0git
TypeDumpVisitor.cpp
Go to the documentation of this file.
1//===-- TypeDumpVisitor.cpp - CodeView type info dumper ----------*- 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
11#include "llvm/ADT/ArrayRef.h"
20
21using namespace llvm;
22using namespace llvm::codeview;
23
25#define CV_TYPE(enum, val) {#enum, enum},
26#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
27};
28
29#define ENUM_ENTRY(enum_class, enum) \
30 { #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
31
45};
46
50};
51
58};
59
68};
69
84};
85
92};
93
104};
105
109};
110
137};
138
143};
144
147};
148
149#undef ENUM_ENTRY
150
152 switch (LT) {
153#define TYPE_RECORD(ename, value, name) \
154 case ename: \
155 return #name;
156#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
157 default:
158 break;
159 }
160 return "UnknownLeaf";
161}
162
164 codeview::printTypeIndex(*W, FieldName, TI, TpiTypes);
165}
166
168 codeview::printTypeIndex(*W, FieldName, TI, getSourceTypes());
169}
170
173}
174
176 W->startLine() << getLeafTypeName(Record.kind());
177 W->getOStream() << " (" << HexNumber(Index.getIndex()) << ")";
178 W->getOStream() << " {\n";
179 W->indent();
180 W->printEnum("TypeLeafKind", unsigned(Record.kind()),
182 return Error::success();
183}
184
186 if (PrintRecordBytes)
187 W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));
188
189 W->unindent();
190 W->startLine() << "}\n";
191 return Error::success();
192}
193
195 W->startLine() << getLeafTypeName(Record.Kind);
196 W->getOStream() << " {\n";
197 W->indent();
198 W->printEnum("TypeLeafKind", unsigned(Record.Kind), ArrayRef(LeafTypeNames));
199 return Error::success();
200}
201
203 if (PrintRecordBytes)
204 W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));
205
206 W->unindent();
207 W->startLine() << "}\n";
208 return Error::success();
209}
210
211Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
213 if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
214 return EC;
215
216 return Error::success();
217}
218
219Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringIdRecord &String) {
220 printItemIndex("Id", String.getId());
221 W->printString("StringData", String.getString());
222 return Error::success();
223}
224
225Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
226 auto Indices = Args.getIndices();
227 uint32_t Size = Indices.size();
228 W->printNumber("NumArgs", Size);
229 ListScope Arguments(*W, "Arguments");
230 for (uint32_t I = 0; I < Size; ++I) {
231 printTypeIndex("ArgType", Indices[I]);
232 }
233 return Error::success();
234}
235
236Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringListRecord &Strs) {
237 auto Indices = Strs.getIndices();
238 uint32_t Size = Indices.size();
239 W->printNumber("NumStrings", Size);
240 ListScope Arguments(*W, "Strings");
241 for (uint32_t I = 0; I < Size; ++I) {
242 printItemIndex("String", Indices[I]);
243 }
244 return Error::success();
245}
246
247Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
248 uint16_t Props = static_cast<uint16_t>(Class.getOptions());
249 W->printNumber("MemberCount", Class.getMemberCount());
250 W->printFlags("Properties", Props, ArrayRef(ClassOptionNames));
251 printTypeIndex("FieldList", Class.getFieldList());
252 printTypeIndex("DerivedFrom", Class.getDerivationList());
253 printTypeIndex("VShape", Class.getVTableShape());
254 W->printNumber("SizeOf", Class.getSize());
255 W->printString("Name", Class.getName());
257 W->printString("LinkageName", Class.getUniqueName());
258 return Error::success();
259}
260
261Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
262 uint16_t Props = static_cast<uint16_t>(Union.getOptions());
263 W->printNumber("MemberCount", Union.getMemberCount());
264 W->printFlags("Properties", Props, ArrayRef(ClassOptionNames));
265 printTypeIndex("FieldList", Union.getFieldList());
266 W->printNumber("SizeOf", Union.getSize());
267 W->printString("Name", Union.getName());
269 W->printString("LinkageName", Union.getUniqueName());
270 return Error::success();
271}
272
273Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
274 uint16_t Props = static_cast<uint16_t>(Enum.getOptions());
275 W->printNumber("NumEnumerators", Enum.getMemberCount());
276 W->printFlags("Properties", uint16_t(Enum.getOptions()),
278 printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
279 printTypeIndex("FieldListType", Enum.getFieldList());
280 W->printString("Name", Enum.getName());
282 W->printString("LinkageName", Enum.getUniqueName());
283 return Error::success();
284}
285
286Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
287 printTypeIndex("ElementType", AT.getElementType());
288 printTypeIndex("IndexType", AT.getIndexType());
289 W->printNumber("SizeOf", AT.getSize());
290 W->printString("Name", AT.getName());
291 return Error::success();
292}
293
294Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {
295 printTypeIndex("CompleteClass", VFT.getCompleteClass());
296 printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());
297 W->printHex("VFPtrOffset", VFT.getVFPtrOffset());
298 W->printString("VFTableName", VFT.getName());
299 for (auto N : VFT.getMethodNames())
300 W->printString("MethodName", N);
301 return Error::success();
302}
303
304Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {
305 printTypeIndex("ClassType", Id.getClassType());
306 printTypeIndex("FunctionType", Id.getFunctionType());
307 W->printString("Name", Id.getName());
308 return Error::success();
309}
310
311Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
312 printTypeIndex("ReturnType", Proc.getReturnType());
313 W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
315 W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
317 W->printNumber("NumParameters", Proc.getParameterCount());
318 printTypeIndex("ArgListType", Proc.getArgumentList());
319 return Error::success();
320}
321
322Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFunctionRecord &MF) {
323 printTypeIndex("ReturnType", MF.getReturnType());
324 printTypeIndex("ClassType", MF.getClassType());
325 printTypeIndex("ThisType", MF.getThisType());
326 W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),
328 W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),
330 W->printNumber("NumParameters", MF.getParameterCount());
331 printTypeIndex("ArgListType", MF.getArgumentList());
332 W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
333 return Error::success();
334}
335
336Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
337 MethodOverloadListRecord &MethodList) {
338 for (const auto &M : MethodList.getMethods()) {
339 ListScope S(*W, "Method");
340 printMemberAttributes(M.getAccess(), M.getMethodKind(), M.getOptions());
341 printTypeIndex("Type", M.getType());
342 if (M.isIntroducingVirtual())
343 W->printHex("VFTableOffset", M.getVFTableOffset());
344 }
345 return Error::success();
346}
347
348Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
349 printItemIndex("ParentScope", Func.getParentScope());
350 printTypeIndex("FunctionType", Func.getFunctionType());
351 W->printString("Name", Func.getName());
352 return Error::success();
353}
354
355Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
356 W->printString("Guid", formatv("{0}", TS.getGuid()).str());
357 W->printNumber("Age", TS.getAge());
358 W->printString("Name", TS.getName());
359 return Error::success();
360}
361
362Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
363 printTypeIndex("PointeeType", Ptr.getReferentType());
364 W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
366 W->printEnum("PtrMode", unsigned(Ptr.getMode()), ArrayRef(PtrModeNames));
367
368 W->printNumber("IsFlat", Ptr.isFlat());
369 W->printNumber("IsConst", Ptr.isConst());
370 W->printNumber("IsVolatile", Ptr.isVolatile());
371 W->printNumber("IsUnaligned", Ptr.isUnaligned());
372 W->printNumber("IsRestrict", Ptr.isRestrict());
373 W->printNumber("IsThisPtr&", Ptr.isLValueReferenceThisPtr());
374 W->printNumber("IsThisPtr&&", Ptr.isRValueReferenceThisPtr());
375 W->printNumber("SizeOf", Ptr.getSize());
376
377 if (Ptr.isPointerToMember()) {
378 const MemberPointerInfo &MI = Ptr.getMemberInfo();
379
380 printTypeIndex("ClassType", MI.getContainingType());
381 W->printEnum("Representation", uint16_t(MI.getRepresentation()),
383 }
384
385 return Error::success();
386}
387
388Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
389 uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
390 printTypeIndex("ModifiedType", Mod.getModifiedType());
391 W->printFlags("Modifiers", Mods, ArrayRef(TypeModifierNames));
392
393 return Error::success();
394}
395
396Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BitFieldRecord &BitField) {
397 printTypeIndex("Type", BitField.getType());
398 W->printNumber("BitSize", BitField.getBitSize());
399 W->printNumber("BitOffset", BitField.getBitOffset());
400 return Error::success();
401}
402
403Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
404 VFTableShapeRecord &Shape) {
405 W->printNumber("VFEntryCount", Shape.getEntryCount());
406 return Error::success();
407}
408
409Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
411 printTypeIndex("UDT", Line.getUDT());
412 printItemIndex("SourceFile", Line.getSourceFile());
413 W->printNumber("LineNumber", Line.getLineNumber());
414 return Error::success();
415}
416
417Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
419 printTypeIndex("UDT", Line.getUDT());
420 printItemIndex("SourceFile", Line.getSourceFile());
421 W->printNumber("LineNumber", Line.getLineNumber());
422 W->printNumber("Module", Line.getModule());
423 return Error::success();
424}
425
426Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BuildInfoRecord &Args) {
427 W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
428
429 ListScope Arguments(*W, "Arguments");
430 for (auto Arg : Args.getArgs()) {
431 printItemIndex("ArgType", Arg);
432 }
433 return Error::success();
434}
435
436void TypeDumpVisitor::printMemberAttributes(MemberAttributes Attrs) {
437 return printMemberAttributes(Attrs.getAccess(), Attrs.getMethodKind(),
438 Attrs.getFlags());
439}
440
441void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,
442 MethodKind Kind,
444 W->printEnum("AccessSpecifier", uint8_t(Access), ArrayRef(MemberAccessNames));
445 // Data members will be vanilla. Don't try to print a method kind for them.
446 if (Kind != MethodKind::Vanilla)
447 W->printEnum("MethodKind", unsigned(Kind), ArrayRef(MemberKindNames));
449 W->printFlags("MethodOptions", unsigned(Options),
451 }
452}
453
455 W->printHex("UnknownMember", unsigned(Record.Kind));
456 return Error::success();
457}
458
460 W->printEnum("Kind", uint16_t(Record.kind()), ArrayRef(LeafTypeNames));
461 W->printNumber("Length", uint32_t(Record.content().size()));
462 return Error::success();
463}
464
465Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
467 printTypeIndex("Type", Nested.getNestedType());
468 W->printString("Name", Nested.getName());
469 return Error::success();
470}
471
472Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
473 OneMethodRecord &Method) {
474 MethodKind K = Method.getMethodKind();
475 printMemberAttributes(Method.getAccess(), K, Method.getOptions());
476 printTypeIndex("Type", Method.getType());
477 // If virtual, then read the vftable offset.
478 if (Method.isIntroducingVirtual())
479 W->printHex("VFTableOffset", Method.getVFTableOffset());
480 W->printString("Name", Method.getName());
481 return Error::success();
482}
483
484Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
485 OverloadedMethodRecord &Method) {
486 W->printHex("MethodCount", Method.getNumOverloads());
487 printTypeIndex("MethodListIndex", Method.getMethodList());
488 W->printString("Name", Method.getName());
489 return Error::success();
490}
491
492Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
494 printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
496 printTypeIndex("Type", Field.getType());
497 W->printHex("FieldOffset", Field.getFieldOffset());
498 W->printString("Name", Field.getName());
499 return Error::success();
500}
501
502Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
504 printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
506 printTypeIndex("Type", Field.getType());
507 W->printString("Name", Field.getName());
508 return Error::success();
509}
510
511Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
512 VFPtrRecord &VFTable) {
513 printTypeIndex("Type", VFTable.getType());
514 return Error::success();
515}
516
517Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
518 EnumeratorRecord &Enum) {
519 printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
521 W->printNumber("EnumValue", Enum.getValue());
522 W->printString("Name", Enum.getName());
523 return Error::success();
524}
525
526Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
528 printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
530 printTypeIndex("BaseType", Base.getBaseType());
531 W->printHex("BaseOffset", Base.getBaseOffset());
532 return Error::success();
533}
534
535Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
537 printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
539 printTypeIndex("BaseType", Base.getBaseType());
540 printTypeIndex("VBPtrType", Base.getVBPtrType());
541 W->printHex("VBPtrOffset", Base.getVBPtrOffset());
542 W->printHex("VBTableIndex", Base.getVTableIndex());
543 return Error::success();
544}
545
546Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
548 printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());
549 return Error::success();
550}
551
552Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) {
553 W->printEnum("Mode", uint16_t(LR.Mode), ArrayRef(LabelTypeEnum));
554 return Error::success();
555}
556
557Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
558 PrecompRecord &Precomp) {
559 W->printHex("StartIndex", Precomp.getStartTypeIndex());
560 W->printHex("Count", Precomp.getTypesCount());
561 W->printHex("Signature", Precomp.getSignature());
562 W->printString("PrecompFile", Precomp.getPrecompFilePath());
563 return Error::success();
564}
565
566Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
567 EndPrecompRecord &EndPrecomp) {
568 W->printHex("Signature", EndPrecomp.getSignature());
569 return Error::success();
570}
@ Generic
AMDGPU Lower Kernel Arguments
static const EnumEntry< uint16_t > MemberKindNames[]
Definition: EnumTables.cpp:348
static const EnumEntry< uint16_t > TypeModifierNames[]
Definition: EnumTables.cpp:396
static const EnumEntry< uint16_t > PtrMemberRepNames[]
Definition: EnumTables.cpp:382
static const EnumEntry< uint8_t > CallingConventions[]
Definition: EnumTables.cpp:402
static const EnumEntry< uint8_t > FunctionOptionEnum[]
Definition: EnumTables.cpp:430
static const EnumEntry< uint16_t > LabelTypeEnum[]
Definition: EnumTables.cpp:436
static const EnumEntry< uint16_t > MethodOptionNames[]
Definition: EnumTables.cpp:340
static const EnumEntry< uint8_t > MemberAccessNames[]
Definition: EnumTables.cpp:333
static const EnumEntry< uint8_t > PtrModeNames[]
Definition: EnumTables.cpp:374
static const EnumEntry< uint16_t > ClassOptionNames[]
Definition: EnumTables.cpp:318
static const EnumEntry< uint8_t > PtrKindNames[]
Definition: EnumTables.cpp:358
uint64_t Size
IRTranslator LLVM IR MI
static LVOptions Options
Definition: LVOptions.cpp:25
#define I(x, y, z)
Definition: MD5.cpp:58
static const EnumEntry< uint16_t > MemberKindNames[]
static const EnumEntry< uint16_t > TypeModifierNames[]
static const EnumEntry< uint16_t > PtrMemberRepNames[]
static const EnumEntry< uint8_t > CallingConventions[]
static const EnumEntry< uint8_t > FunctionOptionEnum[]
static const EnumEntry< uint16_t > LabelTypeEnum[]
static const EnumEntry< uint16_t > MethodOptionNames[]
static const EnumEntry< uint8_t > MemberAccessNames[]
#define ENUM_ENTRY(enum_class, enum)
static StringRef getLeafTypeName(TypeLeafKind LT)
static const EnumEntry< uint8_t > PtrModeNames[]
static const EnumEntry< uint16_t > ClassOptionNames[]
static const EnumEntry< TypeLeafKind > LeafTypeNames[]
static const EnumEntry< uint8_t > PtrKindNames[]
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
virtual void printString(StringRef Value)
void printBinaryBlock(StringRef Label, ArrayRef< uint8_t > Value, uint32_t StartOffset)
void indent(int Levels=1)
void unindent(int Levels=1)
void printEnum(StringRef Label, T Value, ArrayRef< EnumEntry< TEnum > > EnumValues)
virtual raw_ostream & getOStream()
virtual raw_ostream & startLine()
virtual void printNumber(StringRef Label, char Value)
void printHex(StringRef Label, T Value)
void printFlags(StringRef Label, T Value, ArrayRef< EnumEntry< TFlag > > Flags, TFlag EnumMask1={}, TFlag EnumMask2={}, TFlag EnumMask3={}, ArrayRef< FlagEntry > ExtraFlags={})
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
TypeIndex getElementType() const
Definition: TypeRecord.h:405
TypeIndex getIndexType() const
Definition: TypeRecord.h:406
uint64_t getSize() const
Definition: TypeRecord.h:407
StringRef getName() const
Definition: TypeRecord.h:408
LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records together.
Definition: TypeRecord.h:914
int32_t getThisPointerAdjustment() const
Definition: TypeRecord.h:193
FunctionOptions getOptions() const
Definition: TypeRecord.h:190
CallingConvention getCallConv() const
Definition: TypeRecord.h:189
ArrayRef< OneMethodRecord > getMethods() const
Definition: TypeRecord.h:758
int32_t getVFTableOffset() const
Definition: TypeRecord.h:736
MemberAccess getAccess() const
Definition: TypeRecord.h:735
MethodOptions getOptions() const
Definition: TypeRecord.h:734
MethodKind getMethodKind() const
Definition: TypeRecord.h:733
For method overload sets. LF_METHOD.
Definition: TypeRecord.h:764
uint32_t getSignature() const
Definition: TypeRecord.h:935
StringRef getPrecompFilePath() const
Definition: TypeRecord.h:936
uint32_t getTypesCount() const
Definition: TypeRecord.h:934
uint32_t getStartTypeIndex() const
Definition: TypeRecord.h:933
TypeIndex getReturnType() const
Definition: TypeRecord.h:157
TypeIndex getArgumentList() const
Definition: TypeRecord.h:161
uint16_t getParameterCount() const
Definition: TypeRecord.h:160
FunctionOptions getOptions() const
Definition: TypeRecord.h:159
CallingConvention getCallConv() const
Definition: TypeRecord.h:158
ArrayRef< TypeIndex > getIndices() const
Definition: TypeRecord.h:258
virtual uint32_t size()=0
Error visitTypeEnd(CVType &Record) override
void printTypeIndex(StringRef FieldName, TypeIndex TI) const
Error visitUnknownMember(CVMemberRecord &Record) override
Error visitMemberEnd(CVMemberRecord &Record) override
Error visitUnknownType(CVType &Record) override
Action to take on unknown types. By default, they are ignored.
void printItemIndex(StringRef FieldName, TypeIndex TI) const
Error visitTypeBegin(CVType &Record) override
Paired begin/end actions for all types.
Error visitMemberBegin(CVMemberRecord &Record) override
A 32-bit type reference.
Definition: TypeIndex.h:96
static TypeIndex fromArrayIndex(uint32_t Index)
Definition: TypeIndex.h:123
const GUID & getGuid() const
Definition: TypeRecord.h:585
TypeIndex getType() const
Definition: TypeRecord.h:857
uint32_t getVFPtrOffset() const
Definition: TypeRecord.h:705
TypeIndex getOverriddenVTable() const
Definition: TypeRecord.h:704
ArrayRef< StringRef > getMethodNames() const
Definition: TypeRecord.h:708
StringRef getName() const
Definition: TypeRecord.h:706
TypeIndex getCompleteClass() const
Definition: TypeRecord.h:703
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
PointerMode
Equivalent to CV_ptrmode_e.
Definition: CodeView.h:363
MethodKind
Part of member attribute flags. (CV_methodprop_e)
Definition: CodeView.h:280
PointerKind
Equivalent to CV_ptrtype_e.
Definition: CodeView.h:346
PointerToMemberRepresentation
Equivalent to CV_pmtype_e.
Definition: CodeView.h:386
Error visitMemberRecordStream(ArrayRef< uint8_t > FieldList, TypeVisitorCallbacks &Callbacks)
MethodOptions
Equivalent to CV_fldattr_t bitfield.
Definition: CodeView.h:291
StringRef getBytesAsCharacters(ArrayRef< uint8_t > LeafData)
Reinterpret a byte array as an array of characters.
MemberAccess
Source-level access specifier. (CV_access_e)
Definition: CodeView.h:272
TypeLeafKind
Duplicate copy of the above enum, but using the official CV names.
Definition: CodeView.h:34
ModifierOptions
Equivalent to CV_modifier_t.
Definition: CodeView.h:311
LabelType
Equivalent to CV_LABEL_TYPE_e.
Definition: CodeView.h:304
void printTypeIndex(ScopedPrinter &Printer, StringRef FieldName, TypeIndex TI, TypeCollection &Types)
Definition: TypeIndex.cpp:93
CallingConvention
Definition: Dwarf.h:738
NodeAddr< FuncNode * > Func
Definition: RDFGraph.h:393
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
@ None
Definition: CodeGenData.h:101
@ Mod
The access may modify the value stored in memory.
#define N
Equvalent to CV_fldattr_t in cvinfo.h.
Definition: TypeRecord.h:40