contrib/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp

   1 //===- DbiStreamBuilder.cpp - PDB Dbi Stream Creation -----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
  11
  12 #include "llvm/ADT/ArrayRef.h"
  13 #include "llvm/BinaryFormat/COFF.h"
  14 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
  15 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
  16 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
  17 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  18 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  19 #include "llvm/Object/COFF.h"
  20 #include "llvm/Support/BinaryStreamWriter.h"
  21
  22 using namespace llvm;
  23 using namespace llvm::codeview;
  24 using namespace llvm::msf;
  25 using namespace llvm::pdb;
  26
  27 DbiStreamBuilder::DbiStreamBuilder(msf::MSFBuilder &Msf)
  28     : Msf(Msf), Allocator(Msf.getAllocator()), Age(1), BuildNumber(0),
  29       PdbDllVersion(0), PdbDllRbld(0), Flags(0), MachineType(PDB_Machine::x86),
  30       Header(nullptr), DbgStreams((int)DbgHeaderType::Max) {}
  31
  32 DbiStreamBuilder::~DbiStreamBuilder() {}
  33
  34 void DbiStreamBuilder::setVersionHeader(PdbRaw_DbiVer V) { VerHeader = V; }
  35
  36 void DbiStreamBuilder::setAge(uint32_t A) { Age = A; }
  37
  38 void DbiStreamBuilder::setBuildNumber(uint16_t B) { BuildNumber = B; }
  39
  40 void DbiStreamBuilder::setPdbDllVersion(uint16_t V) { PdbDllVersion = V; }
  41
  42 void DbiStreamBuilder::setPdbDllRbld(uint16_t R) { PdbDllRbld = R; }
  43
  44 void DbiStreamBuilder::setFlags(uint16_t F) { Flags = F; }
  45
  46 void DbiStreamBuilder::setMachineType(PDB_Machine M) { MachineType = M; }
  47
  48 void DbiStreamBuilder::setSectionMap(ArrayRef<SecMapEntry> SecMap) {
  49   SectionMap = SecMap;
  50 }
  51
  52 void DbiStreamBuilder::setGlobalsStreamIndex(uint32_t Index) {
  53   GlobalsStreamIndex = Index;
  54 }
  55
  56 void DbiStreamBuilder::setSymbolRecordStreamIndex(uint32_t Index) {
  57   SymRecordStreamIndex = Index;
  58 }
  59
  60 void DbiStreamBuilder::setPublicsStreamIndex(uint32_t Index) {
  61   PublicsStreamIndex = Index;
  62 }
  63
  64 Error DbiStreamBuilder::addDbgStream(pdb::DbgHeaderType Type,
  65                                      ArrayRef<uint8_t> Data) {
  66   if (DbgStreams[(int)Type].StreamNumber != kInvalidStreamIndex)
  67     return make_error<RawError>(raw_error_code::duplicate_entry,
  68                                 "The specified stream type already exists");
  69   auto ExpectedIndex = Msf.addStream(Data.size());
  70   if (!ExpectedIndex)
  71     return ExpectedIndex.takeError();
  72   uint32_t Index = std::move(*ExpectedIndex);
  73   DbgStreams[(int)Type].Data = Data;
  74   DbgStreams[(int)Type].StreamNumber = Index;
  75   return Error::success();
  76 }
  77
  78 uint32_t DbiStreamBuilder::addECName(StringRef Name) {
  79   return ECNamesBuilder.insert(Name);
  80 }
  81
  82 uint32_t DbiStreamBuilder::calculateSerializedLength() const {
  83   // For now we only support serializing the header.
  84   return sizeof(DbiStreamHeader) + calculateFileInfoSubstreamSize() +
  85          calculateModiSubstreamSize() + calculateSectionContribsStreamSize() +
  86          calculateSectionMapStreamSize() + calculateDbgStreamsSize() +
  87          ECNamesBuilder.calculateSerializedSize();
  88 }
  89
  90 Expected<DbiModuleDescriptorBuilder &>
  91 DbiStreamBuilder::addModuleInfo(StringRef ModuleName) {
  92   uint32_t Index = ModiList.size();
  93   ModiList.push_back(
  94       llvm::make_unique<DbiModuleDescriptorBuilder>(ModuleName, Index, Msf));
  95   return *ModiList.back();
  96 }
  97
  98 Error DbiStreamBuilder::addModuleSourceFile(DbiModuleDescriptorBuilder &Module,
  99                                             StringRef File) {
 100   uint32_t Index = SourceFileNames.size();
 101   SourceFileNames.insert(std::make_pair(File, Index));
 102   Module.addSourceFile(File);
 103   return Error::success();
 104 }
 105
 106 Expected<uint32_t> DbiStreamBuilder::getSourceFileNameIndex(StringRef File) {
 107   auto NameIter = SourceFileNames.find(File);
 108   if (NameIter == SourceFileNames.end())
 109     return make_error<RawError>(raw_error_code::no_entry,
 110                                 "The specified source file was not found");
 111   return NameIter->getValue();
 112 }
 113
 114 uint32_t DbiStreamBuilder::calculateModiSubstreamSize() const {
 115   uint32_t Size = 0;
 116   for (const auto &M : ModiList)
 117     Size += M->calculateSerializedLength();
 118   return Size;
 119 }
 120
 121 uint32_t DbiStreamBuilder::calculateSectionContribsStreamSize() const {
 122   if (SectionContribs.empty())
 123     return 0;
 124   return sizeof(enum PdbRaw_DbiSecContribVer) +
 125          sizeof(SectionContribs[0]) * SectionContribs.size();
 126 }
 127
 128 uint32_t DbiStreamBuilder::calculateSectionMapStreamSize() const {
 129   if (SectionMap.empty())
 130     return 0;
 131   return sizeof(SecMapHeader) + sizeof(SecMapEntry) * SectionMap.size();
 132 }
 133
 134 uint32_t DbiStreamBuilder::calculateNamesOffset() const {
 135   uint32_t Offset = 0;
 136   Offset += sizeof(ulittle16_t);                         // NumModules
 137   Offset += sizeof(ulittle16_t);                         // NumSourceFiles
 138   Offset += ModiList.size() * sizeof(ulittle16_t);       // ModIndices
 139   Offset += ModiList.size() * sizeof(ulittle16_t);       // ModFileCounts
 140   uint32_t NumFileInfos = 0;
 141   for (const auto &M : ModiList)
 142     NumFileInfos += M->source_files().size();
 143   Offset += NumFileInfos * sizeof(ulittle32_t); // FileNameOffsets
 144   return Offset;
 145 }
 146
 147 uint32_t DbiStreamBuilder::calculateFileInfoSubstreamSize() const {
 148   uint32_t Size = calculateNamesOffset();
 149   Size += calculateNamesBufferSize();
 150   return alignTo(Size, sizeof(uint32_t));
 151 }
 152
 153 uint32_t DbiStreamBuilder::calculateNamesBufferSize() const {
 154   uint32_t Size = 0;
 155   for (const auto &F : SourceFileNames) {
 156     Size += F.getKeyLength() + 1; // Names[I];
 157   }
 158   return Size;
 159 }
 160
 161 uint32_t DbiStreamBuilder::calculateDbgStreamsSize() const {
 162   return DbgStreams.size() * sizeof(uint16_t);
 163 }
 164
 165 Error DbiStreamBuilder::generateFileInfoSubstream() {
 166   uint32_t Size = calculateFileInfoSubstreamSize();
 167   auto Data = Allocator.Allocate<uint8_t>(Size);
 168   uint32_t NamesOffset = calculateNamesOffset();
 169
 170   FileInfoBuffer = MutableBinaryByteStream(MutableArrayRef<uint8_t>(Data, Size),
 171                                            llvm::support::little);
 172
 173   WritableBinaryStreamRef MetadataBuffer =
 174       WritableBinaryStreamRef(FileInfoBuffer).keep_front(NamesOffset);
 175   BinaryStreamWriter MetadataWriter(MetadataBuffer);
 176
 177   uint16_t ModiCount = std::min<uint32_t>(UINT16_MAX, ModiList.size());
 178   uint16_t FileCount = std::min<uint32_t>(UINT16_MAX, SourceFileNames.size());
 179   if (auto EC = MetadataWriter.writeInteger(ModiCount)) // NumModules
 180     return EC;
 181   if (auto EC = MetadataWriter.writeInteger(FileCount)) // NumSourceFiles
 182     return EC;
 183   for (uint16_t I = 0; I < ModiCount; ++I) {
 184     if (auto EC = MetadataWriter.writeInteger(I)) // Mod Indices
 185       return EC;
 186   }
 187   for (const auto &MI : ModiList) {
 188     FileCount = static_cast<uint16_t>(MI->source_files().size());
 189     if (auto EC = MetadataWriter.writeInteger(FileCount)) // Mod File Counts
 190       return EC;
 191   }
 192
 193   // Before writing the FileNameOffsets array, write the NamesBuffer array.
 194   // A side effect of this is that this will actually compute the various
 195   // file name offsets, so we can then go back and write the FileNameOffsets
 196   // array to the other substream.
 197   NamesBuffer = WritableBinaryStreamRef(FileInfoBuffer).drop_front(NamesOffset);
 198   BinaryStreamWriter NameBufferWriter(NamesBuffer);
 199   for (auto &Name : SourceFileNames) {
 200     Name.second = NameBufferWriter.getOffset();
 201     if (auto EC = NameBufferWriter.writeCString(Name.getKey()))
 202       return EC;
 203   }
 204
 205   for (const auto &MI : ModiList) {
 206     for (StringRef Name : MI->source_files()) {
 207       auto Result = SourceFileNames.find(Name);
 208       if (Result == SourceFileNames.end())
 209         return make_error<RawError>(raw_error_code::no_entry,
 210                                     "The source file was not found.");
 211       if (auto EC = MetadataWriter.writeInteger(Result->second))
 212         return EC;
 213     }
 214   }
 215
 216   if (auto EC = NameBufferWriter.padToAlignment(sizeof(uint32_t)))
 217     return EC;
 218
 219   if (NameBufferWriter.bytesRemaining() > 0)
 220     return make_error<RawError>(raw_error_code::invalid_format,
 221                                 "The names buffer contained unexpected data.");
 222
 223   if (MetadataWriter.bytesRemaining() > sizeof(uint32_t))
 224     return make_error<RawError>(
 225         raw_error_code::invalid_format,
 226         "The metadata buffer contained unexpected data.");
 227
 228   return Error::success();
 229 }
 230
 231 Error DbiStreamBuilder::finalize() {
 232   if (Header)
 233     return Error::success();
 234
 235   for (auto &MI : ModiList)
 236     MI->finalize();
 237
 238   if (auto EC = generateFileInfoSubstream())
 239     return EC;
 240
 241   DbiStreamHeader *H = Allocator.Allocate<DbiStreamHeader>();
 242   ::memset(H, 0, sizeof(DbiStreamHeader));
 243   H->VersionHeader = *VerHeader;
 244   H->VersionSignature = -1;
 245   H->Age = Age;
 246   H->BuildNumber = BuildNumber;
 247   H->Flags = Flags;
 248   H->PdbDllRbld = PdbDllRbld;
 249   H->PdbDllVersion = PdbDllVersion;
 250   H->MachineType = static_cast<uint16_t>(MachineType);
 251
 252   H->ECSubstreamSize = ECNamesBuilder.calculateSerializedSize();
 253   H->FileInfoSize = FileInfoBuffer.getLength();
 254   H->ModiSubstreamSize = calculateModiSubstreamSize();
 255   H->OptionalDbgHdrSize = DbgStreams.size() * sizeof(uint16_t);
 256   H->SecContrSubstreamSize = calculateSectionContribsStreamSize();
 257   H->SectionMapSize = calculateSectionMapStreamSize();
 258   H->TypeServerSize = 0;
 259   H->SymRecordStreamIndex = SymRecordStreamIndex;
 260   H->PublicSymbolStreamIndex = PublicsStreamIndex;
 261   H->MFCTypeServerIndex = kInvalidStreamIndex;
 262   H->GlobalSymbolStreamIndex = GlobalsStreamIndex;
 263
 264   Header = H;
 265   return Error::success();
 266 }
 267
 268 Error DbiStreamBuilder::finalizeMsfLayout() {
 269   for (auto &MI : ModiList) {
 270     if (auto EC = MI->finalizeMsfLayout())
 271       return EC;
 272   }
 273
 274   uint32_t Length = calculateSerializedLength();
 275   if (auto EC = Msf.setStreamSize(StreamDBI, Length))
 276     return EC;
 277   return Error::success();
 278 }
 279
 280 static uint16_t toSecMapFlags(uint32_t Flags) {
 281   uint16_t Ret = 0;
 282   if (Flags & COFF::IMAGE_SCN_MEM_READ)
 283     Ret |= static_cast<uint16_t>(OMFSegDescFlags::Read);
 284   if (Flags & COFF::IMAGE_SCN_MEM_WRITE)
 285     Ret |= static_cast<uint16_t>(OMFSegDescFlags::Write);
 286   if (Flags & COFF::IMAGE_SCN_MEM_EXECUTE)
 287     Ret |= static_cast<uint16_t>(OMFSegDescFlags::Execute);
 288   if (Flags & COFF::IMAGE_SCN_MEM_EXECUTE)
 289     Ret |= static_cast<uint16_t>(OMFSegDescFlags::Execute);
 290   if (!(Flags & COFF::IMAGE_SCN_MEM_16BIT))
 291     Ret |= static_cast<uint16_t>(OMFSegDescFlags::AddressIs32Bit);
 292
 293   // This seems always 1.
 294   Ret |= static_cast<uint16_t>(OMFSegDescFlags::IsSelector);
 295
 296   return Ret;
 297 }
 298
 299 // A utility function to create a Section Map for a given list of COFF sections.
 300 //
 301 // A Section Map seem to be a copy of a COFF section list in other format.
 302 // I don't know why a PDB file contains both a COFF section header and
 303 // a Section Map, but it seems it must be present in a PDB.
 304 std::vector<SecMapEntry> DbiStreamBuilder::createSectionMap(
 305     ArrayRef<llvm::object::coff_section> SecHdrs) {
 306   std::vector<SecMapEntry> Ret;
 307   int Idx = 0;
 308
 309   auto Add = [&]() -> SecMapEntry & {
 310     Ret.emplace_back();
 311     auto &Entry = Ret.back();
 312     memset(&Entry, 0, sizeof(Entry));
 313
 314     Entry.Frame = Idx + 1;
 315
 316     // We don't know the meaning of these fields yet.
 317     Entry.SecName = UINT16_MAX;
 318     Entry.ClassName = UINT16_MAX;
 319
 320     return Entry;
 321   };
 322
 323   for (auto &Hdr : SecHdrs) {
 324     auto &Entry = Add();
 325     Entry.Flags = toSecMapFlags(Hdr.Characteristics);
 326     Entry.SecByteLength = Hdr.VirtualSize;
 327     ++Idx;
 328   }
 329
 330   // The last entry is for absolute symbols.
 331   auto &Entry = Add();
 332   Entry.Flags = static_cast<uint16_t>(OMFSegDescFlags::AddressIs32Bit) |
 333                 static_cast<uint16_t>(OMFSegDescFlags::IsAbsoluteAddress);
 334   Entry.SecByteLength = UINT32_MAX;
 335
 336   return Ret;
 337 }
 338
 339 Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout,
 340                                WritableBinaryStreamRef MsfBuffer) {
 341   if (auto EC = finalize())
 342     return EC;
 343
 344   auto DbiS = WritableMappedBlockStream::createIndexedStream(
 345       Layout, MsfBuffer, StreamDBI, Allocator);
 346
 347   BinaryStreamWriter Writer(*DbiS);
 348   if (auto EC = Writer.writeObject(*Header))
 349     return EC;
 350
 351   for (auto &M : ModiList) {
 352     if (auto EC = M->commit(Writer, Layout, MsfBuffer))
 353       return EC;
 354   }
 355
 356   if (!SectionContribs.empty()) {
 357     if (auto EC = Writer.writeEnum(DbiSecContribVer60))
 358       return EC;
 359     if (auto EC = Writer.writeArray(makeArrayRef(SectionContribs)))
 360       return EC;
 361   }
 362
 363   if (!SectionMap.empty()) {
 364     ulittle16_t Size = static_cast<ulittle16_t>(SectionMap.size());
 365     SecMapHeader SMHeader = {Size, Size};
 366     if (auto EC = Writer.writeObject(SMHeader))
 367       return EC;
 368     if (auto EC = Writer.writeArray(SectionMap))
 369       return EC;
 370   }
 371
 372   if (auto EC = Writer.writeStreamRef(FileInfoBuffer))
 373     return EC;
 374
 375   if (auto EC = ECNamesBuilder.commit(Writer))
 376     return EC;
 377
 378   for (auto &Stream : DbgStreams)
 379     if (auto EC = Writer.writeInteger(Stream.StreamNumber))
 380       return EC;
 381
 382   for (auto &Stream : DbgStreams) {
 383     if (Stream.StreamNumber == kInvalidStreamIndex)
 384       continue;
 385     auto WritableStream = WritableMappedBlockStream::createIndexedStream(
 386         Layout, MsfBuffer, Stream.StreamNumber, Allocator);
 387     BinaryStreamWriter DbgStreamWriter(*WritableStream);
 388     if (auto EC = DbgStreamWriter.writeArray(Stream.Data))
 389       return EC;
 390   }
 391
 392   if (Writer.bytesRemaining() > 0)
 393     return make_error<RawError>(raw_error_code::invalid_format,
 394                                 "Unexpected bytes found in DBI Stream");
 395   return Error::success();
 396 }