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