1 //===- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp ----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing Microsoft CodeView debug info.
12 //===----------------------------------------------------------------------===//
14 #include "CodeViewDebug.h"
15 #include "llvm/ADT/APSInt.h"
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/DenseSet.h"
19 #include "llvm/ADT/MapVector.h"
20 #include "llvm/ADT/None.h"
21 #include "llvm/ADT/Optional.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/ADT/TinyPtrVector.h"
27 #include "llvm/ADT/Triple.h"
28 #include "llvm/ADT/Twine.h"
29 #include "llvm/BinaryFormat/COFF.h"
30 #include "llvm/BinaryFormat/Dwarf.h"
31 #include "llvm/CodeGen/AsmPrinter.h"
32 #include "llvm/CodeGen/LexicalScopes.h"
33 #include "llvm/CodeGen/MachineFunction.h"
34 #include "llvm/CodeGen/MachineInstr.h"
35 #include "llvm/CodeGen/MachineModuleInfo.h"
36 #include "llvm/CodeGen/MachineOperand.h"
37 #include "llvm/Config/llvm-config.h"
38 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
39 #include "llvm/DebugInfo/CodeView/CodeView.h"
40 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
41 #include "llvm/DebugInfo/CodeView/Line.h"
42 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
43 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
44 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
45 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
46 #include "llvm/DebugInfo/CodeView/TypeTableCollection.h"
47 #include "llvm/IR/Constants.h"
48 #include "llvm/IR/DataLayout.h"
49 #include "llvm/IR/DebugInfoMetadata.h"
50 #include "llvm/IR/DebugLoc.h"
51 #include "llvm/IR/Function.h"
52 #include "llvm/IR/GlobalValue.h"
53 #include "llvm/IR/GlobalVariable.h"
54 #include "llvm/IR/Metadata.h"
55 #include "llvm/IR/Module.h"
56 #include "llvm/MC/MCAsmInfo.h"
57 #include "llvm/MC/MCContext.h"
58 #include "llvm/MC/MCSectionCOFF.h"
59 #include "llvm/MC/MCStreamer.h"
60 #include "llvm/MC/MCSymbol.h"
61 #include "llvm/Support/BinaryByteStream.h"
62 #include "llvm/Support/BinaryStreamReader.h"
63 #include "llvm/Support/Casting.h"
64 #include "llvm/Support/Compiler.h"
65 #include "llvm/Support/Endian.h"
66 #include "llvm/Support/Error.h"
67 #include "llvm/Support/ErrorHandling.h"
68 #include "llvm/Support/ScopedPrinter.h"
69 #include "llvm/Support/SMLoc.h"
70 #include "llvm/Target/TargetFrameLowering.h"
71 #include "llvm/Target/TargetLoweringObjectFile.h"
72 #include "llvm/Target/TargetMachine.h"
73 #include "llvm/Target/TargetRegisterInfo.h"
74 #include "llvm/Target/TargetSubtargetInfo.h"
87 using namespace llvm::codeview;
89 CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
90 : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {
91 // If module doesn't have named metadata anchors or COFF debug section
92 // is not available, skip any debug info related stuff.
93 if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") ||
94 !AP->getObjFileLowering().getCOFFDebugSymbolsSection()) {
99 // Tell MMI that we have debug info.
100 MMI->setDebugInfoAvailability(true);
103 StringRef CodeViewDebug::getFullFilepath(const DIFile *File) {
104 std::string &Filepath = FileToFilepathMap[File];
105 if (!Filepath.empty())
108 StringRef Dir = File->getDirectory(), Filename = File->getFilename();
110 // Clang emits directory and relative filename info into the IR, but CodeView
111 // operates on full paths. We could change Clang to emit full paths too, but
112 // that would increase the IR size and probably not needed for other users.
113 // For now, just concatenate and canonicalize the path here.
114 if (Filename.find(':') == 1)
117 Filepath = (Dir + "\\" + Filename).str();
119 // Canonicalize the path. We have to do it textually because we may no longer
120 // have access the file in the filesystem.
121 // First, replace all slashes with backslashes.
122 std::replace(Filepath.begin(), Filepath.end(), '/', '\\');
124 // Remove all "\.\" with "\".
126 while ((Cursor = Filepath.find("\\.\\", Cursor)) != std::string::npos)
127 Filepath.erase(Cursor, 2);
129 // Replace all "\XXX\..\" with "\". Don't try too hard though as the original
130 // path should be well-formatted, e.g. start with a drive letter, etc.
132 while ((Cursor = Filepath.find("\\..\\", Cursor)) != std::string::npos) {
133 // Something's wrong if the path starts with "\..\", abort.
137 size_t PrevSlash = Filepath.rfind('\\', Cursor - 1);
138 if (PrevSlash == std::string::npos)
139 // Something's wrong, abort.
142 Filepath.erase(PrevSlash, Cursor + 3 - PrevSlash);
143 // The next ".." might be following the one we've just erased.
147 // Remove all duplicate backslashes.
149 while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos)
150 Filepath.erase(Cursor, 1);
155 unsigned CodeViewDebug::maybeRecordFile(const DIFile *F) {
156 unsigned NextId = FileIdMap.size() + 1;
157 auto Insertion = FileIdMap.insert(std::make_pair(F, NextId));
158 if (Insertion.second) {
159 // We have to compute the full filepath and emit a .cv_file directive.
160 StringRef FullPath = getFullFilepath(F);
161 bool Success = OS.EmitCVFileDirective(NextId, FullPath);
163 assert(Success && ".cv_file directive failed");
165 return Insertion.first->second;
168 CodeViewDebug::InlineSite &
169 CodeViewDebug::getInlineSite(const DILocation *InlinedAt,
170 const DISubprogram *Inlinee) {
171 auto SiteInsertion = CurFn->InlineSites.insert({InlinedAt, InlineSite()});
172 InlineSite *Site = &SiteInsertion.first->second;
173 if (SiteInsertion.second) {
174 unsigned ParentFuncId = CurFn->FuncId;
175 if (const DILocation *OuterIA = InlinedAt->getInlinedAt())
177 getInlineSite(OuterIA, InlinedAt->getScope()->getSubprogram())
180 Site->SiteFuncId = NextFuncId++;
181 OS.EmitCVInlineSiteIdDirective(
182 Site->SiteFuncId, ParentFuncId, maybeRecordFile(InlinedAt->getFile()),
183 InlinedAt->getLine(), InlinedAt->getColumn(), SMLoc());
184 Site->Inlinee = Inlinee;
185 InlinedSubprograms.insert(Inlinee);
186 getFuncIdForSubprogram(Inlinee);
191 static StringRef getPrettyScopeName(const DIScope *Scope) {
192 StringRef ScopeName = Scope->getName();
193 if (!ScopeName.empty())
196 switch (Scope->getTag()) {
197 case dwarf::DW_TAG_enumeration_type:
198 case dwarf::DW_TAG_class_type:
199 case dwarf::DW_TAG_structure_type:
200 case dwarf::DW_TAG_union_type:
201 return "<unnamed-tag>";
202 case dwarf::DW_TAG_namespace:
203 return "`anonymous namespace'";
209 static const DISubprogram *getQualifiedNameComponents(
210 const DIScope *Scope, SmallVectorImpl<StringRef> &QualifiedNameComponents) {
211 const DISubprogram *ClosestSubprogram = nullptr;
212 while (Scope != nullptr) {
213 if (ClosestSubprogram == nullptr)
214 ClosestSubprogram = dyn_cast<DISubprogram>(Scope);
215 StringRef ScopeName = getPrettyScopeName(Scope);
216 if (!ScopeName.empty())
217 QualifiedNameComponents.push_back(ScopeName);
218 Scope = Scope->getScope().resolve();
220 return ClosestSubprogram;
223 static std::string getQualifiedName(ArrayRef<StringRef> QualifiedNameComponents,
224 StringRef TypeName) {
225 std::string FullyQualifiedName;
226 for (StringRef QualifiedNameComponent :
227 llvm::reverse(QualifiedNameComponents)) {
228 FullyQualifiedName.append(QualifiedNameComponent);
229 FullyQualifiedName.append("::");
231 FullyQualifiedName.append(TypeName);
232 return FullyQualifiedName;
235 static std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name) {
236 SmallVector<StringRef, 5> QualifiedNameComponents;
237 getQualifiedNameComponents(Scope, QualifiedNameComponents);
238 return getQualifiedName(QualifiedNameComponents, Name);
241 struct CodeViewDebug::TypeLoweringScope {
242 TypeLoweringScope(CodeViewDebug &CVD) : CVD(CVD) { ++CVD.TypeEmissionLevel; }
243 ~TypeLoweringScope() {
244 // Don't decrement TypeEmissionLevel until after emitting deferred types, so
245 // inner TypeLoweringScopes don't attempt to emit deferred types.
246 if (CVD.TypeEmissionLevel == 1)
247 CVD.emitDeferredCompleteTypes();
248 --CVD.TypeEmissionLevel;
253 static std::string getFullyQualifiedName(const DIScope *Ty) {
254 const DIScope *Scope = Ty->getScope().resolve();
255 return getFullyQualifiedName(Scope, getPrettyScopeName(Ty));
258 TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) {
259 // No scope means global scope and that uses the zero index.
260 if (!Scope || isa<DIFile>(Scope))
263 assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type");
265 // Check if we've already translated this scope.
266 auto I = TypeIndices.find({Scope, nullptr});
267 if (I != TypeIndices.end())
270 // Build the fully qualified name of the scope.
271 std::string ScopeName = getFullyQualifiedName(Scope);
272 StringIdRecord SID(TypeIndex(), ScopeName);
273 auto TI = TypeTable.writeKnownType(SID);
274 return recordTypeIndexForDINode(Scope, TI);
277 TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
280 // Check if we've already translated this subprogram.
281 auto I = TypeIndices.find({SP, nullptr});
282 if (I != TypeIndices.end())
285 // The display name includes function template arguments. Drop them to match
287 StringRef DisplayName = SP->getName().split('<').first;
289 const DIScope *Scope = SP->getScope().resolve();
291 if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) {
292 // If the scope is a DICompositeType, then this must be a method. Member
293 // function types take some special handling, and require access to the
295 TypeIndex ClassType = getTypeIndex(Class);
296 MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class),
298 TI = TypeTable.writeKnownType(MFuncId);
300 // Otherwise, this must be a free function.
301 TypeIndex ParentScope = getScopeIndex(Scope);
302 FuncIdRecord FuncId(ParentScope, getTypeIndex(SP->getType()), DisplayName);
303 TI = TypeTable.writeKnownType(FuncId);
306 return recordTypeIndexForDINode(SP, TI);
309 TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
310 const DICompositeType *Class) {
311 // Always use the method declaration as the key for the function type. The
312 // method declaration contains the this adjustment.
313 if (SP->getDeclaration())
314 SP = SP->getDeclaration();
315 assert(!SP->getDeclaration() && "should use declaration as key");
317 // Key the MemberFunctionRecord into the map as {SP, Class}. It won't collide
318 // with the MemberFuncIdRecord, which is keyed in as {SP, nullptr}.
319 auto I = TypeIndices.find({SP, Class});
320 if (I != TypeIndices.end())
323 // Make sure complete type info for the class is emitted *after* the member
324 // function type, as the complete class type is likely to reference this
325 // member function type.
326 TypeLoweringScope S(*this);
328 lowerTypeMemberFunction(SP->getType(), Class, SP->getThisAdjustment());
329 return recordTypeIndexForDINode(SP, TI, Class);
332 TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node,
334 const DIType *ClassTy) {
335 auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI});
337 assert(InsertResult.second && "DINode was already assigned a type index");
341 unsigned CodeViewDebug::getPointerSizeInBytes() {
342 return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;
345 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
346 const DILocation *InlinedAt) {
348 // This variable was inlined. Associate it with the InlineSite.
349 const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram();
350 InlineSite &Site = getInlineSite(InlinedAt, Inlinee);
351 Site.InlinedLocals.emplace_back(Var);
353 // This variable goes in the main ProcSym.
354 CurFn->Locals.emplace_back(Var);
358 static void addLocIfNotPresent(SmallVectorImpl<const DILocation *> &Locs,
359 const DILocation *Loc) {
360 auto B = Locs.begin(), E = Locs.end();
361 if (std::find(B, E, Loc) == E)
365 void CodeViewDebug::maybeRecordLocation(const DebugLoc &DL,
366 const MachineFunction *MF) {
367 // Skip this instruction if it has the same location as the previous one.
368 if (!DL || DL == PrevInstLoc)
371 const DIScope *Scope = DL.get()->getScope();
375 // Skip this line if it is longer than the maximum we can record.
376 LineInfo LI(DL.getLine(), DL.getLine(), /*IsStatement=*/true);
377 if (LI.getStartLine() != DL.getLine() || LI.isAlwaysStepInto() ||
378 LI.isNeverStepInto())
381 ColumnInfo CI(DL.getCol(), /*EndColumn=*/0);
382 if (CI.getStartColumn() != DL.getCol())
385 if (!CurFn->HaveLineInfo)
386 CurFn->HaveLineInfo = true;
388 if (PrevInstLoc.get() && PrevInstLoc->getFile() == DL->getFile())
389 FileId = CurFn->LastFileId;
391 FileId = CurFn->LastFileId = maybeRecordFile(DL->getFile());
394 unsigned FuncId = CurFn->FuncId;
395 if (const DILocation *SiteLoc = DL->getInlinedAt()) {
396 const DILocation *Loc = DL.get();
398 // If this location was actually inlined from somewhere else, give it the ID
399 // of the inline call site.
401 getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()).SiteFuncId;
403 // Ensure we have links in the tree of inline call sites.
404 bool FirstLoc = true;
405 while ((SiteLoc = Loc->getInlinedAt())) {
407 getInlineSite(SiteLoc, Loc->getScope()->getSubprogram());
409 addLocIfNotPresent(Site.ChildSites, Loc);
413 addLocIfNotPresent(CurFn->ChildSites, Loc);
416 OS.EmitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(),
417 /*PrologueEnd=*/false, /*IsStmt=*/false,
418 DL->getFilename(), SMLoc());
421 void CodeViewDebug::emitCodeViewMagicVersion() {
422 OS.EmitValueToAlignment(4);
423 OS.AddComment("Debug section magic");
424 OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4);
427 void CodeViewDebug::endModule() {
428 if (!Asm || !MMI->hasDebugInfo())
431 assert(Asm != nullptr);
433 // The COFF .debug$S section consists of several subsections, each starting
434 // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length
435 // of the payload followed by the payload itself. The subsections are 4-byte
438 // Use the generic .debug$S section, and make a subsection for all the inlined
440 switchToDebugSectionForSymbol(nullptr);
442 MCSymbol *CompilerInfo = beginCVSubsection(DebugSubsectionKind::Symbols);
443 emitCompilerInformation();
444 endCVSubsection(CompilerInfo);
446 emitInlineeLinesSubsection();
448 // Emit per-function debug information.
449 for (auto &P : FnDebugInfo)
450 if (!P.first->isDeclarationForLinker())
451 emitDebugInfoForFunction(P.first, P.second);
453 // Emit global variable debug information.
454 setCurrentSubprogram(nullptr);
455 emitDebugInfoForGlobals();
457 // Emit retained types.
458 emitDebugInfoForRetainedTypes();
460 // Switch back to the generic .debug$S section after potentially processing
461 // comdat symbol sections.
462 switchToDebugSectionForSymbol(nullptr);
464 // Emit UDT records for any types used by global variables.
465 if (!GlobalUDTs.empty()) {
466 MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
467 emitDebugInfoForUDTs(GlobalUDTs);
468 endCVSubsection(SymbolsEnd);
471 // This subsection holds a file index to offset in string table table.
472 OS.AddComment("File index to string table offset subsection");
473 OS.EmitCVFileChecksumsDirective();
475 // This subsection holds the string table.
476 OS.AddComment("String table");
477 OS.EmitCVStringTableDirective();
479 // Emit type information last, so that any types we translate while emitting
480 // function info are included.
481 emitTypeInformation();
486 static void emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S) {
487 // The maximum CV record length is 0xFF00. Most of the strings we emit appear
488 // after a fixed length portion of the record. The fixed length portion should
489 // always be less than 0xF00 (3840) bytes, so truncate the string so that the
490 // overall record size is less than the maximum allowed.
491 unsigned MaxFixedRecordLength = 0xF00;
492 SmallString<32> NullTerminatedString(
493 S.take_front(MaxRecordLength - MaxFixedRecordLength - 1));
494 NullTerminatedString.push_back('\0');
495 OS.EmitBytes(NullTerminatedString);
498 void CodeViewDebug::emitTypeInformation() {
499 // Do nothing if we have no debug info or if no non-trivial types were emitted
500 // to TypeTable during codegen.
501 NamedMDNode *CU_Nodes = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
504 if (TypeTable.empty())
507 // Start the .debug$T section with 0x4.
508 OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
509 emitCodeViewMagicVersion();
511 SmallString<8> CommentPrefix;
512 if (OS.isVerboseAsm()) {
513 CommentPrefix += '\t';
514 CommentPrefix += Asm->MAI->getCommentString();
515 CommentPrefix += ' ';
518 TypeTableCollection Table(TypeTable.records());
519 Optional<TypeIndex> B = Table.getFirst();
521 // This will fail if the record data is invalid.
522 CVType Record = Table.getType(*B);
524 if (OS.isVerboseAsm()) {
525 // Emit a block comment describing the type record for readability.
526 SmallString<512> CommentBlock;
527 raw_svector_ostream CommentOS(CommentBlock);
528 ScopedPrinter SP(CommentOS);
529 SP.setPrefix(CommentPrefix);
530 TypeDumpVisitor TDV(Table, &SP, false);
532 Error E = codeview::visitTypeRecord(Record, *B, TDV);
534 logAllUnhandledErrors(std::move(E), errs(), "error: ");
535 llvm_unreachable("produced malformed type record");
537 // emitRawComment will insert its own tab and comment string before
538 // the first line, so strip off our first one. It also prints its own
541 CommentOS.str().drop_front(CommentPrefix.size() - 1).rtrim());
543 OS.EmitBinaryData(Record.str_data());
544 B = Table.getNext(*B);
550 static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
552 case dwarf::DW_LANG_C:
553 case dwarf::DW_LANG_C89:
554 case dwarf::DW_LANG_C99:
555 case dwarf::DW_LANG_C11:
556 case dwarf::DW_LANG_ObjC:
557 return SourceLanguage::C;
558 case dwarf::DW_LANG_C_plus_plus:
559 case dwarf::DW_LANG_C_plus_plus_03:
560 case dwarf::DW_LANG_C_plus_plus_11:
561 case dwarf::DW_LANG_C_plus_plus_14:
562 return SourceLanguage::Cpp;
563 case dwarf::DW_LANG_Fortran77:
564 case dwarf::DW_LANG_Fortran90:
565 case dwarf::DW_LANG_Fortran03:
566 case dwarf::DW_LANG_Fortran08:
567 return SourceLanguage::Fortran;
568 case dwarf::DW_LANG_Pascal83:
569 return SourceLanguage::Pascal;
570 case dwarf::DW_LANG_Cobol74:
571 case dwarf::DW_LANG_Cobol85:
572 return SourceLanguage::Cobol;
573 case dwarf::DW_LANG_Java:
574 return SourceLanguage::Java;
576 // There's no CodeView representation for this language, and CV doesn't
577 // have an "unknown" option for the language field, so we'll use MASM,
578 // as it's very low level.
579 return SourceLanguage::Masm;
587 // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out
588 // the version number.
589 static Version parseVersion(StringRef Name) {
592 for (const char C : Name) {
595 V.Part[N] += C - '0';
596 } else if (C == '.') {
606 static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
608 case Triple::ArchType::x86:
609 return CPUType::Pentium3;
610 case Triple::ArchType::x86_64:
612 case Triple::ArchType::thumb:
613 return CPUType::Thumb;
615 report_fatal_error("target architecture doesn't map to a CodeView "
620 } // end anonymous namespace
622 void CodeViewDebug::emitCompilerInformation() {
623 MCContext &Context = MMI->getContext();
624 MCSymbol *CompilerBegin = Context.createTempSymbol(),
625 *CompilerEnd = Context.createTempSymbol();
626 OS.AddComment("Record length");
627 OS.emitAbsoluteSymbolDiff(CompilerEnd, CompilerBegin, 2);
628 OS.EmitLabel(CompilerBegin);
629 OS.AddComment("Record kind: S_COMPILE3");
630 OS.EmitIntValue(SymbolKind::S_COMPILE3, 2);
633 NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
634 const MDNode *Node = *CUs->operands().begin();
635 const auto *CU = cast<DICompileUnit>(Node);
637 // The low byte of the flags indicates the source language.
638 Flags = MapDWLangToCVLang(CU->getSourceLanguage());
639 // TODO: Figure out which other flags need to be set.
641 OS.AddComment("Flags and language");
642 OS.EmitIntValue(Flags, 4);
644 OS.AddComment("CPUType");
646 mapArchToCVCPUType(Triple(MMI->getModule()->getTargetTriple()).getArch());
647 OS.EmitIntValue(static_cast<uint64_t>(CPU), 2);
649 StringRef CompilerVersion = CU->getProducer();
650 Version FrontVer = parseVersion(CompilerVersion);
651 OS.AddComment("Frontend version");
652 for (int N = 0; N < 4; ++N)
653 OS.EmitIntValue(FrontVer.Part[N], 2);
655 // Some Microsoft tools, like Binscope, expect a backend version number of at
656 // least 8.something, so we'll coerce the LLVM version into a form that
657 // guarantees it'll be big enough without really lying about the version.
658 int Major = 1000 * LLVM_VERSION_MAJOR +
659 10 * LLVM_VERSION_MINOR +
661 // Clamp it for builds that use unusually large version numbers.
662 Major = std::min<int>(Major, std::numeric_limits<uint16_t>::max());
663 Version BackVer = {{ Major, 0, 0, 0 }};
664 OS.AddComment("Backend version");
665 for (int N = 0; N < 4; ++N)
666 OS.EmitIntValue(BackVer.Part[N], 2);
668 OS.AddComment("Null-terminated compiler version string");
669 emitNullTerminatedSymbolName(OS, CompilerVersion);
671 OS.EmitLabel(CompilerEnd);
674 void CodeViewDebug::emitInlineeLinesSubsection() {
675 if (InlinedSubprograms.empty())
678 OS.AddComment("Inlinee lines subsection");
679 MCSymbol *InlineEnd = beginCVSubsection(DebugSubsectionKind::InlineeLines);
681 // We don't provide any extra file info.
682 // FIXME: Find out if debuggers use this info.
683 OS.AddComment("Inlinee lines signature");
684 OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
686 for (const DISubprogram *SP : InlinedSubprograms) {
687 assert(TypeIndices.count({SP, nullptr}));
688 TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
691 unsigned FileId = maybeRecordFile(SP->getFile());
692 OS.AddComment("Inlined function " + SP->getName() + " starts at " +
693 SP->getFilename() + Twine(':') + Twine(SP->getLine()));
695 // The filechecksum table uses 8 byte entries for now, and file ids start at
697 unsigned FileOffset = (FileId - 1) * 8;
698 OS.AddComment("Type index of inlined function");
699 OS.EmitIntValue(InlineeIdx.getIndex(), 4);
700 OS.AddComment("Offset into filechecksum table");
701 OS.EmitIntValue(FileOffset, 4);
702 OS.AddComment("Starting line number");
703 OS.EmitIntValue(SP->getLine(), 4);
706 endCVSubsection(InlineEnd);
709 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
710 const DILocation *InlinedAt,
711 const InlineSite &Site) {
712 MCSymbol *InlineBegin = MMI->getContext().createTempSymbol(),
713 *InlineEnd = MMI->getContext().createTempSymbol();
715 assert(TypeIndices.count({Site.Inlinee, nullptr}));
716 TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];
719 OS.AddComment("Record length");
720 OS.emitAbsoluteSymbolDiff(InlineEnd, InlineBegin, 2); // RecordLength
721 OS.EmitLabel(InlineBegin);
722 OS.AddComment("Record kind: S_INLINESITE");
723 OS.EmitIntValue(SymbolKind::S_INLINESITE, 2); // RecordKind
725 OS.AddComment("PtrParent");
726 OS.EmitIntValue(0, 4);
727 OS.AddComment("PtrEnd");
728 OS.EmitIntValue(0, 4);
729 OS.AddComment("Inlinee type index");
730 OS.EmitIntValue(InlineeIdx.getIndex(), 4);
732 unsigned FileId = maybeRecordFile(Site.Inlinee->getFile());
733 unsigned StartLineNum = Site.Inlinee->getLine();
735 OS.EmitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum,
738 OS.EmitLabel(InlineEnd);
740 emitLocalVariableList(Site.InlinedLocals);
742 // Recurse on child inlined call sites before closing the scope.
743 for (const DILocation *ChildSite : Site.ChildSites) {
744 auto I = FI.InlineSites.find(ChildSite);
745 assert(I != FI.InlineSites.end() &&
746 "child site not in function inline site map");
747 emitInlinedCallSite(FI, ChildSite, I->second);
751 OS.AddComment("Record length");
752 OS.EmitIntValue(2, 2); // RecordLength
753 OS.AddComment("Record kind: S_INLINESITE_END");
754 OS.EmitIntValue(SymbolKind::S_INLINESITE_END, 2); // RecordKind
757 void CodeViewDebug::switchToDebugSectionForSymbol(const MCSymbol *GVSym) {
758 // If we have a symbol, it may be in a section that is COMDAT. If so, find the
759 // comdat key. A section may be comdat because of -ffunction-sections or
760 // because it is comdat in the IR.
761 MCSectionCOFF *GVSec =
762 GVSym ? dyn_cast<MCSectionCOFF>(&GVSym->getSection()) : nullptr;
763 const MCSymbol *KeySym = GVSec ? GVSec->getCOMDATSymbol() : nullptr;
765 MCSectionCOFF *DebugSec = cast<MCSectionCOFF>(
766 Asm->getObjFileLowering().getCOFFDebugSymbolsSection());
767 DebugSec = OS.getContext().getAssociativeCOFFSection(DebugSec, KeySym);
769 OS.SwitchSection(DebugSec);
771 // Emit the magic version number if this is the first time we've switched to
773 if (ComdatDebugSections.insert(DebugSec).second)
774 emitCodeViewMagicVersion();
777 void CodeViewDebug::emitDebugInfoForFunction(const Function *GV,
779 // For each function there is a separate subsection
780 // which holds the PC to file:line table.
781 const MCSymbol *Fn = Asm->getSymbol(GV);
784 // Switch to the to a comdat section, if appropriate.
785 switchToDebugSectionForSymbol(Fn);
787 std::string FuncName;
788 auto *SP = GV->getSubprogram();
790 setCurrentSubprogram(SP);
792 // If we have a display name, build the fully qualified name by walking the
794 if (!SP->getName().empty())
796 getFullyQualifiedName(SP->getScope().resolve(), SP->getName());
798 // If our DISubprogram name is empty, use the mangled name.
799 if (FuncName.empty())
800 FuncName = GlobalValue::dropLLVMManglingEscape(GV->getName());
802 // Emit a symbol subsection, required by VS2012+ to find function boundaries.
803 OS.AddComment("Symbol subsection for " + Twine(FuncName));
804 MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
806 MCSymbol *ProcRecordBegin = MMI->getContext().createTempSymbol(),
807 *ProcRecordEnd = MMI->getContext().createTempSymbol();
808 OS.AddComment("Record length");
809 OS.emitAbsoluteSymbolDiff(ProcRecordEnd, ProcRecordBegin, 2);
810 OS.EmitLabel(ProcRecordBegin);
812 if (GV->hasLocalLinkage()) {
813 OS.AddComment("Record kind: S_LPROC32_ID");
814 OS.EmitIntValue(unsigned(SymbolKind::S_LPROC32_ID), 2);
816 OS.AddComment("Record kind: S_GPROC32_ID");
817 OS.EmitIntValue(unsigned(SymbolKind::S_GPROC32_ID), 2);
820 // These fields are filled in by tools like CVPACK which run after the fact.
821 OS.AddComment("PtrParent");
822 OS.EmitIntValue(0, 4);
823 OS.AddComment("PtrEnd");
824 OS.EmitIntValue(0, 4);
825 OS.AddComment("PtrNext");
826 OS.EmitIntValue(0, 4);
827 // This is the important bit that tells the debugger where the function
828 // code is located and what's its size:
829 OS.AddComment("Code size");
830 OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4);
831 OS.AddComment("Offset after prologue");
832 OS.EmitIntValue(0, 4);
833 OS.AddComment("Offset before epilogue");
834 OS.EmitIntValue(0, 4);
835 OS.AddComment("Function type index");
836 OS.EmitIntValue(getFuncIdForSubprogram(GV->getSubprogram()).getIndex(), 4);
837 OS.AddComment("Function section relative address");
838 OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
839 OS.AddComment("Function section index");
840 OS.EmitCOFFSectionIndex(Fn);
841 OS.AddComment("Flags");
842 OS.EmitIntValue(0, 1);
843 // Emit the function display name as a null-terminated string.
844 OS.AddComment("Function name");
845 // Truncate the name so we won't overflow the record length field.
846 emitNullTerminatedSymbolName(OS, FuncName);
847 OS.EmitLabel(ProcRecordEnd);
849 emitLocalVariableList(FI.Locals);
851 // Emit inlined call site information. Only emit functions inlined directly
852 // into the parent function. We'll emit the other sites recursively as part
853 // of their parent inline site.
854 for (const DILocation *InlinedAt : FI.ChildSites) {
855 auto I = FI.InlineSites.find(InlinedAt);
856 assert(I != FI.InlineSites.end() &&
857 "child site not in function inline site map");
858 emitInlinedCallSite(FI, InlinedAt, I->second);
862 emitDebugInfoForUDTs(LocalUDTs);
864 // We're done with this function.
865 OS.AddComment("Record length");
866 OS.EmitIntValue(0x0002, 2);
867 OS.AddComment("Record kind: S_PROC_ID_END");
868 OS.EmitIntValue(unsigned(SymbolKind::S_PROC_ID_END), 2);
870 endCVSubsection(SymbolsEnd);
872 // We have an assembler directive that takes care of the whole line table.
873 OS.EmitCVLinetableDirective(FI.FuncId, Fn, FI.End);
876 CodeViewDebug::LocalVarDefRange
877 CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) {
880 DR.DataOffset = Offset;
881 assert(DR.DataOffset == Offset && "truncation");
884 DR.CVRegister = CVRegister;
888 CodeViewDebug::LocalVarDefRange
889 CodeViewDebug::createDefRangeGeneral(uint16_t CVRegister, bool InMemory,
890 int Offset, bool IsSubfield,
891 uint16_t StructOffset) {
893 DR.InMemory = InMemory;
894 DR.DataOffset = Offset;
895 DR.IsSubfield = IsSubfield;
896 DR.StructOffset = StructOffset;
897 DR.CVRegister = CVRegister;
901 void CodeViewDebug::collectVariableInfoFromMFTable(
902 DenseSet<InlinedVariable> &Processed) {
903 const MachineFunction &MF = *Asm->MF;
904 const TargetSubtargetInfo &TSI = MF.getSubtarget();
905 const TargetFrameLowering *TFI = TSI.getFrameLowering();
906 const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
908 for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) {
911 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
912 "Expected inlined-at fields to agree");
914 Processed.insert(InlinedVariable(VI.Var, VI.Loc->getInlinedAt()));
915 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
917 // If variable scope is not found then skip this variable.
921 // If the variable has an attached offset expression, extract it.
922 // FIXME: Try to handle DW_OP_deref as well.
923 int64_t ExprOffset = 0;
925 if (!VI.Expr->extractIfOffset(ExprOffset))
928 // Get the frame register used and the offset.
929 unsigned FrameReg = 0;
930 int FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg);
931 uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg);
933 // Calculate the label ranges.
934 LocalVarDefRange DefRange =
935 createDefRangeMem(CVReg, FrameOffset + ExprOffset);
936 for (const InsnRange &Range : Scope->getRanges()) {
937 const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
938 const MCSymbol *End = getLabelAfterInsn(Range.second);
939 End = End ? End : Asm->getFunctionEnd();
940 DefRange.Ranges.emplace_back(Begin, End);
945 Var.DefRanges.emplace_back(std::move(DefRange));
946 recordLocalVariable(std::move(Var), VI.Loc->getInlinedAt());
950 void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
951 DenseSet<InlinedVariable> Processed;
952 // Grab the variable info that was squirreled away in the MMI side-table.
953 collectVariableInfoFromMFTable(Processed);
955 const TargetRegisterInfo *TRI = Asm->MF->getSubtarget().getRegisterInfo();
957 for (const auto &I : DbgValues) {
958 InlinedVariable IV = I.first;
959 if (Processed.count(IV))
961 const DILocalVariable *DIVar = IV.first;
962 const DILocation *InlinedAt = IV.second;
964 // Instruction ranges, specifying where IV is accessible.
965 const auto &Ranges = I.second;
967 LexicalScope *Scope = nullptr;
969 Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);
971 Scope = LScopes.findLexicalScope(DIVar->getScope());
972 // If variable scope is not found then skip this variable.
979 // Calculate the definition ranges.
980 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
981 const InsnRange &Range = *I;
982 const MachineInstr *DVInst = Range.first;
983 assert(DVInst->isDebugValue() && "Invalid History entry");
984 const DIExpression *DIExpr = DVInst->getDebugExpression();
985 bool IsSubfield = false;
986 unsigned StructOffset = 0;
989 auto Fragment = DIExpr->getFragmentInfo();
992 StructOffset = Fragment->OffsetInBits / 8;
993 } else if (DIExpr->getNumElements() > 0) {
994 continue; // Ignore unrecognized exprs.
997 // Bail if operand 0 is not a valid register. This means the variable is a
998 // simple constant, or is described by a complex expression.
999 // FIXME: Find a way to represent constant variables, since they are
1000 // relatively common.
1002 DVInst->getOperand(0).isReg() ? DVInst->getOperand(0).getReg() : 0;
1006 // Handle the two cases we can handle: indirect in memory and in register.
1007 unsigned CVReg = TRI->getCodeViewRegNum(Reg);
1008 bool InMemory = DVInst->getOperand(1).isImm();
1009 int Offset = InMemory ? DVInst->getOperand(1).getImm() : 0;
1011 LocalVarDefRange DR;
1012 DR.CVRegister = CVReg;
1013 DR.InMemory = InMemory;
1014 DR.DataOffset = Offset;
1015 DR.IsSubfield = IsSubfield;
1016 DR.StructOffset = StructOffset;
1018 if (Var.DefRanges.empty() ||
1019 Var.DefRanges.back().isDifferentLocation(DR)) {
1020 Var.DefRanges.emplace_back(std::move(DR));
1024 // Compute the label range.
1025 const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
1026 const MCSymbol *End = getLabelAfterInsn(Range.second);
1028 // This range is valid until the next overlapping bitpiece. In the
1029 // common case, ranges will not be bitpieces, so they will overlap.
1030 auto J = std::next(I);
1032 !fragmentsOverlap(DIExpr, J->first->getDebugExpression()))
1035 End = getLabelBeforeInsn(J->first);
1037 End = Asm->getFunctionEnd();
1040 // If the last range end is our begin, just extend the last range.
1041 // Otherwise make a new range.
1042 SmallVectorImpl<std::pair<const MCSymbol *, const MCSymbol *>> &Ranges =
1043 Var.DefRanges.back().Ranges;
1044 if (!Ranges.empty() && Ranges.back().second == Begin)
1045 Ranges.back().second = End;
1047 Ranges.emplace_back(Begin, End);
1049 // FIXME: Do more range combining.
1052 recordLocalVariable(std::move(Var), InlinedAt);
1056 void CodeViewDebug::beginFunctionImpl(const MachineFunction *MF) {
1057 const Function *GV = MF->getFunction();
1058 assert(FnDebugInfo.count(GV) == false);
1059 CurFn = &FnDebugInfo[GV];
1060 CurFn->FuncId = NextFuncId++;
1061 CurFn->Begin = Asm->getFunctionBegin();
1063 OS.EmitCVFuncIdDirective(CurFn->FuncId);
1065 // Find the end of the function prolog. First known non-DBG_VALUE and
1066 // non-frame setup location marks the beginning of the function body.
1067 // FIXME: is there a simpler a way to do this? Can we just search
1068 // for the first instruction of the function, not the last of the prolog?
1069 DebugLoc PrologEndLoc;
1070 bool EmptyPrologue = true;
1071 for (const auto &MBB : *MF) {
1072 for (const auto &MI : MBB) {
1073 if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
1075 PrologEndLoc = MI.getDebugLoc();
1077 } else if (!MI.isMetaInstruction()) {
1078 EmptyPrologue = false;
1083 // Record beginning of function if we have a non-empty prologue.
1084 if (PrologEndLoc && !EmptyPrologue) {
1085 DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();
1086 maybeRecordLocation(FnStartDL, MF);
1090 void CodeViewDebug::addToUDTs(const DIType *Ty, TypeIndex TI) {
1091 // Don't record empty UDTs.
1092 if (Ty->getName().empty())
1095 SmallVector<StringRef, 5> QualifiedNameComponents;
1096 const DISubprogram *ClosestSubprogram = getQualifiedNameComponents(
1097 Ty->getScope().resolve(), QualifiedNameComponents);
1099 std::string FullyQualifiedName =
1100 getQualifiedName(QualifiedNameComponents, getPrettyScopeName(Ty));
1102 if (ClosestSubprogram == nullptr)
1103 GlobalUDTs.emplace_back(std::move(FullyQualifiedName), TI);
1104 else if (ClosestSubprogram == CurrentSubprogram)
1105 LocalUDTs.emplace_back(std::move(FullyQualifiedName), TI);
1107 // TODO: What if the ClosestSubprogram is neither null or the current
1108 // subprogram? Currently, the UDT just gets dropped on the floor.
1110 // The current behavior is not desirable. To get maximal fidelity, we would
1111 // need to perform all type translation before beginning emission of .debug$S
1112 // and then make LocalUDTs a member of FunctionInfo
1115 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1116 // Generic dispatch for lowering an unknown type.
1117 switch (Ty->getTag()) {
1118 case dwarf::DW_TAG_array_type:
1119 return lowerTypeArray(cast<DICompositeType>(Ty));
1120 case dwarf::DW_TAG_typedef:
1121 return lowerTypeAlias(cast<DIDerivedType>(Ty));
1122 case dwarf::DW_TAG_base_type:
1123 return lowerTypeBasic(cast<DIBasicType>(Ty));
1124 case dwarf::DW_TAG_pointer_type:
1125 if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type")
1126 return lowerTypeVFTableShape(cast<DIDerivedType>(Ty));
1128 case dwarf::DW_TAG_reference_type:
1129 case dwarf::DW_TAG_rvalue_reference_type:
1130 return lowerTypePointer(cast<DIDerivedType>(Ty));
1131 case dwarf::DW_TAG_ptr_to_member_type:
1132 return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
1133 case dwarf::DW_TAG_const_type:
1134 case dwarf::DW_TAG_volatile_type:
1135 // TODO: add support for DW_TAG_atomic_type here
1136 return lowerTypeModifier(cast<DIDerivedType>(Ty));
1137 case dwarf::DW_TAG_subroutine_type:
1139 // The member function type of a member function pointer has no
1141 return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
1142 /*ThisAdjustment=*/0);
1144 return lowerTypeFunction(cast<DISubroutineType>(Ty));
1145 case dwarf::DW_TAG_enumeration_type:
1146 return lowerTypeEnum(cast<DICompositeType>(Ty));
1147 case dwarf::DW_TAG_class_type:
1148 case dwarf::DW_TAG_structure_type:
1149 return lowerTypeClass(cast<DICompositeType>(Ty));
1150 case dwarf::DW_TAG_union_type:
1151 return lowerTypeUnion(cast<DICompositeType>(Ty));
1153 // Use the null type index.
1158 TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) {
1159 DITypeRef UnderlyingTypeRef = Ty->getBaseType();
1160 TypeIndex UnderlyingTypeIndex = getTypeIndex(UnderlyingTypeRef);
1161 StringRef TypeName = Ty->getName();
1163 addToUDTs(Ty, UnderlyingTypeIndex);
1165 if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::Int32Long) &&
1166 TypeName == "HRESULT")
1167 return TypeIndex(SimpleTypeKind::HResult);
1168 if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::UInt16Short) &&
1169 TypeName == "wchar_t")
1170 return TypeIndex(SimpleTypeKind::WideCharacter);
1172 return UnderlyingTypeIndex;
1175 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
1176 DITypeRef ElementTypeRef = Ty->getBaseType();
1177 TypeIndex ElementTypeIndex = getTypeIndex(ElementTypeRef);
1178 // IndexType is size_t, which depends on the bitness of the target.
1179 TypeIndex IndexType = Asm->TM.getPointerSize() == 8
1180 ? TypeIndex(SimpleTypeKind::UInt64Quad)
1181 : TypeIndex(SimpleTypeKind::UInt32Long);
1183 uint64_t ElementSize = getBaseTypeSize(ElementTypeRef) / 8;
1185 // Add subranges to array type.
1186 DINodeArray Elements = Ty->getElements();
1187 for (int i = Elements.size() - 1; i >= 0; --i) {
1188 const DINode *Element = Elements[i];
1189 assert(Element->getTag() == dwarf::DW_TAG_subrange_type);
1191 const DISubrange *Subrange = cast<DISubrange>(Element);
1192 assert(Subrange->getLowerBound() == 0 &&
1193 "codeview doesn't support subranges with lower bounds");
1194 int64_t Count = Subrange->getCount();
1196 // Variable Length Array (VLA) has Count equal to '-1'.
1197 // Replace with Count '1', assume it is the minimum VLA length.
1198 // FIXME: Make front-end support VLA subrange and emit LF_DIMVARLU.
1202 // Update the element size and element type index for subsequent subranges.
1203 ElementSize *= Count;
1205 // If this is the outermost array, use the size from the array. It will be
1206 // more accurate if we had a VLA or an incomplete element type size.
1207 uint64_t ArraySize =
1208 (i == 0 && ElementSize == 0) ? Ty->getSizeInBits() / 8 : ElementSize;
1210 StringRef Name = (i == 0) ? Ty->getName() : "";
1211 ArrayRecord AR(ElementTypeIndex, IndexType, ArraySize, Name);
1212 ElementTypeIndex = TypeTable.writeKnownType(AR);
1215 return ElementTypeIndex;
1218 TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
1220 dwarf::TypeKind Kind;
1223 Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding());
1224 ByteSize = Ty->getSizeInBits() / 8;
1226 SimpleTypeKind STK = SimpleTypeKind::None;
1228 case dwarf::DW_ATE_address:
1231 case dwarf::DW_ATE_boolean:
1233 case 1: STK = SimpleTypeKind::Boolean8; break;
1234 case 2: STK = SimpleTypeKind::Boolean16; break;
1235 case 4: STK = SimpleTypeKind::Boolean32; break;
1236 case 8: STK = SimpleTypeKind::Boolean64; break;
1237 case 16: STK = SimpleTypeKind::Boolean128; break;
1240 case dwarf::DW_ATE_complex_float:
1242 case 2: STK = SimpleTypeKind::Complex16; break;
1243 case 4: STK = SimpleTypeKind::Complex32; break;
1244 case 8: STK = SimpleTypeKind::Complex64; break;
1245 case 10: STK = SimpleTypeKind::Complex80; break;
1246 case 16: STK = SimpleTypeKind::Complex128; break;
1249 case dwarf::DW_ATE_float:
1251 case 2: STK = SimpleTypeKind::Float16; break;
1252 case 4: STK = SimpleTypeKind::Float32; break;
1253 case 6: STK = SimpleTypeKind::Float48; break;
1254 case 8: STK = SimpleTypeKind::Float64; break;
1255 case 10: STK = SimpleTypeKind::Float80; break;
1256 case 16: STK = SimpleTypeKind::Float128; break;
1259 case dwarf::DW_ATE_signed:
1261 case 1: STK = SimpleTypeKind::SignedCharacter; break;
1262 case 2: STK = SimpleTypeKind::Int16Short; break;
1263 case 4: STK = SimpleTypeKind::Int32; break;
1264 case 8: STK = SimpleTypeKind::Int64Quad; break;
1265 case 16: STK = SimpleTypeKind::Int128Oct; break;
1268 case dwarf::DW_ATE_unsigned:
1270 case 1: STK = SimpleTypeKind::UnsignedCharacter; break;
1271 case 2: STK = SimpleTypeKind::UInt16Short; break;
1272 case 4: STK = SimpleTypeKind::UInt32; break;
1273 case 8: STK = SimpleTypeKind::UInt64Quad; break;
1274 case 16: STK = SimpleTypeKind::UInt128Oct; break;
1277 case dwarf::DW_ATE_UTF:
1279 case 2: STK = SimpleTypeKind::Character16; break;
1280 case 4: STK = SimpleTypeKind::Character32; break;
1283 case dwarf::DW_ATE_signed_char:
1285 STK = SimpleTypeKind::SignedCharacter;
1287 case dwarf::DW_ATE_unsigned_char:
1289 STK = SimpleTypeKind::UnsignedCharacter;
1295 // Apply some fixups based on the source-level type name.
1296 if (STK == SimpleTypeKind::Int32 && Ty->getName() == "long int")
1297 STK = SimpleTypeKind::Int32Long;
1298 if (STK == SimpleTypeKind::UInt32 && Ty->getName() == "long unsigned int")
1299 STK = SimpleTypeKind::UInt32Long;
1300 if (STK == SimpleTypeKind::UInt16Short &&
1301 (Ty->getName() == "wchar_t" || Ty->getName() == "__wchar_t"))
1302 STK = SimpleTypeKind::WideCharacter;
1303 if ((STK == SimpleTypeKind::SignedCharacter ||
1304 STK == SimpleTypeKind::UnsignedCharacter) &&
1305 Ty->getName() == "char")
1306 STK = SimpleTypeKind::NarrowCharacter;
1308 return TypeIndex(STK);
1311 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty) {
1312 TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
1314 // Pointers to simple types can use SimpleTypeMode, rather than having a
1315 // dedicated pointer type record.
1316 if (PointeeTI.isSimple() &&
1317 PointeeTI.getSimpleMode() == SimpleTypeMode::Direct &&
1318 Ty->getTag() == dwarf::DW_TAG_pointer_type) {
1319 SimpleTypeMode Mode = Ty->getSizeInBits() == 64
1320 ? SimpleTypeMode::NearPointer64
1321 : SimpleTypeMode::NearPointer32;
1322 return TypeIndex(PointeeTI.getSimpleKind(), Mode);
1326 Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32;
1327 PointerMode PM = PointerMode::Pointer;
1328 switch (Ty->getTag()) {
1329 default: llvm_unreachable("not a pointer tag type");
1330 case dwarf::DW_TAG_pointer_type:
1331 PM = PointerMode::Pointer;
1333 case dwarf::DW_TAG_reference_type:
1334 PM = PointerMode::LValueReference;
1336 case dwarf::DW_TAG_rvalue_reference_type:
1337 PM = PointerMode::RValueReference;
1340 // FIXME: MSVC folds qualifiers into PointerOptions in the context of a method
1341 // 'this' pointer, but not normal contexts. Figure out what we're supposed to
1343 PointerOptions PO = PointerOptions::None;
1344 PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
1345 return TypeTable.writeKnownType(PR);
1348 static PointerToMemberRepresentation
1349 translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) {
1350 // SizeInBytes being zero generally implies that the member pointer type was
1351 // incomplete, which can happen if it is part of a function prototype. In this
1352 // case, use the unknown model instead of the general model.
1354 switch (Flags & DINode::FlagPtrToMemberRep) {
1356 return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1357 : PointerToMemberRepresentation::GeneralFunction;
1358 case DINode::FlagSingleInheritance:
1359 return PointerToMemberRepresentation::SingleInheritanceFunction;
1360 case DINode::FlagMultipleInheritance:
1361 return PointerToMemberRepresentation::MultipleInheritanceFunction;
1362 case DINode::FlagVirtualInheritance:
1363 return PointerToMemberRepresentation::VirtualInheritanceFunction;
1366 switch (Flags & DINode::FlagPtrToMemberRep) {
1368 return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1369 : PointerToMemberRepresentation::GeneralData;
1370 case DINode::FlagSingleInheritance:
1371 return PointerToMemberRepresentation::SingleInheritanceData;
1372 case DINode::FlagMultipleInheritance:
1373 return PointerToMemberRepresentation::MultipleInheritanceData;
1374 case DINode::FlagVirtualInheritance:
1375 return PointerToMemberRepresentation::VirtualInheritanceData;
1378 llvm_unreachable("invalid ptr to member representation");
1381 TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty) {
1382 assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
1383 TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
1384 TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
1385 PointerKind PK = Asm->TM.getPointerSize() == 8 ? PointerKind::Near64
1386 : PointerKind::Near32;
1387 bool IsPMF = isa<DISubroutineType>(Ty->getBaseType());
1388 PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction
1389 : PointerMode::PointerToDataMember;
1390 PointerOptions PO = PointerOptions::None; // FIXME
1391 assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big");
1392 uint8_t SizeInBytes = Ty->getSizeInBits() / 8;
1393 MemberPointerInfo MPI(
1394 ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags()));
1395 PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI);
1396 return TypeTable.writeKnownType(PR);
1399 /// Given a DWARF calling convention, get the CodeView equivalent. If we don't
1400 /// have a translation, use the NearC convention.
1401 static CallingConvention dwarfCCToCodeView(unsigned DwarfCC) {
1403 case dwarf::DW_CC_normal: return CallingConvention::NearC;
1404 case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast;
1405 case dwarf::DW_CC_BORLAND_thiscall: return CallingConvention::ThisCall;
1406 case dwarf::DW_CC_BORLAND_stdcall: return CallingConvention::NearStdCall;
1407 case dwarf::DW_CC_BORLAND_pascal: return CallingConvention::NearPascal;
1408 case dwarf::DW_CC_LLVM_vectorcall: return CallingConvention::NearVector;
1410 return CallingConvention::NearC;
1413 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
1414 ModifierOptions Mods = ModifierOptions::None;
1415 bool IsModifier = true;
1416 const DIType *BaseTy = Ty;
1417 while (IsModifier && BaseTy) {
1418 // FIXME: Need to add DWARF tags for __unaligned and _Atomic
1419 switch (BaseTy->getTag()) {
1420 case dwarf::DW_TAG_const_type:
1421 Mods |= ModifierOptions::Const;
1423 case dwarf::DW_TAG_volatile_type:
1424 Mods |= ModifierOptions::Volatile;
1431 BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
1433 TypeIndex ModifiedTI = getTypeIndex(BaseTy);
1434 ModifierRecord MR(ModifiedTI, Mods);
1435 return TypeTable.writeKnownType(MR);
1438 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
1439 SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1440 for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1441 ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1443 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1444 ArrayRef<TypeIndex> ArgTypeIndices = None;
1445 if (!ReturnAndArgTypeIndices.empty()) {
1446 auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1447 ReturnTypeIndex = ReturnAndArgTypesRef.front();
1448 ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1451 ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1452 TypeIndex ArgListIndex = TypeTable.writeKnownType(ArgListRec);
1454 CallingConvention CC = dwarfCCToCodeView(Ty->getCC());
1456 ProcedureRecord Procedure(ReturnTypeIndex, CC, FunctionOptions::None,
1457 ArgTypeIndices.size(), ArgListIndex);
1458 return TypeTable.writeKnownType(Procedure);
1461 TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
1462 const DIType *ClassTy,
1463 int ThisAdjustment) {
1464 // Lower the containing class type.
1465 TypeIndex ClassType = getTypeIndex(ClassTy);
1467 SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1468 for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1469 ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1471 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1472 ArrayRef<TypeIndex> ArgTypeIndices = None;
1473 if (!ReturnAndArgTypeIndices.empty()) {
1474 auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1475 ReturnTypeIndex = ReturnAndArgTypesRef.front();
1476 ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1478 TypeIndex ThisTypeIndex = TypeIndex::Void();
1479 if (!ArgTypeIndices.empty()) {
1480 ThisTypeIndex = ArgTypeIndices.front();
1481 ArgTypeIndices = ArgTypeIndices.drop_front();
1484 ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1485 TypeIndex ArgListIndex = TypeTable.writeKnownType(ArgListRec);
1487 CallingConvention CC = dwarfCCToCodeView(Ty->getCC());
1489 // TODO: Need to use the correct values for:
1491 // ThisPointerAdjustment.
1492 MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC,
1493 FunctionOptions::None, ArgTypeIndices.size(),
1494 ArgListIndex, ThisAdjustment);
1495 TypeIndex TI = TypeTable.writeKnownType(MFR);
1500 TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) {
1501 unsigned VSlotCount =
1502 Ty->getSizeInBits() / (8 * Asm->MAI->getCodePointerSize());
1503 SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near);
1505 VFTableShapeRecord VFTSR(Slots);
1506 return TypeTable.writeKnownType(VFTSR);
1509 static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) {
1510 switch (Flags & DINode::FlagAccessibility) {
1511 case DINode::FlagPrivate: return MemberAccess::Private;
1512 case DINode::FlagPublic: return MemberAccess::Public;
1513 case DINode::FlagProtected: return MemberAccess::Protected;
1515 // If there was no explicit access control, provide the default for the tag.
1516 return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private
1517 : MemberAccess::Public;
1519 llvm_unreachable("access flags are exclusive");
1522 static MethodOptions translateMethodOptionFlags(const DISubprogram *SP) {
1523 if (SP->isArtificial())
1524 return MethodOptions::CompilerGenerated;
1526 // FIXME: Handle other MethodOptions.
1528 return MethodOptions::None;
1531 static MethodKind translateMethodKindFlags(const DISubprogram *SP,
1533 switch (SP->getVirtuality()) {
1534 case dwarf::DW_VIRTUALITY_none:
1536 case dwarf::DW_VIRTUALITY_virtual:
1537 return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual;
1538 case dwarf::DW_VIRTUALITY_pure_virtual:
1539 return Introduced ? MethodKind::PureIntroducingVirtual
1540 : MethodKind::PureVirtual;
1542 llvm_unreachable("unhandled virtuality case");
1545 // FIXME: Get Clang to mark DISubprogram as static and do something with it.
1547 return MethodKind::Vanilla;
1550 static TypeRecordKind getRecordKind(const DICompositeType *Ty) {
1551 switch (Ty->getTag()) {
1552 case dwarf::DW_TAG_class_type: return TypeRecordKind::Class;
1553 case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct;
1555 llvm_unreachable("unexpected tag");
1558 /// Return ClassOptions that should be present on both the forward declaration
1559 /// and the defintion of a tag type.
1560 static ClassOptions getCommonClassOptions(const DICompositeType *Ty) {
1561 ClassOptions CO = ClassOptions::None;
1563 // MSVC always sets this flag, even for local types. Clang doesn't always
1564 // appear to give every type a linkage name, which may be problematic for us.
1565 // FIXME: Investigate the consequences of not following them here.
1566 if (!Ty->getIdentifier().empty())
1567 CO |= ClassOptions::HasUniqueName;
1569 // Put the Nested flag on a type if it appears immediately inside a tag type.
1570 // Do not walk the scope chain. Do not attempt to compute ContainsNestedClass
1571 // here. That flag is only set on definitions, and not forward declarations.
1572 const DIScope *ImmediateScope = Ty->getScope().resolve();
1573 if (ImmediateScope && isa<DICompositeType>(ImmediateScope))
1574 CO |= ClassOptions::Nested;
1576 // Put the Scoped flag on function-local types.
1577 for (const DIScope *Scope = ImmediateScope; Scope != nullptr;
1578 Scope = Scope->getScope().resolve()) {
1579 if (isa<DISubprogram>(Scope)) {
1580 CO |= ClassOptions::Scoped;
1588 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
1589 ClassOptions CO = getCommonClassOptions(Ty);
1591 unsigned EnumeratorCount = 0;
1593 if (Ty->isForwardDecl()) {
1594 CO |= ClassOptions::ForwardReference;
1596 FieldListRecordBuilder FLRB(TypeTable);
1599 for (const DINode *Element : Ty->getElements()) {
1600 // We assume that the frontend provides all members in source declaration
1601 // order, which is what MSVC does.
1602 if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) {
1603 EnumeratorRecord ER(MemberAccess::Public,
1604 APSInt::getUnsigned(Enumerator->getValue()),
1605 Enumerator->getName());
1606 FLRB.writeMemberType(ER);
1610 FTI = FLRB.end(true);
1613 std::string FullName = getFullyQualifiedName(Ty);
1615 EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(),
1616 getTypeIndex(Ty->getBaseType()));
1617 return TypeTable.writeKnownType(ER);
1620 //===----------------------------------------------------------------------===//
1622 //===----------------------------------------------------------------------===//
1624 struct llvm::ClassInfo {
1626 const DIDerivedType *MemberTypeNode;
1627 uint64_t BaseOffset;
1630 using MemberList = std::vector<MemberInfo>;
1632 using MethodsList = TinyPtrVector<const DISubprogram *>;
1633 // MethodName -> MethodsList
1634 using MethodsMap = MapVector<MDString *, MethodsList>;
1637 std::vector<const DIDerivedType *> Inheritance;
1641 // Direct overloaded methods gathered by name.
1646 std::vector<const DICompositeType *> NestedClasses;
1649 void CodeViewDebug::clear() {
1650 assert(CurFn == nullptr);
1652 FnDebugInfo.clear();
1653 FileToFilepathMap.clear();
1656 TypeIndices.clear();
1657 CompleteTypeIndices.clear();
1660 void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
1661 const DIDerivedType *DDTy) {
1662 if (!DDTy->getName().empty()) {
1663 Info.Members.push_back({DDTy, 0});
1666 // An unnamed member must represent a nested struct or union. Add all the
1667 // indirect fields to the current record.
1668 assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
1669 uint64_t Offset = DDTy->getOffsetInBits();
1670 const DIType *Ty = DDTy->getBaseType().resolve();
1671 const DICompositeType *DCTy = cast<DICompositeType>(Ty);
1672 ClassInfo NestedInfo = collectClassInfo(DCTy);
1673 for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members)
1674 Info.Members.push_back(
1675 {IndirectField.MemberTypeNode, IndirectField.BaseOffset + Offset});
1678 ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) {
1680 // Add elements to structure type.
1681 DINodeArray Elements = Ty->getElements();
1682 for (auto *Element : Elements) {
1683 // We assume that the frontend provides all members in source declaration
1684 // order, which is what MSVC does.
1687 if (auto *SP = dyn_cast<DISubprogram>(Element)) {
1688 Info.Methods[SP->getRawName()].push_back(SP);
1689 } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
1690 if (DDTy->getTag() == dwarf::DW_TAG_member) {
1691 collectMemberInfo(Info, DDTy);
1692 } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) {
1693 Info.Inheritance.push_back(DDTy);
1694 } else if (DDTy->getTag() == dwarf::DW_TAG_pointer_type &&
1695 DDTy->getName() == "__vtbl_ptr_type") {
1696 Info.VShapeTI = getTypeIndex(DDTy);
1697 } else if (DDTy->getTag() == dwarf::DW_TAG_friend) {
1698 // Ignore friend members. It appears that MSVC emitted info about
1699 // friends in the past, but modern versions do not.
1701 } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
1702 Info.NestedClasses.push_back(Composite);
1704 // Skip other unrecognized kinds of elements.
1709 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
1710 // First, construct the forward decl. Don't look into Ty to compute the
1711 // forward decl options, since it might not be available in all TUs.
1712 TypeRecordKind Kind = getRecordKind(Ty);
1714 ClassOptions::ForwardReference | getCommonClassOptions(Ty);
1715 std::string FullName = getFullyQualifiedName(Ty);
1716 ClassRecord CR(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0,
1717 FullName, Ty->getIdentifier());
1718 TypeIndex FwdDeclTI = TypeTable.writeKnownType(CR);
1719 if (!Ty->isForwardDecl())
1720 DeferredCompleteTypes.push_back(Ty);
1724 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
1725 // Construct the field list and complete type record.
1726 TypeRecordKind Kind = getRecordKind(Ty);
1727 ClassOptions CO = getCommonClassOptions(Ty);
1730 unsigned FieldCount;
1731 bool ContainsNestedClass;
1732 std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) =
1733 lowerRecordFieldList(Ty);
1735 if (ContainsNestedClass)
1736 CO |= ClassOptions::ContainsNestedClass;
1738 std::string FullName = getFullyQualifiedName(Ty);
1740 uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
1742 ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI,
1743 SizeInBytes, FullName, Ty->getIdentifier());
1744 TypeIndex ClassTI = TypeTable.writeKnownType(CR);
1746 if (const auto *File = Ty->getFile()) {
1747 StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File));
1748 TypeIndex SIDI = TypeTable.writeKnownType(SIDR);
1749 UdtSourceLineRecord USLR(ClassTI, SIDI, Ty->getLine());
1750 TypeTable.writeKnownType(USLR);
1753 addToUDTs(Ty, ClassTI);
1758 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
1760 ClassOptions::ForwardReference | getCommonClassOptions(Ty);
1761 std::string FullName = getFullyQualifiedName(Ty);
1762 UnionRecord UR(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier());
1763 TypeIndex FwdDeclTI = TypeTable.writeKnownType(UR);
1764 if (!Ty->isForwardDecl())
1765 DeferredCompleteTypes.push_back(Ty);
1769 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
1770 ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty);
1772 unsigned FieldCount;
1773 bool ContainsNestedClass;
1774 std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) =
1775 lowerRecordFieldList(Ty);
1777 if (ContainsNestedClass)
1778 CO |= ClassOptions::ContainsNestedClass;
1780 uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
1781 std::string FullName = getFullyQualifiedName(Ty);
1783 UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName,
1784 Ty->getIdentifier());
1785 TypeIndex UnionTI = TypeTable.writeKnownType(UR);
1787 StringIdRecord SIR(TypeIndex(0x0), getFullFilepath(Ty->getFile()));
1788 TypeIndex SIRI = TypeTable.writeKnownType(SIR);
1789 UdtSourceLineRecord USLR(UnionTI, SIRI, Ty->getLine());
1790 TypeTable.writeKnownType(USLR);
1792 addToUDTs(Ty, UnionTI);
1797 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
1798 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
1799 // Manually count members. MSVC appears to count everything that generates a
1800 // field list record. Each individual overload in a method overload group
1801 // contributes to this count, even though the overload group is a single field
1803 unsigned MemberCount = 0;
1804 ClassInfo Info = collectClassInfo(Ty);
1805 FieldListRecordBuilder FLBR(TypeTable);
1808 // Create base classes.
1809 for (const DIDerivedType *I : Info.Inheritance) {
1810 if (I->getFlags() & DINode::FlagVirtual) {
1812 // FIXME: Emit VBPtrOffset when the frontend provides it.
1813 unsigned VBPtrOffset = 0;
1814 // FIXME: Despite the accessor name, the offset is really in bytes.
1815 unsigned VBTableIndex = I->getOffsetInBits() / 4;
1816 auto RecordKind = (I->getFlags() & DINode::FlagIndirectVirtualBase) == DINode::FlagIndirectVirtualBase
1817 ? TypeRecordKind::IndirectVirtualBaseClass
1818 : TypeRecordKind::VirtualBaseClass;
1819 VirtualBaseClassRecord VBCR(
1820 RecordKind, translateAccessFlags(Ty->getTag(), I->getFlags()),
1821 getTypeIndex(I->getBaseType()), getVBPTypeIndex(), VBPtrOffset,
1824 FLBR.writeMemberType(VBCR);
1826 assert(I->getOffsetInBits() % 8 == 0 &&
1827 "bases must be on byte boundaries");
1828 BaseClassRecord BCR(translateAccessFlags(Ty->getTag(), I->getFlags()),
1829 getTypeIndex(I->getBaseType()),
1830 I->getOffsetInBits() / 8);
1831 FLBR.writeMemberType(BCR);
1836 for (ClassInfo::MemberInfo &MemberInfo : Info.Members) {
1837 const DIDerivedType *Member = MemberInfo.MemberTypeNode;
1838 TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType());
1839 StringRef MemberName = Member->getName();
1840 MemberAccess Access =
1841 translateAccessFlags(Ty->getTag(), Member->getFlags());
1843 if (Member->isStaticMember()) {
1844 StaticDataMemberRecord SDMR(Access, MemberBaseType, MemberName);
1845 FLBR.writeMemberType(SDMR);
1850 // Virtual function pointer member.
1851 if ((Member->getFlags() & DINode::FlagArtificial) &&
1852 Member->getName().startswith("_vptr$")) {
1853 VFPtrRecord VFPR(getTypeIndex(Member->getBaseType()));
1854 FLBR.writeMemberType(VFPR);
1860 uint64_t MemberOffsetInBits =
1861 Member->getOffsetInBits() + MemberInfo.BaseOffset;
1862 if (Member->isBitField()) {
1863 uint64_t StartBitOffset = MemberOffsetInBits;
1864 if (const auto *CI =
1865 dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) {
1866 MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset;
1868 StartBitOffset -= MemberOffsetInBits;
1869 BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(),
1871 MemberBaseType = TypeTable.writeKnownType(BFR);
1873 uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8;
1874 DataMemberRecord DMR(Access, MemberBaseType, MemberOffsetInBytes,
1876 FLBR.writeMemberType(DMR);
1881 for (auto &MethodItr : Info.Methods) {
1882 StringRef Name = MethodItr.first->getString();
1884 std::vector<OneMethodRecord> Methods;
1885 for (const DISubprogram *SP : MethodItr.second) {
1886 TypeIndex MethodType = getMemberFunctionType(SP, Ty);
1887 bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual;
1889 unsigned VFTableOffset = -1;
1891 VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes();
1893 Methods.push_back(OneMethodRecord(
1894 MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()),
1895 translateMethodKindFlags(SP, Introduced),
1896 translateMethodOptionFlags(SP), VFTableOffset, Name));
1899 assert(!Methods.empty() && "Empty methods map entry");
1900 if (Methods.size() == 1)
1901 FLBR.writeMemberType(Methods[0]);
1903 MethodOverloadListRecord MOLR(Methods);
1904 TypeIndex MethodList = TypeTable.writeKnownType(MOLR);
1905 OverloadedMethodRecord OMR(Methods.size(), MethodList, Name);
1906 FLBR.writeMemberType(OMR);
1910 // Create nested classes.
1911 for (const DICompositeType *Nested : Info.NestedClasses) {
1912 NestedTypeRecord R(getTypeIndex(DITypeRef(Nested)), Nested->getName());
1913 FLBR.writeMemberType(R);
1917 TypeIndex FieldTI = FLBR.end(true);
1918 return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount,
1919 !Info.NestedClasses.empty());
1922 TypeIndex CodeViewDebug::getVBPTypeIndex() {
1923 if (!VBPType.getIndex()) {
1924 // Make a 'const int *' type.
1925 ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
1926 TypeIndex ModifiedTI = TypeTable.writeKnownType(MR);
1928 PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
1929 : PointerKind::Near32;
1930 PointerMode PM = PointerMode::Pointer;
1931 PointerOptions PO = PointerOptions::None;
1932 PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
1934 VBPType = TypeTable.writeKnownType(PR);
1940 TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
1941 const DIType *Ty = TypeRef.resolve();
1942 const DIType *ClassTy = ClassTyRef.resolve();
1944 // The null DIType is the void type. Don't try to hash it.
1946 return TypeIndex::Void();
1948 // Check if we've already translated this type. Don't try to do a
1949 // get-or-create style insertion that caches the hash lookup across the
1950 // lowerType call. It will update the TypeIndices map.
1951 auto I = TypeIndices.find({Ty, ClassTy});
1952 if (I != TypeIndices.end())
1955 TypeLoweringScope S(*this);
1956 TypeIndex TI = lowerType(Ty, ClassTy);
1957 return recordTypeIndexForDINode(Ty, TI, ClassTy);
1960 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
1961 const DIType *Ty = TypeRef.resolve();
1963 // The null DIType is the void type. Don't try to hash it.
1965 return TypeIndex::Void();
1967 // If this is a non-record type, the complete type index is the same as the
1968 // normal type index. Just call getTypeIndex.
1969 switch (Ty->getTag()) {
1970 case dwarf::DW_TAG_class_type:
1971 case dwarf::DW_TAG_structure_type:
1972 case dwarf::DW_TAG_union_type:
1975 return getTypeIndex(Ty);
1978 // Check if we've already translated the complete record type. Lowering a
1979 // complete type should never trigger lowering another complete type, so we
1980 // can reuse the hash table lookup result.
1981 const auto *CTy = cast<DICompositeType>(Ty);
1982 auto InsertResult = CompleteTypeIndices.insert({CTy, TypeIndex()});
1983 if (!InsertResult.second)
1984 return InsertResult.first->second;
1986 TypeLoweringScope S(*this);
1988 // Make sure the forward declaration is emitted first. It's unclear if this
1989 // is necessary, but MSVC does it, and we should follow suit until we can show
1991 TypeIndex FwdDeclTI = getTypeIndex(CTy);
1993 // Just use the forward decl if we don't have complete type info. This might
1994 // happen if the frontend is using modules and expects the complete definition
1995 // to be emitted elsewhere.
1996 if (CTy->isForwardDecl())
2000 switch (CTy->getTag()) {
2001 case dwarf::DW_TAG_class_type:
2002 case dwarf::DW_TAG_structure_type:
2003 TI = lowerCompleteTypeClass(CTy);
2005 case dwarf::DW_TAG_union_type:
2006 TI = lowerCompleteTypeUnion(CTy);
2009 llvm_unreachable("not a record");
2012 InsertResult.first->second = TI;
2016 /// Emit all the deferred complete record types. Try to do this in FIFO order,
2017 /// and do this until fixpoint, as each complete record type typically
2019 /// many other record types.
2020 void CodeViewDebug::emitDeferredCompleteTypes() {
2021 SmallVector<const DICompositeType *, 4> TypesToEmit;
2022 while (!DeferredCompleteTypes.empty()) {
2023 std::swap(DeferredCompleteTypes, TypesToEmit);
2024 for (const DICompositeType *RecordTy : TypesToEmit)
2025 getCompleteTypeIndex(RecordTy);
2026 TypesToEmit.clear();
2030 void CodeViewDebug::emitLocalVariableList(ArrayRef<LocalVariable> Locals) {
2031 // Get the sorted list of parameters and emit them first.
2032 SmallVector<const LocalVariable *, 6> Params;
2033 for (const LocalVariable &L : Locals)
2034 if (L.DIVar->isParameter())
2035 Params.push_back(&L);
2036 std::sort(Params.begin(), Params.end(),
2037 [](const LocalVariable *L, const LocalVariable *R) {
2038 return L->DIVar->getArg() < R->DIVar->getArg();
2040 for (const LocalVariable *L : Params)
2041 emitLocalVariable(*L);
2043 // Next emit all non-parameters in the order that we found them.
2044 for (const LocalVariable &L : Locals)
2045 if (!L.DIVar->isParameter())
2046 emitLocalVariable(L);
2049 void CodeViewDebug::emitLocalVariable(const LocalVariable &Var) {
2050 // LocalSym record, see SymbolRecord.h for more info.
2051 MCSymbol *LocalBegin = MMI->getContext().createTempSymbol(),
2052 *LocalEnd = MMI->getContext().createTempSymbol();
2053 OS.AddComment("Record length");
2054 OS.emitAbsoluteSymbolDiff(LocalEnd, LocalBegin, 2);
2055 OS.EmitLabel(LocalBegin);
2057 OS.AddComment("Record kind: S_LOCAL");
2058 OS.EmitIntValue(unsigned(SymbolKind::S_LOCAL), 2);
2060 LocalSymFlags Flags = LocalSymFlags::None;
2061 if (Var.DIVar->isParameter())
2062 Flags |= LocalSymFlags::IsParameter;
2063 if (Var.DefRanges.empty())
2064 Flags |= LocalSymFlags::IsOptimizedOut;
2066 OS.AddComment("TypeIndex");
2067 TypeIndex TI = getCompleteTypeIndex(Var.DIVar->getType());
2068 OS.EmitIntValue(TI.getIndex(), 4);
2069 OS.AddComment("Flags");
2070 OS.EmitIntValue(static_cast<uint16_t>(Flags), 2);
2071 // Truncate the name so we won't overflow the record length field.
2072 emitNullTerminatedSymbolName(OS, Var.DIVar->getName());
2073 OS.EmitLabel(LocalEnd);
2075 // Calculate the on disk prefix of the appropriate def range record. The
2076 // records and on disk formats are described in SymbolRecords.h. BytePrefix
2077 // should be big enough to hold all forms without memory allocation.
2078 SmallString<20> BytePrefix;
2079 for (const LocalVarDefRange &DefRange : Var.DefRanges) {
2081 if (DefRange.InMemory) {
2082 uint16_t RegRelFlags = 0;
2083 if (DefRange.IsSubfield) {
2084 RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag |
2085 (DefRange.StructOffset
2086 << DefRangeRegisterRelSym::OffsetInParentShift);
2088 DefRangeRegisterRelSym Sym(S_DEFRANGE_REGISTER_REL);
2089 Sym.Hdr.Register = DefRange.CVRegister;
2090 Sym.Hdr.Flags = RegRelFlags;
2091 Sym.Hdr.BasePointerOffset = DefRange.DataOffset;
2092 ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_REGISTER_REL);
2094 StringRef(reinterpret_cast<const char *>(&SymKind), sizeof(SymKind));
2096 StringRef(reinterpret_cast<const char *>(&Sym.Hdr), sizeof(Sym.Hdr));
2098 assert(DefRange.DataOffset == 0 && "unexpected offset into register");
2099 if (DefRange.IsSubfield) {
2100 // Unclear what matters here.
2101 DefRangeSubfieldRegisterSym Sym(S_DEFRANGE_SUBFIELD_REGISTER);
2102 Sym.Hdr.Register = DefRange.CVRegister;
2103 Sym.Hdr.MayHaveNoName = 0;
2104 Sym.Hdr.OffsetInParent = DefRange.StructOffset;
2106 ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_SUBFIELD_REGISTER);
2107 BytePrefix += StringRef(reinterpret_cast<const char *>(&SymKind),
2109 BytePrefix += StringRef(reinterpret_cast<const char *>(&Sym.Hdr),
2112 // Unclear what matters here.
2113 DefRangeRegisterSym Sym(S_DEFRANGE_REGISTER);
2114 Sym.Hdr.Register = DefRange.CVRegister;
2115 Sym.Hdr.MayHaveNoName = 0;
2116 ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_REGISTER);
2117 BytePrefix += StringRef(reinterpret_cast<const char *>(&SymKind),
2119 BytePrefix += StringRef(reinterpret_cast<const char *>(&Sym.Hdr),
2123 OS.EmitCVDefRangeDirective(DefRange.Ranges, BytePrefix);
2127 void CodeViewDebug::endFunctionImpl(const MachineFunction *MF) {
2128 const Function *GV = MF->getFunction();
2129 assert(FnDebugInfo.count(GV));
2130 assert(CurFn == &FnDebugInfo[GV]);
2132 collectVariableInfo(GV->getSubprogram());
2134 // Don't emit anything if we don't have any line tables.
2135 if (!CurFn->HaveLineInfo) {
2136 FnDebugInfo.erase(GV);
2141 CurFn->End = Asm->getFunctionEnd();
2146 void CodeViewDebug::beginInstruction(const MachineInstr *MI) {
2147 DebugHandlerBase::beginInstruction(MI);
2149 // Ignore DBG_VALUE locations and function prologue.
2150 if (!Asm || !CurFn || MI->isDebugValue() ||
2151 MI->getFlag(MachineInstr::FrameSetup))
2154 // If the first instruction of a new MBB has no location, find the first
2155 // instruction with a location and use that.
2156 DebugLoc DL = MI->getDebugLoc();
2157 if (!DL && MI->getParent() != PrevInstBB) {
2158 for (const auto &NextMI : *MI->getParent()) {
2159 DL = NextMI.getDebugLoc();
2164 PrevInstBB = MI->getParent();
2166 // If we still don't have a debug location, don't record a location.
2170 maybeRecordLocation(DL, Asm->MF);
2173 MCSymbol *CodeViewDebug::beginCVSubsection(DebugSubsectionKind Kind) {
2174 MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
2175 *EndLabel = MMI->getContext().createTempSymbol();
2176 OS.EmitIntValue(unsigned(Kind), 4);
2177 OS.AddComment("Subsection size");
2178 OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4);
2179 OS.EmitLabel(BeginLabel);
2183 void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) {
2184 OS.EmitLabel(EndLabel);
2185 // Every subsection must be aligned to a 4-byte boundary.
2186 OS.EmitValueToAlignment(4);
2189 void CodeViewDebug::emitDebugInfoForUDTs(
2190 ArrayRef<std::pair<std::string, TypeIndex>> UDTs) {
2191 for (const std::pair<std::string, codeview::TypeIndex> &UDT : UDTs) {
2192 MCSymbol *UDTRecordBegin = MMI->getContext().createTempSymbol(),
2193 *UDTRecordEnd = MMI->getContext().createTempSymbol();
2194 OS.AddComment("Record length");
2195 OS.emitAbsoluteSymbolDiff(UDTRecordEnd, UDTRecordBegin, 2);
2196 OS.EmitLabel(UDTRecordBegin);
2198 OS.AddComment("Record kind: S_UDT");
2199 OS.EmitIntValue(unsigned(SymbolKind::S_UDT), 2);
2201 OS.AddComment("Type");
2202 OS.EmitIntValue(UDT.second.getIndex(), 4);
2204 emitNullTerminatedSymbolName(OS, UDT.first);
2205 OS.EmitLabel(UDTRecordEnd);
2209 void CodeViewDebug::emitDebugInfoForGlobals() {
2210 DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *>
2212 for (const GlobalVariable &GV : MMI->getModule()->globals()) {
2213 SmallVector<DIGlobalVariableExpression *, 1> GVEs;
2214 GV.getDebugInfo(GVEs);
2215 for (const auto *GVE : GVEs)
2216 GlobalMap[GVE] = &GV;
2219 NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2220 for (const MDNode *Node : CUs->operands()) {
2221 const auto *CU = cast<DICompileUnit>(Node);
2223 // First, emit all globals that are not in a comdat in a single symbol
2224 // substream. MSVC doesn't like it if the substream is empty, so only open
2225 // it if we have at least one global to emit.
2226 switchToDebugSectionForSymbol(nullptr);
2227 MCSymbol *EndLabel = nullptr;
2228 for (const auto *GVE : CU->getGlobalVariables()) {
2229 if (const auto *GV = GlobalMap.lookup(GVE))
2230 if (!GV->hasComdat() && !GV->isDeclarationForLinker()) {
2232 OS.AddComment("Symbol subsection for globals");
2233 EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2235 // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2236 emitDebugInfoForGlobal(GVE->getVariable(), GV, Asm->getSymbol(GV));
2240 endCVSubsection(EndLabel);
2242 // Second, emit each global that is in a comdat into its own .debug$S
2243 // section along with its own symbol substream.
2244 for (const auto *GVE : CU->getGlobalVariables()) {
2245 if (const auto *GV = GlobalMap.lookup(GVE)) {
2246 if (GV->hasComdat()) {
2247 MCSymbol *GVSym = Asm->getSymbol(GV);
2248 OS.AddComment("Symbol subsection for " +
2249 Twine(GlobalValue::dropLLVMManglingEscape(GV->getName())));
2250 switchToDebugSectionForSymbol(GVSym);
2251 EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2252 // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2253 emitDebugInfoForGlobal(GVE->getVariable(), GV, GVSym);
2254 endCVSubsection(EndLabel);
2261 void CodeViewDebug::emitDebugInfoForRetainedTypes() {
2262 NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2263 for (const MDNode *Node : CUs->operands()) {
2264 for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) {
2265 if (DIType *RT = dyn_cast<DIType>(Ty)) {
2267 // FIXME: Add to global/local DTU list.
2273 void CodeViewDebug::emitDebugInfoForGlobal(const DIGlobalVariable *DIGV,
2274 const GlobalVariable *GV,
2276 // DataSym record, see SymbolRecord.h for more info.
2277 // FIXME: Thread local data, etc
2278 MCSymbol *DataBegin = MMI->getContext().createTempSymbol(),
2279 *DataEnd = MMI->getContext().createTempSymbol();
2280 OS.AddComment("Record length");
2281 OS.emitAbsoluteSymbolDiff(DataEnd, DataBegin, 2);
2282 OS.EmitLabel(DataBegin);
2283 if (DIGV->isLocalToUnit()) {
2284 if (GV->isThreadLocal()) {
2285 OS.AddComment("Record kind: S_LTHREAD32");
2286 OS.EmitIntValue(unsigned(SymbolKind::S_LTHREAD32), 2);
2288 OS.AddComment("Record kind: S_LDATA32");
2289 OS.EmitIntValue(unsigned(SymbolKind::S_LDATA32), 2);
2292 if (GV->isThreadLocal()) {
2293 OS.AddComment("Record kind: S_GTHREAD32");
2294 OS.EmitIntValue(unsigned(SymbolKind::S_GTHREAD32), 2);
2296 OS.AddComment("Record kind: S_GDATA32");
2297 OS.EmitIntValue(unsigned(SymbolKind::S_GDATA32), 2);
2300 OS.AddComment("Type");
2301 OS.EmitIntValue(getCompleteTypeIndex(DIGV->getType()).getIndex(), 4);
2302 OS.AddComment("DataOffset");
2303 OS.EmitCOFFSecRel32(GVSym, /*Offset=*/0);
2304 OS.AddComment("Segment");
2305 OS.EmitCOFFSectionIndex(GVSym);
2306 OS.AddComment("Name");
2307 emitNullTerminatedSymbolName(OS, DIGV->getName());
2308 OS.EmitLabel(DataEnd);