1 //===- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp ----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for writing Microsoft CodeView debug info.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "CodeViewDebug.h"
15 #include "DwarfExpression.h"
16 #include "llvm/ADT/APSInt.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/DenseSet.h"
20 #include "llvm/ADT/MapVector.h"
21 #include "llvm/ADT/None.h"
22 #include "llvm/ADT/Optional.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/SmallString.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/ADT/TinyPtrVector.h"
28 #include "llvm/ADT/Triple.h"
29 #include "llvm/ADT/Twine.h"
30 #include "llvm/BinaryFormat/COFF.h"
31 #include "llvm/BinaryFormat/Dwarf.h"
32 #include "llvm/CodeGen/AsmPrinter.h"
33 #include "llvm/CodeGen/LexicalScopes.h"
34 #include "llvm/CodeGen/MachineFrameInfo.h"
35 #include "llvm/CodeGen/MachineFunction.h"
36 #include "llvm/CodeGen/MachineInstr.h"
37 #include "llvm/CodeGen/MachineModuleInfo.h"
38 #include "llvm/CodeGen/MachineOperand.h"
39 #include "llvm/CodeGen/TargetFrameLowering.h"
40 #include "llvm/CodeGen/TargetRegisterInfo.h"
41 #include "llvm/CodeGen/TargetSubtargetInfo.h"
42 #include "llvm/Config/llvm-config.h"
43 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
44 #include "llvm/DebugInfo/CodeView/CodeView.h"
45 #include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
46 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
47 #include "llvm/DebugInfo/CodeView/EnumTables.h"
48 #include "llvm/DebugInfo/CodeView/Line.h"
49 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
50 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
51 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
52 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
53 #include "llvm/DebugInfo/CodeView/TypeTableCollection.h"
54 #include "llvm/IR/Constants.h"
55 #include "llvm/IR/DataLayout.h"
56 #include "llvm/IR/DebugInfoMetadata.h"
57 #include "llvm/IR/DebugLoc.h"
58 #include "llvm/IR/Function.h"
59 #include "llvm/IR/GlobalValue.h"
60 #include "llvm/IR/GlobalVariable.h"
61 #include "llvm/IR/Metadata.h"
62 #include "llvm/IR/Module.h"
63 #include "llvm/MC/MCAsmInfo.h"
64 #include "llvm/MC/MCContext.h"
65 #include "llvm/MC/MCSectionCOFF.h"
66 #include "llvm/MC/MCStreamer.h"
67 #include "llvm/MC/MCSymbol.h"
68 #include "llvm/Support/BinaryByteStream.h"
69 #include "llvm/Support/BinaryStreamReader.h"
70 #include "llvm/Support/Casting.h"
71 #include "llvm/Support/CommandLine.h"
72 #include "llvm/Support/Compiler.h"
73 #include "llvm/Support/Endian.h"
74 #include "llvm/Support/Error.h"
75 #include "llvm/Support/ErrorHandling.h"
76 #include "llvm/Support/FormatVariadic.h"
77 #include "llvm/Support/Path.h"
78 #include "llvm/Support/SMLoc.h"
79 #include "llvm/Support/ScopedPrinter.h"
80 #include "llvm/Target/TargetLoweringObjectFile.h"
81 #include "llvm/Target/TargetMachine.h"
82 #include <algorithm>
83 #include <cassert>
84 #include <cctype>
85 #include <cstddef>
86 #include <cstdint>
87 #include <iterator>
88 #include <limits>
89 #include <string>
90 #include <utility>
91 #include <vector>
92
93 using namespace llvm;
94 using namespace llvm::codeview;
95
mapArchToCVCPUType(Triple::ArchType Type)96 static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
97 switch (Type) {
98 case Triple::ArchType::x86:
99 return CPUType::Pentium3;
100 case Triple::ArchType::x86_64:
101 return CPUType::X64;
102 case Triple::ArchType::thumb:
103 return CPUType::Thumb;
104 case Triple::ArchType::aarch64:
105 return CPUType::ARM64;
106 default:
107 report_fatal_error("target architecture doesn't map to a CodeView CPUType");
108 }
109 }
110
CodeViewDebug(AsmPrinter * AP)111 CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
112 : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {
113 // If module doesn't have named metadata anchors or COFF debug section
114 // is not available, skip any debug info related stuff.
115 if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") ||
116 !AP->getObjFileLowering().getCOFFDebugSymbolsSection()) {
117 Asm = nullptr;
118 MMI->setDebugInfoAvailability(false);
119 return;
120 }
121 // Tell MMI that we have debug info.
122 MMI->setDebugInfoAvailability(true);
123
124 TheCPU =
125 mapArchToCVCPUType(Triple(MMI->getModule()->getTargetTriple()).getArch());
126
127 collectGlobalVariableInfo();
128
129 // Check if we should emit type record hashes.
130 ConstantInt *GH = mdconst::extract_or_null<ConstantInt>(
131 MMI->getModule()->getModuleFlag("CodeViewGHash"));
132 EmitDebugGlobalHashes = GH && !GH->isZero();
133 }
134
getFullFilepath(const DIFile * File)135 StringRef CodeViewDebug::getFullFilepath(const DIFile *File) {
136 std::string &Filepath = FileToFilepathMap[File];
137 if (!Filepath.empty())
138 return Filepath;
139
140 StringRef Dir = File->getDirectory(), Filename = File->getFilename();
141
142 // If this is a Unix-style path, just use it as is. Don't try to canonicalize
143 // it textually because one of the path components could be a symlink.
144 if (Dir.startswith("/") || Filename.startswith("/")) {
145 if (llvm::sys::path::is_absolute(Filename, llvm::sys::path::Style::posix))
146 return Filename;
147 Filepath = Dir;
148 if (Dir.back() != '/')
149 Filepath += '/';
150 Filepath += Filename;
151 return Filepath;
152 }
153
154 // Clang emits directory and relative filename info into the IR, but CodeView
155 // operates on full paths. We could change Clang to emit full paths too, but
156 // that would increase the IR size and probably not needed for other users.
157 // For now, just concatenate and canonicalize the path here.
158 if (Filename.find(':') == 1)
159 Filepath = Filename;
160 else
161 Filepath = (Dir + "\\" + Filename).str();
162
163 // Canonicalize the path. We have to do it textually because we may no longer
164 // have access the file in the filesystem.
165 // First, replace all slashes with backslashes.
166 std::replace(Filepath.begin(), Filepath.end(), '/', '\\');
167
168 // Remove all "\.\" with "\".
169 size_t Cursor = 0;
170 while ((Cursor = Filepath.find("\\.\\", Cursor)) != std::string::npos)
171 Filepath.erase(Cursor, 2);
172
173 // Replace all "\XXX\..\" with "\". Don't try too hard though as the original
174 // path should be well-formatted, e.g. start with a drive letter, etc.
175 Cursor = 0;
176 while ((Cursor = Filepath.find("\\..\\", Cursor)) != std::string::npos) {
177 // Something's wrong if the path starts with "\..\", abort.
178 if (Cursor == 0)
179 break;
180
181 size_t PrevSlash = Filepath.rfind('\\', Cursor - 1);
182 if (PrevSlash == std::string::npos)
183 // Something's wrong, abort.
184 break;
185
186 Filepath.erase(PrevSlash, Cursor + 3 - PrevSlash);
187 // The next ".." might be following the one we've just erased.
188 Cursor = PrevSlash;
189 }
190
191 // Remove all duplicate backslashes.
192 Cursor = 0;
193 while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos)
194 Filepath.erase(Cursor, 1);
195
196 return Filepath;
197 }
198
maybeRecordFile(const DIFile * F)199 unsigned CodeViewDebug::maybeRecordFile(const DIFile *F) {
200 StringRef FullPath = getFullFilepath(F);
201 unsigned NextId = FileIdMap.size() + 1;
202 auto Insertion = FileIdMap.insert(std::make_pair(FullPath, NextId));
203 if (Insertion.second) {
204 // We have to compute the full filepath and emit a .cv_file directive.
205 ArrayRef<uint8_t> ChecksumAsBytes;
206 FileChecksumKind CSKind = FileChecksumKind::None;
207 if (F->getChecksum()) {
208 std::string Checksum = fromHex(F->getChecksum()->Value);
209 void *CKMem = OS.getContext().allocate(Checksum.size(), 1);
210 memcpy(CKMem, Checksum.data(), Checksum.size());
211 ChecksumAsBytes = ArrayRef<uint8_t>(
212 reinterpret_cast<const uint8_t *>(CKMem), Checksum.size());
213 switch (F->getChecksum()->Kind) {
214 case DIFile::CSK_MD5: CSKind = FileChecksumKind::MD5; break;
215 case DIFile::CSK_SHA1: CSKind = FileChecksumKind::SHA1; break;
216 }
217 }
218 bool Success = OS.EmitCVFileDirective(NextId, FullPath, ChecksumAsBytes,
219 static_cast<unsigned>(CSKind));
220 (void)Success;
221 assert(Success && ".cv_file directive failed");
222 }
223 return Insertion.first->second;
224 }
225
226 CodeViewDebug::InlineSite &
getInlineSite(const DILocation * InlinedAt,const DISubprogram * Inlinee)227 CodeViewDebug::getInlineSite(const DILocation *InlinedAt,
228 const DISubprogram *Inlinee) {
229 auto SiteInsertion = CurFn->InlineSites.insert({InlinedAt, InlineSite()});
230 InlineSite *Site = &SiteInsertion.first->second;
231 if (SiteInsertion.second) {
232 unsigned ParentFuncId = CurFn->FuncId;
233 if (const DILocation *OuterIA = InlinedAt->getInlinedAt())
234 ParentFuncId =
235 getInlineSite(OuterIA, InlinedAt->getScope()->getSubprogram())
236 .SiteFuncId;
237
238 Site->SiteFuncId = NextFuncId++;
239 OS.EmitCVInlineSiteIdDirective(
240 Site->SiteFuncId, ParentFuncId, maybeRecordFile(InlinedAt->getFile()),
241 InlinedAt->getLine(), InlinedAt->getColumn(), SMLoc());
242 Site->Inlinee = Inlinee;
243 InlinedSubprograms.insert(Inlinee);
244 getFuncIdForSubprogram(Inlinee);
245 }
246 return *Site;
247 }
248
getPrettyScopeName(const DIScope * Scope)249 static StringRef getPrettyScopeName(const DIScope *Scope) {
250 StringRef ScopeName = Scope->getName();
251 if (!ScopeName.empty())
252 return ScopeName;
253
254 switch (Scope->getTag()) {
255 case dwarf::DW_TAG_enumeration_type:
256 case dwarf::DW_TAG_class_type:
257 case dwarf::DW_TAG_structure_type:
258 case dwarf::DW_TAG_union_type:
259 return "<unnamed-tag>";
260 case dwarf::DW_TAG_namespace:
261 return "`anonymous namespace'";
262 }
263
264 return StringRef();
265 }
266
getQualifiedNameComponents(const DIScope * Scope,SmallVectorImpl<StringRef> & QualifiedNameComponents)267 static const DISubprogram *getQualifiedNameComponents(
268 const DIScope *Scope, SmallVectorImpl<StringRef> &QualifiedNameComponents) {
269 const DISubprogram *ClosestSubprogram = nullptr;
270 while (Scope != nullptr) {
271 if (ClosestSubprogram == nullptr)
272 ClosestSubprogram = dyn_cast<DISubprogram>(Scope);
273 StringRef ScopeName = getPrettyScopeName(Scope);
274 if (!ScopeName.empty())
275 QualifiedNameComponents.push_back(ScopeName);
276 Scope = Scope->getScope().resolve();
277 }
278 return ClosestSubprogram;
279 }
280
getQualifiedName(ArrayRef<StringRef> QualifiedNameComponents,StringRef TypeName)281 static std::string getQualifiedName(ArrayRef<StringRef> QualifiedNameComponents,
282 StringRef TypeName) {
283 std::string FullyQualifiedName;
284 for (StringRef QualifiedNameComponent :
285 llvm::reverse(QualifiedNameComponents)) {
286 FullyQualifiedName.append(QualifiedNameComponent);
287 FullyQualifiedName.append("::");
288 }
289 FullyQualifiedName.append(TypeName);
290 return FullyQualifiedName;
291 }
292
getFullyQualifiedName(const DIScope * Scope,StringRef Name)293 static std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name) {
294 SmallVector<StringRef, 5> QualifiedNameComponents;
295 getQualifiedNameComponents(Scope, QualifiedNameComponents);
296 return getQualifiedName(QualifiedNameComponents, Name);
297 }
298
299 struct CodeViewDebug::TypeLoweringScope {
TypeLoweringScopeCodeViewDebug::TypeLoweringScope300 TypeLoweringScope(CodeViewDebug &CVD) : CVD(CVD) { ++CVD.TypeEmissionLevel; }
~TypeLoweringScopeCodeViewDebug::TypeLoweringScope301 ~TypeLoweringScope() {
302 // Don't decrement TypeEmissionLevel until after emitting deferred types, so
303 // inner TypeLoweringScopes don't attempt to emit deferred types.
304 if (CVD.TypeEmissionLevel == 1)
305 CVD.emitDeferredCompleteTypes();
306 --CVD.TypeEmissionLevel;
307 }
308 CodeViewDebug &CVD;
309 };
310
getFullyQualifiedName(const DIScope * Ty)311 static std::string getFullyQualifiedName(const DIScope *Ty) {
312 const DIScope *Scope = Ty->getScope().resolve();
313 return getFullyQualifiedName(Scope, getPrettyScopeName(Ty));
314 }
315
getScopeIndex(const DIScope * Scope)316 TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) {
317 // No scope means global scope and that uses the zero index.
318 if (!Scope || isa<DIFile>(Scope))
319 return TypeIndex();
320
321 assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type");
322
323 // Check if we've already translated this scope.
324 auto I = TypeIndices.find({Scope, nullptr});
325 if (I != TypeIndices.end())
326 return I->second;
327
328 // Build the fully qualified name of the scope.
329 std::string ScopeName = getFullyQualifiedName(Scope);
330 StringIdRecord SID(TypeIndex(), ScopeName);
331 auto TI = TypeTable.writeLeafType(SID);
332 return recordTypeIndexForDINode(Scope, TI);
333 }
334
getFuncIdForSubprogram(const DISubprogram * SP)335 TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
336 assert(SP);
337
338 // Check if we've already translated this subprogram.
339 auto I = TypeIndices.find({SP, nullptr});
340 if (I != TypeIndices.end())
341 return I->second;
342
343 // The display name includes function template arguments. Drop them to match
344 // MSVC.
345 StringRef DisplayName = SP->getName().split('<').first;
346
347 const DIScope *Scope = SP->getScope().resolve();
348 TypeIndex TI;
349 if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) {
350 // If the scope is a DICompositeType, then this must be a method. Member
351 // function types take some special handling, and require access to the
352 // subprogram.
353 TypeIndex ClassType = getTypeIndex(Class);
354 MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class),
355 DisplayName);
356 TI = TypeTable.writeLeafType(MFuncId);
357 } else {
358 // Otherwise, this must be a free function.
359 TypeIndex ParentScope = getScopeIndex(Scope);
360 FuncIdRecord FuncId(ParentScope, getTypeIndex(SP->getType()), DisplayName);
361 TI = TypeTable.writeLeafType(FuncId);
362 }
363
364 return recordTypeIndexForDINode(SP, TI);
365 }
366
isTrivial(const DICompositeType * DCTy)367 static bool isTrivial(const DICompositeType *DCTy) {
368 return ((DCTy->getFlags() & DINode::FlagTrivial) == DINode::FlagTrivial);
369 }
370
371 static FunctionOptions
getFunctionOptions(const DISubroutineType * Ty,const DICompositeType * ClassTy=nullptr,StringRef SPName=StringRef (""))372 getFunctionOptions(const DISubroutineType *Ty,
373 const DICompositeType *ClassTy = nullptr,
374 StringRef SPName = StringRef("")) {
375 FunctionOptions FO = FunctionOptions::None;
376 const DIType *ReturnTy = nullptr;
377 if (auto TypeArray = Ty->getTypeArray()) {
378 if (TypeArray.size())
379 ReturnTy = TypeArray[0].resolve();
380 }
381
382 if (auto *ReturnDCTy = dyn_cast_or_null<DICompositeType>(ReturnTy)) {
383 if (!isTrivial(ReturnDCTy))
384 FO |= FunctionOptions::CxxReturnUdt;
385 }
386
387 // DISubroutineType is unnamed. Use DISubprogram's i.e. SPName in comparison.
388 if (ClassTy && !isTrivial(ClassTy) && SPName == ClassTy->getName()) {
389 FO |= FunctionOptions::Constructor;
390
391 // TODO: put the FunctionOptions::ConstructorWithVirtualBases flag.
392
393 }
394 return FO;
395 }
396
getMemberFunctionType(const DISubprogram * SP,const DICompositeType * Class)397 TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
398 const DICompositeType *Class) {
399 // Always use the method declaration as the key for the function type. The
400 // method declaration contains the this adjustment.
401 if (SP->getDeclaration())
402 SP = SP->getDeclaration();
403 assert(!SP->getDeclaration() && "should use declaration as key");
404
405 // Key the MemberFunctionRecord into the map as {SP, Class}. It won't collide
406 // with the MemberFuncIdRecord, which is keyed in as {SP, nullptr}.
407 auto I = TypeIndices.find({SP, Class});
408 if (I != TypeIndices.end())
409 return I->second;
410
411 // Make sure complete type info for the class is emitted *after* the member
412 // function type, as the complete class type is likely to reference this
413 // member function type.
414 TypeLoweringScope S(*this);
415 const bool IsStaticMethod = (SP->getFlags() & DINode::FlagStaticMember) != 0;
416
417 FunctionOptions FO = getFunctionOptions(SP->getType(), Class, SP->getName());
418 TypeIndex TI = lowerTypeMemberFunction(
419 SP->getType(), Class, SP->getThisAdjustment(), IsStaticMethod, FO);
420 return recordTypeIndexForDINode(SP, TI, Class);
421 }
422
recordTypeIndexForDINode(const DINode * Node,TypeIndex TI,const DIType * ClassTy)423 TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node,
424 TypeIndex TI,
425 const DIType *ClassTy) {
426 auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI});
427 (void)InsertResult;
428 assert(InsertResult.second && "DINode was already assigned a type index");
429 return TI;
430 }
431
getPointerSizeInBytes()432 unsigned CodeViewDebug::getPointerSizeInBytes() {
433 return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;
434 }
435
recordLocalVariable(LocalVariable && Var,const LexicalScope * LS)436 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
437 const LexicalScope *LS) {
438 if (const DILocation *InlinedAt = LS->getInlinedAt()) {
439 // This variable was inlined. Associate it with the InlineSite.
440 const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram();
441 InlineSite &Site = getInlineSite(InlinedAt, Inlinee);
442 Site.InlinedLocals.emplace_back(Var);
443 } else {
444 // This variable goes into the corresponding lexical scope.
445 ScopeVariables[LS].emplace_back(Var);
446 }
447 }
448
addLocIfNotPresent(SmallVectorImpl<const DILocation * > & Locs,const DILocation * Loc)449 static void addLocIfNotPresent(SmallVectorImpl<const DILocation *> &Locs,
450 const DILocation *Loc) {
451 auto B = Locs.begin(), E = Locs.end();
452 if (std::find(B, E, Loc) == E)
453 Locs.push_back(Loc);
454 }
455
maybeRecordLocation(const DebugLoc & DL,const MachineFunction * MF)456 void CodeViewDebug::maybeRecordLocation(const DebugLoc &DL,
457 const MachineFunction *MF) {
458 // Skip this instruction if it has the same location as the previous one.
459 if (!DL || DL == PrevInstLoc)
460 return;
461
462 const DIScope *Scope = DL.get()->getScope();
463 if (!Scope)
464 return;
465
466 // Skip this line if it is longer than the maximum we can record.
467 LineInfo LI(DL.getLine(), DL.getLine(), /*IsStatement=*/true);
468 if (LI.getStartLine() != DL.getLine() || LI.isAlwaysStepInto() ||
469 LI.isNeverStepInto())
470 return;
471
472 ColumnInfo CI(DL.getCol(), /*EndColumn=*/0);
473 if (CI.getStartColumn() != DL.getCol())
474 return;
475
476 if (!CurFn->HaveLineInfo)
477 CurFn->HaveLineInfo = true;
478 unsigned FileId = 0;
479 if (PrevInstLoc.get() && PrevInstLoc->getFile() == DL->getFile())
480 FileId = CurFn->LastFileId;
481 else
482 FileId = CurFn->LastFileId = maybeRecordFile(DL->getFile());
483 PrevInstLoc = DL;
484
485 unsigned FuncId = CurFn->FuncId;
486 if (const DILocation *SiteLoc = DL->getInlinedAt()) {
487 const DILocation *Loc = DL.get();
488
489 // If this location was actually inlined from somewhere else, give it the ID
490 // of the inline call site.
491 FuncId =
492 getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()).SiteFuncId;
493
494 // Ensure we have links in the tree of inline call sites.
495 bool FirstLoc = true;
496 while ((SiteLoc = Loc->getInlinedAt())) {
497 InlineSite &Site =
498 getInlineSite(SiteLoc, Loc->getScope()->getSubprogram());
499 if (!FirstLoc)
500 addLocIfNotPresent(Site.ChildSites, Loc);
501 FirstLoc = false;
502 Loc = SiteLoc;
503 }
504 addLocIfNotPresent(CurFn->ChildSites, Loc);
505 }
506
507 OS.EmitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(),
508 /*PrologueEnd=*/false, /*IsStmt=*/false,
509 DL->getFilename(), SMLoc());
510 }
511
emitCodeViewMagicVersion()512 void CodeViewDebug::emitCodeViewMagicVersion() {
513 OS.EmitValueToAlignment(4);
514 OS.AddComment("Debug section magic");
515 OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4);
516 }
517
endModule()518 void CodeViewDebug::endModule() {
519 if (!Asm || !MMI->hasDebugInfo())
520 return;
521
522 assert(Asm != nullptr);
523
524 // The COFF .debug$S section consists of several subsections, each starting
525 // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length
526 // of the payload followed by the payload itself. The subsections are 4-byte
527 // aligned.
528
529 // Use the generic .debug$S section, and make a subsection for all the inlined
530 // subprograms.
531 switchToDebugSectionForSymbol(nullptr);
532
533 MCSymbol *CompilerInfo = beginCVSubsection(DebugSubsectionKind::Symbols);
534 emitCompilerInformation();
535 endCVSubsection(CompilerInfo);
536
537 emitInlineeLinesSubsection();
538
539 // Emit per-function debug information.
540 for (auto &P : FnDebugInfo)
541 if (!P.first->isDeclarationForLinker())
542 emitDebugInfoForFunction(P.first, *P.second);
543
544 // Emit global variable debug information.
545 setCurrentSubprogram(nullptr);
546 emitDebugInfoForGlobals();
547
548 // Emit retained types.
549 emitDebugInfoForRetainedTypes();
550
551 // Switch back to the generic .debug$S section after potentially processing
552 // comdat symbol sections.
553 switchToDebugSectionForSymbol(nullptr);
554
555 // Emit UDT records for any types used by global variables.
556 if (!GlobalUDTs.empty()) {
557 MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
558 emitDebugInfoForUDTs(GlobalUDTs);
559 endCVSubsection(SymbolsEnd);
560 }
561
562 // This subsection holds a file index to offset in string table table.
563 OS.AddComment("File index to string table offset subsection");
564 OS.EmitCVFileChecksumsDirective();
565
566 // This subsection holds the string table.
567 OS.AddComment("String table");
568 OS.EmitCVStringTableDirective();
569
570 // Emit S_BUILDINFO, which points to LF_BUILDINFO. Put this in its own symbol
571 // subsection in the generic .debug$S section at the end. There is no
572 // particular reason for this ordering other than to match MSVC.
573 emitBuildInfo();
574
575 // Emit type information and hashes last, so that any types we translate while
576 // emitting function info are included.
577 emitTypeInformation();
578
579 if (EmitDebugGlobalHashes)
580 emitTypeGlobalHashes();
581
582 clear();
583 }
584
emitNullTerminatedSymbolName(MCStreamer & OS,StringRef S,unsigned MaxFixedRecordLength=0xF00)585 static void emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S,
586 unsigned MaxFixedRecordLength = 0xF00) {
587 // The maximum CV record length is 0xFF00. Most of the strings we emit appear
588 // after a fixed length portion of the record. The fixed length portion should
589 // always be less than 0xF00 (3840) bytes, so truncate the string so that the
590 // overall record size is less than the maximum allowed.
591 SmallString<32> NullTerminatedString(
592 S.take_front(MaxRecordLength - MaxFixedRecordLength - 1));
593 NullTerminatedString.push_back('\0');
594 OS.EmitBytes(NullTerminatedString);
595 }
596
emitTypeInformation()597 void CodeViewDebug::emitTypeInformation() {
598 if (TypeTable.empty())
599 return;
600
601 // Start the .debug$T or .debug$P section with 0x4.
602 OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
603 emitCodeViewMagicVersion();
604
605 SmallString<8> CommentPrefix;
606 if (OS.isVerboseAsm()) {
607 CommentPrefix += '\t';
608 CommentPrefix += Asm->MAI->getCommentString();
609 CommentPrefix += ' ';
610 }
611
612 TypeTableCollection Table(TypeTable.records());
613 Optional<TypeIndex> B = Table.getFirst();
614 while (B) {
615 // This will fail if the record data is invalid.
616 CVType Record = Table.getType(*B);
617
618 if (OS.isVerboseAsm()) {
619 // Emit a block comment describing the type record for readability.
620 SmallString<512> CommentBlock;
621 raw_svector_ostream CommentOS(CommentBlock);
622 ScopedPrinter SP(CommentOS);
623 SP.setPrefix(CommentPrefix);
624 TypeDumpVisitor TDV(Table, &SP, false);
625
626 Error E = codeview::visitTypeRecord(Record, *B, TDV);
627 if (E) {
628 logAllUnhandledErrors(std::move(E), errs(), "error: ");
629 llvm_unreachable("produced malformed type record");
630 }
631 // emitRawComment will insert its own tab and comment string before
632 // the first line, so strip off our first one. It also prints its own
633 // newline.
634 OS.emitRawComment(
635 CommentOS.str().drop_front(CommentPrefix.size() - 1).rtrim());
636 }
637 OS.EmitBinaryData(Record.str_data());
638 B = Table.getNext(*B);
639 }
640 }
641
emitTypeGlobalHashes()642 void CodeViewDebug::emitTypeGlobalHashes() {
643 if (TypeTable.empty())
644 return;
645
646 // Start the .debug$H section with the version and hash algorithm, currently
647 // hardcoded to version 0, SHA1.
648 OS.SwitchSection(Asm->getObjFileLowering().getCOFFGlobalTypeHashesSection());
649
650 OS.EmitValueToAlignment(4);
651 OS.AddComment("Magic");
652 OS.EmitIntValue(COFF::DEBUG_HASHES_SECTION_MAGIC, 4);
653 OS.AddComment("Section Version");
654 OS.EmitIntValue(0, 2);
655 OS.AddComment("Hash Algorithm");
656 OS.EmitIntValue(uint16_t(GlobalTypeHashAlg::SHA1_8), 2);
657
658 TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
659 for (const auto &GHR : TypeTable.hashes()) {
660 if (OS.isVerboseAsm()) {
661 // Emit an EOL-comment describing which TypeIndex this hash corresponds
662 // to, as well as the stringified SHA1 hash.
663 SmallString<32> Comment;
664 raw_svector_ostream CommentOS(Comment);
665 CommentOS << formatv("{0:X+} [{1}]", TI.getIndex(), GHR);
666 OS.AddComment(Comment);
667 ++TI;
668 }
669 assert(GHR.Hash.size() == 8);
670 StringRef S(reinterpret_cast<const char *>(GHR.Hash.data()),
671 GHR.Hash.size());
672 OS.EmitBinaryData(S);
673 }
674 }
675
MapDWLangToCVLang(unsigned DWLang)676 static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
677 switch (DWLang) {
678 case dwarf::DW_LANG_C:
679 case dwarf::DW_LANG_C89:
680 case dwarf::DW_LANG_C99:
681 case dwarf::DW_LANG_C11:
682 case dwarf::DW_LANG_ObjC:
683 return SourceLanguage::C;
684 case dwarf::DW_LANG_C_plus_plus:
685 case dwarf::DW_LANG_C_plus_plus_03:
686 case dwarf::DW_LANG_C_plus_plus_11:
687 case dwarf::DW_LANG_C_plus_plus_14:
688 return SourceLanguage::Cpp;
689 case dwarf::DW_LANG_Fortran77:
690 case dwarf::DW_LANG_Fortran90:
691 case dwarf::DW_LANG_Fortran03:
692 case dwarf::DW_LANG_Fortran08:
693 return SourceLanguage::Fortran;
694 case dwarf::DW_LANG_Pascal83:
695 return SourceLanguage::Pascal;
696 case dwarf::DW_LANG_Cobol74:
697 case dwarf::DW_LANG_Cobol85:
698 return SourceLanguage::Cobol;
699 case dwarf::DW_LANG_Java:
700 return SourceLanguage::Java;
701 case dwarf::DW_LANG_D:
702 return SourceLanguage::D;
703 default:
704 // There's no CodeView representation for this language, and CV doesn't
705 // have an "unknown" option for the language field, so we'll use MASM,
706 // as it's very low level.
707 return SourceLanguage::Masm;
708 }
709 }
710
711 namespace {
712 struct Version {
713 int Part[4];
714 };
715 } // end anonymous namespace
716
717 // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out
718 // the version number.
parseVersion(StringRef Name)719 static Version parseVersion(StringRef Name) {
720 Version V = {{0}};
721 int N = 0;
722 for (const char C : Name) {
723 if (isdigit(C)) {
724 V.Part[N] *= 10;
725 V.Part[N] += C - '0';
726 } else if (C == '.') {
727 ++N;
728 if (N >= 4)
729 return V;
730 } else if (N > 0)
731 return V;
732 }
733 return V;
734 }
735
emitCompilerInformation()736 void CodeViewDebug::emitCompilerInformation() {
737 MCSymbol *CompilerEnd = beginSymbolRecord(SymbolKind::S_COMPILE3);
738 uint32_t Flags = 0;
739
740 NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
741 const MDNode *Node = *CUs->operands().begin();
742 const auto *CU = cast<DICompileUnit>(Node);
743
744 // The low byte of the flags indicates the source language.
745 Flags = MapDWLangToCVLang(CU->getSourceLanguage());
746 // TODO: Figure out which other flags need to be set.
747
748 OS.AddComment("Flags and language");
749 OS.EmitIntValue(Flags, 4);
750
751 OS.AddComment("CPUType");
752 OS.EmitIntValue(static_cast<uint64_t>(TheCPU), 2);
753
754 StringRef CompilerVersion = CU->getProducer();
755 Version FrontVer = parseVersion(CompilerVersion);
756 OS.AddComment("Frontend version");
757 for (int N = 0; N < 4; ++N)
758 OS.EmitIntValue(FrontVer.Part[N], 2);
759
760 // Some Microsoft tools, like Binscope, expect a backend version number of at
761 // least 8.something, so we'll coerce the LLVM version into a form that
762 // guarantees it'll be big enough without really lying about the version.
763 int Major = 1000 * LLVM_VERSION_MAJOR +
764 10 * LLVM_VERSION_MINOR +
765 LLVM_VERSION_PATCH;
766 // Clamp it for builds that use unusually large version numbers.
767 Major = std::min<int>(Major, std::numeric_limits<uint16_t>::max());
768 Version BackVer = {{ Major, 0, 0, 0 }};
769 OS.AddComment("Backend version");
770 for (int N = 0; N < 4; ++N)
771 OS.EmitIntValue(BackVer.Part[N], 2);
772
773 OS.AddComment("Null-terminated compiler version string");
774 emitNullTerminatedSymbolName(OS, CompilerVersion);
775
776 endSymbolRecord(CompilerEnd);
777 }
778
getStringIdTypeIdx(GlobalTypeTableBuilder & TypeTable,StringRef S)779 static TypeIndex getStringIdTypeIdx(GlobalTypeTableBuilder &TypeTable,
780 StringRef S) {
781 StringIdRecord SIR(TypeIndex(0x0), S);
782 return TypeTable.writeLeafType(SIR);
783 }
784
emitBuildInfo()785 void CodeViewDebug::emitBuildInfo() {
786 // First, make LF_BUILDINFO. It's a sequence of strings with various bits of
787 // build info. The known prefix is:
788 // - Absolute path of current directory
789 // - Compiler path
790 // - Main source file path, relative to CWD or absolute
791 // - Type server PDB file
792 // - Canonical compiler command line
793 // If frontend and backend compilation are separated (think llc or LTO), it's
794 // not clear if the compiler path should refer to the executable for the
795 // frontend or the backend. Leave it blank for now.
796 TypeIndex BuildInfoArgs[BuildInfoRecord::MaxArgs] = {};
797 NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
798 const MDNode *Node = *CUs->operands().begin(); // FIXME: Multiple CUs.
799 const auto *CU = cast<DICompileUnit>(Node);
800 const DIFile *MainSourceFile = CU->getFile();
801 BuildInfoArgs[BuildInfoRecord::CurrentDirectory] =
802 getStringIdTypeIdx(TypeTable, MainSourceFile->getDirectory());
803 BuildInfoArgs[BuildInfoRecord::SourceFile] =
804 getStringIdTypeIdx(TypeTable, MainSourceFile->getFilename());
805 // FIXME: Path to compiler and command line. PDB is intentionally blank unless
806 // we implement /Zi type servers.
807 BuildInfoRecord BIR(BuildInfoArgs);
808 TypeIndex BuildInfoIndex = TypeTable.writeLeafType(BIR);
809
810 // Make a new .debug$S subsection for the S_BUILDINFO record, which points
811 // from the module symbols into the type stream.
812 MCSymbol *BISubsecEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
813 MCSymbol *BIEnd = beginSymbolRecord(SymbolKind::S_BUILDINFO);
814 OS.AddComment("LF_BUILDINFO index");
815 OS.EmitIntValue(BuildInfoIndex.getIndex(), 4);
816 endSymbolRecord(BIEnd);
817 endCVSubsection(BISubsecEnd);
818 }
819
emitInlineeLinesSubsection()820 void CodeViewDebug::emitInlineeLinesSubsection() {
821 if (InlinedSubprograms.empty())
822 return;
823
824 OS.AddComment("Inlinee lines subsection");
825 MCSymbol *InlineEnd = beginCVSubsection(DebugSubsectionKind::InlineeLines);
826
827 // We emit the checksum info for files. This is used by debuggers to
828 // determine if a pdb matches the source before loading it. Visual Studio,
829 // for instance, will display a warning that the breakpoints are not valid if
830 // the pdb does not match the source.
831 OS.AddComment("Inlinee lines signature");
832 OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
833
834 for (const DISubprogram *SP : InlinedSubprograms) {
835 assert(TypeIndices.count({SP, nullptr}));
836 TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
837
838 OS.AddBlankLine();
839 unsigned FileId = maybeRecordFile(SP->getFile());
840 OS.AddComment("Inlined function " + SP->getName() + " starts at " +
841 SP->getFilename() + Twine(':') + Twine(SP->getLine()));
842 OS.AddBlankLine();
843 OS.AddComment("Type index of inlined function");
844 OS.EmitIntValue(InlineeIdx.getIndex(), 4);
845 OS.AddComment("Offset into filechecksum table");
846 OS.EmitCVFileChecksumOffsetDirective(FileId);
847 OS.AddComment("Starting line number");
848 OS.EmitIntValue(SP->getLine(), 4);
849 }
850
851 endCVSubsection(InlineEnd);
852 }
853
emitInlinedCallSite(const FunctionInfo & FI,const DILocation * InlinedAt,const InlineSite & Site)854 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
855 const DILocation *InlinedAt,
856 const InlineSite &Site) {
857 assert(TypeIndices.count({Site.Inlinee, nullptr}));
858 TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];
859
860 // SymbolRecord
861 MCSymbol *InlineEnd = beginSymbolRecord(SymbolKind::S_INLINESITE);
862
863 OS.AddComment("PtrParent");
864 OS.EmitIntValue(0, 4);
865 OS.AddComment("PtrEnd");
866 OS.EmitIntValue(0, 4);
867 OS.AddComment("Inlinee type index");
868 OS.EmitIntValue(InlineeIdx.getIndex(), 4);
869
870 unsigned FileId = maybeRecordFile(Site.Inlinee->getFile());
871 unsigned StartLineNum = Site.Inlinee->getLine();
872
873 OS.EmitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum,
874 FI.Begin, FI.End);
875
876 endSymbolRecord(InlineEnd);
877
878 emitLocalVariableList(FI, Site.InlinedLocals);
879
880 // Recurse on child inlined call sites before closing the scope.
881 for (const DILocation *ChildSite : Site.ChildSites) {
882 auto I = FI.InlineSites.find(ChildSite);
883 assert(I != FI.InlineSites.end() &&
884 "child site not in function inline site map");
885 emitInlinedCallSite(FI, ChildSite, I->second);
886 }
887
888 // Close the scope.
889 emitEndSymbolRecord(SymbolKind::S_INLINESITE_END);
890 }
891
switchToDebugSectionForSymbol(const MCSymbol * GVSym)892 void CodeViewDebug::switchToDebugSectionForSymbol(const MCSymbol *GVSym) {
893 // If we have a symbol, it may be in a section that is COMDAT. If so, find the
894 // comdat key. A section may be comdat because of -ffunction-sections or
895 // because it is comdat in the IR.
896 MCSectionCOFF *GVSec =
897 GVSym ? dyn_cast<MCSectionCOFF>(&GVSym->getSection()) : nullptr;
898 const MCSymbol *KeySym = GVSec ? GVSec->getCOMDATSymbol() : nullptr;
899
900 MCSectionCOFF *DebugSec = cast<MCSectionCOFF>(
901 Asm->getObjFileLowering().getCOFFDebugSymbolsSection());
902 DebugSec = OS.getContext().getAssociativeCOFFSection(DebugSec, KeySym);
903
904 OS.SwitchSection(DebugSec);
905
906 // Emit the magic version number if this is the first time we've switched to
907 // this section.
908 if (ComdatDebugSections.insert(DebugSec).second)
909 emitCodeViewMagicVersion();
910 }
911
912 // Emit an S_THUNK32/S_END symbol pair for a thunk routine.
913 // The only supported thunk ordinal is currently the standard type.
emitDebugInfoForThunk(const Function * GV,FunctionInfo & FI,const MCSymbol * Fn)914 void CodeViewDebug::emitDebugInfoForThunk(const Function *GV,
915 FunctionInfo &FI,
916 const MCSymbol *Fn) {
917 std::string FuncName = GlobalValue::dropLLVMManglingEscape(GV->getName());
918 const ThunkOrdinal ordinal = ThunkOrdinal::Standard; // Only supported kind.
919
920 OS.AddComment("Symbol subsection for " + Twine(FuncName));
921 MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
922
923 // Emit S_THUNK32
924 MCSymbol *ThunkRecordEnd = beginSymbolRecord(SymbolKind::S_THUNK32);
925 OS.AddComment("PtrParent");
926 OS.EmitIntValue(0, 4);
927 OS.AddComment("PtrEnd");
928 OS.EmitIntValue(0, 4);
929 OS.AddComment("PtrNext");
930 OS.EmitIntValue(0, 4);
931 OS.AddComment("Thunk section relative address");
932 OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
933 OS.AddComment("Thunk section index");
934 OS.EmitCOFFSectionIndex(Fn);
935 OS.AddComment("Code size");
936 OS.emitAbsoluteSymbolDiff(FI.End, Fn, 2);
937 OS.AddComment("Ordinal");
938 OS.EmitIntValue(unsigned(ordinal), 1);
939 OS.AddComment("Function name");
940 emitNullTerminatedSymbolName(OS, FuncName);
941 // Additional fields specific to the thunk ordinal would go here.
942 endSymbolRecord(ThunkRecordEnd);
943
944 // Local variables/inlined routines are purposely omitted here. The point of
945 // marking this as a thunk is so Visual Studio will NOT stop in this routine.
946
947 // Emit S_PROC_ID_END
948 emitEndSymbolRecord(SymbolKind::S_PROC_ID_END);
949
950 endCVSubsection(SymbolsEnd);
951 }
952
emitDebugInfoForFunction(const Function * GV,FunctionInfo & FI)953 void CodeViewDebug::emitDebugInfoForFunction(const Function *GV,
954 FunctionInfo &FI) {
955 // For each function there is a separate subsection which holds the PC to
956 // file:line table.
957 const MCSymbol *Fn = Asm->getSymbol(GV);
958 assert(Fn);
959
960 // Switch to the to a comdat section, if appropriate.
961 switchToDebugSectionForSymbol(Fn);
962
963 std::string FuncName;
964 auto *SP = GV->getSubprogram();
965 assert(SP);
966 setCurrentSubprogram(SP);
967
968 if (SP->isThunk()) {
969 emitDebugInfoForThunk(GV, FI, Fn);
970 return;
971 }
972
973 // If we have a display name, build the fully qualified name by walking the
974 // chain of scopes.
975 if (!SP->getName().empty())
976 FuncName =
977 getFullyQualifiedName(SP->getScope().resolve(), SP->getName());
978
979 // If our DISubprogram name is empty, use the mangled name.
980 if (FuncName.empty())
981 FuncName = GlobalValue::dropLLVMManglingEscape(GV->getName());
982
983 // Emit FPO data, but only on 32-bit x86. No other platforms use it.
984 if (Triple(MMI->getModule()->getTargetTriple()).getArch() == Triple::x86)
985 OS.EmitCVFPOData(Fn);
986
987 // Emit a symbol subsection, required by VS2012+ to find function boundaries.
988 OS.AddComment("Symbol subsection for " + Twine(FuncName));
989 MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
990 {
991 SymbolKind ProcKind = GV->hasLocalLinkage() ? SymbolKind::S_LPROC32_ID
992 : SymbolKind::S_GPROC32_ID;
993 MCSymbol *ProcRecordEnd = beginSymbolRecord(ProcKind);
994
995 // These fields are filled in by tools like CVPACK which run after the fact.
996 OS.AddComment("PtrParent");
997 OS.EmitIntValue(0, 4);
998 OS.AddComment("PtrEnd");
999 OS.EmitIntValue(0, 4);
1000 OS.AddComment("PtrNext");
1001 OS.EmitIntValue(0, 4);
1002 // This is the important bit that tells the debugger where the function
1003 // code is located and what's its size:
1004 OS.AddComment("Code size");
1005 OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4);
1006 OS.AddComment("Offset after prologue");
1007 OS.EmitIntValue(0, 4);
1008 OS.AddComment("Offset before epilogue");
1009 OS.EmitIntValue(0, 4);
1010 OS.AddComment("Function type index");
1011 OS.EmitIntValue(getFuncIdForSubprogram(GV->getSubprogram()).getIndex(), 4);
1012 OS.AddComment("Function section relative address");
1013 OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
1014 OS.AddComment("Function section index");
1015 OS.EmitCOFFSectionIndex(Fn);
1016 OS.AddComment("Flags");
1017 OS.EmitIntValue(0, 1);
1018 // Emit the function display name as a null-terminated string.
1019 OS.AddComment("Function name");
1020 // Truncate the name so we won't overflow the record length field.
1021 emitNullTerminatedSymbolName(OS, FuncName);
1022 endSymbolRecord(ProcRecordEnd);
1023
1024 MCSymbol *FrameProcEnd = beginSymbolRecord(SymbolKind::S_FRAMEPROC);
1025 // Subtract out the CSR size since MSVC excludes that and we include it.
1026 OS.AddComment("FrameSize");
1027 OS.EmitIntValue(FI.FrameSize - FI.CSRSize, 4);
1028 OS.AddComment("Padding");
1029 OS.EmitIntValue(0, 4);
1030 OS.AddComment("Offset of padding");
1031 OS.EmitIntValue(0, 4);
1032 OS.AddComment("Bytes of callee saved registers");
1033 OS.EmitIntValue(FI.CSRSize, 4);
1034 OS.AddComment("Exception handler offset");
1035 OS.EmitIntValue(0, 4);
1036 OS.AddComment("Exception handler section");
1037 OS.EmitIntValue(0, 2);
1038 OS.AddComment("Flags (defines frame register)");
1039 OS.EmitIntValue(uint32_t(FI.FrameProcOpts), 4);
1040 endSymbolRecord(FrameProcEnd);
1041
1042 emitLocalVariableList(FI, FI.Locals);
1043 emitGlobalVariableList(FI.Globals);
1044 emitLexicalBlockList(FI.ChildBlocks, FI);
1045
1046 // Emit inlined call site information. Only emit functions inlined directly
1047 // into the parent function. We'll emit the other sites recursively as part
1048 // of their parent inline site.
1049 for (const DILocation *InlinedAt : FI.ChildSites) {
1050 auto I = FI.InlineSites.find(InlinedAt);
1051 assert(I != FI.InlineSites.end() &&
1052 "child site not in function inline site map");
1053 emitInlinedCallSite(FI, InlinedAt, I->second);
1054 }
1055
1056 for (auto Annot : FI.Annotations) {
1057 MCSymbol *Label = Annot.first;
1058 MDTuple *Strs = cast<MDTuple>(Annot.second);
1059 MCSymbol *AnnotEnd = beginSymbolRecord(SymbolKind::S_ANNOTATION);
1060 OS.EmitCOFFSecRel32(Label, /*Offset=*/0);
1061 // FIXME: Make sure we don't overflow the max record size.
1062 OS.EmitCOFFSectionIndex(Label);
1063 OS.EmitIntValue(Strs->getNumOperands(), 2);
1064 for (Metadata *MD : Strs->operands()) {
1065 // MDStrings are null terminated, so we can do EmitBytes and get the
1066 // nice .asciz directive.
1067 StringRef Str = cast<MDString>(MD)->getString();
1068 assert(Str.data()[Str.size()] == '\0' && "non-nullterminated MDString");
1069 OS.EmitBytes(StringRef(Str.data(), Str.size() + 1));
1070 }
1071 endSymbolRecord(AnnotEnd);
1072 }
1073
1074 if (SP != nullptr)
1075 emitDebugInfoForUDTs(LocalUDTs);
1076
1077 // We're done with this function.
1078 emitEndSymbolRecord(SymbolKind::S_PROC_ID_END);
1079 }
1080 endCVSubsection(SymbolsEnd);
1081
1082 // We have an assembler directive that takes care of the whole line table.
1083 OS.EmitCVLinetableDirective(FI.FuncId, Fn, FI.End);
1084 }
1085
1086 CodeViewDebug::LocalVarDefRange
createDefRangeMem(uint16_t CVRegister,int Offset)1087 CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) {
1088 LocalVarDefRange DR;
1089 DR.InMemory = -1;
1090 DR.DataOffset = Offset;
1091 assert(DR.DataOffset == Offset && "truncation");
1092 DR.IsSubfield = 0;
1093 DR.StructOffset = 0;
1094 DR.CVRegister = CVRegister;
1095 return DR;
1096 }
1097
collectVariableInfoFromMFTable(DenseSet<InlinedEntity> & Processed)1098 void CodeViewDebug::collectVariableInfoFromMFTable(
1099 DenseSet<InlinedEntity> &Processed) {
1100 const MachineFunction &MF = *Asm->MF;
1101 const TargetSubtargetInfo &TSI = MF.getSubtarget();
1102 const TargetFrameLowering *TFI = TSI.getFrameLowering();
1103 const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
1104
1105 for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) {
1106 if (!VI.Var)
1107 continue;
1108 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
1109 "Expected inlined-at fields to agree");
1110
1111 Processed.insert(InlinedEntity(VI.Var, VI.Loc->getInlinedAt()));
1112 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1113
1114 // If variable scope is not found then skip this variable.
1115 if (!Scope)
1116 continue;
1117
1118 // If the variable has an attached offset expression, extract it.
1119 // FIXME: Try to handle DW_OP_deref as well.
1120 int64_t ExprOffset = 0;
1121 if (VI.Expr)
1122 if (!VI.Expr->extractIfOffset(ExprOffset))
1123 continue;
1124
1125 // Get the frame register used and the offset.
1126 unsigned FrameReg = 0;
1127 int FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg);
1128 uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg);
1129
1130 // Calculate the label ranges.
1131 LocalVarDefRange DefRange =
1132 createDefRangeMem(CVReg, FrameOffset + ExprOffset);
1133 for (const InsnRange &Range : Scope->getRanges()) {
1134 const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
1135 const MCSymbol *End = getLabelAfterInsn(Range.second);
1136 End = End ? End : Asm->getFunctionEnd();
1137 DefRange.Ranges.emplace_back(Begin, End);
1138 }
1139
1140 LocalVariable Var;
1141 Var.DIVar = VI.Var;
1142 Var.DefRanges.emplace_back(std::move(DefRange));
1143 recordLocalVariable(std::move(Var), Scope);
1144 }
1145 }
1146
canUseReferenceType(const DbgVariableLocation & Loc)1147 static bool canUseReferenceType(const DbgVariableLocation &Loc) {
1148 return !Loc.LoadChain.empty() && Loc.LoadChain.back() == 0;
1149 }
1150
needsReferenceType(const DbgVariableLocation & Loc)1151 static bool needsReferenceType(const DbgVariableLocation &Loc) {
1152 return Loc.LoadChain.size() == 2 && Loc.LoadChain.back() == 0;
1153 }
1154
calculateRanges(LocalVariable & Var,const DbgValueHistoryMap::InstrRanges & Ranges)1155 void CodeViewDebug::calculateRanges(
1156 LocalVariable &Var, const DbgValueHistoryMap::InstrRanges &Ranges) {
1157 const TargetRegisterInfo *TRI = Asm->MF->getSubtarget().getRegisterInfo();
1158
1159 // Calculate the definition ranges.
1160 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1161 const InsnRange &Range = *I;
1162 const MachineInstr *DVInst = Range.first;
1163 assert(DVInst->isDebugValue() && "Invalid History entry");
1164 // FIXME: Find a way to represent constant variables, since they are
1165 // relatively common.
1166 Optional<DbgVariableLocation> Location =
1167 DbgVariableLocation::extractFromMachineInstruction(*DVInst);
1168 if (!Location)
1169 continue;
1170
1171 // CodeView can only express variables in register and variables in memory
1172 // at a constant offset from a register. However, for variables passed
1173 // indirectly by pointer, it is common for that pointer to be spilled to a
1174 // stack location. For the special case of one offseted load followed by a
1175 // zero offset load (a pointer spilled to the stack), we change the type of
1176 // the local variable from a value type to a reference type. This tricks the
1177 // debugger into doing the load for us.
1178 if (Var.UseReferenceType) {
1179 // We're using a reference type. Drop the last zero offset load.
1180 if (canUseReferenceType(*Location))
1181 Location->LoadChain.pop_back();
1182 else
1183 continue;
1184 } else if (needsReferenceType(*Location)) {
1185 // This location can't be expressed without switching to a reference type.
1186 // Start over using that.
1187 Var.UseReferenceType = true;
1188 Var.DefRanges.clear();
1189 calculateRanges(Var, Ranges);
1190 return;
1191 }
1192
1193 // We can only handle a register or an offseted load of a register.
1194 if (Location->Register == 0 || Location->LoadChain.size() > 1)
1195 continue;
1196 {
1197 LocalVarDefRange DR;
1198 DR.CVRegister = TRI->getCodeViewRegNum(Location->Register);
1199 DR.InMemory = !Location->LoadChain.empty();
1200 DR.DataOffset =
1201 !Location->LoadChain.empty() ? Location->LoadChain.back() : 0;
1202 if (Location->FragmentInfo) {
1203 DR.IsSubfield = true;
1204 DR.StructOffset = Location->FragmentInfo->OffsetInBits / 8;
1205 } else {
1206 DR.IsSubfield = false;
1207 DR.StructOffset = 0;
1208 }
1209
1210 if (Var.DefRanges.empty() ||
1211 Var.DefRanges.back().isDifferentLocation(DR)) {
1212 Var.DefRanges.emplace_back(std::move(DR));
1213 }
1214 }
1215
1216 // Compute the label range.
1217 const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
1218 const MCSymbol *End = getLabelAfterInsn(Range.second);
1219 if (!End) {
1220 // This range is valid until the next overlapping bitpiece. In the
1221 // common case, ranges will not be bitpieces, so they will overlap.
1222 auto J = std::next(I);
1223 const DIExpression *DIExpr = DVInst->getDebugExpression();
1224 while (J != E &&
1225 !DIExpr->fragmentsOverlap(J->first->getDebugExpression()))
1226 ++J;
1227 if (J != E)
1228 End = getLabelBeforeInsn(J->first);
1229 else
1230 End = Asm->getFunctionEnd();
1231 }
1232
1233 // If the last range end is our begin, just extend the last range.
1234 // Otherwise make a new range.
1235 SmallVectorImpl<std::pair<const MCSymbol *, const MCSymbol *>> &R =
1236 Var.DefRanges.back().Ranges;
1237 if (!R.empty() && R.back().second == Begin)
1238 R.back().second = End;
1239 else
1240 R.emplace_back(Begin, End);
1241
1242 // FIXME: Do more range combining.
1243 }
1244 }
1245
collectVariableInfo(const DISubprogram * SP)1246 void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
1247 DenseSet<InlinedEntity> Processed;
1248 // Grab the variable info that was squirreled away in the MMI side-table.
1249 collectVariableInfoFromMFTable(Processed);
1250
1251 for (const auto &I : DbgValues) {
1252 InlinedEntity IV = I.first;
1253 if (Processed.count(IV))
1254 continue;
1255 const DILocalVariable *DIVar = cast<DILocalVariable>(IV.first);
1256 const DILocation *InlinedAt = IV.second;
1257
1258 // Instruction ranges, specifying where IV is accessible.
1259 const auto &Ranges = I.second;
1260
1261 LexicalScope *Scope = nullptr;
1262 if (InlinedAt)
1263 Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);
1264 else
1265 Scope = LScopes.findLexicalScope(DIVar->getScope());
1266 // If variable scope is not found then skip this variable.
1267 if (!Scope)
1268 continue;
1269
1270 LocalVariable Var;
1271 Var.DIVar = DIVar;
1272
1273 calculateRanges(Var, Ranges);
1274 recordLocalVariable(std::move(Var), Scope);
1275 }
1276 }
1277
beginFunctionImpl(const MachineFunction * MF)1278 void CodeViewDebug::beginFunctionImpl(const MachineFunction *MF) {
1279 const TargetSubtargetInfo &TSI = MF->getSubtarget();
1280 const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
1281 const MachineFrameInfo &MFI = MF->getFrameInfo();
1282 const Function &GV = MF->getFunction();
1283 auto Insertion = FnDebugInfo.insert({&GV, llvm::make_unique<FunctionInfo>()});
1284 assert(Insertion.second && "function already has info");
1285 CurFn = Insertion.first->second.get();
1286 CurFn->FuncId = NextFuncId++;
1287 CurFn->Begin = Asm->getFunctionBegin();
1288
1289 // The S_FRAMEPROC record reports the stack size, and how many bytes of
1290 // callee-saved registers were used. For targets that don't use a PUSH
1291 // instruction (AArch64), this will be zero.
1292 CurFn->CSRSize = MFI.getCVBytesOfCalleeSavedRegisters();
1293 CurFn->FrameSize = MFI.getStackSize();
1294 CurFn->OffsetAdjustment = MFI.getOffsetAdjustment();
1295 CurFn->HasStackRealignment = TRI->needsStackRealignment(*MF);
1296
1297 // For this function S_FRAMEPROC record, figure out which codeview register
1298 // will be the frame pointer.
1299 CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::None; // None.
1300 CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::None; // None.
1301 if (CurFn->FrameSize > 0) {
1302 if (!TSI.getFrameLowering()->hasFP(*MF)) {
1303 CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr;
1304 CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::StackPtr;
1305 } else {
1306 // If there is an FP, parameters are always relative to it.
1307 CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::FramePtr;
1308 if (CurFn->HasStackRealignment) {
1309 // If the stack needs realignment, locals are relative to SP or VFRAME.
1310 CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr;
1311 } else {
1312 // Otherwise, locals are relative to EBP, and we probably have VLAs or
1313 // other stack adjustments.
1314 CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::FramePtr;
1315 }
1316 }
1317 }
1318
1319 // Compute other frame procedure options.
1320 FrameProcedureOptions FPO = FrameProcedureOptions::None;
1321 if (MFI.hasVarSizedObjects())
1322 FPO |= FrameProcedureOptions::HasAlloca;
1323 if (MF->exposesReturnsTwice())
1324 FPO |= FrameProcedureOptions::HasSetJmp;
1325 // FIXME: Set HasLongJmp if we ever track that info.
1326 if (MF->hasInlineAsm())
1327 FPO |= FrameProcedureOptions::HasInlineAssembly;
1328 if (GV.hasPersonalityFn()) {
1329 if (isAsynchronousEHPersonality(
1330 classifyEHPersonality(GV.getPersonalityFn())))
1331 FPO |= FrameProcedureOptions::HasStructuredExceptionHandling;
1332 else
1333 FPO |= FrameProcedureOptions::HasExceptionHandling;
1334 }
1335 if (GV.hasFnAttribute(Attribute::InlineHint))
1336 FPO |= FrameProcedureOptions::MarkedInline;
1337 if (GV.hasFnAttribute(Attribute::Naked))
1338 FPO |= FrameProcedureOptions::Naked;
1339 if (MFI.hasStackProtectorIndex())
1340 FPO |= FrameProcedureOptions::SecurityChecks;
1341 FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedLocalFramePtrReg) << 14U);
1342 FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedParamFramePtrReg) << 16U);
1343 if (Asm->TM.getOptLevel() != CodeGenOpt::None && !GV.optForSize() &&
1344 !GV.hasFnAttribute(Attribute::OptimizeNone))
1345 FPO |= FrameProcedureOptions::OptimizedForSpeed;
1346 // FIXME: Set GuardCfg when it is implemented.
1347 CurFn->FrameProcOpts = FPO;
1348
1349 OS.EmitCVFuncIdDirective(CurFn->FuncId);
1350
1351 // Find the end of the function prolog. First known non-DBG_VALUE and
1352 // non-frame setup location marks the beginning of the function body.
1353 // FIXME: is there a simpler a way to do this? Can we just search
1354 // for the first instruction of the function, not the last of the prolog?
1355 DebugLoc PrologEndLoc;
1356 bool EmptyPrologue = true;
1357 for (const auto &MBB : *MF) {
1358 for (const auto &MI : MBB) {
1359 if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
1360 MI.getDebugLoc()) {
1361 PrologEndLoc = MI.getDebugLoc();
1362 break;
1363 } else if (!MI.isMetaInstruction()) {
1364 EmptyPrologue = false;
1365 }
1366 }
1367 }
1368
1369 // Record beginning of function if we have a non-empty prologue.
1370 if (PrologEndLoc && !EmptyPrologue) {
1371 DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();
1372 maybeRecordLocation(FnStartDL, MF);
1373 }
1374 }
1375
shouldEmitUdt(const DIType * T)1376 static bool shouldEmitUdt(const DIType *T) {
1377 if (!T)
1378 return false;
1379
1380 // MSVC does not emit UDTs for typedefs that are scoped to classes.
1381 if (T->getTag() == dwarf::DW_TAG_typedef) {
1382 if (DIScope *Scope = T->getScope().resolve()) {
1383 switch (Scope->getTag()) {
1384 case dwarf::DW_TAG_structure_type:
1385 case dwarf::DW_TAG_class_type:
1386 case dwarf::DW_TAG_union_type:
1387 return false;
1388 }
1389 }
1390 }
1391
1392 while (true) {
1393 if (!T || T->isForwardDecl())
1394 return false;
1395
1396 const DIDerivedType *DT = dyn_cast<DIDerivedType>(T);
1397 if (!DT)
1398 return true;
1399 T = DT->getBaseType().resolve();
1400 }
1401 return true;
1402 }
1403
addToUDTs(const DIType * Ty)1404 void CodeViewDebug::addToUDTs(const DIType *Ty) {
1405 // Don't record empty UDTs.
1406 if (Ty->getName().empty())
1407 return;
1408 if (!shouldEmitUdt(Ty))
1409 return;
1410
1411 SmallVector<StringRef, 5> QualifiedNameComponents;
1412 const DISubprogram *ClosestSubprogram = getQualifiedNameComponents(
1413 Ty->getScope().resolve(), QualifiedNameComponents);
1414
1415 std::string FullyQualifiedName =
1416 getQualifiedName(QualifiedNameComponents, getPrettyScopeName(Ty));
1417
1418 if (ClosestSubprogram == nullptr) {
1419 GlobalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
1420 } else if (ClosestSubprogram == CurrentSubprogram) {
1421 LocalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
1422 }
1423
1424 // TODO: What if the ClosestSubprogram is neither null or the current
1425 // subprogram? Currently, the UDT just gets dropped on the floor.
1426 //
1427 // The current behavior is not desirable. To get maximal fidelity, we would
1428 // need to perform all type translation before beginning emission of .debug$S
1429 // and then make LocalUDTs a member of FunctionInfo
1430 }
1431
lowerType(const DIType * Ty,const DIType * ClassTy)1432 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1433 // Generic dispatch for lowering an unknown type.
1434 switch (Ty->getTag()) {
1435 case dwarf::DW_TAG_array_type:
1436 return lowerTypeArray(cast<DICompositeType>(Ty));
1437 case dwarf::DW_TAG_typedef:
1438 return lowerTypeAlias(cast<DIDerivedType>(Ty));
1439 case dwarf::DW_TAG_base_type:
1440 return lowerTypeBasic(cast<DIBasicType>(Ty));
1441 case dwarf::DW_TAG_pointer_type:
1442 if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type")
1443 return lowerTypeVFTableShape(cast<DIDerivedType>(Ty));
1444 LLVM_FALLTHROUGH;
1445 case dwarf::DW_TAG_reference_type:
1446 case dwarf::DW_TAG_rvalue_reference_type:
1447 return lowerTypePointer(cast<DIDerivedType>(Ty));
1448 case dwarf::DW_TAG_ptr_to_member_type:
1449 return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
1450 case dwarf::DW_TAG_restrict_type:
1451 case dwarf::DW_TAG_const_type:
1452 case dwarf::DW_TAG_volatile_type:
1453 // TODO: add support for DW_TAG_atomic_type here
1454 return lowerTypeModifier(cast<DIDerivedType>(Ty));
1455 case dwarf::DW_TAG_subroutine_type:
1456 if (ClassTy) {
1457 // The member function type of a member function pointer has no
1458 // ThisAdjustment.
1459 return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
1460 /*ThisAdjustment=*/0,
1461 /*IsStaticMethod=*/false);
1462 }
1463 return lowerTypeFunction(cast<DISubroutineType>(Ty));
1464 case dwarf::DW_TAG_enumeration_type:
1465 return lowerTypeEnum(cast<DICompositeType>(Ty));
1466 case dwarf::DW_TAG_class_type:
1467 case dwarf::DW_TAG_structure_type:
1468 return lowerTypeClass(cast<DICompositeType>(Ty));
1469 case dwarf::DW_TAG_union_type:
1470 return lowerTypeUnion(cast<DICompositeType>(Ty));
1471 case dwarf::DW_TAG_unspecified_type:
1472 if (Ty->getName() == "decltype(nullptr)")
1473 return TypeIndex::NullptrT();
1474 return TypeIndex::None();
1475 default:
1476 // Use the null type index.
1477 return TypeIndex();
1478 }
1479 }
1480
lowerTypeAlias(const DIDerivedType * Ty)1481 TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) {
1482 DITypeRef UnderlyingTypeRef = Ty->getBaseType();
1483 TypeIndex UnderlyingTypeIndex = getTypeIndex(UnderlyingTypeRef);
1484 StringRef TypeName = Ty->getName();
1485
1486 addToUDTs(Ty);
1487
1488 if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::Int32Long) &&
1489 TypeName == "HRESULT")
1490 return TypeIndex(SimpleTypeKind::HResult);
1491 if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::UInt16Short) &&
1492 TypeName == "wchar_t")
1493 return TypeIndex(SimpleTypeKind::WideCharacter);
1494
1495 return UnderlyingTypeIndex;
1496 }
1497
lowerTypeArray(const DICompositeType * Ty)1498 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
1499 DITypeRef ElementTypeRef = Ty->getBaseType();
1500 TypeIndex ElementTypeIndex = getTypeIndex(ElementTypeRef);
1501 // IndexType is size_t, which depends on the bitness of the target.
1502 TypeIndex IndexType = getPointerSizeInBytes() == 8
1503 ? TypeIndex(SimpleTypeKind::UInt64Quad)
1504 : TypeIndex(SimpleTypeKind::UInt32Long);
1505
1506 uint64_t ElementSize = getBaseTypeSize(ElementTypeRef) / 8;
1507
1508 // Add subranges to array type.
1509 DINodeArray Elements = Ty->getElements();
1510 for (int i = Elements.size() - 1; i >= 0; --i) {
1511 const DINode *Element = Elements[i];
1512 assert(Element->getTag() == dwarf::DW_TAG_subrange_type);
1513
1514 const DISubrange *Subrange = cast<DISubrange>(Element);
1515 assert(Subrange->getLowerBound() == 0 &&
1516 "codeview doesn't support subranges with lower bounds");
1517 int64_t Count = -1;
1518 if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt*>())
1519 Count = CI->getSExtValue();
1520
1521 // Forward declarations of arrays without a size and VLAs use a count of -1.
1522 // Emit a count of zero in these cases to match what MSVC does for arrays
1523 // without a size. MSVC doesn't support VLAs, so it's not clear what we
1524 // should do for them even if we could distinguish them.
1525 if (Count == -1)
1526 Count = 0;
1527
1528 // Update the element size and element type index for subsequent subranges.
1529 ElementSize *= Count;
1530
1531 // If this is the outermost array, use the size from the array. It will be
1532 // more accurate if we had a VLA or an incomplete element type size.
1533 uint64_t ArraySize =
1534 (i == 0 && ElementSize == 0) ? Ty->getSizeInBits() / 8 : ElementSize;
1535
1536 StringRef Name = (i == 0) ? Ty->getName() : "";
1537 ArrayRecord AR(ElementTypeIndex, IndexType, ArraySize, Name);
1538 ElementTypeIndex = TypeTable.writeLeafType(AR);
1539 }
1540
1541 return ElementTypeIndex;
1542 }
1543
lowerTypeBasic(const DIBasicType * Ty)1544 TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
1545 TypeIndex Index;
1546 dwarf::TypeKind Kind;
1547 uint32_t ByteSize;
1548
1549 Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding());
1550 ByteSize = Ty->getSizeInBits() / 8;
1551
1552 SimpleTypeKind STK = SimpleTypeKind::None;
1553 switch (Kind) {
1554 case dwarf::DW_ATE_address:
1555 // FIXME: Translate
1556 break;
1557 case dwarf::DW_ATE_boolean:
1558 switch (ByteSize) {
1559 case 1: STK = SimpleTypeKind::Boolean8; break;
1560 case 2: STK = SimpleTypeKind::Boolean16; break;
1561 case 4: STK = SimpleTypeKind::Boolean32; break;
1562 case 8: STK = SimpleTypeKind::Boolean64; break;
1563 case 16: STK = SimpleTypeKind::Boolean128; break;
1564 }
1565 break;
1566 case dwarf::DW_ATE_complex_float:
1567 switch (ByteSize) {
1568 case 2: STK = SimpleTypeKind::Complex16; break;
1569 case 4: STK = SimpleTypeKind::Complex32; break;
1570 case 8: STK = SimpleTypeKind::Complex64; break;
1571 case 10: STK = SimpleTypeKind::Complex80; break;
1572 case 16: STK = SimpleTypeKind::Complex128; break;
1573 }
1574 break;
1575 case dwarf::DW_ATE_float:
1576 switch (ByteSize) {
1577 case 2: STK = SimpleTypeKind::Float16; break;
1578 case 4: STK = SimpleTypeKind::Float32; break;
1579 case 6: STK = SimpleTypeKind::Float48; break;
1580 case 8: STK = SimpleTypeKind::Float64; break;
1581 case 10: STK = SimpleTypeKind::Float80; break;
1582 case 16: STK = SimpleTypeKind::Float128; break;
1583 }
1584 break;
1585 case dwarf::DW_ATE_signed:
1586 switch (ByteSize) {
1587 case 1: STK = SimpleTypeKind::SignedCharacter; break;
1588 case 2: STK = SimpleTypeKind::Int16Short; break;
1589 case 4: STK = SimpleTypeKind::Int32; break;
1590 case 8: STK = SimpleTypeKind::Int64Quad; break;
1591 case 16: STK = SimpleTypeKind::Int128Oct; break;
1592 }
1593 break;
1594 case dwarf::DW_ATE_unsigned:
1595 switch (ByteSize) {
1596 case 1: STK = SimpleTypeKind::UnsignedCharacter; break;
1597 case 2: STK = SimpleTypeKind::UInt16Short; break;
1598 case 4: STK = SimpleTypeKind::UInt32; break;
1599 case 8: STK = SimpleTypeKind::UInt64Quad; break;
1600 case 16: STK = SimpleTypeKind::UInt128Oct; break;
1601 }
1602 break;
1603 case dwarf::DW_ATE_UTF:
1604 switch (ByteSize) {
1605 case 2: STK = SimpleTypeKind::Character16; break;
1606 case 4: STK = SimpleTypeKind::Character32; break;
1607 }
1608 break;
1609 case dwarf::DW_ATE_signed_char:
1610 if (ByteSize == 1)
1611 STK = SimpleTypeKind::SignedCharacter;
1612 break;
1613 case dwarf::DW_ATE_unsigned_char:
1614 if (ByteSize == 1)
1615 STK = SimpleTypeKind::UnsignedCharacter;
1616 break;
1617 default:
1618 break;
1619 }
1620
1621 // Apply some fixups based on the source-level type name.
1622 if (STK == SimpleTypeKind::Int32 && Ty->getName() == "long int")
1623 STK = SimpleTypeKind::Int32Long;
1624 if (STK == SimpleTypeKind::UInt32 && Ty->getName() == "long unsigned int")
1625 STK = SimpleTypeKind::UInt32Long;
1626 if (STK == SimpleTypeKind::UInt16Short &&
1627 (Ty->getName() == "wchar_t" || Ty->getName() == "__wchar_t"))
1628 STK = SimpleTypeKind::WideCharacter;
1629 if ((STK == SimpleTypeKind::SignedCharacter ||
1630 STK == SimpleTypeKind::UnsignedCharacter) &&
1631 Ty->getName() == "char")
1632 STK = SimpleTypeKind::NarrowCharacter;
1633
1634 return TypeIndex(STK);
1635 }
1636
lowerTypePointer(const DIDerivedType * Ty,PointerOptions PO)1637 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
1638 PointerOptions PO) {
1639 TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
1640
1641 // Pointers to simple types without any options can use SimpleTypeMode, rather
1642 // than having a dedicated pointer type record.
1643 if (PointeeTI.isSimple() && PO == PointerOptions::None &&
1644 PointeeTI.getSimpleMode() == SimpleTypeMode::Direct &&
1645 Ty->getTag() == dwarf::DW_TAG_pointer_type) {
1646 SimpleTypeMode Mode = Ty->getSizeInBits() == 64
1647 ? SimpleTypeMode::NearPointer64
1648 : SimpleTypeMode::NearPointer32;
1649 return TypeIndex(PointeeTI.getSimpleKind(), Mode);
1650 }
1651
1652 PointerKind PK =
1653 Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32;
1654 PointerMode PM = PointerMode::Pointer;
1655 switch (Ty->getTag()) {
1656 default: llvm_unreachable("not a pointer tag type");
1657 case dwarf::DW_TAG_pointer_type:
1658 PM = PointerMode::Pointer;
1659 break;
1660 case dwarf::DW_TAG_reference_type:
1661 PM = PointerMode::LValueReference;
1662 break;
1663 case dwarf::DW_TAG_rvalue_reference_type:
1664 PM = PointerMode::RValueReference;
1665 break;
1666 }
1667
1668 if (Ty->isObjectPointer())
1669 PO |= PointerOptions::Const;
1670
1671 PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
1672 return TypeTable.writeLeafType(PR);
1673 }
1674
1675 static PointerToMemberRepresentation
translatePtrToMemberRep(unsigned SizeInBytes,bool IsPMF,unsigned Flags)1676 translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) {
1677 // SizeInBytes being zero generally implies that the member pointer type was
1678 // incomplete, which can happen if it is part of a function prototype. In this
1679 // case, use the unknown model instead of the general model.
1680 if (IsPMF) {
1681 switch (Flags & DINode::FlagPtrToMemberRep) {
1682 case 0:
1683 return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1684 : PointerToMemberRepresentation::GeneralFunction;
1685 case DINode::FlagSingleInheritance:
1686 return PointerToMemberRepresentation::SingleInheritanceFunction;
1687 case DINode::FlagMultipleInheritance:
1688 return PointerToMemberRepresentation::MultipleInheritanceFunction;
1689 case DINode::FlagVirtualInheritance:
1690 return PointerToMemberRepresentation::VirtualInheritanceFunction;
1691 }
1692 } else {
1693 switch (Flags & DINode::FlagPtrToMemberRep) {
1694 case 0:
1695 return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1696 : PointerToMemberRepresentation::GeneralData;
1697 case DINode::FlagSingleInheritance:
1698 return PointerToMemberRepresentation::SingleInheritanceData;
1699 case DINode::FlagMultipleInheritance:
1700 return PointerToMemberRepresentation::MultipleInheritanceData;
1701 case DINode::FlagVirtualInheritance:
1702 return PointerToMemberRepresentation::VirtualInheritanceData;
1703 }
1704 }
1705 llvm_unreachable("invalid ptr to member representation");
1706 }
1707
lowerTypeMemberPointer(const DIDerivedType * Ty,PointerOptions PO)1708 TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty,
1709 PointerOptions PO) {
1710 assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
1711 TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
1712 TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
1713 PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
1714 : PointerKind::Near32;
1715 bool IsPMF = isa<DISubroutineType>(Ty->getBaseType());
1716 PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction
1717 : PointerMode::PointerToDataMember;
1718
1719 assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big");
1720 uint8_t SizeInBytes = Ty->getSizeInBits() / 8;
1721 MemberPointerInfo MPI(
1722 ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags()));
1723 PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI);
1724 return TypeTable.writeLeafType(PR);
1725 }
1726
1727 /// Given a DWARF calling convention, get the CodeView equivalent. If we don't
1728 /// have a translation, use the NearC convention.
dwarfCCToCodeView(unsigned DwarfCC)1729 static CallingConvention dwarfCCToCodeView(unsigned DwarfCC) {
1730 switch (DwarfCC) {
1731 case dwarf::DW_CC_normal: return CallingConvention::NearC;
1732 case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast;
1733 case dwarf::DW_CC_BORLAND_thiscall: return CallingConvention::ThisCall;
1734 case dwarf::DW_CC_BORLAND_stdcall: return CallingConvention::NearStdCall;
1735 case dwarf::DW_CC_BORLAND_pascal: return CallingConvention::NearPascal;
1736 case dwarf::DW_CC_LLVM_vectorcall: return CallingConvention::NearVector;
1737 }
1738 return CallingConvention::NearC;
1739 }
1740
lowerTypeModifier(const DIDerivedType * Ty)1741 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
1742 ModifierOptions Mods = ModifierOptions::None;
1743 PointerOptions PO = PointerOptions::None;
1744 bool IsModifier = true;
1745 const DIType *BaseTy = Ty;
1746 while (IsModifier && BaseTy) {
1747 // FIXME: Need to add DWARF tags for __unaligned and _Atomic
1748 switch (BaseTy->getTag()) {
1749 case dwarf::DW_TAG_const_type:
1750 Mods |= ModifierOptions::Const;
1751 PO |= PointerOptions::Const;
1752 break;
1753 case dwarf::DW_TAG_volatile_type:
1754 Mods |= ModifierOptions::Volatile;
1755 PO |= PointerOptions::Volatile;
1756 break;
1757 case dwarf::DW_TAG_restrict_type:
1758 // Only pointer types be marked with __restrict. There is no known flag
1759 // for __restrict in LF_MODIFIER records.
1760 PO |= PointerOptions::Restrict;
1761 break;
1762 default:
1763 IsModifier = false;
1764 break;
1765 }
1766 if (IsModifier)
1767 BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
1768 }
1769
1770 // Check if the inner type will use an LF_POINTER record. If so, the
1771 // qualifiers will go in the LF_POINTER record. This comes up for types like
1772 // 'int *const' and 'int *__restrict', not the more common cases like 'const
1773 // char *'.
1774 if (BaseTy) {
1775 switch (BaseTy->getTag()) {
1776 case dwarf::DW_TAG_pointer_type:
1777 case dwarf::DW_TAG_reference_type:
1778 case dwarf::DW_TAG_rvalue_reference_type:
1779 return lowerTypePointer(cast<DIDerivedType>(BaseTy), PO);
1780 case dwarf::DW_TAG_ptr_to_member_type:
1781 return lowerTypeMemberPointer(cast<DIDerivedType>(BaseTy), PO);
1782 default:
1783 break;
1784 }
1785 }
1786
1787 TypeIndex ModifiedTI = getTypeIndex(BaseTy);
1788
1789 // Return the base type index if there aren't any modifiers. For example, the
1790 // metadata could contain restrict wrappers around non-pointer types.
1791 if (Mods == ModifierOptions::None)
1792 return ModifiedTI;
1793
1794 ModifierRecord MR(ModifiedTI, Mods);
1795 return TypeTable.writeLeafType(MR);
1796 }
1797
lowerTypeFunction(const DISubroutineType * Ty)1798 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
1799 SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1800 for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1801 ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1802
1803 // MSVC uses type none for variadic argument.
1804 if (ReturnAndArgTypeIndices.size() > 1 &&
1805 ReturnAndArgTypeIndices.back() == TypeIndex::Void()) {
1806 ReturnAndArgTypeIndices.back() = TypeIndex::None();
1807 }
1808 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1809 ArrayRef<TypeIndex> ArgTypeIndices = None;
1810 if (!ReturnAndArgTypeIndices.empty()) {
1811 auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1812 ReturnTypeIndex = ReturnAndArgTypesRef.front();
1813 ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1814 }
1815
1816 ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1817 TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1818
1819 CallingConvention CC = dwarfCCToCodeView(Ty->getCC());
1820
1821 FunctionOptions FO = getFunctionOptions(Ty);
1822 ProcedureRecord Procedure(ReturnTypeIndex, CC, FO, ArgTypeIndices.size(),
1823 ArgListIndex);
1824 return TypeTable.writeLeafType(Procedure);
1825 }
1826
lowerTypeMemberFunction(const DISubroutineType * Ty,const DIType * ClassTy,int ThisAdjustment,bool IsStaticMethod,FunctionOptions FO)1827 TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
1828 const DIType *ClassTy,
1829 int ThisAdjustment,
1830 bool IsStaticMethod,
1831 FunctionOptions FO) {
1832 // Lower the containing class type.
1833 TypeIndex ClassType = getTypeIndex(ClassTy);
1834
1835 DITypeRefArray ReturnAndArgs = Ty->getTypeArray();
1836
1837 unsigned Index = 0;
1838 SmallVector<TypeIndex, 8> ArgTypeIndices;
1839 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1840 if (ReturnAndArgs.size() > Index) {
1841 ReturnTypeIndex = getTypeIndex(ReturnAndArgs[Index++]);
1842 }
1843
1844 // If the first argument is a pointer type and this isn't a static method,
1845 // treat it as the special 'this' parameter, which is encoded separately from
1846 // the arguments.
1847 TypeIndex ThisTypeIndex;
1848 if (!IsStaticMethod && ReturnAndArgs.size() > Index) {
1849 if (const DIDerivedType *PtrTy =
1850 dyn_cast_or_null<DIDerivedType>(ReturnAndArgs[Index].resolve())) {
1851 if (PtrTy->getTag() == dwarf::DW_TAG_pointer_type) {
1852 ThisTypeIndex = getTypeIndexForThisPtr(PtrTy, Ty);
1853 Index++;
1854 }
1855 }
1856 }
1857
1858 while (Index < ReturnAndArgs.size())
1859 ArgTypeIndices.push_back(getTypeIndex(ReturnAndArgs[Index++]));
1860
1861 // MSVC uses type none for variadic argument.
1862 if (!ArgTypeIndices.empty() && ArgTypeIndices.back() == TypeIndex::Void())
1863 ArgTypeIndices.back() = TypeIndex::None();
1864
1865 ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1866 TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1867
1868 CallingConvention CC = dwarfCCToCodeView(Ty->getCC());
1869
1870 MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC, FO,
1871 ArgTypeIndices.size(), ArgListIndex, ThisAdjustment);
1872 return TypeTable.writeLeafType(MFR);
1873 }
1874
lowerTypeVFTableShape(const DIDerivedType * Ty)1875 TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) {
1876 unsigned VSlotCount =
1877 Ty->getSizeInBits() / (8 * Asm->MAI->getCodePointerSize());
1878 SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near);
1879
1880 VFTableShapeRecord VFTSR(Slots);
1881 return TypeTable.writeLeafType(VFTSR);
1882 }
1883
translateAccessFlags(unsigned RecordTag,unsigned Flags)1884 static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) {
1885 switch (Flags & DINode::FlagAccessibility) {
1886 case DINode::FlagPrivate: return MemberAccess::Private;
1887 case DINode::FlagPublic: return MemberAccess::Public;
1888 case DINode::FlagProtected: return MemberAccess::Protected;
1889 case 0:
1890 // If there was no explicit access control, provide the default for the tag.
1891 return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private
1892 : MemberAccess::Public;
1893 }
1894 llvm_unreachable("access flags are exclusive");
1895 }
1896
translateMethodOptionFlags(const DISubprogram * SP)1897 static MethodOptions translateMethodOptionFlags(const DISubprogram *SP) {
1898 if (SP->isArtificial())
1899 return MethodOptions::CompilerGenerated;
1900
1901 // FIXME: Handle other MethodOptions.
1902
1903 return MethodOptions::None;
1904 }
1905
translateMethodKindFlags(const DISubprogram * SP,bool Introduced)1906 static MethodKind translateMethodKindFlags(const DISubprogram *SP,
1907 bool Introduced) {
1908 if (SP->getFlags() & DINode::FlagStaticMember)
1909 return MethodKind::Static;
1910
1911 switch (SP->getVirtuality()) {
1912 case dwarf::DW_VIRTUALITY_none:
1913 break;
1914 case dwarf::DW_VIRTUALITY_virtual:
1915 return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual;
1916 case dwarf::DW_VIRTUALITY_pure_virtual:
1917 return Introduced ? MethodKind::PureIntroducingVirtual
1918 : MethodKind::PureVirtual;
1919 default:
1920 llvm_unreachable("unhandled virtuality case");
1921 }
1922
1923 return MethodKind::Vanilla;
1924 }
1925
getRecordKind(const DICompositeType * Ty)1926 static TypeRecordKind getRecordKind(const DICompositeType *Ty) {
1927 switch (Ty->getTag()) {
1928 case dwarf::DW_TAG_class_type: return TypeRecordKind::Class;
1929 case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct;
1930 }
1931 llvm_unreachable("unexpected tag");
1932 }
1933
1934 /// Return ClassOptions that should be present on both the forward declaration
1935 /// and the defintion of a tag type.
getCommonClassOptions(const DICompositeType * Ty)1936 static ClassOptions getCommonClassOptions(const DICompositeType *Ty) {
1937 ClassOptions CO = ClassOptions::None;
1938
1939 // MSVC always sets this flag, even for local types. Clang doesn't always
1940 // appear to give every type a linkage name, which may be problematic for us.
1941 // FIXME: Investigate the consequences of not following them here.
1942 if (!Ty->getIdentifier().empty())
1943 CO |= ClassOptions::HasUniqueName;
1944
1945 // Put the Nested flag on a type if it appears immediately inside a tag type.
1946 // Do not walk the scope chain. Do not attempt to compute ContainsNestedClass
1947 // here. That flag is only set on definitions, and not forward declarations.
1948 const DIScope *ImmediateScope = Ty->getScope().resolve();
1949 if (ImmediateScope && isa<DICompositeType>(ImmediateScope))
1950 CO |= ClassOptions::Nested;
1951
1952 // Put the Scoped flag on function-local types. MSVC puts this flag for enum
1953 // type only when it has an immediate function scope. Clang never puts enums
1954 // inside DILexicalBlock scopes. Enum types, as generated by clang, are
1955 // always in function, class, or file scopes.
1956 if (Ty->getTag() == dwarf::DW_TAG_enumeration_type) {
1957 if (ImmediateScope && isa<DISubprogram>(ImmediateScope))
1958 CO |= ClassOptions::Scoped;
1959 } else {
1960 for (const DIScope *Scope = ImmediateScope; Scope != nullptr;
1961 Scope = Scope->getScope().resolve()) {
1962 if (isa<DISubprogram>(Scope)) {
1963 CO |= ClassOptions::Scoped;
1964 break;
1965 }
1966 }
1967 }
1968
1969 return CO;
1970 }
1971
addUDTSrcLine(const DIType * Ty,TypeIndex TI)1972 void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) {
1973 switch (Ty->getTag()) {
1974 case dwarf::DW_TAG_class_type:
1975 case dwarf::DW_TAG_structure_type:
1976 case dwarf::DW_TAG_union_type:
1977 case dwarf::DW_TAG_enumeration_type:
1978 break;
1979 default:
1980 return;
1981 }
1982
1983 if (const auto *File = Ty->getFile()) {
1984 StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File));
1985 TypeIndex SIDI = TypeTable.writeLeafType(SIDR);
1986
1987 UdtSourceLineRecord USLR(TI, SIDI, Ty->getLine());
1988 TypeTable.writeLeafType(USLR);
1989 }
1990 }
1991
lowerTypeEnum(const DICompositeType * Ty)1992 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
1993 ClassOptions CO = getCommonClassOptions(Ty);
1994 TypeIndex FTI;
1995 unsigned EnumeratorCount = 0;
1996
1997 if (Ty->isForwardDecl()) {
1998 CO |= ClassOptions::ForwardReference;
1999 } else {
2000 ContinuationRecordBuilder ContinuationBuilder;
2001 ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
2002 for (const DINode *Element : Ty->getElements()) {
2003 // We assume that the frontend provides all members in source declaration
2004 // order, which is what MSVC does.
2005 if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) {
2006 EnumeratorRecord ER(MemberAccess::Public,
2007 APSInt::getUnsigned(Enumerator->getValue()),
2008 Enumerator->getName());
2009 ContinuationBuilder.writeMemberType(ER);
2010 EnumeratorCount++;
2011 }
2012 }
2013 FTI = TypeTable.insertRecord(ContinuationBuilder);
2014 }
2015
2016 std::string FullName = getFullyQualifiedName(Ty);
2017
2018 EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(),
2019 getTypeIndex(Ty->getBaseType()));
2020 TypeIndex EnumTI = TypeTable.writeLeafType(ER);
2021
2022 addUDTSrcLine(Ty, EnumTI);
2023
2024 return EnumTI;
2025 }
2026
2027 //===----------------------------------------------------------------------===//
2028 // ClassInfo
2029 //===----------------------------------------------------------------------===//
2030
2031 struct llvm::ClassInfo {
2032 struct MemberInfo {
2033 const DIDerivedType *MemberTypeNode;
2034 uint64_t BaseOffset;
2035 };
2036 // [MemberInfo]
2037 using MemberList = std::vector<MemberInfo>;
2038
2039 using MethodsList = TinyPtrVector<const DISubprogram *>;
2040 // MethodName -> MethodsList
2041 using MethodsMap = MapVector<MDString *, MethodsList>;
2042
2043 /// Base classes.
2044 std::vector<const DIDerivedType *> Inheritance;
2045
2046 /// Direct members.
2047 MemberList Members;
2048 // Direct overloaded methods gathered by name.
2049 MethodsMap Methods;
2050
2051 TypeIndex VShapeTI;
2052
2053 std::vector<const DIType *> NestedTypes;
2054 };
2055
clear()2056 void CodeViewDebug::clear() {
2057 assert(CurFn == nullptr);
2058 FileIdMap.clear();
2059 FnDebugInfo.clear();
2060 FileToFilepathMap.clear();
2061 LocalUDTs.clear();
2062 GlobalUDTs.clear();
2063 TypeIndices.clear();
2064 CompleteTypeIndices.clear();
2065 ScopeGlobals.clear();
2066 }
2067
collectMemberInfo(ClassInfo & Info,const DIDerivedType * DDTy)2068 void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
2069 const DIDerivedType *DDTy) {
2070 if (!DDTy->getName().empty()) {
2071 Info.Members.push_back({DDTy, 0});
2072 return;
2073 }
2074
2075 // An unnamed member may represent a nested struct or union. Attempt to
2076 // interpret the unnamed member as a DICompositeType possibly wrapped in
2077 // qualifier types. Add all the indirect fields to the current record if that
2078 // succeeds, and drop the member if that fails.
2079 assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
2080 uint64_t Offset = DDTy->getOffsetInBits();
2081 const DIType *Ty = DDTy->getBaseType().resolve();
2082 bool FullyResolved = false;
2083 while (!FullyResolved) {
2084 switch (Ty->getTag()) {
2085 case dwarf::DW_TAG_const_type:
2086 case dwarf::DW_TAG_volatile_type:
2087 // FIXME: we should apply the qualifier types to the indirect fields
2088 // rather than dropping them.
2089 Ty = cast<DIDerivedType>(Ty)->getBaseType().resolve();
2090 break;
2091 default:
2092 FullyResolved = true;
2093 break;
2094 }
2095 }
2096
2097 const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty);
2098 if (!DCTy)
2099 return;
2100
2101 ClassInfo NestedInfo = collectClassInfo(DCTy);
2102 for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members)
2103 Info.Members.push_back(
2104 {IndirectField.MemberTypeNode, IndirectField.BaseOffset + Offset});
2105 }
2106
collectClassInfo(const DICompositeType * Ty)2107 ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) {
2108 ClassInfo Info;
2109 // Add elements to structure type.
2110 DINodeArray Elements = Ty->getElements();
2111 for (auto *Element : Elements) {
2112 // We assume that the frontend provides all members in source declaration
2113 // order, which is what MSVC does.
2114 if (!Element)
2115 continue;
2116 if (auto *SP = dyn_cast<DISubprogram>(Element)) {
2117 Info.Methods[SP->getRawName()].push_back(SP);
2118 } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
2119 if (DDTy->getTag() == dwarf::DW_TAG_member) {
2120 collectMemberInfo(Info, DDTy);
2121 } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) {
2122 Info.Inheritance.push_back(DDTy);
2123 } else if (DDTy->getTag() == dwarf::DW_TAG_pointer_type &&
2124 DDTy->getName() == "__vtbl_ptr_type") {
2125 Info.VShapeTI = getTypeIndex(DDTy);
2126 } else if (DDTy->getTag() == dwarf::DW_TAG_typedef) {
2127 Info.NestedTypes.push_back(DDTy);
2128 } else if (DDTy->getTag() == dwarf::DW_TAG_friend) {
2129 // Ignore friend members. It appears that MSVC emitted info about
2130 // friends in the past, but modern versions do not.
2131 }
2132 } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
2133 Info.NestedTypes.push_back(Composite);
2134 }
2135 // Skip other unrecognized kinds of elements.
2136 }
2137 return Info;
2138 }
2139
shouldAlwaysEmitCompleteClassType(const DICompositeType * Ty)2140 static bool shouldAlwaysEmitCompleteClassType(const DICompositeType *Ty) {
2141 // This routine is used by lowerTypeClass and lowerTypeUnion to determine
2142 // if a complete type should be emitted instead of a forward reference.
2143 return Ty->getName().empty() && Ty->getIdentifier().empty() &&
2144 !Ty->isForwardDecl();
2145 }
2146
lowerTypeClass(const DICompositeType * Ty)2147 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
2148 // Emit the complete type for unnamed structs. C++ classes with methods
2149 // which have a circular reference back to the class type are expected to
2150 // be named by the front-end and should not be "unnamed". C unnamed
2151 // structs should not have circular references.
2152 if (shouldAlwaysEmitCompleteClassType(Ty)) {
2153 // If this unnamed complete type is already in the process of being defined
2154 // then the description of the type is malformed and cannot be emitted
2155 // into CodeView correctly so report a fatal error.
2156 auto I = CompleteTypeIndices.find(Ty);
2157 if (I != CompleteTypeIndices.end() && I->second == TypeIndex())
2158 report_fatal_error("cannot debug circular reference to unnamed type");
2159 return getCompleteTypeIndex(Ty);
2160 }
2161
2162 // First, construct the forward decl. Don't look into Ty to compute the
2163 // forward decl options, since it might not be available in all TUs.
2164 TypeRecordKind Kind = getRecordKind(Ty);
2165 ClassOptions CO =
2166 ClassOptions::ForwardReference | getCommonClassOptions(Ty);
2167 std::string FullName = getFullyQualifiedName(Ty);
2168 ClassRecord CR(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0,
2169 FullName, Ty->getIdentifier());
2170 TypeIndex FwdDeclTI = TypeTable.writeLeafType(CR);
2171 if (!Ty->isForwardDecl())
2172 DeferredCompleteTypes.push_back(Ty);
2173 return FwdDeclTI;
2174 }
2175
lowerCompleteTypeClass(const DICompositeType * Ty)2176 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
2177 // Construct the field list and complete type record.
2178 TypeRecordKind Kind = getRecordKind(Ty);
2179 ClassOptions CO = getCommonClassOptions(Ty);
2180 TypeIndex FieldTI;
2181 TypeIndex VShapeTI;
2182 unsigned FieldCount;
2183 bool ContainsNestedClass;
2184 std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) =
2185 lowerRecordFieldList(Ty);
2186
2187 if (ContainsNestedClass)
2188 CO |= ClassOptions::ContainsNestedClass;
2189
2190 std::string FullName = getFullyQualifiedName(Ty);
2191
2192 uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
2193
2194 ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI,
2195 SizeInBytes, FullName, Ty->getIdentifier());
2196 TypeIndex ClassTI = TypeTable.writeLeafType(CR);
2197
2198 addUDTSrcLine(Ty, ClassTI);
2199
2200 addToUDTs(Ty);
2201
2202 return ClassTI;
2203 }
2204
lowerTypeUnion(const DICompositeType * Ty)2205 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
2206 // Emit the complete type for unnamed unions.
2207 if (shouldAlwaysEmitCompleteClassType(Ty))
2208 return getCompleteTypeIndex(Ty);
2209
2210 ClassOptions CO =
2211 ClassOptions::ForwardReference | getCommonClassOptions(Ty);
2212 std::string FullName = getFullyQualifiedName(Ty);
2213 UnionRecord UR(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier());
2214 TypeIndex FwdDeclTI = TypeTable.writeLeafType(UR);
2215 if (!Ty->isForwardDecl())
2216 DeferredCompleteTypes.push_back(Ty);
2217 return FwdDeclTI;
2218 }
2219
lowerCompleteTypeUnion(const DICompositeType * Ty)2220 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
2221 ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty);
2222 TypeIndex FieldTI;
2223 unsigned FieldCount;
2224 bool ContainsNestedClass;
2225 std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) =
2226 lowerRecordFieldList(Ty);
2227
2228 if (ContainsNestedClass)
2229 CO |= ClassOptions::ContainsNestedClass;
2230
2231 uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
2232 std::string FullName = getFullyQualifiedName(Ty);
2233
2234 UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName,
2235 Ty->getIdentifier());
2236 TypeIndex UnionTI = TypeTable.writeLeafType(UR);
2237
2238 addUDTSrcLine(Ty, UnionTI);
2239
2240 addToUDTs(Ty);
2241
2242 return UnionTI;
2243 }
2244
2245 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
lowerRecordFieldList(const DICompositeType * Ty)2246 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
2247 // Manually count members. MSVC appears to count everything that generates a
2248 // field list record. Each individual overload in a method overload group
2249 // contributes to this count, even though the overload group is a single field
2250 // list record.
2251 unsigned MemberCount = 0;
2252 ClassInfo Info = collectClassInfo(Ty);
2253 ContinuationRecordBuilder ContinuationBuilder;
2254 ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
2255
2256 // Create base classes.
2257 for (const DIDerivedType *I : Info.Inheritance) {
2258 if (I->getFlags() & DINode::FlagVirtual) {
2259 // Virtual base.
2260 unsigned VBPtrOffset = I->getVBPtrOffset();
2261 // FIXME: Despite the accessor name, the offset is really in bytes.
2262 unsigned VBTableIndex = I->getOffsetInBits() / 4;
2263 auto RecordKind = (I->getFlags() & DINode::FlagIndirectVirtualBase) == DINode::FlagIndirectVirtualBase
2264 ? TypeRecordKind::IndirectVirtualBaseClass
2265 : TypeRecordKind::VirtualBaseClass;
2266 VirtualBaseClassRecord VBCR(
2267 RecordKind, translateAccessFlags(Ty->getTag(), I->getFlags()),
2268 getTypeIndex(I->getBaseType()), getVBPTypeIndex(), VBPtrOffset,
2269 VBTableIndex);
2270
2271 ContinuationBuilder.writeMemberType(VBCR);
2272 MemberCount++;
2273 } else {
2274 assert(I->getOffsetInBits() % 8 == 0 &&
2275 "bases must be on byte boundaries");
2276 BaseClassRecord BCR(translateAccessFlags(Ty->getTag(), I->getFlags()),
2277 getTypeIndex(I->getBaseType()),
2278 I->getOffsetInBits() / 8);
2279 ContinuationBuilder.writeMemberType(BCR);
2280 MemberCount++;
2281 }
2282 }
2283
2284 // Create members.
2285 for (ClassInfo::MemberInfo &MemberInfo : Info.Members) {
2286 const DIDerivedType *Member = MemberInfo.MemberTypeNode;
2287 TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType());
2288 StringRef MemberName = Member->getName();
2289 MemberAccess Access =
2290 translateAccessFlags(Ty->getTag(), Member->getFlags());
2291
2292 if (Member->isStaticMember()) {
2293 StaticDataMemberRecord SDMR(Access, MemberBaseType, MemberName);
2294 ContinuationBuilder.writeMemberType(SDMR);
2295 MemberCount++;
2296 continue;
2297 }
2298
2299 // Virtual function pointer member.
2300 if ((Member->getFlags() & DINode::FlagArtificial) &&
2301 Member->getName().startswith("_vptr$")) {
2302 VFPtrRecord VFPR(getTypeIndex(Member->getBaseType()));
2303 ContinuationBuilder.writeMemberType(VFPR);
2304 MemberCount++;
2305 continue;
2306 }
2307
2308 // Data member.
2309 uint64_t MemberOffsetInBits =
2310 Member->getOffsetInBits() + MemberInfo.BaseOffset;
2311 if (Member->isBitField()) {
2312 uint64_t StartBitOffset = MemberOffsetInBits;
2313 if (const auto *CI =
2314 dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) {
2315 MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset;
2316 }
2317 StartBitOffset -= MemberOffsetInBits;
2318 BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(),
2319 StartBitOffset);
2320 MemberBaseType = TypeTable.writeLeafType(BFR);
2321 }
2322 uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8;
2323 DataMemberRecord DMR(Access, MemberBaseType, MemberOffsetInBytes,
2324 MemberName);
2325 ContinuationBuilder.writeMemberType(DMR);
2326 MemberCount++;
2327 }
2328
2329 // Create methods
2330 for (auto &MethodItr : Info.Methods) {
2331 StringRef Name = MethodItr.first->getString();
2332
2333 std::vector<OneMethodRecord> Methods;
2334 for (const DISubprogram *SP : MethodItr.second) {
2335 TypeIndex MethodType = getMemberFunctionType(SP, Ty);
2336 bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual;
2337
2338 unsigned VFTableOffset = -1;
2339 if (Introduced)
2340 VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes();
2341
2342 Methods.push_back(OneMethodRecord(
2343 MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()),
2344 translateMethodKindFlags(SP, Introduced),
2345 translateMethodOptionFlags(SP), VFTableOffset, Name));
2346 MemberCount++;
2347 }
2348 assert(!Methods.empty() && "Empty methods map entry");
2349 if (Methods.size() == 1)
2350 ContinuationBuilder.writeMemberType(Methods[0]);
2351 else {
2352 // FIXME: Make this use its own ContinuationBuilder so that
2353 // MethodOverloadList can be split correctly.
2354 MethodOverloadListRecord MOLR(Methods);
2355 TypeIndex MethodList = TypeTable.writeLeafType(MOLR);
2356
2357 OverloadedMethodRecord OMR(Methods.size(), MethodList, Name);
2358 ContinuationBuilder.writeMemberType(OMR);
2359 }
2360 }
2361
2362 // Create nested classes.
2363 for (const DIType *Nested : Info.NestedTypes) {
2364 NestedTypeRecord R(getTypeIndex(DITypeRef(Nested)), Nested->getName());
2365 ContinuationBuilder.writeMemberType(R);
2366 MemberCount++;
2367 }
2368
2369 TypeIndex FieldTI = TypeTable.insertRecord(ContinuationBuilder);
2370 return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount,
2371 !Info.NestedTypes.empty());
2372 }
2373
getVBPTypeIndex()2374 TypeIndex CodeViewDebug::getVBPTypeIndex() {
2375 if (!VBPType.getIndex()) {
2376 // Make a 'const int *' type.
2377 ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
2378 TypeIndex ModifiedTI = TypeTable.writeLeafType(MR);
2379
2380 PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
2381 : PointerKind::Near32;
2382 PointerMode PM = PointerMode::Pointer;
2383 PointerOptions PO = PointerOptions::None;
2384 PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
2385 VBPType = TypeTable.writeLeafType(PR);
2386 }
2387
2388 return VBPType;
2389 }
2390
getTypeIndex(DITypeRef TypeRef,DITypeRef ClassTyRef)2391 TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
2392 const DIType *Ty = TypeRef.resolve();
2393 const DIType *ClassTy = ClassTyRef.resolve();
2394
2395 // The null DIType is the void type. Don't try to hash it.
2396 if (!Ty)
2397 return TypeIndex::Void();
2398
2399 // Check if we've already translated this type. Don't try to do a
2400 // get-or-create style insertion that caches the hash lookup across the
2401 // lowerType call. It will update the TypeIndices map.
2402 auto I = TypeIndices.find({Ty, ClassTy});
2403 if (I != TypeIndices.end())
2404 return I->second;
2405
2406 TypeLoweringScope S(*this);
2407 TypeIndex TI = lowerType(Ty, ClassTy);
2408 return recordTypeIndexForDINode(Ty, TI, ClassTy);
2409 }
2410
2411 codeview::TypeIndex
getTypeIndexForThisPtr(const DIDerivedType * PtrTy,const DISubroutineType * SubroutineTy)2412 CodeViewDebug::getTypeIndexForThisPtr(const DIDerivedType *PtrTy,
2413 const DISubroutineType *SubroutineTy) {
2414 assert(PtrTy->getTag() == dwarf::DW_TAG_pointer_type &&
2415 "this type must be a pointer type");
2416
2417 PointerOptions Options = PointerOptions::None;
2418 if (SubroutineTy->getFlags() & DINode::DIFlags::FlagLValueReference)
2419 Options = PointerOptions::LValueRefThisPointer;
2420 else if (SubroutineTy->getFlags() & DINode::DIFlags::FlagRValueReference)
2421 Options = PointerOptions::RValueRefThisPointer;
2422
2423 // Check if we've already translated this type. If there is no ref qualifier
2424 // on the function then we look up this pointer type with no associated class
2425 // so that the TypeIndex for the this pointer can be shared with the type
2426 // index for other pointers to this class type. If there is a ref qualifier
2427 // then we lookup the pointer using the subroutine as the parent type.
2428 auto I = TypeIndices.find({PtrTy, SubroutineTy});
2429 if (I != TypeIndices.end())
2430 return I->second;
2431
2432 TypeLoweringScope S(*this);
2433 TypeIndex TI = lowerTypePointer(PtrTy, Options);
2434 return recordTypeIndexForDINode(PtrTy, TI, SubroutineTy);
2435 }
2436
getTypeIndexForReferenceTo(DITypeRef TypeRef)2437 TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(DITypeRef TypeRef) {
2438 DIType *Ty = TypeRef.resolve();
2439 PointerRecord PR(getTypeIndex(Ty),
2440 getPointerSizeInBytes() == 8 ? PointerKind::Near64
2441 : PointerKind::Near32,
2442 PointerMode::LValueReference, PointerOptions::None,
2443 Ty->getSizeInBits() / 8);
2444 return TypeTable.writeLeafType(PR);
2445 }
2446
getCompleteTypeIndex(DITypeRef TypeRef)2447 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
2448 const DIType *Ty = TypeRef.resolve();
2449
2450 // The null DIType is the void type. Don't try to hash it.
2451 if (!Ty)
2452 return TypeIndex::Void();
2453
2454 // Look through typedefs when getting the complete type index. Call
2455 // getTypeIndex on the typdef to ensure that any UDTs are accumulated and are
2456 // emitted only once.
2457 if (Ty->getTag() == dwarf::DW_TAG_typedef)
2458 (void)getTypeIndex(Ty);
2459 while (Ty->getTag() == dwarf::DW_TAG_typedef)
2460 Ty = cast<DIDerivedType>(Ty)->getBaseType().resolve();
2461
2462 // If this is a non-record type, the complete type index is the same as the
2463 // normal type index. Just call getTypeIndex.
2464 switch (Ty->getTag()) {
2465 case dwarf::DW_TAG_class_type:
2466 case dwarf::DW_TAG_structure_type:
2467 case dwarf::DW_TAG_union_type:
2468 break;
2469 default:
2470 return getTypeIndex(Ty);
2471 }
2472
2473 // Check if we've already translated the complete record type.
2474 const auto *CTy = cast<DICompositeType>(Ty);
2475 auto InsertResult = CompleteTypeIndices.insert({CTy, TypeIndex()});
2476 if (!InsertResult.second)
2477 return InsertResult.first->second;
2478
2479 TypeLoweringScope S(*this);
2480
2481 // Make sure the forward declaration is emitted first. It's unclear if this
2482 // is necessary, but MSVC does it, and we should follow suit until we can show
2483 // otherwise.
2484 // We only emit a forward declaration for named types.
2485 if (!CTy->getName().empty() || !CTy->getIdentifier().empty()) {
2486 TypeIndex FwdDeclTI = getTypeIndex(CTy);
2487
2488 // Just use the forward decl if we don't have complete type info. This
2489 // might happen if the frontend is using modules and expects the complete
2490 // definition to be emitted elsewhere.
2491 if (CTy->isForwardDecl())
2492 return FwdDeclTI;
2493 }
2494
2495 TypeIndex TI;
2496 switch (CTy->getTag()) {
2497 case dwarf::DW_TAG_class_type:
2498 case dwarf::DW_TAG_structure_type:
2499 TI = lowerCompleteTypeClass(CTy);
2500 break;
2501 case dwarf::DW_TAG_union_type:
2502 TI = lowerCompleteTypeUnion(CTy);
2503 break;
2504 default:
2505 llvm_unreachable("not a record");
2506 }
2507
2508 // Update the type index associated with this CompositeType. This cannot
2509 // use the 'InsertResult' iterator above because it is potentially
2510 // invalidated by map insertions which can occur while lowering the class
2511 // type above.
2512 CompleteTypeIndices[CTy] = TI;
2513 return TI;
2514 }
2515
2516 /// Emit all the deferred complete record types. Try to do this in FIFO order,
2517 /// and do this until fixpoint, as each complete record type typically
2518 /// references
2519 /// many other record types.
emitDeferredCompleteTypes()2520 void CodeViewDebug::emitDeferredCompleteTypes() {
2521 SmallVector<const DICompositeType *, 4> TypesToEmit;
2522 while (!DeferredCompleteTypes.empty()) {
2523 std::swap(DeferredCompleteTypes, TypesToEmit);
2524 for (const DICompositeType *RecordTy : TypesToEmit)
2525 getCompleteTypeIndex(RecordTy);
2526 TypesToEmit.clear();
2527 }
2528 }
2529
emitLocalVariableList(const FunctionInfo & FI,ArrayRef<LocalVariable> Locals)2530 void CodeViewDebug::emitLocalVariableList(const FunctionInfo &FI,
2531 ArrayRef<LocalVariable> Locals) {
2532 // Get the sorted list of parameters and emit them first.
2533 SmallVector<const LocalVariable *, 6> Params;
2534 for (const LocalVariable &L : Locals)
2535 if (L.DIVar->isParameter())
2536 Params.push_back(&L);
2537 llvm::sort(Params, [](const LocalVariable *L, const LocalVariable *R) {
2538 return L->DIVar->getArg() < R->DIVar->getArg();
2539 });
2540 for (const LocalVariable *L : Params)
2541 emitLocalVariable(FI, *L);
2542
2543 // Next emit all non-parameters in the order that we found them.
2544 for (const LocalVariable &L : Locals)
2545 if (!L.DIVar->isParameter())
2546 emitLocalVariable(FI, L);
2547 }
2548
2549 /// Only call this on endian-specific types like ulittle16_t and little32_t, or
2550 /// structs composed of them.
2551 template <typename T>
copyBytesForDefRange(SmallString<20> & BytePrefix,SymbolKind SymKind,const T & DefRangeHeader)2552 static void copyBytesForDefRange(SmallString<20> &BytePrefix,
2553 SymbolKind SymKind, const T &DefRangeHeader) {
2554 BytePrefix.resize(2 + sizeof(T));
2555 ulittle16_t SymKindLE = ulittle16_t(SymKind);
2556 memcpy(&BytePrefix[0], &SymKindLE, 2);
2557 memcpy(&BytePrefix[2], &DefRangeHeader, sizeof(T));
2558 }
2559
emitLocalVariable(const FunctionInfo & FI,const LocalVariable & Var)2560 void CodeViewDebug::emitLocalVariable(const FunctionInfo &FI,
2561 const LocalVariable &Var) {
2562 // LocalSym record, see SymbolRecord.h for more info.
2563 MCSymbol *LocalEnd = beginSymbolRecord(SymbolKind::S_LOCAL);
2564
2565 LocalSymFlags Flags = LocalSymFlags::None;
2566 if (Var.DIVar->isParameter())
2567 Flags |= LocalSymFlags::IsParameter;
2568 if (Var.DefRanges.empty())
2569 Flags |= LocalSymFlags::IsOptimizedOut;
2570
2571 OS.AddComment("TypeIndex");
2572 TypeIndex TI = Var.UseReferenceType
2573 ? getTypeIndexForReferenceTo(Var.DIVar->getType())
2574 : getCompleteTypeIndex(Var.DIVar->getType());
2575 OS.EmitIntValue(TI.getIndex(), 4);
2576 OS.AddComment("Flags");
2577 OS.EmitIntValue(static_cast<uint16_t>(Flags), 2);
2578 // Truncate the name so we won't overflow the record length field.
2579 emitNullTerminatedSymbolName(OS, Var.DIVar->getName());
2580 endSymbolRecord(LocalEnd);
2581
2582 // Calculate the on disk prefix of the appropriate def range record. The
2583 // records and on disk formats are described in SymbolRecords.h. BytePrefix
2584 // should be big enough to hold all forms without memory allocation.
2585 SmallString<20> BytePrefix;
2586 for (const LocalVarDefRange &DefRange : Var.DefRanges) {
2587 BytePrefix.clear();
2588 if (DefRange.InMemory) {
2589 int Offset = DefRange.DataOffset;
2590 unsigned Reg = DefRange.CVRegister;
2591
2592 // 32-bit x86 call sequences often use PUSH instructions, which disrupt
2593 // ESP-relative offsets. Use the virtual frame pointer, VFRAME or $T0,
2594 // instead. In frames without stack realignment, $T0 will be the CFA.
2595 if (RegisterId(Reg) == RegisterId::ESP) {
2596 Reg = unsigned(RegisterId::VFRAME);
2597 Offset += FI.OffsetAdjustment;
2598 }
2599
2600 // If we can use the chosen frame pointer for the frame and this isn't a
2601 // sliced aggregate, use the smaller S_DEFRANGE_FRAMEPOINTER_REL record.
2602 // Otherwise, use S_DEFRANGE_REGISTER_REL.
2603 EncodedFramePtrReg EncFP = encodeFramePtrReg(RegisterId(Reg), TheCPU);
2604 if (!DefRange.IsSubfield && EncFP != EncodedFramePtrReg::None &&
2605 (bool(Flags & LocalSymFlags::IsParameter)
2606 ? (EncFP == FI.EncodedParamFramePtrReg)
2607 : (EncFP == FI.EncodedLocalFramePtrReg))) {
2608 little32_t FPOffset = little32_t(Offset);
2609 copyBytesForDefRange(BytePrefix, S_DEFRANGE_FRAMEPOINTER_REL, FPOffset);
2610 } else {
2611 uint16_t RegRelFlags = 0;
2612 if (DefRange.IsSubfield) {
2613 RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag |
2614 (DefRange.StructOffset
2615 << DefRangeRegisterRelSym::OffsetInParentShift);
2616 }
2617 DefRangeRegisterRelSym::Header DRHdr;
2618 DRHdr.Register = Reg;
2619 DRHdr.Flags = RegRelFlags;
2620 DRHdr.BasePointerOffset = Offset;
2621 copyBytesForDefRange(BytePrefix, S_DEFRANGE_REGISTER_REL, DRHdr);
2622 }
2623 } else {
2624 assert(DefRange.DataOffset == 0 && "unexpected offset into register");
2625 if (DefRange.IsSubfield) {
2626 DefRangeSubfieldRegisterSym::Header DRHdr;
2627 DRHdr.Register = DefRange.CVRegister;
2628 DRHdr.MayHaveNoName = 0;
2629 DRHdr.OffsetInParent = DefRange.StructOffset;
2630 copyBytesForDefRange(BytePrefix, S_DEFRANGE_SUBFIELD_REGISTER, DRHdr);
2631 } else {
2632 DefRangeRegisterSym::Header DRHdr;
2633 DRHdr.Register = DefRange.CVRegister;
2634 DRHdr.MayHaveNoName = 0;
2635 copyBytesForDefRange(BytePrefix, S_DEFRANGE_REGISTER, DRHdr);
2636 }
2637 }
2638 OS.EmitCVDefRangeDirective(DefRange.Ranges, BytePrefix);
2639 }
2640 }
2641
emitLexicalBlockList(ArrayRef<LexicalBlock * > Blocks,const FunctionInfo & FI)2642 void CodeViewDebug::emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
2643 const FunctionInfo& FI) {
2644 for (LexicalBlock *Block : Blocks)
2645 emitLexicalBlock(*Block, FI);
2646 }
2647
2648 /// Emit an S_BLOCK32 and S_END record pair delimiting the contents of a
2649 /// lexical block scope.
emitLexicalBlock(const LexicalBlock & Block,const FunctionInfo & FI)2650 void CodeViewDebug::emitLexicalBlock(const LexicalBlock &Block,
2651 const FunctionInfo& FI) {
2652 MCSymbol *RecordEnd = beginSymbolRecord(SymbolKind::S_BLOCK32);
2653 OS.AddComment("PtrParent");
2654 OS.EmitIntValue(0, 4); // PtrParent
2655 OS.AddComment("PtrEnd");
2656 OS.EmitIntValue(0, 4); // PtrEnd
2657 OS.AddComment("Code size");
2658 OS.emitAbsoluteSymbolDiff(Block.End, Block.Begin, 4); // Code Size
2659 OS.AddComment("Function section relative address");
2660 OS.EmitCOFFSecRel32(Block.Begin, /*Offset=*/0); // Func Offset
2661 OS.AddComment("Function section index");
2662 OS.EmitCOFFSectionIndex(FI.Begin); // Func Symbol
2663 OS.AddComment("Lexical block name");
2664 emitNullTerminatedSymbolName(OS, Block.Name); // Name
2665 endSymbolRecord(RecordEnd);
2666
2667 // Emit variables local to this lexical block.
2668 emitLocalVariableList(FI, Block.Locals);
2669 emitGlobalVariableList(Block.Globals);
2670
2671 // Emit lexical blocks contained within this block.
2672 emitLexicalBlockList(Block.Children, FI);
2673
2674 // Close the lexical block scope.
2675 emitEndSymbolRecord(SymbolKind::S_END);
2676 }
2677
2678 /// Convenience routine for collecting lexical block information for a list
2679 /// of lexical scopes.
collectLexicalBlockInfo(SmallVectorImpl<LexicalScope * > & Scopes,SmallVectorImpl<LexicalBlock * > & Blocks,SmallVectorImpl<LocalVariable> & Locals,SmallVectorImpl<CVGlobalVariable> & Globals)2680 void CodeViewDebug::collectLexicalBlockInfo(
2681 SmallVectorImpl<LexicalScope *> &Scopes,
2682 SmallVectorImpl<LexicalBlock *> &Blocks,
2683 SmallVectorImpl<LocalVariable> &Locals,
2684 SmallVectorImpl<CVGlobalVariable> &Globals) {
2685 for (LexicalScope *Scope : Scopes)
2686 collectLexicalBlockInfo(*Scope, Blocks, Locals, Globals);
2687 }
2688
2689 /// Populate the lexical blocks and local variable lists of the parent with
2690 /// information about the specified lexical scope.
collectLexicalBlockInfo(LexicalScope & Scope,SmallVectorImpl<LexicalBlock * > & ParentBlocks,SmallVectorImpl<LocalVariable> & ParentLocals,SmallVectorImpl<CVGlobalVariable> & ParentGlobals)2691 void CodeViewDebug::collectLexicalBlockInfo(
2692 LexicalScope &Scope,
2693 SmallVectorImpl<LexicalBlock *> &ParentBlocks,
2694 SmallVectorImpl<LocalVariable> &ParentLocals,
2695 SmallVectorImpl<CVGlobalVariable> &ParentGlobals) {
2696 if (Scope.isAbstractScope())
2697 return;
2698
2699 // Gather information about the lexical scope including local variables,
2700 // global variables, and address ranges.
2701 bool IgnoreScope = false;
2702 auto LI = ScopeVariables.find(&Scope);
2703 SmallVectorImpl<LocalVariable> *Locals =
2704 LI != ScopeVariables.end() ? &LI->second : nullptr;
2705 auto GI = ScopeGlobals.find(Scope.getScopeNode());
2706 SmallVectorImpl<CVGlobalVariable> *Globals =
2707 GI != ScopeGlobals.end() ? GI->second.get() : nullptr;
2708 const DILexicalBlock *DILB = dyn_cast<DILexicalBlock>(Scope.getScopeNode());
2709 const SmallVectorImpl<InsnRange> &Ranges = Scope.getRanges();
2710
2711 // Ignore lexical scopes which do not contain variables.
2712 if (!Locals && !Globals)
2713 IgnoreScope = true;
2714
2715 // Ignore lexical scopes which are not lexical blocks.
2716 if (!DILB)
2717 IgnoreScope = true;
2718
2719 // Ignore scopes which have too many address ranges to represent in the
2720 // current CodeView format or do not have a valid address range.
2721 //
2722 // For lexical scopes with multiple address ranges you may be tempted to
2723 // construct a single range covering every instruction where the block is
2724 // live and everything in between. Unfortunately, Visual Studio only
2725 // displays variables from the first matching lexical block scope. If the
2726 // first lexical block contains exception handling code or cold code which
2727 // is moved to the bottom of the routine creating a single range covering
2728 // nearly the entire routine, then it will hide all other lexical blocks
2729 // and the variables they contain.
2730 if (Ranges.size() != 1 || !getLabelAfterInsn(Ranges.front().second))
2731 IgnoreScope = true;
2732
2733 if (IgnoreScope) {
2734 // This scope can be safely ignored and eliminating it will reduce the
2735 // size of the debug information. Be sure to collect any variable and scope
2736 // information from the this scope or any of its children and collapse them
2737 // into the parent scope.
2738 if (Locals)
2739 ParentLocals.append(Locals->begin(), Locals->end());
2740 if (Globals)
2741 ParentGlobals.append(Globals->begin(), Globals->end());
2742 collectLexicalBlockInfo(Scope.getChildren(),
2743 ParentBlocks,
2744 ParentLocals,
2745 ParentGlobals);
2746 return;
2747 }
2748
2749 // Create a new CodeView lexical block for this lexical scope. If we've
2750 // seen this DILexicalBlock before then the scope tree is malformed and
2751 // we can handle this gracefully by not processing it a second time.
2752 auto BlockInsertion = CurFn->LexicalBlocks.insert({DILB, LexicalBlock()});
2753 if (!BlockInsertion.second)
2754 return;
2755
2756 // Create a lexical block containing the variables and collect the the
2757 // lexical block information for the children.
2758 const InsnRange &Range = Ranges.front();
2759 assert(Range.first && Range.second);
2760 LexicalBlock &Block = BlockInsertion.first->second;
2761 Block.Begin = getLabelBeforeInsn(Range.first);
2762 Block.End = getLabelAfterInsn(Range.second);
2763 assert(Block.Begin && "missing label for scope begin");
2764 assert(Block.End && "missing label for scope end");
2765 Block.Name = DILB->getName();
2766 if (Locals)
2767 Block.Locals = std::move(*Locals);
2768 if (Globals)
2769 Block.Globals = std::move(*Globals);
2770 ParentBlocks.push_back(&Block);
2771 collectLexicalBlockInfo(Scope.getChildren(),
2772 Block.Children,
2773 Block.Locals,
2774 Block.Globals);
2775 }
2776
endFunctionImpl(const MachineFunction * MF)2777 void CodeViewDebug::endFunctionImpl(const MachineFunction *MF) {
2778 const Function &GV = MF->getFunction();
2779 assert(FnDebugInfo.count(&GV));
2780 assert(CurFn == FnDebugInfo[&GV].get());
2781
2782 collectVariableInfo(GV.getSubprogram());
2783
2784 // Build the lexical block structure to emit for this routine.
2785 if (LexicalScope *CFS = LScopes.getCurrentFunctionScope())
2786 collectLexicalBlockInfo(*CFS,
2787 CurFn->ChildBlocks,
2788 CurFn->Locals,
2789 CurFn->Globals);
2790
2791 // Clear the scope and variable information from the map which will not be
2792 // valid after we have finished processing this routine. This also prepares
2793 // the map for the subsequent routine.
2794 ScopeVariables.clear();
2795
2796 // Don't emit anything if we don't have any line tables.
2797 // Thunks are compiler-generated and probably won't have source correlation.
2798 if (!CurFn->HaveLineInfo && !GV.getSubprogram()->isThunk()) {
2799 FnDebugInfo.erase(&GV);
2800 CurFn = nullptr;
2801 return;
2802 }
2803
2804 CurFn->Annotations = MF->getCodeViewAnnotations();
2805
2806 CurFn->End = Asm->getFunctionEnd();
2807
2808 CurFn = nullptr;
2809 }
2810
beginInstruction(const MachineInstr * MI)2811 void CodeViewDebug::beginInstruction(const MachineInstr *MI) {
2812 DebugHandlerBase::beginInstruction(MI);
2813
2814 // Ignore DBG_VALUE and DBG_LABEL locations and function prologue.
2815 if (!Asm || !CurFn || MI->isDebugInstr() ||
2816 MI->getFlag(MachineInstr::FrameSetup))
2817 return;
2818
2819 // If the first instruction of a new MBB has no location, find the first
2820 // instruction with a location and use that.
2821 DebugLoc DL = MI->getDebugLoc();
2822 if (!DL && MI->getParent() != PrevInstBB) {
2823 for (const auto &NextMI : *MI->getParent()) {
2824 if (NextMI.isDebugInstr())
2825 continue;
2826 DL = NextMI.getDebugLoc();
2827 if (DL)
2828 break;
2829 }
2830 }
2831 PrevInstBB = MI->getParent();
2832
2833 // If we still don't have a debug location, don't record a location.
2834 if (!DL)
2835 return;
2836
2837 maybeRecordLocation(DL, Asm->MF);
2838 }
2839
beginCVSubsection(DebugSubsectionKind Kind)2840 MCSymbol *CodeViewDebug::beginCVSubsection(DebugSubsectionKind Kind) {
2841 MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
2842 *EndLabel = MMI->getContext().createTempSymbol();
2843 OS.EmitIntValue(unsigned(Kind), 4);
2844 OS.AddComment("Subsection size");
2845 OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4);
2846 OS.EmitLabel(BeginLabel);
2847 return EndLabel;
2848 }
2849
endCVSubsection(MCSymbol * EndLabel)2850 void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) {
2851 OS.EmitLabel(EndLabel);
2852 // Every subsection must be aligned to a 4-byte boundary.
2853 OS.EmitValueToAlignment(4);
2854 }
2855
getSymbolName(SymbolKind SymKind)2856 static StringRef getSymbolName(SymbolKind SymKind) {
2857 for (const EnumEntry<SymbolKind> &EE : getSymbolTypeNames())
2858 if (EE.Value == SymKind)
2859 return EE.Name;
2860 return "";
2861 }
2862
beginSymbolRecord(SymbolKind SymKind)2863 MCSymbol *CodeViewDebug::beginSymbolRecord(SymbolKind SymKind) {
2864 MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
2865 *EndLabel = MMI->getContext().createTempSymbol();
2866 OS.AddComment("Record length");
2867 OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 2);
2868 OS.EmitLabel(BeginLabel);
2869 if (OS.isVerboseAsm())
2870 OS.AddComment("Record kind: " + getSymbolName(SymKind));
2871 OS.EmitIntValue(unsigned(SymKind), 2);
2872 return EndLabel;
2873 }
2874
endSymbolRecord(MCSymbol * SymEnd)2875 void CodeViewDebug::endSymbolRecord(MCSymbol *SymEnd) {
2876 // MSVC does not pad out symbol records to four bytes, but LLVM does to avoid
2877 // an extra copy of every symbol record in LLD. This increases object file
2878 // size by less than 1% in the clang build, and is compatible with the Visual
2879 // C++ linker.
2880 OS.EmitValueToAlignment(4);
2881 OS.EmitLabel(SymEnd);
2882 }
2883
emitEndSymbolRecord(SymbolKind EndKind)2884 void CodeViewDebug::emitEndSymbolRecord(SymbolKind EndKind) {
2885 OS.AddComment("Record length");
2886 OS.EmitIntValue(2, 2);
2887 if (OS.isVerboseAsm())
2888 OS.AddComment("Record kind: " + getSymbolName(EndKind));
2889 OS.EmitIntValue(unsigned(EndKind), 2); // Record Kind
2890 }
2891
emitDebugInfoForUDTs(ArrayRef<std::pair<std::string,const DIType * >> UDTs)2892 void CodeViewDebug::emitDebugInfoForUDTs(
2893 ArrayRef<std::pair<std::string, const DIType *>> UDTs) {
2894 for (const auto &UDT : UDTs) {
2895 const DIType *T = UDT.second;
2896 assert(shouldEmitUdt(T));
2897
2898 MCSymbol *UDTRecordEnd = beginSymbolRecord(SymbolKind::S_UDT);
2899 OS.AddComment("Type");
2900 OS.EmitIntValue(getCompleteTypeIndex(T).getIndex(), 4);
2901 emitNullTerminatedSymbolName(OS, UDT.first);
2902 endSymbolRecord(UDTRecordEnd);
2903 }
2904 }
2905
collectGlobalVariableInfo()2906 void CodeViewDebug::collectGlobalVariableInfo() {
2907 DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *>
2908 GlobalMap;
2909 for (const GlobalVariable &GV : MMI->getModule()->globals()) {
2910 SmallVector<DIGlobalVariableExpression *, 1> GVEs;
2911 GV.getDebugInfo(GVEs);
2912 for (const auto *GVE : GVEs)
2913 GlobalMap[GVE] = &GV;
2914 }
2915
2916 NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2917 for (const MDNode *Node : CUs->operands()) {
2918 const auto *CU = cast<DICompileUnit>(Node);
2919 for (const auto *GVE : CU->getGlobalVariables()) {
2920 const auto *GV = GlobalMap.lookup(GVE);
2921 if (!GV || GV->isDeclarationForLinker())
2922 continue;
2923 const DIGlobalVariable *DIGV = GVE->getVariable();
2924 DIScope *Scope = DIGV->getScope();
2925 SmallVector<CVGlobalVariable, 1> *VariableList;
2926 if (Scope && isa<DILocalScope>(Scope)) {
2927 // Locate a global variable list for this scope, creating one if
2928 // necessary.
2929 auto Insertion = ScopeGlobals.insert(
2930 {Scope, std::unique_ptr<GlobalVariableList>()});
2931 if (Insertion.second)
2932 Insertion.first->second = llvm::make_unique<GlobalVariableList>();
2933 VariableList = Insertion.first->second.get();
2934 } else if (GV->hasComdat())
2935 // Emit this global variable into a COMDAT section.
2936 VariableList = &ComdatVariables;
2937 else
2938 // Emit this globla variable in a single global symbol section.
2939 VariableList = &GlobalVariables;
2940 CVGlobalVariable CVGV = {DIGV, GV};
2941 VariableList->emplace_back(std::move(CVGV));
2942 }
2943 }
2944 }
2945
emitDebugInfoForGlobals()2946 void CodeViewDebug::emitDebugInfoForGlobals() {
2947 // First, emit all globals that are not in a comdat in a single symbol
2948 // substream. MSVC doesn't like it if the substream is empty, so only open
2949 // it if we have at least one global to emit.
2950 switchToDebugSectionForSymbol(nullptr);
2951 if (!GlobalVariables.empty()) {
2952 OS.AddComment("Symbol subsection for globals");
2953 MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2954 emitGlobalVariableList(GlobalVariables);
2955 endCVSubsection(EndLabel);
2956 }
2957
2958 // Second, emit each global that is in a comdat into its own .debug$S
2959 // section along with its own symbol substream.
2960 for (const CVGlobalVariable &CVGV : ComdatVariables) {
2961 MCSymbol *GVSym = Asm->getSymbol(CVGV.GV);
2962 OS.AddComment("Symbol subsection for " +
2963 Twine(GlobalValue::dropLLVMManglingEscape(CVGV.GV->getName())));
2964 switchToDebugSectionForSymbol(GVSym);
2965 MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2966 // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2967 emitDebugInfoForGlobal(CVGV.DIGV, CVGV.GV, GVSym);
2968 endCVSubsection(EndLabel);
2969 }
2970 }
2971
emitDebugInfoForRetainedTypes()2972 void CodeViewDebug::emitDebugInfoForRetainedTypes() {
2973 NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2974 for (const MDNode *Node : CUs->operands()) {
2975 for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) {
2976 if (DIType *RT = dyn_cast<DIType>(Ty)) {
2977 getTypeIndex(RT);
2978 // FIXME: Add to global/local DTU list.
2979 }
2980 }
2981 }
2982 }
2983
2984 // Emit each global variable in the specified array.
emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals)2985 void CodeViewDebug::emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals) {
2986 for (const CVGlobalVariable &CVGV : Globals) {
2987 MCSymbol *GVSym = Asm->getSymbol(CVGV.GV);
2988 // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2989 emitDebugInfoForGlobal(CVGV.DIGV, CVGV.GV, GVSym);
2990 }
2991 }
2992
emitDebugInfoForGlobal(const DIGlobalVariable * DIGV,const GlobalVariable * GV,MCSymbol * GVSym)2993 void CodeViewDebug::emitDebugInfoForGlobal(const DIGlobalVariable *DIGV,
2994 const GlobalVariable *GV,
2995 MCSymbol *GVSym) {
2996 // DataSym record, see SymbolRecord.h for more info. Thread local data
2997 // happens to have the same format as global data.
2998 SymbolKind DataSym = GV->isThreadLocal()
2999 ? (DIGV->isLocalToUnit() ? SymbolKind::S_LTHREAD32
3000 : SymbolKind::S_GTHREAD32)
3001 : (DIGV->isLocalToUnit() ? SymbolKind::S_LDATA32
3002 : SymbolKind::S_GDATA32);
3003 MCSymbol *DataEnd = beginSymbolRecord(DataSym);
3004 OS.AddComment("Type");
3005 OS.EmitIntValue(getCompleteTypeIndex(DIGV->getType()).getIndex(), 4);
3006 OS.AddComment("DataOffset");
3007 OS.EmitCOFFSecRel32(GVSym, /*Offset=*/0);
3008 OS.AddComment("Segment");
3009 OS.EmitCOFFSectionIndex(GVSym);
3010 OS.AddComment("Name");
3011 const unsigned LengthOfDataRecord = 12;
3012 emitNullTerminatedSymbolName(OS, DIGV->getName(), LengthOfDataRecord);
3013 endSymbolRecord(DataEnd);
3014 }
3015