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/ArrayRef.h" 170b57cec5SDimitry Andric #include "llvm/ADT/DenseMap.h" 180b57cec5SDimitry Andric #include "llvm/ADT/DenseSet.h" 190b57cec5SDimitry Andric #include "llvm/ADT/MapVector.h" 200b57cec5SDimitry Andric #include "llvm/ADT/None.h" 210b57cec5SDimitry Andric #include "llvm/ADT/Optional.h" 220b57cec5SDimitry Andric #include "llvm/ADT/STLExtras.h" 230b57cec5SDimitry Andric #include "llvm/ADT/SmallString.h" 240b57cec5SDimitry Andric #include "llvm/ADT/SmallVector.h" 250b57cec5SDimitry Andric #include "llvm/ADT/StringRef.h" 260b57cec5SDimitry Andric #include "llvm/ADT/TinyPtrVector.h" 270b57cec5SDimitry Andric #include "llvm/ADT/Triple.h" 280b57cec5SDimitry Andric #include "llvm/ADT/Twine.h" 290b57cec5SDimitry Andric #include "llvm/BinaryFormat/COFF.h" 300b57cec5SDimitry Andric #include "llvm/BinaryFormat/Dwarf.h" 310b57cec5SDimitry Andric #include "llvm/CodeGen/AsmPrinter.h" 320b57cec5SDimitry Andric #include "llvm/CodeGen/LexicalScopes.h" 330b57cec5SDimitry Andric #include "llvm/CodeGen/MachineFrameInfo.h" 340b57cec5SDimitry Andric #include "llvm/CodeGen/MachineFunction.h" 350b57cec5SDimitry Andric #include "llvm/CodeGen/MachineInstr.h" 360b57cec5SDimitry Andric #include "llvm/CodeGen/MachineModuleInfo.h" 370b57cec5SDimitry Andric #include "llvm/CodeGen/MachineOperand.h" 380b57cec5SDimitry Andric #include "llvm/CodeGen/TargetFrameLowering.h" 390b57cec5SDimitry Andric #include "llvm/CodeGen/TargetRegisterInfo.h" 400b57cec5SDimitry Andric #include "llvm/CodeGen/TargetSubtargetInfo.h" 410b57cec5SDimitry Andric #include "llvm/Config/llvm-config.h" 420b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h" 430b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/CodeView.h" 440b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h" 450b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h" 460b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h" 470b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/EnumTables.h" 480b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/Line.h" 490b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/SymbolRecord.h" 500b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h" 510b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeIndex.h" 520b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeRecord.h" 530b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeTableCollection.h" 540b57cec5SDimitry Andric #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h" 550b57cec5SDimitry Andric #include "llvm/IR/Constants.h" 560b57cec5SDimitry Andric #include "llvm/IR/DataLayout.h" 570b57cec5SDimitry Andric #include "llvm/IR/DebugInfoMetadata.h" 580b57cec5SDimitry Andric #include "llvm/IR/DebugLoc.h" 590b57cec5SDimitry Andric #include "llvm/IR/Function.h" 600b57cec5SDimitry Andric #include "llvm/IR/GlobalValue.h" 610b57cec5SDimitry Andric #include "llvm/IR/GlobalVariable.h" 620b57cec5SDimitry Andric #include "llvm/IR/Metadata.h" 630b57cec5SDimitry Andric #include "llvm/IR/Module.h" 640b57cec5SDimitry Andric #include "llvm/MC/MCAsmInfo.h" 650b57cec5SDimitry Andric #include "llvm/MC/MCContext.h" 660b57cec5SDimitry Andric #include "llvm/MC/MCSectionCOFF.h" 670b57cec5SDimitry Andric #include "llvm/MC/MCStreamer.h" 680b57cec5SDimitry Andric #include "llvm/MC/MCSymbol.h" 690b57cec5SDimitry Andric #include "llvm/Support/BinaryByteStream.h" 700b57cec5SDimitry Andric #include "llvm/Support/BinaryStreamReader.h" 710b57cec5SDimitry Andric #include "llvm/Support/BinaryStreamWriter.h" 720b57cec5SDimitry Andric #include "llvm/Support/Casting.h" 730b57cec5SDimitry Andric #include "llvm/Support/CommandLine.h" 740b57cec5SDimitry Andric #include "llvm/Support/Compiler.h" 750b57cec5SDimitry Andric #include "llvm/Support/Endian.h" 760b57cec5SDimitry Andric #include "llvm/Support/Error.h" 770b57cec5SDimitry Andric #include "llvm/Support/ErrorHandling.h" 780b57cec5SDimitry Andric #include "llvm/Support/FormatVariadic.h" 790b57cec5SDimitry Andric #include "llvm/Support/Path.h" 800b57cec5SDimitry Andric #include "llvm/Support/SMLoc.h" 810b57cec5SDimitry Andric #include "llvm/Support/ScopedPrinter.h" 820b57cec5SDimitry Andric #include "llvm/Target/TargetLoweringObjectFile.h" 830b57cec5SDimitry Andric #include "llvm/Target/TargetMachine.h" 840b57cec5SDimitry Andric #include <algorithm> 850b57cec5SDimitry Andric #include <cassert> 860b57cec5SDimitry Andric #include <cctype> 870b57cec5SDimitry Andric #include <cstddef> 880b57cec5SDimitry Andric #include <cstdint> 890b57cec5SDimitry Andric #include <iterator> 900b57cec5SDimitry Andric #include <limits> 910b57cec5SDimitry Andric #include <string> 920b57cec5SDimitry Andric #include <utility> 930b57cec5SDimitry Andric #include <vector> 940b57cec5SDimitry Andric 950b57cec5SDimitry Andric using namespace llvm; 960b57cec5SDimitry Andric using namespace llvm::codeview; 970b57cec5SDimitry Andric 980b57cec5SDimitry Andric namespace { 990b57cec5SDimitry Andric class CVMCAdapter : public CodeViewRecordStreamer { 1000b57cec5SDimitry Andric public: 1018bcb0991SDimitry Andric CVMCAdapter(MCStreamer &OS, TypeCollection &TypeTable) 1028bcb0991SDimitry Andric : OS(&OS), TypeTable(TypeTable) {} 1030b57cec5SDimitry Andric 1045ffd83dbSDimitry Andric void emitBytes(StringRef Data) override { OS->emitBytes(Data); } 1050b57cec5SDimitry Andric 1065ffd83dbSDimitry Andric void emitIntValue(uint64_t Value, unsigned Size) override { 1075ffd83dbSDimitry Andric OS->emitIntValueInHex(Value, Size); 1080b57cec5SDimitry Andric } 1090b57cec5SDimitry Andric 1105ffd83dbSDimitry Andric void emitBinaryData(StringRef Data) override { OS->emitBinaryData(Data); } 1110b57cec5SDimitry Andric 1125ffd83dbSDimitry Andric void AddComment(const Twine &T) override { OS->AddComment(T); } 1130b57cec5SDimitry Andric 1145ffd83dbSDimitry Andric void AddRawComment(const Twine &T) override { OS->emitRawComment(T); } 1158bcb0991SDimitry Andric 1165ffd83dbSDimitry Andric bool isVerboseAsm() override { return OS->isVerboseAsm(); } 1178bcb0991SDimitry Andric 1185ffd83dbSDimitry Andric std::string getTypeName(TypeIndex TI) override { 1198bcb0991SDimitry Andric std::string TypeName; 1208bcb0991SDimitry Andric if (!TI.isNoneType()) { 1218bcb0991SDimitry Andric if (TI.isSimple()) 1225ffd83dbSDimitry Andric TypeName = std::string(TypeIndex::simpleTypeName(TI)); 1238bcb0991SDimitry Andric else 1245ffd83dbSDimitry Andric TypeName = std::string(TypeTable.getTypeName(TI)); 1258bcb0991SDimitry Andric } 1268bcb0991SDimitry Andric return TypeName; 1278bcb0991SDimitry Andric } 1288bcb0991SDimitry Andric 1290b57cec5SDimitry Andric private: 1300b57cec5SDimitry Andric MCStreamer *OS = nullptr; 1318bcb0991SDimitry Andric TypeCollection &TypeTable; 1320b57cec5SDimitry Andric }; 1330b57cec5SDimitry Andric } // namespace 1340b57cec5SDimitry Andric 1350b57cec5SDimitry Andric static CPUType mapArchToCVCPUType(Triple::ArchType Type) { 1360b57cec5SDimitry Andric switch (Type) { 1370b57cec5SDimitry Andric case Triple::ArchType::x86: 1380b57cec5SDimitry Andric return CPUType::Pentium3; 1390b57cec5SDimitry Andric case Triple::ArchType::x86_64: 1400b57cec5SDimitry Andric return CPUType::X64; 1410b57cec5SDimitry Andric case Triple::ArchType::thumb: 1420b57cec5SDimitry Andric return CPUType::Thumb; 1430b57cec5SDimitry Andric case Triple::ArchType::aarch64: 1440b57cec5SDimitry Andric return CPUType::ARM64; 1450b57cec5SDimitry Andric default: 1460b57cec5SDimitry Andric report_fatal_error("target architecture doesn't map to a CodeView CPUType"); 1470b57cec5SDimitry Andric } 1480b57cec5SDimitry Andric } 1490b57cec5SDimitry Andric 1500b57cec5SDimitry Andric CodeViewDebug::CodeViewDebug(AsmPrinter *AP) 1510b57cec5SDimitry Andric : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) { 1520b57cec5SDimitry Andric // If module doesn't have named metadata anchors or COFF debug section 1530b57cec5SDimitry Andric // is not available, skip any debug info related stuff. 1540b57cec5SDimitry Andric if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") || 1550b57cec5SDimitry Andric !AP->getObjFileLowering().getCOFFDebugSymbolsSection()) { 1560b57cec5SDimitry Andric Asm = nullptr; 1570b57cec5SDimitry Andric MMI->setDebugInfoAvailability(false); 1580b57cec5SDimitry Andric return; 1590b57cec5SDimitry Andric } 1600b57cec5SDimitry Andric // Tell MMI that we have debug info. 1610b57cec5SDimitry Andric MMI->setDebugInfoAvailability(true); 1620b57cec5SDimitry Andric 1630b57cec5SDimitry Andric TheCPU = 1640b57cec5SDimitry Andric mapArchToCVCPUType(Triple(MMI->getModule()->getTargetTriple()).getArch()); 1650b57cec5SDimitry Andric 1660b57cec5SDimitry Andric collectGlobalVariableInfo(); 1670b57cec5SDimitry Andric 1680b57cec5SDimitry Andric // Check if we should emit type record hashes. 1690b57cec5SDimitry Andric ConstantInt *GH = mdconst::extract_or_null<ConstantInt>( 1700b57cec5SDimitry Andric MMI->getModule()->getModuleFlag("CodeViewGHash")); 1710b57cec5SDimitry Andric EmitDebugGlobalHashes = GH && !GH->isZero(); 1720b57cec5SDimitry Andric } 1730b57cec5SDimitry Andric 1740b57cec5SDimitry Andric StringRef CodeViewDebug::getFullFilepath(const DIFile *File) { 1750b57cec5SDimitry Andric std::string &Filepath = FileToFilepathMap[File]; 1760b57cec5SDimitry Andric if (!Filepath.empty()) 1770b57cec5SDimitry Andric return Filepath; 1780b57cec5SDimitry Andric 1790b57cec5SDimitry Andric StringRef Dir = File->getDirectory(), Filename = File->getFilename(); 1800b57cec5SDimitry Andric 1810b57cec5SDimitry Andric // If this is a Unix-style path, just use it as is. Don't try to canonicalize 1820b57cec5SDimitry Andric // it textually because one of the path components could be a symlink. 1830b57cec5SDimitry Andric if (Dir.startswith("/") || Filename.startswith("/")) { 1840b57cec5SDimitry Andric if (llvm::sys::path::is_absolute(Filename, llvm::sys::path::Style::posix)) 1850b57cec5SDimitry Andric return Filename; 1865ffd83dbSDimitry Andric Filepath = std::string(Dir); 1870b57cec5SDimitry Andric if (Dir.back() != '/') 1880b57cec5SDimitry Andric Filepath += '/'; 1890b57cec5SDimitry Andric Filepath += Filename; 1900b57cec5SDimitry Andric return Filepath; 1910b57cec5SDimitry Andric } 1920b57cec5SDimitry Andric 1930b57cec5SDimitry Andric // Clang emits directory and relative filename info into the IR, but CodeView 1940b57cec5SDimitry Andric // operates on full paths. We could change Clang to emit full paths too, but 1950b57cec5SDimitry Andric // that would increase the IR size and probably not needed for other users. 1960b57cec5SDimitry Andric // For now, just concatenate and canonicalize the path here. 1970b57cec5SDimitry Andric if (Filename.find(':') == 1) 1985ffd83dbSDimitry Andric Filepath = std::string(Filename); 1990b57cec5SDimitry Andric else 2000b57cec5SDimitry Andric Filepath = (Dir + "\\" + Filename).str(); 2010b57cec5SDimitry Andric 2020b57cec5SDimitry Andric // Canonicalize the path. We have to do it textually because we may no longer 2030b57cec5SDimitry Andric // have access the file in the filesystem. 2040b57cec5SDimitry Andric // First, replace all slashes with backslashes. 2050b57cec5SDimitry Andric std::replace(Filepath.begin(), Filepath.end(), '/', '\\'); 2060b57cec5SDimitry Andric 2070b57cec5SDimitry Andric // Remove all "\.\" with "\". 2080b57cec5SDimitry Andric size_t Cursor = 0; 2090b57cec5SDimitry Andric while ((Cursor = Filepath.find("\\.\\", Cursor)) != std::string::npos) 2100b57cec5SDimitry Andric Filepath.erase(Cursor, 2); 2110b57cec5SDimitry Andric 2120b57cec5SDimitry Andric // Replace all "\XXX\..\" with "\". Don't try too hard though as the original 2130b57cec5SDimitry Andric // path should be well-formatted, e.g. start with a drive letter, etc. 2140b57cec5SDimitry Andric Cursor = 0; 2150b57cec5SDimitry Andric while ((Cursor = Filepath.find("\\..\\", Cursor)) != std::string::npos) { 2160b57cec5SDimitry Andric // Something's wrong if the path starts with "\..\", abort. 2170b57cec5SDimitry Andric if (Cursor == 0) 2180b57cec5SDimitry Andric break; 2190b57cec5SDimitry Andric 2200b57cec5SDimitry Andric size_t PrevSlash = Filepath.rfind('\\', Cursor - 1); 2210b57cec5SDimitry Andric if (PrevSlash == std::string::npos) 2220b57cec5SDimitry Andric // Something's wrong, abort. 2230b57cec5SDimitry Andric break; 2240b57cec5SDimitry Andric 2250b57cec5SDimitry Andric Filepath.erase(PrevSlash, Cursor + 3 - PrevSlash); 2260b57cec5SDimitry Andric // The next ".." might be following the one we've just erased. 2270b57cec5SDimitry Andric Cursor = PrevSlash; 2280b57cec5SDimitry Andric } 2290b57cec5SDimitry Andric 2300b57cec5SDimitry Andric // Remove all duplicate backslashes. 2310b57cec5SDimitry Andric Cursor = 0; 2320b57cec5SDimitry Andric while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos) 2330b57cec5SDimitry Andric Filepath.erase(Cursor, 1); 2340b57cec5SDimitry Andric 2350b57cec5SDimitry Andric return Filepath; 2360b57cec5SDimitry Andric } 2370b57cec5SDimitry Andric 2380b57cec5SDimitry Andric unsigned CodeViewDebug::maybeRecordFile(const DIFile *F) { 2390b57cec5SDimitry Andric StringRef FullPath = getFullFilepath(F); 2400b57cec5SDimitry Andric unsigned NextId = FileIdMap.size() + 1; 2410b57cec5SDimitry Andric auto Insertion = FileIdMap.insert(std::make_pair(FullPath, NextId)); 2420b57cec5SDimitry Andric if (Insertion.second) { 2430b57cec5SDimitry Andric // We have to compute the full filepath and emit a .cv_file directive. 2440b57cec5SDimitry Andric ArrayRef<uint8_t> ChecksumAsBytes; 2450b57cec5SDimitry Andric FileChecksumKind CSKind = FileChecksumKind::None; 2460b57cec5SDimitry Andric if (F->getChecksum()) { 2470b57cec5SDimitry Andric std::string Checksum = fromHex(F->getChecksum()->Value); 2480b57cec5SDimitry Andric void *CKMem = OS.getContext().allocate(Checksum.size(), 1); 2490b57cec5SDimitry Andric memcpy(CKMem, Checksum.data(), Checksum.size()); 2500b57cec5SDimitry Andric ChecksumAsBytes = ArrayRef<uint8_t>( 2510b57cec5SDimitry Andric reinterpret_cast<const uint8_t *>(CKMem), Checksum.size()); 2520b57cec5SDimitry Andric switch (F->getChecksum()->Kind) { 2535ffd83dbSDimitry Andric case DIFile::CSK_MD5: 2545ffd83dbSDimitry Andric CSKind = FileChecksumKind::MD5; 2555ffd83dbSDimitry Andric break; 2565ffd83dbSDimitry Andric case DIFile::CSK_SHA1: 2575ffd83dbSDimitry Andric CSKind = FileChecksumKind::SHA1; 2585ffd83dbSDimitry Andric break; 2595ffd83dbSDimitry Andric case DIFile::CSK_SHA256: 2605ffd83dbSDimitry Andric CSKind = FileChecksumKind::SHA256; 2615ffd83dbSDimitry Andric break; 2620b57cec5SDimitry Andric } 2630b57cec5SDimitry Andric } 2640b57cec5SDimitry Andric bool Success = OS.EmitCVFileDirective(NextId, FullPath, ChecksumAsBytes, 2650b57cec5SDimitry Andric static_cast<unsigned>(CSKind)); 2660b57cec5SDimitry Andric (void)Success; 2670b57cec5SDimitry Andric assert(Success && ".cv_file directive failed"); 2680b57cec5SDimitry Andric } 2690b57cec5SDimitry Andric return Insertion.first->second; 2700b57cec5SDimitry Andric } 2710b57cec5SDimitry Andric 2720b57cec5SDimitry Andric CodeViewDebug::InlineSite & 2730b57cec5SDimitry Andric CodeViewDebug::getInlineSite(const DILocation *InlinedAt, 2740b57cec5SDimitry Andric const DISubprogram *Inlinee) { 2750b57cec5SDimitry Andric auto SiteInsertion = CurFn->InlineSites.insert({InlinedAt, InlineSite()}); 2760b57cec5SDimitry Andric InlineSite *Site = &SiteInsertion.first->second; 2770b57cec5SDimitry Andric if (SiteInsertion.second) { 2780b57cec5SDimitry Andric unsigned ParentFuncId = CurFn->FuncId; 2790b57cec5SDimitry Andric if (const DILocation *OuterIA = InlinedAt->getInlinedAt()) 2800b57cec5SDimitry Andric ParentFuncId = 2810b57cec5SDimitry Andric getInlineSite(OuterIA, InlinedAt->getScope()->getSubprogram()) 2820b57cec5SDimitry Andric .SiteFuncId; 2830b57cec5SDimitry Andric 2840b57cec5SDimitry Andric Site->SiteFuncId = NextFuncId++; 2850b57cec5SDimitry Andric OS.EmitCVInlineSiteIdDirective( 2860b57cec5SDimitry Andric Site->SiteFuncId, ParentFuncId, maybeRecordFile(InlinedAt->getFile()), 2870b57cec5SDimitry Andric InlinedAt->getLine(), InlinedAt->getColumn(), SMLoc()); 2880b57cec5SDimitry Andric Site->Inlinee = Inlinee; 2890b57cec5SDimitry Andric InlinedSubprograms.insert(Inlinee); 2900b57cec5SDimitry Andric getFuncIdForSubprogram(Inlinee); 2910b57cec5SDimitry Andric } 2920b57cec5SDimitry Andric return *Site; 2930b57cec5SDimitry Andric } 2940b57cec5SDimitry Andric 2950b57cec5SDimitry Andric static StringRef getPrettyScopeName(const DIScope *Scope) { 2960b57cec5SDimitry Andric StringRef ScopeName = Scope->getName(); 2970b57cec5SDimitry Andric if (!ScopeName.empty()) 2980b57cec5SDimitry Andric return ScopeName; 2990b57cec5SDimitry Andric 3000b57cec5SDimitry Andric switch (Scope->getTag()) { 3010b57cec5SDimitry Andric case dwarf::DW_TAG_enumeration_type: 3020b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 3030b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 3040b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 3050b57cec5SDimitry Andric return "<unnamed-tag>"; 3060b57cec5SDimitry Andric case dwarf::DW_TAG_namespace: 3070b57cec5SDimitry Andric return "`anonymous namespace'"; 3080b57cec5SDimitry Andric } 3090b57cec5SDimitry Andric 3100b57cec5SDimitry Andric return StringRef(); 3110b57cec5SDimitry Andric } 3120b57cec5SDimitry Andric 3135ffd83dbSDimitry Andric const DISubprogram *CodeViewDebug::collectParentScopeNames( 3140b57cec5SDimitry Andric const DIScope *Scope, SmallVectorImpl<StringRef> &QualifiedNameComponents) { 3150b57cec5SDimitry Andric const DISubprogram *ClosestSubprogram = nullptr; 3160b57cec5SDimitry Andric while (Scope != nullptr) { 3170b57cec5SDimitry Andric if (ClosestSubprogram == nullptr) 3180b57cec5SDimitry Andric ClosestSubprogram = dyn_cast<DISubprogram>(Scope); 3195ffd83dbSDimitry Andric 3205ffd83dbSDimitry Andric // If a type appears in a scope chain, make sure it gets emitted. The 3215ffd83dbSDimitry Andric // frontend will be responsible for deciding if this should be a forward 3225ffd83dbSDimitry Andric // declaration or a complete type. 3235ffd83dbSDimitry Andric if (const auto *Ty = dyn_cast<DICompositeType>(Scope)) 3245ffd83dbSDimitry Andric DeferredCompleteTypes.push_back(Ty); 3255ffd83dbSDimitry Andric 3260b57cec5SDimitry Andric StringRef ScopeName = getPrettyScopeName(Scope); 3270b57cec5SDimitry Andric if (!ScopeName.empty()) 3280b57cec5SDimitry Andric QualifiedNameComponents.push_back(ScopeName); 3290b57cec5SDimitry Andric Scope = Scope->getScope(); 3300b57cec5SDimitry Andric } 3310b57cec5SDimitry Andric return ClosestSubprogram; 3320b57cec5SDimitry Andric } 3330b57cec5SDimitry Andric 3345ffd83dbSDimitry Andric static std::string formatNestedName(ArrayRef<StringRef> QualifiedNameComponents, 3350b57cec5SDimitry Andric StringRef TypeName) { 3360b57cec5SDimitry Andric std::string FullyQualifiedName; 3370b57cec5SDimitry Andric for (StringRef QualifiedNameComponent : 3380b57cec5SDimitry Andric llvm::reverse(QualifiedNameComponents)) { 3395ffd83dbSDimitry Andric FullyQualifiedName.append(std::string(QualifiedNameComponent)); 3400b57cec5SDimitry Andric FullyQualifiedName.append("::"); 3410b57cec5SDimitry Andric } 3425ffd83dbSDimitry Andric FullyQualifiedName.append(std::string(TypeName)); 3430b57cec5SDimitry Andric return FullyQualifiedName; 3440b57cec5SDimitry Andric } 3450b57cec5SDimitry Andric 3460b57cec5SDimitry Andric struct CodeViewDebug::TypeLoweringScope { 3470b57cec5SDimitry Andric TypeLoweringScope(CodeViewDebug &CVD) : CVD(CVD) { ++CVD.TypeEmissionLevel; } 3480b57cec5SDimitry Andric ~TypeLoweringScope() { 3490b57cec5SDimitry Andric // Don't decrement TypeEmissionLevel until after emitting deferred types, so 3500b57cec5SDimitry Andric // inner TypeLoweringScopes don't attempt to emit deferred types. 3510b57cec5SDimitry Andric if (CVD.TypeEmissionLevel == 1) 3520b57cec5SDimitry Andric CVD.emitDeferredCompleteTypes(); 3530b57cec5SDimitry Andric --CVD.TypeEmissionLevel; 3540b57cec5SDimitry Andric } 3550b57cec5SDimitry Andric CodeViewDebug &CVD; 3560b57cec5SDimitry Andric }; 3570b57cec5SDimitry Andric 3585ffd83dbSDimitry Andric std::string CodeViewDebug::getFullyQualifiedName(const DIScope *Scope, 3595ffd83dbSDimitry Andric StringRef Name) { 3605ffd83dbSDimitry Andric // Ensure types in the scope chain are emitted as soon as possible. 3615ffd83dbSDimitry Andric // This can create otherwise a situation where S_UDTs are emitted while 3625ffd83dbSDimitry Andric // looping in emitDebugInfoForUDTs. 3635ffd83dbSDimitry Andric TypeLoweringScope S(*this); 3645ffd83dbSDimitry Andric SmallVector<StringRef, 5> QualifiedNameComponents; 3655ffd83dbSDimitry Andric collectParentScopeNames(Scope, QualifiedNameComponents); 3665ffd83dbSDimitry Andric return formatNestedName(QualifiedNameComponents, Name); 3675ffd83dbSDimitry Andric } 3685ffd83dbSDimitry Andric 3695ffd83dbSDimitry Andric std::string CodeViewDebug::getFullyQualifiedName(const DIScope *Ty) { 3700b57cec5SDimitry Andric const DIScope *Scope = Ty->getScope(); 3710b57cec5SDimitry Andric return getFullyQualifiedName(Scope, getPrettyScopeName(Ty)); 3720b57cec5SDimitry Andric } 3730b57cec5SDimitry Andric 3740b57cec5SDimitry Andric TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) { 3750b57cec5SDimitry Andric // No scope means global scope and that uses the zero index. 3760b57cec5SDimitry Andric if (!Scope || isa<DIFile>(Scope)) 3770b57cec5SDimitry Andric return TypeIndex(); 3780b57cec5SDimitry Andric 3790b57cec5SDimitry Andric assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type"); 3800b57cec5SDimitry Andric 3810b57cec5SDimitry Andric // Check if we've already translated this scope. 3820b57cec5SDimitry Andric auto I = TypeIndices.find({Scope, nullptr}); 3830b57cec5SDimitry Andric if (I != TypeIndices.end()) 3840b57cec5SDimitry Andric return I->second; 3850b57cec5SDimitry Andric 3860b57cec5SDimitry Andric // Build the fully qualified name of the scope. 3870b57cec5SDimitry Andric std::string ScopeName = getFullyQualifiedName(Scope); 3880b57cec5SDimitry Andric StringIdRecord SID(TypeIndex(), ScopeName); 3890b57cec5SDimitry Andric auto TI = TypeTable.writeLeafType(SID); 3900b57cec5SDimitry Andric return recordTypeIndexForDINode(Scope, TI); 3910b57cec5SDimitry Andric } 3920b57cec5SDimitry Andric 3930b57cec5SDimitry Andric TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) { 3940b57cec5SDimitry Andric assert(SP); 3950b57cec5SDimitry Andric 3960b57cec5SDimitry Andric // Check if we've already translated this subprogram. 3970b57cec5SDimitry Andric auto I = TypeIndices.find({SP, nullptr}); 3980b57cec5SDimitry Andric if (I != TypeIndices.end()) 3990b57cec5SDimitry Andric return I->second; 4000b57cec5SDimitry Andric 4010b57cec5SDimitry Andric // The display name includes function template arguments. Drop them to match 4020b57cec5SDimitry Andric // MSVC. 4030b57cec5SDimitry Andric StringRef DisplayName = SP->getName().split('<').first; 4040b57cec5SDimitry Andric 4050b57cec5SDimitry Andric const DIScope *Scope = SP->getScope(); 4060b57cec5SDimitry Andric TypeIndex TI; 4070b57cec5SDimitry Andric if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) { 4080b57cec5SDimitry Andric // If the scope is a DICompositeType, then this must be a method. Member 4090b57cec5SDimitry Andric // function types take some special handling, and require access to the 4100b57cec5SDimitry Andric // subprogram. 4110b57cec5SDimitry Andric TypeIndex ClassType = getTypeIndex(Class); 4120b57cec5SDimitry Andric MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class), 4130b57cec5SDimitry Andric DisplayName); 4140b57cec5SDimitry Andric TI = TypeTable.writeLeafType(MFuncId); 4150b57cec5SDimitry Andric } else { 4160b57cec5SDimitry Andric // Otherwise, this must be a free function. 4170b57cec5SDimitry Andric TypeIndex ParentScope = getScopeIndex(Scope); 4180b57cec5SDimitry Andric FuncIdRecord FuncId(ParentScope, getTypeIndex(SP->getType()), DisplayName); 4190b57cec5SDimitry Andric TI = TypeTable.writeLeafType(FuncId); 4200b57cec5SDimitry Andric } 4210b57cec5SDimitry Andric 4220b57cec5SDimitry Andric return recordTypeIndexForDINode(SP, TI); 4230b57cec5SDimitry Andric } 4240b57cec5SDimitry Andric 4250b57cec5SDimitry Andric static bool isNonTrivial(const DICompositeType *DCTy) { 4260b57cec5SDimitry Andric return ((DCTy->getFlags() & DINode::FlagNonTrivial) == DINode::FlagNonTrivial); 4270b57cec5SDimitry Andric } 4280b57cec5SDimitry Andric 4290b57cec5SDimitry Andric static FunctionOptions 4300b57cec5SDimitry Andric getFunctionOptions(const DISubroutineType *Ty, 4310b57cec5SDimitry Andric const DICompositeType *ClassTy = nullptr, 4320b57cec5SDimitry Andric StringRef SPName = StringRef("")) { 4330b57cec5SDimitry Andric FunctionOptions FO = FunctionOptions::None; 4340b57cec5SDimitry Andric const DIType *ReturnTy = nullptr; 4350b57cec5SDimitry Andric if (auto TypeArray = Ty->getTypeArray()) { 4360b57cec5SDimitry Andric if (TypeArray.size()) 4370b57cec5SDimitry Andric ReturnTy = TypeArray[0]; 4380b57cec5SDimitry Andric } 4390b57cec5SDimitry Andric 4405ffd83dbSDimitry Andric // Add CxxReturnUdt option to functions that return nontrivial record types 4415ffd83dbSDimitry Andric // or methods that return record types. 4425ffd83dbSDimitry Andric if (auto *ReturnDCTy = dyn_cast_or_null<DICompositeType>(ReturnTy)) 4435ffd83dbSDimitry Andric if (isNonTrivial(ReturnDCTy) || ClassTy) 4440b57cec5SDimitry Andric FO |= FunctionOptions::CxxReturnUdt; 4450b57cec5SDimitry Andric 4460b57cec5SDimitry Andric // DISubroutineType is unnamed. Use DISubprogram's i.e. SPName in comparison. 4470b57cec5SDimitry Andric if (ClassTy && isNonTrivial(ClassTy) && SPName == ClassTy->getName()) { 4480b57cec5SDimitry Andric FO |= FunctionOptions::Constructor; 4490b57cec5SDimitry Andric 4500b57cec5SDimitry Andric // TODO: put the FunctionOptions::ConstructorWithVirtualBases flag. 4510b57cec5SDimitry Andric 4520b57cec5SDimitry Andric } 4530b57cec5SDimitry Andric return FO; 4540b57cec5SDimitry Andric } 4550b57cec5SDimitry Andric 4560b57cec5SDimitry Andric TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP, 4570b57cec5SDimitry Andric const DICompositeType *Class) { 4580b57cec5SDimitry Andric // Always use the method declaration as the key for the function type. The 4590b57cec5SDimitry Andric // method declaration contains the this adjustment. 4600b57cec5SDimitry Andric if (SP->getDeclaration()) 4610b57cec5SDimitry Andric SP = SP->getDeclaration(); 4620b57cec5SDimitry Andric assert(!SP->getDeclaration() && "should use declaration as key"); 4630b57cec5SDimitry Andric 4640b57cec5SDimitry Andric // Key the MemberFunctionRecord into the map as {SP, Class}. It won't collide 4650b57cec5SDimitry Andric // with the MemberFuncIdRecord, which is keyed in as {SP, nullptr}. 4660b57cec5SDimitry Andric auto I = TypeIndices.find({SP, Class}); 4670b57cec5SDimitry Andric if (I != TypeIndices.end()) 4680b57cec5SDimitry Andric return I->second; 4690b57cec5SDimitry Andric 4700b57cec5SDimitry Andric // Make sure complete type info for the class is emitted *after* the member 4710b57cec5SDimitry Andric // function type, as the complete class type is likely to reference this 4720b57cec5SDimitry Andric // member function type. 4730b57cec5SDimitry Andric TypeLoweringScope S(*this); 4740b57cec5SDimitry Andric const bool IsStaticMethod = (SP->getFlags() & DINode::FlagStaticMember) != 0; 4750b57cec5SDimitry Andric 4760b57cec5SDimitry Andric FunctionOptions FO = getFunctionOptions(SP->getType(), Class, SP->getName()); 4770b57cec5SDimitry Andric TypeIndex TI = lowerTypeMemberFunction( 4780b57cec5SDimitry Andric SP->getType(), Class, SP->getThisAdjustment(), IsStaticMethod, FO); 4790b57cec5SDimitry Andric return recordTypeIndexForDINode(SP, TI, Class); 4800b57cec5SDimitry Andric } 4810b57cec5SDimitry Andric 4820b57cec5SDimitry Andric TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node, 4830b57cec5SDimitry Andric TypeIndex TI, 4840b57cec5SDimitry Andric const DIType *ClassTy) { 4850b57cec5SDimitry Andric auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI}); 4860b57cec5SDimitry Andric (void)InsertResult; 4870b57cec5SDimitry Andric assert(InsertResult.second && "DINode was already assigned a type index"); 4880b57cec5SDimitry Andric return TI; 4890b57cec5SDimitry Andric } 4900b57cec5SDimitry Andric 4910b57cec5SDimitry Andric unsigned CodeViewDebug::getPointerSizeInBytes() { 4920b57cec5SDimitry Andric return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8; 4930b57cec5SDimitry Andric } 4940b57cec5SDimitry Andric 4950b57cec5SDimitry Andric void CodeViewDebug::recordLocalVariable(LocalVariable &&Var, 4960b57cec5SDimitry Andric const LexicalScope *LS) { 4970b57cec5SDimitry Andric if (const DILocation *InlinedAt = LS->getInlinedAt()) { 4980b57cec5SDimitry Andric // This variable was inlined. Associate it with the InlineSite. 4990b57cec5SDimitry Andric const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram(); 5000b57cec5SDimitry Andric InlineSite &Site = getInlineSite(InlinedAt, Inlinee); 5010b57cec5SDimitry Andric Site.InlinedLocals.emplace_back(Var); 5020b57cec5SDimitry Andric } else { 5030b57cec5SDimitry Andric // This variable goes into the corresponding lexical scope. 5040b57cec5SDimitry Andric ScopeVariables[LS].emplace_back(Var); 5050b57cec5SDimitry Andric } 5060b57cec5SDimitry Andric } 5070b57cec5SDimitry Andric 5080b57cec5SDimitry Andric static void addLocIfNotPresent(SmallVectorImpl<const DILocation *> &Locs, 5090b57cec5SDimitry Andric const DILocation *Loc) { 5100b57cec5SDimitry Andric auto B = Locs.begin(), E = Locs.end(); 5110b57cec5SDimitry Andric if (std::find(B, E, Loc) == E) 5120b57cec5SDimitry Andric Locs.push_back(Loc); 5130b57cec5SDimitry Andric } 5140b57cec5SDimitry Andric 5150b57cec5SDimitry Andric void CodeViewDebug::maybeRecordLocation(const DebugLoc &DL, 5160b57cec5SDimitry Andric const MachineFunction *MF) { 5170b57cec5SDimitry Andric // Skip this instruction if it has the same location as the previous one. 5180b57cec5SDimitry Andric if (!DL || DL == PrevInstLoc) 5190b57cec5SDimitry Andric return; 5200b57cec5SDimitry Andric 5210b57cec5SDimitry Andric const DIScope *Scope = DL.get()->getScope(); 5220b57cec5SDimitry Andric if (!Scope) 5230b57cec5SDimitry Andric return; 5240b57cec5SDimitry Andric 5250b57cec5SDimitry Andric // Skip this line if it is longer than the maximum we can record. 5260b57cec5SDimitry Andric LineInfo LI(DL.getLine(), DL.getLine(), /*IsStatement=*/true); 5270b57cec5SDimitry Andric if (LI.getStartLine() != DL.getLine() || LI.isAlwaysStepInto() || 5280b57cec5SDimitry Andric LI.isNeverStepInto()) 5290b57cec5SDimitry Andric return; 5300b57cec5SDimitry Andric 5310b57cec5SDimitry Andric ColumnInfo CI(DL.getCol(), /*EndColumn=*/0); 5320b57cec5SDimitry Andric if (CI.getStartColumn() != DL.getCol()) 5330b57cec5SDimitry Andric return; 5340b57cec5SDimitry Andric 5350b57cec5SDimitry Andric if (!CurFn->HaveLineInfo) 5360b57cec5SDimitry Andric CurFn->HaveLineInfo = true; 5370b57cec5SDimitry Andric unsigned FileId = 0; 5380b57cec5SDimitry Andric if (PrevInstLoc.get() && PrevInstLoc->getFile() == DL->getFile()) 5390b57cec5SDimitry Andric FileId = CurFn->LastFileId; 5400b57cec5SDimitry Andric else 5410b57cec5SDimitry Andric FileId = CurFn->LastFileId = maybeRecordFile(DL->getFile()); 5420b57cec5SDimitry Andric PrevInstLoc = DL; 5430b57cec5SDimitry Andric 5440b57cec5SDimitry Andric unsigned FuncId = CurFn->FuncId; 5450b57cec5SDimitry Andric if (const DILocation *SiteLoc = DL->getInlinedAt()) { 5460b57cec5SDimitry Andric const DILocation *Loc = DL.get(); 5470b57cec5SDimitry Andric 5480b57cec5SDimitry Andric // If this location was actually inlined from somewhere else, give it the ID 5490b57cec5SDimitry Andric // of the inline call site. 5500b57cec5SDimitry Andric FuncId = 5510b57cec5SDimitry Andric getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()).SiteFuncId; 5520b57cec5SDimitry Andric 5530b57cec5SDimitry Andric // Ensure we have links in the tree of inline call sites. 5540b57cec5SDimitry Andric bool FirstLoc = true; 5550b57cec5SDimitry Andric while ((SiteLoc = Loc->getInlinedAt())) { 5560b57cec5SDimitry Andric InlineSite &Site = 5570b57cec5SDimitry Andric getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()); 5580b57cec5SDimitry Andric if (!FirstLoc) 5590b57cec5SDimitry Andric addLocIfNotPresent(Site.ChildSites, Loc); 5600b57cec5SDimitry Andric FirstLoc = false; 5610b57cec5SDimitry Andric Loc = SiteLoc; 5620b57cec5SDimitry Andric } 5630b57cec5SDimitry Andric addLocIfNotPresent(CurFn->ChildSites, Loc); 5640b57cec5SDimitry Andric } 5650b57cec5SDimitry Andric 5665ffd83dbSDimitry Andric OS.emitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(), 5670b57cec5SDimitry Andric /*PrologueEnd=*/false, /*IsStmt=*/false, 5680b57cec5SDimitry Andric DL->getFilename(), SMLoc()); 5690b57cec5SDimitry Andric } 5700b57cec5SDimitry Andric 5710b57cec5SDimitry Andric void CodeViewDebug::emitCodeViewMagicVersion() { 5725ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 5730b57cec5SDimitry Andric OS.AddComment("Debug section magic"); 5745ffd83dbSDimitry Andric OS.emitInt32(COFF::DEBUG_SECTION_MAGIC); 5750b57cec5SDimitry Andric } 5760b57cec5SDimitry Andric 5770b57cec5SDimitry Andric void CodeViewDebug::endModule() { 5780b57cec5SDimitry Andric if (!Asm || !MMI->hasDebugInfo()) 5790b57cec5SDimitry Andric return; 5800b57cec5SDimitry Andric 5810b57cec5SDimitry Andric assert(Asm != nullptr); 5820b57cec5SDimitry Andric 5830b57cec5SDimitry Andric // The COFF .debug$S section consists of several subsections, each starting 5840b57cec5SDimitry Andric // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length 5850b57cec5SDimitry Andric // of the payload followed by the payload itself. The subsections are 4-byte 5860b57cec5SDimitry Andric // aligned. 5870b57cec5SDimitry Andric 5880b57cec5SDimitry Andric // Use the generic .debug$S section, and make a subsection for all the inlined 5890b57cec5SDimitry Andric // subprograms. 5900b57cec5SDimitry Andric switchToDebugSectionForSymbol(nullptr); 5910b57cec5SDimitry Andric 5920b57cec5SDimitry Andric MCSymbol *CompilerInfo = beginCVSubsection(DebugSubsectionKind::Symbols); 5930b57cec5SDimitry Andric emitCompilerInformation(); 5940b57cec5SDimitry Andric endCVSubsection(CompilerInfo); 5950b57cec5SDimitry Andric 5960b57cec5SDimitry Andric emitInlineeLinesSubsection(); 5970b57cec5SDimitry Andric 5980b57cec5SDimitry Andric // Emit per-function debug information. 5990b57cec5SDimitry Andric for (auto &P : FnDebugInfo) 6000b57cec5SDimitry Andric if (!P.first->isDeclarationForLinker()) 6010b57cec5SDimitry Andric emitDebugInfoForFunction(P.first, *P.second); 6020b57cec5SDimitry Andric 6030b57cec5SDimitry Andric // Emit global variable debug information. 6040b57cec5SDimitry Andric setCurrentSubprogram(nullptr); 6050b57cec5SDimitry Andric emitDebugInfoForGlobals(); 6060b57cec5SDimitry Andric 6070b57cec5SDimitry Andric // Emit retained types. 6080b57cec5SDimitry Andric emitDebugInfoForRetainedTypes(); 6090b57cec5SDimitry Andric 6100b57cec5SDimitry Andric // Switch back to the generic .debug$S section after potentially processing 6110b57cec5SDimitry Andric // comdat symbol sections. 6120b57cec5SDimitry Andric switchToDebugSectionForSymbol(nullptr); 6130b57cec5SDimitry Andric 6140b57cec5SDimitry Andric // Emit UDT records for any types used by global variables. 6150b57cec5SDimitry Andric if (!GlobalUDTs.empty()) { 6160b57cec5SDimitry Andric MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 6170b57cec5SDimitry Andric emitDebugInfoForUDTs(GlobalUDTs); 6180b57cec5SDimitry Andric endCVSubsection(SymbolsEnd); 6190b57cec5SDimitry Andric } 6200b57cec5SDimitry Andric 6210b57cec5SDimitry Andric // This subsection holds a file index to offset in string table table. 6220b57cec5SDimitry Andric OS.AddComment("File index to string table offset subsection"); 6235ffd83dbSDimitry Andric OS.emitCVFileChecksumsDirective(); 6240b57cec5SDimitry Andric 6250b57cec5SDimitry Andric // This subsection holds the string table. 6260b57cec5SDimitry Andric OS.AddComment("String table"); 6275ffd83dbSDimitry Andric OS.emitCVStringTableDirective(); 6280b57cec5SDimitry Andric 6290b57cec5SDimitry Andric // Emit S_BUILDINFO, which points to LF_BUILDINFO. Put this in its own symbol 6300b57cec5SDimitry Andric // subsection in the generic .debug$S section at the end. There is no 6310b57cec5SDimitry Andric // particular reason for this ordering other than to match MSVC. 6320b57cec5SDimitry Andric emitBuildInfo(); 6330b57cec5SDimitry Andric 6340b57cec5SDimitry Andric // Emit type information and hashes last, so that any types we translate while 6350b57cec5SDimitry Andric // emitting function info are included. 6360b57cec5SDimitry Andric emitTypeInformation(); 6370b57cec5SDimitry Andric 6380b57cec5SDimitry Andric if (EmitDebugGlobalHashes) 6390b57cec5SDimitry Andric emitTypeGlobalHashes(); 6400b57cec5SDimitry Andric 6410b57cec5SDimitry Andric clear(); 6420b57cec5SDimitry Andric } 6430b57cec5SDimitry Andric 6440b57cec5SDimitry Andric static void 6450b57cec5SDimitry Andric emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S, 6460b57cec5SDimitry Andric unsigned MaxFixedRecordLength = 0xF00) { 6470b57cec5SDimitry Andric // The maximum CV record length is 0xFF00. Most of the strings we emit appear 6480b57cec5SDimitry Andric // after a fixed length portion of the record. The fixed length portion should 6490b57cec5SDimitry Andric // always be less than 0xF00 (3840) bytes, so truncate the string so that the 6500b57cec5SDimitry Andric // overall record size is less than the maximum allowed. 6510b57cec5SDimitry Andric SmallString<32> NullTerminatedString( 6520b57cec5SDimitry Andric S.take_front(MaxRecordLength - MaxFixedRecordLength - 1)); 6530b57cec5SDimitry Andric NullTerminatedString.push_back('\0'); 6545ffd83dbSDimitry Andric OS.emitBytes(NullTerminatedString); 6550b57cec5SDimitry Andric } 6560b57cec5SDimitry Andric 6570b57cec5SDimitry Andric void CodeViewDebug::emitTypeInformation() { 6580b57cec5SDimitry Andric if (TypeTable.empty()) 6590b57cec5SDimitry Andric return; 6600b57cec5SDimitry Andric 6610b57cec5SDimitry Andric // Start the .debug$T or .debug$P section with 0x4. 6620b57cec5SDimitry Andric OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection()); 6630b57cec5SDimitry Andric emitCodeViewMagicVersion(); 6640b57cec5SDimitry Andric 6650b57cec5SDimitry Andric TypeTableCollection Table(TypeTable.records()); 6660b57cec5SDimitry Andric TypeVisitorCallbackPipeline Pipeline; 6670b57cec5SDimitry Andric 6680b57cec5SDimitry Andric // To emit type record using Codeview MCStreamer adapter 6698bcb0991SDimitry Andric CVMCAdapter CVMCOS(OS, Table); 6700b57cec5SDimitry Andric TypeRecordMapping typeMapping(CVMCOS); 6710b57cec5SDimitry Andric Pipeline.addCallbackToPipeline(typeMapping); 6720b57cec5SDimitry Andric 6730b57cec5SDimitry Andric Optional<TypeIndex> B = Table.getFirst(); 6740b57cec5SDimitry Andric while (B) { 6750b57cec5SDimitry Andric // This will fail if the record data is invalid. 6760b57cec5SDimitry Andric CVType Record = Table.getType(*B); 6770b57cec5SDimitry Andric 6780b57cec5SDimitry Andric Error E = codeview::visitTypeRecord(Record, *B, Pipeline); 6790b57cec5SDimitry Andric 6800b57cec5SDimitry Andric if (E) { 6810b57cec5SDimitry Andric logAllUnhandledErrors(std::move(E), errs(), "error: "); 6820b57cec5SDimitry Andric llvm_unreachable("produced malformed type record"); 6830b57cec5SDimitry Andric } 6840b57cec5SDimitry Andric 6850b57cec5SDimitry Andric B = Table.getNext(*B); 6860b57cec5SDimitry Andric } 6870b57cec5SDimitry Andric } 6880b57cec5SDimitry Andric 6890b57cec5SDimitry Andric void CodeViewDebug::emitTypeGlobalHashes() { 6900b57cec5SDimitry Andric if (TypeTable.empty()) 6910b57cec5SDimitry Andric return; 6920b57cec5SDimitry Andric 6930b57cec5SDimitry Andric // Start the .debug$H section with the version and hash algorithm, currently 6940b57cec5SDimitry Andric // hardcoded to version 0, SHA1. 6950b57cec5SDimitry Andric OS.SwitchSection(Asm->getObjFileLowering().getCOFFGlobalTypeHashesSection()); 6960b57cec5SDimitry Andric 6975ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 6980b57cec5SDimitry Andric OS.AddComment("Magic"); 6995ffd83dbSDimitry Andric OS.emitInt32(COFF::DEBUG_HASHES_SECTION_MAGIC); 7000b57cec5SDimitry Andric OS.AddComment("Section Version"); 7015ffd83dbSDimitry Andric OS.emitInt16(0); 7020b57cec5SDimitry Andric OS.AddComment("Hash Algorithm"); 7035ffd83dbSDimitry Andric OS.emitInt16(uint16_t(GlobalTypeHashAlg::SHA1_8)); 7040b57cec5SDimitry Andric 7050b57cec5SDimitry Andric TypeIndex TI(TypeIndex::FirstNonSimpleIndex); 7060b57cec5SDimitry Andric for (const auto &GHR : TypeTable.hashes()) { 7070b57cec5SDimitry Andric if (OS.isVerboseAsm()) { 7080b57cec5SDimitry Andric // Emit an EOL-comment describing which TypeIndex this hash corresponds 7090b57cec5SDimitry Andric // to, as well as the stringified SHA1 hash. 7100b57cec5SDimitry Andric SmallString<32> Comment; 7110b57cec5SDimitry Andric raw_svector_ostream CommentOS(Comment); 7120b57cec5SDimitry Andric CommentOS << formatv("{0:X+} [{1}]", TI.getIndex(), GHR); 7130b57cec5SDimitry Andric OS.AddComment(Comment); 7140b57cec5SDimitry Andric ++TI; 7150b57cec5SDimitry Andric } 7160b57cec5SDimitry Andric assert(GHR.Hash.size() == 8); 7170b57cec5SDimitry Andric StringRef S(reinterpret_cast<const char *>(GHR.Hash.data()), 7180b57cec5SDimitry Andric GHR.Hash.size()); 7195ffd83dbSDimitry Andric OS.emitBinaryData(S); 7200b57cec5SDimitry Andric } 7210b57cec5SDimitry Andric } 7220b57cec5SDimitry Andric 7230b57cec5SDimitry Andric static SourceLanguage MapDWLangToCVLang(unsigned DWLang) { 7240b57cec5SDimitry Andric switch (DWLang) { 7250b57cec5SDimitry Andric case dwarf::DW_LANG_C: 7260b57cec5SDimitry Andric case dwarf::DW_LANG_C89: 7270b57cec5SDimitry Andric case dwarf::DW_LANG_C99: 7280b57cec5SDimitry Andric case dwarf::DW_LANG_C11: 7290b57cec5SDimitry Andric case dwarf::DW_LANG_ObjC: 7300b57cec5SDimitry Andric return SourceLanguage::C; 7310b57cec5SDimitry Andric case dwarf::DW_LANG_C_plus_plus: 7320b57cec5SDimitry Andric case dwarf::DW_LANG_C_plus_plus_03: 7330b57cec5SDimitry Andric case dwarf::DW_LANG_C_plus_plus_11: 7340b57cec5SDimitry Andric case dwarf::DW_LANG_C_plus_plus_14: 7350b57cec5SDimitry Andric return SourceLanguage::Cpp; 7360b57cec5SDimitry Andric case dwarf::DW_LANG_Fortran77: 7370b57cec5SDimitry Andric case dwarf::DW_LANG_Fortran90: 7380b57cec5SDimitry Andric case dwarf::DW_LANG_Fortran03: 7390b57cec5SDimitry Andric case dwarf::DW_LANG_Fortran08: 7400b57cec5SDimitry Andric return SourceLanguage::Fortran; 7410b57cec5SDimitry Andric case dwarf::DW_LANG_Pascal83: 7420b57cec5SDimitry Andric return SourceLanguage::Pascal; 7430b57cec5SDimitry Andric case dwarf::DW_LANG_Cobol74: 7440b57cec5SDimitry Andric case dwarf::DW_LANG_Cobol85: 7450b57cec5SDimitry Andric return SourceLanguage::Cobol; 7460b57cec5SDimitry Andric case dwarf::DW_LANG_Java: 7470b57cec5SDimitry Andric return SourceLanguage::Java; 7480b57cec5SDimitry Andric case dwarf::DW_LANG_D: 7490b57cec5SDimitry Andric return SourceLanguage::D; 7500b57cec5SDimitry Andric case dwarf::DW_LANG_Swift: 7510b57cec5SDimitry Andric return SourceLanguage::Swift; 7520b57cec5SDimitry Andric default: 7530b57cec5SDimitry Andric // There's no CodeView representation for this language, and CV doesn't 7540b57cec5SDimitry Andric // have an "unknown" option for the language field, so we'll use MASM, 7550b57cec5SDimitry Andric // as it's very low level. 7560b57cec5SDimitry Andric return SourceLanguage::Masm; 7570b57cec5SDimitry Andric } 7580b57cec5SDimitry Andric } 7590b57cec5SDimitry Andric 7600b57cec5SDimitry Andric namespace { 7610b57cec5SDimitry Andric struct Version { 7620b57cec5SDimitry Andric int Part[4]; 7630b57cec5SDimitry Andric }; 7640b57cec5SDimitry Andric } // end anonymous namespace 7650b57cec5SDimitry Andric 7660b57cec5SDimitry Andric // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out 7670b57cec5SDimitry Andric // the version number. 7680b57cec5SDimitry Andric static Version parseVersion(StringRef Name) { 7690b57cec5SDimitry Andric Version V = {{0}}; 7700b57cec5SDimitry Andric int N = 0; 7710b57cec5SDimitry Andric for (const char C : Name) { 7720b57cec5SDimitry Andric if (isdigit(C)) { 7730b57cec5SDimitry Andric V.Part[N] *= 10; 7740b57cec5SDimitry Andric V.Part[N] += C - '0'; 7750b57cec5SDimitry Andric } else if (C == '.') { 7760b57cec5SDimitry Andric ++N; 7770b57cec5SDimitry Andric if (N >= 4) 7780b57cec5SDimitry Andric return V; 7790b57cec5SDimitry Andric } else if (N > 0) 7800b57cec5SDimitry Andric return V; 7810b57cec5SDimitry Andric } 7820b57cec5SDimitry Andric return V; 7830b57cec5SDimitry Andric } 7840b57cec5SDimitry Andric 7850b57cec5SDimitry Andric void CodeViewDebug::emitCompilerInformation() { 7860b57cec5SDimitry Andric MCSymbol *CompilerEnd = beginSymbolRecord(SymbolKind::S_COMPILE3); 7870b57cec5SDimitry Andric uint32_t Flags = 0; 7880b57cec5SDimitry Andric 7890b57cec5SDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 7900b57cec5SDimitry Andric const MDNode *Node = *CUs->operands().begin(); 7910b57cec5SDimitry Andric const auto *CU = cast<DICompileUnit>(Node); 7920b57cec5SDimitry Andric 7930b57cec5SDimitry Andric // The low byte of the flags indicates the source language. 7940b57cec5SDimitry Andric Flags = MapDWLangToCVLang(CU->getSourceLanguage()); 7950b57cec5SDimitry Andric // TODO: Figure out which other flags need to be set. 7960b57cec5SDimitry Andric 7970b57cec5SDimitry Andric OS.AddComment("Flags and language"); 7985ffd83dbSDimitry Andric OS.emitInt32(Flags); 7990b57cec5SDimitry Andric 8000b57cec5SDimitry Andric OS.AddComment("CPUType"); 8015ffd83dbSDimitry Andric OS.emitInt16(static_cast<uint64_t>(TheCPU)); 8020b57cec5SDimitry Andric 8030b57cec5SDimitry Andric StringRef CompilerVersion = CU->getProducer(); 8040b57cec5SDimitry Andric Version FrontVer = parseVersion(CompilerVersion); 8050b57cec5SDimitry Andric OS.AddComment("Frontend version"); 8060b57cec5SDimitry Andric for (int N = 0; N < 4; ++N) 8075ffd83dbSDimitry Andric OS.emitInt16(FrontVer.Part[N]); 8080b57cec5SDimitry Andric 8090b57cec5SDimitry Andric // Some Microsoft tools, like Binscope, expect a backend version number of at 8100b57cec5SDimitry Andric // least 8.something, so we'll coerce the LLVM version into a form that 8110b57cec5SDimitry Andric // guarantees it'll be big enough without really lying about the version. 8120b57cec5SDimitry Andric int Major = 1000 * LLVM_VERSION_MAJOR + 8130b57cec5SDimitry Andric 10 * LLVM_VERSION_MINOR + 8140b57cec5SDimitry Andric LLVM_VERSION_PATCH; 8150b57cec5SDimitry Andric // Clamp it for builds that use unusually large version numbers. 8160b57cec5SDimitry Andric Major = std::min<int>(Major, std::numeric_limits<uint16_t>::max()); 8170b57cec5SDimitry Andric Version BackVer = {{ Major, 0, 0, 0 }}; 8180b57cec5SDimitry Andric OS.AddComment("Backend version"); 8190b57cec5SDimitry Andric for (int N = 0; N < 4; ++N) 8205ffd83dbSDimitry Andric OS.emitInt16(BackVer.Part[N]); 8210b57cec5SDimitry Andric 8220b57cec5SDimitry Andric OS.AddComment("Null-terminated compiler version string"); 8230b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, CompilerVersion); 8240b57cec5SDimitry Andric 8250b57cec5SDimitry Andric endSymbolRecord(CompilerEnd); 8260b57cec5SDimitry Andric } 8270b57cec5SDimitry Andric 8280b57cec5SDimitry Andric static TypeIndex getStringIdTypeIdx(GlobalTypeTableBuilder &TypeTable, 8290b57cec5SDimitry Andric StringRef S) { 8300b57cec5SDimitry Andric StringIdRecord SIR(TypeIndex(0x0), S); 8310b57cec5SDimitry Andric return TypeTable.writeLeafType(SIR); 8320b57cec5SDimitry Andric } 8330b57cec5SDimitry Andric 8340b57cec5SDimitry Andric void CodeViewDebug::emitBuildInfo() { 8350b57cec5SDimitry Andric // First, make LF_BUILDINFO. It's a sequence of strings with various bits of 8360b57cec5SDimitry Andric // build info. The known prefix is: 8370b57cec5SDimitry Andric // - Absolute path of current directory 8380b57cec5SDimitry Andric // - Compiler path 8390b57cec5SDimitry Andric // - Main source file path, relative to CWD or absolute 8400b57cec5SDimitry Andric // - Type server PDB file 8410b57cec5SDimitry Andric // - Canonical compiler command line 8420b57cec5SDimitry Andric // If frontend and backend compilation are separated (think llc or LTO), it's 8430b57cec5SDimitry Andric // not clear if the compiler path should refer to the executable for the 8440b57cec5SDimitry Andric // frontend or the backend. Leave it blank for now. 8450b57cec5SDimitry Andric TypeIndex BuildInfoArgs[BuildInfoRecord::MaxArgs] = {}; 8460b57cec5SDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 8470b57cec5SDimitry Andric const MDNode *Node = *CUs->operands().begin(); // FIXME: Multiple CUs. 8480b57cec5SDimitry Andric const auto *CU = cast<DICompileUnit>(Node); 8490b57cec5SDimitry Andric const DIFile *MainSourceFile = CU->getFile(); 8500b57cec5SDimitry Andric BuildInfoArgs[BuildInfoRecord::CurrentDirectory] = 8510b57cec5SDimitry Andric getStringIdTypeIdx(TypeTable, MainSourceFile->getDirectory()); 8520b57cec5SDimitry Andric BuildInfoArgs[BuildInfoRecord::SourceFile] = 8530b57cec5SDimitry Andric getStringIdTypeIdx(TypeTable, MainSourceFile->getFilename()); 8540b57cec5SDimitry Andric // FIXME: Path to compiler and command line. PDB is intentionally blank unless 8550b57cec5SDimitry Andric // we implement /Zi type servers. 8560b57cec5SDimitry Andric BuildInfoRecord BIR(BuildInfoArgs); 8570b57cec5SDimitry Andric TypeIndex BuildInfoIndex = TypeTable.writeLeafType(BIR); 8580b57cec5SDimitry Andric 8590b57cec5SDimitry Andric // Make a new .debug$S subsection for the S_BUILDINFO record, which points 8600b57cec5SDimitry Andric // from the module symbols into the type stream. 8610b57cec5SDimitry Andric MCSymbol *BISubsecEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 8620b57cec5SDimitry Andric MCSymbol *BIEnd = beginSymbolRecord(SymbolKind::S_BUILDINFO); 8630b57cec5SDimitry Andric OS.AddComment("LF_BUILDINFO index"); 8645ffd83dbSDimitry Andric OS.emitInt32(BuildInfoIndex.getIndex()); 8650b57cec5SDimitry Andric endSymbolRecord(BIEnd); 8660b57cec5SDimitry Andric endCVSubsection(BISubsecEnd); 8670b57cec5SDimitry Andric } 8680b57cec5SDimitry Andric 8690b57cec5SDimitry Andric void CodeViewDebug::emitInlineeLinesSubsection() { 8700b57cec5SDimitry Andric if (InlinedSubprograms.empty()) 8710b57cec5SDimitry Andric return; 8720b57cec5SDimitry Andric 8730b57cec5SDimitry Andric OS.AddComment("Inlinee lines subsection"); 8740b57cec5SDimitry Andric MCSymbol *InlineEnd = beginCVSubsection(DebugSubsectionKind::InlineeLines); 8750b57cec5SDimitry Andric 8760b57cec5SDimitry Andric // We emit the checksum info for files. This is used by debuggers to 8770b57cec5SDimitry Andric // determine if a pdb matches the source before loading it. Visual Studio, 8780b57cec5SDimitry Andric // for instance, will display a warning that the breakpoints are not valid if 8790b57cec5SDimitry Andric // the pdb does not match the source. 8800b57cec5SDimitry Andric OS.AddComment("Inlinee lines signature"); 8815ffd83dbSDimitry Andric OS.emitInt32(unsigned(InlineeLinesSignature::Normal)); 8820b57cec5SDimitry Andric 8830b57cec5SDimitry Andric for (const DISubprogram *SP : InlinedSubprograms) { 8840b57cec5SDimitry Andric assert(TypeIndices.count({SP, nullptr})); 8850b57cec5SDimitry Andric TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}]; 8860b57cec5SDimitry Andric 8870b57cec5SDimitry Andric OS.AddBlankLine(); 8880b57cec5SDimitry Andric unsigned FileId = maybeRecordFile(SP->getFile()); 8890b57cec5SDimitry Andric OS.AddComment("Inlined function " + SP->getName() + " starts at " + 8900b57cec5SDimitry Andric SP->getFilename() + Twine(':') + Twine(SP->getLine())); 8910b57cec5SDimitry Andric OS.AddBlankLine(); 8920b57cec5SDimitry Andric OS.AddComment("Type index of inlined function"); 8935ffd83dbSDimitry Andric OS.emitInt32(InlineeIdx.getIndex()); 8940b57cec5SDimitry Andric OS.AddComment("Offset into filechecksum table"); 8955ffd83dbSDimitry Andric OS.emitCVFileChecksumOffsetDirective(FileId); 8960b57cec5SDimitry Andric OS.AddComment("Starting line number"); 8975ffd83dbSDimitry Andric OS.emitInt32(SP->getLine()); 8980b57cec5SDimitry Andric } 8990b57cec5SDimitry Andric 9000b57cec5SDimitry Andric endCVSubsection(InlineEnd); 9010b57cec5SDimitry Andric } 9020b57cec5SDimitry Andric 9030b57cec5SDimitry Andric void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI, 9040b57cec5SDimitry Andric const DILocation *InlinedAt, 9050b57cec5SDimitry Andric const InlineSite &Site) { 9060b57cec5SDimitry Andric assert(TypeIndices.count({Site.Inlinee, nullptr})); 9070b57cec5SDimitry Andric TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}]; 9080b57cec5SDimitry Andric 9090b57cec5SDimitry Andric // SymbolRecord 9100b57cec5SDimitry Andric MCSymbol *InlineEnd = beginSymbolRecord(SymbolKind::S_INLINESITE); 9110b57cec5SDimitry Andric 9120b57cec5SDimitry Andric OS.AddComment("PtrParent"); 9135ffd83dbSDimitry Andric OS.emitInt32(0); 9140b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 9155ffd83dbSDimitry Andric OS.emitInt32(0); 9160b57cec5SDimitry Andric OS.AddComment("Inlinee type index"); 9175ffd83dbSDimitry Andric OS.emitInt32(InlineeIdx.getIndex()); 9180b57cec5SDimitry Andric 9190b57cec5SDimitry Andric unsigned FileId = maybeRecordFile(Site.Inlinee->getFile()); 9200b57cec5SDimitry Andric unsigned StartLineNum = Site.Inlinee->getLine(); 9210b57cec5SDimitry Andric 9225ffd83dbSDimitry Andric OS.emitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum, 9230b57cec5SDimitry Andric FI.Begin, FI.End); 9240b57cec5SDimitry Andric 9250b57cec5SDimitry Andric endSymbolRecord(InlineEnd); 9260b57cec5SDimitry Andric 9270b57cec5SDimitry Andric emitLocalVariableList(FI, Site.InlinedLocals); 9280b57cec5SDimitry Andric 9290b57cec5SDimitry Andric // Recurse on child inlined call sites before closing the scope. 9300b57cec5SDimitry Andric for (const DILocation *ChildSite : Site.ChildSites) { 9310b57cec5SDimitry Andric auto I = FI.InlineSites.find(ChildSite); 9320b57cec5SDimitry Andric assert(I != FI.InlineSites.end() && 9330b57cec5SDimitry Andric "child site not in function inline site map"); 9340b57cec5SDimitry Andric emitInlinedCallSite(FI, ChildSite, I->second); 9350b57cec5SDimitry Andric } 9360b57cec5SDimitry Andric 9370b57cec5SDimitry Andric // Close the scope. 9380b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_INLINESITE_END); 9390b57cec5SDimitry Andric } 9400b57cec5SDimitry Andric 9410b57cec5SDimitry Andric void CodeViewDebug::switchToDebugSectionForSymbol(const MCSymbol *GVSym) { 9420b57cec5SDimitry Andric // If we have a symbol, it may be in a section that is COMDAT. If so, find the 9430b57cec5SDimitry Andric // comdat key. A section may be comdat because of -ffunction-sections or 9440b57cec5SDimitry Andric // because it is comdat in the IR. 9450b57cec5SDimitry Andric MCSectionCOFF *GVSec = 9460b57cec5SDimitry Andric GVSym ? dyn_cast<MCSectionCOFF>(&GVSym->getSection()) : nullptr; 9470b57cec5SDimitry Andric const MCSymbol *KeySym = GVSec ? GVSec->getCOMDATSymbol() : nullptr; 9480b57cec5SDimitry Andric 9490b57cec5SDimitry Andric MCSectionCOFF *DebugSec = cast<MCSectionCOFF>( 9500b57cec5SDimitry Andric Asm->getObjFileLowering().getCOFFDebugSymbolsSection()); 9510b57cec5SDimitry Andric DebugSec = OS.getContext().getAssociativeCOFFSection(DebugSec, KeySym); 9520b57cec5SDimitry Andric 9530b57cec5SDimitry Andric OS.SwitchSection(DebugSec); 9540b57cec5SDimitry Andric 9550b57cec5SDimitry Andric // Emit the magic version number if this is the first time we've switched to 9560b57cec5SDimitry Andric // this section. 9570b57cec5SDimitry Andric if (ComdatDebugSections.insert(DebugSec).second) 9580b57cec5SDimitry Andric emitCodeViewMagicVersion(); 9590b57cec5SDimitry Andric } 9600b57cec5SDimitry Andric 9610b57cec5SDimitry Andric // Emit an S_THUNK32/S_END symbol pair for a thunk routine. 9620b57cec5SDimitry Andric // The only supported thunk ordinal is currently the standard type. 9630b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForThunk(const Function *GV, 9640b57cec5SDimitry Andric FunctionInfo &FI, 9650b57cec5SDimitry Andric const MCSymbol *Fn) { 9665ffd83dbSDimitry Andric std::string FuncName = 9675ffd83dbSDimitry Andric std::string(GlobalValue::dropLLVMManglingEscape(GV->getName())); 9680b57cec5SDimitry Andric const ThunkOrdinal ordinal = ThunkOrdinal::Standard; // Only supported kind. 9690b57cec5SDimitry Andric 9700b57cec5SDimitry Andric OS.AddComment("Symbol subsection for " + Twine(FuncName)); 9710b57cec5SDimitry Andric MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 9720b57cec5SDimitry Andric 9730b57cec5SDimitry Andric // Emit S_THUNK32 9740b57cec5SDimitry Andric MCSymbol *ThunkRecordEnd = beginSymbolRecord(SymbolKind::S_THUNK32); 9750b57cec5SDimitry Andric OS.AddComment("PtrParent"); 9765ffd83dbSDimitry Andric OS.emitInt32(0); 9770b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 9785ffd83dbSDimitry Andric OS.emitInt32(0); 9790b57cec5SDimitry Andric OS.AddComment("PtrNext"); 9805ffd83dbSDimitry Andric OS.emitInt32(0); 9810b57cec5SDimitry Andric OS.AddComment("Thunk section relative address"); 9820b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Fn, /*Offset=*/0); 9830b57cec5SDimitry Andric OS.AddComment("Thunk section index"); 9840b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(Fn); 9850b57cec5SDimitry Andric OS.AddComment("Code size"); 9860b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(FI.End, Fn, 2); 9870b57cec5SDimitry Andric OS.AddComment("Ordinal"); 9885ffd83dbSDimitry Andric OS.emitInt8(unsigned(ordinal)); 9890b57cec5SDimitry Andric OS.AddComment("Function name"); 9900b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, FuncName); 9910b57cec5SDimitry Andric // Additional fields specific to the thunk ordinal would go here. 9920b57cec5SDimitry Andric endSymbolRecord(ThunkRecordEnd); 9930b57cec5SDimitry Andric 9940b57cec5SDimitry Andric // Local variables/inlined routines are purposely omitted here. The point of 9950b57cec5SDimitry Andric // marking this as a thunk is so Visual Studio will NOT stop in this routine. 9960b57cec5SDimitry Andric 9970b57cec5SDimitry Andric // Emit S_PROC_ID_END 9980b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_PROC_ID_END); 9990b57cec5SDimitry Andric 10000b57cec5SDimitry Andric endCVSubsection(SymbolsEnd); 10010b57cec5SDimitry Andric } 10020b57cec5SDimitry Andric 10030b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForFunction(const Function *GV, 10040b57cec5SDimitry Andric FunctionInfo &FI) { 10050b57cec5SDimitry Andric // For each function there is a separate subsection which holds the PC to 10060b57cec5SDimitry Andric // file:line table. 10070b57cec5SDimitry Andric const MCSymbol *Fn = Asm->getSymbol(GV); 10080b57cec5SDimitry Andric assert(Fn); 10090b57cec5SDimitry Andric 10100b57cec5SDimitry Andric // Switch to the to a comdat section, if appropriate. 10110b57cec5SDimitry Andric switchToDebugSectionForSymbol(Fn); 10120b57cec5SDimitry Andric 10130b57cec5SDimitry Andric std::string FuncName; 10140b57cec5SDimitry Andric auto *SP = GV->getSubprogram(); 10150b57cec5SDimitry Andric assert(SP); 10160b57cec5SDimitry Andric setCurrentSubprogram(SP); 10170b57cec5SDimitry Andric 10180b57cec5SDimitry Andric if (SP->isThunk()) { 10190b57cec5SDimitry Andric emitDebugInfoForThunk(GV, FI, Fn); 10200b57cec5SDimitry Andric return; 10210b57cec5SDimitry Andric } 10220b57cec5SDimitry Andric 10230b57cec5SDimitry Andric // If we have a display name, build the fully qualified name by walking the 10240b57cec5SDimitry Andric // chain of scopes. 10250b57cec5SDimitry Andric if (!SP->getName().empty()) 10260b57cec5SDimitry Andric FuncName = getFullyQualifiedName(SP->getScope(), SP->getName()); 10270b57cec5SDimitry Andric 10280b57cec5SDimitry Andric // If our DISubprogram name is empty, use the mangled name. 10290b57cec5SDimitry Andric if (FuncName.empty()) 10305ffd83dbSDimitry Andric FuncName = std::string(GlobalValue::dropLLVMManglingEscape(GV->getName())); 10310b57cec5SDimitry Andric 10320b57cec5SDimitry Andric // Emit FPO data, but only on 32-bit x86. No other platforms use it. 10330b57cec5SDimitry Andric if (Triple(MMI->getModule()->getTargetTriple()).getArch() == Triple::x86) 10340b57cec5SDimitry Andric OS.EmitCVFPOData(Fn); 10350b57cec5SDimitry Andric 10360b57cec5SDimitry Andric // Emit a symbol subsection, required by VS2012+ to find function boundaries. 10370b57cec5SDimitry Andric OS.AddComment("Symbol subsection for " + Twine(FuncName)); 10380b57cec5SDimitry Andric MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols); 10390b57cec5SDimitry Andric { 10400b57cec5SDimitry Andric SymbolKind ProcKind = GV->hasLocalLinkage() ? SymbolKind::S_LPROC32_ID 10410b57cec5SDimitry Andric : SymbolKind::S_GPROC32_ID; 10420b57cec5SDimitry Andric MCSymbol *ProcRecordEnd = beginSymbolRecord(ProcKind); 10430b57cec5SDimitry Andric 10440b57cec5SDimitry Andric // These fields are filled in by tools like CVPACK which run after the fact. 10450b57cec5SDimitry Andric OS.AddComment("PtrParent"); 10465ffd83dbSDimitry Andric OS.emitInt32(0); 10470b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 10485ffd83dbSDimitry Andric OS.emitInt32(0); 10490b57cec5SDimitry Andric OS.AddComment("PtrNext"); 10505ffd83dbSDimitry Andric OS.emitInt32(0); 10510b57cec5SDimitry Andric // This is the important bit that tells the debugger where the function 10520b57cec5SDimitry Andric // code is located and what's its size: 10530b57cec5SDimitry Andric OS.AddComment("Code size"); 10540b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4); 10550b57cec5SDimitry Andric OS.AddComment("Offset after prologue"); 10565ffd83dbSDimitry Andric OS.emitInt32(0); 10570b57cec5SDimitry Andric OS.AddComment("Offset before epilogue"); 10585ffd83dbSDimitry Andric OS.emitInt32(0); 10590b57cec5SDimitry Andric OS.AddComment("Function type index"); 10605ffd83dbSDimitry Andric OS.emitInt32(getFuncIdForSubprogram(GV->getSubprogram()).getIndex()); 10610b57cec5SDimitry Andric OS.AddComment("Function section relative address"); 10620b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Fn, /*Offset=*/0); 10630b57cec5SDimitry Andric OS.AddComment("Function section index"); 10640b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(Fn); 10650b57cec5SDimitry Andric OS.AddComment("Flags"); 10665ffd83dbSDimitry Andric OS.emitInt8(0); 10670b57cec5SDimitry Andric // Emit the function display name as a null-terminated string. 10680b57cec5SDimitry Andric OS.AddComment("Function name"); 10690b57cec5SDimitry Andric // Truncate the name so we won't overflow the record length field. 10700b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, FuncName); 10710b57cec5SDimitry Andric endSymbolRecord(ProcRecordEnd); 10720b57cec5SDimitry Andric 10730b57cec5SDimitry Andric MCSymbol *FrameProcEnd = beginSymbolRecord(SymbolKind::S_FRAMEPROC); 10740b57cec5SDimitry Andric // Subtract out the CSR size since MSVC excludes that and we include it. 10750b57cec5SDimitry Andric OS.AddComment("FrameSize"); 10765ffd83dbSDimitry Andric OS.emitInt32(FI.FrameSize - FI.CSRSize); 10770b57cec5SDimitry Andric OS.AddComment("Padding"); 10785ffd83dbSDimitry Andric OS.emitInt32(0); 10790b57cec5SDimitry Andric OS.AddComment("Offset of padding"); 10805ffd83dbSDimitry Andric OS.emitInt32(0); 10810b57cec5SDimitry Andric OS.AddComment("Bytes of callee saved registers"); 10825ffd83dbSDimitry Andric OS.emitInt32(FI.CSRSize); 10830b57cec5SDimitry Andric OS.AddComment("Exception handler offset"); 10845ffd83dbSDimitry Andric OS.emitInt32(0); 10850b57cec5SDimitry Andric OS.AddComment("Exception handler section"); 10865ffd83dbSDimitry Andric OS.emitInt16(0); 10870b57cec5SDimitry Andric OS.AddComment("Flags (defines frame register)"); 10885ffd83dbSDimitry Andric OS.emitInt32(uint32_t(FI.FrameProcOpts)); 10890b57cec5SDimitry Andric endSymbolRecord(FrameProcEnd); 10900b57cec5SDimitry Andric 10910b57cec5SDimitry Andric emitLocalVariableList(FI, FI.Locals); 10920b57cec5SDimitry Andric emitGlobalVariableList(FI.Globals); 10930b57cec5SDimitry Andric emitLexicalBlockList(FI.ChildBlocks, FI); 10940b57cec5SDimitry Andric 10950b57cec5SDimitry Andric // Emit inlined call site information. Only emit functions inlined directly 10960b57cec5SDimitry Andric // into the parent function. We'll emit the other sites recursively as part 10970b57cec5SDimitry Andric // of their parent inline site. 10980b57cec5SDimitry Andric for (const DILocation *InlinedAt : FI.ChildSites) { 10990b57cec5SDimitry Andric auto I = FI.InlineSites.find(InlinedAt); 11000b57cec5SDimitry Andric assert(I != FI.InlineSites.end() && 11010b57cec5SDimitry Andric "child site not in function inline site map"); 11020b57cec5SDimitry Andric emitInlinedCallSite(FI, InlinedAt, I->second); 11030b57cec5SDimitry Andric } 11040b57cec5SDimitry Andric 11050b57cec5SDimitry Andric for (auto Annot : FI.Annotations) { 11060b57cec5SDimitry Andric MCSymbol *Label = Annot.first; 11070b57cec5SDimitry Andric MDTuple *Strs = cast<MDTuple>(Annot.second); 11080b57cec5SDimitry Andric MCSymbol *AnnotEnd = beginSymbolRecord(SymbolKind::S_ANNOTATION); 11090b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Label, /*Offset=*/0); 11100b57cec5SDimitry Andric // FIXME: Make sure we don't overflow the max record size. 11110b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(Label); 11125ffd83dbSDimitry Andric OS.emitInt16(Strs->getNumOperands()); 11130b57cec5SDimitry Andric for (Metadata *MD : Strs->operands()) { 11140b57cec5SDimitry Andric // MDStrings are null terminated, so we can do EmitBytes and get the 11150b57cec5SDimitry Andric // nice .asciz directive. 11160b57cec5SDimitry Andric StringRef Str = cast<MDString>(MD)->getString(); 11170b57cec5SDimitry Andric assert(Str.data()[Str.size()] == '\0' && "non-nullterminated MDString"); 11185ffd83dbSDimitry Andric OS.emitBytes(StringRef(Str.data(), Str.size() + 1)); 11190b57cec5SDimitry Andric } 11200b57cec5SDimitry Andric endSymbolRecord(AnnotEnd); 11210b57cec5SDimitry Andric } 11220b57cec5SDimitry Andric 11230b57cec5SDimitry Andric for (auto HeapAllocSite : FI.HeapAllocSites) { 1124480093f4SDimitry Andric const MCSymbol *BeginLabel = std::get<0>(HeapAllocSite); 1125480093f4SDimitry Andric const MCSymbol *EndLabel = std::get<1>(HeapAllocSite); 1126c14a5a88SDimitry Andric const DIType *DITy = std::get<2>(HeapAllocSite); 11270b57cec5SDimitry Andric MCSymbol *HeapAllocEnd = beginSymbolRecord(SymbolKind::S_HEAPALLOCSITE); 11280b57cec5SDimitry Andric OS.AddComment("Call site offset"); 11290b57cec5SDimitry Andric OS.EmitCOFFSecRel32(BeginLabel, /*Offset=*/0); 11300b57cec5SDimitry Andric OS.AddComment("Call site section index"); 11310b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(BeginLabel); 11320b57cec5SDimitry Andric OS.AddComment("Call instruction length"); 11330b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 2); 11340b57cec5SDimitry Andric OS.AddComment("Type index"); 11355ffd83dbSDimitry Andric OS.emitInt32(getCompleteTypeIndex(DITy).getIndex()); 11360b57cec5SDimitry Andric endSymbolRecord(HeapAllocEnd); 11370b57cec5SDimitry Andric } 11380b57cec5SDimitry Andric 11390b57cec5SDimitry Andric if (SP != nullptr) 11400b57cec5SDimitry Andric emitDebugInfoForUDTs(LocalUDTs); 11410b57cec5SDimitry Andric 11420b57cec5SDimitry Andric // We're done with this function. 11430b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_PROC_ID_END); 11440b57cec5SDimitry Andric } 11450b57cec5SDimitry Andric endCVSubsection(SymbolsEnd); 11460b57cec5SDimitry Andric 11470b57cec5SDimitry Andric // We have an assembler directive that takes care of the whole line table. 11485ffd83dbSDimitry Andric OS.emitCVLinetableDirective(FI.FuncId, Fn, FI.End); 11490b57cec5SDimitry Andric } 11500b57cec5SDimitry Andric 11510b57cec5SDimitry Andric CodeViewDebug::LocalVarDefRange 11520b57cec5SDimitry Andric CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) { 11530b57cec5SDimitry Andric LocalVarDefRange DR; 11540b57cec5SDimitry Andric DR.InMemory = -1; 11550b57cec5SDimitry Andric DR.DataOffset = Offset; 11560b57cec5SDimitry Andric assert(DR.DataOffset == Offset && "truncation"); 11570b57cec5SDimitry Andric DR.IsSubfield = 0; 11580b57cec5SDimitry Andric DR.StructOffset = 0; 11590b57cec5SDimitry Andric DR.CVRegister = CVRegister; 11600b57cec5SDimitry Andric return DR; 11610b57cec5SDimitry Andric } 11620b57cec5SDimitry Andric 11630b57cec5SDimitry Andric void CodeViewDebug::collectVariableInfoFromMFTable( 11640b57cec5SDimitry Andric DenseSet<InlinedEntity> &Processed) { 11650b57cec5SDimitry Andric const MachineFunction &MF = *Asm->MF; 11660b57cec5SDimitry Andric const TargetSubtargetInfo &TSI = MF.getSubtarget(); 11670b57cec5SDimitry Andric const TargetFrameLowering *TFI = TSI.getFrameLowering(); 11680b57cec5SDimitry Andric const TargetRegisterInfo *TRI = TSI.getRegisterInfo(); 11690b57cec5SDimitry Andric 11700b57cec5SDimitry Andric for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) { 11710b57cec5SDimitry Andric if (!VI.Var) 11720b57cec5SDimitry Andric continue; 11730b57cec5SDimitry Andric assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) && 11740b57cec5SDimitry Andric "Expected inlined-at fields to agree"); 11750b57cec5SDimitry Andric 11760b57cec5SDimitry Andric Processed.insert(InlinedEntity(VI.Var, VI.Loc->getInlinedAt())); 11770b57cec5SDimitry Andric LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc); 11780b57cec5SDimitry Andric 11790b57cec5SDimitry Andric // If variable scope is not found then skip this variable. 11800b57cec5SDimitry Andric if (!Scope) 11810b57cec5SDimitry Andric continue; 11820b57cec5SDimitry Andric 11830b57cec5SDimitry Andric // If the variable has an attached offset expression, extract it. 11840b57cec5SDimitry Andric // FIXME: Try to handle DW_OP_deref as well. 11850b57cec5SDimitry Andric int64_t ExprOffset = 0; 11860b57cec5SDimitry Andric bool Deref = false; 11870b57cec5SDimitry Andric if (VI.Expr) { 11880b57cec5SDimitry Andric // If there is one DW_OP_deref element, use offset of 0 and keep going. 11890b57cec5SDimitry Andric if (VI.Expr->getNumElements() == 1 && 11900b57cec5SDimitry Andric VI.Expr->getElement(0) == llvm::dwarf::DW_OP_deref) 11910b57cec5SDimitry Andric Deref = true; 11920b57cec5SDimitry Andric else if (!VI.Expr->extractIfOffset(ExprOffset)) 11930b57cec5SDimitry Andric continue; 11940b57cec5SDimitry Andric } 11950b57cec5SDimitry Andric 11960b57cec5SDimitry Andric // Get the frame register used and the offset. 11975ffd83dbSDimitry Andric Register FrameReg; 11980b57cec5SDimitry Andric int FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg); 11990b57cec5SDimitry Andric uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg); 12000b57cec5SDimitry Andric 12010b57cec5SDimitry Andric // Calculate the label ranges. 12020b57cec5SDimitry Andric LocalVarDefRange DefRange = 12030b57cec5SDimitry Andric createDefRangeMem(CVReg, FrameOffset + ExprOffset); 12040b57cec5SDimitry Andric 12050b57cec5SDimitry Andric for (const InsnRange &Range : Scope->getRanges()) { 12060b57cec5SDimitry Andric const MCSymbol *Begin = getLabelBeforeInsn(Range.first); 12070b57cec5SDimitry Andric const MCSymbol *End = getLabelAfterInsn(Range.second); 12080b57cec5SDimitry Andric End = End ? End : Asm->getFunctionEnd(); 12090b57cec5SDimitry Andric DefRange.Ranges.emplace_back(Begin, End); 12100b57cec5SDimitry Andric } 12110b57cec5SDimitry Andric 12120b57cec5SDimitry Andric LocalVariable Var; 12130b57cec5SDimitry Andric Var.DIVar = VI.Var; 12140b57cec5SDimitry Andric Var.DefRanges.emplace_back(std::move(DefRange)); 12150b57cec5SDimitry Andric if (Deref) 12160b57cec5SDimitry Andric Var.UseReferenceType = true; 12170b57cec5SDimitry Andric 12180b57cec5SDimitry Andric recordLocalVariable(std::move(Var), Scope); 12190b57cec5SDimitry Andric } 12200b57cec5SDimitry Andric } 12210b57cec5SDimitry Andric 12220b57cec5SDimitry Andric static bool canUseReferenceType(const DbgVariableLocation &Loc) { 12230b57cec5SDimitry Andric return !Loc.LoadChain.empty() && Loc.LoadChain.back() == 0; 12240b57cec5SDimitry Andric } 12250b57cec5SDimitry Andric 12260b57cec5SDimitry Andric static bool needsReferenceType(const DbgVariableLocation &Loc) { 12270b57cec5SDimitry Andric return Loc.LoadChain.size() == 2 && Loc.LoadChain.back() == 0; 12280b57cec5SDimitry Andric } 12290b57cec5SDimitry Andric 12300b57cec5SDimitry Andric void CodeViewDebug::calculateRanges( 12310b57cec5SDimitry Andric LocalVariable &Var, const DbgValueHistoryMap::Entries &Entries) { 12320b57cec5SDimitry Andric const TargetRegisterInfo *TRI = Asm->MF->getSubtarget().getRegisterInfo(); 12330b57cec5SDimitry Andric 12340b57cec5SDimitry Andric // Calculate the definition ranges. 12350b57cec5SDimitry Andric for (auto I = Entries.begin(), E = Entries.end(); I != E; ++I) { 12360b57cec5SDimitry Andric const auto &Entry = *I; 12370b57cec5SDimitry Andric if (!Entry.isDbgValue()) 12380b57cec5SDimitry Andric continue; 12390b57cec5SDimitry Andric const MachineInstr *DVInst = Entry.getInstr(); 12400b57cec5SDimitry Andric assert(DVInst->isDebugValue() && "Invalid History entry"); 12410b57cec5SDimitry Andric // FIXME: Find a way to represent constant variables, since they are 12420b57cec5SDimitry Andric // relatively common. 12430b57cec5SDimitry Andric Optional<DbgVariableLocation> Location = 12440b57cec5SDimitry Andric DbgVariableLocation::extractFromMachineInstruction(*DVInst); 12450b57cec5SDimitry Andric if (!Location) 12460b57cec5SDimitry Andric continue; 12470b57cec5SDimitry Andric 12480b57cec5SDimitry Andric // CodeView can only express variables in register and variables in memory 12490b57cec5SDimitry Andric // at a constant offset from a register. However, for variables passed 12500b57cec5SDimitry Andric // indirectly by pointer, it is common for that pointer to be spilled to a 12510b57cec5SDimitry Andric // stack location. For the special case of one offseted load followed by a 12520b57cec5SDimitry Andric // zero offset load (a pointer spilled to the stack), we change the type of 12530b57cec5SDimitry Andric // the local variable from a value type to a reference type. This tricks the 12540b57cec5SDimitry Andric // debugger into doing the load for us. 12550b57cec5SDimitry Andric if (Var.UseReferenceType) { 12560b57cec5SDimitry Andric // We're using a reference type. Drop the last zero offset load. 12570b57cec5SDimitry Andric if (canUseReferenceType(*Location)) 12580b57cec5SDimitry Andric Location->LoadChain.pop_back(); 12590b57cec5SDimitry Andric else 12600b57cec5SDimitry Andric continue; 12610b57cec5SDimitry Andric } else if (needsReferenceType(*Location)) { 12620b57cec5SDimitry Andric // This location can't be expressed without switching to a reference type. 12630b57cec5SDimitry Andric // Start over using that. 12640b57cec5SDimitry Andric Var.UseReferenceType = true; 12650b57cec5SDimitry Andric Var.DefRanges.clear(); 12660b57cec5SDimitry Andric calculateRanges(Var, Entries); 12670b57cec5SDimitry Andric return; 12680b57cec5SDimitry Andric } 12690b57cec5SDimitry Andric 12700b57cec5SDimitry Andric // We can only handle a register or an offseted load of a register. 12710b57cec5SDimitry Andric if (Location->Register == 0 || Location->LoadChain.size() > 1) 12720b57cec5SDimitry Andric continue; 12730b57cec5SDimitry Andric { 12740b57cec5SDimitry Andric LocalVarDefRange DR; 12750b57cec5SDimitry Andric DR.CVRegister = TRI->getCodeViewRegNum(Location->Register); 12760b57cec5SDimitry Andric DR.InMemory = !Location->LoadChain.empty(); 12770b57cec5SDimitry Andric DR.DataOffset = 12780b57cec5SDimitry Andric !Location->LoadChain.empty() ? Location->LoadChain.back() : 0; 12790b57cec5SDimitry Andric if (Location->FragmentInfo) { 12800b57cec5SDimitry Andric DR.IsSubfield = true; 12810b57cec5SDimitry Andric DR.StructOffset = Location->FragmentInfo->OffsetInBits / 8; 12820b57cec5SDimitry Andric } else { 12830b57cec5SDimitry Andric DR.IsSubfield = false; 12840b57cec5SDimitry Andric DR.StructOffset = 0; 12850b57cec5SDimitry Andric } 12860b57cec5SDimitry Andric 12870b57cec5SDimitry Andric if (Var.DefRanges.empty() || 12880b57cec5SDimitry Andric Var.DefRanges.back().isDifferentLocation(DR)) { 12890b57cec5SDimitry Andric Var.DefRanges.emplace_back(std::move(DR)); 12900b57cec5SDimitry Andric } 12910b57cec5SDimitry Andric } 12920b57cec5SDimitry Andric 12930b57cec5SDimitry Andric // Compute the label range. 12940b57cec5SDimitry Andric const MCSymbol *Begin = getLabelBeforeInsn(Entry.getInstr()); 12950b57cec5SDimitry Andric const MCSymbol *End; 12960b57cec5SDimitry Andric if (Entry.getEndIndex() != DbgValueHistoryMap::NoEntry) { 12970b57cec5SDimitry Andric auto &EndingEntry = Entries[Entry.getEndIndex()]; 12980b57cec5SDimitry Andric End = EndingEntry.isDbgValue() 12990b57cec5SDimitry Andric ? getLabelBeforeInsn(EndingEntry.getInstr()) 13000b57cec5SDimitry Andric : getLabelAfterInsn(EndingEntry.getInstr()); 13010b57cec5SDimitry Andric } else 13020b57cec5SDimitry Andric End = Asm->getFunctionEnd(); 13030b57cec5SDimitry Andric 13040b57cec5SDimitry Andric // If the last range end is our begin, just extend the last range. 13050b57cec5SDimitry Andric // Otherwise make a new range. 13060b57cec5SDimitry Andric SmallVectorImpl<std::pair<const MCSymbol *, const MCSymbol *>> &R = 13070b57cec5SDimitry Andric Var.DefRanges.back().Ranges; 13080b57cec5SDimitry Andric if (!R.empty() && R.back().second == Begin) 13090b57cec5SDimitry Andric R.back().second = End; 13100b57cec5SDimitry Andric else 13110b57cec5SDimitry Andric R.emplace_back(Begin, End); 13120b57cec5SDimitry Andric 13130b57cec5SDimitry Andric // FIXME: Do more range combining. 13140b57cec5SDimitry Andric } 13150b57cec5SDimitry Andric } 13160b57cec5SDimitry Andric 13170b57cec5SDimitry Andric void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) { 13180b57cec5SDimitry Andric DenseSet<InlinedEntity> Processed; 13190b57cec5SDimitry Andric // Grab the variable info that was squirreled away in the MMI side-table. 13200b57cec5SDimitry Andric collectVariableInfoFromMFTable(Processed); 13210b57cec5SDimitry Andric 13220b57cec5SDimitry Andric for (const auto &I : DbgValues) { 13230b57cec5SDimitry Andric InlinedEntity IV = I.first; 13240b57cec5SDimitry Andric if (Processed.count(IV)) 13250b57cec5SDimitry Andric continue; 13260b57cec5SDimitry Andric const DILocalVariable *DIVar = cast<DILocalVariable>(IV.first); 13270b57cec5SDimitry Andric const DILocation *InlinedAt = IV.second; 13280b57cec5SDimitry Andric 13290b57cec5SDimitry Andric // Instruction ranges, specifying where IV is accessible. 13300b57cec5SDimitry Andric const auto &Entries = I.second; 13310b57cec5SDimitry Andric 13320b57cec5SDimitry Andric LexicalScope *Scope = nullptr; 13330b57cec5SDimitry Andric if (InlinedAt) 13340b57cec5SDimitry Andric Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt); 13350b57cec5SDimitry Andric else 13360b57cec5SDimitry Andric Scope = LScopes.findLexicalScope(DIVar->getScope()); 13370b57cec5SDimitry Andric // If variable scope is not found then skip this variable. 13380b57cec5SDimitry Andric if (!Scope) 13390b57cec5SDimitry Andric continue; 13400b57cec5SDimitry Andric 13410b57cec5SDimitry Andric LocalVariable Var; 13420b57cec5SDimitry Andric Var.DIVar = DIVar; 13430b57cec5SDimitry Andric 13440b57cec5SDimitry Andric calculateRanges(Var, Entries); 13450b57cec5SDimitry Andric recordLocalVariable(std::move(Var), Scope); 13460b57cec5SDimitry Andric } 13470b57cec5SDimitry Andric } 13480b57cec5SDimitry Andric 13490b57cec5SDimitry Andric void CodeViewDebug::beginFunctionImpl(const MachineFunction *MF) { 13500b57cec5SDimitry Andric const TargetSubtargetInfo &TSI = MF->getSubtarget(); 13510b57cec5SDimitry Andric const TargetRegisterInfo *TRI = TSI.getRegisterInfo(); 13520b57cec5SDimitry Andric const MachineFrameInfo &MFI = MF->getFrameInfo(); 13530b57cec5SDimitry Andric const Function &GV = MF->getFunction(); 13548bcb0991SDimitry Andric auto Insertion = FnDebugInfo.insert({&GV, std::make_unique<FunctionInfo>()}); 13550b57cec5SDimitry Andric assert(Insertion.second && "function already has info"); 13560b57cec5SDimitry Andric CurFn = Insertion.first->second.get(); 13570b57cec5SDimitry Andric CurFn->FuncId = NextFuncId++; 13580b57cec5SDimitry Andric CurFn->Begin = Asm->getFunctionBegin(); 13590b57cec5SDimitry Andric 13600b57cec5SDimitry Andric // The S_FRAMEPROC record reports the stack size, and how many bytes of 13610b57cec5SDimitry Andric // callee-saved registers were used. For targets that don't use a PUSH 13620b57cec5SDimitry Andric // instruction (AArch64), this will be zero. 13630b57cec5SDimitry Andric CurFn->CSRSize = MFI.getCVBytesOfCalleeSavedRegisters(); 13640b57cec5SDimitry Andric CurFn->FrameSize = MFI.getStackSize(); 13650b57cec5SDimitry Andric CurFn->OffsetAdjustment = MFI.getOffsetAdjustment(); 13660b57cec5SDimitry Andric CurFn->HasStackRealignment = TRI->needsStackRealignment(*MF); 13670b57cec5SDimitry Andric 13680b57cec5SDimitry Andric // For this function S_FRAMEPROC record, figure out which codeview register 13690b57cec5SDimitry Andric // will be the frame pointer. 13700b57cec5SDimitry Andric CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::None; // None. 13710b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::None; // None. 13720b57cec5SDimitry Andric if (CurFn->FrameSize > 0) { 13730b57cec5SDimitry Andric if (!TSI.getFrameLowering()->hasFP(*MF)) { 13740b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr; 13750b57cec5SDimitry Andric CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::StackPtr; 13760b57cec5SDimitry Andric } else { 13770b57cec5SDimitry Andric // If there is an FP, parameters are always relative to it. 13780b57cec5SDimitry Andric CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::FramePtr; 13790b57cec5SDimitry Andric if (CurFn->HasStackRealignment) { 13800b57cec5SDimitry Andric // If the stack needs realignment, locals are relative to SP or VFRAME. 13810b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr; 13820b57cec5SDimitry Andric } else { 13830b57cec5SDimitry Andric // Otherwise, locals are relative to EBP, and we probably have VLAs or 13840b57cec5SDimitry Andric // other stack adjustments. 13850b57cec5SDimitry Andric CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::FramePtr; 13860b57cec5SDimitry Andric } 13870b57cec5SDimitry Andric } 13880b57cec5SDimitry Andric } 13890b57cec5SDimitry Andric 13900b57cec5SDimitry Andric // Compute other frame procedure options. 13910b57cec5SDimitry Andric FrameProcedureOptions FPO = FrameProcedureOptions::None; 13920b57cec5SDimitry Andric if (MFI.hasVarSizedObjects()) 13930b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasAlloca; 13940b57cec5SDimitry Andric if (MF->exposesReturnsTwice()) 13950b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasSetJmp; 13960b57cec5SDimitry Andric // FIXME: Set HasLongJmp if we ever track that info. 13970b57cec5SDimitry Andric if (MF->hasInlineAsm()) 13980b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasInlineAssembly; 13990b57cec5SDimitry Andric if (GV.hasPersonalityFn()) { 14000b57cec5SDimitry Andric if (isAsynchronousEHPersonality( 14010b57cec5SDimitry Andric classifyEHPersonality(GV.getPersonalityFn()))) 14020b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasStructuredExceptionHandling; 14030b57cec5SDimitry Andric else 14040b57cec5SDimitry Andric FPO |= FrameProcedureOptions::HasExceptionHandling; 14050b57cec5SDimitry Andric } 14060b57cec5SDimitry Andric if (GV.hasFnAttribute(Attribute::InlineHint)) 14070b57cec5SDimitry Andric FPO |= FrameProcedureOptions::MarkedInline; 14080b57cec5SDimitry Andric if (GV.hasFnAttribute(Attribute::Naked)) 14090b57cec5SDimitry Andric FPO |= FrameProcedureOptions::Naked; 14100b57cec5SDimitry Andric if (MFI.hasStackProtectorIndex()) 14110b57cec5SDimitry Andric FPO |= FrameProcedureOptions::SecurityChecks; 14120b57cec5SDimitry Andric FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedLocalFramePtrReg) << 14U); 14130b57cec5SDimitry Andric FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedParamFramePtrReg) << 16U); 14140b57cec5SDimitry Andric if (Asm->TM.getOptLevel() != CodeGenOpt::None && 14150b57cec5SDimitry Andric !GV.hasOptSize() && !GV.hasOptNone()) 14160b57cec5SDimitry Andric FPO |= FrameProcedureOptions::OptimizedForSpeed; 14170b57cec5SDimitry Andric // FIXME: Set GuardCfg when it is implemented. 14180b57cec5SDimitry Andric CurFn->FrameProcOpts = FPO; 14190b57cec5SDimitry Andric 14200b57cec5SDimitry Andric OS.EmitCVFuncIdDirective(CurFn->FuncId); 14210b57cec5SDimitry Andric 14220b57cec5SDimitry Andric // Find the end of the function prolog. First known non-DBG_VALUE and 14230b57cec5SDimitry Andric // non-frame setup location marks the beginning of the function body. 14240b57cec5SDimitry Andric // FIXME: is there a simpler a way to do this? Can we just search 14250b57cec5SDimitry Andric // for the first instruction of the function, not the last of the prolog? 14260b57cec5SDimitry Andric DebugLoc PrologEndLoc; 14270b57cec5SDimitry Andric bool EmptyPrologue = true; 14280b57cec5SDimitry Andric for (const auto &MBB : *MF) { 14290b57cec5SDimitry Andric for (const auto &MI : MBB) { 14300b57cec5SDimitry Andric if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) && 14310b57cec5SDimitry Andric MI.getDebugLoc()) { 14320b57cec5SDimitry Andric PrologEndLoc = MI.getDebugLoc(); 14330b57cec5SDimitry Andric break; 14340b57cec5SDimitry Andric } else if (!MI.isMetaInstruction()) { 14350b57cec5SDimitry Andric EmptyPrologue = false; 14360b57cec5SDimitry Andric } 14370b57cec5SDimitry Andric } 14380b57cec5SDimitry Andric } 14390b57cec5SDimitry Andric 14400b57cec5SDimitry Andric // Record beginning of function if we have a non-empty prologue. 14410b57cec5SDimitry Andric if (PrologEndLoc && !EmptyPrologue) { 14420b57cec5SDimitry Andric DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc(); 14430b57cec5SDimitry Andric maybeRecordLocation(FnStartDL, MF); 14440b57cec5SDimitry Andric } 1445480093f4SDimitry Andric 1446480093f4SDimitry Andric // Find heap alloc sites and emit labels around them. 1447480093f4SDimitry Andric for (const auto &MBB : *MF) { 1448480093f4SDimitry Andric for (const auto &MI : MBB) { 1449480093f4SDimitry Andric if (MI.getHeapAllocMarker()) { 1450480093f4SDimitry Andric requestLabelBeforeInsn(&MI); 1451480093f4SDimitry Andric requestLabelAfterInsn(&MI); 1452480093f4SDimitry Andric } 1453480093f4SDimitry Andric } 1454480093f4SDimitry Andric } 14550b57cec5SDimitry Andric } 14560b57cec5SDimitry Andric 14570b57cec5SDimitry Andric static bool shouldEmitUdt(const DIType *T) { 14580b57cec5SDimitry Andric if (!T) 14590b57cec5SDimitry Andric return false; 14600b57cec5SDimitry Andric 14610b57cec5SDimitry Andric // MSVC does not emit UDTs for typedefs that are scoped to classes. 14620b57cec5SDimitry Andric if (T->getTag() == dwarf::DW_TAG_typedef) { 14630b57cec5SDimitry Andric if (DIScope *Scope = T->getScope()) { 14640b57cec5SDimitry Andric switch (Scope->getTag()) { 14650b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 14660b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 14670b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 14680b57cec5SDimitry Andric return false; 14690b57cec5SDimitry Andric } 14700b57cec5SDimitry Andric } 14710b57cec5SDimitry Andric } 14720b57cec5SDimitry Andric 14730b57cec5SDimitry Andric while (true) { 14740b57cec5SDimitry Andric if (!T || T->isForwardDecl()) 14750b57cec5SDimitry Andric return false; 14760b57cec5SDimitry Andric 14770b57cec5SDimitry Andric const DIDerivedType *DT = dyn_cast<DIDerivedType>(T); 14780b57cec5SDimitry Andric if (!DT) 14790b57cec5SDimitry Andric return true; 14800b57cec5SDimitry Andric T = DT->getBaseType(); 14810b57cec5SDimitry Andric } 14820b57cec5SDimitry Andric return true; 14830b57cec5SDimitry Andric } 14840b57cec5SDimitry Andric 14850b57cec5SDimitry Andric void CodeViewDebug::addToUDTs(const DIType *Ty) { 14860b57cec5SDimitry Andric // Don't record empty UDTs. 14870b57cec5SDimitry Andric if (Ty->getName().empty()) 14880b57cec5SDimitry Andric return; 14890b57cec5SDimitry Andric if (!shouldEmitUdt(Ty)) 14900b57cec5SDimitry Andric return; 14910b57cec5SDimitry Andric 14925ffd83dbSDimitry Andric SmallVector<StringRef, 5> ParentScopeNames; 14930b57cec5SDimitry Andric const DISubprogram *ClosestSubprogram = 14945ffd83dbSDimitry Andric collectParentScopeNames(Ty->getScope(), ParentScopeNames); 14950b57cec5SDimitry Andric 14960b57cec5SDimitry Andric std::string FullyQualifiedName = 14975ffd83dbSDimitry Andric formatNestedName(ParentScopeNames, getPrettyScopeName(Ty)); 14980b57cec5SDimitry Andric 14990b57cec5SDimitry Andric if (ClosestSubprogram == nullptr) { 15000b57cec5SDimitry Andric GlobalUDTs.emplace_back(std::move(FullyQualifiedName), Ty); 15010b57cec5SDimitry Andric } else if (ClosestSubprogram == CurrentSubprogram) { 15020b57cec5SDimitry Andric LocalUDTs.emplace_back(std::move(FullyQualifiedName), Ty); 15030b57cec5SDimitry Andric } 15040b57cec5SDimitry Andric 15050b57cec5SDimitry Andric // TODO: What if the ClosestSubprogram is neither null or the current 15060b57cec5SDimitry Andric // subprogram? Currently, the UDT just gets dropped on the floor. 15070b57cec5SDimitry Andric // 15080b57cec5SDimitry Andric // The current behavior is not desirable. To get maximal fidelity, we would 15090b57cec5SDimitry Andric // need to perform all type translation before beginning emission of .debug$S 15100b57cec5SDimitry Andric // and then make LocalUDTs a member of FunctionInfo 15110b57cec5SDimitry Andric } 15120b57cec5SDimitry Andric 15130b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) { 15140b57cec5SDimitry Andric // Generic dispatch for lowering an unknown type. 15150b57cec5SDimitry Andric switch (Ty->getTag()) { 15160b57cec5SDimitry Andric case dwarf::DW_TAG_array_type: 15170b57cec5SDimitry Andric return lowerTypeArray(cast<DICompositeType>(Ty)); 15180b57cec5SDimitry Andric case dwarf::DW_TAG_typedef: 15190b57cec5SDimitry Andric return lowerTypeAlias(cast<DIDerivedType>(Ty)); 15200b57cec5SDimitry Andric case dwarf::DW_TAG_base_type: 15210b57cec5SDimitry Andric return lowerTypeBasic(cast<DIBasicType>(Ty)); 15220b57cec5SDimitry Andric case dwarf::DW_TAG_pointer_type: 15230b57cec5SDimitry Andric if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type") 15240b57cec5SDimitry Andric return lowerTypeVFTableShape(cast<DIDerivedType>(Ty)); 15250b57cec5SDimitry Andric LLVM_FALLTHROUGH; 15260b57cec5SDimitry Andric case dwarf::DW_TAG_reference_type: 15270b57cec5SDimitry Andric case dwarf::DW_TAG_rvalue_reference_type: 15280b57cec5SDimitry Andric return lowerTypePointer(cast<DIDerivedType>(Ty)); 15290b57cec5SDimitry Andric case dwarf::DW_TAG_ptr_to_member_type: 15300b57cec5SDimitry Andric return lowerTypeMemberPointer(cast<DIDerivedType>(Ty)); 15310b57cec5SDimitry Andric case dwarf::DW_TAG_restrict_type: 15320b57cec5SDimitry Andric case dwarf::DW_TAG_const_type: 15330b57cec5SDimitry Andric case dwarf::DW_TAG_volatile_type: 15340b57cec5SDimitry Andric // TODO: add support for DW_TAG_atomic_type here 15350b57cec5SDimitry Andric return lowerTypeModifier(cast<DIDerivedType>(Ty)); 15360b57cec5SDimitry Andric case dwarf::DW_TAG_subroutine_type: 15370b57cec5SDimitry Andric if (ClassTy) { 15380b57cec5SDimitry Andric // The member function type of a member function pointer has no 15390b57cec5SDimitry Andric // ThisAdjustment. 15400b57cec5SDimitry Andric return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy, 15410b57cec5SDimitry Andric /*ThisAdjustment=*/0, 15420b57cec5SDimitry Andric /*IsStaticMethod=*/false); 15430b57cec5SDimitry Andric } 15440b57cec5SDimitry Andric return lowerTypeFunction(cast<DISubroutineType>(Ty)); 15450b57cec5SDimitry Andric case dwarf::DW_TAG_enumeration_type: 15460b57cec5SDimitry Andric return lowerTypeEnum(cast<DICompositeType>(Ty)); 15470b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 15480b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 15490b57cec5SDimitry Andric return lowerTypeClass(cast<DICompositeType>(Ty)); 15500b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 15510b57cec5SDimitry Andric return lowerTypeUnion(cast<DICompositeType>(Ty)); 15520b57cec5SDimitry Andric case dwarf::DW_TAG_unspecified_type: 15530b57cec5SDimitry Andric if (Ty->getName() == "decltype(nullptr)") 15540b57cec5SDimitry Andric return TypeIndex::NullptrT(); 15550b57cec5SDimitry Andric return TypeIndex::None(); 15560b57cec5SDimitry Andric default: 15570b57cec5SDimitry Andric // Use the null type index. 15580b57cec5SDimitry Andric return TypeIndex(); 15590b57cec5SDimitry Andric } 15600b57cec5SDimitry Andric } 15610b57cec5SDimitry Andric 15620b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) { 15630b57cec5SDimitry Andric TypeIndex UnderlyingTypeIndex = getTypeIndex(Ty->getBaseType()); 15640b57cec5SDimitry Andric StringRef TypeName = Ty->getName(); 15650b57cec5SDimitry Andric 15660b57cec5SDimitry Andric addToUDTs(Ty); 15670b57cec5SDimitry Andric 15680b57cec5SDimitry Andric if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::Int32Long) && 15690b57cec5SDimitry Andric TypeName == "HRESULT") 15700b57cec5SDimitry Andric return TypeIndex(SimpleTypeKind::HResult); 15710b57cec5SDimitry Andric if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::UInt16Short) && 15720b57cec5SDimitry Andric TypeName == "wchar_t") 15730b57cec5SDimitry Andric return TypeIndex(SimpleTypeKind::WideCharacter); 15740b57cec5SDimitry Andric 15750b57cec5SDimitry Andric return UnderlyingTypeIndex; 15760b57cec5SDimitry Andric } 15770b57cec5SDimitry Andric 15780b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) { 15790b57cec5SDimitry Andric const DIType *ElementType = Ty->getBaseType(); 15800b57cec5SDimitry Andric TypeIndex ElementTypeIndex = getTypeIndex(ElementType); 15810b57cec5SDimitry Andric // IndexType is size_t, which depends on the bitness of the target. 15820b57cec5SDimitry Andric TypeIndex IndexType = getPointerSizeInBytes() == 8 15830b57cec5SDimitry Andric ? TypeIndex(SimpleTypeKind::UInt64Quad) 15840b57cec5SDimitry Andric : TypeIndex(SimpleTypeKind::UInt32Long); 15850b57cec5SDimitry Andric 15860b57cec5SDimitry Andric uint64_t ElementSize = getBaseTypeSize(ElementType) / 8; 15870b57cec5SDimitry Andric 15880b57cec5SDimitry Andric // Add subranges to array type. 15890b57cec5SDimitry Andric DINodeArray Elements = Ty->getElements(); 15900b57cec5SDimitry Andric for (int i = Elements.size() - 1; i >= 0; --i) { 15910b57cec5SDimitry Andric const DINode *Element = Elements[i]; 15920b57cec5SDimitry Andric assert(Element->getTag() == dwarf::DW_TAG_subrange_type); 15930b57cec5SDimitry Andric 15940b57cec5SDimitry Andric const DISubrange *Subrange = cast<DISubrange>(Element); 15955ffd83dbSDimitry Andric assert(!Subrange->getRawLowerBound() && 15960b57cec5SDimitry Andric "codeview doesn't support subranges with lower bounds"); 15970b57cec5SDimitry Andric int64_t Count = -1; 15980b57cec5SDimitry Andric if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt*>()) 15990b57cec5SDimitry Andric Count = CI->getSExtValue(); 16000b57cec5SDimitry Andric 16010b57cec5SDimitry Andric // Forward declarations of arrays without a size and VLAs use a count of -1. 16020b57cec5SDimitry Andric // Emit a count of zero in these cases to match what MSVC does for arrays 16030b57cec5SDimitry Andric // without a size. MSVC doesn't support VLAs, so it's not clear what we 16040b57cec5SDimitry Andric // should do for them even if we could distinguish them. 16050b57cec5SDimitry Andric if (Count == -1) 16060b57cec5SDimitry Andric Count = 0; 16070b57cec5SDimitry Andric 16080b57cec5SDimitry Andric // Update the element size and element type index for subsequent subranges. 16090b57cec5SDimitry Andric ElementSize *= Count; 16100b57cec5SDimitry Andric 16110b57cec5SDimitry Andric // If this is the outermost array, use the size from the array. It will be 16120b57cec5SDimitry Andric // more accurate if we had a VLA or an incomplete element type size. 16130b57cec5SDimitry Andric uint64_t ArraySize = 16140b57cec5SDimitry Andric (i == 0 && ElementSize == 0) ? Ty->getSizeInBits() / 8 : ElementSize; 16150b57cec5SDimitry Andric 16160b57cec5SDimitry Andric StringRef Name = (i == 0) ? Ty->getName() : ""; 16170b57cec5SDimitry Andric ArrayRecord AR(ElementTypeIndex, IndexType, ArraySize, Name); 16180b57cec5SDimitry Andric ElementTypeIndex = TypeTable.writeLeafType(AR); 16190b57cec5SDimitry Andric } 16200b57cec5SDimitry Andric 16210b57cec5SDimitry Andric return ElementTypeIndex; 16220b57cec5SDimitry Andric } 16230b57cec5SDimitry Andric 16240b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) { 16250b57cec5SDimitry Andric TypeIndex Index; 16260b57cec5SDimitry Andric dwarf::TypeKind Kind; 16270b57cec5SDimitry Andric uint32_t ByteSize; 16280b57cec5SDimitry Andric 16290b57cec5SDimitry Andric Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding()); 16300b57cec5SDimitry Andric ByteSize = Ty->getSizeInBits() / 8; 16310b57cec5SDimitry Andric 16320b57cec5SDimitry Andric SimpleTypeKind STK = SimpleTypeKind::None; 16330b57cec5SDimitry Andric switch (Kind) { 16340b57cec5SDimitry Andric case dwarf::DW_ATE_address: 16350b57cec5SDimitry Andric // FIXME: Translate 16360b57cec5SDimitry Andric break; 16370b57cec5SDimitry Andric case dwarf::DW_ATE_boolean: 16380b57cec5SDimitry Andric switch (ByteSize) { 16390b57cec5SDimitry Andric case 1: STK = SimpleTypeKind::Boolean8; break; 16400b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Boolean16; break; 16410b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Boolean32; break; 16420b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Boolean64; break; 16430b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Boolean128; break; 16440b57cec5SDimitry Andric } 16450b57cec5SDimitry Andric break; 16460b57cec5SDimitry Andric case dwarf::DW_ATE_complex_float: 16470b57cec5SDimitry Andric switch (ByteSize) { 16480b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Complex16; break; 16490b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Complex32; break; 16500b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Complex64; break; 16510b57cec5SDimitry Andric case 10: STK = SimpleTypeKind::Complex80; break; 16520b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Complex128; break; 16530b57cec5SDimitry Andric } 16540b57cec5SDimitry Andric break; 16550b57cec5SDimitry Andric case dwarf::DW_ATE_float: 16560b57cec5SDimitry Andric switch (ByteSize) { 16570b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Float16; break; 16580b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Float32; break; 16590b57cec5SDimitry Andric case 6: STK = SimpleTypeKind::Float48; break; 16600b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Float64; break; 16610b57cec5SDimitry Andric case 10: STK = SimpleTypeKind::Float80; break; 16620b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Float128; break; 16630b57cec5SDimitry Andric } 16640b57cec5SDimitry Andric break; 16650b57cec5SDimitry Andric case dwarf::DW_ATE_signed: 16660b57cec5SDimitry Andric switch (ByteSize) { 16670b57cec5SDimitry Andric case 1: STK = SimpleTypeKind::SignedCharacter; break; 16680b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Int16Short; break; 16690b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Int32; break; 16700b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::Int64Quad; break; 16710b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::Int128Oct; break; 16720b57cec5SDimitry Andric } 16730b57cec5SDimitry Andric break; 16740b57cec5SDimitry Andric case dwarf::DW_ATE_unsigned: 16750b57cec5SDimitry Andric switch (ByteSize) { 16760b57cec5SDimitry Andric case 1: STK = SimpleTypeKind::UnsignedCharacter; break; 16770b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::UInt16Short; break; 16780b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::UInt32; break; 16790b57cec5SDimitry Andric case 8: STK = SimpleTypeKind::UInt64Quad; break; 16800b57cec5SDimitry Andric case 16: STK = SimpleTypeKind::UInt128Oct; break; 16810b57cec5SDimitry Andric } 16820b57cec5SDimitry Andric break; 16830b57cec5SDimitry Andric case dwarf::DW_ATE_UTF: 16840b57cec5SDimitry Andric switch (ByteSize) { 16850b57cec5SDimitry Andric case 2: STK = SimpleTypeKind::Character16; break; 16860b57cec5SDimitry Andric case 4: STK = SimpleTypeKind::Character32; break; 16870b57cec5SDimitry Andric } 16880b57cec5SDimitry Andric break; 16890b57cec5SDimitry Andric case dwarf::DW_ATE_signed_char: 16900b57cec5SDimitry Andric if (ByteSize == 1) 16910b57cec5SDimitry Andric STK = SimpleTypeKind::SignedCharacter; 16920b57cec5SDimitry Andric break; 16930b57cec5SDimitry Andric case dwarf::DW_ATE_unsigned_char: 16940b57cec5SDimitry Andric if (ByteSize == 1) 16950b57cec5SDimitry Andric STK = SimpleTypeKind::UnsignedCharacter; 16960b57cec5SDimitry Andric break; 16970b57cec5SDimitry Andric default: 16980b57cec5SDimitry Andric break; 16990b57cec5SDimitry Andric } 17000b57cec5SDimitry Andric 17010b57cec5SDimitry Andric // Apply some fixups based on the source-level type name. 17020b57cec5SDimitry Andric if (STK == SimpleTypeKind::Int32 && Ty->getName() == "long int") 17030b57cec5SDimitry Andric STK = SimpleTypeKind::Int32Long; 17040b57cec5SDimitry Andric if (STK == SimpleTypeKind::UInt32 && Ty->getName() == "long unsigned int") 17050b57cec5SDimitry Andric STK = SimpleTypeKind::UInt32Long; 17060b57cec5SDimitry Andric if (STK == SimpleTypeKind::UInt16Short && 17070b57cec5SDimitry Andric (Ty->getName() == "wchar_t" || Ty->getName() == "__wchar_t")) 17080b57cec5SDimitry Andric STK = SimpleTypeKind::WideCharacter; 17090b57cec5SDimitry Andric if ((STK == SimpleTypeKind::SignedCharacter || 17100b57cec5SDimitry Andric STK == SimpleTypeKind::UnsignedCharacter) && 17110b57cec5SDimitry Andric Ty->getName() == "char") 17120b57cec5SDimitry Andric STK = SimpleTypeKind::NarrowCharacter; 17130b57cec5SDimitry Andric 17140b57cec5SDimitry Andric return TypeIndex(STK); 17150b57cec5SDimitry Andric } 17160b57cec5SDimitry Andric 17170b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty, 17180b57cec5SDimitry Andric PointerOptions PO) { 17190b57cec5SDimitry Andric TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType()); 17200b57cec5SDimitry Andric 17210b57cec5SDimitry Andric // Pointers to simple types without any options can use SimpleTypeMode, rather 17220b57cec5SDimitry Andric // than having a dedicated pointer type record. 17230b57cec5SDimitry Andric if (PointeeTI.isSimple() && PO == PointerOptions::None && 17240b57cec5SDimitry Andric PointeeTI.getSimpleMode() == SimpleTypeMode::Direct && 17250b57cec5SDimitry Andric Ty->getTag() == dwarf::DW_TAG_pointer_type) { 17260b57cec5SDimitry Andric SimpleTypeMode Mode = Ty->getSizeInBits() == 64 17270b57cec5SDimitry Andric ? SimpleTypeMode::NearPointer64 17280b57cec5SDimitry Andric : SimpleTypeMode::NearPointer32; 17290b57cec5SDimitry Andric return TypeIndex(PointeeTI.getSimpleKind(), Mode); 17300b57cec5SDimitry Andric } 17310b57cec5SDimitry Andric 17320b57cec5SDimitry Andric PointerKind PK = 17330b57cec5SDimitry Andric Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32; 17340b57cec5SDimitry Andric PointerMode PM = PointerMode::Pointer; 17350b57cec5SDimitry Andric switch (Ty->getTag()) { 17360b57cec5SDimitry Andric default: llvm_unreachable("not a pointer tag type"); 17370b57cec5SDimitry Andric case dwarf::DW_TAG_pointer_type: 17380b57cec5SDimitry Andric PM = PointerMode::Pointer; 17390b57cec5SDimitry Andric break; 17400b57cec5SDimitry Andric case dwarf::DW_TAG_reference_type: 17410b57cec5SDimitry Andric PM = PointerMode::LValueReference; 17420b57cec5SDimitry Andric break; 17430b57cec5SDimitry Andric case dwarf::DW_TAG_rvalue_reference_type: 17440b57cec5SDimitry Andric PM = PointerMode::RValueReference; 17450b57cec5SDimitry Andric break; 17460b57cec5SDimitry Andric } 17470b57cec5SDimitry Andric 17480b57cec5SDimitry Andric if (Ty->isObjectPointer()) 17490b57cec5SDimitry Andric PO |= PointerOptions::Const; 17500b57cec5SDimitry Andric 17510b57cec5SDimitry Andric PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8); 17520b57cec5SDimitry Andric return TypeTable.writeLeafType(PR); 17530b57cec5SDimitry Andric } 17540b57cec5SDimitry Andric 17550b57cec5SDimitry Andric static PointerToMemberRepresentation 17560b57cec5SDimitry Andric translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) { 17570b57cec5SDimitry Andric // SizeInBytes being zero generally implies that the member pointer type was 17580b57cec5SDimitry Andric // incomplete, which can happen if it is part of a function prototype. In this 17590b57cec5SDimitry Andric // case, use the unknown model instead of the general model. 17600b57cec5SDimitry Andric if (IsPMF) { 17610b57cec5SDimitry Andric switch (Flags & DINode::FlagPtrToMemberRep) { 17620b57cec5SDimitry Andric case 0: 17630b57cec5SDimitry Andric return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown 17640b57cec5SDimitry Andric : PointerToMemberRepresentation::GeneralFunction; 17650b57cec5SDimitry Andric case DINode::FlagSingleInheritance: 17660b57cec5SDimitry Andric return PointerToMemberRepresentation::SingleInheritanceFunction; 17670b57cec5SDimitry Andric case DINode::FlagMultipleInheritance: 17680b57cec5SDimitry Andric return PointerToMemberRepresentation::MultipleInheritanceFunction; 17690b57cec5SDimitry Andric case DINode::FlagVirtualInheritance: 17700b57cec5SDimitry Andric return PointerToMemberRepresentation::VirtualInheritanceFunction; 17710b57cec5SDimitry Andric } 17720b57cec5SDimitry Andric } else { 17730b57cec5SDimitry Andric switch (Flags & DINode::FlagPtrToMemberRep) { 17740b57cec5SDimitry Andric case 0: 17750b57cec5SDimitry Andric return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown 17760b57cec5SDimitry Andric : PointerToMemberRepresentation::GeneralData; 17770b57cec5SDimitry Andric case DINode::FlagSingleInheritance: 17780b57cec5SDimitry Andric return PointerToMemberRepresentation::SingleInheritanceData; 17790b57cec5SDimitry Andric case DINode::FlagMultipleInheritance: 17800b57cec5SDimitry Andric return PointerToMemberRepresentation::MultipleInheritanceData; 17810b57cec5SDimitry Andric case DINode::FlagVirtualInheritance: 17820b57cec5SDimitry Andric return PointerToMemberRepresentation::VirtualInheritanceData; 17830b57cec5SDimitry Andric } 17840b57cec5SDimitry Andric } 17850b57cec5SDimitry Andric llvm_unreachable("invalid ptr to member representation"); 17860b57cec5SDimitry Andric } 17870b57cec5SDimitry Andric 17880b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty, 17890b57cec5SDimitry Andric PointerOptions PO) { 17900b57cec5SDimitry Andric assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type); 17915ffd83dbSDimitry Andric bool IsPMF = isa<DISubroutineType>(Ty->getBaseType()); 17920b57cec5SDimitry Andric TypeIndex ClassTI = getTypeIndex(Ty->getClassType()); 17935ffd83dbSDimitry Andric TypeIndex PointeeTI = 17945ffd83dbSDimitry Andric getTypeIndex(Ty->getBaseType(), IsPMF ? Ty->getClassType() : nullptr); 17950b57cec5SDimitry Andric PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64 17960b57cec5SDimitry Andric : PointerKind::Near32; 17970b57cec5SDimitry Andric PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction 17980b57cec5SDimitry Andric : PointerMode::PointerToDataMember; 17990b57cec5SDimitry Andric 18000b57cec5SDimitry Andric assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big"); 18010b57cec5SDimitry Andric uint8_t SizeInBytes = Ty->getSizeInBits() / 8; 18020b57cec5SDimitry Andric MemberPointerInfo MPI( 18030b57cec5SDimitry Andric ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags())); 18040b57cec5SDimitry Andric PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI); 18050b57cec5SDimitry Andric return TypeTable.writeLeafType(PR); 18060b57cec5SDimitry Andric } 18070b57cec5SDimitry Andric 18080b57cec5SDimitry Andric /// Given a DWARF calling convention, get the CodeView equivalent. If we don't 18090b57cec5SDimitry Andric /// have a translation, use the NearC convention. 18100b57cec5SDimitry Andric static CallingConvention dwarfCCToCodeView(unsigned DwarfCC) { 18110b57cec5SDimitry Andric switch (DwarfCC) { 18120b57cec5SDimitry Andric case dwarf::DW_CC_normal: return CallingConvention::NearC; 18130b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast; 18140b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_thiscall: return CallingConvention::ThisCall; 18150b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_stdcall: return CallingConvention::NearStdCall; 18160b57cec5SDimitry Andric case dwarf::DW_CC_BORLAND_pascal: return CallingConvention::NearPascal; 18170b57cec5SDimitry Andric case dwarf::DW_CC_LLVM_vectorcall: return CallingConvention::NearVector; 18180b57cec5SDimitry Andric } 18190b57cec5SDimitry Andric return CallingConvention::NearC; 18200b57cec5SDimitry Andric } 18210b57cec5SDimitry Andric 18220b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) { 18230b57cec5SDimitry Andric ModifierOptions Mods = ModifierOptions::None; 18240b57cec5SDimitry Andric PointerOptions PO = PointerOptions::None; 18250b57cec5SDimitry Andric bool IsModifier = true; 18260b57cec5SDimitry Andric const DIType *BaseTy = Ty; 18270b57cec5SDimitry Andric while (IsModifier && BaseTy) { 18280b57cec5SDimitry Andric // FIXME: Need to add DWARF tags for __unaligned and _Atomic 18290b57cec5SDimitry Andric switch (BaseTy->getTag()) { 18300b57cec5SDimitry Andric case dwarf::DW_TAG_const_type: 18310b57cec5SDimitry Andric Mods |= ModifierOptions::Const; 18320b57cec5SDimitry Andric PO |= PointerOptions::Const; 18330b57cec5SDimitry Andric break; 18340b57cec5SDimitry Andric case dwarf::DW_TAG_volatile_type: 18350b57cec5SDimitry Andric Mods |= ModifierOptions::Volatile; 18360b57cec5SDimitry Andric PO |= PointerOptions::Volatile; 18370b57cec5SDimitry Andric break; 18380b57cec5SDimitry Andric case dwarf::DW_TAG_restrict_type: 18390b57cec5SDimitry Andric // Only pointer types be marked with __restrict. There is no known flag 18400b57cec5SDimitry Andric // for __restrict in LF_MODIFIER records. 18410b57cec5SDimitry Andric PO |= PointerOptions::Restrict; 18420b57cec5SDimitry Andric break; 18430b57cec5SDimitry Andric default: 18440b57cec5SDimitry Andric IsModifier = false; 18450b57cec5SDimitry Andric break; 18460b57cec5SDimitry Andric } 18470b57cec5SDimitry Andric if (IsModifier) 18480b57cec5SDimitry Andric BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType(); 18490b57cec5SDimitry Andric } 18500b57cec5SDimitry Andric 18510b57cec5SDimitry Andric // Check if the inner type will use an LF_POINTER record. If so, the 18520b57cec5SDimitry Andric // qualifiers will go in the LF_POINTER record. This comes up for types like 18530b57cec5SDimitry Andric // 'int *const' and 'int *__restrict', not the more common cases like 'const 18540b57cec5SDimitry Andric // char *'. 18550b57cec5SDimitry Andric if (BaseTy) { 18560b57cec5SDimitry Andric switch (BaseTy->getTag()) { 18570b57cec5SDimitry Andric case dwarf::DW_TAG_pointer_type: 18580b57cec5SDimitry Andric case dwarf::DW_TAG_reference_type: 18590b57cec5SDimitry Andric case dwarf::DW_TAG_rvalue_reference_type: 18600b57cec5SDimitry Andric return lowerTypePointer(cast<DIDerivedType>(BaseTy), PO); 18610b57cec5SDimitry Andric case dwarf::DW_TAG_ptr_to_member_type: 18620b57cec5SDimitry Andric return lowerTypeMemberPointer(cast<DIDerivedType>(BaseTy), PO); 18630b57cec5SDimitry Andric default: 18640b57cec5SDimitry Andric break; 18650b57cec5SDimitry Andric } 18660b57cec5SDimitry Andric } 18670b57cec5SDimitry Andric 18680b57cec5SDimitry Andric TypeIndex ModifiedTI = getTypeIndex(BaseTy); 18690b57cec5SDimitry Andric 18700b57cec5SDimitry Andric // Return the base type index if there aren't any modifiers. For example, the 18710b57cec5SDimitry Andric // metadata could contain restrict wrappers around non-pointer types. 18720b57cec5SDimitry Andric if (Mods == ModifierOptions::None) 18730b57cec5SDimitry Andric return ModifiedTI; 18740b57cec5SDimitry Andric 18750b57cec5SDimitry Andric ModifierRecord MR(ModifiedTI, Mods); 18760b57cec5SDimitry Andric return TypeTable.writeLeafType(MR); 18770b57cec5SDimitry Andric } 18780b57cec5SDimitry Andric 18790b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) { 18800b57cec5SDimitry Andric SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices; 18810b57cec5SDimitry Andric for (const DIType *ArgType : Ty->getTypeArray()) 18820b57cec5SDimitry Andric ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgType)); 18830b57cec5SDimitry Andric 18840b57cec5SDimitry Andric // MSVC uses type none for variadic argument. 18850b57cec5SDimitry Andric if (ReturnAndArgTypeIndices.size() > 1 && 18860b57cec5SDimitry Andric ReturnAndArgTypeIndices.back() == TypeIndex::Void()) { 18870b57cec5SDimitry Andric ReturnAndArgTypeIndices.back() = TypeIndex::None(); 18880b57cec5SDimitry Andric } 18890b57cec5SDimitry Andric TypeIndex ReturnTypeIndex = TypeIndex::Void(); 18900b57cec5SDimitry Andric ArrayRef<TypeIndex> ArgTypeIndices = None; 18910b57cec5SDimitry Andric if (!ReturnAndArgTypeIndices.empty()) { 18920b57cec5SDimitry Andric auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices); 18930b57cec5SDimitry Andric ReturnTypeIndex = ReturnAndArgTypesRef.front(); 18940b57cec5SDimitry Andric ArgTypeIndices = ReturnAndArgTypesRef.drop_front(); 18950b57cec5SDimitry Andric } 18960b57cec5SDimitry Andric 18970b57cec5SDimitry Andric ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices); 18980b57cec5SDimitry Andric TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec); 18990b57cec5SDimitry Andric 19000b57cec5SDimitry Andric CallingConvention CC = dwarfCCToCodeView(Ty->getCC()); 19010b57cec5SDimitry Andric 19020b57cec5SDimitry Andric FunctionOptions FO = getFunctionOptions(Ty); 19030b57cec5SDimitry Andric ProcedureRecord Procedure(ReturnTypeIndex, CC, FO, ArgTypeIndices.size(), 19040b57cec5SDimitry Andric ArgListIndex); 19050b57cec5SDimitry Andric return TypeTable.writeLeafType(Procedure); 19060b57cec5SDimitry Andric } 19070b57cec5SDimitry Andric 19080b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty, 19090b57cec5SDimitry Andric const DIType *ClassTy, 19100b57cec5SDimitry Andric int ThisAdjustment, 19110b57cec5SDimitry Andric bool IsStaticMethod, 19120b57cec5SDimitry Andric FunctionOptions FO) { 19130b57cec5SDimitry Andric // Lower the containing class type. 19140b57cec5SDimitry Andric TypeIndex ClassType = getTypeIndex(ClassTy); 19150b57cec5SDimitry Andric 19160b57cec5SDimitry Andric DITypeRefArray ReturnAndArgs = Ty->getTypeArray(); 19170b57cec5SDimitry Andric 19180b57cec5SDimitry Andric unsigned Index = 0; 19190b57cec5SDimitry Andric SmallVector<TypeIndex, 8> ArgTypeIndices; 19200b57cec5SDimitry Andric TypeIndex ReturnTypeIndex = TypeIndex::Void(); 19210b57cec5SDimitry Andric if (ReturnAndArgs.size() > Index) { 19220b57cec5SDimitry Andric ReturnTypeIndex = getTypeIndex(ReturnAndArgs[Index++]); 19230b57cec5SDimitry Andric } 19240b57cec5SDimitry Andric 19250b57cec5SDimitry Andric // If the first argument is a pointer type and this isn't a static method, 19260b57cec5SDimitry Andric // treat it as the special 'this' parameter, which is encoded separately from 19270b57cec5SDimitry Andric // the arguments. 19280b57cec5SDimitry Andric TypeIndex ThisTypeIndex; 19290b57cec5SDimitry Andric if (!IsStaticMethod && ReturnAndArgs.size() > Index) { 19300b57cec5SDimitry Andric if (const DIDerivedType *PtrTy = 19310b57cec5SDimitry Andric dyn_cast_or_null<DIDerivedType>(ReturnAndArgs[Index])) { 19320b57cec5SDimitry Andric if (PtrTy->getTag() == dwarf::DW_TAG_pointer_type) { 19330b57cec5SDimitry Andric ThisTypeIndex = getTypeIndexForThisPtr(PtrTy, Ty); 19340b57cec5SDimitry Andric Index++; 19350b57cec5SDimitry Andric } 19360b57cec5SDimitry Andric } 19370b57cec5SDimitry Andric } 19380b57cec5SDimitry Andric 19390b57cec5SDimitry Andric while (Index < ReturnAndArgs.size()) 19400b57cec5SDimitry Andric ArgTypeIndices.push_back(getTypeIndex(ReturnAndArgs[Index++])); 19410b57cec5SDimitry Andric 19420b57cec5SDimitry Andric // MSVC uses type none for variadic argument. 19430b57cec5SDimitry Andric if (!ArgTypeIndices.empty() && ArgTypeIndices.back() == TypeIndex::Void()) 19440b57cec5SDimitry Andric ArgTypeIndices.back() = TypeIndex::None(); 19450b57cec5SDimitry Andric 19460b57cec5SDimitry Andric ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices); 19470b57cec5SDimitry Andric TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec); 19480b57cec5SDimitry Andric 19490b57cec5SDimitry Andric CallingConvention CC = dwarfCCToCodeView(Ty->getCC()); 19500b57cec5SDimitry Andric 19510b57cec5SDimitry Andric MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC, FO, 19520b57cec5SDimitry Andric ArgTypeIndices.size(), ArgListIndex, ThisAdjustment); 19530b57cec5SDimitry Andric return TypeTable.writeLeafType(MFR); 19540b57cec5SDimitry Andric } 19550b57cec5SDimitry Andric 19560b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) { 19570b57cec5SDimitry Andric unsigned VSlotCount = 19580b57cec5SDimitry Andric Ty->getSizeInBits() / (8 * Asm->MAI->getCodePointerSize()); 19590b57cec5SDimitry Andric SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near); 19600b57cec5SDimitry Andric 19610b57cec5SDimitry Andric VFTableShapeRecord VFTSR(Slots); 19620b57cec5SDimitry Andric return TypeTable.writeLeafType(VFTSR); 19630b57cec5SDimitry Andric } 19640b57cec5SDimitry Andric 19650b57cec5SDimitry Andric static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) { 19660b57cec5SDimitry Andric switch (Flags & DINode::FlagAccessibility) { 19670b57cec5SDimitry Andric case DINode::FlagPrivate: return MemberAccess::Private; 19680b57cec5SDimitry Andric case DINode::FlagPublic: return MemberAccess::Public; 19690b57cec5SDimitry Andric case DINode::FlagProtected: return MemberAccess::Protected; 19700b57cec5SDimitry Andric case 0: 19710b57cec5SDimitry Andric // If there was no explicit access control, provide the default for the tag. 19720b57cec5SDimitry Andric return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private 19730b57cec5SDimitry Andric : MemberAccess::Public; 19740b57cec5SDimitry Andric } 19750b57cec5SDimitry Andric llvm_unreachable("access flags are exclusive"); 19760b57cec5SDimitry Andric } 19770b57cec5SDimitry Andric 19780b57cec5SDimitry Andric static MethodOptions translateMethodOptionFlags(const DISubprogram *SP) { 19790b57cec5SDimitry Andric if (SP->isArtificial()) 19800b57cec5SDimitry Andric return MethodOptions::CompilerGenerated; 19810b57cec5SDimitry Andric 19820b57cec5SDimitry Andric // FIXME: Handle other MethodOptions. 19830b57cec5SDimitry Andric 19840b57cec5SDimitry Andric return MethodOptions::None; 19850b57cec5SDimitry Andric } 19860b57cec5SDimitry Andric 19870b57cec5SDimitry Andric static MethodKind translateMethodKindFlags(const DISubprogram *SP, 19880b57cec5SDimitry Andric bool Introduced) { 19890b57cec5SDimitry Andric if (SP->getFlags() & DINode::FlagStaticMember) 19900b57cec5SDimitry Andric return MethodKind::Static; 19910b57cec5SDimitry Andric 19920b57cec5SDimitry Andric switch (SP->getVirtuality()) { 19930b57cec5SDimitry Andric case dwarf::DW_VIRTUALITY_none: 19940b57cec5SDimitry Andric break; 19950b57cec5SDimitry Andric case dwarf::DW_VIRTUALITY_virtual: 19960b57cec5SDimitry Andric return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual; 19970b57cec5SDimitry Andric case dwarf::DW_VIRTUALITY_pure_virtual: 19980b57cec5SDimitry Andric return Introduced ? MethodKind::PureIntroducingVirtual 19990b57cec5SDimitry Andric : MethodKind::PureVirtual; 20000b57cec5SDimitry Andric default: 20010b57cec5SDimitry Andric llvm_unreachable("unhandled virtuality case"); 20020b57cec5SDimitry Andric } 20030b57cec5SDimitry Andric 20040b57cec5SDimitry Andric return MethodKind::Vanilla; 20050b57cec5SDimitry Andric } 20060b57cec5SDimitry Andric 20070b57cec5SDimitry Andric static TypeRecordKind getRecordKind(const DICompositeType *Ty) { 20080b57cec5SDimitry Andric switch (Ty->getTag()) { 20090b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: return TypeRecordKind::Class; 20100b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct; 20110b57cec5SDimitry Andric } 20120b57cec5SDimitry Andric llvm_unreachable("unexpected tag"); 20130b57cec5SDimitry Andric } 20140b57cec5SDimitry Andric 20150b57cec5SDimitry Andric /// Return ClassOptions that should be present on both the forward declaration 20160b57cec5SDimitry Andric /// and the defintion of a tag type. 20170b57cec5SDimitry Andric static ClassOptions getCommonClassOptions(const DICompositeType *Ty) { 20180b57cec5SDimitry Andric ClassOptions CO = ClassOptions::None; 20190b57cec5SDimitry Andric 20200b57cec5SDimitry Andric // MSVC always sets this flag, even for local types. Clang doesn't always 20210b57cec5SDimitry Andric // appear to give every type a linkage name, which may be problematic for us. 20220b57cec5SDimitry Andric // FIXME: Investigate the consequences of not following them here. 20230b57cec5SDimitry Andric if (!Ty->getIdentifier().empty()) 20240b57cec5SDimitry Andric CO |= ClassOptions::HasUniqueName; 20250b57cec5SDimitry Andric 20260b57cec5SDimitry Andric // Put the Nested flag on a type if it appears immediately inside a tag type. 20270b57cec5SDimitry Andric // Do not walk the scope chain. Do not attempt to compute ContainsNestedClass 20280b57cec5SDimitry Andric // here. That flag is only set on definitions, and not forward declarations. 20290b57cec5SDimitry Andric const DIScope *ImmediateScope = Ty->getScope(); 20300b57cec5SDimitry Andric if (ImmediateScope && isa<DICompositeType>(ImmediateScope)) 20310b57cec5SDimitry Andric CO |= ClassOptions::Nested; 20320b57cec5SDimitry Andric 20330b57cec5SDimitry Andric // Put the Scoped flag on function-local types. MSVC puts this flag for enum 20340b57cec5SDimitry Andric // type only when it has an immediate function scope. Clang never puts enums 20350b57cec5SDimitry Andric // inside DILexicalBlock scopes. Enum types, as generated by clang, are 20360b57cec5SDimitry Andric // always in function, class, or file scopes. 20370b57cec5SDimitry Andric if (Ty->getTag() == dwarf::DW_TAG_enumeration_type) { 20380b57cec5SDimitry Andric if (ImmediateScope && isa<DISubprogram>(ImmediateScope)) 20390b57cec5SDimitry Andric CO |= ClassOptions::Scoped; 20400b57cec5SDimitry Andric } else { 20410b57cec5SDimitry Andric for (const DIScope *Scope = ImmediateScope; Scope != nullptr; 20420b57cec5SDimitry Andric Scope = Scope->getScope()) { 20430b57cec5SDimitry Andric if (isa<DISubprogram>(Scope)) { 20440b57cec5SDimitry Andric CO |= ClassOptions::Scoped; 20450b57cec5SDimitry Andric break; 20460b57cec5SDimitry Andric } 20470b57cec5SDimitry Andric } 20480b57cec5SDimitry Andric } 20490b57cec5SDimitry Andric 20500b57cec5SDimitry Andric return CO; 20510b57cec5SDimitry Andric } 20520b57cec5SDimitry Andric 20530b57cec5SDimitry Andric void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) { 20540b57cec5SDimitry Andric switch (Ty->getTag()) { 20550b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 20560b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 20570b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 20580b57cec5SDimitry Andric case dwarf::DW_TAG_enumeration_type: 20590b57cec5SDimitry Andric break; 20600b57cec5SDimitry Andric default: 20610b57cec5SDimitry Andric return; 20620b57cec5SDimitry Andric } 20630b57cec5SDimitry Andric 20640b57cec5SDimitry Andric if (const auto *File = Ty->getFile()) { 20650b57cec5SDimitry Andric StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File)); 20660b57cec5SDimitry Andric TypeIndex SIDI = TypeTable.writeLeafType(SIDR); 20670b57cec5SDimitry Andric 20680b57cec5SDimitry Andric UdtSourceLineRecord USLR(TI, SIDI, Ty->getLine()); 20690b57cec5SDimitry Andric TypeTable.writeLeafType(USLR); 20700b57cec5SDimitry Andric } 20710b57cec5SDimitry Andric } 20720b57cec5SDimitry Andric 20730b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) { 20740b57cec5SDimitry Andric ClassOptions CO = getCommonClassOptions(Ty); 20750b57cec5SDimitry Andric TypeIndex FTI; 20760b57cec5SDimitry Andric unsigned EnumeratorCount = 0; 20770b57cec5SDimitry Andric 20780b57cec5SDimitry Andric if (Ty->isForwardDecl()) { 20790b57cec5SDimitry Andric CO |= ClassOptions::ForwardReference; 20800b57cec5SDimitry Andric } else { 20810b57cec5SDimitry Andric ContinuationRecordBuilder ContinuationBuilder; 20820b57cec5SDimitry Andric ContinuationBuilder.begin(ContinuationRecordKind::FieldList); 20830b57cec5SDimitry Andric for (const DINode *Element : Ty->getElements()) { 20840b57cec5SDimitry Andric // We assume that the frontend provides all members in source declaration 20850b57cec5SDimitry Andric // order, which is what MSVC does. 20860b57cec5SDimitry Andric if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) { 20870b57cec5SDimitry Andric EnumeratorRecord ER(MemberAccess::Public, 20885ffd83dbSDimitry Andric APSInt(Enumerator->getValue(), true), 20890b57cec5SDimitry Andric Enumerator->getName()); 20900b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(ER); 20910b57cec5SDimitry Andric EnumeratorCount++; 20920b57cec5SDimitry Andric } 20930b57cec5SDimitry Andric } 20940b57cec5SDimitry Andric FTI = TypeTable.insertRecord(ContinuationBuilder); 20950b57cec5SDimitry Andric } 20960b57cec5SDimitry Andric 20970b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 20980b57cec5SDimitry Andric 20990b57cec5SDimitry Andric EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(), 21000b57cec5SDimitry Andric getTypeIndex(Ty->getBaseType())); 21010b57cec5SDimitry Andric TypeIndex EnumTI = TypeTable.writeLeafType(ER); 21020b57cec5SDimitry Andric 21030b57cec5SDimitry Andric addUDTSrcLine(Ty, EnumTI); 21040b57cec5SDimitry Andric 21050b57cec5SDimitry Andric return EnumTI; 21060b57cec5SDimitry Andric } 21070b57cec5SDimitry Andric 21080b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 21090b57cec5SDimitry Andric // ClassInfo 21100b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 21110b57cec5SDimitry Andric 21120b57cec5SDimitry Andric struct llvm::ClassInfo { 21130b57cec5SDimitry Andric struct MemberInfo { 21140b57cec5SDimitry Andric const DIDerivedType *MemberTypeNode; 21150b57cec5SDimitry Andric uint64_t BaseOffset; 21160b57cec5SDimitry Andric }; 21170b57cec5SDimitry Andric // [MemberInfo] 21180b57cec5SDimitry Andric using MemberList = std::vector<MemberInfo>; 21190b57cec5SDimitry Andric 21200b57cec5SDimitry Andric using MethodsList = TinyPtrVector<const DISubprogram *>; 21210b57cec5SDimitry Andric // MethodName -> MethodsList 21220b57cec5SDimitry Andric using MethodsMap = MapVector<MDString *, MethodsList>; 21230b57cec5SDimitry Andric 21240b57cec5SDimitry Andric /// Base classes. 21250b57cec5SDimitry Andric std::vector<const DIDerivedType *> Inheritance; 21260b57cec5SDimitry Andric 21270b57cec5SDimitry Andric /// Direct members. 21280b57cec5SDimitry Andric MemberList Members; 21290b57cec5SDimitry Andric // Direct overloaded methods gathered by name. 21300b57cec5SDimitry Andric MethodsMap Methods; 21310b57cec5SDimitry Andric 21320b57cec5SDimitry Andric TypeIndex VShapeTI; 21330b57cec5SDimitry Andric 21340b57cec5SDimitry Andric std::vector<const DIType *> NestedTypes; 21350b57cec5SDimitry Andric }; 21360b57cec5SDimitry Andric 21370b57cec5SDimitry Andric void CodeViewDebug::clear() { 21380b57cec5SDimitry Andric assert(CurFn == nullptr); 21390b57cec5SDimitry Andric FileIdMap.clear(); 21400b57cec5SDimitry Andric FnDebugInfo.clear(); 21410b57cec5SDimitry Andric FileToFilepathMap.clear(); 21420b57cec5SDimitry Andric LocalUDTs.clear(); 21430b57cec5SDimitry Andric GlobalUDTs.clear(); 21440b57cec5SDimitry Andric TypeIndices.clear(); 21450b57cec5SDimitry Andric CompleteTypeIndices.clear(); 21460b57cec5SDimitry Andric ScopeGlobals.clear(); 21470b57cec5SDimitry Andric } 21480b57cec5SDimitry Andric 21490b57cec5SDimitry Andric void CodeViewDebug::collectMemberInfo(ClassInfo &Info, 21500b57cec5SDimitry Andric const DIDerivedType *DDTy) { 21510b57cec5SDimitry Andric if (!DDTy->getName().empty()) { 21520b57cec5SDimitry Andric Info.Members.push_back({DDTy, 0}); 21530b57cec5SDimitry Andric return; 21540b57cec5SDimitry Andric } 21550b57cec5SDimitry Andric 21560b57cec5SDimitry Andric // An unnamed member may represent a nested struct or union. Attempt to 21570b57cec5SDimitry Andric // interpret the unnamed member as a DICompositeType possibly wrapped in 21580b57cec5SDimitry Andric // qualifier types. Add all the indirect fields to the current record if that 21590b57cec5SDimitry Andric // succeeds, and drop the member if that fails. 21600b57cec5SDimitry Andric assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!"); 21610b57cec5SDimitry Andric uint64_t Offset = DDTy->getOffsetInBits(); 21620b57cec5SDimitry Andric const DIType *Ty = DDTy->getBaseType(); 21630b57cec5SDimitry Andric bool FullyResolved = false; 21640b57cec5SDimitry Andric while (!FullyResolved) { 21650b57cec5SDimitry Andric switch (Ty->getTag()) { 21660b57cec5SDimitry Andric case dwarf::DW_TAG_const_type: 21670b57cec5SDimitry Andric case dwarf::DW_TAG_volatile_type: 21680b57cec5SDimitry Andric // FIXME: we should apply the qualifier types to the indirect fields 21690b57cec5SDimitry Andric // rather than dropping them. 21700b57cec5SDimitry Andric Ty = cast<DIDerivedType>(Ty)->getBaseType(); 21710b57cec5SDimitry Andric break; 21720b57cec5SDimitry Andric default: 21730b57cec5SDimitry Andric FullyResolved = true; 21740b57cec5SDimitry Andric break; 21750b57cec5SDimitry Andric } 21760b57cec5SDimitry Andric } 21770b57cec5SDimitry Andric 21780b57cec5SDimitry Andric const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty); 21790b57cec5SDimitry Andric if (!DCTy) 21800b57cec5SDimitry Andric return; 21810b57cec5SDimitry Andric 21820b57cec5SDimitry Andric ClassInfo NestedInfo = collectClassInfo(DCTy); 21830b57cec5SDimitry Andric for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members) 21840b57cec5SDimitry Andric Info.Members.push_back( 21850b57cec5SDimitry Andric {IndirectField.MemberTypeNode, IndirectField.BaseOffset + Offset}); 21860b57cec5SDimitry Andric } 21870b57cec5SDimitry Andric 21880b57cec5SDimitry Andric ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) { 21890b57cec5SDimitry Andric ClassInfo Info; 21900b57cec5SDimitry Andric // Add elements to structure type. 21910b57cec5SDimitry Andric DINodeArray Elements = Ty->getElements(); 21920b57cec5SDimitry Andric for (auto *Element : Elements) { 21930b57cec5SDimitry Andric // We assume that the frontend provides all members in source declaration 21940b57cec5SDimitry Andric // order, which is what MSVC does. 21950b57cec5SDimitry Andric if (!Element) 21960b57cec5SDimitry Andric continue; 21970b57cec5SDimitry Andric if (auto *SP = dyn_cast<DISubprogram>(Element)) { 21980b57cec5SDimitry Andric Info.Methods[SP->getRawName()].push_back(SP); 21990b57cec5SDimitry Andric } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) { 22000b57cec5SDimitry Andric if (DDTy->getTag() == dwarf::DW_TAG_member) { 22010b57cec5SDimitry Andric collectMemberInfo(Info, DDTy); 22020b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) { 22030b57cec5SDimitry Andric Info.Inheritance.push_back(DDTy); 22040b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_pointer_type && 22050b57cec5SDimitry Andric DDTy->getName() == "__vtbl_ptr_type") { 22060b57cec5SDimitry Andric Info.VShapeTI = getTypeIndex(DDTy); 22070b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_typedef) { 22080b57cec5SDimitry Andric Info.NestedTypes.push_back(DDTy); 22090b57cec5SDimitry Andric } else if (DDTy->getTag() == dwarf::DW_TAG_friend) { 22100b57cec5SDimitry Andric // Ignore friend members. It appears that MSVC emitted info about 22110b57cec5SDimitry Andric // friends in the past, but modern versions do not. 22120b57cec5SDimitry Andric } 22130b57cec5SDimitry Andric } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) { 22140b57cec5SDimitry Andric Info.NestedTypes.push_back(Composite); 22150b57cec5SDimitry Andric } 22160b57cec5SDimitry Andric // Skip other unrecognized kinds of elements. 22170b57cec5SDimitry Andric } 22180b57cec5SDimitry Andric return Info; 22190b57cec5SDimitry Andric } 22200b57cec5SDimitry Andric 22210b57cec5SDimitry Andric static bool shouldAlwaysEmitCompleteClassType(const DICompositeType *Ty) { 22220b57cec5SDimitry Andric // This routine is used by lowerTypeClass and lowerTypeUnion to determine 22230b57cec5SDimitry Andric // if a complete type should be emitted instead of a forward reference. 22240b57cec5SDimitry Andric return Ty->getName().empty() && Ty->getIdentifier().empty() && 22250b57cec5SDimitry Andric !Ty->isForwardDecl(); 22260b57cec5SDimitry Andric } 22270b57cec5SDimitry Andric 22280b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) { 22290b57cec5SDimitry Andric // Emit the complete type for unnamed structs. C++ classes with methods 22300b57cec5SDimitry Andric // which have a circular reference back to the class type are expected to 22310b57cec5SDimitry Andric // be named by the front-end and should not be "unnamed". C unnamed 22320b57cec5SDimitry Andric // structs should not have circular references. 22330b57cec5SDimitry Andric if (shouldAlwaysEmitCompleteClassType(Ty)) { 22340b57cec5SDimitry Andric // If this unnamed complete type is already in the process of being defined 22350b57cec5SDimitry Andric // then the description of the type is malformed and cannot be emitted 22360b57cec5SDimitry Andric // into CodeView correctly so report a fatal error. 22370b57cec5SDimitry Andric auto I = CompleteTypeIndices.find(Ty); 22380b57cec5SDimitry Andric if (I != CompleteTypeIndices.end() && I->second == TypeIndex()) 22390b57cec5SDimitry Andric report_fatal_error("cannot debug circular reference to unnamed type"); 22400b57cec5SDimitry Andric return getCompleteTypeIndex(Ty); 22410b57cec5SDimitry Andric } 22420b57cec5SDimitry Andric 22430b57cec5SDimitry Andric // First, construct the forward decl. Don't look into Ty to compute the 22440b57cec5SDimitry Andric // forward decl options, since it might not be available in all TUs. 22450b57cec5SDimitry Andric TypeRecordKind Kind = getRecordKind(Ty); 22460b57cec5SDimitry Andric ClassOptions CO = 22470b57cec5SDimitry Andric ClassOptions::ForwardReference | getCommonClassOptions(Ty); 22480b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 22490b57cec5SDimitry Andric ClassRecord CR(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0, 22500b57cec5SDimitry Andric FullName, Ty->getIdentifier()); 22510b57cec5SDimitry Andric TypeIndex FwdDeclTI = TypeTable.writeLeafType(CR); 22520b57cec5SDimitry Andric if (!Ty->isForwardDecl()) 22530b57cec5SDimitry Andric DeferredCompleteTypes.push_back(Ty); 22540b57cec5SDimitry Andric return FwdDeclTI; 22550b57cec5SDimitry Andric } 22560b57cec5SDimitry Andric 22570b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) { 22580b57cec5SDimitry Andric // Construct the field list and complete type record. 22590b57cec5SDimitry Andric TypeRecordKind Kind = getRecordKind(Ty); 22600b57cec5SDimitry Andric ClassOptions CO = getCommonClassOptions(Ty); 22610b57cec5SDimitry Andric TypeIndex FieldTI; 22620b57cec5SDimitry Andric TypeIndex VShapeTI; 22630b57cec5SDimitry Andric unsigned FieldCount; 22640b57cec5SDimitry Andric bool ContainsNestedClass; 22650b57cec5SDimitry Andric std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) = 22660b57cec5SDimitry Andric lowerRecordFieldList(Ty); 22670b57cec5SDimitry Andric 22680b57cec5SDimitry Andric if (ContainsNestedClass) 22690b57cec5SDimitry Andric CO |= ClassOptions::ContainsNestedClass; 22700b57cec5SDimitry Andric 22710b57cec5SDimitry Andric // MSVC appears to set this flag by searching any destructor or method with 22720b57cec5SDimitry Andric // FunctionOptions::Constructor among the emitted members. Clang AST has all 22730b57cec5SDimitry Andric // the members, however special member functions are not yet emitted into 22740b57cec5SDimitry Andric // debug information. For now checking a class's non-triviality seems enough. 22750b57cec5SDimitry Andric // FIXME: not true for a nested unnamed struct. 22760b57cec5SDimitry Andric if (isNonTrivial(Ty)) 22770b57cec5SDimitry Andric CO |= ClassOptions::HasConstructorOrDestructor; 22780b57cec5SDimitry Andric 22790b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 22800b57cec5SDimitry Andric 22810b57cec5SDimitry Andric uint64_t SizeInBytes = Ty->getSizeInBits() / 8; 22820b57cec5SDimitry Andric 22830b57cec5SDimitry Andric ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI, 22840b57cec5SDimitry Andric SizeInBytes, FullName, Ty->getIdentifier()); 22850b57cec5SDimitry Andric TypeIndex ClassTI = TypeTable.writeLeafType(CR); 22860b57cec5SDimitry Andric 22870b57cec5SDimitry Andric addUDTSrcLine(Ty, ClassTI); 22880b57cec5SDimitry Andric 22890b57cec5SDimitry Andric addToUDTs(Ty); 22900b57cec5SDimitry Andric 22910b57cec5SDimitry Andric return ClassTI; 22920b57cec5SDimitry Andric } 22930b57cec5SDimitry Andric 22940b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) { 22950b57cec5SDimitry Andric // Emit the complete type for unnamed unions. 22960b57cec5SDimitry Andric if (shouldAlwaysEmitCompleteClassType(Ty)) 22970b57cec5SDimitry Andric return getCompleteTypeIndex(Ty); 22980b57cec5SDimitry Andric 22990b57cec5SDimitry Andric ClassOptions CO = 23000b57cec5SDimitry Andric ClassOptions::ForwardReference | getCommonClassOptions(Ty); 23010b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 23020b57cec5SDimitry Andric UnionRecord UR(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier()); 23030b57cec5SDimitry Andric TypeIndex FwdDeclTI = TypeTable.writeLeafType(UR); 23040b57cec5SDimitry Andric if (!Ty->isForwardDecl()) 23050b57cec5SDimitry Andric DeferredCompleteTypes.push_back(Ty); 23060b57cec5SDimitry Andric return FwdDeclTI; 23070b57cec5SDimitry Andric } 23080b57cec5SDimitry Andric 23090b57cec5SDimitry Andric TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) { 23100b57cec5SDimitry Andric ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty); 23110b57cec5SDimitry Andric TypeIndex FieldTI; 23120b57cec5SDimitry Andric unsigned FieldCount; 23130b57cec5SDimitry Andric bool ContainsNestedClass; 23140b57cec5SDimitry Andric std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) = 23150b57cec5SDimitry Andric lowerRecordFieldList(Ty); 23160b57cec5SDimitry Andric 23170b57cec5SDimitry Andric if (ContainsNestedClass) 23180b57cec5SDimitry Andric CO |= ClassOptions::ContainsNestedClass; 23190b57cec5SDimitry Andric 23200b57cec5SDimitry Andric uint64_t SizeInBytes = Ty->getSizeInBits() / 8; 23210b57cec5SDimitry Andric std::string FullName = getFullyQualifiedName(Ty); 23220b57cec5SDimitry Andric 23230b57cec5SDimitry Andric UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName, 23240b57cec5SDimitry Andric Ty->getIdentifier()); 23250b57cec5SDimitry Andric TypeIndex UnionTI = TypeTable.writeLeafType(UR); 23260b57cec5SDimitry Andric 23270b57cec5SDimitry Andric addUDTSrcLine(Ty, UnionTI); 23280b57cec5SDimitry Andric 23290b57cec5SDimitry Andric addToUDTs(Ty); 23300b57cec5SDimitry Andric 23310b57cec5SDimitry Andric return UnionTI; 23320b57cec5SDimitry Andric } 23330b57cec5SDimitry Andric 23340b57cec5SDimitry Andric std::tuple<TypeIndex, TypeIndex, unsigned, bool> 23350b57cec5SDimitry Andric CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) { 23360b57cec5SDimitry Andric // Manually count members. MSVC appears to count everything that generates a 23370b57cec5SDimitry Andric // field list record. Each individual overload in a method overload group 23380b57cec5SDimitry Andric // contributes to this count, even though the overload group is a single field 23390b57cec5SDimitry Andric // list record. 23400b57cec5SDimitry Andric unsigned MemberCount = 0; 23410b57cec5SDimitry Andric ClassInfo Info = collectClassInfo(Ty); 23420b57cec5SDimitry Andric ContinuationRecordBuilder ContinuationBuilder; 23430b57cec5SDimitry Andric ContinuationBuilder.begin(ContinuationRecordKind::FieldList); 23440b57cec5SDimitry Andric 23450b57cec5SDimitry Andric // Create base classes. 23460b57cec5SDimitry Andric for (const DIDerivedType *I : Info.Inheritance) { 23470b57cec5SDimitry Andric if (I->getFlags() & DINode::FlagVirtual) { 23480b57cec5SDimitry Andric // Virtual base. 23490b57cec5SDimitry Andric unsigned VBPtrOffset = I->getVBPtrOffset(); 23500b57cec5SDimitry Andric // FIXME: Despite the accessor name, the offset is really in bytes. 23510b57cec5SDimitry Andric unsigned VBTableIndex = I->getOffsetInBits() / 4; 23520b57cec5SDimitry Andric auto RecordKind = (I->getFlags() & DINode::FlagIndirectVirtualBase) == DINode::FlagIndirectVirtualBase 23530b57cec5SDimitry Andric ? TypeRecordKind::IndirectVirtualBaseClass 23540b57cec5SDimitry Andric : TypeRecordKind::VirtualBaseClass; 23550b57cec5SDimitry Andric VirtualBaseClassRecord VBCR( 23560b57cec5SDimitry Andric RecordKind, translateAccessFlags(Ty->getTag(), I->getFlags()), 23570b57cec5SDimitry Andric getTypeIndex(I->getBaseType()), getVBPTypeIndex(), VBPtrOffset, 23580b57cec5SDimitry Andric VBTableIndex); 23590b57cec5SDimitry Andric 23600b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(VBCR); 23610b57cec5SDimitry Andric MemberCount++; 23620b57cec5SDimitry Andric } else { 23630b57cec5SDimitry Andric assert(I->getOffsetInBits() % 8 == 0 && 23640b57cec5SDimitry Andric "bases must be on byte boundaries"); 23650b57cec5SDimitry Andric BaseClassRecord BCR(translateAccessFlags(Ty->getTag(), I->getFlags()), 23660b57cec5SDimitry Andric getTypeIndex(I->getBaseType()), 23670b57cec5SDimitry Andric I->getOffsetInBits() / 8); 23680b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(BCR); 23690b57cec5SDimitry Andric MemberCount++; 23700b57cec5SDimitry Andric } 23710b57cec5SDimitry Andric } 23720b57cec5SDimitry Andric 23730b57cec5SDimitry Andric // Create members. 23740b57cec5SDimitry Andric for (ClassInfo::MemberInfo &MemberInfo : Info.Members) { 23750b57cec5SDimitry Andric const DIDerivedType *Member = MemberInfo.MemberTypeNode; 23760b57cec5SDimitry Andric TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType()); 23770b57cec5SDimitry Andric StringRef MemberName = Member->getName(); 23780b57cec5SDimitry Andric MemberAccess Access = 23790b57cec5SDimitry Andric translateAccessFlags(Ty->getTag(), Member->getFlags()); 23800b57cec5SDimitry Andric 23810b57cec5SDimitry Andric if (Member->isStaticMember()) { 23820b57cec5SDimitry Andric StaticDataMemberRecord SDMR(Access, MemberBaseType, MemberName); 23830b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(SDMR); 23840b57cec5SDimitry Andric MemberCount++; 23850b57cec5SDimitry Andric continue; 23860b57cec5SDimitry Andric } 23870b57cec5SDimitry Andric 23880b57cec5SDimitry Andric // Virtual function pointer member. 23890b57cec5SDimitry Andric if ((Member->getFlags() & DINode::FlagArtificial) && 23900b57cec5SDimitry Andric Member->getName().startswith("_vptr$")) { 23910b57cec5SDimitry Andric VFPtrRecord VFPR(getTypeIndex(Member->getBaseType())); 23920b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(VFPR); 23930b57cec5SDimitry Andric MemberCount++; 23940b57cec5SDimitry Andric continue; 23950b57cec5SDimitry Andric } 23960b57cec5SDimitry Andric 23970b57cec5SDimitry Andric // Data member. 23980b57cec5SDimitry Andric uint64_t MemberOffsetInBits = 23990b57cec5SDimitry Andric Member->getOffsetInBits() + MemberInfo.BaseOffset; 24000b57cec5SDimitry Andric if (Member->isBitField()) { 24010b57cec5SDimitry Andric uint64_t StartBitOffset = MemberOffsetInBits; 24020b57cec5SDimitry Andric if (const auto *CI = 24030b57cec5SDimitry Andric dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) { 24040b57cec5SDimitry Andric MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset; 24050b57cec5SDimitry Andric } 24060b57cec5SDimitry Andric StartBitOffset -= MemberOffsetInBits; 24070b57cec5SDimitry Andric BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(), 24080b57cec5SDimitry Andric StartBitOffset); 24090b57cec5SDimitry Andric MemberBaseType = TypeTable.writeLeafType(BFR); 24100b57cec5SDimitry Andric } 24110b57cec5SDimitry Andric uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8; 24120b57cec5SDimitry Andric DataMemberRecord DMR(Access, MemberBaseType, MemberOffsetInBytes, 24130b57cec5SDimitry Andric MemberName); 24140b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(DMR); 24150b57cec5SDimitry Andric MemberCount++; 24160b57cec5SDimitry Andric } 24170b57cec5SDimitry Andric 24180b57cec5SDimitry Andric // Create methods 24190b57cec5SDimitry Andric for (auto &MethodItr : Info.Methods) { 24200b57cec5SDimitry Andric StringRef Name = MethodItr.first->getString(); 24210b57cec5SDimitry Andric 24220b57cec5SDimitry Andric std::vector<OneMethodRecord> Methods; 24230b57cec5SDimitry Andric for (const DISubprogram *SP : MethodItr.second) { 24240b57cec5SDimitry Andric TypeIndex MethodType = getMemberFunctionType(SP, Ty); 24250b57cec5SDimitry Andric bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual; 24260b57cec5SDimitry Andric 24270b57cec5SDimitry Andric unsigned VFTableOffset = -1; 24280b57cec5SDimitry Andric if (Introduced) 24290b57cec5SDimitry Andric VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes(); 24300b57cec5SDimitry Andric 24310b57cec5SDimitry Andric Methods.push_back(OneMethodRecord( 24320b57cec5SDimitry Andric MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()), 24330b57cec5SDimitry Andric translateMethodKindFlags(SP, Introduced), 24340b57cec5SDimitry Andric translateMethodOptionFlags(SP), VFTableOffset, Name)); 24350b57cec5SDimitry Andric MemberCount++; 24360b57cec5SDimitry Andric } 24370b57cec5SDimitry Andric assert(!Methods.empty() && "Empty methods map entry"); 24380b57cec5SDimitry Andric if (Methods.size() == 1) 24390b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(Methods[0]); 24400b57cec5SDimitry Andric else { 24410b57cec5SDimitry Andric // FIXME: Make this use its own ContinuationBuilder so that 24420b57cec5SDimitry Andric // MethodOverloadList can be split correctly. 24430b57cec5SDimitry Andric MethodOverloadListRecord MOLR(Methods); 24440b57cec5SDimitry Andric TypeIndex MethodList = TypeTable.writeLeafType(MOLR); 24450b57cec5SDimitry Andric 24460b57cec5SDimitry Andric OverloadedMethodRecord OMR(Methods.size(), MethodList, Name); 24470b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(OMR); 24480b57cec5SDimitry Andric } 24490b57cec5SDimitry Andric } 24500b57cec5SDimitry Andric 24510b57cec5SDimitry Andric // Create nested classes. 24520b57cec5SDimitry Andric for (const DIType *Nested : Info.NestedTypes) { 24530b57cec5SDimitry Andric NestedTypeRecord R(getTypeIndex(Nested), Nested->getName()); 24540b57cec5SDimitry Andric ContinuationBuilder.writeMemberType(R); 24550b57cec5SDimitry Andric MemberCount++; 24560b57cec5SDimitry Andric } 24570b57cec5SDimitry Andric 24580b57cec5SDimitry Andric TypeIndex FieldTI = TypeTable.insertRecord(ContinuationBuilder); 24590b57cec5SDimitry Andric return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount, 24600b57cec5SDimitry Andric !Info.NestedTypes.empty()); 24610b57cec5SDimitry Andric } 24620b57cec5SDimitry Andric 24630b57cec5SDimitry Andric TypeIndex CodeViewDebug::getVBPTypeIndex() { 24640b57cec5SDimitry Andric if (!VBPType.getIndex()) { 24650b57cec5SDimitry Andric // Make a 'const int *' type. 24660b57cec5SDimitry Andric ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const); 24670b57cec5SDimitry Andric TypeIndex ModifiedTI = TypeTable.writeLeafType(MR); 24680b57cec5SDimitry Andric 24690b57cec5SDimitry Andric PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64 24700b57cec5SDimitry Andric : PointerKind::Near32; 24710b57cec5SDimitry Andric PointerMode PM = PointerMode::Pointer; 24720b57cec5SDimitry Andric PointerOptions PO = PointerOptions::None; 24730b57cec5SDimitry Andric PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes()); 24740b57cec5SDimitry Andric VBPType = TypeTable.writeLeafType(PR); 24750b57cec5SDimitry Andric } 24760b57cec5SDimitry Andric 24770b57cec5SDimitry Andric return VBPType; 24780b57cec5SDimitry Andric } 24790b57cec5SDimitry Andric 24800b57cec5SDimitry Andric TypeIndex CodeViewDebug::getTypeIndex(const DIType *Ty, const DIType *ClassTy) { 24810b57cec5SDimitry Andric // The null DIType is the void type. Don't try to hash it. 24820b57cec5SDimitry Andric if (!Ty) 24830b57cec5SDimitry Andric return TypeIndex::Void(); 24840b57cec5SDimitry Andric 24850b57cec5SDimitry Andric // Check if we've already translated this type. Don't try to do a 24860b57cec5SDimitry Andric // get-or-create style insertion that caches the hash lookup across the 24870b57cec5SDimitry Andric // lowerType call. It will update the TypeIndices map. 24880b57cec5SDimitry Andric auto I = TypeIndices.find({Ty, ClassTy}); 24890b57cec5SDimitry Andric if (I != TypeIndices.end()) 24900b57cec5SDimitry Andric return I->second; 24910b57cec5SDimitry Andric 24920b57cec5SDimitry Andric TypeLoweringScope S(*this); 24930b57cec5SDimitry Andric TypeIndex TI = lowerType(Ty, ClassTy); 24940b57cec5SDimitry Andric return recordTypeIndexForDINode(Ty, TI, ClassTy); 24950b57cec5SDimitry Andric } 24960b57cec5SDimitry Andric 24970b57cec5SDimitry Andric codeview::TypeIndex 24980b57cec5SDimitry Andric CodeViewDebug::getTypeIndexForThisPtr(const DIDerivedType *PtrTy, 24990b57cec5SDimitry Andric const DISubroutineType *SubroutineTy) { 25000b57cec5SDimitry Andric assert(PtrTy->getTag() == dwarf::DW_TAG_pointer_type && 25010b57cec5SDimitry Andric "this type must be a pointer type"); 25020b57cec5SDimitry Andric 25030b57cec5SDimitry Andric PointerOptions Options = PointerOptions::None; 25040b57cec5SDimitry Andric if (SubroutineTy->getFlags() & DINode::DIFlags::FlagLValueReference) 25050b57cec5SDimitry Andric Options = PointerOptions::LValueRefThisPointer; 25060b57cec5SDimitry Andric else if (SubroutineTy->getFlags() & DINode::DIFlags::FlagRValueReference) 25070b57cec5SDimitry Andric Options = PointerOptions::RValueRefThisPointer; 25080b57cec5SDimitry Andric 25090b57cec5SDimitry Andric // Check if we've already translated this type. If there is no ref qualifier 25100b57cec5SDimitry Andric // on the function then we look up this pointer type with no associated class 25110b57cec5SDimitry Andric // so that the TypeIndex for the this pointer can be shared with the type 25120b57cec5SDimitry Andric // index for other pointers to this class type. If there is a ref qualifier 25130b57cec5SDimitry Andric // then we lookup the pointer using the subroutine as the parent type. 25140b57cec5SDimitry Andric auto I = TypeIndices.find({PtrTy, SubroutineTy}); 25150b57cec5SDimitry Andric if (I != TypeIndices.end()) 25160b57cec5SDimitry Andric return I->second; 25170b57cec5SDimitry Andric 25180b57cec5SDimitry Andric TypeLoweringScope S(*this); 25190b57cec5SDimitry Andric TypeIndex TI = lowerTypePointer(PtrTy, Options); 25200b57cec5SDimitry Andric return recordTypeIndexForDINode(PtrTy, TI, SubroutineTy); 25210b57cec5SDimitry Andric } 25220b57cec5SDimitry Andric 25230b57cec5SDimitry Andric TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(const DIType *Ty) { 25240b57cec5SDimitry Andric PointerRecord PR(getTypeIndex(Ty), 25250b57cec5SDimitry Andric getPointerSizeInBytes() == 8 ? PointerKind::Near64 25260b57cec5SDimitry Andric : PointerKind::Near32, 25270b57cec5SDimitry Andric PointerMode::LValueReference, PointerOptions::None, 25280b57cec5SDimitry Andric Ty->getSizeInBits() / 8); 25290b57cec5SDimitry Andric return TypeTable.writeLeafType(PR); 25300b57cec5SDimitry Andric } 25310b57cec5SDimitry Andric 25320b57cec5SDimitry Andric TypeIndex CodeViewDebug::getCompleteTypeIndex(const DIType *Ty) { 25330b57cec5SDimitry Andric // The null DIType is the void type. Don't try to hash it. 25340b57cec5SDimitry Andric if (!Ty) 25350b57cec5SDimitry Andric return TypeIndex::Void(); 25360b57cec5SDimitry Andric 25370b57cec5SDimitry Andric // Look through typedefs when getting the complete type index. Call 25380b57cec5SDimitry Andric // getTypeIndex on the typdef to ensure that any UDTs are accumulated and are 25390b57cec5SDimitry Andric // emitted only once. 25400b57cec5SDimitry Andric if (Ty->getTag() == dwarf::DW_TAG_typedef) 25410b57cec5SDimitry Andric (void)getTypeIndex(Ty); 25420b57cec5SDimitry Andric while (Ty->getTag() == dwarf::DW_TAG_typedef) 25430b57cec5SDimitry Andric Ty = cast<DIDerivedType>(Ty)->getBaseType(); 25440b57cec5SDimitry Andric 25450b57cec5SDimitry Andric // If this is a non-record type, the complete type index is the same as the 25460b57cec5SDimitry Andric // normal type index. Just call getTypeIndex. 25470b57cec5SDimitry Andric switch (Ty->getTag()) { 25480b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 25490b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 25500b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 25510b57cec5SDimitry Andric break; 25520b57cec5SDimitry Andric default: 25530b57cec5SDimitry Andric return getTypeIndex(Ty); 25540b57cec5SDimitry Andric } 25550b57cec5SDimitry Andric 25560b57cec5SDimitry Andric const auto *CTy = cast<DICompositeType>(Ty); 25570b57cec5SDimitry Andric 25580b57cec5SDimitry Andric TypeLoweringScope S(*this); 25590b57cec5SDimitry Andric 25600b57cec5SDimitry Andric // Make sure the forward declaration is emitted first. It's unclear if this 25610b57cec5SDimitry Andric // is necessary, but MSVC does it, and we should follow suit until we can show 25620b57cec5SDimitry Andric // otherwise. 25630b57cec5SDimitry Andric // We only emit a forward declaration for named types. 25640b57cec5SDimitry Andric if (!CTy->getName().empty() || !CTy->getIdentifier().empty()) { 25650b57cec5SDimitry Andric TypeIndex FwdDeclTI = getTypeIndex(CTy); 25660b57cec5SDimitry Andric 25670b57cec5SDimitry Andric // Just use the forward decl if we don't have complete type info. This 25680b57cec5SDimitry Andric // might happen if the frontend is using modules and expects the complete 25690b57cec5SDimitry Andric // definition to be emitted elsewhere. 25700b57cec5SDimitry Andric if (CTy->isForwardDecl()) 25710b57cec5SDimitry Andric return FwdDeclTI; 25720b57cec5SDimitry Andric } 25730b57cec5SDimitry Andric 25740b57cec5SDimitry Andric // Check if we've already translated the complete record type. 25750b57cec5SDimitry Andric // Insert the type with a null TypeIndex to signify that the type is currently 25760b57cec5SDimitry Andric // being lowered. 25770b57cec5SDimitry Andric auto InsertResult = CompleteTypeIndices.insert({CTy, TypeIndex()}); 25780b57cec5SDimitry Andric if (!InsertResult.second) 25790b57cec5SDimitry Andric return InsertResult.first->second; 25800b57cec5SDimitry Andric 25810b57cec5SDimitry Andric TypeIndex TI; 25820b57cec5SDimitry Andric switch (CTy->getTag()) { 25830b57cec5SDimitry Andric case dwarf::DW_TAG_class_type: 25840b57cec5SDimitry Andric case dwarf::DW_TAG_structure_type: 25850b57cec5SDimitry Andric TI = lowerCompleteTypeClass(CTy); 25860b57cec5SDimitry Andric break; 25870b57cec5SDimitry Andric case dwarf::DW_TAG_union_type: 25880b57cec5SDimitry Andric TI = lowerCompleteTypeUnion(CTy); 25890b57cec5SDimitry Andric break; 25900b57cec5SDimitry Andric default: 25910b57cec5SDimitry Andric llvm_unreachable("not a record"); 25920b57cec5SDimitry Andric } 25930b57cec5SDimitry Andric 25940b57cec5SDimitry Andric // Update the type index associated with this CompositeType. This cannot 25950b57cec5SDimitry Andric // use the 'InsertResult' iterator above because it is potentially 25960b57cec5SDimitry Andric // invalidated by map insertions which can occur while lowering the class 25970b57cec5SDimitry Andric // type above. 25980b57cec5SDimitry Andric CompleteTypeIndices[CTy] = TI; 25990b57cec5SDimitry Andric return TI; 26000b57cec5SDimitry Andric } 26010b57cec5SDimitry Andric 26020b57cec5SDimitry Andric /// Emit all the deferred complete record types. Try to do this in FIFO order, 26030b57cec5SDimitry Andric /// and do this until fixpoint, as each complete record type typically 26040b57cec5SDimitry Andric /// references 26050b57cec5SDimitry Andric /// many other record types. 26060b57cec5SDimitry Andric void CodeViewDebug::emitDeferredCompleteTypes() { 26070b57cec5SDimitry Andric SmallVector<const DICompositeType *, 4> TypesToEmit; 26080b57cec5SDimitry Andric while (!DeferredCompleteTypes.empty()) { 26090b57cec5SDimitry Andric std::swap(DeferredCompleteTypes, TypesToEmit); 26100b57cec5SDimitry Andric for (const DICompositeType *RecordTy : TypesToEmit) 26110b57cec5SDimitry Andric getCompleteTypeIndex(RecordTy); 26120b57cec5SDimitry Andric TypesToEmit.clear(); 26130b57cec5SDimitry Andric } 26140b57cec5SDimitry Andric } 26150b57cec5SDimitry Andric 26160b57cec5SDimitry Andric void CodeViewDebug::emitLocalVariableList(const FunctionInfo &FI, 26170b57cec5SDimitry Andric ArrayRef<LocalVariable> Locals) { 26180b57cec5SDimitry Andric // Get the sorted list of parameters and emit them first. 26190b57cec5SDimitry Andric SmallVector<const LocalVariable *, 6> Params; 26200b57cec5SDimitry Andric for (const LocalVariable &L : Locals) 26210b57cec5SDimitry Andric if (L.DIVar->isParameter()) 26220b57cec5SDimitry Andric Params.push_back(&L); 26230b57cec5SDimitry Andric llvm::sort(Params, [](const LocalVariable *L, const LocalVariable *R) { 26240b57cec5SDimitry Andric return L->DIVar->getArg() < R->DIVar->getArg(); 26250b57cec5SDimitry Andric }); 26260b57cec5SDimitry Andric for (const LocalVariable *L : Params) 26270b57cec5SDimitry Andric emitLocalVariable(FI, *L); 26280b57cec5SDimitry Andric 26290b57cec5SDimitry Andric // Next emit all non-parameters in the order that we found them. 26300b57cec5SDimitry Andric for (const LocalVariable &L : Locals) 26310b57cec5SDimitry Andric if (!L.DIVar->isParameter()) 26320b57cec5SDimitry Andric emitLocalVariable(FI, L); 26330b57cec5SDimitry Andric } 26340b57cec5SDimitry Andric 26350b57cec5SDimitry Andric void CodeViewDebug::emitLocalVariable(const FunctionInfo &FI, 26360b57cec5SDimitry Andric const LocalVariable &Var) { 26370b57cec5SDimitry Andric // LocalSym record, see SymbolRecord.h for more info. 26380b57cec5SDimitry Andric MCSymbol *LocalEnd = beginSymbolRecord(SymbolKind::S_LOCAL); 26390b57cec5SDimitry Andric 26400b57cec5SDimitry Andric LocalSymFlags Flags = LocalSymFlags::None; 26410b57cec5SDimitry Andric if (Var.DIVar->isParameter()) 26420b57cec5SDimitry Andric Flags |= LocalSymFlags::IsParameter; 26430b57cec5SDimitry Andric if (Var.DefRanges.empty()) 26440b57cec5SDimitry Andric Flags |= LocalSymFlags::IsOptimizedOut; 26450b57cec5SDimitry Andric 26460b57cec5SDimitry Andric OS.AddComment("TypeIndex"); 26470b57cec5SDimitry Andric TypeIndex TI = Var.UseReferenceType 26480b57cec5SDimitry Andric ? getTypeIndexForReferenceTo(Var.DIVar->getType()) 26490b57cec5SDimitry Andric : getCompleteTypeIndex(Var.DIVar->getType()); 26505ffd83dbSDimitry Andric OS.emitInt32(TI.getIndex()); 26510b57cec5SDimitry Andric OS.AddComment("Flags"); 26525ffd83dbSDimitry Andric OS.emitInt16(static_cast<uint16_t>(Flags)); 26530b57cec5SDimitry Andric // Truncate the name so we won't overflow the record length field. 26540b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, Var.DIVar->getName()); 26550b57cec5SDimitry Andric endSymbolRecord(LocalEnd); 26560b57cec5SDimitry Andric 26570b57cec5SDimitry Andric // Calculate the on disk prefix of the appropriate def range record. The 26580b57cec5SDimitry Andric // records and on disk formats are described in SymbolRecords.h. BytePrefix 26590b57cec5SDimitry Andric // should be big enough to hold all forms without memory allocation. 26600b57cec5SDimitry Andric SmallString<20> BytePrefix; 26610b57cec5SDimitry Andric for (const LocalVarDefRange &DefRange : Var.DefRanges) { 26620b57cec5SDimitry Andric BytePrefix.clear(); 26630b57cec5SDimitry Andric if (DefRange.InMemory) { 26640b57cec5SDimitry Andric int Offset = DefRange.DataOffset; 26650b57cec5SDimitry Andric unsigned Reg = DefRange.CVRegister; 26660b57cec5SDimitry Andric 26670b57cec5SDimitry Andric // 32-bit x86 call sequences often use PUSH instructions, which disrupt 26680b57cec5SDimitry Andric // ESP-relative offsets. Use the virtual frame pointer, VFRAME or $T0, 26690b57cec5SDimitry Andric // instead. In frames without stack realignment, $T0 will be the CFA. 26700b57cec5SDimitry Andric if (RegisterId(Reg) == RegisterId::ESP) { 26710b57cec5SDimitry Andric Reg = unsigned(RegisterId::VFRAME); 26720b57cec5SDimitry Andric Offset += FI.OffsetAdjustment; 26730b57cec5SDimitry Andric } 26740b57cec5SDimitry Andric 26750b57cec5SDimitry Andric // If we can use the chosen frame pointer for the frame and this isn't a 26760b57cec5SDimitry Andric // sliced aggregate, use the smaller S_DEFRANGE_FRAMEPOINTER_REL record. 26770b57cec5SDimitry Andric // Otherwise, use S_DEFRANGE_REGISTER_REL. 26780b57cec5SDimitry Andric EncodedFramePtrReg EncFP = encodeFramePtrReg(RegisterId(Reg), TheCPU); 26790b57cec5SDimitry Andric if (!DefRange.IsSubfield && EncFP != EncodedFramePtrReg::None && 26800b57cec5SDimitry Andric (bool(Flags & LocalSymFlags::IsParameter) 26810b57cec5SDimitry Andric ? (EncFP == FI.EncodedParamFramePtrReg) 26820b57cec5SDimitry Andric : (EncFP == FI.EncodedLocalFramePtrReg))) { 26838bcb0991SDimitry Andric DefRangeFramePointerRelHeader DRHdr; 26848bcb0991SDimitry Andric DRHdr.Offset = Offset; 26855ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 26860b57cec5SDimitry Andric } else { 26870b57cec5SDimitry Andric uint16_t RegRelFlags = 0; 26880b57cec5SDimitry Andric if (DefRange.IsSubfield) { 26890b57cec5SDimitry Andric RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag | 26900b57cec5SDimitry Andric (DefRange.StructOffset 26910b57cec5SDimitry Andric << DefRangeRegisterRelSym::OffsetInParentShift); 26920b57cec5SDimitry Andric } 26938bcb0991SDimitry Andric DefRangeRegisterRelHeader DRHdr; 26940b57cec5SDimitry Andric DRHdr.Register = Reg; 26950b57cec5SDimitry Andric DRHdr.Flags = RegRelFlags; 26960b57cec5SDimitry Andric DRHdr.BasePointerOffset = Offset; 26975ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 26980b57cec5SDimitry Andric } 26990b57cec5SDimitry Andric } else { 27000b57cec5SDimitry Andric assert(DefRange.DataOffset == 0 && "unexpected offset into register"); 27010b57cec5SDimitry Andric if (DefRange.IsSubfield) { 27028bcb0991SDimitry Andric DefRangeSubfieldRegisterHeader DRHdr; 27030b57cec5SDimitry Andric DRHdr.Register = DefRange.CVRegister; 27040b57cec5SDimitry Andric DRHdr.MayHaveNoName = 0; 27050b57cec5SDimitry Andric DRHdr.OffsetInParent = DefRange.StructOffset; 27065ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 27070b57cec5SDimitry Andric } else { 27088bcb0991SDimitry Andric DefRangeRegisterHeader DRHdr; 27090b57cec5SDimitry Andric DRHdr.Register = DefRange.CVRegister; 27100b57cec5SDimitry Andric DRHdr.MayHaveNoName = 0; 27115ffd83dbSDimitry Andric OS.emitCVDefRangeDirective(DefRange.Ranges, DRHdr); 27120b57cec5SDimitry Andric } 27130b57cec5SDimitry Andric } 27140b57cec5SDimitry Andric } 27150b57cec5SDimitry Andric } 27160b57cec5SDimitry Andric 27170b57cec5SDimitry Andric void CodeViewDebug::emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks, 27180b57cec5SDimitry Andric const FunctionInfo& FI) { 27190b57cec5SDimitry Andric for (LexicalBlock *Block : Blocks) 27200b57cec5SDimitry Andric emitLexicalBlock(*Block, FI); 27210b57cec5SDimitry Andric } 27220b57cec5SDimitry Andric 27230b57cec5SDimitry Andric /// Emit an S_BLOCK32 and S_END record pair delimiting the contents of a 27240b57cec5SDimitry Andric /// lexical block scope. 27250b57cec5SDimitry Andric void CodeViewDebug::emitLexicalBlock(const LexicalBlock &Block, 27260b57cec5SDimitry Andric const FunctionInfo& FI) { 27270b57cec5SDimitry Andric MCSymbol *RecordEnd = beginSymbolRecord(SymbolKind::S_BLOCK32); 27280b57cec5SDimitry Andric OS.AddComment("PtrParent"); 27295ffd83dbSDimitry Andric OS.emitInt32(0); // PtrParent 27300b57cec5SDimitry Andric OS.AddComment("PtrEnd"); 27315ffd83dbSDimitry Andric OS.emitInt32(0); // PtrEnd 27320b57cec5SDimitry Andric OS.AddComment("Code size"); 27330b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(Block.End, Block.Begin, 4); // Code Size 27340b57cec5SDimitry Andric OS.AddComment("Function section relative address"); 27350b57cec5SDimitry Andric OS.EmitCOFFSecRel32(Block.Begin, /*Offset=*/0); // Func Offset 27360b57cec5SDimitry Andric OS.AddComment("Function section index"); 27370b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(FI.Begin); // Func Symbol 27380b57cec5SDimitry Andric OS.AddComment("Lexical block name"); 27390b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, Block.Name); // Name 27400b57cec5SDimitry Andric endSymbolRecord(RecordEnd); 27410b57cec5SDimitry Andric 27420b57cec5SDimitry Andric // Emit variables local to this lexical block. 27430b57cec5SDimitry Andric emitLocalVariableList(FI, Block.Locals); 27440b57cec5SDimitry Andric emitGlobalVariableList(Block.Globals); 27450b57cec5SDimitry Andric 27460b57cec5SDimitry Andric // Emit lexical blocks contained within this block. 27470b57cec5SDimitry Andric emitLexicalBlockList(Block.Children, FI); 27480b57cec5SDimitry Andric 27490b57cec5SDimitry Andric // Close the lexical block scope. 27500b57cec5SDimitry Andric emitEndSymbolRecord(SymbolKind::S_END); 27510b57cec5SDimitry Andric } 27520b57cec5SDimitry Andric 27530b57cec5SDimitry Andric /// Convenience routine for collecting lexical block information for a list 27540b57cec5SDimitry Andric /// of lexical scopes. 27550b57cec5SDimitry Andric void CodeViewDebug::collectLexicalBlockInfo( 27560b57cec5SDimitry Andric SmallVectorImpl<LexicalScope *> &Scopes, 27570b57cec5SDimitry Andric SmallVectorImpl<LexicalBlock *> &Blocks, 27580b57cec5SDimitry Andric SmallVectorImpl<LocalVariable> &Locals, 27590b57cec5SDimitry Andric SmallVectorImpl<CVGlobalVariable> &Globals) { 27600b57cec5SDimitry Andric for (LexicalScope *Scope : Scopes) 27610b57cec5SDimitry Andric collectLexicalBlockInfo(*Scope, Blocks, Locals, Globals); 27620b57cec5SDimitry Andric } 27630b57cec5SDimitry Andric 27640b57cec5SDimitry Andric /// Populate the lexical blocks and local variable lists of the parent with 27650b57cec5SDimitry Andric /// information about the specified lexical scope. 27660b57cec5SDimitry Andric void CodeViewDebug::collectLexicalBlockInfo( 27670b57cec5SDimitry Andric LexicalScope &Scope, 27680b57cec5SDimitry Andric SmallVectorImpl<LexicalBlock *> &ParentBlocks, 27690b57cec5SDimitry Andric SmallVectorImpl<LocalVariable> &ParentLocals, 27700b57cec5SDimitry Andric SmallVectorImpl<CVGlobalVariable> &ParentGlobals) { 27710b57cec5SDimitry Andric if (Scope.isAbstractScope()) 27720b57cec5SDimitry Andric return; 27730b57cec5SDimitry Andric 27740b57cec5SDimitry Andric // Gather information about the lexical scope including local variables, 27750b57cec5SDimitry Andric // global variables, and address ranges. 27760b57cec5SDimitry Andric bool IgnoreScope = false; 27770b57cec5SDimitry Andric auto LI = ScopeVariables.find(&Scope); 27780b57cec5SDimitry Andric SmallVectorImpl<LocalVariable> *Locals = 27790b57cec5SDimitry Andric LI != ScopeVariables.end() ? &LI->second : nullptr; 27800b57cec5SDimitry Andric auto GI = ScopeGlobals.find(Scope.getScopeNode()); 27810b57cec5SDimitry Andric SmallVectorImpl<CVGlobalVariable> *Globals = 27820b57cec5SDimitry Andric GI != ScopeGlobals.end() ? GI->second.get() : nullptr; 27830b57cec5SDimitry Andric const DILexicalBlock *DILB = dyn_cast<DILexicalBlock>(Scope.getScopeNode()); 27840b57cec5SDimitry Andric const SmallVectorImpl<InsnRange> &Ranges = Scope.getRanges(); 27850b57cec5SDimitry Andric 27860b57cec5SDimitry Andric // Ignore lexical scopes which do not contain variables. 27870b57cec5SDimitry Andric if (!Locals && !Globals) 27880b57cec5SDimitry Andric IgnoreScope = true; 27890b57cec5SDimitry Andric 27900b57cec5SDimitry Andric // Ignore lexical scopes which are not lexical blocks. 27910b57cec5SDimitry Andric if (!DILB) 27920b57cec5SDimitry Andric IgnoreScope = true; 27930b57cec5SDimitry Andric 27940b57cec5SDimitry Andric // Ignore scopes which have too many address ranges to represent in the 27950b57cec5SDimitry Andric // current CodeView format or do not have a valid address range. 27960b57cec5SDimitry Andric // 27970b57cec5SDimitry Andric // For lexical scopes with multiple address ranges you may be tempted to 27980b57cec5SDimitry Andric // construct a single range covering every instruction where the block is 27990b57cec5SDimitry Andric // live and everything in between. Unfortunately, Visual Studio only 28000b57cec5SDimitry Andric // displays variables from the first matching lexical block scope. If the 28010b57cec5SDimitry Andric // first lexical block contains exception handling code or cold code which 28020b57cec5SDimitry Andric // is moved to the bottom of the routine creating a single range covering 28030b57cec5SDimitry Andric // nearly the entire routine, then it will hide all other lexical blocks 28040b57cec5SDimitry Andric // and the variables they contain. 28050b57cec5SDimitry Andric if (Ranges.size() != 1 || !getLabelAfterInsn(Ranges.front().second)) 28060b57cec5SDimitry Andric IgnoreScope = true; 28070b57cec5SDimitry Andric 28080b57cec5SDimitry Andric if (IgnoreScope) { 28090b57cec5SDimitry Andric // This scope can be safely ignored and eliminating it will reduce the 28100b57cec5SDimitry Andric // size of the debug information. Be sure to collect any variable and scope 28110b57cec5SDimitry Andric // information from the this scope or any of its children and collapse them 28120b57cec5SDimitry Andric // into the parent scope. 28130b57cec5SDimitry Andric if (Locals) 28140b57cec5SDimitry Andric ParentLocals.append(Locals->begin(), Locals->end()); 28150b57cec5SDimitry Andric if (Globals) 28160b57cec5SDimitry Andric ParentGlobals.append(Globals->begin(), Globals->end()); 28170b57cec5SDimitry Andric collectLexicalBlockInfo(Scope.getChildren(), 28180b57cec5SDimitry Andric ParentBlocks, 28190b57cec5SDimitry Andric ParentLocals, 28200b57cec5SDimitry Andric ParentGlobals); 28210b57cec5SDimitry Andric return; 28220b57cec5SDimitry Andric } 28230b57cec5SDimitry Andric 28240b57cec5SDimitry Andric // Create a new CodeView lexical block for this lexical scope. If we've 28250b57cec5SDimitry Andric // seen this DILexicalBlock before then the scope tree is malformed and 28260b57cec5SDimitry Andric // we can handle this gracefully by not processing it a second time. 28270b57cec5SDimitry Andric auto BlockInsertion = CurFn->LexicalBlocks.insert({DILB, LexicalBlock()}); 28280b57cec5SDimitry Andric if (!BlockInsertion.second) 28290b57cec5SDimitry Andric return; 28300b57cec5SDimitry Andric 28310b57cec5SDimitry Andric // Create a lexical block containing the variables and collect the the 28320b57cec5SDimitry Andric // lexical block information for the children. 28330b57cec5SDimitry Andric const InsnRange &Range = Ranges.front(); 28340b57cec5SDimitry Andric assert(Range.first && Range.second); 28350b57cec5SDimitry Andric LexicalBlock &Block = BlockInsertion.first->second; 28360b57cec5SDimitry Andric Block.Begin = getLabelBeforeInsn(Range.first); 28370b57cec5SDimitry Andric Block.End = getLabelAfterInsn(Range.second); 28380b57cec5SDimitry Andric assert(Block.Begin && "missing label for scope begin"); 28390b57cec5SDimitry Andric assert(Block.End && "missing label for scope end"); 28400b57cec5SDimitry Andric Block.Name = DILB->getName(); 28410b57cec5SDimitry Andric if (Locals) 28420b57cec5SDimitry Andric Block.Locals = std::move(*Locals); 28430b57cec5SDimitry Andric if (Globals) 28440b57cec5SDimitry Andric Block.Globals = std::move(*Globals); 28450b57cec5SDimitry Andric ParentBlocks.push_back(&Block); 28460b57cec5SDimitry Andric collectLexicalBlockInfo(Scope.getChildren(), 28470b57cec5SDimitry Andric Block.Children, 28480b57cec5SDimitry Andric Block.Locals, 28490b57cec5SDimitry Andric Block.Globals); 28500b57cec5SDimitry Andric } 28510b57cec5SDimitry Andric 28520b57cec5SDimitry Andric void CodeViewDebug::endFunctionImpl(const MachineFunction *MF) { 28530b57cec5SDimitry Andric const Function &GV = MF->getFunction(); 28540b57cec5SDimitry Andric assert(FnDebugInfo.count(&GV)); 28550b57cec5SDimitry Andric assert(CurFn == FnDebugInfo[&GV].get()); 28560b57cec5SDimitry Andric 28570b57cec5SDimitry Andric collectVariableInfo(GV.getSubprogram()); 28580b57cec5SDimitry Andric 28590b57cec5SDimitry Andric // Build the lexical block structure to emit for this routine. 28600b57cec5SDimitry Andric if (LexicalScope *CFS = LScopes.getCurrentFunctionScope()) 28610b57cec5SDimitry Andric collectLexicalBlockInfo(*CFS, 28620b57cec5SDimitry Andric CurFn->ChildBlocks, 28630b57cec5SDimitry Andric CurFn->Locals, 28640b57cec5SDimitry Andric CurFn->Globals); 28650b57cec5SDimitry Andric 28660b57cec5SDimitry Andric // Clear the scope and variable information from the map which will not be 28670b57cec5SDimitry Andric // valid after we have finished processing this routine. This also prepares 28680b57cec5SDimitry Andric // the map for the subsequent routine. 28690b57cec5SDimitry Andric ScopeVariables.clear(); 28700b57cec5SDimitry Andric 28710b57cec5SDimitry Andric // Don't emit anything if we don't have any line tables. 28720b57cec5SDimitry Andric // Thunks are compiler-generated and probably won't have source correlation. 28730b57cec5SDimitry Andric if (!CurFn->HaveLineInfo && !GV.getSubprogram()->isThunk()) { 28740b57cec5SDimitry Andric FnDebugInfo.erase(&GV); 28750b57cec5SDimitry Andric CurFn = nullptr; 28760b57cec5SDimitry Andric return; 28770b57cec5SDimitry Andric } 28780b57cec5SDimitry Andric 2879480093f4SDimitry Andric // Find heap alloc sites and add to list. 2880480093f4SDimitry Andric for (const auto &MBB : *MF) { 2881480093f4SDimitry Andric for (const auto &MI : MBB) { 2882480093f4SDimitry Andric if (MDNode *MD = MI.getHeapAllocMarker()) { 2883480093f4SDimitry Andric CurFn->HeapAllocSites.push_back(std::make_tuple(getLabelBeforeInsn(&MI), 2884480093f4SDimitry Andric getLabelAfterInsn(&MI), 2885480093f4SDimitry Andric dyn_cast<DIType>(MD))); 2886480093f4SDimitry Andric } 2887480093f4SDimitry Andric } 2888480093f4SDimitry Andric } 2889480093f4SDimitry Andric 28900b57cec5SDimitry Andric CurFn->Annotations = MF->getCodeViewAnnotations(); 28910b57cec5SDimitry Andric 28920b57cec5SDimitry Andric CurFn->End = Asm->getFunctionEnd(); 28930b57cec5SDimitry Andric 28940b57cec5SDimitry Andric CurFn = nullptr; 28950b57cec5SDimitry Andric } 28960b57cec5SDimitry Andric 28978bcb0991SDimitry Andric // Usable locations are valid with non-zero line numbers. A line number of zero 28988bcb0991SDimitry Andric // corresponds to optimized code that doesn't have a distinct source location. 28998bcb0991SDimitry Andric // In this case, we try to use the previous or next source location depending on 29008bcb0991SDimitry Andric // the context. 29018bcb0991SDimitry Andric static bool isUsableDebugLoc(DebugLoc DL) { 29028bcb0991SDimitry Andric return DL && DL.getLine() != 0; 29038bcb0991SDimitry Andric } 29048bcb0991SDimitry Andric 29050b57cec5SDimitry Andric void CodeViewDebug::beginInstruction(const MachineInstr *MI) { 29060b57cec5SDimitry Andric DebugHandlerBase::beginInstruction(MI); 29070b57cec5SDimitry Andric 29080b57cec5SDimitry Andric // Ignore DBG_VALUE and DBG_LABEL locations and function prologue. 29090b57cec5SDimitry Andric if (!Asm || !CurFn || MI->isDebugInstr() || 29100b57cec5SDimitry Andric MI->getFlag(MachineInstr::FrameSetup)) 29110b57cec5SDimitry Andric return; 29120b57cec5SDimitry Andric 29130b57cec5SDimitry Andric // If the first instruction of a new MBB has no location, find the first 29140b57cec5SDimitry Andric // instruction with a location and use that. 29150b57cec5SDimitry Andric DebugLoc DL = MI->getDebugLoc(); 29168bcb0991SDimitry Andric if (!isUsableDebugLoc(DL) && MI->getParent() != PrevInstBB) { 29170b57cec5SDimitry Andric for (const auto &NextMI : *MI->getParent()) { 29180b57cec5SDimitry Andric if (NextMI.isDebugInstr()) 29190b57cec5SDimitry Andric continue; 29200b57cec5SDimitry Andric DL = NextMI.getDebugLoc(); 29218bcb0991SDimitry Andric if (isUsableDebugLoc(DL)) 29220b57cec5SDimitry Andric break; 29230b57cec5SDimitry Andric } 29248bcb0991SDimitry Andric // FIXME: Handle the case where the BB has no valid locations. This would 29258bcb0991SDimitry Andric // probably require doing a real dataflow analysis. 29260b57cec5SDimitry Andric } 29270b57cec5SDimitry Andric PrevInstBB = MI->getParent(); 29280b57cec5SDimitry Andric 29290b57cec5SDimitry Andric // If we still don't have a debug location, don't record a location. 29308bcb0991SDimitry Andric if (!isUsableDebugLoc(DL)) 29310b57cec5SDimitry Andric return; 29320b57cec5SDimitry Andric 29330b57cec5SDimitry Andric maybeRecordLocation(DL, Asm->MF); 29340b57cec5SDimitry Andric } 29350b57cec5SDimitry Andric 29360b57cec5SDimitry Andric MCSymbol *CodeViewDebug::beginCVSubsection(DebugSubsectionKind Kind) { 29370b57cec5SDimitry Andric MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(), 29380b57cec5SDimitry Andric *EndLabel = MMI->getContext().createTempSymbol(); 29395ffd83dbSDimitry Andric OS.emitInt32(unsigned(Kind)); 29400b57cec5SDimitry Andric OS.AddComment("Subsection size"); 29410b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4); 29425ffd83dbSDimitry Andric OS.emitLabel(BeginLabel); 29430b57cec5SDimitry Andric return EndLabel; 29440b57cec5SDimitry Andric } 29450b57cec5SDimitry Andric 29460b57cec5SDimitry Andric void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) { 29475ffd83dbSDimitry Andric OS.emitLabel(EndLabel); 29480b57cec5SDimitry Andric // Every subsection must be aligned to a 4-byte boundary. 29495ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 29500b57cec5SDimitry Andric } 29510b57cec5SDimitry Andric 29520b57cec5SDimitry Andric static StringRef getSymbolName(SymbolKind SymKind) { 29530b57cec5SDimitry Andric for (const EnumEntry<SymbolKind> &EE : getSymbolTypeNames()) 29540b57cec5SDimitry Andric if (EE.Value == SymKind) 29550b57cec5SDimitry Andric return EE.Name; 29560b57cec5SDimitry Andric return ""; 29570b57cec5SDimitry Andric } 29580b57cec5SDimitry Andric 29590b57cec5SDimitry Andric MCSymbol *CodeViewDebug::beginSymbolRecord(SymbolKind SymKind) { 29600b57cec5SDimitry Andric MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(), 29610b57cec5SDimitry Andric *EndLabel = MMI->getContext().createTempSymbol(); 29620b57cec5SDimitry Andric OS.AddComment("Record length"); 29630b57cec5SDimitry Andric OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 2); 29645ffd83dbSDimitry Andric OS.emitLabel(BeginLabel); 29650b57cec5SDimitry Andric if (OS.isVerboseAsm()) 29660b57cec5SDimitry Andric OS.AddComment("Record kind: " + getSymbolName(SymKind)); 29675ffd83dbSDimitry Andric OS.emitInt16(unsigned(SymKind)); 29680b57cec5SDimitry Andric return EndLabel; 29690b57cec5SDimitry Andric } 29700b57cec5SDimitry Andric 29710b57cec5SDimitry Andric void CodeViewDebug::endSymbolRecord(MCSymbol *SymEnd) { 29720b57cec5SDimitry Andric // MSVC does not pad out symbol records to four bytes, but LLVM does to avoid 29730b57cec5SDimitry Andric // an extra copy of every symbol record in LLD. This increases object file 29740b57cec5SDimitry Andric // size by less than 1% in the clang build, and is compatible with the Visual 29750b57cec5SDimitry Andric // C++ linker. 29765ffd83dbSDimitry Andric OS.emitValueToAlignment(4); 29775ffd83dbSDimitry Andric OS.emitLabel(SymEnd); 29780b57cec5SDimitry Andric } 29790b57cec5SDimitry Andric 29800b57cec5SDimitry Andric void CodeViewDebug::emitEndSymbolRecord(SymbolKind EndKind) { 29810b57cec5SDimitry Andric OS.AddComment("Record length"); 29825ffd83dbSDimitry Andric OS.emitInt16(2); 29830b57cec5SDimitry Andric if (OS.isVerboseAsm()) 29840b57cec5SDimitry Andric OS.AddComment("Record kind: " + getSymbolName(EndKind)); 29855ffd83dbSDimitry Andric OS.emitInt16(uint16_t(EndKind)); // Record Kind 29860b57cec5SDimitry Andric } 29870b57cec5SDimitry Andric 29880b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForUDTs( 29895ffd83dbSDimitry Andric const std::vector<std::pair<std::string, const DIType *>> &UDTs) { 29905ffd83dbSDimitry Andric #ifndef NDEBUG 29915ffd83dbSDimitry Andric size_t OriginalSize = UDTs.size(); 29925ffd83dbSDimitry Andric #endif 29930b57cec5SDimitry Andric for (const auto &UDT : UDTs) { 29940b57cec5SDimitry Andric const DIType *T = UDT.second; 29950b57cec5SDimitry Andric assert(shouldEmitUdt(T)); 29960b57cec5SDimitry Andric MCSymbol *UDTRecordEnd = beginSymbolRecord(SymbolKind::S_UDT); 29970b57cec5SDimitry Andric OS.AddComment("Type"); 29985ffd83dbSDimitry Andric OS.emitInt32(getCompleteTypeIndex(T).getIndex()); 29995ffd83dbSDimitry Andric assert(OriginalSize == UDTs.size() && 30005ffd83dbSDimitry Andric "getCompleteTypeIndex found new UDTs!"); 30010b57cec5SDimitry Andric emitNullTerminatedSymbolName(OS, UDT.first); 30020b57cec5SDimitry Andric endSymbolRecord(UDTRecordEnd); 30030b57cec5SDimitry Andric } 30040b57cec5SDimitry Andric } 30050b57cec5SDimitry Andric 30060b57cec5SDimitry Andric void CodeViewDebug::collectGlobalVariableInfo() { 30070b57cec5SDimitry Andric DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *> 30080b57cec5SDimitry Andric GlobalMap; 30090b57cec5SDimitry Andric for (const GlobalVariable &GV : MMI->getModule()->globals()) { 30100b57cec5SDimitry Andric SmallVector<DIGlobalVariableExpression *, 1> GVEs; 30110b57cec5SDimitry Andric GV.getDebugInfo(GVEs); 30120b57cec5SDimitry Andric for (const auto *GVE : GVEs) 30130b57cec5SDimitry Andric GlobalMap[GVE] = &GV; 30140b57cec5SDimitry Andric } 30150b57cec5SDimitry Andric 30160b57cec5SDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 30170b57cec5SDimitry Andric for (const MDNode *Node : CUs->operands()) { 30180b57cec5SDimitry Andric const auto *CU = cast<DICompileUnit>(Node); 30190b57cec5SDimitry Andric for (const auto *GVE : CU->getGlobalVariables()) { 30200b57cec5SDimitry Andric const DIGlobalVariable *DIGV = GVE->getVariable(); 30210b57cec5SDimitry Andric const DIExpression *DIE = GVE->getExpression(); 30220b57cec5SDimitry Andric 30230b57cec5SDimitry Andric // Emit constant global variables in a global symbol section. 30240b57cec5SDimitry Andric if (GlobalMap.count(GVE) == 0 && DIE->isConstant()) { 30250b57cec5SDimitry Andric CVGlobalVariable CVGV = {DIGV, DIE}; 30260b57cec5SDimitry Andric GlobalVariables.emplace_back(std::move(CVGV)); 30270b57cec5SDimitry Andric } 30280b57cec5SDimitry Andric 30290b57cec5SDimitry Andric const auto *GV = GlobalMap.lookup(GVE); 30300b57cec5SDimitry Andric if (!GV || GV->isDeclarationForLinker()) 30310b57cec5SDimitry Andric continue; 30320b57cec5SDimitry Andric 30330b57cec5SDimitry Andric DIScope *Scope = DIGV->getScope(); 30340b57cec5SDimitry Andric SmallVector<CVGlobalVariable, 1> *VariableList; 30350b57cec5SDimitry Andric if (Scope && isa<DILocalScope>(Scope)) { 30360b57cec5SDimitry Andric // Locate a global variable list for this scope, creating one if 30370b57cec5SDimitry Andric // necessary. 30380b57cec5SDimitry Andric auto Insertion = ScopeGlobals.insert( 30390b57cec5SDimitry Andric {Scope, std::unique_ptr<GlobalVariableList>()}); 30400b57cec5SDimitry Andric if (Insertion.second) 30418bcb0991SDimitry Andric Insertion.first->second = std::make_unique<GlobalVariableList>(); 30420b57cec5SDimitry Andric VariableList = Insertion.first->second.get(); 30430b57cec5SDimitry Andric } else if (GV->hasComdat()) 30440b57cec5SDimitry Andric // Emit this global variable into a COMDAT section. 30450b57cec5SDimitry Andric VariableList = &ComdatVariables; 30460b57cec5SDimitry Andric else 30470b57cec5SDimitry Andric // Emit this global variable in a single global symbol section. 30480b57cec5SDimitry Andric VariableList = &GlobalVariables; 30490b57cec5SDimitry Andric CVGlobalVariable CVGV = {DIGV, GV}; 30500b57cec5SDimitry Andric VariableList->emplace_back(std::move(CVGV)); 30510b57cec5SDimitry Andric } 30520b57cec5SDimitry Andric } 30530b57cec5SDimitry Andric } 30540b57cec5SDimitry Andric 30550b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForGlobals() { 30560b57cec5SDimitry Andric // First, emit all globals that are not in a comdat in a single symbol 30570b57cec5SDimitry Andric // substream. MSVC doesn't like it if the substream is empty, so only open 30580b57cec5SDimitry Andric // it if we have at least one global to emit. 30590b57cec5SDimitry Andric switchToDebugSectionForSymbol(nullptr); 30600b57cec5SDimitry Andric if (!GlobalVariables.empty()) { 30610b57cec5SDimitry Andric OS.AddComment("Symbol subsection for globals"); 30620b57cec5SDimitry Andric MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols); 30630b57cec5SDimitry Andric emitGlobalVariableList(GlobalVariables); 30640b57cec5SDimitry Andric endCVSubsection(EndLabel); 30650b57cec5SDimitry Andric } 30660b57cec5SDimitry Andric 30670b57cec5SDimitry Andric // Second, emit each global that is in a comdat into its own .debug$S 30680b57cec5SDimitry Andric // section along with its own symbol substream. 30690b57cec5SDimitry Andric for (const CVGlobalVariable &CVGV : ComdatVariables) { 30700b57cec5SDimitry Andric const GlobalVariable *GV = CVGV.GVInfo.get<const GlobalVariable *>(); 30710b57cec5SDimitry Andric MCSymbol *GVSym = Asm->getSymbol(GV); 30720b57cec5SDimitry Andric OS.AddComment("Symbol subsection for " + 30730b57cec5SDimitry Andric Twine(GlobalValue::dropLLVMManglingEscape(GV->getName()))); 30740b57cec5SDimitry Andric switchToDebugSectionForSymbol(GVSym); 30750b57cec5SDimitry Andric MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols); 30760b57cec5SDimitry Andric // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions. 30770b57cec5SDimitry Andric emitDebugInfoForGlobal(CVGV); 30780b57cec5SDimitry Andric endCVSubsection(EndLabel); 30790b57cec5SDimitry Andric } 30800b57cec5SDimitry Andric } 30810b57cec5SDimitry Andric 30820b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForRetainedTypes() { 30830b57cec5SDimitry Andric NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu"); 30840b57cec5SDimitry Andric for (const MDNode *Node : CUs->operands()) { 30850b57cec5SDimitry Andric for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) { 30860b57cec5SDimitry Andric if (DIType *RT = dyn_cast<DIType>(Ty)) { 30870b57cec5SDimitry Andric getTypeIndex(RT); 30880b57cec5SDimitry Andric // FIXME: Add to global/local DTU list. 30890b57cec5SDimitry Andric } 30900b57cec5SDimitry Andric } 30910b57cec5SDimitry Andric } 30920b57cec5SDimitry Andric } 30930b57cec5SDimitry Andric 30940b57cec5SDimitry Andric // Emit each global variable in the specified array. 30950b57cec5SDimitry Andric void CodeViewDebug::emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals) { 30960b57cec5SDimitry Andric for (const CVGlobalVariable &CVGV : Globals) { 30970b57cec5SDimitry Andric // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions. 30980b57cec5SDimitry Andric emitDebugInfoForGlobal(CVGV); 30990b57cec5SDimitry Andric } 31000b57cec5SDimitry Andric } 31010b57cec5SDimitry Andric 31020b57cec5SDimitry Andric void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) { 31030b57cec5SDimitry Andric const DIGlobalVariable *DIGV = CVGV.DIGV; 31045ffd83dbSDimitry Andric 31055ffd83dbSDimitry Andric const DIScope *Scope = DIGV->getScope(); 31065ffd83dbSDimitry Andric // For static data members, get the scope from the declaration. 31075ffd83dbSDimitry Andric if (const auto *MemberDecl = dyn_cast_or_null<DIDerivedType>( 31085ffd83dbSDimitry Andric DIGV->getRawStaticDataMemberDeclaration())) 31095ffd83dbSDimitry Andric Scope = MemberDecl->getScope(); 31105ffd83dbSDimitry Andric std::string QualifiedName = getFullyQualifiedName(Scope, DIGV->getName()); 31115ffd83dbSDimitry Andric 31120b57cec5SDimitry Andric if (const GlobalVariable *GV = 31130b57cec5SDimitry Andric CVGV.GVInfo.dyn_cast<const GlobalVariable *>()) { 31140b57cec5SDimitry Andric // DataSym record, see SymbolRecord.h for more info. Thread local data 31150b57cec5SDimitry Andric // happens to have the same format as global data. 31160b57cec5SDimitry Andric MCSymbol *GVSym = Asm->getSymbol(GV); 31170b57cec5SDimitry Andric SymbolKind DataSym = GV->isThreadLocal() 31180b57cec5SDimitry Andric ? (DIGV->isLocalToUnit() ? SymbolKind::S_LTHREAD32 31190b57cec5SDimitry Andric : SymbolKind::S_GTHREAD32) 31200b57cec5SDimitry Andric : (DIGV->isLocalToUnit() ? SymbolKind::S_LDATA32 31210b57cec5SDimitry Andric : SymbolKind::S_GDATA32); 31220b57cec5SDimitry Andric MCSymbol *DataEnd = beginSymbolRecord(DataSym); 31230b57cec5SDimitry Andric OS.AddComment("Type"); 31245ffd83dbSDimitry Andric OS.emitInt32(getCompleteTypeIndex(DIGV->getType()).getIndex()); 31250b57cec5SDimitry Andric OS.AddComment("DataOffset"); 31260b57cec5SDimitry Andric OS.EmitCOFFSecRel32(GVSym, /*Offset=*/0); 31270b57cec5SDimitry Andric OS.AddComment("Segment"); 31280b57cec5SDimitry Andric OS.EmitCOFFSectionIndex(GVSym); 31290b57cec5SDimitry Andric OS.AddComment("Name"); 31300b57cec5SDimitry Andric const unsigned LengthOfDataRecord = 12; 31315ffd83dbSDimitry Andric emitNullTerminatedSymbolName(OS, QualifiedName, LengthOfDataRecord); 31320b57cec5SDimitry Andric endSymbolRecord(DataEnd); 31330b57cec5SDimitry Andric } else { 31340b57cec5SDimitry Andric const DIExpression *DIE = CVGV.GVInfo.get<const DIExpression *>(); 31350b57cec5SDimitry Andric assert(DIE->isConstant() && 31360b57cec5SDimitry Andric "Global constant variables must contain a constant expression."); 31370b57cec5SDimitry Andric uint64_t Val = DIE->getElement(1); 31380b57cec5SDimitry Andric 31390b57cec5SDimitry Andric MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT); 31400b57cec5SDimitry Andric OS.AddComment("Type"); 31415ffd83dbSDimitry Andric OS.emitInt32(getTypeIndex(DIGV->getType()).getIndex()); 31420b57cec5SDimitry Andric OS.AddComment("Value"); 31430b57cec5SDimitry Andric 31440b57cec5SDimitry Andric // Encoded integers shouldn't need more than 10 bytes. 31450b57cec5SDimitry Andric uint8_t data[10]; 31460b57cec5SDimitry Andric BinaryStreamWriter Writer(data, llvm::support::endianness::little); 31470b57cec5SDimitry Andric CodeViewRecordIO IO(Writer); 31480b57cec5SDimitry Andric cantFail(IO.mapEncodedInteger(Val)); 31490b57cec5SDimitry Andric StringRef SRef((char *)data, Writer.getOffset()); 31505ffd83dbSDimitry Andric OS.emitBinaryData(SRef); 31510b57cec5SDimitry Andric 31520b57cec5SDimitry Andric OS.AddComment("Name"); 31535ffd83dbSDimitry Andric emitNullTerminatedSymbolName(OS, QualifiedName); 31540b57cec5SDimitry Andric endSymbolRecord(SConstantEnd); 31550b57cec5SDimitry Andric } 31560b57cec5SDimitry Andric } 3157