10b57cec5SDimitry Andric //===- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp ----------------------===// 20b57cec5SDimitry Andric // 30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric // 70b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 80b57cec5SDimitry Andric // 90b57cec5SDimitry Andric // This file contains support for writing Microsoft CodeView debug info. 100b57cec5SDimitry Andric // 110b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 120b57cec5SDimitry Andric 130b57cec5SDimitry Andric #include "CodeViewDebug.h" 140b57cec5SDimitry Andric #include "DwarfExpression.h" 150b57cec5SDimitry Andric #include "llvm/ADT/APSInt.h" 160b57cec5SDimitry Andric #include "llvm/ADT/None.h" 170b57cec5SDimitry Andric #include "llvm/ADT/Optional.h" 180b57cec5SDimitry Andric #include "llvm/ADT/STLExtras.h" 190b57cec5SDimitry Andric #include "llvm/ADT/SmallString.h" 200b57cec5SDimitry Andric #include "llvm/ADT/StringRef.h" 210b57cec5SDimitry Andric #include "llvm/ADT/TinyPtrVector.h" 220b57cec5SDimitry Andric #include "llvm/ADT/Triple.h" 230b57cec5SDimitry Andric #include "llvm/ADT/Twine.h" 240b57cec5SDimitry Andric #include "llvm/BinaryFormat/COFF.h" 250b57cec5SDimitry Andric #include "llvm/BinaryFormat/Dwarf.h" 260b57cec5SDimitry Andric #include "llvm/CodeGen/AsmPrinter.h" 270b57cec5SDimitry Andric #include "llvm/CodeGen/LexicalScopes.h" 280b57cec5SDimitry Andric #include "llvm/CodeGen/MachineFrameInfo.h" 290b57cec5SDimitry Andric #include "llvm/CodeGen/MachineFunction.h" 300b57cec5SDimitry Andric #include "llvm/CodeGen/MachineInstr.h" 310b57cec5SDimitry Andric #include "llvm/CodeGen/MachineModuleInfo.h" 320b57cec5SDimitry Andric #include "llvm/CodeGen/MachineOperand.h" 330b57cec5SDimitry Andric #include "llvm/CodeGen/TargetFrameLowering.h" 340b57cec5SDimitry Andric #include "llvm/CodeGen/TargetRegisterInfo.h" 350b57cec5SDimitry Andric #include "llvm/CodeGen/TargetSubtargetInfo.h" 360b57cec5SDimitry Andric #include "llvm/Config/llvm-config.h" 370b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h" 380b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h" 390b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h" 400b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h" 410b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/EnumTables.h" 420b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/Line.h" 430b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/SymbolRecord.h" 440b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h" 450b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeRecord.h" 460b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeTableCollection.h" 470b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h" 480b57cec5SDimitry Andric #include "llvm/IR/Constants.h" 490b57cec5SDimitry Andric #include "llvm/IR/DataLayout.h" 500b57cec5SDimitry Andric #include "llvm/IR/DebugInfoMetadata.h" 510b57cec5SDimitry Andric #include "llvm/IR/Function.h" 520b57cec5SDimitry Andric #include "llvm/IR/GlobalValue.h" 530b57cec5SDimitry Andric #include "llvm/IR/GlobalVariable.h" 540b57cec5SDimitry Andric #include "llvm/IR/Metadata.h" 550b57cec5SDimitry Andric #include "llvm/IR/Module.h" 560b57cec5SDimitry Andric #include "llvm/MC/MCAsmInfo.h" 570b57cec5SDimitry Andric #include "llvm/MC/MCContext.h" 580b57cec5SDimitry Andric #include "llvm/MC/MCSectionCOFF.h" 590b57cec5SDimitry Andric #include "llvm/MC/MCStreamer.h" 600b57cec5SDimitry Andric #include "llvm/MC/MCSymbol.h" 610b57cec5SDimitry Andric #include "llvm/Support/BinaryByteStream.h" 620b57cec5SDimitry Andric #include "llvm/Support/BinaryStreamReader.h" 630b57cec5SDimitry Andric #include "llvm/Support/BinaryStreamWriter.h" 640b57cec5SDimitry Andric #include "llvm/Support/Casting.h" 650b57cec5SDimitry Andric #include "llvm/Support/CommandLine.h" 660b57cec5SDimitry Andric #include "llvm/Support/Endian.h" 670b57cec5SDimitry Andric #include "llvm/Support/Error.h" 680b57cec5SDimitry Andric #include "llvm/Support/ErrorHandling.h" 690b57cec5SDimitry Andric #include "llvm/Support/FormatVariadic.h" 700b57cec5SDimitry Andric #include "llvm/Support/Path.h" 7104eeddc0SDimitry Andric #include "llvm/Support/Program.h" 720b57cec5SDimitry Andric #include "llvm/Support/SMLoc.h" 730b57cec5SDimitry Andric #include "llvm/Support/ScopedPrinter.h" 740b57cec5SDimitry Andric #include "llvm/Target/TargetLoweringObjectFile.h" 750b57cec5SDimitry Andric #include "llvm/Target/TargetMachine.h" 760b57cec5SDimitry Andric #include <algorithm> 770b57cec5SDimitry Andric #include <cassert> 780b57cec5SDimitry Andric #include <cctype> 790b57cec5SDimitry Andric #include <cstddef> 800b57cec5SDimitry Andric #include <iterator> 810b57cec5SDimitry Andric #include <limits> 820b57cec5SDimitry Andric 830b57cec5SDimitry Andric using namespace llvm; 840b57cec5SDimitry Andric using namespace llvm::codeview; 850b57cec5SDimitry Andric 860b57cec5SDimitry Andric namespace { 870b57cec5SDimitry Andric class CVMCAdapter : public CodeViewRecordStreamer { 880b57cec5SDimitry Andric public: 898bcb0991SDimitry Andric CVMCAdapter(MCStreamer &OS, TypeCollection &TypeTable) 908bcb0991SDimitry Andric : OS(&OS), TypeTable(TypeTable) {} 910b57cec5SDimitry Andric 925ffd83dbSDimitry Andric void emitBytes(StringRef Data) override { OS->emitBytes(Data); } 930b57cec5SDimitry Andric 945ffd83dbSDimitry Andric void emitIntValue(uint64_t Value, unsigned Size) override { 955ffd83dbSDimitry Andric OS->emitIntValueInHex(Value, Size); 960b57cec5SDimitry Andric } 970b57cec5SDimitry Andric 985ffd83dbSDimitry Andric void emitBinaryData(StringRef Data) override { OS->emitBinaryData(Data); } 990b57cec5SDimitry Andric 1005ffd83dbSDimitry Andric void AddComment(const Twine &T) override { OS->AddComment(T); } 1010b57cec5SDimitry Andric 1025ffd83dbSDimitry Andric void AddRawComment(const Twine &T) override { OS->emitRawComment(T); } 1038bcb0991SDimitry Andric 1045ffd83dbSDimitry Andric bool isVerboseAsm() override { return OS->isVerboseAsm(); } 1058bcb0991SDimitry Andric 1065ffd83dbSDimitry Andric std::string getTypeName(TypeIndex TI) override { 1078bcb0991SDimitry Andric std::string TypeName; 1088bcb0991SDimitry Andric if (!TI.isNoneType()) { 1098bcb0991SDimitry Andric if (TI.isSimple()) 1105ffd83dbSDimitry Andric TypeName = std::string(TypeIndex::simpleTypeName(TI)); 1118bcb0991SDimitry Andric else 1125ffd83dbSDimitry Andric TypeName = std::string(TypeTable.getTypeName(TI)); 1138bcb0991SDimitry Andric } 1148bcb0991SDimitry Andric return TypeName; 1158bcb0991SDimitry Andric } 1168bcb0991SDimitry Andric 1170b57cec5SDimitry Andric private: 1180b57cec5SDimitry Andric MCStreamer *OS = nullptr; 1198bcb0991SDimitry Andric TypeCollection &TypeTable; 1200b57cec5SDimitry Andric }; 1210b57cec5SDimitry Andric } // namespace 1220b57cec5SDimitry Andric 1230b57cec5SDimitry Andric static CPUType mapArchToCVCPUType(Triple::ArchType Type) { 1240b57cec5SDimitry Andric switch (Type) { 1250b57cec5SDimitry Andric case Triple::ArchType::x86: 1260b57cec5SDimitry Andric return CPUType::Pentium3; 1270b57cec5SDimitry Andric case Triple::ArchType::x86_64: 1280b57cec5SDimitry Andric return CPUType::X64; 1290b57cec5SDimitry Andric case Triple::ArchType::thumb: 130e8d8bef9SDimitry Andric // LLVM currently doesn't support Windows CE and so thumb 131e8d8bef9SDimitry Andric // here is indiscriminately mapped to ARMNT specifically. 132e8d8bef9SDimitry Andric return CPUType::ARMNT; 1330b57cec5SDimitry Andric case Triple::ArchType::aarch64: 1340b57cec5SDimitry Andric return CPUType::ARM64; 1350b57cec5SDimitry Andric default: 1360b57cec5SDimitry Andric report_fatal_error("target architecture doesn't map to a CodeView CPUType"); 1370b57cec5SDimitry Andric } 1380b57cec5SDimitry Andric } 1390b57cec5SDimitry Andric 1400b57cec5SDimitry Andric CodeViewDebug::CodeViewDebug(AsmPrinter *AP) 141e8d8bef9SDimitry Andric : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {} 1420b57cec5SDimitry Andric 1430b57cec5SDimitry Andric StringRef CodeViewDebug::getFullFilepath(const DIFile *File) { 1440b57cec5SDimitry Andric std::string &Filepath = FileToFilepathMap[File]; 1450b57cec5SDimitry Andric if (!Filepath.empty()) 1460b57cec5SDimitry Andric return Filepath; 1470b57cec5SDimitry Andric 1480b57cec5SDimitry Andric StringRef Dir = File->getDirectory(), Filename = File->getFilename(); 1490b57cec5SDimitry Andric 1500b57cec5SDimitry Andric // If this is a Unix-style path, just use it as is. Don't try to canonicalize 1510b57cec5SDimitry Andric // it textually because one of the path components could be a symlink. 1520b57cec5SDimitry Andric if (Dir.startswith("/") || Filename.startswith("/")) { 1530b57cec5SDimitry Andric if (llvm::sys::path::is_absolute(Filename, llvm::sys::path::Style::posix)) 1540b57cec5SDimitry Andric return Filename; 1555ffd83dbSDimitry Andric Filepath = std::string(Dir); 1560b57cec5SDimitry Andric if (Dir.back() != '/') 1570b57cec5SDimitry Andric Filepath += '/'; 1580b57cec5SDimitry Andric Filepath += Filename; 1590b57cec5SDimitry Andric return Filepath; 1600b57cec5SDimitry Andric } 1610b57cec5SDimitry Andric 1620b57cec5SDimitry Andric // Clang emits directory and relative filename info into the IR, but CodeView 1630b57cec5SDimitry Andric // operates on full paths. We could change Clang to emit full paths too, but 1640b57cec5SDimitry Andric // that would increase the IR size and probably not needed for other users. 1650b57cec5SDimitry Andric // For now, just concatenate and canonicalize the path here. 1660b57cec5SDimitry Andric if (Filename.find(':') == 1) 1675ffd83dbSDimitry Andric Filepath = std::string(Filename); 1680b57cec5SDimitry Andric else 1690b57cec5SDimitry Andric Filepath = (Dir + "\\" + Filename).str(); 1700b57cec5SDimitry Andric 1710b57cec5SDimitry Andric // Canonicalize the path. We have to do it textually because we may no longer 1720b57cec5SDimitry Andric // have access the file in the filesystem. 1730b57cec5SDimitry Andric // First, replace all slashes with backslashes. 1740b57cec5SDimitry Andric std::replace(Filepath.begin(), Filepath.end(), '/', '\\'); 1750b57cec5SDimitry Andric 1760b57cec5SDimitry Andric // Remove all "\.\" with "\". 1770b57cec5SDimitry Andric size_t Cursor = 0; 1780b57cec5SDimitry Andric while ((Cursor = Filepath.find("\\.\\", Cursor)) != std::string::npos) 1790b57cec5SDimitry Andric Filepath.erase(Cursor, 2); 1800b57cec5SDimitry Andric 1810b57cec5SDimitry Andric // Replace all "\XXX\..\" with "\". Don't try too hard though as the original 1820b57cec5SDimitry Andric // path should be well-formatted, e.g. start with a drive letter, etc. 1830b57cec5SDimitry Andric Cursor = 0; 1840b57cec5SDimitry Andric while ((Cursor = Filepath.find("\\..\\", Cursor)) != std::string::npos) { 1850b57cec5SDimitry Andric // Something's wrong if the path starts with "\..\", abort. 1860b57cec5SDimitry Andric if (Cursor == 0) 1870b57cec5SDimitry Andric break; 1880b57cec5SDimitry Andric 1890b57cec5SDimitry Andric size_t PrevSlash = Filepath.rfind('\\', Cursor - 1); 1900b57cec5SDimitry Andric if (PrevSlash == std::string::npos) 1910b57cec5SDimitry Andric // Something's wrong, abort. 1920b57cec5SDimitry Andric break; 1930b57cec5SDimitry Andric 1940b57cec5SDimitry Andric Filepath.erase(PrevSlash, Cursor + 3 - PrevSlash); 1950b57cec5SDimitry Andric // The next ".." might be following the one we've just erased. 1960b57cec5SDimitry Andric Cursor = PrevSlash; 1970b57cec5SDimitry Andric } 1980b57cec5SDimitry Andric 1990b57cec5SDimitry Andric // Remove all duplicate backslashes. 2000b57cec5SDimitry Andric Cursor = 0; 2010b57cec5SDimitry Andric while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos) 2020b57cec5SDimitry Andric Filepath.erase(Cursor, 1); 2030b57cec5SDimitry Andric 2040b57cec5SDimitry Andric return Filepath; 2050b57cec5SDimitry Andric } 2060b57cec5SDimitry Andric 2070b57cec5SDimitry Andric unsigned CodeViewDebug::maybeRecordFile(const DIFile *F) { 2080b57cec5SDimitry Andric StringRef FullPath = getFullFilepath(F); 2090b57cec5SDimitry Andric unsigned NextId = FileIdMap.size() + 1; 2100b57cec5SDimitry Andric auto Insertion = FileIdMap.insert(std::make_pair(FullPath, NextId)); 2110b57cec5SDimitry Andric if (Insertion.second) { 2120b57cec5SDimitry Andric // We have to compute the full filepath and emit a .cv_file directive. 2130b57cec5SDimitry Andric ArrayRef<uint8_t> ChecksumAsBytes; 2140b57cec5SDimitry Andric FileChecksumKind CSKind = FileChecksumKind::None; 2150b57cec5SDimitry Andric if (F->getChecksum()) { 2160b57cec5SDimitry Andric std::string Checksum = fromHex(F->getChecksum()->Value); 2170b57cec5SDimitry Andric void *CKMem = OS.getContext().allocate(Checksum.size(), 1); 2180b57cec5SDimitry Andric memcpy(CKMem, Checksum.data(), Checksum.size()); 2190b57cec5SDimitry Andric ChecksumAsBytes = ArrayRef<uint8_t>( 2200b57cec5SDimitry Andric reinterpret_cast<const uint8_t *>(CKMem), Checksum.size()); 2210b57cec5SDimitry Andric switch (F->getChecksum()->Kind) { 2225ffd83dbSDimitry Andric case DIFile::CSK_MD5: 2235ffd83dbSDimitry Andric CSKind = FileChecksumKind::MD5; 2245ffd83dbSDimitry Andric break; 2255ffd83dbSDimitry Andric case DIFile::CSK_SHA1: 2265ffd83dbSDimitry Andric CSKind = FileChecksumKind::SHA1; 2275ffd83dbSDimitry Andric break; 2285ffd83dbSDimitry Andric case DIFile::CSK_SHA256: 2295ffd83dbSDimitry Andric CSKind = FileChecksumKind::SHA256; 2305ffd83dbSDimitry Andric break; 2310b57cec5SDimitry Andric } 2320b57cec5SDimitry Andric } 2330b57cec5SDimitry Andric bool Success = OS.EmitCVFileDirective(NextId, FullPath, ChecksumAsBytes, 2340b57cec5SDimitry Andric static_cast<unsigned>(CSKind)); 2350b57cec5SDimitry Andric (void)Success; 2360b57cec5SDimitry Andric assert(Success && ".cv_file directive failed"); 2370b57cec5SDimitry Andric } 2380b57cec5SDimitry Andric return Insertion.first->second; 2390b57cec5SDimitry Andric } 2400b57cec5SDimitry Andric 2410b57cec5SDimitry Andric CodeViewDebug::InlineSite & 2420b57cec5SDimitry Andric CodeViewDebug::getInlineSite(const DILocation *InlinedAt, 2430b57cec5SDimitry Andric const DISubprogram *Inlinee) { 2440b57cec5SDimitry Andric auto SiteInsertion = CurFn->InlineSites.insert({InlinedAt, InlineSite()}); 2450b57cec5SDimitry Andric InlineSite *Site = &SiteInsertion.first->second; 2460b57cec5SDimitry Andric if (SiteInsertion.second) { 2470b57cec5SDimitry Andric unsigned ParentFuncId = CurFn->FuncId; 2480b57cec5SDimitry Andric if (const DILocation *OuterIA = InlinedAt->getInlinedAt()) 2490b57cec5SDimitry Andric ParentFuncId = 2500b57cec5SDimitry Andric getInlineSite(OuterIA, InlinedAt->getScope()->getSubprogram()) 2510b57cec5SDimitry Andric .SiteFuncId; 2520b57cec5SDimitry Andric 2530b57cec5SDimitry Andric Site->SiteFuncId = NextFuncId++; 2540b57cec5SDimitry Andric OS.EmitCVInlineSiteIdDirective( 2550b57cec5SDimitry Andric Site->SiteFuncId, ParentFuncId, maybeRecordFile(InlinedAt->getFile()), 2560b57cec5SDimitry Andric InlinedAt->getLine(), InlinedAt->getColumn(), SMLoc()); 2570b57cec5SDimitry Andric Site->Inlinee = Inlinee; 2580b57cec5SDimitry Andric InlinedSubprograms.insert(Inlinee); 2590b57cec5SDimitry Andric getFuncIdForSubprogram(Inlinee); 2600b57cec5SDimitry Andric } 2610b57cec5SDimitry Andric return *Site; 2620b57cec5SDimitry Andric } 2630b57cec5SDimitry Andric 2640b57cec5SDimitry Andric static StringRef getPrettyScopeName(const DIScope *Scope) { 2650b57cec5SDimitry Andric StringRef ScopeName = Scope->getName(); 2660b57cec5SDimitry Andric if (!ScopeName.empty()) 2670b57cec5SDimitry Andric return ScopeName; 2680b57cec5SDimitry Andric 2690b57cec5SDimitry Andric switch (Scope->getTag()) { 2700b57cec5SDimitry Andric case dwarf::DW_TAG_enumeration_type: 2710b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 2720b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 2730b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 2740b57cec5SDimitry Andric return "<unnamed-tag>"; 2750b57cec5SDimitry Andric case dwarf::DW_TAG_namespace: 2760b57cec5SDimitry Andric return "`anonymous namespace'"; 277fe6060f1SDimitry Andric default: 2780b57cec5SDimitry Andric return StringRef(); 2790b57cec5SDimitry Andric } 280fe6060f1SDimitry Andric } 2810b57cec5SDimitry Andric 2825ffd83dbSDimitry Andric const DISubprogram *CodeViewDebug::collectParentScopeNames( 2830b57cec5SDimitry Andric const DIScope *Scope, SmallVectorImpl<StringRef> &QualifiedNameComponents) { 2840b57cec5SDimitry Andric const DISubprogram *ClosestSubprogram = nullptr; 2850b57cec5SDimitry Andric while (Scope != nullptr) { 2860b57cec5SDimitry Andric if (ClosestSubprogram == nullptr) 2870b57cec5SDimitry Andric ClosestSubprogram = dyn_cast<DISubprogram>(Scope); 2885ffd83dbSDimitry Andric 2895ffd83dbSDimitry Andric // If a type appears in a scope chain, make sure it gets emitted. The 2905ffd83dbSDimitry Andric // frontend will be responsible for deciding if this should be a forward 2915ffd83dbSDimitry Andric // declaration or a complete type. 2925ffd83dbSDimitry Andric if (const auto *Ty = dyn_cast<DICompositeType>(Scope)) 2935ffd83dbSDimitry Andric DeferredCompleteTypes.push_back(Ty); 2945ffd83dbSDimitry Andric 2950b57cec5SDimitry Andric StringRef ScopeName = getPrettyScopeName(Scope); 2960b57cec5SDimitry Andric if (!ScopeName.empty()) 2970b57cec5SDimitry Andric QualifiedNameComponents.push_back(ScopeName); 2980b57cec5SDimitry Andric Scope = Scope->getScope(); 2990b57cec5SDimitry Andric } 3000b57cec5SDimitry Andric return ClosestSubprogram; 3010b57cec5SDimitry Andric } 3020b57cec5SDimitry Andric 3035ffd83dbSDimitry Andric static std::string formatNestedName(ArrayRef<StringRef> QualifiedNameComponents, 3040b57cec5SDimitry Andric StringRef TypeName) { 3050b57cec5SDimitry Andric std::string FullyQualifiedName; 3060b57cec5SDimitry Andric for (StringRef QualifiedNameComponent : 3070b57cec5SDimitry Andric llvm::reverse(QualifiedNameComponents)) { 3085ffd83dbSDimitry Andric FullyQualifiedName.append(std::string(QualifiedNameComponent)); 3090b57cec5SDimitry Andric FullyQualifiedName.append("::"); 3100b57cec5SDimitry Andric } 3115ffd83dbSDimitry Andric FullyQualifiedName.append(std::string(TypeName)); 3120b57cec5SDimitry Andric return FullyQualifiedName; 3130b57cec5SDimitry Andric } 3140b57cec5SDimitry Andric 3150b57cec5SDimitry Andric struct CodeViewDebug::TypeLoweringScope { 3160b57cec5SDimitry Andric TypeLoweringScope(CodeViewDebug &CVD) : CVD(CVD) { ++CVD.TypeEmissionLevel; } 3170b57cec5SDimitry Andric ~TypeLoweringScope() { 3180b57cec5SDimitry Andric // Don't decrement TypeEmissionLevel until after emitting deferred types, so 3190b57cec5SDimitry Andric // inner TypeLoweringScopes don't attempt to emit deferred types. 3200b57cec5SDimitry Andric if (CVD.TypeEmissionLevel == 1) 3210b57cec5SDimitry Andric CVD.emitDeferredCompleteTypes(); 3220b57cec5SDimitry Andric --CVD.TypeEmissionLevel; 3230b57cec5SDimitry Andric } 3240b57cec5SDimitry Andric CodeViewDebug &CVD; 3250b57cec5SDimitry Andric }; 3260b57cec5SDimitry Andric 3275ffd83dbSDimitry Andric std::string CodeViewDebug::getFullyQualifiedName(const DIScope *Scope, 3285ffd83dbSDimitry Andric StringRef Name) { 3295ffd83dbSDimitry Andric // Ensure types in the scope chain are emitted as soon as possible. 3305ffd83dbSDimitry Andric // This can create otherwise a situation where S_UDTs are emitted while 3315ffd83dbSDimitry Andric // looping in emitDebugInfoForUDTs. 3325ffd83dbSDimitry Andric TypeLoweringScope S(*this); 3335ffd83dbSDimitry Andric SmallVector<StringRef, 5> QualifiedNameComponents; 3345ffd83dbSDimitry Andric collectParentScopeNames(Scope, QualifiedNameComponents); 3355ffd83dbSDimitry Andric return formatNestedName(QualifiedNameComponents, Name); 3365ffd83dbSDimitry Andric } 3375ffd83dbSDimitry Andric 3385ffd83dbSDimitry Andric std::string CodeViewDebug::getFullyQualifiedName(const DIScope *Ty) { 3390b57cec5SDimitry Andric const DIScope *Scope = Ty->getScope(); 3400b57cec5SDimitry Andric return getFullyQualifiedName(Scope, getPrettyScopeName(Ty)); 3410b57cec5SDimitry Andric } 3420b57cec5SDimitry Andric 3430b57cec5SDimitry Andric TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) { 3440b57cec5SDimitry Andric // No scope means global scope and that uses the zero index. 345349cc55cSDimitry Andric // 346349cc55cSDimitry Andric // We also use zero index when the scope is a DISubprogram 347349cc55cSDimitry Andric // to suppress the emission of LF_STRING_ID for the function, 348349cc55cSDimitry Andric // which can trigger a link-time error with the linker in 349349cc55cSDimitry Andric // VS2019 version 16.11.2 or newer. 350349cc55cSDimitry Andric // Note, however, skipping the debug info emission for the DISubprogram 351349cc55cSDimitry Andric // is a temporary fix. The root issue here is that we need to figure out 352349cc55cSDimitry Andric // the proper way to encode a function nested in another function 353349cc55cSDimitry Andric // (as introduced by the Fortran 'contains' keyword) in CodeView. 354349cc55cSDimitry Andric if (!Scope || isa<DIFile>(Scope) || isa<DISubprogram>(Scope)) 3550b57cec5SDimitry Andric return TypeIndex(); 3560b57cec5SDimitry Andric 3570b57cec5SDimitry Andric assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type"); 3580b57cec5SDimitry Andric 3590b57cec5SDimitry Andric // Check if we've already translated this scope. 3600b57cec5SDimitry Andric auto I = TypeIndices.find({Scope, nullptr}); 3610b57cec5SDimitry Andric if (I != TypeIndices.end()) 3620b57cec5SDimitry Andric return I->second; 3630b57cec5SDimitry Andric 3640b57cec5SDimitry Andric // Build the fully qualified name of the scope. 3650b57cec5SDimitry Andric std::string ScopeName = getFullyQualifiedName(Scope); 3660b57cec5SDimitry Andric StringIdRecord SID(TypeIndex(), ScopeName); 3670b57cec5SDimitry Andric auto TI = TypeTable.writeLeafType(SID); 3680b57cec5SDimitry Andric return recordTypeIndexForDINode(Scope, TI); 3690b57cec5SDimitry Andric } 3700b57cec5SDimitry Andric 371fe6060f1SDimitry Andric static StringRef removeTemplateArgs(StringRef Name) { 372fe6060f1SDimitry Andric // Remove template args from the display name. Assume that the template args 373fe6060f1SDimitry Andric // are the last thing in the name. 374fe6060f1SDimitry Andric if (Name.empty() || Name.back() != '>') 375fe6060f1SDimitry Andric return Name; 376fe6060f1SDimitry Andric 377fe6060f1SDimitry Andric int OpenBrackets = 0; 378fe6060f1SDimitry Andric for (int i = Name.size() - 1; i >= 0; --i) { 379fe6060f1SDimitry Andric if (Name[i] == '>') 380fe6060f1SDimitry Andric ++OpenBrackets; 381fe6060f1SDimitry Andric else if (Name[i] == '<') { 382fe6060f1SDimitry Andric --OpenBrackets; 383fe6060f1SDimitry Andric if (OpenBrackets == 0) 384fe6060f1SDimitry Andric return Name.substr(0, i); 385fe6060f1SDimitry Andric } 386fe6060f1SDimitry Andric } 387fe6060f1SDimitry Andric return Name; 388fe6060f1SDimitry Andric } 389fe6060f1SDimitry Andric 3900b57cec5SDimitry Andric TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) { 3910b57cec5SDimitry Andric assert(SP); 3920b57cec5SDimitry Andric 3930b57cec5SDimitry Andric // Check if we've already translated this subprogram. 3940b57cec5SDimitry Andric auto I = TypeIndices.find({SP, nullptr}); 3950b57cec5SDimitry Andric if (I != TypeIndices.end()) 3960b57cec5SDimitry Andric return I->second; 3970b57cec5SDimitry Andric 3980b57cec5SDimitry Andric // The display name includes function template arguments. Drop them to match 399fe6060f1SDimitry Andric // MSVC. We need to have the template arguments in the DISubprogram name 400fe6060f1SDimitry Andric // because they are used in other symbol records, such as S_GPROC32_IDs. 401fe6060f1SDimitry Andric StringRef DisplayName = removeTemplateArgs(SP->getName()); 4020b57cec5SDimitry Andric 4030b57cec5SDimitry Andric const DIScope *Scope = SP->getScope(); 4040b57cec5SDimitry Andric TypeIndex TI; 4050b57cec5SDimitry Andric if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) { 4060b57cec5SDimitry Andric // If the scope is a DICompositeType, then this must be a method. Member 4070b57cec5SDimitry Andric // function types take some special handling, and require access to the 4080b57cec5SDimitry Andric // subprogram. 4090b57cec5SDimitry Andric TypeIndex ClassType = getTypeIndex(Class); 4100b57cec5SDimitry Andric MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class), 4110b57cec5SDimitry Andric DisplayName); 4120b57cec5SDimitry Andric TI = TypeTable.writeLeafType(MFuncId); 4130b57cec5SDimitry Andric } else { 4140b57cec5SDimitry Andric // Otherwise, this must be a free function. 4150b57cec5SDimitry Andric TypeIndex ParentScope = getScopeIndex(Scope); 4160b57cec5SDimitry Andric FuncIdRecord FuncId(ParentScope, getTypeIndex(SP->getType()), DisplayName); 4170b57cec5SDimitry Andric TI = TypeTable.writeLeafType(FuncId); 4180b57cec5SDimitry Andric } 4190b57cec5SDimitry Andric 4200b57cec5SDimitry Andric return recordTypeIndexForDINode(SP, TI); 4210b57cec5SDimitry Andric } 4220b57cec5SDimitry Andric 4230b57cec5SDimitry Andric static bool isNonTrivial(const DICompositeType *DCTy) { 4240b57cec5SDimitry Andric return ((DCTy->getFlags() & DINode::FlagNonTrivial) == DINode::FlagNonTrivial); 4250b57cec5SDimitry Andric } 4260b57cec5SDimitry Andric 4270b57cec5SDimitry Andric static FunctionOptions 4280b57cec5SDimitry Andric getFunctionOptions(const DISubroutineType *Ty, 4290b57cec5SDimitry Andric const DICompositeType *ClassTy = nullptr, 4300b57cec5SDimitry Andric StringRef SPName = StringRef("")) { 4310b57cec5SDimitry Andric FunctionOptions FO = FunctionOptions::None; 4320b57cec5SDimitry Andric const DIType *ReturnTy = nullptr; 4330b57cec5SDimitry Andric if (auto TypeArray = Ty->getTypeArray()) { 4340b57cec5SDimitry Andric if (TypeArray.size()) 4350b57cec5SDimitry Andric ReturnTy = TypeArray[0]; 4360b57cec5SDimitry Andric } 4370b57cec5SDimitry Andric 4385ffd83dbSDimitry Andric // Add CxxReturnUdt option to functions that return nontrivial record types 4395ffd83dbSDimitry Andric // or methods that return record types. 4405ffd83dbSDimitry Andric if (auto *ReturnDCTy = dyn_cast_or_null<DICompositeType>(ReturnTy)) 4415ffd83dbSDimitry Andric if (isNonTrivial(ReturnDCTy) || ClassTy) 4420b57cec5SDimitry Andric FO |= FunctionOptions::CxxReturnUdt; 4430b57cec5SDimitry Andric 4440b57cec5SDimitry Andric // DISubroutineType is unnamed. Use DISubprogram's i.e. SPName in comparison. 4450b57cec5SDimitry Andric if (ClassTy && isNonTrivial(ClassTy) && SPName == ClassTy->getName()) { 4460b57cec5SDimitry Andric FO |= FunctionOptions::Constructor; 4470b57cec5SDimitry Andric 4480b57cec5SDimitry Andric // TODO: put the FunctionOptions::ConstructorWithVirtualBases flag. 4490b57cec5SDimitry Andric 4500b57cec5SDimitry Andric } 4510b57cec5SDimitry Andric return FO; 4520b57cec5SDimitry Andric } 4530b57cec5SDimitry Andric 4540b57cec5SDimitry Andric TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP, 4550b57cec5SDimitry Andric const DICompositeType *Class) { 4560b57cec5SDimitry Andric // Always use the method declaration as the key for the function type. The 4570b57cec5SDimitry Andric // method declaration contains the this adjustment. 4580b57cec5SDimitry Andric if (SP->getDeclaration()) 4590b57cec5SDimitry Andric SP = SP->getDeclaration(); 4600b57cec5SDimitry Andric assert(!SP->getDeclaration() && "should use declaration as key"); 4610b57cec5SDimitry Andric 4620b57cec5SDimitry Andric // Key the MemberFunctionRecord into the map as {SP, Class}. It won't collide 4630b57cec5SDimitry Andric // with the MemberFuncIdRecord, which is keyed in as {SP, nullptr}. 4640b57cec5SDimitry Andric auto I = TypeIndices.find({SP, Class}); 4650b57cec5SDimitry Andric if (I != TypeIndices.end()) 4660b57cec5SDimitry Andric return I->second; 4670b57cec5SDimitry Andric 4680b57cec5SDimitry Andric // Make sure complete type info for the class is emitted *after* the member 4690b57cec5SDimitry Andric // function type, as the complete class type is likely to reference this 4700b57cec5SDimitry Andric // member function type. 4710b57cec5SDimitry Andric TypeLoweringScope S(*this); 4720b57cec5SDimitry Andric const bool IsStaticMethod = (SP->getFlags() & DINode::FlagStaticMember) != 0; 4730b57cec5SDimitry Andric 4740b57cec5SDimitry Andric FunctionOptions FO = getFunctionOptions(SP->getType(), Class, SP->getName()); 4750b57cec5SDimitry Andric TypeIndex TI = lowerTypeMemberFunction( 4760b57cec5SDimitry Andric SP->getType(), Class, SP->getThisAdjustment(), IsStaticMethod, FO); 4770b57cec5SDimitry Andric return recordTypeIndexForDINode(SP, TI, Class); 4780b57cec5SDimitry Andric } 4790b57cec5SDimitry Andric 4800b57cec5SDimitry Andric TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node, 4810b57cec5SDimitry Andric TypeIndex TI, 4820b57cec5SDimitry Andric const DIType *ClassTy) { 4830b57cec5SDimitry Andric auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI}); 4840b57cec5SDimitry Andric (void)InsertResult; 4850b57cec5SDimitry Andric assert(InsertResult.second && "DINode was already assigned a type index"); 4860b57cec5SDimitry Andric return TI; 4870b57cec5SDimitry Andric } 4880b57cec5SDimitry Andric 4890b57cec5SDimitry Andric unsigned CodeViewDebug::getPointerSizeInBytes() { 4900b57cec5SDimitry Andric return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8; 4910b57cec5SDimitry Andric } 4920b57cec5SDimitry Andric 4930b57cec5SDimitry Andric void CodeViewDebug::recordLocalVariable(LocalVariable &&Var, 4940b57cec5SDimitry Andric const LexicalScope *LS) { 4950b57cec5SDimitry Andric if (const DILocation *InlinedAt = LS->getInlinedAt()) { 4960b57cec5SDimitry Andric // This variable was inlined. Associate it with the InlineSite. 4970b57cec5SDimitry Andric const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram(); 4980b57cec5SDimitry Andric InlineSite &Site = getInlineSite(InlinedAt, Inlinee); 4990b57cec5SDimitry Andric Site.InlinedLocals.emplace_back(Var); 5000b57cec5SDimitry Andric } else { 5010b57cec5SDimitry Andric // This variable goes into the corresponding lexical scope. 5020b57cec5SDimitry Andric ScopeVariables[LS].emplace_back(Var); 5030b57cec5SDimitry Andric } 5040b57cec5SDimitry Andric } 5050b57cec5SDimitry Andric 5060b57cec5SDimitry Andric static void addLocIfNotPresent(SmallVectorImpl<const DILocation *> &Locs, 5070b57cec5SDimitry Andric const DILocation *Loc) { 508e8d8bef9SDimitry Andric if (!llvm::is_contained(Locs, Loc)) 5090b57cec5SDimitry Andric Locs.push_back(Loc); 5100b57cec5SDimitry Andric } 5110b57cec5SDimitry Andric 5120b57cec5SDimitry Andric void CodeViewDebug::maybeRecordLocation(const DebugLoc &DL, 5130b57cec5SDimitry Andric const MachineFunction *MF) { 5140b57cec5SDimitry Andric // Skip this instruction if it has the same location as the previous one. 5150b57cec5SDimitry Andric if (!DL || DL == PrevInstLoc) 5160b57cec5SDimitry Andric return; 5170b57cec5SDimitry Andric 5180b57cec5SDimitry Andric const DIScope *Scope = DL.get()->getScope(); 5190b57cec5SDimitry Andric if (!Scope) 5200b57cec5SDimitry Andric return; 5210b57cec5SDimitry Andric 5220b57cec5SDimitry Andric // Skip this line if it is longer than the maximum we can record. 5230b57cec5SDimitry Andric LineInfo LI(DL.getLine(), DL.getLine(), /*IsStatement=*/true); 5240b57cec5SDimitry Andric if (LI.getStartLine() != DL.getLine() || LI.isAlwaysStepInto() || 5250b57cec5SDimitry Andric LI.isNeverStepInto()) 5260b57cec5SDimitry Andric return; 5270b57cec5SDimitry Andric 5280b57cec5SDimitry Andric ColumnInfo CI(DL.getCol(), /*EndColumn=*/0); 5290b57cec5SDimitry Andric if (CI.getStartColumn() != DL.getCol()) 5300b57cec5SDimitry Andric return; 5310b57cec5SDimitry Andric 5320b57cec5SDimitry Andric if (!CurFn->HaveLineInfo) 5330b57cec5SDimitry Andric CurFn->HaveLineInfo = true; 5340b57cec5SDimitry Andric unsigned FileId = 0; 5350b57cec5SDimitry Andric if (PrevInstLoc.get() && PrevInstLoc->getFile() == DL->getFile()) 5360b57cec5SDimitry Andric FileId = CurFn->LastFileId; 5370b57cec5SDimitry Andric else 5380b57cec5SDimitry Andric FileId = CurFn->LastFileId = maybeRecordFile(DL->getFile()); 5390b57cec5SDimitry Andric PrevInstLoc = DL; 5400b57cec5SDimitry Andric 5410b57cec5SDimitry Andric unsigned FuncId = CurFn->FuncId; 5420b57cec5SDimitry Andric if (const DILocation *SiteLoc = DL->getInlinedAt()) { 5430b57cec5SDimitry Andric const DILocation *Loc = DL.get(); 5440b57cec5SDimitry Andric 5450b57cec5SDimitry Andric // If this location was actually inlined from somewhere else, give it the ID 5460b57cec5SDimitry Andric // of the inline call site. 5470b57cec5SDimitry Andric FuncId = 5480b57cec5SDimitry Andric getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()).SiteFuncId; 5490b57cec5SDimitry Andric 5500b57cec5SDimitry Andric // Ensure we have links in the tree of inline call sites. 5510b57cec5SDimitry Andric bool FirstLoc = true; 5520b57cec5SDimitry Andric while ((SiteLoc = Loc->getInlinedAt())) { 5530b57cec5SDimitry Andric InlineSite &Site = 5540b57cec5SDimitry Andric getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()); 5550b57cec5SDimitry Andric if (!FirstLoc) 5560b57cec5SDimitry Andric addLocIfNotPresent(Site.ChildSites, Loc); 5570b57cec5SDimitry Andric FirstLoc = false; 5580b57cec5SDimitry Andric Loc = SiteLoc; 5590b57cec5SDimitry Andric } 5600b57cec5SDimitry Andric addLocIfNotPresent(CurFn->ChildSites, Loc); 5610b57cec5SDimitry Andric } 5620b57cec5SDimitry Andric 5635ffd83dbSDimitry Andric OS.emitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(), 5640b57cec5SDimitry Andric /*PrologueEnd=*/false, /*IsStmt=*/false, 5650b57cec5SDimitry Andric DL->getFilename(), SMLoc()); 5660b57cec5SDimitry Andric } 5670b57cec5SDimitry Andric 5680b57cec5SDimitry Andric void CodeViewDebug::emitCodeViewMagicVersion() { 5695ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 5700b57cec5SDimitry Andric OS.AddComment("Debug section magic"); 5715ffd83dbSDimitry Andric OS.emitInt32(COFF::DEBUG_SECTION_MAGIC); 5720b57cec5SDimitry Andric } 5730b57cec5SDimitry Andric 574349cc55cSDimitry Andric static SourceLanguage MapDWLangToCVLang(unsigned DWLang) { 575349cc55cSDimitry Andric switch (DWLang) { 576349cc55cSDimitry Andric case dwarf::DW_LANG_C: 577349cc55cSDimitry Andric case dwarf::DW_LANG_C89: 578349cc55cSDimitry Andric case dwarf::DW_LANG_C99: 579349cc55cSDimitry Andric case dwarf::DW_LANG_C11: 580349cc55cSDimitry Andric case dwarf::DW_LANG_ObjC: 581349cc55cSDimitry Andric return SourceLanguage::C; 582349cc55cSDimitry Andric case dwarf::DW_LANG_C_plus_plus: 583349cc55cSDimitry Andric case dwarf::DW_LANG_C_plus_plus_03: 584349cc55cSDimitry Andric case dwarf::DW_LANG_C_plus_plus_11: 585349cc55cSDimitry Andric case dwarf::DW_LANG_C_plus_plus_14: 586349cc55cSDimitry Andric return SourceLanguage::Cpp; 587349cc55cSDimitry Andric case dwarf::DW_LANG_Fortran77: 588349cc55cSDimitry Andric case dwarf::DW_LANG_Fortran90: 589349cc55cSDimitry Andric case dwarf::DW_LANG_Fortran95: 590349cc55cSDimitry Andric case dwarf::DW_LANG_Fortran03: 591349cc55cSDimitry Andric case dwarf::DW_LANG_Fortran08: 592349cc55cSDimitry Andric return SourceLanguage::Fortran; 593349cc55cSDimitry Andric case dwarf::DW_LANG_Pascal83: 594349cc55cSDimitry Andric return SourceLanguage::Pascal; 595349cc55cSDimitry Andric case dwarf::DW_LANG_Cobol74: 596349cc55cSDimitry Andric case dwarf::DW_LANG_Cobol85: 597349cc55cSDimitry Andric return SourceLanguage::Cobol; 598349cc55cSDimitry Andric case dwarf::DW_LANG_Java: 599349cc55cSDimitry Andric return SourceLanguage::Java; 600349cc55cSDimitry Andric case dwarf::DW_LANG_D: 601349cc55cSDimitry Andric return SourceLanguage::D; 602349cc55cSDimitry Andric case dwarf::DW_LANG_Swift: 603349cc55cSDimitry Andric return SourceLanguage::Swift; 60404eeddc0SDimitry Andric case dwarf::DW_LANG_Rust: 60504eeddc0SDimitry Andric return SourceLanguage::Rust; 606349cc55cSDimitry Andric default: 607349cc55cSDimitry Andric // There's no CodeView representation for this language, and CV doesn't 608349cc55cSDimitry Andric // have an "unknown" option for the language field, so we'll use MASM, 609349cc55cSDimitry Andric // as it's very low level. 610349cc55cSDimitry Andric return SourceLanguage::Masm; 611349cc55cSDimitry Andric } 612349cc55cSDimitry Andric } 613349cc55cSDimitry Andric 614e8d8bef9SDimitry Andric void CodeViewDebug::beginModule(Module *M) { 615e8d8bef9SDimitry Andric // If module doesn't have named metadata anchors or COFF debug section 616e8d8bef9SDimitry Andric // is not available, skip any debug info related stuff. 6170eae32dcSDimitry Andric NamedMDNode *CUs = M->getNamedMetadata("llvm.dbg.cu"); 6180eae32dcSDimitry Andric if (!CUs || !Asm->getObjFileLowering().getCOFFDebugSymbolsSection()) { 619e8d8bef9SDimitry Andric Asm = nullptr; 620e8d8bef9SDimitry Andric return; 621e8d8bef9SDimitry Andric } 622e8d8bef9SDimitry Andric // Tell MMI that we have and need debug info. 623e8d8bef9SDimitry Andric MMI->setDebugInfoAvailability(true); 624e8d8bef9SDimitry Andric 625e8d8bef9SDimitry Andric TheCPU = mapArchToCVCPUType(Triple(M->getTargetTriple()).getArch()); 626e8d8bef9SDimitry Andric 627349cc55cSDimitry Andric // Get the current source language. 628349cc55cSDimitry Andric const MDNode *Node = *CUs->operands().begin(); 629349cc55cSDimitry Andric const auto *CU = cast<DICompileUnit>(Node); 630349cc55cSDimitry Andric 631349cc55cSDimitry Andric CurrentSourceLanguage = MapDWLangToCVLang(CU->getSourceLanguage()); 632349cc55cSDimitry Andric 633e8d8bef9SDimitry Andric collectGlobalVariableInfo(); 634e8d8bef9SDimitry Andric 635e8d8bef9SDimitry Andric // Check if we should emit type record hashes. 636e8d8bef9SDimitry Andric ConstantInt *GH = 637e8d8bef9SDimitry Andric mdconst::extract_or_null<ConstantInt>(M->getModuleFlag("CodeViewGHash")); 638e8d8bef9SDimitry Andric EmitDebugGlobalHashes = GH && !GH->isZero(); 639e8d8bef9SDimitry Andric } 640e8d8bef9SDimitry Andric 6410b57cec5SDimitry Andric void CodeViewDebug::endModule() { 6420b57cec5SDimitry Andric if (!Asm || !MMI->hasDebugInfo()) 6430b57cec5SDimitry Andric return; 6440b57cec5SDimitry Andric 6450b57cec5SDimitry Andric // The COFF .debug$S section consists of several subsections, each starting 6460b57cec5SDimitry Andric // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length 6470b57cec5SDimitry Andric // of the payload followed by the payload itself. The subsections are 4-byte 6480b57cec5SDimitry Andric // aligned. 6490b57cec5SDimitry Andric 6500b57cec5SDimitry Andric // Use the generic .debug$S section, and make a subsection for all the inlined 6510b57cec5SDimitry Andric // subprograms. 6520b57cec5SDimitry Andric switchToDebugSectionForSymbol(nullptr); 6530b57cec5SDimitry Andric 6540b57cec5SDimitry Andric MCSymbol *CompilerInfo = beginCVSubsection(DebugSubsectionKind::Symbols); 6550eae32dcSDimitry Andric emitObjName(); 6560b57cec5SDimitry Andric emitCompilerInformation(); 6570b57cec5SDimitry Andric endCVSubsection(CompilerInfo); 6580b57cec5SDimitry Andric 6590b57cec5SDimitry Andric emitInlineeLinesSubsection(); 6600b57cec5SDimitry Andric 6610b57cec5SDimitry Andric // Emit per-function debug information. 6620b57cec5SDimitry Andric for (auto &P : FnDebugInfo) 6630b57cec5SDimitry Andric if (!P.first->isDeclarationForLinker()) 6640b57cec5SDimitry Andric emitDebugInfoForFunction(P.first, *P.second); 6650b57cec5SDimitry Andric 666e8d8bef9SDimitry Andric // Get types used by globals without emitting anything. 667e8d8bef9SDimitry Andric // This is meant to collect all static const data members so they can be 668e8d8bef9SDimitry Andric // emitted as globals. 669e8d8bef9SDimitry Andric collectDebugInfoForGlobals(); 6700b57cec5SDimitry Andric 6710b57cec5SDimitry Andric // Emit retained types. 6720b57cec5SDimitry Andric emitDebugInfoForRetainedTypes(); 6730b57cec5SDimitry Andric 674e8d8bef9SDimitry Andric // Emit global variable debug information. 675e8d8bef9SDimitry Andric setCurrentSubprogram(nullptr); 676e8d8bef9SDimitry Andric emitDebugInfoForGlobals(); 677e8d8bef9SDimitry Andric 6780b57cec5SDimitry Andric // Switch back to the generic .debug$S section after potentially processing 6790b57cec5SDimitry Andric // comdat symbol sections. 6800b57cec5SDimitry Andric switchToDebugSectionForSymbol(nullptr); 6810b57cec5SDimitry Andric 6820b57cec5SDimitry Andric // Emit UDT records for any types used by global variables. 6830b57cec5SDimitry Andric if (!GlobalUDTs.empty()) { 6840b57cec5SDimitry Andric MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 6850b57cec5SDimitry Andric emitDebugInfoForUDTs(GlobalUDTs); 6860b57cec5SDimitry Andric endCVSubsection(SymbolsEnd); 6870b57cec5SDimitry Andric } 6880b57cec5SDimitry Andric 6890b57cec5SDimitry Andric // This subsection holds a file index to offset in string table table. 6900b57cec5SDimitry Andric OS.AddComment("File index to string table offset subsection"); 6915ffd83dbSDimitry Andric OS.emitCVFileChecksumsDirective(); 6920b57cec5SDimitry Andric 6930b57cec5SDimitry Andric // This subsection holds the string table. 6940b57cec5SDimitry Andric OS.AddComment("String table"); 6955ffd83dbSDimitry Andric OS.emitCVStringTableDirective(); 6960b57cec5SDimitry Andric 6970b57cec5SDimitry Andric // Emit S_BUILDINFO, which points to LF_BUILDINFO. Put this in its own symbol 6980b57cec5SDimitry Andric // subsection in the generic .debug$S section at the end. There is no 6990b57cec5SDimitry Andric // particular reason for this ordering other than to match MSVC. 7000b57cec5SDimitry Andric emitBuildInfo(); 7010b57cec5SDimitry Andric 7020b57cec5SDimitry Andric // Emit type information and hashes last, so that any types we translate while 7030b57cec5SDimitry Andric // emitting function info are included. 7040b57cec5SDimitry Andric emitTypeInformation(); 7050b57cec5SDimitry Andric 7060b57cec5SDimitry Andric if (EmitDebugGlobalHashes) 7070b57cec5SDimitry Andric emitTypeGlobalHashes(); 7080b57cec5SDimitry Andric 7090b57cec5SDimitry Andric clear(); 7100b57cec5SDimitry Andric } 7110b57cec5SDimitry Andric 7120b57cec5SDimitry Andric static void 7130b57cec5SDimitry Andric emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S, 7140b57cec5SDimitry Andric unsigned MaxFixedRecordLength = 0xF00) { 7150b57cec5SDimitry Andric // The maximum CV record length is 0xFF00. Most of the strings we emit appear 7160b57cec5SDimitry Andric // after a fixed length portion of the record. The fixed length portion should 7170b57cec5SDimitry Andric // always be less than 0xF00 (3840) bytes, so truncate the string so that the 7180b57cec5SDimitry Andric // overall record size is less than the maximum allowed. 7190b57cec5SDimitry Andric SmallString<32> NullTerminatedString( 7200b57cec5SDimitry Andric S.take_front(MaxRecordLength - MaxFixedRecordLength - 1)); 7210b57cec5SDimitry Andric NullTerminatedString.push_back('\0'); 7225ffd83dbSDimitry Andric OS.emitBytes(NullTerminatedString); 7230b57cec5SDimitry Andric } 7240b57cec5SDimitry Andric 7250b57cec5SDimitry Andric void CodeViewDebug::emitTypeInformation() { 7260b57cec5SDimitry Andric if (TypeTable.empty()) 7270b57cec5SDimitry Andric return; 7280b57cec5SDimitry Andric 7290b57cec5SDimitry Andric // Start the .debug$T or .debug$P section with 0x4. 7300b57cec5SDimitry Andric OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection()); 7310b57cec5SDimitry Andric emitCodeViewMagicVersion(); 7320b57cec5SDimitry Andric 7330b57cec5SDimitry Andric TypeTableCollection Table(TypeTable.records()); 7340b57cec5SDimitry Andric TypeVisitorCallbackPipeline Pipeline; 7350b57cec5SDimitry Andric 7360b57cec5SDimitry Andric // To emit type record using Codeview MCStreamer adapter 7378bcb0991SDimitry Andric CVMCAdapter CVMCOS(OS, Table); 7380b57cec5SDimitry Andric TypeRecordMapping typeMapping(CVMCOS); 7390b57cec5SDimitry Andric Pipeline.addCallbackToPipeline(typeMapping); 7400b57cec5SDimitry Andric 7410b57cec5SDimitry Andric Optional<TypeIndex> B = Table.getFirst(); 7420b57cec5SDimitry Andric while (B) { 7430b57cec5SDimitry Andric // This will fail if the record data is invalid. 7440b57cec5SDimitry Andric CVType Record = Table.getType(*B); 7450b57cec5SDimitry Andric 7460b57cec5SDimitry Andric Error E = codeview::visitTypeRecord(Record, *B, Pipeline); 7470b57cec5SDimitry Andric 7480b57cec5SDimitry Andric if (E) { 7490b57cec5SDimitry Andric logAllUnhandledErrors(std::move(E), errs(), "error: "); 7500b57cec5SDimitry Andric llvm_unreachable("produced malformed type record"); 7510b57cec5SDimitry Andric } 7520b57cec5SDimitry Andric 7530b57cec5SDimitry Andric B = Table.getNext(*B); 7540b57cec5SDimitry Andric } 7550b57cec5SDimitry Andric } 7560b57cec5SDimitry Andric 7570b57cec5SDimitry Andric void CodeViewDebug::emitTypeGlobalHashes() { 7580b57cec5SDimitry Andric if (TypeTable.empty()) 7590b57cec5SDimitry Andric return; 7600b57cec5SDimitry Andric 7610b57cec5SDimitry Andric // Start the .debug$H section with the version and hash algorithm, currently 7620b57cec5SDimitry Andric // hardcoded to version 0, SHA1. 7630b57cec5SDimitry Andric OS.SwitchSection(Asm->getObjFileLowering().getCOFFGlobalTypeHashesSection()); 7640b57cec5SDimitry Andric 7655ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 7660b57cec5SDimitry Andric OS.AddComment("Magic"); 7675ffd83dbSDimitry Andric OS.emitInt32(COFF::DEBUG_HASHES_SECTION_MAGIC); 7680b57cec5SDimitry Andric OS.AddComment("Section Version"); 7695ffd83dbSDimitry Andric OS.emitInt16(0); 7700b57cec5SDimitry Andric OS.AddComment("Hash Algorithm"); 7715ffd83dbSDimitry Andric OS.emitInt16(uint16_t(GlobalTypeHashAlg::SHA1_8)); 7720b57cec5SDimitry Andric 7730b57cec5SDimitry Andric TypeIndex TI(TypeIndex::FirstNonSimpleIndex); 7740b57cec5SDimitry Andric for (const auto &GHR : TypeTable.hashes()) { 7750b57cec5SDimitry Andric if (OS.isVerboseAsm()) { 7760b57cec5SDimitry Andric // Emit an EOL-comment describing which TypeIndex this hash corresponds 7770b57cec5SDimitry Andric // to, as well as the stringified SHA1 hash. 7780b57cec5SDimitry Andric SmallString<32> Comment; 7790b57cec5SDimitry Andric raw_svector_ostream CommentOS(Comment); 7800b57cec5SDimitry Andric CommentOS << formatv("{0:X+} [{1}]", TI.getIndex(), GHR); 7810b57cec5SDimitry Andric OS.AddComment(Comment); 7820b57cec5SDimitry Andric ++TI; 7830b57cec5SDimitry Andric } 7840b57cec5SDimitry Andric assert(GHR.Hash.size() == 8); 7850b57cec5SDimitry Andric StringRef S(reinterpret_cast<const char *>(GHR.Hash.data()), 7860b57cec5SDimitry Andric GHR.Hash.size()); 7875ffd83dbSDimitry Andric OS.emitBinaryData(S); 7880b57cec5SDimitry Andric } 7890b57cec5SDimitry Andric } 7900b57cec5SDimitry Andric 7910eae32dcSDimitry Andric void CodeViewDebug::emitObjName() { 7920eae32dcSDimitry Andric MCSymbol *CompilerEnd = beginSymbolRecord(SymbolKind::S_OBJNAME); 7930eae32dcSDimitry Andric 7940eae32dcSDimitry Andric StringRef PathRef(Asm->TM.Options.ObjectFilenameForDebug); 7950eae32dcSDimitry Andric llvm::SmallString<256> PathStore(PathRef); 7960eae32dcSDimitry Andric 7970eae32dcSDimitry Andric if (PathRef.empty() || PathRef == "-") { 7980eae32dcSDimitry Andric // Don't emit the filename if we're writing to stdout or to /dev/null. 7990eae32dcSDimitry Andric PathRef = {}; 8000eae32dcSDimitry Andric } else { 8010eae32dcSDimitry Andric llvm::sys::path::remove_dots(PathStore, /*remove_dot_dot=*/true); 8020eae32dcSDimitry Andric PathRef = PathStore; 8030eae32dcSDimitry Andric } 8040eae32dcSDimitry Andric 8050eae32dcSDimitry Andric OS.AddComment("Signature"); 8060eae32dcSDimitry Andric OS.emitIntValue(0, 4); 8070eae32dcSDimitry Andric 8080eae32dcSDimitry Andric OS.AddComment("Object name"); 8090eae32dcSDimitry Andric emitNullTerminatedSymbolName(OS, PathRef); 8100eae32dcSDimitry Andric 8110eae32dcSDimitry Andric endSymbolRecord(CompilerEnd); 8120eae32dcSDimitry Andric } 8130eae32dcSDimitry Andric 8140b57cec5SDimitry Andric namespace { 8150b57cec5SDimitry Andric struct Version { 8160b57cec5SDimitry Andric int Part[4]; 8170b57cec5SDimitry Andric }; 8180b57cec5SDimitry Andric } // end anonymous namespace 8190b57cec5SDimitry Andric 8200b57cec5SDimitry Andric // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out 8210b57cec5SDimitry Andric // the version number. 8220b57cec5SDimitry Andric static Version parseVersion(StringRef Name) { 8230b57cec5SDimitry Andric Version V = {{0}}; 8240b57cec5SDimitry Andric int N = 0; 8250b57cec5SDimitry Andric for (const char C : Name) { 8260b57cec5SDimitry Andric if (isdigit(C)) { 8270b57cec5SDimitry Andric V.Part[N] *= 10; 8280b57cec5SDimitry Andric V.Part[N] += C - '0'; 8290b57cec5SDimitry Andric } else if (C == '.') { 8300b57cec5SDimitry Andric ++N; 8310b57cec5SDimitry Andric if (N >= 4) 8320b57cec5SDimitry Andric return V; 8330b57cec5SDimitry Andric } else if (N > 0) 8340b57cec5SDimitry Andric return V; 8350b57cec5SDimitry Andric } 8360b57cec5SDimitry Andric return V; 8370b57cec5SDimitry Andric } 8380b57cec5SDimitry Andric 8390b57cec5SDimitry Andric void CodeViewDebug::emitCompilerInformation() { 8400b57cec5SDimitry Andric MCSymbol *CompilerEnd = beginSymbolRecord(SymbolKind::S_COMPILE3); 8410b57cec5SDimitry Andric uint32_t Flags = 0; 8420b57cec5SDimitry Andric 8430b57cec5SDimitry Andric // The low byte of the flags indicates the source language. 844349cc55cSDimitry Andric Flags = CurrentSourceLanguage; 8450b57cec5SDimitry Andric // TODO: Figure out which other flags need to be set. 846fe6060f1SDimitry Andric if (MMI->getModule()->getProfileSummary(/*IsCS*/ false) != nullptr) { 847fe6060f1SDimitry Andric Flags |= static_cast<uint32_t>(CompileSym3Flags::PGO); 848fe6060f1SDimitry Andric } 84904eeddc0SDimitry Andric using ArchType = llvm::Triple::ArchType; 85004eeddc0SDimitry Andric ArchType Arch = Triple(MMI->getModule()->getTargetTriple()).getArch(); 85104eeddc0SDimitry Andric if (Asm->TM.Options.Hotpatch || Arch == ArchType::thumb || 85204eeddc0SDimitry Andric Arch == ArchType::aarch64) { 85304eeddc0SDimitry Andric Flags |= static_cast<uint32_t>(CompileSym3Flags::HotPatch); 85404eeddc0SDimitry Andric } 8550b57cec5SDimitry Andric 8560b57cec5SDimitry Andric OS.AddComment("Flags and language"); 8575ffd83dbSDimitry Andric OS.emitInt32(Flags); 8580b57cec5SDimitry Andric 8590b57cec5SDimitry Andric OS.AddComment("CPUType"); 8605ffd83dbSDimitry Andric OS.emitInt16(static_cast<uint64_t>(TheCPU)); 8610b57cec5SDimitry Andric 862349cc55cSDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 863349cc55cSDimitry Andric const MDNode *Node = *CUs->operands().begin(); 864349cc55cSDimitry Andric const auto *CU = cast<DICompileUnit>(Node); 865349cc55cSDimitry Andric 8660b57cec5SDimitry Andric StringRef CompilerVersion = CU->getProducer(); 8670b57cec5SDimitry Andric Version FrontVer = parseVersion(CompilerVersion); 8680b57cec5SDimitry Andric OS.AddComment("Frontend version"); 86904eeddc0SDimitry Andric for (int N : FrontVer.Part) { 87004eeddc0SDimitry Andric N = std::min<int>(N, std::numeric_limits<uint16_t>::max()); 871fe6060f1SDimitry Andric OS.emitInt16(N); 87204eeddc0SDimitry Andric } 8730b57cec5SDimitry Andric 8740b57cec5SDimitry Andric // Some Microsoft tools, like Binscope, expect a backend version number of at 8750b57cec5SDimitry Andric // least 8.something, so we'll coerce the LLVM version into a form that 8760b57cec5SDimitry Andric // guarantees it'll be big enough without really lying about the version. 8770b57cec5SDimitry Andric int Major = 1000 * LLVM_VERSION_MAJOR + 8780b57cec5SDimitry Andric 10 * LLVM_VERSION_MINOR + 8790b57cec5SDimitry Andric LLVM_VERSION_PATCH; 8800b57cec5SDimitry Andric // Clamp it for builds that use unusually large version numbers. 8810b57cec5SDimitry Andric Major = std::min<int>(Major, std::numeric_limits<uint16_t>::max()); 8820b57cec5SDimitry Andric Version BackVer = {{ Major, 0, 0, 0 }}; 8830b57cec5SDimitry Andric OS.AddComment("Backend version"); 884fe6060f1SDimitry Andric for (int N : BackVer.Part) 885fe6060f1SDimitry Andric OS.emitInt16(N); 8860b57cec5SDimitry Andric 8870b57cec5SDimitry Andric OS.AddComment("Null-terminated compiler version string"); 8880b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, CompilerVersion); 8890b57cec5SDimitry Andric 8900b57cec5SDimitry Andric endSymbolRecord(CompilerEnd); 8910b57cec5SDimitry Andric } 8920b57cec5SDimitry Andric 8930b57cec5SDimitry Andric static TypeIndex getStringIdTypeIdx(GlobalTypeTableBuilder &TypeTable, 8940b57cec5SDimitry Andric StringRef S) { 8950b57cec5SDimitry Andric StringIdRecord SIR(TypeIndex(0x0), S); 8960b57cec5SDimitry Andric return TypeTable.writeLeafType(SIR); 8970b57cec5SDimitry Andric } 8980b57cec5SDimitry Andric 89904eeddc0SDimitry Andric static std::string flattenCommandLine(ArrayRef<std::string> Args, 90004eeddc0SDimitry Andric StringRef MainFilename) { 90104eeddc0SDimitry Andric std::string FlatCmdLine; 90204eeddc0SDimitry Andric raw_string_ostream OS(FlatCmdLine); 90304eeddc0SDimitry Andric bool PrintedOneArg = false; 90404eeddc0SDimitry Andric if (!StringRef(Args[0]).contains("-cc1")) { 90504eeddc0SDimitry Andric llvm::sys::printArg(OS, "-cc1", /*Quote=*/true); 90604eeddc0SDimitry Andric PrintedOneArg = true; 90704eeddc0SDimitry Andric } 90804eeddc0SDimitry Andric for (unsigned i = 0; i < Args.size(); i++) { 90904eeddc0SDimitry Andric StringRef Arg = Args[i]; 91004eeddc0SDimitry Andric if (Arg.empty()) 91104eeddc0SDimitry Andric continue; 91204eeddc0SDimitry Andric if (Arg == "-main-file-name" || Arg == "-o") { 91304eeddc0SDimitry Andric i++; // Skip this argument and next one. 91404eeddc0SDimitry Andric continue; 91504eeddc0SDimitry Andric } 91604eeddc0SDimitry Andric if (Arg.startswith("-object-file-name") || Arg == MainFilename) 91704eeddc0SDimitry Andric continue; 91804eeddc0SDimitry Andric if (PrintedOneArg) 91904eeddc0SDimitry Andric OS << " "; 92004eeddc0SDimitry Andric llvm::sys::printArg(OS, Arg, /*Quote=*/true); 92104eeddc0SDimitry Andric PrintedOneArg = true; 92204eeddc0SDimitry Andric } 92304eeddc0SDimitry Andric OS.flush(); 92404eeddc0SDimitry Andric return FlatCmdLine; 92504eeddc0SDimitry Andric } 92604eeddc0SDimitry Andric 9270b57cec5SDimitry Andric void CodeViewDebug::emitBuildInfo() { 9280b57cec5SDimitry Andric // First, make LF_BUILDINFO. It's a sequence of strings with various bits of 9290b57cec5SDimitry Andric // build info. The known prefix is: 9300b57cec5SDimitry Andric // - Absolute path of current directory 9310b57cec5SDimitry Andric // - Compiler path 9320b57cec5SDimitry Andric // - Main source file path, relative to CWD or absolute 9330b57cec5SDimitry Andric // - Type server PDB file 9340b57cec5SDimitry Andric // - Canonical compiler command line 9350b57cec5SDimitry Andric // If frontend and backend compilation are separated (think llc or LTO), it's 9360b57cec5SDimitry Andric // not clear if the compiler path should refer to the executable for the 9370b57cec5SDimitry Andric // frontend or the backend. Leave it blank for now. 9380b57cec5SDimitry Andric TypeIndex BuildInfoArgs[BuildInfoRecord::MaxArgs] = {}; 9390b57cec5SDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 9400b57cec5SDimitry Andric const MDNode *Node = *CUs->operands().begin(); // FIXME: Multiple CUs. 9410b57cec5SDimitry Andric const auto *CU = cast<DICompileUnit>(Node); 9420b57cec5SDimitry Andric const DIFile *MainSourceFile = CU->getFile(); 9430b57cec5SDimitry Andric BuildInfoArgs[BuildInfoRecord::CurrentDirectory] = 9440b57cec5SDimitry Andric getStringIdTypeIdx(TypeTable, MainSourceFile->getDirectory()); 9450b57cec5SDimitry Andric BuildInfoArgs[BuildInfoRecord::SourceFile] = 9460b57cec5SDimitry Andric getStringIdTypeIdx(TypeTable, MainSourceFile->getFilename()); 94704eeddc0SDimitry Andric // FIXME: PDB is intentionally blank unless we implement /Zi type servers. 94804eeddc0SDimitry Andric BuildInfoArgs[BuildInfoRecord::TypeServerPDB] = 94904eeddc0SDimitry Andric getStringIdTypeIdx(TypeTable, ""); 95004eeddc0SDimitry Andric if (Asm->TM.Options.MCOptions.Argv0 != nullptr) { 95104eeddc0SDimitry Andric BuildInfoArgs[BuildInfoRecord::BuildTool] = 95204eeddc0SDimitry Andric getStringIdTypeIdx(TypeTable, Asm->TM.Options.MCOptions.Argv0); 95304eeddc0SDimitry Andric BuildInfoArgs[BuildInfoRecord::CommandLine] = getStringIdTypeIdx( 95404eeddc0SDimitry Andric TypeTable, flattenCommandLine(Asm->TM.Options.MCOptions.CommandLineArgs, 95504eeddc0SDimitry Andric MainSourceFile->getFilename())); 95604eeddc0SDimitry Andric } 9570b57cec5SDimitry Andric BuildInfoRecord BIR(BuildInfoArgs); 9580b57cec5SDimitry Andric TypeIndex BuildInfoIndex = TypeTable.writeLeafType(BIR); 9590b57cec5SDimitry Andric 9600b57cec5SDimitry Andric // Make a new .debug$S subsection for the S_BUILDINFO record, which points 9610b57cec5SDimitry Andric // from the module symbols into the type stream. 9620b57cec5SDimitry Andric MCSymbol *BISubsecEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 9630b57cec5SDimitry Andric MCSymbol *BIEnd = beginSymbolRecord(SymbolKind::S_BUILDINFO); 9640b57cec5SDimitry Andric OS.AddComment("LF_BUILDINFO index"); 9655ffd83dbSDimitry Andric OS.emitInt32(BuildInfoIndex.getIndex()); 9660b57cec5SDimitry Andric endSymbolRecord(BIEnd); 9670b57cec5SDimitry Andric endCVSubsection(BISubsecEnd); 9680b57cec5SDimitry Andric } 9690b57cec5SDimitry Andric 9700b57cec5SDimitry Andric void CodeViewDebug::emitInlineeLinesSubsection() { 9710b57cec5SDimitry Andric if (InlinedSubprograms.empty()) 9720b57cec5SDimitry Andric return; 9730b57cec5SDimitry Andric 9740b57cec5SDimitry Andric OS.AddComment("Inlinee lines subsection"); 9750b57cec5SDimitry Andric MCSymbol *InlineEnd = beginCVSubsection(DebugSubsectionKind::InlineeLines); 9760b57cec5SDimitry Andric 9770b57cec5SDimitry Andric // We emit the checksum info for files. This is used by debuggers to 9780b57cec5SDimitry Andric // determine if a pdb matches the source before loading it. Visual Studio, 9790b57cec5SDimitry Andric // for instance, will display a warning that the breakpoints are not valid if 9800b57cec5SDimitry Andric // the pdb does not match the source. 9810b57cec5SDimitry Andric OS.AddComment("Inlinee lines signature"); 9825ffd83dbSDimitry Andric OS.emitInt32(unsigned(InlineeLinesSignature::Normal)); 9830b57cec5SDimitry Andric 9840b57cec5SDimitry Andric for (const DISubprogram *SP : InlinedSubprograms) { 9850b57cec5SDimitry Andric assert(TypeIndices.count({SP, nullptr})); 9860b57cec5SDimitry Andric TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}]; 9870b57cec5SDimitry Andric 9880b57cec5SDimitry Andric OS.AddBlankLine(); 9890b57cec5SDimitry Andric unsigned FileId = maybeRecordFile(SP->getFile()); 9900b57cec5SDimitry Andric OS.AddComment("Inlined function " + SP->getName() + " starts at " + 9910b57cec5SDimitry Andric SP->getFilename() + Twine(':') + Twine(SP->getLine())); 9920b57cec5SDimitry Andric OS.AddBlankLine(); 9930b57cec5SDimitry Andric OS.AddComment("Type index of inlined function"); 9945ffd83dbSDimitry Andric OS.emitInt32(InlineeIdx.getIndex()); 9950b57cec5SDimitry Andric OS.AddComment("Offset into filechecksum table"); 9965ffd83dbSDimitry Andric OS.emitCVFileChecksumOffsetDirective(FileId); 9970b57cec5SDimitry Andric OS.AddComment("Starting line number"); 9985ffd83dbSDimitry Andric OS.emitInt32(SP->getLine()); 9990b57cec5SDimitry Andric } 10000b57cec5SDimitry Andric 10010b57cec5SDimitry Andric endCVSubsection(InlineEnd); 10020b57cec5SDimitry Andric } 10030b57cec5SDimitry Andric 10040b57cec5SDimitry Andric void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI, 10050b57cec5SDimitry Andric const DILocation *InlinedAt, 10060b57cec5SDimitry Andric const InlineSite &Site) { 10070b57cec5SDimitry Andric assert(TypeIndices.count({Site.Inlinee, nullptr})); 10080b57cec5SDimitry Andric TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}]; 10090b57cec5SDimitry Andric 10100b57cec5SDimitry Andric // SymbolRecord 10110b57cec5SDimitry Andric MCSymbol *InlineEnd = beginSymbolRecord(SymbolKind::S_INLINESITE); 10120b57cec5SDimitry Andric 10130b57cec5SDimitry Andric OS.AddComment("PtrParent"); 10145ffd83dbSDimitry Andric OS.emitInt32(0); 10150b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 10165ffd83dbSDimitry Andric OS.emitInt32(0); 10170b57cec5SDimitry Andric OS.AddComment("Inlinee type index"); 10185ffd83dbSDimitry Andric OS.emitInt32(InlineeIdx.getIndex()); 10190b57cec5SDimitry Andric 10200b57cec5SDimitry Andric unsigned FileId = maybeRecordFile(Site.Inlinee->getFile()); 10210b57cec5SDimitry Andric unsigned StartLineNum = Site.Inlinee->getLine(); 10220b57cec5SDimitry Andric 10235ffd83dbSDimitry Andric OS.emitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum, 10240b57cec5SDimitry Andric FI.Begin, FI.End); 10250b57cec5SDimitry Andric 10260b57cec5SDimitry Andric endSymbolRecord(InlineEnd); 10270b57cec5SDimitry Andric 10280b57cec5SDimitry Andric emitLocalVariableList(FI, Site.InlinedLocals); 10290b57cec5SDimitry Andric 10300b57cec5SDimitry Andric // Recurse on child inlined call sites before closing the scope. 10310b57cec5SDimitry Andric for (const DILocation *ChildSite : Site.ChildSites) { 10320b57cec5SDimitry Andric auto I = FI.InlineSites.find(ChildSite); 10330b57cec5SDimitry Andric assert(I != FI.InlineSites.end() && 10340b57cec5SDimitry Andric "child site not in function inline site map"); 10350b57cec5SDimitry Andric emitInlinedCallSite(FI, ChildSite, I->second); 10360b57cec5SDimitry Andric } 10370b57cec5SDimitry Andric 10380b57cec5SDimitry Andric // Close the scope. 10390b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_INLINESITE_END); 10400b57cec5SDimitry Andric } 10410b57cec5SDimitry Andric 10420b57cec5SDimitry Andric void CodeViewDebug::switchToDebugSectionForSymbol(const MCSymbol *GVSym) { 10430b57cec5SDimitry Andric // If we have a symbol, it may be in a section that is COMDAT. If so, find the 10440b57cec5SDimitry Andric // comdat key. A section may be comdat because of -ffunction-sections or 10450b57cec5SDimitry Andric // because it is comdat in the IR. 10460b57cec5SDimitry Andric MCSectionCOFF *GVSec = 10470b57cec5SDimitry Andric GVSym ? dyn_cast<MCSectionCOFF>(&GVSym->getSection()) : nullptr; 10480b57cec5SDimitry Andric const MCSymbol *KeySym = GVSec ? GVSec->getCOMDATSymbol() : nullptr; 10490b57cec5SDimitry Andric 10500b57cec5SDimitry Andric MCSectionCOFF *DebugSec = cast<MCSectionCOFF>( 10510b57cec5SDimitry Andric Asm->getObjFileLowering().getCOFFDebugSymbolsSection()); 10520b57cec5SDimitry Andric DebugSec = OS.getContext().getAssociativeCOFFSection(DebugSec, KeySym); 10530b57cec5SDimitry Andric 10540b57cec5SDimitry Andric OS.SwitchSection(DebugSec); 10550b57cec5SDimitry Andric 10560b57cec5SDimitry Andric // Emit the magic version number if this is the first time we've switched to 10570b57cec5SDimitry Andric // this section. 10580b57cec5SDimitry Andric if (ComdatDebugSections.insert(DebugSec).second) 10590b57cec5SDimitry Andric emitCodeViewMagicVersion(); 10600b57cec5SDimitry Andric } 10610b57cec5SDimitry Andric 10620b57cec5SDimitry Andric // Emit an S_THUNK32/S_END symbol pair for a thunk routine. 10630b57cec5SDimitry Andric // The only supported thunk ordinal is currently the standard type. 10640b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForThunk(const Function *GV, 10650b57cec5SDimitry Andric FunctionInfo &FI, 10660b57cec5SDimitry Andric const MCSymbol *Fn) { 10675ffd83dbSDimitry Andric std::string FuncName = 10685ffd83dbSDimitry Andric std::string(GlobalValue::dropLLVMManglingEscape(GV->getName())); 10690b57cec5SDimitry Andric const ThunkOrdinal ordinal = ThunkOrdinal::Standard; // Only supported kind. 10700b57cec5SDimitry Andric 10710b57cec5SDimitry Andric OS.AddComment("Symbol subsection for " + Twine(FuncName)); 10720b57cec5SDimitry Andric MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 10730b57cec5SDimitry Andric 10740b57cec5SDimitry Andric // Emit S_THUNK32 10750b57cec5SDimitry Andric MCSymbol *ThunkRecordEnd = beginSymbolRecord(SymbolKind::S_THUNK32); 10760b57cec5SDimitry Andric OS.AddComment("PtrParent"); 10775ffd83dbSDimitry Andric OS.emitInt32(0); 10780b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 10795ffd83dbSDimitry Andric OS.emitInt32(0); 10800b57cec5SDimitry Andric OS.AddComment("PtrNext"); 10815ffd83dbSDimitry Andric OS.emitInt32(0); 10820b57cec5SDimitry Andric OS.AddComment("Thunk section relative address"); 10830b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Fn, /*Offset=*/0); 10840b57cec5SDimitry Andric OS.AddComment("Thunk section index"); 10850b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(Fn); 10860b57cec5SDimitry Andric OS.AddComment("Code size"); 10870b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(FI.End, Fn, 2); 10880b57cec5SDimitry Andric OS.AddComment("Ordinal"); 10895ffd83dbSDimitry Andric OS.emitInt8(unsigned(ordinal)); 10900b57cec5SDimitry Andric OS.AddComment("Function name"); 10910b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, FuncName); 10920b57cec5SDimitry Andric // Additional fields specific to the thunk ordinal would go here. 10930b57cec5SDimitry Andric endSymbolRecord(ThunkRecordEnd); 10940b57cec5SDimitry Andric 10950b57cec5SDimitry Andric // Local variables/inlined routines are purposely omitted here. The point of 10960b57cec5SDimitry Andric // marking this as a thunk is so Visual Studio will NOT stop in this routine. 10970b57cec5SDimitry Andric 10980b57cec5SDimitry Andric // Emit S_PROC_ID_END 10990b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_PROC_ID_END); 11000b57cec5SDimitry Andric 11010b57cec5SDimitry Andric endCVSubsection(SymbolsEnd); 11020b57cec5SDimitry Andric } 11030b57cec5SDimitry Andric 11040b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForFunction(const Function *GV, 11050b57cec5SDimitry Andric FunctionInfo &FI) { 11060b57cec5SDimitry Andric // For each function there is a separate subsection which holds the PC to 11070b57cec5SDimitry Andric // file:line table. 11080b57cec5SDimitry Andric const MCSymbol *Fn = Asm->getSymbol(GV); 11090b57cec5SDimitry Andric assert(Fn); 11100b57cec5SDimitry Andric 11110b57cec5SDimitry Andric // Switch to the to a comdat section, if appropriate. 11120b57cec5SDimitry Andric switchToDebugSectionForSymbol(Fn); 11130b57cec5SDimitry Andric 11140b57cec5SDimitry Andric std::string FuncName; 11150b57cec5SDimitry Andric auto *SP = GV->getSubprogram(); 11160b57cec5SDimitry Andric assert(SP); 11170b57cec5SDimitry Andric setCurrentSubprogram(SP); 11180b57cec5SDimitry Andric 11190b57cec5SDimitry Andric if (SP->isThunk()) { 11200b57cec5SDimitry Andric emitDebugInfoForThunk(GV, FI, Fn); 11210b57cec5SDimitry Andric return; 11220b57cec5SDimitry Andric } 11230b57cec5SDimitry Andric 11240b57cec5SDimitry Andric // If we have a display name, build the fully qualified name by walking the 11250b57cec5SDimitry Andric // chain of scopes. 11260b57cec5SDimitry Andric if (!SP->getName().empty()) 11270b57cec5SDimitry Andric FuncName = getFullyQualifiedName(SP->getScope(), SP->getName()); 11280b57cec5SDimitry Andric 11290b57cec5SDimitry Andric // If our DISubprogram name is empty, use the mangled name. 11300b57cec5SDimitry Andric if (FuncName.empty()) 11315ffd83dbSDimitry Andric FuncName = std::string(GlobalValue::dropLLVMManglingEscape(GV->getName())); 11320b57cec5SDimitry Andric 11330b57cec5SDimitry Andric // Emit FPO data, but only on 32-bit x86. No other platforms use it. 11340b57cec5SDimitry Andric if (Triple(MMI->getModule()->getTargetTriple()).getArch() == Triple::x86) 11350b57cec5SDimitry Andric OS.EmitCVFPOData(Fn); 11360b57cec5SDimitry Andric 11370b57cec5SDimitry Andric // Emit a symbol subsection, required by VS2012+ to find function boundaries. 11380b57cec5SDimitry Andric OS.AddComment("Symbol subsection for " + Twine(FuncName)); 11390b57cec5SDimitry Andric MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 11400b57cec5SDimitry Andric { 11410b57cec5SDimitry Andric SymbolKind ProcKind = GV->hasLocalLinkage() ? SymbolKind::S_LPROC32_ID 11420b57cec5SDimitry Andric : SymbolKind::S_GPROC32_ID; 11430b57cec5SDimitry Andric MCSymbol *ProcRecordEnd = beginSymbolRecord(ProcKind); 11440b57cec5SDimitry Andric 11450b57cec5SDimitry Andric // These fields are filled in by tools like CVPACK which run after the fact. 11460b57cec5SDimitry Andric OS.AddComment("PtrParent"); 11475ffd83dbSDimitry Andric OS.emitInt32(0); 11480b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 11495ffd83dbSDimitry Andric OS.emitInt32(0); 11500b57cec5SDimitry Andric OS.AddComment("PtrNext"); 11515ffd83dbSDimitry Andric OS.emitInt32(0); 11520b57cec5SDimitry Andric // This is the important bit that tells the debugger where the function 11530b57cec5SDimitry Andric // code is located and what's its size: 11540b57cec5SDimitry Andric OS.AddComment("Code size"); 11550b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4); 11560b57cec5SDimitry Andric OS.AddComment("Offset after prologue"); 11575ffd83dbSDimitry Andric OS.emitInt32(0); 11580b57cec5SDimitry Andric OS.AddComment("Offset before epilogue"); 11595ffd83dbSDimitry Andric OS.emitInt32(0); 11600b57cec5SDimitry Andric OS.AddComment("Function type index"); 11615ffd83dbSDimitry Andric OS.emitInt32(getFuncIdForSubprogram(GV->getSubprogram()).getIndex()); 11620b57cec5SDimitry Andric OS.AddComment("Function section relative address"); 11630b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Fn, /*Offset=*/0); 11640b57cec5SDimitry Andric OS.AddComment("Function section index"); 11650b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(Fn); 11660b57cec5SDimitry Andric OS.AddComment("Flags"); 11675ffd83dbSDimitry Andric OS.emitInt8(0); 11680b57cec5SDimitry Andric // Emit the function display name as a null-terminated string. 11690b57cec5SDimitry Andric OS.AddComment("Function name"); 11700b57cec5SDimitry Andric // Truncate the name so we won't overflow the record length field. 11710b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, FuncName); 11720b57cec5SDimitry Andric endSymbolRecord(ProcRecordEnd); 11730b57cec5SDimitry Andric 11740b57cec5SDimitry Andric MCSymbol *FrameProcEnd = beginSymbolRecord(SymbolKind::S_FRAMEPROC); 11750b57cec5SDimitry Andric // Subtract out the CSR size since MSVC excludes that and we include it. 11760b57cec5SDimitry Andric OS.AddComment("FrameSize"); 11775ffd83dbSDimitry Andric OS.emitInt32(FI.FrameSize - FI.CSRSize); 11780b57cec5SDimitry Andric OS.AddComment("Padding"); 11795ffd83dbSDimitry Andric OS.emitInt32(0); 11800b57cec5SDimitry Andric OS.AddComment("Offset of padding"); 11815ffd83dbSDimitry Andric OS.emitInt32(0); 11820b57cec5SDimitry Andric OS.AddComment("Bytes of callee saved registers"); 11835ffd83dbSDimitry Andric OS.emitInt32(FI.CSRSize); 11840b57cec5SDimitry Andric OS.AddComment("Exception handler offset"); 11855ffd83dbSDimitry Andric OS.emitInt32(0); 11860b57cec5SDimitry Andric OS.AddComment("Exception handler section"); 11875ffd83dbSDimitry Andric OS.emitInt16(0); 11880b57cec5SDimitry Andric OS.AddComment("Flags (defines frame register)"); 11895ffd83dbSDimitry Andric OS.emitInt32(uint32_t(FI.FrameProcOpts)); 11900b57cec5SDimitry Andric endSymbolRecord(FrameProcEnd); 11910b57cec5SDimitry Andric 11920b57cec5SDimitry Andric emitLocalVariableList(FI, FI.Locals); 11930b57cec5SDimitry Andric emitGlobalVariableList(FI.Globals); 11940b57cec5SDimitry Andric emitLexicalBlockList(FI.ChildBlocks, FI); 11950b57cec5SDimitry Andric 11960b57cec5SDimitry Andric // Emit inlined call site information. Only emit functions inlined directly 11970b57cec5SDimitry Andric // into the parent function. We'll emit the other sites recursively as part 11980b57cec5SDimitry Andric // of their parent inline site. 11990b57cec5SDimitry Andric for (const DILocation *InlinedAt : FI.ChildSites) { 12000b57cec5SDimitry Andric auto I = FI.InlineSites.find(InlinedAt); 12010b57cec5SDimitry Andric assert(I != FI.InlineSites.end() && 12020b57cec5SDimitry Andric "child site not in function inline site map"); 12030b57cec5SDimitry Andric emitInlinedCallSite(FI, InlinedAt, I->second); 12040b57cec5SDimitry Andric } 12050b57cec5SDimitry Andric 12060b57cec5SDimitry Andric for (auto Annot : FI.Annotations) { 12070b57cec5SDimitry Andric MCSymbol *Label = Annot.first; 12080b57cec5SDimitry Andric MDTuple *Strs = cast<MDTuple>(Annot.second); 12090b57cec5SDimitry Andric MCSymbol *AnnotEnd = beginSymbolRecord(SymbolKind::S_ANNOTATION); 12100b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Label, /*Offset=*/0); 12110b57cec5SDimitry Andric // FIXME: Make sure we don't overflow the max record size. 12120b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(Label); 12135ffd83dbSDimitry Andric OS.emitInt16(Strs->getNumOperands()); 12140b57cec5SDimitry Andric for (Metadata *MD : Strs->operands()) { 12150b57cec5SDimitry Andric // MDStrings are null terminated, so we can do EmitBytes and get the 12160b57cec5SDimitry Andric // nice .asciz directive. 12170b57cec5SDimitry Andric StringRef Str = cast<MDString>(MD)->getString(); 12180b57cec5SDimitry Andric assert(Str.data()[Str.size()] == '\0' && "non-nullterminated MDString"); 12195ffd83dbSDimitry Andric OS.emitBytes(StringRef(Str.data(), Str.size() + 1)); 12200b57cec5SDimitry Andric } 12210b57cec5SDimitry Andric endSymbolRecord(AnnotEnd); 12220b57cec5SDimitry Andric } 12230b57cec5SDimitry Andric 12240b57cec5SDimitry Andric for (auto HeapAllocSite : FI.HeapAllocSites) { 1225480093f4SDimitry Andric const MCSymbol *BeginLabel = std::get<0>(HeapAllocSite); 1226480093f4SDimitry Andric const MCSymbol *EndLabel = std::get<1>(HeapAllocSite); 1227c14a5a88SDimitry Andric const DIType *DITy = std::get<2>(HeapAllocSite); 12280b57cec5SDimitry Andric MCSymbol *HeapAllocEnd = beginSymbolRecord(SymbolKind::S_HEAPALLOCSITE); 12290b57cec5SDimitry Andric OS.AddComment("Call site offset"); 12300b57cec5SDimitry Andric OS.EmitCOFFSecRel32(BeginLabel, /*Offset=*/0); 12310b57cec5SDimitry Andric OS.AddComment("Call site section index"); 12320b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(BeginLabel); 12330b57cec5SDimitry Andric OS.AddComment("Call instruction length"); 12340b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 2); 12350b57cec5SDimitry Andric OS.AddComment("Type index"); 12365ffd83dbSDimitry Andric OS.emitInt32(getCompleteTypeIndex(DITy).getIndex()); 12370b57cec5SDimitry Andric endSymbolRecord(HeapAllocEnd); 12380b57cec5SDimitry Andric } 12390b57cec5SDimitry Andric 12400b57cec5SDimitry Andric if (SP != nullptr) 12410b57cec5SDimitry Andric emitDebugInfoForUDTs(LocalUDTs); 12420b57cec5SDimitry Andric 12430b57cec5SDimitry Andric // We're done with this function. 12440b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_PROC_ID_END); 12450b57cec5SDimitry Andric } 12460b57cec5SDimitry Andric endCVSubsection(SymbolsEnd); 12470b57cec5SDimitry Andric 12480b57cec5SDimitry Andric // We have an assembler directive that takes care of the whole line table. 12495ffd83dbSDimitry Andric OS.emitCVLinetableDirective(FI.FuncId, Fn, FI.End); 12500b57cec5SDimitry Andric } 12510b57cec5SDimitry Andric 12520b57cec5SDimitry Andric CodeViewDebug::LocalVarDefRange 12530b57cec5SDimitry Andric CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) { 12540b57cec5SDimitry Andric LocalVarDefRange DR; 12550b57cec5SDimitry Andric DR.InMemory = -1; 12560b57cec5SDimitry Andric DR.DataOffset = Offset; 12570b57cec5SDimitry Andric assert(DR.DataOffset == Offset && "truncation"); 12580b57cec5SDimitry Andric DR.IsSubfield = 0; 12590b57cec5SDimitry Andric DR.StructOffset = 0; 12600b57cec5SDimitry Andric DR.CVRegister = CVRegister; 12610b57cec5SDimitry Andric return DR; 12620b57cec5SDimitry Andric } 12630b57cec5SDimitry Andric 12640b57cec5SDimitry Andric void CodeViewDebug::collectVariableInfoFromMFTable( 12650b57cec5SDimitry Andric DenseSet<InlinedEntity> &Processed) { 12660b57cec5SDimitry Andric const MachineFunction &MF = *Asm->MF; 12670b57cec5SDimitry Andric const TargetSubtargetInfo &TSI = MF.getSubtarget(); 12680b57cec5SDimitry Andric const TargetFrameLowering *TFI = TSI.getFrameLowering(); 12690b57cec5SDimitry Andric const TargetRegisterInfo *TRI = TSI.getRegisterInfo(); 12700b57cec5SDimitry Andric 12710b57cec5SDimitry Andric for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) { 12720b57cec5SDimitry Andric if (!VI.Var) 12730b57cec5SDimitry Andric continue; 12740b57cec5SDimitry Andric assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) && 12750b57cec5SDimitry Andric "Expected inlined-at fields to agree"); 12760b57cec5SDimitry Andric 12770b57cec5SDimitry Andric Processed.insert(InlinedEntity(VI.Var, VI.Loc->getInlinedAt())); 12780b57cec5SDimitry Andric LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc); 12790b57cec5SDimitry Andric 12800b57cec5SDimitry Andric // If variable scope is not found then skip this variable. 12810b57cec5SDimitry Andric if (!Scope) 12820b57cec5SDimitry Andric continue; 12830b57cec5SDimitry Andric 12840b57cec5SDimitry Andric // If the variable has an attached offset expression, extract it. 12850b57cec5SDimitry Andric // FIXME: Try to handle DW_OP_deref as well. 12860b57cec5SDimitry Andric int64_t ExprOffset = 0; 12870b57cec5SDimitry Andric bool Deref = false; 12880b57cec5SDimitry Andric if (VI.Expr) { 12890b57cec5SDimitry Andric // If there is one DW_OP_deref element, use offset of 0 and keep going. 12900b57cec5SDimitry Andric if (VI.Expr->getNumElements() == 1 && 12910b57cec5SDimitry Andric VI.Expr->getElement(0) == llvm::dwarf::DW_OP_deref) 12920b57cec5SDimitry Andric Deref = true; 12930b57cec5SDimitry Andric else if (!VI.Expr->extractIfOffset(ExprOffset)) 12940b57cec5SDimitry Andric continue; 12950b57cec5SDimitry Andric } 12960b57cec5SDimitry Andric 12970b57cec5SDimitry Andric // Get the frame register used and the offset. 12985ffd83dbSDimitry Andric Register FrameReg; 1299e8d8bef9SDimitry Andric StackOffset FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg); 13000b57cec5SDimitry Andric uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg); 13010b57cec5SDimitry Andric 1302e8d8bef9SDimitry Andric assert(!FrameOffset.getScalable() && 1303e8d8bef9SDimitry Andric "Frame offsets with a scalable component are not supported"); 1304e8d8bef9SDimitry Andric 13050b57cec5SDimitry Andric // Calculate the label ranges. 13060b57cec5SDimitry Andric LocalVarDefRange DefRange = 1307e8d8bef9SDimitry Andric createDefRangeMem(CVReg, FrameOffset.getFixed() + ExprOffset); 13080b57cec5SDimitry Andric 13090b57cec5SDimitry Andric for (const InsnRange &Range : Scope->getRanges()) { 13100b57cec5SDimitry Andric const MCSymbol *Begin = getLabelBeforeInsn(Range.first); 13110b57cec5SDimitry Andric const MCSymbol *End = getLabelAfterInsn(Range.second); 13120b57cec5SDimitry Andric End = End ? End : Asm->getFunctionEnd(); 13130b57cec5SDimitry Andric DefRange.Ranges.emplace_back(Begin, End); 13140b57cec5SDimitry Andric } 13150b57cec5SDimitry Andric 13160b57cec5SDimitry Andric LocalVariable Var; 13170b57cec5SDimitry Andric Var.DIVar = VI.Var; 13180b57cec5SDimitry Andric Var.DefRanges.emplace_back(std::move(DefRange)); 13190b57cec5SDimitry Andric if (Deref) 13200b57cec5SDimitry Andric Var.UseReferenceType = true; 13210b57cec5SDimitry Andric 13220b57cec5SDimitry Andric recordLocalVariable(std::move(Var), Scope); 13230b57cec5SDimitry Andric } 13240b57cec5SDimitry Andric } 13250b57cec5SDimitry Andric 13260b57cec5SDimitry Andric static bool canUseReferenceType(const DbgVariableLocation &Loc) { 13270b57cec5SDimitry Andric return !Loc.LoadChain.empty() && Loc.LoadChain.back() == 0; 13280b57cec5SDimitry Andric } 13290b57cec5SDimitry Andric 13300b57cec5SDimitry Andric static bool needsReferenceType(const DbgVariableLocation &Loc) { 13310b57cec5SDimitry Andric return Loc.LoadChain.size() == 2 && Loc.LoadChain.back() == 0; 13320b57cec5SDimitry Andric } 13330b57cec5SDimitry Andric 13340b57cec5SDimitry Andric void CodeViewDebug::calculateRanges( 13350b57cec5SDimitry Andric LocalVariable &Var, const DbgValueHistoryMap::Entries &Entries) { 13360b57cec5SDimitry Andric const TargetRegisterInfo *TRI = Asm->MF->getSubtarget().getRegisterInfo(); 13370b57cec5SDimitry Andric 13380b57cec5SDimitry Andric // Calculate the definition ranges. 13390b57cec5SDimitry Andric for (auto I = Entries.begin(), E = Entries.end(); I != E; ++I) { 13400b57cec5SDimitry Andric const auto &Entry = *I; 13410b57cec5SDimitry Andric if (!Entry.isDbgValue()) 13420b57cec5SDimitry Andric continue; 13430b57cec5SDimitry Andric const MachineInstr *DVInst = Entry.getInstr(); 13440b57cec5SDimitry Andric assert(DVInst->isDebugValue() && "Invalid History entry"); 13450b57cec5SDimitry Andric // FIXME: Find a way to represent constant variables, since they are 13460b57cec5SDimitry Andric // relatively common. 13470b57cec5SDimitry Andric Optional<DbgVariableLocation> Location = 13480b57cec5SDimitry Andric DbgVariableLocation::extractFromMachineInstruction(*DVInst); 13490b57cec5SDimitry Andric if (!Location) 13500b57cec5SDimitry Andric continue; 13510b57cec5SDimitry Andric 13520b57cec5SDimitry Andric // CodeView can only express variables in register and variables in memory 13530b57cec5SDimitry Andric // at a constant offset from a register. However, for variables passed 13540b57cec5SDimitry Andric // indirectly by pointer, it is common for that pointer to be spilled to a 13550b57cec5SDimitry Andric // stack location. For the special case of one offseted load followed by a 13560b57cec5SDimitry Andric // zero offset load (a pointer spilled to the stack), we change the type of 13570b57cec5SDimitry Andric // the local variable from a value type to a reference type. This tricks the 13580b57cec5SDimitry Andric // debugger into doing the load for us. 13590b57cec5SDimitry Andric if (Var.UseReferenceType) { 13600b57cec5SDimitry Andric // We're using a reference type. Drop the last zero offset load. 13610b57cec5SDimitry Andric if (canUseReferenceType(*Location)) 13620b57cec5SDimitry Andric Location->LoadChain.pop_back(); 13630b57cec5SDimitry Andric else 13640b57cec5SDimitry Andric continue; 13650b57cec5SDimitry Andric } else if (needsReferenceType(*Location)) { 13660b57cec5SDimitry Andric // This location can't be expressed without switching to a reference type. 13670b57cec5SDimitry Andric // Start over using that. 13680b57cec5SDimitry Andric Var.UseReferenceType = true; 13690b57cec5SDimitry Andric Var.DefRanges.clear(); 13700b57cec5SDimitry Andric calculateRanges(Var, Entries); 13710b57cec5SDimitry Andric return; 13720b57cec5SDimitry Andric } 13730b57cec5SDimitry Andric 13740b57cec5SDimitry Andric // We can only handle a register or an offseted load of a register. 13750b57cec5SDimitry Andric if (Location->Register == 0 || Location->LoadChain.size() > 1) 13760b57cec5SDimitry Andric continue; 13770b57cec5SDimitry Andric { 13780b57cec5SDimitry Andric LocalVarDefRange DR; 13790b57cec5SDimitry Andric DR.CVRegister = TRI->getCodeViewRegNum(Location->Register); 13800b57cec5SDimitry Andric DR.InMemory = !Location->LoadChain.empty(); 13810b57cec5SDimitry Andric DR.DataOffset = 13820b57cec5SDimitry Andric !Location->LoadChain.empty() ? Location->LoadChain.back() : 0; 13830b57cec5SDimitry Andric if (Location->FragmentInfo) { 13840b57cec5SDimitry Andric DR.IsSubfield = true; 13850b57cec5SDimitry Andric DR.StructOffset = Location->FragmentInfo->OffsetInBits / 8; 13860b57cec5SDimitry Andric } else { 13870b57cec5SDimitry Andric DR.IsSubfield = false; 13880b57cec5SDimitry Andric DR.StructOffset = 0; 13890b57cec5SDimitry Andric } 13900b57cec5SDimitry Andric 13910b57cec5SDimitry Andric if (Var.DefRanges.empty() || 13920b57cec5SDimitry Andric Var.DefRanges.back().isDifferentLocation(DR)) { 13930b57cec5SDimitry Andric Var.DefRanges.emplace_back(std::move(DR)); 13940b57cec5SDimitry Andric } 13950b57cec5SDimitry Andric } 13960b57cec5SDimitry Andric 13970b57cec5SDimitry Andric // Compute the label range. 13980b57cec5SDimitry Andric const MCSymbol *Begin = getLabelBeforeInsn(Entry.getInstr()); 13990b57cec5SDimitry Andric const MCSymbol *End; 14000b57cec5SDimitry Andric if (Entry.getEndIndex() != DbgValueHistoryMap::NoEntry) { 14010b57cec5SDimitry Andric auto &EndingEntry = Entries[Entry.getEndIndex()]; 14020b57cec5SDimitry Andric End = EndingEntry.isDbgValue() 14030b57cec5SDimitry Andric ? getLabelBeforeInsn(EndingEntry.getInstr()) 14040b57cec5SDimitry Andric : getLabelAfterInsn(EndingEntry.getInstr()); 14050b57cec5SDimitry Andric } else 14060b57cec5SDimitry Andric End = Asm->getFunctionEnd(); 14070b57cec5SDimitry Andric 14080b57cec5SDimitry Andric // If the last range end is our begin, just extend the last range. 14090b57cec5SDimitry Andric // Otherwise make a new range. 14100b57cec5SDimitry Andric SmallVectorImpl<std::pair<const MCSymbol *, const MCSymbol *>> &R = 14110b57cec5SDimitry Andric Var.DefRanges.back().Ranges; 14120b57cec5SDimitry Andric if (!R.empty() && R.back().second == Begin) 14130b57cec5SDimitry Andric R.back().second = End; 14140b57cec5SDimitry Andric else 14150b57cec5SDimitry Andric R.emplace_back(Begin, End); 14160b57cec5SDimitry Andric 14170b57cec5SDimitry Andric // FIXME: Do more range combining. 14180b57cec5SDimitry Andric } 14190b57cec5SDimitry Andric } 14200b57cec5SDimitry Andric 14210b57cec5SDimitry Andric void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) { 14220b57cec5SDimitry Andric DenseSet<InlinedEntity> Processed; 14230b57cec5SDimitry Andric // Grab the variable info that was squirreled away in the MMI side-table. 14240b57cec5SDimitry Andric collectVariableInfoFromMFTable(Processed); 14250b57cec5SDimitry Andric 14260b57cec5SDimitry Andric for (const auto &I : DbgValues) { 14270b57cec5SDimitry Andric InlinedEntity IV = I.first; 14280b57cec5SDimitry Andric if (Processed.count(IV)) 14290b57cec5SDimitry Andric continue; 14300b57cec5SDimitry Andric const DILocalVariable *DIVar = cast<DILocalVariable>(IV.first); 14310b57cec5SDimitry Andric const DILocation *InlinedAt = IV.second; 14320b57cec5SDimitry Andric 14330b57cec5SDimitry Andric // Instruction ranges, specifying where IV is accessible. 14340b57cec5SDimitry Andric const auto &Entries = I.second; 14350b57cec5SDimitry Andric 14360b57cec5SDimitry Andric LexicalScope *Scope = nullptr; 14370b57cec5SDimitry Andric if (InlinedAt) 14380b57cec5SDimitry Andric Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt); 14390b57cec5SDimitry Andric else 14400b57cec5SDimitry Andric Scope = LScopes.findLexicalScope(DIVar->getScope()); 14410b57cec5SDimitry Andric // If variable scope is not found then skip this variable. 14420b57cec5SDimitry Andric if (!Scope) 14430b57cec5SDimitry Andric continue; 14440b57cec5SDimitry Andric 14450b57cec5SDimitry Andric LocalVariable Var; 14460b57cec5SDimitry Andric Var.DIVar = DIVar; 14470b57cec5SDimitry Andric 14480b57cec5SDimitry Andric calculateRanges(Var, Entries); 14490b57cec5SDimitry Andric recordLocalVariable(std::move(Var), Scope); 14500b57cec5SDimitry Andric } 14510b57cec5SDimitry Andric } 14520b57cec5SDimitry Andric 14530b57cec5SDimitry Andric void CodeViewDebug::beginFunctionImpl(const MachineFunction *MF) { 14540b57cec5SDimitry Andric const TargetSubtargetInfo &TSI = MF->getSubtarget(); 14550b57cec5SDimitry Andric const TargetRegisterInfo *TRI = TSI.getRegisterInfo(); 14560b57cec5SDimitry Andric const MachineFrameInfo &MFI = MF->getFrameInfo(); 14570b57cec5SDimitry Andric const Function &GV = MF->getFunction(); 14588bcb0991SDimitry Andric auto Insertion = FnDebugInfo.insert({&GV, std::make_unique<FunctionInfo>()}); 14590b57cec5SDimitry Andric assert(Insertion.second && "function already has info"); 14600b57cec5SDimitry Andric CurFn = Insertion.first->second.get(); 14610b57cec5SDimitry Andric CurFn->FuncId = NextFuncId++; 14620b57cec5SDimitry Andric CurFn->Begin = Asm->getFunctionBegin(); 14630b57cec5SDimitry Andric 14640b57cec5SDimitry Andric // The S_FRAMEPROC record reports the stack size, and how many bytes of 14650b57cec5SDimitry Andric // callee-saved registers were used. For targets that don't use a PUSH 14660b57cec5SDimitry Andric // instruction (AArch64), this will be zero. 14670b57cec5SDimitry Andric CurFn->CSRSize = MFI.getCVBytesOfCalleeSavedRegisters(); 14680b57cec5SDimitry Andric CurFn->FrameSize = MFI.getStackSize(); 14690b57cec5SDimitry Andric CurFn->OffsetAdjustment = MFI.getOffsetAdjustment(); 1470fe6060f1SDimitry Andric CurFn->HasStackRealignment = TRI->hasStackRealignment(*MF); 14710b57cec5SDimitry Andric 14720b57cec5SDimitry Andric // For this function S_FRAMEPROC record, figure out which codeview register 14730b57cec5SDimitry Andric // will be the frame pointer. 14740b57cec5SDimitry Andric CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::None; // None. 14750b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::None; // None. 14760b57cec5SDimitry Andric if (CurFn->FrameSize > 0) { 14770b57cec5SDimitry Andric if (!TSI.getFrameLowering()->hasFP(*MF)) { 14780b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr; 14790b57cec5SDimitry Andric CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::StackPtr; 14800b57cec5SDimitry Andric } else { 14810b57cec5SDimitry Andric // If there is an FP, parameters are always relative to it. 14820b57cec5SDimitry Andric CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::FramePtr; 14830b57cec5SDimitry Andric if (CurFn->HasStackRealignment) { 14840b57cec5SDimitry Andric // If the stack needs realignment, locals are relative to SP or VFRAME. 14850b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr; 14860b57cec5SDimitry Andric } else { 14870b57cec5SDimitry Andric // Otherwise, locals are relative to EBP, and we probably have VLAs or 14880b57cec5SDimitry Andric // other stack adjustments. 14890b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::FramePtr; 14900b57cec5SDimitry Andric } 14910b57cec5SDimitry Andric } 14920b57cec5SDimitry Andric } 14930b57cec5SDimitry Andric 14940b57cec5SDimitry Andric // Compute other frame procedure options. 14950b57cec5SDimitry Andric FrameProcedureOptions FPO = FrameProcedureOptions::None; 14960b57cec5SDimitry Andric if (MFI.hasVarSizedObjects()) 14970b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasAlloca; 14980b57cec5SDimitry Andric if (MF->exposesReturnsTwice()) 14990b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasSetJmp; 15000b57cec5SDimitry Andric // FIXME: Set HasLongJmp if we ever track that info. 15010b57cec5SDimitry Andric if (MF->hasInlineAsm()) 15020b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasInlineAssembly; 15030b57cec5SDimitry Andric if (GV.hasPersonalityFn()) { 15040b57cec5SDimitry Andric if (isAsynchronousEHPersonality( 15050b57cec5SDimitry Andric classifyEHPersonality(GV.getPersonalityFn()))) 15060b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasStructuredExceptionHandling; 15070b57cec5SDimitry Andric else 15080b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasExceptionHandling; 15090b57cec5SDimitry Andric } 15100b57cec5SDimitry Andric if (GV.hasFnAttribute(Attribute::InlineHint)) 15110b57cec5SDimitry Andric FPO |= FrameProcedureOptions::MarkedInline; 15120b57cec5SDimitry Andric if (GV.hasFnAttribute(Attribute::Naked)) 15130b57cec5SDimitry Andric FPO |= FrameProcedureOptions::Naked; 15140b57cec5SDimitry Andric if (MFI.hasStackProtectorIndex()) 15150b57cec5SDimitry Andric FPO |= FrameProcedureOptions::SecurityChecks; 15160b57cec5SDimitry Andric FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedLocalFramePtrReg) << 14U); 15170b57cec5SDimitry Andric FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedParamFramePtrReg) << 16U); 15180b57cec5SDimitry Andric if (Asm->TM.getOptLevel() != CodeGenOpt::None && 15190b57cec5SDimitry Andric !GV.hasOptSize() && !GV.hasOptNone()) 15200b57cec5SDimitry Andric FPO |= FrameProcedureOptions::OptimizedForSpeed; 1521fe6060f1SDimitry Andric if (GV.hasProfileData()) { 1522fe6060f1SDimitry Andric FPO |= FrameProcedureOptions::ValidProfileCounts; 1523fe6060f1SDimitry Andric FPO |= FrameProcedureOptions::ProfileGuidedOptimization; 1524fe6060f1SDimitry Andric } 15250b57cec5SDimitry Andric // FIXME: Set GuardCfg when it is implemented. 15260b57cec5SDimitry Andric CurFn->FrameProcOpts = FPO; 15270b57cec5SDimitry Andric 15280b57cec5SDimitry Andric OS.EmitCVFuncIdDirective(CurFn->FuncId); 15290b57cec5SDimitry Andric 15300b57cec5SDimitry Andric // Find the end of the function prolog. First known non-DBG_VALUE and 15310b57cec5SDimitry Andric // non-frame setup location marks the beginning of the function body. 15320b57cec5SDimitry Andric // FIXME: is there a simpler a way to do this? Can we just search 15330b57cec5SDimitry Andric // for the first instruction of the function, not the last of the prolog? 15340b57cec5SDimitry Andric DebugLoc PrologEndLoc; 15350b57cec5SDimitry Andric bool EmptyPrologue = true; 15360b57cec5SDimitry Andric for (const auto &MBB : *MF) { 15370b57cec5SDimitry Andric for (const auto &MI : MBB) { 15380b57cec5SDimitry Andric if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) && 15390b57cec5SDimitry Andric MI.getDebugLoc()) { 15400b57cec5SDimitry Andric PrologEndLoc = MI.getDebugLoc(); 15410b57cec5SDimitry Andric break; 15420b57cec5SDimitry Andric } else if (!MI.isMetaInstruction()) { 15430b57cec5SDimitry Andric EmptyPrologue = false; 15440b57cec5SDimitry Andric } 15450b57cec5SDimitry Andric } 15460b57cec5SDimitry Andric } 15470b57cec5SDimitry Andric 15480b57cec5SDimitry Andric // Record beginning of function if we have a non-empty prologue. 15490b57cec5SDimitry Andric if (PrologEndLoc && !EmptyPrologue) { 15500b57cec5SDimitry Andric DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc(); 15510b57cec5SDimitry Andric maybeRecordLocation(FnStartDL, MF); 15520b57cec5SDimitry Andric } 1553480093f4SDimitry Andric 1554480093f4SDimitry Andric // Find heap alloc sites and emit labels around them. 1555480093f4SDimitry Andric for (const auto &MBB : *MF) { 1556480093f4SDimitry Andric for (const auto &MI : MBB) { 1557480093f4SDimitry Andric if (MI.getHeapAllocMarker()) { 1558480093f4SDimitry Andric requestLabelBeforeInsn(&MI); 1559480093f4SDimitry Andric requestLabelAfterInsn(&MI); 1560480093f4SDimitry Andric } 1561480093f4SDimitry Andric } 1562480093f4SDimitry Andric } 15630b57cec5SDimitry Andric } 15640b57cec5SDimitry Andric 15650b57cec5SDimitry Andric static bool shouldEmitUdt(const DIType *T) { 15660b57cec5SDimitry Andric if (!T) 15670b57cec5SDimitry Andric return false; 15680b57cec5SDimitry Andric 15690b57cec5SDimitry Andric // MSVC does not emit UDTs for typedefs that are scoped to classes. 15700b57cec5SDimitry Andric if (T->getTag() == dwarf::DW_TAG_typedef) { 15710b57cec5SDimitry Andric if (DIScope *Scope = T->getScope()) { 15720b57cec5SDimitry Andric switch (Scope->getTag()) { 15730b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 15740b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 15750b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 15760b57cec5SDimitry Andric return false; 1577fe6060f1SDimitry Andric default: 1578fe6060f1SDimitry Andric // do nothing. 1579fe6060f1SDimitry Andric ; 15800b57cec5SDimitry Andric } 15810b57cec5SDimitry Andric } 15820b57cec5SDimitry Andric } 15830b57cec5SDimitry Andric 15840b57cec5SDimitry Andric while (true) { 15850b57cec5SDimitry Andric if (!T || T->isForwardDecl()) 15860b57cec5SDimitry Andric return false; 15870b57cec5SDimitry Andric 15880b57cec5SDimitry Andric const DIDerivedType *DT = dyn_cast<DIDerivedType>(T); 15890b57cec5SDimitry Andric if (!DT) 15900b57cec5SDimitry Andric return true; 15910b57cec5SDimitry Andric T = DT->getBaseType(); 15920b57cec5SDimitry Andric } 15930b57cec5SDimitry Andric return true; 15940b57cec5SDimitry Andric } 15950b57cec5SDimitry Andric 15960b57cec5SDimitry Andric void CodeViewDebug::addToUDTs(const DIType *Ty) { 15970b57cec5SDimitry Andric // Don't record empty UDTs. 15980b57cec5SDimitry Andric if (Ty->getName().empty()) 15990b57cec5SDimitry Andric return; 16000b57cec5SDimitry Andric if (!shouldEmitUdt(Ty)) 16010b57cec5SDimitry Andric return; 16020b57cec5SDimitry Andric 16035ffd83dbSDimitry Andric SmallVector<StringRef, 5> ParentScopeNames; 16040b57cec5SDimitry Andric const DISubprogram *ClosestSubprogram = 16055ffd83dbSDimitry Andric collectParentScopeNames(Ty->getScope(), ParentScopeNames); 16060b57cec5SDimitry Andric 16070b57cec5SDimitry Andric std::string FullyQualifiedName = 16085ffd83dbSDimitry Andric formatNestedName(ParentScopeNames, getPrettyScopeName(Ty)); 16090b57cec5SDimitry Andric 16100b57cec5SDimitry Andric if (ClosestSubprogram == nullptr) { 16110b57cec5SDimitry Andric GlobalUDTs.emplace_back(std::move(FullyQualifiedName), Ty); 16120b57cec5SDimitry Andric } else if (ClosestSubprogram == CurrentSubprogram) { 16130b57cec5SDimitry Andric LocalUDTs.emplace_back(std::move(FullyQualifiedName), Ty); 16140b57cec5SDimitry Andric } 16150b57cec5SDimitry Andric 16160b57cec5SDimitry Andric // TODO: What if the ClosestSubprogram is neither null or the current 16170b57cec5SDimitry Andric // subprogram? Currently, the UDT just gets dropped on the floor. 16180b57cec5SDimitry Andric // 16190b57cec5SDimitry Andric // The current behavior is not desirable. To get maximal fidelity, we would 16200b57cec5SDimitry Andric // need to perform all type translation before beginning emission of .debug$S 16210b57cec5SDimitry Andric // and then make LocalUDTs a member of FunctionInfo 16220b57cec5SDimitry Andric } 16230b57cec5SDimitry Andric 16240b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) { 16250b57cec5SDimitry Andric // Generic dispatch for lowering an unknown type. 16260b57cec5SDimitry Andric switch (Ty->getTag()) { 16270b57cec5SDimitry Andric case dwarf::DW_TAG_array_type: 16280b57cec5SDimitry Andric return lowerTypeArray(cast<DICompositeType>(Ty)); 16290b57cec5SDimitry Andric case dwarf::DW_TAG_typedef: 16300b57cec5SDimitry Andric return lowerTypeAlias(cast<DIDerivedType>(Ty)); 16310b57cec5SDimitry Andric case dwarf::DW_TAG_base_type: 16320b57cec5SDimitry Andric return lowerTypeBasic(cast<DIBasicType>(Ty)); 16330b57cec5SDimitry Andric case dwarf::DW_TAG_pointer_type: 16340b57cec5SDimitry Andric if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type") 16350b57cec5SDimitry Andric return lowerTypeVFTableShape(cast<DIDerivedType>(Ty)); 16360b57cec5SDimitry Andric LLVM_FALLTHROUGH; 16370b57cec5SDimitry Andric case dwarf::DW_TAG_reference_type: 16380b57cec5SDimitry Andric case dwarf::DW_TAG_rvalue_reference_type: 16390b57cec5SDimitry Andric return lowerTypePointer(cast<DIDerivedType>(Ty)); 16400b57cec5SDimitry Andric case dwarf::DW_TAG_ptr_to_member_type: 16410b57cec5SDimitry Andric return lowerTypeMemberPointer(cast<DIDerivedType>(Ty)); 16420b57cec5SDimitry Andric case dwarf::DW_TAG_restrict_type: 16430b57cec5SDimitry Andric case dwarf::DW_TAG_const_type: 16440b57cec5SDimitry Andric case dwarf::DW_TAG_volatile_type: 16450b57cec5SDimitry Andric // TODO: add support for DW_TAG_atomic_type here 16460b57cec5SDimitry Andric return lowerTypeModifier(cast<DIDerivedType>(Ty)); 16470b57cec5SDimitry Andric case dwarf::DW_TAG_subroutine_type: 16480b57cec5SDimitry Andric if (ClassTy) { 16490b57cec5SDimitry Andric // The member function type of a member function pointer has no 16500b57cec5SDimitry Andric // ThisAdjustment. 16510b57cec5SDimitry Andric return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy, 16520b57cec5SDimitry Andric /*ThisAdjustment=*/0, 16530b57cec5SDimitry Andric /*IsStaticMethod=*/false); 16540b57cec5SDimitry Andric } 16550b57cec5SDimitry Andric return lowerTypeFunction(cast<DISubroutineType>(Ty)); 16560b57cec5SDimitry Andric case dwarf::DW_TAG_enumeration_type: 16570b57cec5SDimitry Andric return lowerTypeEnum(cast<DICompositeType>(Ty)); 16580b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 16590b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 16600b57cec5SDimitry Andric return lowerTypeClass(cast<DICompositeType>(Ty)); 16610b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 16620b57cec5SDimitry Andric return lowerTypeUnion(cast<DICompositeType>(Ty)); 1663349cc55cSDimitry Andric case dwarf::DW_TAG_string_type: 1664349cc55cSDimitry Andric return lowerTypeString(cast<DIStringType>(Ty)); 16650b57cec5SDimitry Andric case dwarf::DW_TAG_unspecified_type: 16660b57cec5SDimitry Andric if (Ty->getName() == "decltype(nullptr)") 16670b57cec5SDimitry Andric return TypeIndex::NullptrT(); 16680b57cec5SDimitry Andric return TypeIndex::None(); 16690b57cec5SDimitry Andric default: 16700b57cec5SDimitry Andric // Use the null type index. 16710b57cec5SDimitry Andric return TypeIndex(); 16720b57cec5SDimitry Andric } 16730b57cec5SDimitry Andric } 16740b57cec5SDimitry Andric 16750b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) { 16760b57cec5SDimitry Andric TypeIndex UnderlyingTypeIndex = getTypeIndex(Ty->getBaseType()); 16770b57cec5SDimitry Andric StringRef TypeName = Ty->getName(); 16780b57cec5SDimitry Andric 16790b57cec5SDimitry Andric addToUDTs(Ty); 16800b57cec5SDimitry Andric 16810b57cec5SDimitry Andric if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::Int32Long) && 16820b57cec5SDimitry Andric TypeName == "HRESULT") 16830b57cec5SDimitry Andric return TypeIndex(SimpleTypeKind::HResult); 16840b57cec5SDimitry Andric if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::UInt16Short) && 16850b57cec5SDimitry Andric TypeName == "wchar_t") 16860b57cec5SDimitry Andric return TypeIndex(SimpleTypeKind::WideCharacter); 16870b57cec5SDimitry Andric 16880b57cec5SDimitry Andric return UnderlyingTypeIndex; 16890b57cec5SDimitry Andric } 16900b57cec5SDimitry Andric 16910b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) { 16920b57cec5SDimitry Andric const DIType *ElementType = Ty->getBaseType(); 16930b57cec5SDimitry Andric TypeIndex ElementTypeIndex = getTypeIndex(ElementType); 16940b57cec5SDimitry Andric // IndexType is size_t, which depends on the bitness of the target. 16950b57cec5SDimitry Andric TypeIndex IndexType = getPointerSizeInBytes() == 8 16960b57cec5SDimitry Andric ? TypeIndex(SimpleTypeKind::UInt64Quad) 16970b57cec5SDimitry Andric : TypeIndex(SimpleTypeKind::UInt32Long); 16980b57cec5SDimitry Andric 16990b57cec5SDimitry Andric uint64_t ElementSize = getBaseTypeSize(ElementType) / 8; 17000b57cec5SDimitry Andric 17010b57cec5SDimitry Andric // Add subranges to array type. 17020b57cec5SDimitry Andric DINodeArray Elements = Ty->getElements(); 17030b57cec5SDimitry Andric for (int i = Elements.size() - 1; i >= 0; --i) { 17040b57cec5SDimitry Andric const DINode *Element = Elements[i]; 17050b57cec5SDimitry Andric assert(Element->getTag() == dwarf::DW_TAG_subrange_type); 17060b57cec5SDimitry Andric 17070b57cec5SDimitry Andric const DISubrange *Subrange = cast<DISubrange>(Element); 17080b57cec5SDimitry Andric int64_t Count = -1; 1709349cc55cSDimitry Andric 1710349cc55cSDimitry Andric // If Subrange has a Count field, use it. 1711349cc55cSDimitry Andric // Otherwise, if it has an upperboud, use (upperbound - lowerbound + 1), 1712349cc55cSDimitry Andric // where lowerbound is from the LowerBound field of the Subrange, 1713349cc55cSDimitry Andric // or the language default lowerbound if that field is unspecified. 17140b57cec5SDimitry Andric if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt *>()) 17150b57cec5SDimitry Andric Count = CI->getSExtValue(); 1716349cc55cSDimitry Andric else if (auto *UI = Subrange->getUpperBound().dyn_cast<ConstantInt *>()) { 1717349cc55cSDimitry Andric // Fortran uses 1 as the default lowerbound; other languages use 0. 1718349cc55cSDimitry Andric int64_t Lowerbound = (moduleIsInFortran()) ? 1 : 0; 1719349cc55cSDimitry Andric auto *LI = Subrange->getLowerBound().dyn_cast<ConstantInt *>(); 1720349cc55cSDimitry Andric Lowerbound = (LI) ? LI->getSExtValue() : Lowerbound; 1721349cc55cSDimitry Andric Count = UI->getSExtValue() - Lowerbound + 1; 172216d6b3b3SDimitry Andric } 17230b57cec5SDimitry Andric 17240b57cec5SDimitry Andric // Forward declarations of arrays without a size and VLAs use a count of -1. 17250b57cec5SDimitry Andric // Emit a count of zero in these cases to match what MSVC does for arrays 17260b57cec5SDimitry Andric // without a size. MSVC doesn't support VLAs, so it's not clear what we 17270b57cec5SDimitry Andric // should do for them even if we could distinguish them. 17280b57cec5SDimitry Andric if (Count == -1) 17290b57cec5SDimitry Andric Count = 0; 17300b57cec5SDimitry Andric 17310b57cec5SDimitry Andric // Update the element size and element type index for subsequent subranges. 17320b57cec5SDimitry Andric ElementSize *= Count; 17330b57cec5SDimitry Andric 17340b57cec5SDimitry Andric // If this is the outermost array, use the size from the array. It will be 17350b57cec5SDimitry Andric // more accurate if we had a VLA or an incomplete element type size. 17360b57cec5SDimitry Andric uint64_t ArraySize = 17370b57cec5SDimitry Andric (i == 0 && ElementSize == 0) ? Ty->getSizeInBits() / 8 : ElementSize; 17380b57cec5SDimitry Andric 17390b57cec5SDimitry Andric StringRef Name = (i == 0) ? Ty->getName() : ""; 17400b57cec5SDimitry Andric ArrayRecord AR(ElementTypeIndex, IndexType, ArraySize, Name); 17410b57cec5SDimitry Andric ElementTypeIndex = TypeTable.writeLeafType(AR); 17420b57cec5SDimitry Andric } 17430b57cec5SDimitry Andric 17440b57cec5SDimitry Andric return ElementTypeIndex; 17450b57cec5SDimitry Andric } 17460b57cec5SDimitry Andric 1747349cc55cSDimitry Andric // This function lowers a Fortran character type (DIStringType). 1748349cc55cSDimitry Andric // Note that it handles only the character*n variant (using SizeInBits 1749349cc55cSDimitry Andric // field in DIString to describe the type size) at the moment. 1750349cc55cSDimitry Andric // Other variants (leveraging the StringLength and StringLengthExp 1751349cc55cSDimitry Andric // fields in DIStringType) remain TBD. 1752349cc55cSDimitry Andric TypeIndex CodeViewDebug::lowerTypeString(const DIStringType *Ty) { 1753349cc55cSDimitry Andric TypeIndex CharType = TypeIndex(SimpleTypeKind::NarrowCharacter); 1754349cc55cSDimitry Andric uint64_t ArraySize = Ty->getSizeInBits() >> 3; 1755349cc55cSDimitry Andric StringRef Name = Ty->getName(); 1756349cc55cSDimitry Andric // IndexType is size_t, which depends on the bitness of the target. 1757349cc55cSDimitry Andric TypeIndex IndexType = getPointerSizeInBytes() == 8 1758349cc55cSDimitry Andric ? TypeIndex(SimpleTypeKind::UInt64Quad) 1759349cc55cSDimitry Andric : TypeIndex(SimpleTypeKind::UInt32Long); 1760349cc55cSDimitry Andric 1761349cc55cSDimitry Andric // Create a type of character array of ArraySize. 1762349cc55cSDimitry Andric ArrayRecord AR(CharType, IndexType, ArraySize, Name); 1763349cc55cSDimitry Andric 1764349cc55cSDimitry Andric return TypeTable.writeLeafType(AR); 1765349cc55cSDimitry Andric } 1766349cc55cSDimitry Andric 17670b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) { 17680b57cec5SDimitry Andric TypeIndex Index; 17690b57cec5SDimitry Andric dwarf::TypeKind Kind; 17700b57cec5SDimitry Andric uint32_t ByteSize; 17710b57cec5SDimitry Andric 17720b57cec5SDimitry Andric Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding()); 17730b57cec5SDimitry Andric ByteSize = Ty->getSizeInBits() / 8; 17740b57cec5SDimitry Andric 17750b57cec5SDimitry Andric SimpleTypeKind STK = SimpleTypeKind::None; 17760b57cec5SDimitry Andric switch (Kind) { 17770b57cec5SDimitry Andric case dwarf::DW_ATE_address: 17780b57cec5SDimitry Andric // FIXME: Translate 17790b57cec5SDimitry Andric break; 17800b57cec5SDimitry Andric case dwarf::DW_ATE_boolean: 17810b57cec5SDimitry Andric switch (ByteSize) { 17820b57cec5SDimitry Andric case 1: STK = SimpleTypeKind::Boolean8; break; 17830b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Boolean16; break; 17840b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Boolean32; break; 17850b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Boolean64; break; 17860b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Boolean128; break; 17870b57cec5SDimitry Andric } 17880b57cec5SDimitry Andric break; 17890b57cec5SDimitry Andric case dwarf::DW_ATE_complex_float: 17900b57cec5SDimitry Andric switch (ByteSize) { 17910b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Complex16; break; 17920b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Complex32; break; 17930b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Complex64; break; 17940b57cec5SDimitry Andric case 10: STK = SimpleTypeKind::Complex80; break; 17950b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Complex128; break; 17960b57cec5SDimitry Andric } 17970b57cec5SDimitry Andric break; 17980b57cec5SDimitry Andric case dwarf::DW_ATE_float: 17990b57cec5SDimitry Andric switch (ByteSize) { 18000b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Float16; break; 18010b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Float32; break; 18020b57cec5SDimitry Andric case 6: STK = SimpleTypeKind::Float48; break; 18030b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Float64; break; 18040b57cec5SDimitry Andric case 10: STK = SimpleTypeKind::Float80; break; 18050b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Float128; break; 18060b57cec5SDimitry Andric } 18070b57cec5SDimitry Andric break; 18080b57cec5SDimitry Andric case dwarf::DW_ATE_signed: 18090b57cec5SDimitry Andric switch (ByteSize) { 18100b57cec5SDimitry Andric case 1: STK = SimpleTypeKind::SignedCharacter; break; 18110b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Int16Short; break; 18120b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Int32; break; 18130b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Int64Quad; break; 18140b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Int128Oct; break; 18150b57cec5SDimitry Andric } 18160b57cec5SDimitry Andric break; 18170b57cec5SDimitry Andric case dwarf::DW_ATE_unsigned: 18180b57cec5SDimitry Andric switch (ByteSize) { 18190b57cec5SDimitry Andric case 1: STK = SimpleTypeKind::UnsignedCharacter; break; 18200b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::UInt16Short; break; 18210b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::UInt32; break; 18220b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::UInt64Quad; break; 18230b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::UInt128Oct; break; 18240b57cec5SDimitry Andric } 18250b57cec5SDimitry Andric break; 18260b57cec5SDimitry Andric case dwarf::DW_ATE_UTF: 18270b57cec5SDimitry Andric switch (ByteSize) { 18280b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Character16; break; 18290b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Character32; break; 18300b57cec5SDimitry Andric } 18310b57cec5SDimitry Andric break; 18320b57cec5SDimitry Andric case dwarf::DW_ATE_signed_char: 18330b57cec5SDimitry Andric if (ByteSize == 1) 18340b57cec5SDimitry Andric STK = SimpleTypeKind::SignedCharacter; 18350b57cec5SDimitry Andric break; 18360b57cec5SDimitry Andric case dwarf::DW_ATE_unsigned_char: 18370b57cec5SDimitry Andric if (ByteSize == 1) 18380b57cec5SDimitry Andric STK = SimpleTypeKind::UnsignedCharacter; 18390b57cec5SDimitry Andric break; 18400b57cec5SDimitry Andric default: 18410b57cec5SDimitry Andric break; 18420b57cec5SDimitry Andric } 18430b57cec5SDimitry Andric 18440b57cec5SDimitry Andric // Apply some fixups based on the source-level type name. 1845349cc55cSDimitry Andric // Include some amount of canonicalization from an old naming scheme Clang 1846349cc55cSDimitry Andric // used to use for integer types (in an outdated effort to be compatible with 1847349cc55cSDimitry Andric // GCC's debug info/GDB's behavior, which has since been addressed). 1848349cc55cSDimitry Andric if (STK == SimpleTypeKind::Int32 && 1849349cc55cSDimitry Andric (Ty->getName() == "long int" || Ty->getName() == "long")) 18500b57cec5SDimitry Andric STK = SimpleTypeKind::Int32Long; 1851349cc55cSDimitry Andric if (STK == SimpleTypeKind::UInt32 && (Ty->getName() == "long unsigned int" || 1852349cc55cSDimitry Andric Ty->getName() == "unsigned long")) 18530b57cec5SDimitry Andric STK = SimpleTypeKind::UInt32Long; 18540b57cec5SDimitry Andric if (STK == SimpleTypeKind::UInt16Short && 18550b57cec5SDimitry Andric (Ty->getName() == "wchar_t" || Ty->getName() == "__wchar_t")) 18560b57cec5SDimitry Andric STK = SimpleTypeKind::WideCharacter; 18570b57cec5SDimitry Andric if ((STK == SimpleTypeKind::SignedCharacter || 18580b57cec5SDimitry Andric STK == SimpleTypeKind::UnsignedCharacter) && 18590b57cec5SDimitry Andric Ty->getName() == "char") 18600b57cec5SDimitry Andric STK = SimpleTypeKind::NarrowCharacter; 18610b57cec5SDimitry Andric 18620b57cec5SDimitry Andric return TypeIndex(STK); 18630b57cec5SDimitry Andric } 18640b57cec5SDimitry Andric 18650b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty, 18660b57cec5SDimitry Andric PointerOptions PO) { 18670b57cec5SDimitry Andric TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType()); 18680b57cec5SDimitry Andric 18690b57cec5SDimitry Andric // Pointers to simple types without any options can use SimpleTypeMode, rather 18700b57cec5SDimitry Andric // than having a dedicated pointer type record. 18710b57cec5SDimitry Andric if (PointeeTI.isSimple() && PO == PointerOptions::None && 18720b57cec5SDimitry Andric PointeeTI.getSimpleMode() == SimpleTypeMode::Direct && 18730b57cec5SDimitry Andric Ty->getTag() == dwarf::DW_TAG_pointer_type) { 18740b57cec5SDimitry Andric SimpleTypeMode Mode = Ty->getSizeInBits() == 64 18750b57cec5SDimitry Andric ? SimpleTypeMode::NearPointer64 18760b57cec5SDimitry Andric : SimpleTypeMode::NearPointer32; 18770b57cec5SDimitry Andric return TypeIndex(PointeeTI.getSimpleKind(), Mode); 18780b57cec5SDimitry Andric } 18790b57cec5SDimitry Andric 18800b57cec5SDimitry Andric PointerKind PK = 18810b57cec5SDimitry Andric Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32; 18820b57cec5SDimitry Andric PointerMode PM = PointerMode::Pointer; 18830b57cec5SDimitry Andric switch (Ty->getTag()) { 18840b57cec5SDimitry Andric default: llvm_unreachable("not a pointer tag type"); 18850b57cec5SDimitry Andric case dwarf::DW_TAG_pointer_type: 18860b57cec5SDimitry Andric PM = PointerMode::Pointer; 18870b57cec5SDimitry Andric break; 18880b57cec5SDimitry Andric case dwarf::DW_TAG_reference_type: 18890b57cec5SDimitry Andric PM = PointerMode::LValueReference; 18900b57cec5SDimitry Andric break; 18910b57cec5SDimitry Andric case dwarf::DW_TAG_rvalue_reference_type: 18920b57cec5SDimitry Andric PM = PointerMode::RValueReference; 18930b57cec5SDimitry Andric break; 18940b57cec5SDimitry Andric } 18950b57cec5SDimitry Andric 18960b57cec5SDimitry Andric if (Ty->isObjectPointer()) 18970b57cec5SDimitry Andric PO |= PointerOptions::Const; 18980b57cec5SDimitry Andric 18990b57cec5SDimitry Andric PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8); 19000b57cec5SDimitry Andric return TypeTable.writeLeafType(PR); 19010b57cec5SDimitry Andric } 19020b57cec5SDimitry Andric 19030b57cec5SDimitry Andric static PointerToMemberRepresentation 19040b57cec5SDimitry Andric translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) { 19050b57cec5SDimitry Andric // SizeInBytes being zero generally implies that the member pointer type was 19060b57cec5SDimitry Andric // incomplete, which can happen if it is part of a function prototype. In this 19070b57cec5SDimitry Andric // case, use the unknown model instead of the general model. 19080b57cec5SDimitry Andric if (IsPMF) { 19090b57cec5SDimitry Andric switch (Flags & DINode::FlagPtrToMemberRep) { 19100b57cec5SDimitry Andric case 0: 19110b57cec5SDimitry Andric return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown 19120b57cec5SDimitry Andric : PointerToMemberRepresentation::GeneralFunction; 19130b57cec5SDimitry Andric case DINode::FlagSingleInheritance: 19140b57cec5SDimitry Andric return PointerToMemberRepresentation::SingleInheritanceFunction; 19150b57cec5SDimitry Andric case DINode::FlagMultipleInheritance: 19160b57cec5SDimitry Andric return PointerToMemberRepresentation::MultipleInheritanceFunction; 19170b57cec5SDimitry Andric case DINode::FlagVirtualInheritance: 19180b57cec5SDimitry Andric return PointerToMemberRepresentation::VirtualInheritanceFunction; 19190b57cec5SDimitry Andric } 19200b57cec5SDimitry Andric } else { 19210b57cec5SDimitry Andric switch (Flags & DINode::FlagPtrToMemberRep) { 19220b57cec5SDimitry Andric case 0: 19230b57cec5SDimitry Andric return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown 19240b57cec5SDimitry Andric : PointerToMemberRepresentation::GeneralData; 19250b57cec5SDimitry Andric case DINode::FlagSingleInheritance: 19260b57cec5SDimitry Andric return PointerToMemberRepresentation::SingleInheritanceData; 19270b57cec5SDimitry Andric case DINode::FlagMultipleInheritance: 19280b57cec5SDimitry Andric return PointerToMemberRepresentation::MultipleInheritanceData; 19290b57cec5SDimitry Andric case DINode::FlagVirtualInheritance: 19300b57cec5SDimitry Andric return PointerToMemberRepresentation::VirtualInheritanceData; 19310b57cec5SDimitry Andric } 19320b57cec5SDimitry Andric } 19330b57cec5SDimitry Andric llvm_unreachable("invalid ptr to member representation"); 19340b57cec5SDimitry Andric } 19350b57cec5SDimitry Andric 19360b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty, 19370b57cec5SDimitry Andric PointerOptions PO) { 19380b57cec5SDimitry Andric assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type); 19395ffd83dbSDimitry Andric bool IsPMF = isa<DISubroutineType>(Ty->getBaseType()); 19400b57cec5SDimitry Andric TypeIndex ClassTI = getTypeIndex(Ty->getClassType()); 19415ffd83dbSDimitry Andric TypeIndex PointeeTI = 19425ffd83dbSDimitry Andric getTypeIndex(Ty->getBaseType(), IsPMF ? Ty->getClassType() : nullptr); 19430b57cec5SDimitry Andric PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64 19440b57cec5SDimitry Andric : PointerKind::Near32; 19450b57cec5SDimitry Andric PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction 19460b57cec5SDimitry Andric : PointerMode::PointerToDataMember; 19470b57cec5SDimitry Andric 19480b57cec5SDimitry Andric assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big"); 19490b57cec5SDimitry Andric uint8_t SizeInBytes = Ty->getSizeInBits() / 8; 19500b57cec5SDimitry Andric MemberPointerInfo MPI( 19510b57cec5SDimitry Andric ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags())); 19520b57cec5SDimitry Andric PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI); 19530b57cec5SDimitry Andric return TypeTable.writeLeafType(PR); 19540b57cec5SDimitry Andric } 19550b57cec5SDimitry Andric 19560b57cec5SDimitry Andric /// Given a DWARF calling convention, get the CodeView equivalent. If we don't 19570b57cec5SDimitry Andric /// have a translation, use the NearC convention. 19580b57cec5SDimitry Andric static CallingConvention dwarfCCToCodeView(unsigned DwarfCC) { 19590b57cec5SDimitry Andric switch (DwarfCC) { 19600b57cec5SDimitry Andric case dwarf::DW_CC_normal: return CallingConvention::NearC; 19610b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast; 19620b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_thiscall: return CallingConvention::ThisCall; 19630b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_stdcall: return CallingConvention::NearStdCall; 19640b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_pascal: return CallingConvention::NearPascal; 19650b57cec5SDimitry Andric case dwarf::DW_CC_LLVM_vectorcall: return CallingConvention::NearVector; 19660b57cec5SDimitry Andric } 19670b57cec5SDimitry Andric return CallingConvention::NearC; 19680b57cec5SDimitry Andric } 19690b57cec5SDimitry Andric 19700b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) { 19710b57cec5SDimitry Andric ModifierOptions Mods = ModifierOptions::None; 19720b57cec5SDimitry Andric PointerOptions PO = PointerOptions::None; 19730b57cec5SDimitry Andric bool IsModifier = true; 19740b57cec5SDimitry Andric const DIType *BaseTy = Ty; 19750b57cec5SDimitry Andric while (IsModifier && BaseTy) { 19760b57cec5SDimitry Andric // FIXME: Need to add DWARF tags for __unaligned and _Atomic 19770b57cec5SDimitry Andric switch (BaseTy->getTag()) { 19780b57cec5SDimitry Andric case dwarf::DW_TAG_const_type: 19790b57cec5SDimitry Andric Mods |= ModifierOptions::Const; 19800b57cec5SDimitry Andric PO |= PointerOptions::Const; 19810b57cec5SDimitry Andric break; 19820b57cec5SDimitry Andric case dwarf::DW_TAG_volatile_type: 19830b57cec5SDimitry Andric Mods |= ModifierOptions::Volatile; 19840b57cec5SDimitry Andric PO |= PointerOptions::Volatile; 19850b57cec5SDimitry Andric break; 19860b57cec5SDimitry Andric case dwarf::DW_TAG_restrict_type: 19870b57cec5SDimitry Andric // Only pointer types be marked with __restrict. There is no known flag 19880b57cec5SDimitry Andric // for __restrict in LF_MODIFIER records. 19890b57cec5SDimitry Andric PO |= PointerOptions::Restrict; 19900b57cec5SDimitry Andric break; 19910b57cec5SDimitry Andric default: 19920b57cec5SDimitry Andric IsModifier = false; 19930b57cec5SDimitry Andric break; 19940b57cec5SDimitry Andric } 19950b57cec5SDimitry Andric if (IsModifier) 19960b57cec5SDimitry Andric BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType(); 19970b57cec5SDimitry Andric } 19980b57cec5SDimitry Andric 19990b57cec5SDimitry Andric // Check if the inner type will use an LF_POINTER record. If so, the 20000b57cec5SDimitry Andric // qualifiers will go in the LF_POINTER record. This comes up for types like 20010b57cec5SDimitry Andric // 'int *const' and 'int *__restrict', not the more common cases like 'const 20020b57cec5SDimitry Andric // char *'. 20030b57cec5SDimitry Andric if (BaseTy) { 20040b57cec5SDimitry Andric switch (BaseTy->getTag()) { 20050b57cec5SDimitry Andric case dwarf::DW_TAG_pointer_type: 20060b57cec5SDimitry Andric case dwarf::DW_TAG_reference_type: 20070b57cec5SDimitry Andric case dwarf::DW_TAG_rvalue_reference_type: 20080b57cec5SDimitry Andric return lowerTypePointer(cast<DIDerivedType>(BaseTy), PO); 20090b57cec5SDimitry Andric case dwarf::DW_TAG_ptr_to_member_type: 20100b57cec5SDimitry Andric return lowerTypeMemberPointer(cast<DIDerivedType>(BaseTy), PO); 20110b57cec5SDimitry Andric default: 20120b57cec5SDimitry Andric break; 20130b57cec5SDimitry Andric } 20140b57cec5SDimitry Andric } 20150b57cec5SDimitry Andric 20160b57cec5SDimitry Andric TypeIndex ModifiedTI = getTypeIndex(BaseTy); 20170b57cec5SDimitry Andric 20180b57cec5SDimitry Andric // Return the base type index if there aren't any modifiers. For example, the 20190b57cec5SDimitry Andric // metadata could contain restrict wrappers around non-pointer types. 20200b57cec5SDimitry Andric if (Mods == ModifierOptions::None) 20210b57cec5SDimitry Andric return ModifiedTI; 20220b57cec5SDimitry Andric 20230b57cec5SDimitry Andric ModifierRecord MR(ModifiedTI, Mods); 20240b57cec5SDimitry Andric return TypeTable.writeLeafType(MR); 20250b57cec5SDimitry Andric } 20260b57cec5SDimitry Andric 20270b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) { 20280b57cec5SDimitry Andric SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices; 20290b57cec5SDimitry Andric for (const DIType *ArgType : Ty->getTypeArray()) 20300b57cec5SDimitry Andric ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgType)); 20310b57cec5SDimitry Andric 20320b57cec5SDimitry Andric // MSVC uses type none for variadic argument. 20330b57cec5SDimitry Andric if (ReturnAndArgTypeIndices.size() > 1 && 20340b57cec5SDimitry Andric ReturnAndArgTypeIndices.back() == TypeIndex::Void()) { 20350b57cec5SDimitry Andric ReturnAndArgTypeIndices.back() = TypeIndex::None(); 20360b57cec5SDimitry Andric } 20370b57cec5SDimitry Andric TypeIndex ReturnTypeIndex = TypeIndex::Void(); 20380b57cec5SDimitry Andric ArrayRef<TypeIndex> ArgTypeIndices = None; 20390b57cec5SDimitry Andric if (!ReturnAndArgTypeIndices.empty()) { 20400b57cec5SDimitry Andric auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices); 20410b57cec5SDimitry Andric ReturnTypeIndex = ReturnAndArgTypesRef.front(); 20420b57cec5SDimitry Andric ArgTypeIndices = ReturnAndArgTypesRef.drop_front(); 20430b57cec5SDimitry Andric } 20440b57cec5SDimitry Andric 20450b57cec5SDimitry Andric ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices); 20460b57cec5SDimitry Andric TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec); 20470b57cec5SDimitry Andric 20480b57cec5SDimitry Andric CallingConvention CC = dwarfCCToCodeView(Ty->getCC()); 20490b57cec5SDimitry Andric 20500b57cec5SDimitry Andric FunctionOptions FO = getFunctionOptions(Ty); 20510b57cec5SDimitry Andric ProcedureRecord Procedure(ReturnTypeIndex, CC, FO, ArgTypeIndices.size(), 20520b57cec5SDimitry Andric ArgListIndex); 20530b57cec5SDimitry Andric return TypeTable.writeLeafType(Procedure); 20540b57cec5SDimitry Andric } 20550b57cec5SDimitry Andric 20560b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty, 20570b57cec5SDimitry Andric const DIType *ClassTy, 20580b57cec5SDimitry Andric int ThisAdjustment, 20590b57cec5SDimitry Andric bool IsStaticMethod, 20600b57cec5SDimitry Andric FunctionOptions FO) { 20610b57cec5SDimitry Andric // Lower the containing class type. 20620b57cec5SDimitry Andric TypeIndex ClassType = getTypeIndex(ClassTy); 20630b57cec5SDimitry Andric 20640b57cec5SDimitry Andric DITypeRefArray ReturnAndArgs = Ty->getTypeArray(); 20650b57cec5SDimitry Andric 20660b57cec5SDimitry Andric unsigned Index = 0; 20670b57cec5SDimitry Andric SmallVector<TypeIndex, 8> ArgTypeIndices; 20680b57cec5SDimitry Andric TypeIndex ReturnTypeIndex = TypeIndex::Void(); 20690b57cec5SDimitry Andric if (ReturnAndArgs.size() > Index) { 20700b57cec5SDimitry Andric ReturnTypeIndex = getTypeIndex(ReturnAndArgs[Index++]); 20710b57cec5SDimitry Andric } 20720b57cec5SDimitry Andric 20730b57cec5SDimitry Andric // If the first argument is a pointer type and this isn't a static method, 20740b57cec5SDimitry Andric // treat it as the special 'this' parameter, which is encoded separately from 20750b57cec5SDimitry Andric // the arguments. 20760b57cec5SDimitry Andric TypeIndex ThisTypeIndex; 20770b57cec5SDimitry Andric if (!IsStaticMethod && ReturnAndArgs.size() > Index) { 20780b57cec5SDimitry Andric if (const DIDerivedType *PtrTy = 20790b57cec5SDimitry Andric dyn_cast_or_null<DIDerivedType>(ReturnAndArgs[Index])) { 20800b57cec5SDimitry Andric if (PtrTy->getTag() == dwarf::DW_TAG_pointer_type) { 20810b57cec5SDimitry Andric ThisTypeIndex = getTypeIndexForThisPtr(PtrTy, Ty); 20820b57cec5SDimitry Andric Index++; 20830b57cec5SDimitry Andric } 20840b57cec5SDimitry Andric } 20850b57cec5SDimitry Andric } 20860b57cec5SDimitry Andric 20870b57cec5SDimitry Andric while (Index < ReturnAndArgs.size()) 20880b57cec5SDimitry Andric ArgTypeIndices.push_back(getTypeIndex(ReturnAndArgs[Index++])); 20890b57cec5SDimitry Andric 20900b57cec5SDimitry Andric // MSVC uses type none for variadic argument. 20910b57cec5SDimitry Andric if (!ArgTypeIndices.empty() && ArgTypeIndices.back() == TypeIndex::Void()) 20920b57cec5SDimitry Andric ArgTypeIndices.back() = TypeIndex::None(); 20930b57cec5SDimitry Andric 20940b57cec5SDimitry Andric ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices); 20950b57cec5SDimitry Andric TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec); 20960b57cec5SDimitry Andric 20970b57cec5SDimitry Andric CallingConvention CC = dwarfCCToCodeView(Ty->getCC()); 20980b57cec5SDimitry Andric 20990b57cec5SDimitry Andric MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC, FO, 21000b57cec5SDimitry Andric ArgTypeIndices.size(), ArgListIndex, ThisAdjustment); 21010b57cec5SDimitry Andric return TypeTable.writeLeafType(MFR); 21020b57cec5SDimitry Andric } 21030b57cec5SDimitry Andric 21040b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) { 21050b57cec5SDimitry Andric unsigned VSlotCount = 21060b57cec5SDimitry Andric Ty->getSizeInBits() / (8 * Asm->MAI->getCodePointerSize()); 21070b57cec5SDimitry Andric SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near); 21080b57cec5SDimitry Andric 21090b57cec5SDimitry Andric VFTableShapeRecord VFTSR(Slots); 21100b57cec5SDimitry Andric return TypeTable.writeLeafType(VFTSR); 21110b57cec5SDimitry Andric } 21120b57cec5SDimitry Andric 21130b57cec5SDimitry Andric static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) { 21140b57cec5SDimitry Andric switch (Flags & DINode::FlagAccessibility) { 21150b57cec5SDimitry Andric case DINode::FlagPrivate: return MemberAccess::Private; 21160b57cec5SDimitry Andric case DINode::FlagPublic: return MemberAccess::Public; 21170b57cec5SDimitry Andric case DINode::FlagProtected: return MemberAccess::Protected; 21180b57cec5SDimitry Andric case 0: 21190b57cec5SDimitry Andric // If there was no explicit access control, provide the default for the tag. 21200b57cec5SDimitry Andric return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private 21210b57cec5SDimitry Andric : MemberAccess::Public; 21220b57cec5SDimitry Andric } 21230b57cec5SDimitry Andric llvm_unreachable("access flags are exclusive"); 21240b57cec5SDimitry Andric } 21250b57cec5SDimitry Andric 21260b57cec5SDimitry Andric static MethodOptions translateMethodOptionFlags(const DISubprogram *SP) { 21270b57cec5SDimitry Andric if (SP->isArtificial()) 21280b57cec5SDimitry Andric return MethodOptions::CompilerGenerated; 21290b57cec5SDimitry Andric 21300b57cec5SDimitry Andric // FIXME: Handle other MethodOptions. 21310b57cec5SDimitry Andric 21320b57cec5SDimitry Andric return MethodOptions::None; 21330b57cec5SDimitry Andric } 21340b57cec5SDimitry Andric 21350b57cec5SDimitry Andric static MethodKind translateMethodKindFlags(const DISubprogram *SP, 21360b57cec5SDimitry Andric bool Introduced) { 21370b57cec5SDimitry Andric if (SP->getFlags() & DINode::FlagStaticMember) 21380b57cec5SDimitry Andric return MethodKind::Static; 21390b57cec5SDimitry Andric 21400b57cec5SDimitry Andric switch (SP->getVirtuality()) { 21410b57cec5SDimitry Andric case dwarf::DW_VIRTUALITY_none: 21420b57cec5SDimitry Andric break; 21430b57cec5SDimitry Andric case dwarf::DW_VIRTUALITY_virtual: 21440b57cec5SDimitry Andric return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual; 21450b57cec5SDimitry Andric case dwarf::DW_VIRTUALITY_pure_virtual: 21460b57cec5SDimitry Andric return Introduced ? MethodKind::PureIntroducingVirtual 21470b57cec5SDimitry Andric : MethodKind::PureVirtual; 21480b57cec5SDimitry Andric default: 21490b57cec5SDimitry Andric llvm_unreachable("unhandled virtuality case"); 21500b57cec5SDimitry Andric } 21510b57cec5SDimitry Andric 21520b57cec5SDimitry Andric return MethodKind::Vanilla; 21530b57cec5SDimitry Andric } 21540b57cec5SDimitry Andric 21550b57cec5SDimitry Andric static TypeRecordKind getRecordKind(const DICompositeType *Ty) { 21560b57cec5SDimitry Andric switch (Ty->getTag()) { 2157fe6060f1SDimitry Andric case dwarf::DW_TAG_class_type: 2158fe6060f1SDimitry Andric return TypeRecordKind::Class; 2159fe6060f1SDimitry Andric case dwarf::DW_TAG_structure_type: 2160fe6060f1SDimitry Andric return TypeRecordKind::Struct; 2161fe6060f1SDimitry Andric default: 21620b57cec5SDimitry Andric llvm_unreachable("unexpected tag"); 21630b57cec5SDimitry Andric } 2164fe6060f1SDimitry Andric } 21650b57cec5SDimitry Andric 21660b57cec5SDimitry Andric /// Return ClassOptions that should be present on both the forward declaration 21670b57cec5SDimitry Andric /// and the defintion of a tag type. 21680b57cec5SDimitry Andric static ClassOptions getCommonClassOptions(const DICompositeType *Ty) { 21690b57cec5SDimitry Andric ClassOptions CO = ClassOptions::None; 21700b57cec5SDimitry Andric 21710b57cec5SDimitry Andric // MSVC always sets this flag, even for local types. Clang doesn't always 21720b57cec5SDimitry Andric // appear to give every type a linkage name, which may be problematic for us. 21730b57cec5SDimitry Andric // FIXME: Investigate the consequences of not following them here. 21740b57cec5SDimitry Andric if (!Ty->getIdentifier().empty()) 21750b57cec5SDimitry Andric CO |= ClassOptions::HasUniqueName; 21760b57cec5SDimitry Andric 21770b57cec5SDimitry Andric // Put the Nested flag on a type if it appears immediately inside a tag type. 21780b57cec5SDimitry Andric // Do not walk the scope chain. Do not attempt to compute ContainsNestedClass 21790b57cec5SDimitry Andric // here. That flag is only set on definitions, and not forward declarations. 21800b57cec5SDimitry Andric const DIScope *ImmediateScope = Ty->getScope(); 21810b57cec5SDimitry Andric if (ImmediateScope && isa<DICompositeType>(ImmediateScope)) 21820b57cec5SDimitry Andric CO |= ClassOptions::Nested; 21830b57cec5SDimitry Andric 21840b57cec5SDimitry Andric // Put the Scoped flag on function-local types. MSVC puts this flag for enum 21850b57cec5SDimitry Andric // type only when it has an immediate function scope. Clang never puts enums 21860b57cec5SDimitry Andric // inside DILexicalBlock scopes. Enum types, as generated by clang, are 21870b57cec5SDimitry Andric // always in function, class, or file scopes. 21880b57cec5SDimitry Andric if (Ty->getTag() == dwarf::DW_TAG_enumeration_type) { 21890b57cec5SDimitry Andric if (ImmediateScope && isa<DISubprogram>(ImmediateScope)) 21900b57cec5SDimitry Andric CO |= ClassOptions::Scoped; 21910b57cec5SDimitry Andric } else { 21920b57cec5SDimitry Andric for (const DIScope *Scope = ImmediateScope; Scope != nullptr; 21930b57cec5SDimitry Andric Scope = Scope->getScope()) { 21940b57cec5SDimitry Andric if (isa<DISubprogram>(Scope)) { 21950b57cec5SDimitry Andric CO |= ClassOptions::Scoped; 21960b57cec5SDimitry Andric break; 21970b57cec5SDimitry Andric } 21980b57cec5SDimitry Andric } 21990b57cec5SDimitry Andric } 22000b57cec5SDimitry Andric 22010b57cec5SDimitry Andric return CO; 22020b57cec5SDimitry Andric } 22030b57cec5SDimitry Andric 22040b57cec5SDimitry Andric void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) { 22050b57cec5SDimitry Andric switch (Ty->getTag()) { 22060b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 22070b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 22080b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 22090b57cec5SDimitry Andric case dwarf::DW_TAG_enumeration_type: 22100b57cec5SDimitry Andric break; 22110b57cec5SDimitry Andric default: 22120b57cec5SDimitry Andric return; 22130b57cec5SDimitry Andric } 22140b57cec5SDimitry Andric 22150b57cec5SDimitry Andric if (const auto *File = Ty->getFile()) { 22160b57cec5SDimitry Andric StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File)); 22170b57cec5SDimitry Andric TypeIndex SIDI = TypeTable.writeLeafType(SIDR); 22180b57cec5SDimitry Andric 22190b57cec5SDimitry Andric UdtSourceLineRecord USLR(TI, SIDI, Ty->getLine()); 22200b57cec5SDimitry Andric TypeTable.writeLeafType(USLR); 22210b57cec5SDimitry Andric } 22220b57cec5SDimitry Andric } 22230b57cec5SDimitry Andric 22240b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) { 22250b57cec5SDimitry Andric ClassOptions CO = getCommonClassOptions(Ty); 22260b57cec5SDimitry Andric TypeIndex FTI; 22270b57cec5SDimitry Andric unsigned EnumeratorCount = 0; 22280b57cec5SDimitry Andric 22290b57cec5SDimitry Andric if (Ty->isForwardDecl()) { 22300b57cec5SDimitry Andric CO |= ClassOptions::ForwardReference; 22310b57cec5SDimitry Andric } else { 22320b57cec5SDimitry Andric ContinuationRecordBuilder ContinuationBuilder; 22330b57cec5SDimitry Andric ContinuationBuilder.begin(ContinuationRecordKind::FieldList); 22340b57cec5SDimitry Andric for (const DINode *Element : Ty->getElements()) { 22350b57cec5SDimitry Andric // We assume that the frontend provides all members in source declaration 22360b57cec5SDimitry Andric // order, which is what MSVC does. 22370b57cec5SDimitry Andric if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) { 2238fe6060f1SDimitry Andric // FIXME: Is it correct to always emit these as unsigned here? 22390b57cec5SDimitry Andric EnumeratorRecord ER(MemberAccess::Public, 22405ffd83dbSDimitry Andric APSInt(Enumerator->getValue(), true), 22410b57cec5SDimitry Andric Enumerator->getName()); 22420b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(ER); 22430b57cec5SDimitry Andric EnumeratorCount++; 22440b57cec5SDimitry Andric } 22450b57cec5SDimitry Andric } 22460b57cec5SDimitry Andric FTI = TypeTable.insertRecord(ContinuationBuilder); 22470b57cec5SDimitry Andric } 22480b57cec5SDimitry Andric 22490b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 22500b57cec5SDimitry Andric 22510b57cec5SDimitry Andric EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(), 22520b57cec5SDimitry Andric getTypeIndex(Ty->getBaseType())); 22530b57cec5SDimitry Andric TypeIndex EnumTI = TypeTable.writeLeafType(ER); 22540b57cec5SDimitry Andric 22550b57cec5SDimitry Andric addUDTSrcLine(Ty, EnumTI); 22560b57cec5SDimitry Andric 22570b57cec5SDimitry Andric return EnumTI; 22580b57cec5SDimitry Andric } 22590b57cec5SDimitry Andric 22600b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 22610b57cec5SDimitry Andric // ClassInfo 22620b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 22630b57cec5SDimitry Andric 22640b57cec5SDimitry Andric struct llvm::ClassInfo { 22650b57cec5SDimitry Andric struct MemberInfo { 22660b57cec5SDimitry Andric const DIDerivedType *MemberTypeNode; 22670b57cec5SDimitry Andric uint64_t BaseOffset; 22680b57cec5SDimitry Andric }; 22690b57cec5SDimitry Andric // [MemberInfo] 22700b57cec5SDimitry Andric using MemberList = std::vector<MemberInfo>; 22710b57cec5SDimitry Andric 22720b57cec5SDimitry Andric using MethodsList = TinyPtrVector<const DISubprogram *>; 22730b57cec5SDimitry Andric // MethodName -> MethodsList 22740b57cec5SDimitry Andric using MethodsMap = MapVector<MDString *, MethodsList>; 22750b57cec5SDimitry Andric 22760b57cec5SDimitry Andric /// Base classes. 22770b57cec5SDimitry Andric std::vector<const DIDerivedType *> Inheritance; 22780b57cec5SDimitry Andric 22790b57cec5SDimitry Andric /// Direct members. 22800b57cec5SDimitry Andric MemberList Members; 22810b57cec5SDimitry Andric // Direct overloaded methods gathered by name. 22820b57cec5SDimitry Andric MethodsMap Methods; 22830b57cec5SDimitry Andric 22840b57cec5SDimitry Andric TypeIndex VShapeTI; 22850b57cec5SDimitry Andric 22860b57cec5SDimitry Andric std::vector<const DIType *> NestedTypes; 22870b57cec5SDimitry Andric }; 22880b57cec5SDimitry Andric 22890b57cec5SDimitry Andric void CodeViewDebug::clear() { 22900b57cec5SDimitry Andric assert(CurFn == nullptr); 22910b57cec5SDimitry Andric FileIdMap.clear(); 22920b57cec5SDimitry Andric FnDebugInfo.clear(); 22930b57cec5SDimitry Andric FileToFilepathMap.clear(); 22940b57cec5SDimitry Andric LocalUDTs.clear(); 22950b57cec5SDimitry Andric GlobalUDTs.clear(); 22960b57cec5SDimitry Andric TypeIndices.clear(); 22970b57cec5SDimitry Andric CompleteTypeIndices.clear(); 22980b57cec5SDimitry Andric ScopeGlobals.clear(); 2299349cc55cSDimitry Andric CVGlobalVariableOffsets.clear(); 23000b57cec5SDimitry Andric } 23010b57cec5SDimitry Andric 23020b57cec5SDimitry Andric void CodeViewDebug::collectMemberInfo(ClassInfo &Info, 23030b57cec5SDimitry Andric const DIDerivedType *DDTy) { 23040b57cec5SDimitry Andric if (!DDTy->getName().empty()) { 23050b57cec5SDimitry Andric Info.Members.push_back({DDTy, 0}); 2306e8d8bef9SDimitry Andric 2307e8d8bef9SDimitry Andric // Collect static const data members with values. 2308e8d8bef9SDimitry Andric if ((DDTy->getFlags() & DINode::FlagStaticMember) == 2309e8d8bef9SDimitry Andric DINode::FlagStaticMember) { 2310e8d8bef9SDimitry Andric if (DDTy->getConstant() && (isa<ConstantInt>(DDTy->getConstant()) || 2311e8d8bef9SDimitry Andric isa<ConstantFP>(DDTy->getConstant()))) 2312e8d8bef9SDimitry Andric StaticConstMembers.push_back(DDTy); 2313e8d8bef9SDimitry Andric } 2314e8d8bef9SDimitry Andric 23150b57cec5SDimitry Andric return; 23160b57cec5SDimitry Andric } 23170b57cec5SDimitry Andric 23180b57cec5SDimitry Andric // An unnamed member may represent a nested struct or union. Attempt to 23190b57cec5SDimitry Andric // interpret the unnamed member as a DICompositeType possibly wrapped in 23200b57cec5SDimitry Andric // qualifier types. Add all the indirect fields to the current record if that 23210b57cec5SDimitry Andric // succeeds, and drop the member if that fails. 23220b57cec5SDimitry Andric assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!"); 23230b57cec5SDimitry Andric uint64_t Offset = DDTy->getOffsetInBits(); 23240b57cec5SDimitry Andric const DIType *Ty = DDTy->getBaseType(); 23250b57cec5SDimitry Andric bool FullyResolved = false; 23260b57cec5SDimitry Andric while (!FullyResolved) { 23270b57cec5SDimitry Andric switch (Ty->getTag()) { 23280b57cec5SDimitry Andric case dwarf::DW_TAG_const_type: 23290b57cec5SDimitry Andric case dwarf::DW_TAG_volatile_type: 23300b57cec5SDimitry Andric // FIXME: we should apply the qualifier types to the indirect fields 23310b57cec5SDimitry Andric // rather than dropping them. 23320b57cec5SDimitry Andric Ty = cast<DIDerivedType>(Ty)->getBaseType(); 23330b57cec5SDimitry Andric break; 23340b57cec5SDimitry Andric default: 23350b57cec5SDimitry Andric FullyResolved = true; 23360b57cec5SDimitry Andric break; 23370b57cec5SDimitry Andric } 23380b57cec5SDimitry Andric } 23390b57cec5SDimitry Andric 23400b57cec5SDimitry Andric const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty); 23410b57cec5SDimitry Andric if (!DCTy) 23420b57cec5SDimitry Andric return; 23430b57cec5SDimitry Andric 23440b57cec5SDimitry Andric ClassInfo NestedInfo = collectClassInfo(DCTy); 23450b57cec5SDimitry Andric for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members) 23460b57cec5SDimitry Andric Info.Members.push_back( 23470b57cec5SDimitry Andric {IndirectField.MemberTypeNode, IndirectField.BaseOffset + Offset}); 23480b57cec5SDimitry Andric } 23490b57cec5SDimitry Andric 23500b57cec5SDimitry Andric ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) { 23510b57cec5SDimitry Andric ClassInfo Info; 23520b57cec5SDimitry Andric // Add elements to structure type. 23530b57cec5SDimitry Andric DINodeArray Elements = Ty->getElements(); 23540b57cec5SDimitry Andric for (auto *Element : Elements) { 23550b57cec5SDimitry Andric // We assume that the frontend provides all members in source declaration 23560b57cec5SDimitry Andric // order, which is what MSVC does. 23570b57cec5SDimitry Andric if (!Element) 23580b57cec5SDimitry Andric continue; 23590b57cec5SDimitry Andric if (auto *SP = dyn_cast<DISubprogram>(Element)) { 23600b57cec5SDimitry Andric Info.Methods[SP->getRawName()].push_back(SP); 23610b57cec5SDimitry Andric } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) { 23620b57cec5SDimitry Andric if (DDTy->getTag() == dwarf::DW_TAG_member) { 23630b57cec5SDimitry Andric collectMemberInfo(Info, DDTy); 23640b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) { 23650b57cec5SDimitry Andric Info.Inheritance.push_back(DDTy); 23660b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_pointer_type && 23670b57cec5SDimitry Andric DDTy->getName() == "__vtbl_ptr_type") { 23680b57cec5SDimitry Andric Info.VShapeTI = getTypeIndex(DDTy); 23690b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_typedef) { 23700b57cec5SDimitry Andric Info.NestedTypes.push_back(DDTy); 23710b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_friend) { 23720b57cec5SDimitry Andric // Ignore friend members. It appears that MSVC emitted info about 23730b57cec5SDimitry Andric // friends in the past, but modern versions do not. 23740b57cec5SDimitry Andric } 23750b57cec5SDimitry Andric } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) { 23760b57cec5SDimitry Andric Info.NestedTypes.push_back(Composite); 23770b57cec5SDimitry Andric } 23780b57cec5SDimitry Andric // Skip other unrecognized kinds of elements. 23790b57cec5SDimitry Andric } 23800b57cec5SDimitry Andric return Info; 23810b57cec5SDimitry Andric } 23820b57cec5SDimitry Andric 23830b57cec5SDimitry Andric static bool shouldAlwaysEmitCompleteClassType(const DICompositeType *Ty) { 23840b57cec5SDimitry Andric // This routine is used by lowerTypeClass and lowerTypeUnion to determine 23850b57cec5SDimitry Andric // if a complete type should be emitted instead of a forward reference. 23860b57cec5SDimitry Andric return Ty->getName().empty() && Ty->getIdentifier().empty() && 23870b57cec5SDimitry Andric !Ty->isForwardDecl(); 23880b57cec5SDimitry Andric } 23890b57cec5SDimitry Andric 23900b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) { 23910b57cec5SDimitry Andric // Emit the complete type for unnamed structs. C++ classes with methods 23920b57cec5SDimitry Andric // which have a circular reference back to the class type are expected to 23930b57cec5SDimitry Andric // be named by the front-end and should not be "unnamed". C unnamed 23940b57cec5SDimitry Andric // structs should not have circular references. 23950b57cec5SDimitry Andric if (shouldAlwaysEmitCompleteClassType(Ty)) { 23960b57cec5SDimitry Andric // If this unnamed complete type is already in the process of being defined 23970b57cec5SDimitry Andric // then the description of the type is malformed and cannot be emitted 23980b57cec5SDimitry Andric // into CodeView correctly so report a fatal error. 23990b57cec5SDimitry Andric auto I = CompleteTypeIndices.find(Ty); 24000b57cec5SDimitry Andric if (I != CompleteTypeIndices.end() && I->second == TypeIndex()) 24010b57cec5SDimitry Andric report_fatal_error("cannot debug circular reference to unnamed type"); 24020b57cec5SDimitry Andric return getCompleteTypeIndex(Ty); 24030b57cec5SDimitry Andric } 24040b57cec5SDimitry Andric 24050b57cec5SDimitry Andric // First, construct the forward decl. Don't look into Ty to compute the 24060b57cec5SDimitry Andric // forward decl options, since it might not be available in all TUs. 24070b57cec5SDimitry Andric TypeRecordKind Kind = getRecordKind(Ty); 24080b57cec5SDimitry Andric ClassOptions CO = 24090b57cec5SDimitry Andric ClassOptions::ForwardReference | getCommonClassOptions(Ty); 24100b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 24110b57cec5SDimitry Andric ClassRecord CR(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0, 24120b57cec5SDimitry Andric FullName, Ty->getIdentifier()); 24130b57cec5SDimitry Andric TypeIndex FwdDeclTI = TypeTable.writeLeafType(CR); 24140b57cec5SDimitry Andric if (!Ty->isForwardDecl()) 24150b57cec5SDimitry Andric DeferredCompleteTypes.push_back(Ty); 24160b57cec5SDimitry Andric return FwdDeclTI; 24170b57cec5SDimitry Andric } 24180b57cec5SDimitry Andric 24190b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) { 24200b57cec5SDimitry Andric // Construct the field list and complete type record. 24210b57cec5SDimitry Andric TypeRecordKind Kind = getRecordKind(Ty); 24220b57cec5SDimitry Andric ClassOptions CO = getCommonClassOptions(Ty); 24230b57cec5SDimitry Andric TypeIndex FieldTI; 24240b57cec5SDimitry Andric TypeIndex VShapeTI; 24250b57cec5SDimitry Andric unsigned FieldCount; 24260b57cec5SDimitry Andric bool ContainsNestedClass; 24270b57cec5SDimitry Andric std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) = 24280b57cec5SDimitry Andric lowerRecordFieldList(Ty); 24290b57cec5SDimitry Andric 24300b57cec5SDimitry Andric if (ContainsNestedClass) 24310b57cec5SDimitry Andric CO |= ClassOptions::ContainsNestedClass; 24320b57cec5SDimitry Andric 24330b57cec5SDimitry Andric // MSVC appears to set this flag by searching any destructor or method with 24340b57cec5SDimitry Andric // FunctionOptions::Constructor among the emitted members. Clang AST has all 24350b57cec5SDimitry Andric // the members, however special member functions are not yet emitted into 24360b57cec5SDimitry Andric // debug information. For now checking a class's non-triviality seems enough. 24370b57cec5SDimitry Andric // FIXME: not true for a nested unnamed struct. 24380b57cec5SDimitry Andric if (isNonTrivial(Ty)) 24390b57cec5SDimitry Andric CO |= ClassOptions::HasConstructorOrDestructor; 24400b57cec5SDimitry Andric 24410b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 24420b57cec5SDimitry Andric 24430b57cec5SDimitry Andric uint64_t SizeInBytes = Ty->getSizeInBits() / 8; 24440b57cec5SDimitry Andric 24450b57cec5SDimitry Andric ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI, 24460b57cec5SDimitry Andric SizeInBytes, FullName, Ty->getIdentifier()); 24470b57cec5SDimitry Andric TypeIndex ClassTI = TypeTable.writeLeafType(CR); 24480b57cec5SDimitry Andric 24490b57cec5SDimitry Andric addUDTSrcLine(Ty, ClassTI); 24500b57cec5SDimitry Andric 24510b57cec5SDimitry Andric addToUDTs(Ty); 24520b57cec5SDimitry Andric 24530b57cec5SDimitry Andric return ClassTI; 24540b57cec5SDimitry Andric } 24550b57cec5SDimitry Andric 24560b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) { 24570b57cec5SDimitry Andric // Emit the complete type for unnamed unions. 24580b57cec5SDimitry Andric if (shouldAlwaysEmitCompleteClassType(Ty)) 24590b57cec5SDimitry Andric return getCompleteTypeIndex(Ty); 24600b57cec5SDimitry Andric 24610b57cec5SDimitry Andric ClassOptions CO = 24620b57cec5SDimitry Andric ClassOptions::ForwardReference | getCommonClassOptions(Ty); 24630b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 24640b57cec5SDimitry Andric UnionRecord UR(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier()); 24650b57cec5SDimitry Andric TypeIndex FwdDeclTI = TypeTable.writeLeafType(UR); 24660b57cec5SDimitry Andric if (!Ty->isForwardDecl()) 24670b57cec5SDimitry Andric DeferredCompleteTypes.push_back(Ty); 24680b57cec5SDimitry Andric return FwdDeclTI; 24690b57cec5SDimitry Andric } 24700b57cec5SDimitry Andric 24710b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) { 24720b57cec5SDimitry Andric ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty); 24730b57cec5SDimitry Andric TypeIndex FieldTI; 24740b57cec5SDimitry Andric unsigned FieldCount; 24750b57cec5SDimitry Andric bool ContainsNestedClass; 24760b57cec5SDimitry Andric std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) = 24770b57cec5SDimitry Andric lowerRecordFieldList(Ty); 24780b57cec5SDimitry Andric 24790b57cec5SDimitry Andric if (ContainsNestedClass) 24800b57cec5SDimitry Andric CO |= ClassOptions::ContainsNestedClass; 24810b57cec5SDimitry Andric 24820b57cec5SDimitry Andric uint64_t SizeInBytes = Ty->getSizeInBits() / 8; 24830b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 24840b57cec5SDimitry Andric 24850b57cec5SDimitry Andric UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName, 24860b57cec5SDimitry Andric Ty->getIdentifier()); 24870b57cec5SDimitry Andric TypeIndex UnionTI = TypeTable.writeLeafType(UR); 24880b57cec5SDimitry Andric 24890b57cec5SDimitry Andric addUDTSrcLine(Ty, UnionTI); 24900b57cec5SDimitry Andric 24910b57cec5SDimitry Andric addToUDTs(Ty); 24920b57cec5SDimitry Andric 24930b57cec5SDimitry Andric return UnionTI; 24940b57cec5SDimitry Andric } 24950b57cec5SDimitry Andric 24960b57cec5SDimitry Andric std::tuple<TypeIndex, TypeIndex, unsigned, bool> 24970b57cec5SDimitry Andric CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) { 24980b57cec5SDimitry Andric // Manually count members. MSVC appears to count everything that generates a 24990b57cec5SDimitry Andric // field list record. Each individual overload in a method overload group 25000b57cec5SDimitry Andric // contributes to this count, even though the overload group is a single field 25010b57cec5SDimitry Andric // list record. 25020b57cec5SDimitry Andric unsigned MemberCount = 0; 25030b57cec5SDimitry Andric ClassInfo Info = collectClassInfo(Ty); 25040b57cec5SDimitry Andric ContinuationRecordBuilder ContinuationBuilder; 25050b57cec5SDimitry Andric ContinuationBuilder.begin(ContinuationRecordKind::FieldList); 25060b57cec5SDimitry Andric 25070b57cec5SDimitry Andric // Create base classes. 25080b57cec5SDimitry Andric for (const DIDerivedType *I : Info.Inheritance) { 25090b57cec5SDimitry Andric if (I->getFlags() & DINode::FlagVirtual) { 25100b57cec5SDimitry Andric // Virtual base. 25110b57cec5SDimitry Andric unsigned VBPtrOffset = I->getVBPtrOffset(); 25120b57cec5SDimitry Andric // FIXME: Despite the accessor name, the offset is really in bytes. 25130b57cec5SDimitry Andric unsigned VBTableIndex = I->getOffsetInBits() / 4; 25140b57cec5SDimitry Andric auto RecordKind = (I->getFlags() & DINode::FlagIndirectVirtualBase) == DINode::FlagIndirectVirtualBase 25150b57cec5SDimitry Andric ? TypeRecordKind::IndirectVirtualBaseClass 25160b57cec5SDimitry Andric : TypeRecordKind::VirtualBaseClass; 25170b57cec5SDimitry Andric VirtualBaseClassRecord VBCR( 25180b57cec5SDimitry Andric RecordKind, translateAccessFlags(Ty->getTag(), I->getFlags()), 25190b57cec5SDimitry Andric getTypeIndex(I->getBaseType()), getVBPTypeIndex(), VBPtrOffset, 25200b57cec5SDimitry Andric VBTableIndex); 25210b57cec5SDimitry Andric 25220b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(VBCR); 25230b57cec5SDimitry Andric MemberCount++; 25240b57cec5SDimitry Andric } else { 25250b57cec5SDimitry Andric assert(I->getOffsetInBits() % 8 == 0 && 25260b57cec5SDimitry Andric "bases must be on byte boundaries"); 25270b57cec5SDimitry Andric BaseClassRecord BCR(translateAccessFlags(Ty->getTag(), I->getFlags()), 25280b57cec5SDimitry Andric getTypeIndex(I->getBaseType()), 25290b57cec5SDimitry Andric I->getOffsetInBits() / 8); 25300b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(BCR); 25310b57cec5SDimitry Andric MemberCount++; 25320b57cec5SDimitry Andric } 25330b57cec5SDimitry Andric } 25340b57cec5SDimitry Andric 25350b57cec5SDimitry Andric // Create members. 25360b57cec5SDimitry Andric for (ClassInfo::MemberInfo &MemberInfo : Info.Members) { 25370b57cec5SDimitry Andric const DIDerivedType *Member = MemberInfo.MemberTypeNode; 25380b57cec5SDimitry Andric TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType()); 25390b57cec5SDimitry Andric StringRef MemberName = Member->getName(); 25400b57cec5SDimitry Andric MemberAccess Access = 25410b57cec5SDimitry Andric translateAccessFlags(Ty->getTag(), Member->getFlags()); 25420b57cec5SDimitry Andric 25430b57cec5SDimitry Andric if (Member->isStaticMember()) { 25440b57cec5SDimitry Andric StaticDataMemberRecord SDMR(Access, MemberBaseType, MemberName); 25450b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(SDMR); 25460b57cec5SDimitry Andric MemberCount++; 25470b57cec5SDimitry Andric continue; 25480b57cec5SDimitry Andric } 25490b57cec5SDimitry Andric 25500b57cec5SDimitry Andric // Virtual function pointer member. 25510b57cec5SDimitry Andric if ((Member->getFlags() & DINode::FlagArtificial) && 25520b57cec5SDimitry Andric Member->getName().startswith("_vptr$")) { 25530b57cec5SDimitry Andric VFPtrRecord VFPR(getTypeIndex(Member->getBaseType())); 25540b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(VFPR); 25550b57cec5SDimitry Andric MemberCount++; 25560b57cec5SDimitry Andric continue; 25570b57cec5SDimitry Andric } 25580b57cec5SDimitry Andric 25590b57cec5SDimitry Andric // Data member. 25600b57cec5SDimitry Andric uint64_t MemberOffsetInBits = 25610b57cec5SDimitry Andric Member->getOffsetInBits() + MemberInfo.BaseOffset; 25620b57cec5SDimitry Andric if (Member->isBitField()) { 25630b57cec5SDimitry Andric uint64_t StartBitOffset = MemberOffsetInBits; 25640b57cec5SDimitry Andric if (const auto *CI = 25650b57cec5SDimitry Andric dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) { 25660b57cec5SDimitry Andric MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset; 25670b57cec5SDimitry Andric } 25680b57cec5SDimitry Andric StartBitOffset -= MemberOffsetInBits; 25690b57cec5SDimitry Andric BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(), 25700b57cec5SDimitry Andric StartBitOffset); 25710b57cec5SDimitry Andric MemberBaseType = TypeTable.writeLeafType(BFR); 25720b57cec5SDimitry Andric } 25730b57cec5SDimitry Andric uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8; 25740b57cec5SDimitry Andric DataMemberRecord DMR(Access, MemberBaseType, MemberOffsetInBytes, 25750b57cec5SDimitry Andric MemberName); 25760b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(DMR); 25770b57cec5SDimitry Andric MemberCount++; 25780b57cec5SDimitry Andric } 25790b57cec5SDimitry Andric 25800b57cec5SDimitry Andric // Create methods 25810b57cec5SDimitry Andric for (auto &MethodItr : Info.Methods) { 25820b57cec5SDimitry Andric StringRef Name = MethodItr.first->getString(); 25830b57cec5SDimitry Andric 25840b57cec5SDimitry Andric std::vector<OneMethodRecord> Methods; 25850b57cec5SDimitry Andric for (const DISubprogram *SP : MethodItr.second) { 25860b57cec5SDimitry Andric TypeIndex MethodType = getMemberFunctionType(SP, Ty); 25870b57cec5SDimitry Andric bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual; 25880b57cec5SDimitry Andric 25890b57cec5SDimitry Andric unsigned VFTableOffset = -1; 25900b57cec5SDimitry Andric if (Introduced) 25910b57cec5SDimitry Andric VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes(); 25920b57cec5SDimitry Andric 25930b57cec5SDimitry Andric Methods.push_back(OneMethodRecord( 25940b57cec5SDimitry Andric MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()), 25950b57cec5SDimitry Andric translateMethodKindFlags(SP, Introduced), 25960b57cec5SDimitry Andric translateMethodOptionFlags(SP), VFTableOffset, Name)); 25970b57cec5SDimitry Andric MemberCount++; 25980b57cec5SDimitry Andric } 25990b57cec5SDimitry Andric assert(!Methods.empty() && "Empty methods map entry"); 26000b57cec5SDimitry Andric if (Methods.size() == 1) 26010b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(Methods[0]); 26020b57cec5SDimitry Andric else { 26030b57cec5SDimitry Andric // FIXME: Make this use its own ContinuationBuilder so that 26040b57cec5SDimitry Andric // MethodOverloadList can be split correctly. 26050b57cec5SDimitry Andric MethodOverloadListRecord MOLR(Methods); 26060b57cec5SDimitry Andric TypeIndex MethodList = TypeTable.writeLeafType(MOLR); 26070b57cec5SDimitry Andric 26080b57cec5SDimitry Andric OverloadedMethodRecord OMR(Methods.size(), MethodList, Name); 26090b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(OMR); 26100b57cec5SDimitry Andric } 26110b57cec5SDimitry Andric } 26120b57cec5SDimitry Andric 26130b57cec5SDimitry Andric // Create nested classes. 26140b57cec5SDimitry Andric for (const DIType *Nested : Info.NestedTypes) { 26150b57cec5SDimitry Andric NestedTypeRecord R(getTypeIndex(Nested), Nested->getName()); 26160b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(R); 26170b57cec5SDimitry Andric MemberCount++; 26180b57cec5SDimitry Andric } 26190b57cec5SDimitry Andric 26200b57cec5SDimitry Andric TypeIndex FieldTI = TypeTable.insertRecord(ContinuationBuilder); 26210b57cec5SDimitry Andric return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount, 26220b57cec5SDimitry Andric !Info.NestedTypes.empty()); 26230b57cec5SDimitry Andric } 26240b57cec5SDimitry Andric 26250b57cec5SDimitry Andric TypeIndex CodeViewDebug::getVBPTypeIndex() { 26260b57cec5SDimitry Andric if (!VBPType.getIndex()) { 26270b57cec5SDimitry Andric // Make a 'const int *' type. 26280b57cec5SDimitry Andric ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const); 26290b57cec5SDimitry Andric TypeIndex ModifiedTI = TypeTable.writeLeafType(MR); 26300b57cec5SDimitry Andric 26310b57cec5SDimitry Andric PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64 26320b57cec5SDimitry Andric : PointerKind::Near32; 26330b57cec5SDimitry Andric PointerMode PM = PointerMode::Pointer; 26340b57cec5SDimitry Andric PointerOptions PO = PointerOptions::None; 26350b57cec5SDimitry Andric PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes()); 26360b57cec5SDimitry Andric VBPType = TypeTable.writeLeafType(PR); 26370b57cec5SDimitry Andric } 26380b57cec5SDimitry Andric 26390b57cec5SDimitry Andric return VBPType; 26400b57cec5SDimitry Andric } 26410b57cec5SDimitry Andric 26420b57cec5SDimitry Andric TypeIndex CodeViewDebug::getTypeIndex(const DIType *Ty, const DIType *ClassTy) { 26430b57cec5SDimitry Andric // The null DIType is the void type. Don't try to hash it. 26440b57cec5SDimitry Andric if (!Ty) 26450b57cec5SDimitry Andric return TypeIndex::Void(); 26460b57cec5SDimitry Andric 26470b57cec5SDimitry Andric // Check if we've already translated this type. Don't try to do a 26480b57cec5SDimitry Andric // get-or-create style insertion that caches the hash lookup across the 26490b57cec5SDimitry Andric // lowerType call. It will update the TypeIndices map. 26500b57cec5SDimitry Andric auto I = TypeIndices.find({Ty, ClassTy}); 26510b57cec5SDimitry Andric if (I != TypeIndices.end()) 26520b57cec5SDimitry Andric return I->second; 26530b57cec5SDimitry Andric 26540b57cec5SDimitry Andric TypeLoweringScope S(*this); 26550b57cec5SDimitry Andric TypeIndex TI = lowerType(Ty, ClassTy); 26560b57cec5SDimitry Andric return recordTypeIndexForDINode(Ty, TI, ClassTy); 26570b57cec5SDimitry Andric } 26580b57cec5SDimitry Andric 26590b57cec5SDimitry Andric codeview::TypeIndex 26600b57cec5SDimitry Andric CodeViewDebug::getTypeIndexForThisPtr(const DIDerivedType *PtrTy, 26610b57cec5SDimitry Andric const DISubroutineType *SubroutineTy) { 26620b57cec5SDimitry Andric assert(PtrTy->getTag() == dwarf::DW_TAG_pointer_type && 26630b57cec5SDimitry Andric "this type must be a pointer type"); 26640b57cec5SDimitry Andric 26650b57cec5SDimitry Andric PointerOptions Options = PointerOptions::None; 26660b57cec5SDimitry Andric if (SubroutineTy->getFlags() & DINode::DIFlags::FlagLValueReference) 26670b57cec5SDimitry Andric Options = PointerOptions::LValueRefThisPointer; 26680b57cec5SDimitry Andric else if (SubroutineTy->getFlags() & DINode::DIFlags::FlagRValueReference) 26690b57cec5SDimitry Andric Options = PointerOptions::RValueRefThisPointer; 26700b57cec5SDimitry Andric 26710b57cec5SDimitry Andric // Check if we've already translated this type. If there is no ref qualifier 26720b57cec5SDimitry Andric // on the function then we look up this pointer type with no associated class 26730b57cec5SDimitry Andric // so that the TypeIndex for the this pointer can be shared with the type 26740b57cec5SDimitry Andric // index for other pointers to this class type. If there is a ref qualifier 26750b57cec5SDimitry Andric // then we lookup the pointer using the subroutine as the parent type. 26760b57cec5SDimitry Andric auto I = TypeIndices.find({PtrTy, SubroutineTy}); 26770b57cec5SDimitry Andric if (I != TypeIndices.end()) 26780b57cec5SDimitry Andric return I->second; 26790b57cec5SDimitry Andric 26800b57cec5SDimitry Andric TypeLoweringScope S(*this); 26810b57cec5SDimitry Andric TypeIndex TI = lowerTypePointer(PtrTy, Options); 26820b57cec5SDimitry Andric return recordTypeIndexForDINode(PtrTy, TI, SubroutineTy); 26830b57cec5SDimitry Andric } 26840b57cec5SDimitry Andric 26850b57cec5SDimitry Andric TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(const DIType *Ty) { 26860b57cec5SDimitry Andric PointerRecord PR(getTypeIndex(Ty), 26870b57cec5SDimitry Andric getPointerSizeInBytes() == 8 ? PointerKind::Near64 26880b57cec5SDimitry Andric : PointerKind::Near32, 26890b57cec5SDimitry Andric PointerMode::LValueReference, PointerOptions::None, 26900b57cec5SDimitry Andric Ty->getSizeInBits() / 8); 26910b57cec5SDimitry Andric return TypeTable.writeLeafType(PR); 26920b57cec5SDimitry Andric } 26930b57cec5SDimitry Andric 26940b57cec5SDimitry Andric TypeIndex CodeViewDebug::getCompleteTypeIndex(const DIType *Ty) { 26950b57cec5SDimitry Andric // The null DIType is the void type. Don't try to hash it. 26960b57cec5SDimitry Andric if (!Ty) 26970b57cec5SDimitry Andric return TypeIndex::Void(); 26980b57cec5SDimitry Andric 26990b57cec5SDimitry Andric // Look through typedefs when getting the complete type index. Call 27000b57cec5SDimitry Andric // getTypeIndex on the typdef to ensure that any UDTs are accumulated and are 27010b57cec5SDimitry Andric // emitted only once. 27020b57cec5SDimitry Andric if (Ty->getTag() == dwarf::DW_TAG_typedef) 27030b57cec5SDimitry Andric (void)getTypeIndex(Ty); 27040b57cec5SDimitry Andric while (Ty->getTag() == dwarf::DW_TAG_typedef) 27050b57cec5SDimitry Andric Ty = cast<DIDerivedType>(Ty)->getBaseType(); 27060b57cec5SDimitry Andric 27070b57cec5SDimitry Andric // If this is a non-record type, the complete type index is the same as the 27080b57cec5SDimitry Andric // normal type index. Just call getTypeIndex. 27090b57cec5SDimitry Andric switch (Ty->getTag()) { 27100b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 27110b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 27120b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 27130b57cec5SDimitry Andric break; 27140b57cec5SDimitry Andric default: 27150b57cec5SDimitry Andric return getTypeIndex(Ty); 27160b57cec5SDimitry Andric } 27170b57cec5SDimitry Andric 27180b57cec5SDimitry Andric const auto *CTy = cast<DICompositeType>(Ty); 27190b57cec5SDimitry Andric 27200b57cec5SDimitry Andric TypeLoweringScope S(*this); 27210b57cec5SDimitry Andric 27220b57cec5SDimitry Andric // Make sure the forward declaration is emitted first. It's unclear if this 27230b57cec5SDimitry Andric // is necessary, but MSVC does it, and we should follow suit until we can show 27240b57cec5SDimitry Andric // otherwise. 27250b57cec5SDimitry Andric // We only emit a forward declaration for named types. 27260b57cec5SDimitry Andric if (!CTy->getName().empty() || !CTy->getIdentifier().empty()) { 27270b57cec5SDimitry Andric TypeIndex FwdDeclTI = getTypeIndex(CTy); 27280b57cec5SDimitry Andric 27290b57cec5SDimitry Andric // Just use the forward decl if we don't have complete type info. This 27300b57cec5SDimitry Andric // might happen if the frontend is using modules and expects the complete 27310b57cec5SDimitry Andric // definition to be emitted elsewhere. 27320b57cec5SDimitry Andric if (CTy->isForwardDecl()) 27330b57cec5SDimitry Andric return FwdDeclTI; 27340b57cec5SDimitry Andric } 27350b57cec5SDimitry Andric 27360b57cec5SDimitry Andric // Check if we've already translated the complete record type. 27370b57cec5SDimitry Andric // Insert the type with a null TypeIndex to signify that the type is currently 27380b57cec5SDimitry Andric // being lowered. 27390b57cec5SDimitry Andric auto InsertResult = CompleteTypeIndices.insert({CTy, TypeIndex()}); 27400b57cec5SDimitry Andric if (!InsertResult.second) 27410b57cec5SDimitry Andric return InsertResult.first->second; 27420b57cec5SDimitry Andric 27430b57cec5SDimitry Andric TypeIndex TI; 27440b57cec5SDimitry Andric switch (CTy->getTag()) { 27450b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 27460b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 27470b57cec5SDimitry Andric TI = lowerCompleteTypeClass(CTy); 27480b57cec5SDimitry Andric break; 27490b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 27500b57cec5SDimitry Andric TI = lowerCompleteTypeUnion(CTy); 27510b57cec5SDimitry Andric break; 27520b57cec5SDimitry Andric default: 27530b57cec5SDimitry Andric llvm_unreachable("not a record"); 27540b57cec5SDimitry Andric } 27550b57cec5SDimitry Andric 27560b57cec5SDimitry Andric // Update the type index associated with this CompositeType. This cannot 27570b57cec5SDimitry Andric // use the 'InsertResult' iterator above because it is potentially 27580b57cec5SDimitry Andric // invalidated by map insertions which can occur while lowering the class 27590b57cec5SDimitry Andric // type above. 27600b57cec5SDimitry Andric CompleteTypeIndices[CTy] = TI; 27610b57cec5SDimitry Andric return TI; 27620b57cec5SDimitry Andric } 27630b57cec5SDimitry Andric 27640b57cec5SDimitry Andric /// Emit all the deferred complete record types. Try to do this in FIFO order, 27650b57cec5SDimitry Andric /// and do this until fixpoint, as each complete record type typically 27660b57cec5SDimitry Andric /// references 27670b57cec5SDimitry Andric /// many other record types. 27680b57cec5SDimitry Andric void CodeViewDebug::emitDeferredCompleteTypes() { 27690b57cec5SDimitry Andric SmallVector<const DICompositeType *, 4> TypesToEmit; 27700b57cec5SDimitry Andric while (!DeferredCompleteTypes.empty()) { 27710b57cec5SDimitry Andric std::swap(DeferredCompleteTypes, TypesToEmit); 27720b57cec5SDimitry Andric for (const DICompositeType *RecordTy : TypesToEmit) 27730b57cec5SDimitry Andric getCompleteTypeIndex(RecordTy); 27740b57cec5SDimitry Andric TypesToEmit.clear(); 27750b57cec5SDimitry Andric } 27760b57cec5SDimitry Andric } 27770b57cec5SDimitry Andric 27780b57cec5SDimitry Andric void CodeViewDebug::emitLocalVariableList(const FunctionInfo &FI, 27790b57cec5SDimitry Andric ArrayRef<LocalVariable> Locals) { 27800b57cec5SDimitry Andric // Get the sorted list of parameters and emit them first. 27810b57cec5SDimitry Andric SmallVector<const LocalVariable *, 6> Params; 27820b57cec5SDimitry Andric for (const LocalVariable &L : Locals) 27830b57cec5SDimitry Andric if (L.DIVar->isParameter()) 27840b57cec5SDimitry Andric Params.push_back(&L); 27850b57cec5SDimitry Andric llvm::sort(Params, [](const LocalVariable *L, const LocalVariable *R) { 27860b57cec5SDimitry Andric return L->DIVar->getArg() < R->DIVar->getArg(); 27870b57cec5SDimitry Andric }); 27880b57cec5SDimitry Andric for (const LocalVariable *L : Params) 27890b57cec5SDimitry Andric emitLocalVariable(FI, *L); 27900b57cec5SDimitry Andric 27910b57cec5SDimitry Andric // Next emit all non-parameters in the order that we found them. 27920b57cec5SDimitry Andric for (const LocalVariable &L : Locals) 27930b57cec5SDimitry Andric if (!L.DIVar->isParameter()) 27940b57cec5SDimitry Andric emitLocalVariable(FI, L); 27950b57cec5SDimitry Andric } 27960b57cec5SDimitry Andric 27970b57cec5SDimitry Andric void CodeViewDebug::emitLocalVariable(const FunctionInfo &FI, 27980b57cec5SDimitry Andric const LocalVariable &Var) { 27990b57cec5SDimitry Andric // LocalSym record, see SymbolRecord.h for more info. 28000b57cec5SDimitry Andric MCSymbol *LocalEnd = beginSymbolRecord(SymbolKind::S_LOCAL); 28010b57cec5SDimitry Andric 28020b57cec5SDimitry Andric LocalSymFlags Flags = LocalSymFlags::None; 28030b57cec5SDimitry Andric if (Var.DIVar->isParameter()) 28040b57cec5SDimitry Andric Flags |= LocalSymFlags::IsParameter; 28050b57cec5SDimitry Andric if (Var.DefRanges.empty()) 28060b57cec5SDimitry Andric Flags |= LocalSymFlags::IsOptimizedOut; 28070b57cec5SDimitry Andric 28080b57cec5SDimitry Andric OS.AddComment("TypeIndex"); 28090b57cec5SDimitry Andric TypeIndex TI = Var.UseReferenceType 28100b57cec5SDimitry Andric ? getTypeIndexForReferenceTo(Var.DIVar->getType()) 28110b57cec5SDimitry Andric : getCompleteTypeIndex(Var.DIVar->getType()); 28125ffd83dbSDimitry Andric OS.emitInt32(TI.getIndex()); 28130b57cec5SDimitry Andric OS.AddComment("Flags"); 28145ffd83dbSDimitry Andric OS.emitInt16(static_cast<uint16_t>(Flags)); 28150b57cec5SDimitry Andric // Truncate the name so we won't overflow the record length field. 28160b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, Var.DIVar->getName()); 28170b57cec5SDimitry Andric endSymbolRecord(LocalEnd); 28180b57cec5SDimitry Andric 28190b57cec5SDimitry Andric // Calculate the on disk prefix of the appropriate def range record. The 28200b57cec5SDimitry Andric // records and on disk formats are described in SymbolRecords.h. BytePrefix 28210b57cec5SDimitry Andric // should be big enough to hold all forms without memory allocation. 28220b57cec5SDimitry Andric SmallString<20> BytePrefix; 28230b57cec5SDimitry Andric for (const LocalVarDefRange &DefRange : Var.DefRanges) { 28240b57cec5SDimitry Andric BytePrefix.clear(); 28250b57cec5SDimitry Andric if (DefRange.InMemory) { 28260b57cec5SDimitry Andric int Offset = DefRange.DataOffset; 28270b57cec5SDimitry Andric unsigned Reg = DefRange.CVRegister; 28280b57cec5SDimitry Andric 28290b57cec5SDimitry Andric // 32-bit x86 call sequences often use PUSH instructions, which disrupt 28300b57cec5SDimitry Andric // ESP-relative offsets. Use the virtual frame pointer, VFRAME or $T0, 28310b57cec5SDimitry Andric // instead. In frames without stack realignment, $T0 will be the CFA. 28320b57cec5SDimitry Andric if (RegisterId(Reg) == RegisterId::ESP) { 28330b57cec5SDimitry Andric Reg = unsigned(RegisterId::VFRAME); 28340b57cec5SDimitry Andric Offset += FI.OffsetAdjustment; 28350b57cec5SDimitry Andric } 28360b57cec5SDimitry Andric 28370b57cec5SDimitry Andric // If we can use the chosen frame pointer for the frame and this isn't a 28380b57cec5SDimitry Andric // sliced aggregate, use the smaller S_DEFRANGE_FRAMEPOINTER_REL record. 28390b57cec5SDimitry Andric // Otherwise, use S_DEFRANGE_REGISTER_REL. 28400b57cec5SDimitry Andric EncodedFramePtrReg EncFP = encodeFramePtrReg(RegisterId(Reg), TheCPU); 28410b57cec5SDimitry Andric if (!DefRange.IsSubfield && EncFP != EncodedFramePtrReg::None && 28420b57cec5SDimitry Andric (bool(Flags & LocalSymFlags::IsParameter) 28430b57cec5SDimitry Andric ? (EncFP == FI.EncodedParamFramePtrReg) 28440b57cec5SDimitry Andric : (EncFP == FI.EncodedLocalFramePtrReg))) { 28458bcb0991SDimitry Andric DefRangeFramePointerRelHeader DRHdr; 28468bcb0991SDimitry Andric DRHdr.Offset = Offset; 28475ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 28480b57cec5SDimitry Andric } else { 28490b57cec5SDimitry Andric uint16_t RegRelFlags = 0; 28500b57cec5SDimitry Andric if (DefRange.IsSubfield) { 28510b57cec5SDimitry Andric RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag | 28520b57cec5SDimitry Andric (DefRange.StructOffset 28530b57cec5SDimitry Andric << DefRangeRegisterRelSym::OffsetInParentShift); 28540b57cec5SDimitry Andric } 28558bcb0991SDimitry Andric DefRangeRegisterRelHeader DRHdr; 28560b57cec5SDimitry Andric DRHdr.Register = Reg; 28570b57cec5SDimitry Andric DRHdr.Flags = RegRelFlags; 28580b57cec5SDimitry Andric DRHdr.BasePointerOffset = Offset; 28595ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 28600b57cec5SDimitry Andric } 28610b57cec5SDimitry Andric } else { 28620b57cec5SDimitry Andric assert(DefRange.DataOffset == 0 && "unexpected offset into register"); 28630b57cec5SDimitry Andric if (DefRange.IsSubfield) { 28648bcb0991SDimitry Andric DefRangeSubfieldRegisterHeader DRHdr; 28650b57cec5SDimitry Andric DRHdr.Register = DefRange.CVRegister; 28660b57cec5SDimitry Andric DRHdr.MayHaveNoName = 0; 28670b57cec5SDimitry Andric DRHdr.OffsetInParent = DefRange.StructOffset; 28685ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 28690b57cec5SDimitry Andric } else { 28708bcb0991SDimitry Andric DefRangeRegisterHeader DRHdr; 28710b57cec5SDimitry Andric DRHdr.Register = DefRange.CVRegister; 28720b57cec5SDimitry Andric DRHdr.MayHaveNoName = 0; 28735ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 28740b57cec5SDimitry Andric } 28750b57cec5SDimitry Andric } 28760b57cec5SDimitry Andric } 28770b57cec5SDimitry Andric } 28780b57cec5SDimitry Andric 28790b57cec5SDimitry Andric void CodeViewDebug::emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks, 28800b57cec5SDimitry Andric const FunctionInfo& FI) { 28810b57cec5SDimitry Andric for (LexicalBlock *Block : Blocks) 28820b57cec5SDimitry Andric emitLexicalBlock(*Block, FI); 28830b57cec5SDimitry Andric } 28840b57cec5SDimitry Andric 28850b57cec5SDimitry Andric /// Emit an S_BLOCK32 and S_END record pair delimiting the contents of a 28860b57cec5SDimitry Andric /// lexical block scope. 28870b57cec5SDimitry Andric void CodeViewDebug::emitLexicalBlock(const LexicalBlock &Block, 28880b57cec5SDimitry Andric const FunctionInfo& FI) { 28890b57cec5SDimitry Andric MCSymbol *RecordEnd = beginSymbolRecord(SymbolKind::S_BLOCK32); 28900b57cec5SDimitry Andric OS.AddComment("PtrParent"); 28915ffd83dbSDimitry Andric OS.emitInt32(0); // PtrParent 28920b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 28935ffd83dbSDimitry Andric OS.emitInt32(0); // PtrEnd 28940b57cec5SDimitry Andric OS.AddComment("Code size"); 28950b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(Block.End, Block.Begin, 4); // Code Size 28960b57cec5SDimitry Andric OS.AddComment("Function section relative address"); 28970b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Block.Begin, /*Offset=*/0); // Func Offset 28980b57cec5SDimitry Andric OS.AddComment("Function section index"); 28990b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(FI.Begin); // Func Symbol 29000b57cec5SDimitry Andric OS.AddComment("Lexical block name"); 29010b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, Block.Name); // Name 29020b57cec5SDimitry Andric endSymbolRecord(RecordEnd); 29030b57cec5SDimitry Andric 29040b57cec5SDimitry Andric // Emit variables local to this lexical block. 29050b57cec5SDimitry Andric emitLocalVariableList(FI, Block.Locals); 29060b57cec5SDimitry Andric emitGlobalVariableList(Block.Globals); 29070b57cec5SDimitry Andric 29080b57cec5SDimitry Andric // Emit lexical blocks contained within this block. 29090b57cec5SDimitry Andric emitLexicalBlockList(Block.Children, FI); 29100b57cec5SDimitry Andric 29110b57cec5SDimitry Andric // Close the lexical block scope. 29120b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_END); 29130b57cec5SDimitry Andric } 29140b57cec5SDimitry Andric 29150b57cec5SDimitry Andric /// Convenience routine for collecting lexical block information for a list 29160b57cec5SDimitry Andric /// of lexical scopes. 29170b57cec5SDimitry Andric void CodeViewDebug::collectLexicalBlockInfo( 29180b57cec5SDimitry Andric SmallVectorImpl<LexicalScope *> &Scopes, 29190b57cec5SDimitry Andric SmallVectorImpl<LexicalBlock *> &Blocks, 29200b57cec5SDimitry Andric SmallVectorImpl<LocalVariable> &Locals, 29210b57cec5SDimitry Andric SmallVectorImpl<CVGlobalVariable> &Globals) { 29220b57cec5SDimitry Andric for (LexicalScope *Scope : Scopes) 29230b57cec5SDimitry Andric collectLexicalBlockInfo(*Scope, Blocks, Locals, Globals); 29240b57cec5SDimitry Andric } 29250b57cec5SDimitry Andric 29260b57cec5SDimitry Andric /// Populate the lexical blocks and local variable lists of the parent with 29270b57cec5SDimitry Andric /// information about the specified lexical scope. 29280b57cec5SDimitry Andric void CodeViewDebug::collectLexicalBlockInfo( 29290b57cec5SDimitry Andric LexicalScope &Scope, 29300b57cec5SDimitry Andric SmallVectorImpl<LexicalBlock *> &ParentBlocks, 29310b57cec5SDimitry Andric SmallVectorImpl<LocalVariable> &ParentLocals, 29320b57cec5SDimitry Andric SmallVectorImpl<CVGlobalVariable> &ParentGlobals) { 29330b57cec5SDimitry Andric if (Scope.isAbstractScope()) 29340b57cec5SDimitry Andric return; 29350b57cec5SDimitry Andric 29360b57cec5SDimitry Andric // Gather information about the lexical scope including local variables, 29370b57cec5SDimitry Andric // global variables, and address ranges. 29380b57cec5SDimitry Andric bool IgnoreScope = false; 29390b57cec5SDimitry Andric auto LI = ScopeVariables.find(&Scope); 29400b57cec5SDimitry Andric SmallVectorImpl<LocalVariable> *Locals = 29410b57cec5SDimitry Andric LI != ScopeVariables.end() ? &LI->second : nullptr; 29420b57cec5SDimitry Andric auto GI = ScopeGlobals.find(Scope.getScopeNode()); 29430b57cec5SDimitry Andric SmallVectorImpl<CVGlobalVariable> *Globals = 29440b57cec5SDimitry Andric GI != ScopeGlobals.end() ? GI->second.get() : nullptr; 29450b57cec5SDimitry Andric const DILexicalBlock *DILB = dyn_cast<DILexicalBlock>(Scope.getScopeNode()); 29460b57cec5SDimitry Andric const SmallVectorImpl<InsnRange> &Ranges = Scope.getRanges(); 29470b57cec5SDimitry Andric 29480b57cec5SDimitry Andric // Ignore lexical scopes which do not contain variables. 29490b57cec5SDimitry Andric if (!Locals && !Globals) 29500b57cec5SDimitry Andric IgnoreScope = true; 29510b57cec5SDimitry Andric 29520b57cec5SDimitry Andric // Ignore lexical scopes which are not lexical blocks. 29530b57cec5SDimitry Andric if (!DILB) 29540b57cec5SDimitry Andric IgnoreScope = true; 29550b57cec5SDimitry Andric 29560b57cec5SDimitry Andric // Ignore scopes which have too many address ranges to represent in the 29570b57cec5SDimitry Andric // current CodeView format or do not have a valid address range. 29580b57cec5SDimitry Andric // 29590b57cec5SDimitry Andric // For lexical scopes with multiple address ranges you may be tempted to 29600b57cec5SDimitry Andric // construct a single range covering every instruction where the block is 29610b57cec5SDimitry Andric // live and everything in between. Unfortunately, Visual Studio only 29620b57cec5SDimitry Andric // displays variables from the first matching lexical block scope. If the 29630b57cec5SDimitry Andric // first lexical block contains exception handling code or cold code which 29640b57cec5SDimitry Andric // is moved to the bottom of the routine creating a single range covering 29650b57cec5SDimitry Andric // nearly the entire routine, then it will hide all other lexical blocks 29660b57cec5SDimitry Andric // and the variables they contain. 29670b57cec5SDimitry Andric if (Ranges.size() != 1 || !getLabelAfterInsn(Ranges.front().second)) 29680b57cec5SDimitry Andric IgnoreScope = true; 29690b57cec5SDimitry Andric 29700b57cec5SDimitry Andric if (IgnoreScope) { 29710b57cec5SDimitry Andric // This scope can be safely ignored and eliminating it will reduce the 29720b57cec5SDimitry Andric // size of the debug information. Be sure to collect any variable and scope 29730b57cec5SDimitry Andric // information from the this scope or any of its children and collapse them 29740b57cec5SDimitry Andric // into the parent scope. 29750b57cec5SDimitry Andric if (Locals) 29760b57cec5SDimitry Andric ParentLocals.append(Locals->begin(), Locals->end()); 29770b57cec5SDimitry Andric if (Globals) 29780b57cec5SDimitry Andric ParentGlobals.append(Globals->begin(), Globals->end()); 29790b57cec5SDimitry Andric collectLexicalBlockInfo(Scope.getChildren(), 29800b57cec5SDimitry Andric ParentBlocks, 29810b57cec5SDimitry Andric ParentLocals, 29820b57cec5SDimitry Andric ParentGlobals); 29830b57cec5SDimitry Andric return; 29840b57cec5SDimitry Andric } 29850b57cec5SDimitry Andric 29860b57cec5SDimitry Andric // Create a new CodeView lexical block for this lexical scope. If we've 29870b57cec5SDimitry Andric // seen this DILexicalBlock before then the scope tree is malformed and 29880b57cec5SDimitry Andric // we can handle this gracefully by not processing it a second time. 29890b57cec5SDimitry Andric auto BlockInsertion = CurFn->LexicalBlocks.insert({DILB, LexicalBlock()}); 29900b57cec5SDimitry Andric if (!BlockInsertion.second) 29910b57cec5SDimitry Andric return; 29920b57cec5SDimitry Andric 29930b57cec5SDimitry Andric // Create a lexical block containing the variables and collect the the 29940b57cec5SDimitry Andric // lexical block information for the children. 29950b57cec5SDimitry Andric const InsnRange &Range = Ranges.front(); 29960b57cec5SDimitry Andric assert(Range.first && Range.second); 29970b57cec5SDimitry Andric LexicalBlock &Block = BlockInsertion.first->second; 29980b57cec5SDimitry Andric Block.Begin = getLabelBeforeInsn(Range.first); 29990b57cec5SDimitry Andric Block.End = getLabelAfterInsn(Range.second); 30000b57cec5SDimitry Andric assert(Block.Begin && "missing label for scope begin"); 30010b57cec5SDimitry Andric assert(Block.End && "missing label for scope end"); 30020b57cec5SDimitry Andric Block.Name = DILB->getName(); 30030b57cec5SDimitry Andric if (Locals) 30040b57cec5SDimitry Andric Block.Locals = std::move(*Locals); 30050b57cec5SDimitry Andric if (Globals) 30060b57cec5SDimitry Andric Block.Globals = std::move(*Globals); 30070b57cec5SDimitry Andric ParentBlocks.push_back(&Block); 30080b57cec5SDimitry Andric collectLexicalBlockInfo(Scope.getChildren(), 30090b57cec5SDimitry Andric Block.Children, 30100b57cec5SDimitry Andric Block.Locals, 30110b57cec5SDimitry Andric Block.Globals); 30120b57cec5SDimitry Andric } 30130b57cec5SDimitry Andric 30140b57cec5SDimitry Andric void CodeViewDebug::endFunctionImpl(const MachineFunction *MF) { 30150b57cec5SDimitry Andric const Function &GV = MF->getFunction(); 30160b57cec5SDimitry Andric assert(FnDebugInfo.count(&GV)); 30170b57cec5SDimitry Andric assert(CurFn == FnDebugInfo[&GV].get()); 30180b57cec5SDimitry Andric 30190b57cec5SDimitry Andric collectVariableInfo(GV.getSubprogram()); 30200b57cec5SDimitry Andric 30210b57cec5SDimitry Andric // Build the lexical block structure to emit for this routine. 30220b57cec5SDimitry Andric if (LexicalScope *CFS = LScopes.getCurrentFunctionScope()) 30230b57cec5SDimitry Andric collectLexicalBlockInfo(*CFS, 30240b57cec5SDimitry Andric CurFn->ChildBlocks, 30250b57cec5SDimitry Andric CurFn->Locals, 30260b57cec5SDimitry Andric CurFn->Globals); 30270b57cec5SDimitry Andric 30280b57cec5SDimitry Andric // Clear the scope and variable information from the map which will not be 30290b57cec5SDimitry Andric // valid after we have finished processing this routine. This also prepares 30300b57cec5SDimitry Andric // the map for the subsequent routine. 30310b57cec5SDimitry Andric ScopeVariables.clear(); 30320b57cec5SDimitry Andric 30330b57cec5SDimitry Andric // Don't emit anything if we don't have any line tables. 30340b57cec5SDimitry Andric // Thunks are compiler-generated and probably won't have source correlation. 30350b57cec5SDimitry Andric if (!CurFn->HaveLineInfo && !GV.getSubprogram()->isThunk()) { 30360b57cec5SDimitry Andric FnDebugInfo.erase(&GV); 30370b57cec5SDimitry Andric CurFn = nullptr; 30380b57cec5SDimitry Andric return; 30390b57cec5SDimitry Andric } 30400b57cec5SDimitry Andric 3041480093f4SDimitry Andric // Find heap alloc sites and add to list. 3042480093f4SDimitry Andric for (const auto &MBB : *MF) { 3043480093f4SDimitry Andric for (const auto &MI : MBB) { 3044480093f4SDimitry Andric if (MDNode *MD = MI.getHeapAllocMarker()) { 3045480093f4SDimitry Andric CurFn->HeapAllocSites.push_back(std::make_tuple(getLabelBeforeInsn(&MI), 3046480093f4SDimitry Andric getLabelAfterInsn(&MI), 3047480093f4SDimitry Andric dyn_cast<DIType>(MD))); 3048480093f4SDimitry Andric } 3049480093f4SDimitry Andric } 3050480093f4SDimitry Andric } 3051480093f4SDimitry Andric 30520b57cec5SDimitry Andric CurFn->Annotations = MF->getCodeViewAnnotations(); 30530b57cec5SDimitry Andric 30540b57cec5SDimitry Andric CurFn->End = Asm->getFunctionEnd(); 30550b57cec5SDimitry Andric 30560b57cec5SDimitry Andric CurFn = nullptr; 30570b57cec5SDimitry Andric } 30580b57cec5SDimitry Andric 30598bcb0991SDimitry Andric // Usable locations are valid with non-zero line numbers. A line number of zero 30608bcb0991SDimitry Andric // corresponds to optimized code that doesn't have a distinct source location. 30618bcb0991SDimitry Andric // In this case, we try to use the previous or next source location depending on 30628bcb0991SDimitry Andric // the context. 30638bcb0991SDimitry Andric static bool isUsableDebugLoc(DebugLoc DL) { 30648bcb0991SDimitry Andric return DL && DL.getLine() != 0; 30658bcb0991SDimitry Andric } 30668bcb0991SDimitry Andric 30670b57cec5SDimitry Andric void CodeViewDebug::beginInstruction(const MachineInstr *MI) { 30680b57cec5SDimitry Andric DebugHandlerBase::beginInstruction(MI); 30690b57cec5SDimitry Andric 30700b57cec5SDimitry Andric // Ignore DBG_VALUE and DBG_LABEL locations and function prologue. 30710b57cec5SDimitry Andric if (!Asm || !CurFn || MI->isDebugInstr() || 30720b57cec5SDimitry Andric MI->getFlag(MachineInstr::FrameSetup)) 30730b57cec5SDimitry Andric return; 30740b57cec5SDimitry Andric 30750b57cec5SDimitry Andric // If the first instruction of a new MBB has no location, find the first 30760b57cec5SDimitry Andric // instruction with a location and use that. 30770b57cec5SDimitry Andric DebugLoc DL = MI->getDebugLoc(); 30788bcb0991SDimitry Andric if (!isUsableDebugLoc(DL) && MI->getParent() != PrevInstBB) { 30790b57cec5SDimitry Andric for (const auto &NextMI : *MI->getParent()) { 30800b57cec5SDimitry Andric if (NextMI.isDebugInstr()) 30810b57cec5SDimitry Andric continue; 30820b57cec5SDimitry Andric DL = NextMI.getDebugLoc(); 30838bcb0991SDimitry Andric if (isUsableDebugLoc(DL)) 30840b57cec5SDimitry Andric break; 30850b57cec5SDimitry Andric } 30868bcb0991SDimitry Andric // FIXME: Handle the case where the BB has no valid locations. This would 30878bcb0991SDimitry Andric // probably require doing a real dataflow analysis. 30880b57cec5SDimitry Andric } 30890b57cec5SDimitry Andric PrevInstBB = MI->getParent(); 30900b57cec5SDimitry Andric 30910b57cec5SDimitry Andric // If we still don't have a debug location, don't record a location. 30928bcb0991SDimitry Andric if (!isUsableDebugLoc(DL)) 30930b57cec5SDimitry Andric return; 30940b57cec5SDimitry Andric 30950b57cec5SDimitry Andric maybeRecordLocation(DL, Asm->MF); 30960b57cec5SDimitry Andric } 30970b57cec5SDimitry Andric 30980b57cec5SDimitry Andric MCSymbol *CodeViewDebug::beginCVSubsection(DebugSubsectionKind Kind) { 30990b57cec5SDimitry Andric MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(), 31000b57cec5SDimitry Andric *EndLabel = MMI->getContext().createTempSymbol(); 31015ffd83dbSDimitry Andric OS.emitInt32(unsigned(Kind)); 31020b57cec5SDimitry Andric OS.AddComment("Subsection size"); 31030b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4); 31045ffd83dbSDimitry Andric OS.emitLabel(BeginLabel); 31050b57cec5SDimitry Andric return EndLabel; 31060b57cec5SDimitry Andric } 31070b57cec5SDimitry Andric 31080b57cec5SDimitry Andric void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) { 31095ffd83dbSDimitry Andric OS.emitLabel(EndLabel); 31100b57cec5SDimitry Andric // Every subsection must be aligned to a 4-byte boundary. 31115ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 31120b57cec5SDimitry Andric } 31130b57cec5SDimitry Andric 31140b57cec5SDimitry Andric static StringRef getSymbolName(SymbolKind SymKind) { 31150b57cec5SDimitry Andric for (const EnumEntry<SymbolKind> &EE : getSymbolTypeNames()) 31160b57cec5SDimitry Andric if (EE.Value == SymKind) 31170b57cec5SDimitry Andric return EE.Name; 31180b57cec5SDimitry Andric return ""; 31190b57cec5SDimitry Andric } 31200b57cec5SDimitry Andric 31210b57cec5SDimitry Andric MCSymbol *CodeViewDebug::beginSymbolRecord(SymbolKind SymKind) { 31220b57cec5SDimitry Andric MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(), 31230b57cec5SDimitry Andric *EndLabel = MMI->getContext().createTempSymbol(); 31240b57cec5SDimitry Andric OS.AddComment("Record length"); 31250b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 2); 31265ffd83dbSDimitry Andric OS.emitLabel(BeginLabel); 31270b57cec5SDimitry Andric if (OS.isVerboseAsm()) 31280b57cec5SDimitry Andric OS.AddComment("Record kind: " + getSymbolName(SymKind)); 31295ffd83dbSDimitry Andric OS.emitInt16(unsigned(SymKind)); 31300b57cec5SDimitry Andric return EndLabel; 31310b57cec5SDimitry Andric } 31320b57cec5SDimitry Andric 31330b57cec5SDimitry Andric void CodeViewDebug::endSymbolRecord(MCSymbol *SymEnd) { 31340b57cec5SDimitry Andric // MSVC does not pad out symbol records to four bytes, but LLVM does to avoid 31350b57cec5SDimitry Andric // an extra copy of every symbol record in LLD. This increases object file 31360b57cec5SDimitry Andric // size by less than 1% in the clang build, and is compatible with the Visual 31370b57cec5SDimitry Andric // C++ linker. 31385ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 31395ffd83dbSDimitry Andric OS.emitLabel(SymEnd); 31400b57cec5SDimitry Andric } 31410b57cec5SDimitry Andric 31420b57cec5SDimitry Andric void CodeViewDebug::emitEndSymbolRecord(SymbolKind EndKind) { 31430b57cec5SDimitry Andric OS.AddComment("Record length"); 31445ffd83dbSDimitry Andric OS.emitInt16(2); 31450b57cec5SDimitry Andric if (OS.isVerboseAsm()) 31460b57cec5SDimitry Andric OS.AddComment("Record kind: " + getSymbolName(EndKind)); 31475ffd83dbSDimitry Andric OS.emitInt16(uint16_t(EndKind)); // Record Kind 31480b57cec5SDimitry Andric } 31490b57cec5SDimitry Andric 31500b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForUDTs( 31515ffd83dbSDimitry Andric const std::vector<std::pair<std::string, const DIType *>> &UDTs) { 31525ffd83dbSDimitry Andric #ifndef NDEBUG 31535ffd83dbSDimitry Andric size_t OriginalSize = UDTs.size(); 31545ffd83dbSDimitry Andric #endif 31550b57cec5SDimitry Andric for (const auto &UDT : UDTs) { 31560b57cec5SDimitry Andric const DIType *T = UDT.second; 31570b57cec5SDimitry Andric assert(shouldEmitUdt(T)); 31580b57cec5SDimitry Andric MCSymbol *UDTRecordEnd = beginSymbolRecord(SymbolKind::S_UDT); 31590b57cec5SDimitry Andric OS.AddComment("Type"); 31605ffd83dbSDimitry Andric OS.emitInt32(getCompleteTypeIndex(T).getIndex()); 31615ffd83dbSDimitry Andric assert(OriginalSize == UDTs.size() && 31625ffd83dbSDimitry Andric "getCompleteTypeIndex found new UDTs!"); 31630b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, UDT.first); 31640b57cec5SDimitry Andric endSymbolRecord(UDTRecordEnd); 31650b57cec5SDimitry Andric } 31660b57cec5SDimitry Andric } 31670b57cec5SDimitry Andric 31680b57cec5SDimitry Andric void CodeViewDebug::collectGlobalVariableInfo() { 31690b57cec5SDimitry Andric DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *> 31700b57cec5SDimitry Andric GlobalMap; 31710b57cec5SDimitry Andric for (const GlobalVariable &GV : MMI->getModule()->globals()) { 31720b57cec5SDimitry Andric SmallVector<DIGlobalVariableExpression *, 1> GVEs; 31730b57cec5SDimitry Andric GV.getDebugInfo(GVEs); 31740b57cec5SDimitry Andric for (const auto *GVE : GVEs) 31750b57cec5SDimitry Andric GlobalMap[GVE] = &GV; 31760b57cec5SDimitry Andric } 31770b57cec5SDimitry Andric 31780b57cec5SDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 31790b57cec5SDimitry Andric for (const MDNode *Node : CUs->operands()) { 31800b57cec5SDimitry Andric const auto *CU = cast<DICompileUnit>(Node); 31810b57cec5SDimitry Andric for (const auto *GVE : CU->getGlobalVariables()) { 31820b57cec5SDimitry Andric const DIGlobalVariable *DIGV = GVE->getVariable(); 31830b57cec5SDimitry Andric const DIExpression *DIE = GVE->getExpression(); 31840b57cec5SDimitry Andric 3185349cc55cSDimitry Andric if ((DIE->getNumElements() == 2) && 3186349cc55cSDimitry Andric (DIE->getElement(0) == dwarf::DW_OP_plus_uconst)) 3187349cc55cSDimitry Andric // Record the constant offset for the variable. 3188349cc55cSDimitry Andric // 3189349cc55cSDimitry Andric // A Fortran common block uses this idiom to encode the offset 3190349cc55cSDimitry Andric // of a variable from the common block's starting address. 3191349cc55cSDimitry Andric CVGlobalVariableOffsets.insert( 3192349cc55cSDimitry Andric std::make_pair(DIGV, DIE->getElement(1))); 3193349cc55cSDimitry Andric 31940b57cec5SDimitry Andric // Emit constant global variables in a global symbol section. 31950b57cec5SDimitry Andric if (GlobalMap.count(GVE) == 0 && DIE->isConstant()) { 31960b57cec5SDimitry Andric CVGlobalVariable CVGV = {DIGV, DIE}; 31970b57cec5SDimitry Andric GlobalVariables.emplace_back(std::move(CVGV)); 31980b57cec5SDimitry Andric } 31990b57cec5SDimitry Andric 32000b57cec5SDimitry Andric const auto *GV = GlobalMap.lookup(GVE); 32010b57cec5SDimitry Andric if (!GV || GV->isDeclarationForLinker()) 32020b57cec5SDimitry Andric continue; 32030b57cec5SDimitry Andric 32040b57cec5SDimitry Andric DIScope *Scope = DIGV->getScope(); 32050b57cec5SDimitry Andric SmallVector<CVGlobalVariable, 1> *VariableList; 32060b57cec5SDimitry Andric if (Scope && isa<DILocalScope>(Scope)) { 32070b57cec5SDimitry Andric // Locate a global variable list for this scope, creating one if 32080b57cec5SDimitry Andric // necessary. 32090b57cec5SDimitry Andric auto Insertion = ScopeGlobals.insert( 32100b57cec5SDimitry Andric {Scope, std::unique_ptr<GlobalVariableList>()}); 32110b57cec5SDimitry Andric if (Insertion.second) 32128bcb0991SDimitry Andric Insertion.first->second = std::make_unique<GlobalVariableList>(); 32130b57cec5SDimitry Andric VariableList = Insertion.first->second.get(); 32140b57cec5SDimitry Andric } else if (GV->hasComdat()) 32150b57cec5SDimitry Andric // Emit this global variable into a COMDAT section. 32160b57cec5SDimitry Andric VariableList = &ComdatVariables; 32170b57cec5SDimitry Andric else 32180b57cec5SDimitry Andric // Emit this global variable in a single global symbol section. 32190b57cec5SDimitry Andric VariableList = &GlobalVariables; 32200b57cec5SDimitry Andric CVGlobalVariable CVGV = {DIGV, GV}; 32210b57cec5SDimitry Andric VariableList->emplace_back(std::move(CVGV)); 32220b57cec5SDimitry Andric } 32230b57cec5SDimitry Andric } 32240b57cec5SDimitry Andric } 32250b57cec5SDimitry Andric 3226e8d8bef9SDimitry Andric void CodeViewDebug::collectDebugInfoForGlobals() { 3227e8d8bef9SDimitry Andric for (const CVGlobalVariable &CVGV : GlobalVariables) { 3228e8d8bef9SDimitry Andric const DIGlobalVariable *DIGV = CVGV.DIGV; 3229e8d8bef9SDimitry Andric const DIScope *Scope = DIGV->getScope(); 3230e8d8bef9SDimitry Andric getCompleteTypeIndex(DIGV->getType()); 3231e8d8bef9SDimitry Andric getFullyQualifiedName(Scope, DIGV->getName()); 3232e8d8bef9SDimitry Andric } 3233e8d8bef9SDimitry Andric 3234e8d8bef9SDimitry Andric for (const CVGlobalVariable &CVGV : ComdatVariables) { 3235e8d8bef9SDimitry Andric const DIGlobalVariable *DIGV = CVGV.DIGV; 3236e8d8bef9SDimitry Andric const DIScope *Scope = DIGV->getScope(); 3237e8d8bef9SDimitry Andric getCompleteTypeIndex(DIGV->getType()); 3238e8d8bef9SDimitry Andric getFullyQualifiedName(Scope, DIGV->getName()); 3239e8d8bef9SDimitry Andric } 3240e8d8bef9SDimitry Andric } 3241e8d8bef9SDimitry Andric 32420b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForGlobals() { 32430b57cec5SDimitry Andric // First, emit all globals that are not in a comdat in a single symbol 32440b57cec5SDimitry Andric // substream. MSVC doesn't like it if the substream is empty, so only open 32450b57cec5SDimitry Andric // it if we have at least one global to emit. 32460b57cec5SDimitry Andric switchToDebugSectionForSymbol(nullptr); 3247e8d8bef9SDimitry Andric if (!GlobalVariables.empty() || !StaticConstMembers.empty()) { 32480b57cec5SDimitry Andric OS.AddComment("Symbol subsection for globals"); 32490b57cec5SDimitry Andric MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols); 32500b57cec5SDimitry Andric emitGlobalVariableList(GlobalVariables); 3251e8d8bef9SDimitry Andric emitStaticConstMemberList(); 32520b57cec5SDimitry Andric endCVSubsection(EndLabel); 32530b57cec5SDimitry Andric } 32540b57cec5SDimitry Andric 32550b57cec5SDimitry Andric // Second, emit each global that is in a comdat into its own .debug$S 32560b57cec5SDimitry Andric // section along with its own symbol substream. 32570b57cec5SDimitry Andric for (const CVGlobalVariable &CVGV : ComdatVariables) { 32580b57cec5SDimitry Andric const GlobalVariable *GV = CVGV.GVInfo.get<const GlobalVariable *>(); 32590b57cec5SDimitry Andric MCSymbol *GVSym = Asm->getSymbol(GV); 32600b57cec5SDimitry Andric OS.AddComment("Symbol subsection for " + 32610b57cec5SDimitry Andric Twine(GlobalValue::dropLLVMManglingEscape(GV->getName()))); 32620b57cec5SDimitry Andric switchToDebugSectionForSymbol(GVSym); 32630b57cec5SDimitry Andric MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols); 32640b57cec5SDimitry Andric // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions. 32650b57cec5SDimitry Andric emitDebugInfoForGlobal(CVGV); 32660b57cec5SDimitry Andric endCVSubsection(EndLabel); 32670b57cec5SDimitry Andric } 32680b57cec5SDimitry Andric } 32690b57cec5SDimitry Andric 32700b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForRetainedTypes() { 32710b57cec5SDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 32720b57cec5SDimitry Andric for (const MDNode *Node : CUs->operands()) { 32730b57cec5SDimitry Andric for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) { 32740b57cec5SDimitry Andric if (DIType *RT = dyn_cast<DIType>(Ty)) { 32750b57cec5SDimitry Andric getTypeIndex(RT); 32760b57cec5SDimitry Andric // FIXME: Add to global/local DTU list. 32770b57cec5SDimitry Andric } 32780b57cec5SDimitry Andric } 32790b57cec5SDimitry Andric } 32800b57cec5SDimitry Andric } 32810b57cec5SDimitry Andric 32820b57cec5SDimitry Andric // Emit each global variable in the specified array. 32830b57cec5SDimitry Andric void CodeViewDebug::emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals) { 32840b57cec5SDimitry Andric for (const CVGlobalVariable &CVGV : Globals) { 32850b57cec5SDimitry Andric // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions. 32860b57cec5SDimitry Andric emitDebugInfoForGlobal(CVGV); 32870b57cec5SDimitry Andric } 32880b57cec5SDimitry Andric } 32890b57cec5SDimitry Andric 3290fe6060f1SDimitry Andric void CodeViewDebug::emitConstantSymbolRecord(const DIType *DTy, APSInt &Value, 3291fe6060f1SDimitry Andric const std::string &QualifiedName) { 3292fe6060f1SDimitry Andric MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT); 3293fe6060f1SDimitry Andric OS.AddComment("Type"); 3294fe6060f1SDimitry Andric OS.emitInt32(getTypeIndex(DTy).getIndex()); 3295fe6060f1SDimitry Andric 3296fe6060f1SDimitry Andric OS.AddComment("Value"); 3297fe6060f1SDimitry Andric 3298fe6060f1SDimitry Andric // Encoded integers shouldn't need more than 10 bytes. 3299fe6060f1SDimitry Andric uint8_t Data[10]; 3300fe6060f1SDimitry Andric BinaryStreamWriter Writer(Data, llvm::support::endianness::little); 3301fe6060f1SDimitry Andric CodeViewRecordIO IO(Writer); 3302fe6060f1SDimitry Andric cantFail(IO.mapEncodedInteger(Value)); 3303fe6060f1SDimitry Andric StringRef SRef((char *)Data, Writer.getOffset()); 3304fe6060f1SDimitry Andric OS.emitBinaryData(SRef); 3305fe6060f1SDimitry Andric 3306fe6060f1SDimitry Andric OS.AddComment("Name"); 3307fe6060f1SDimitry Andric emitNullTerminatedSymbolName(OS, QualifiedName); 3308fe6060f1SDimitry Andric endSymbolRecord(SConstantEnd); 3309fe6060f1SDimitry Andric } 3310fe6060f1SDimitry Andric 3311e8d8bef9SDimitry Andric void CodeViewDebug::emitStaticConstMemberList() { 3312e8d8bef9SDimitry Andric for (const DIDerivedType *DTy : StaticConstMembers) { 3313e8d8bef9SDimitry Andric const DIScope *Scope = DTy->getScope(); 3314e8d8bef9SDimitry Andric 3315e8d8bef9SDimitry Andric APSInt Value; 3316e8d8bef9SDimitry Andric if (const ConstantInt *CI = 3317e8d8bef9SDimitry Andric dyn_cast_or_null<ConstantInt>(DTy->getConstant())) 3318e8d8bef9SDimitry Andric Value = APSInt(CI->getValue(), 3319e8d8bef9SDimitry Andric DebugHandlerBase::isUnsignedDIType(DTy->getBaseType())); 3320e8d8bef9SDimitry Andric else if (const ConstantFP *CFP = 3321e8d8bef9SDimitry Andric dyn_cast_or_null<ConstantFP>(DTy->getConstant())) 3322e8d8bef9SDimitry Andric Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true); 3323e8d8bef9SDimitry Andric else 3324e8d8bef9SDimitry Andric llvm_unreachable("cannot emit a constant without a value"); 3325e8d8bef9SDimitry Andric 3326fe6060f1SDimitry Andric emitConstantSymbolRecord(DTy->getBaseType(), Value, 3327fe6060f1SDimitry Andric getFullyQualifiedName(Scope, DTy->getName())); 3328e8d8bef9SDimitry Andric } 3329e8d8bef9SDimitry Andric } 3330e8d8bef9SDimitry Andric 3331e8d8bef9SDimitry Andric static bool isFloatDIType(const DIType *Ty) { 3332e8d8bef9SDimitry Andric if (isa<DICompositeType>(Ty)) 3333e8d8bef9SDimitry Andric return false; 3334e8d8bef9SDimitry Andric 3335e8d8bef9SDimitry Andric if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) { 3336e8d8bef9SDimitry Andric dwarf::Tag T = (dwarf::Tag)Ty->getTag(); 3337e8d8bef9SDimitry Andric if (T == dwarf::DW_TAG_pointer_type || 3338e8d8bef9SDimitry Andric T == dwarf::DW_TAG_ptr_to_member_type || 3339e8d8bef9SDimitry Andric T == dwarf::DW_TAG_reference_type || 3340e8d8bef9SDimitry Andric T == dwarf::DW_TAG_rvalue_reference_type) 3341e8d8bef9SDimitry Andric return false; 3342e8d8bef9SDimitry Andric assert(DTy->getBaseType() && "Expected valid base type"); 3343e8d8bef9SDimitry Andric return isFloatDIType(DTy->getBaseType()); 3344e8d8bef9SDimitry Andric } 3345e8d8bef9SDimitry Andric 3346e8d8bef9SDimitry Andric auto *BTy = cast<DIBasicType>(Ty); 3347e8d8bef9SDimitry Andric return (BTy->getEncoding() == dwarf::DW_ATE_float); 3348e8d8bef9SDimitry Andric } 3349e8d8bef9SDimitry Andric 33500b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) { 33510b57cec5SDimitry Andric const DIGlobalVariable *DIGV = CVGV.DIGV; 33525ffd83dbSDimitry Andric 33535ffd83dbSDimitry Andric const DIScope *Scope = DIGV->getScope(); 33545ffd83dbSDimitry Andric // For static data members, get the scope from the declaration. 33555ffd83dbSDimitry Andric if (const auto *MemberDecl = dyn_cast_or_null<DIDerivedType>( 33565ffd83dbSDimitry Andric DIGV->getRawStaticDataMemberDeclaration())) 33575ffd83dbSDimitry Andric Scope = MemberDecl->getScope(); 3358349cc55cSDimitry Andric // For Fortran, the scoping portion is elided in its name so that we can 3359349cc55cSDimitry Andric // reference the variable in the command line of the VS debugger. 3360349cc55cSDimitry Andric std::string QualifiedName = 3361349cc55cSDimitry Andric (moduleIsInFortran()) ? std::string(DIGV->getName()) 3362349cc55cSDimitry Andric : getFullyQualifiedName(Scope, DIGV->getName()); 33635ffd83dbSDimitry Andric 33640b57cec5SDimitry Andric if (const GlobalVariable *GV = 33650b57cec5SDimitry Andric CVGV.GVInfo.dyn_cast<const GlobalVariable *>()) { 33660b57cec5SDimitry Andric // DataSym record, see SymbolRecord.h for more info. Thread local data 33670b57cec5SDimitry Andric // happens to have the same format as global data. 33680b57cec5SDimitry Andric MCSymbol *GVSym = Asm->getSymbol(GV); 33690b57cec5SDimitry Andric SymbolKind DataSym = GV->isThreadLocal() 33700b57cec5SDimitry Andric ? (DIGV->isLocalToUnit() ? SymbolKind::S_LTHREAD32 33710b57cec5SDimitry Andric : SymbolKind::S_GTHREAD32) 33720b57cec5SDimitry Andric : (DIGV->isLocalToUnit() ? SymbolKind::S_LDATA32 33730b57cec5SDimitry Andric : SymbolKind::S_GDATA32); 33740b57cec5SDimitry Andric MCSymbol *DataEnd = beginSymbolRecord(DataSym); 33750b57cec5SDimitry Andric OS.AddComment("Type"); 33765ffd83dbSDimitry Andric OS.emitInt32(getCompleteTypeIndex(DIGV->getType()).getIndex()); 33770b57cec5SDimitry Andric OS.AddComment("DataOffset"); 3378349cc55cSDimitry Andric 3379349cc55cSDimitry Andric uint64_t Offset = 0; 3380349cc55cSDimitry Andric if (CVGlobalVariableOffsets.find(DIGV) != CVGlobalVariableOffsets.end()) 3381349cc55cSDimitry Andric // Use the offset seen while collecting info on globals. 3382349cc55cSDimitry Andric Offset = CVGlobalVariableOffsets[DIGV]; 3383349cc55cSDimitry Andric OS.EmitCOFFSecRel32(GVSym, Offset); 3384349cc55cSDimitry Andric 33850b57cec5SDimitry Andric OS.AddComment("Segment"); 33860b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(GVSym); 33870b57cec5SDimitry Andric OS.AddComment("Name"); 33880b57cec5SDimitry Andric const unsigned LengthOfDataRecord = 12; 33895ffd83dbSDimitry Andric emitNullTerminatedSymbolName(OS, QualifiedName, LengthOfDataRecord); 33900b57cec5SDimitry Andric endSymbolRecord(DataEnd); 33910b57cec5SDimitry Andric } else { 33920b57cec5SDimitry Andric const DIExpression *DIE = CVGV.GVInfo.get<const DIExpression *>(); 33930b57cec5SDimitry Andric assert(DIE->isConstant() && 33940b57cec5SDimitry Andric "Global constant variables must contain a constant expression."); 3395e8d8bef9SDimitry Andric 3396e8d8bef9SDimitry Andric // Use unsigned for floats. 3397e8d8bef9SDimitry Andric bool isUnsigned = isFloatDIType(DIGV->getType()) 3398e8d8bef9SDimitry Andric ? true 3399e8d8bef9SDimitry Andric : DebugHandlerBase::isUnsignedDIType(DIGV->getType()); 3400e8d8bef9SDimitry Andric APSInt Value(APInt(/*BitWidth=*/64, DIE->getElement(1)), isUnsigned); 3401fe6060f1SDimitry Andric emitConstantSymbolRecord(DIGV->getType(), Value, QualifiedName); 34020b57cec5SDimitry Andric } 34030b57cec5SDimitry Andric } 3404