1 //===- PDB.cpp ------------------------------------------------------------===// 2 // 3 // The LLVM Linker 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "PDB.h" 11 #include "Chunks.h" 12 #include "Config.h" 13 #include "Error.h" 14 #include "SymbolTable.h" 15 #include "Symbols.h" 16 #include "llvm/DebugInfo/CodeView/SymbolDumper.h" 17 #include "llvm/DebugInfo/CodeView/TypeDumper.h" 18 #include "llvm/DebugInfo/MSF/ByteStream.h" 19 #include "llvm/DebugInfo/MSF/MSFBuilder.h" 20 #include "llvm/DebugInfo/MSF/MSFCommon.h" 21 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h" 22 #include "llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h" 23 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h" 24 #include "llvm/DebugInfo/PDB/Raw/InfoStreamBuilder.h" 25 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h" 26 #include "llvm/DebugInfo/PDB/Raw/PDBFileBuilder.h" 27 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h" 28 #include "llvm/DebugInfo/PDB/Raw/TpiStreamBuilder.h" 29 #include "llvm/Object/COFF.h" 30 #include "llvm/Support/Endian.h" 31 #include "llvm/Support/FileOutputBuffer.h" 32 #include "llvm/Support/ScopedPrinter.h" 33 #include <memory> 34 35 using namespace lld; 36 using namespace lld::coff; 37 using namespace llvm; 38 using namespace llvm::codeview; 39 using namespace llvm::support; 40 using namespace llvm::support::endian; 41 42 using llvm::object::coff_section; 43 44 static ExitOnError ExitOnErr; 45 46 // Returns a list of all SectionChunks. 47 static std::vector<coff_section> getInputSections(SymbolTable *Symtab) { 48 std::vector<coff_section> V; 49 for (Chunk *C : Symtab->getChunks()) 50 if (auto *SC = dyn_cast<SectionChunk>(C)) 51 V.push_back(*SC->Header); 52 return V; 53 } 54 55 static SectionChunk *findByName(std::vector<SectionChunk *> &Sections, 56 StringRef Name) { 57 for (SectionChunk *C : Sections) 58 if (C->getSectionName() == Name) 59 return C; 60 return nullptr; 61 } 62 63 static ArrayRef<uint8_t> getDebugT(ObjectFile *File) { 64 SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$T"); 65 if (!Sec) 66 return {}; 67 68 // First 4 bytes are section magic. 69 ArrayRef<uint8_t> Data = Sec->getContents(); 70 if (Data.size() < 4) 71 fatal(".debug$T too short"); 72 if (read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC) 73 fatal(".debug$T has an invalid magic"); 74 return Data.slice(4); 75 } 76 77 static void dumpDebugT(ScopedPrinter &W, ObjectFile *File) { 78 ArrayRef<uint8_t> Data = getDebugT(File); 79 if (Data.empty()) 80 return; 81 82 msf::ByteStream Stream(Data); 83 CVTypeDumper TypeDumper(&W, false); 84 if (auto EC = TypeDumper.dump(Data)) 85 fatal(EC, "CVTypeDumper::dump failed"); 86 } 87 88 static void dumpDebugS(ScopedPrinter &W, ObjectFile *File) { 89 SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$S"); 90 if (!Sec) 91 return; 92 93 msf::ByteStream Stream(Sec->getContents()); 94 CVSymbolArray Symbols; 95 msf::StreamReader Reader(Stream); 96 if (auto EC = Reader.readArray(Symbols, Reader.getLength())) 97 fatal(EC, "StreamReader.readArray<CVSymbolArray> failed"); 98 99 CVTypeDumper TypeDumper(&W, false); 100 CVSymbolDumper SymbolDumper(W, TypeDumper, nullptr, false); 101 if (auto EC = SymbolDumper.dump(Symbols)) 102 fatal(EC, "CVSymbolDumper::dump failed"); 103 } 104 105 // Dump CodeView debug info. This is for debugging. 106 static void dumpCodeView(SymbolTable *Symtab) { 107 ScopedPrinter W(outs()); 108 109 for (ObjectFile *File : Symtab->ObjectFiles) { 110 dumpDebugT(W, File); 111 dumpDebugS(W, File); 112 } 113 } 114 115 static void addTypeInfo(SymbolTable *Symtab, 116 pdb::TpiStreamBuilder &TpiBuilder) { 117 for (ObjectFile *File : Symtab->ObjectFiles) { 118 ArrayRef<uint8_t> Data = getDebugT(File); 119 if (Data.empty()) 120 continue; 121 122 msf::ByteStream Stream(Data); 123 codeview::CVTypeArray Records; 124 msf::StreamReader Reader(Stream); 125 if (auto EC = Reader.readArray(Records, Reader.getLength())) 126 fatal(EC, "Reader.readArray failed"); 127 for (const codeview::CVType &Rec : Records) 128 TpiBuilder.addTypeRecord(Rec); 129 } 130 } 131 132 // Creates a PDB file. 133 void coff::createPDB(StringRef Path, SymbolTable *Symtab, 134 ArrayRef<uint8_t> SectionTable) { 135 if (Config->DumpPdb) 136 dumpCodeView(Symtab); 137 138 BumpPtrAllocator Alloc; 139 pdb::PDBFileBuilder Builder(Alloc); 140 ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize 141 142 // Create streams in MSF for predefined streams, namely 143 // PDB, TPI, DBI and IPI. 144 for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I) 145 ExitOnErr(Builder.getMsfBuilder().addStream(0)); 146 147 // Add an Info stream. 148 auto &InfoBuilder = Builder.getInfoBuilder(); 149 InfoBuilder.setAge(1); 150 151 // Should be a random number, 0 for now. 152 InfoBuilder.setGuid({}); 153 154 // Should be the current time, but set 0 for reproducibilty. 155 InfoBuilder.setSignature(0); 156 InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70); 157 158 // Add an empty DPI stream. 159 auto &DbiBuilder = Builder.getDbiBuilder(); 160 DbiBuilder.setVersionHeader(pdb::PdbDbiV110); 161 162 // Add an empty TPI stream. 163 auto &TpiBuilder = Builder.getTpiBuilder(); 164 TpiBuilder.setVersionHeader(pdb::PdbTpiV80); 165 if (Config->DebugPdb) 166 addTypeInfo(Symtab, TpiBuilder); 167 168 // Add an empty IPI stream. 169 auto &IpiBuilder = Builder.getIpiBuilder(); 170 IpiBuilder.setVersionHeader(pdb::PdbTpiV80); 171 172 // Add Section Contributions. 173 std::vector<pdb::SectionContrib> Contribs = 174 pdb::DbiStreamBuilder::createSectionContribs(getInputSections(Symtab)); 175 DbiBuilder.setSectionContribs(Contribs); 176 177 // Add Section Map stream. 178 ArrayRef<object::coff_section> Sections = { 179 (const object::coff_section *)SectionTable.data(), 180 SectionTable.size() / sizeof(object::coff_section)}; 181 std::vector<pdb::SecMapEntry> SectionMap = 182 pdb::DbiStreamBuilder::createSectionMap(Sections); 183 DbiBuilder.setSectionMap(SectionMap); 184 185 ExitOnErr(DbiBuilder.addModuleInfo("", "* Linker *")); 186 187 // Add COFF section header stream. 188 ExitOnErr( 189 DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable)); 190 191 // Write to a file. 192 ExitOnErr(Builder.commit(Path)); 193 } 194