Define DbiStreamBuilder::addSectionContribs.

[ruiu]

Summary

This patch defines a new function to add a SectionContribs stream
to a PDB file. Unlike SectionMap, SectionContribs contains a list
of input sections as opposed to output sections.

Note that this patch needs improving because currently we do not
set Module field in SectionContribs entries. In a follow-up patch,
I'll add Modules and then fix it after that.

[ruiu]

Ping. I noticed that this wasn't committed yet.

[zturner]

include/llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h

68 ↗

(On Diff #76619)

This line looks like it wraps too soon.

lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp

315 ↗

(On Diff #76619)

I think you should try to fill out Entry.ISect and Entry.IMod. The first one seems like it's probably just the index, so you could get it by iterating over using llvm::enumerate(). Not sure how you will get the last one, but it seems important nonetheless. What do you think?

[ruiu]

lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp

315 ↗

(On Diff #76619)

I will fill ISect but probably not IMod in this patch because I don't understand the meaning of the field yet.

[zturner]

lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp

315 ↗

(On Diff #76619)

IMod is the index of the module in the DBI Stream's ModInfo array. For example, if this section contribution is for foo.obj, and foo.obj is the 7th entry in the ModInfo array, then IMod would be 7. For example, if I run -section-contribs against empty.pdb I get this:

Section Contributions [
  Contribution {
    ISect: 1
    Off: 0
    Size: 10
    Characteristics [ (0x60000020)
      IMAGE_SCN_CNT_CODE (0x20)
      IMAGE_SCN_MEM_EXECUTE (0x20000000)
      IMAGE_SCN_MEM_READ (0x40000000)
    ]
    Module {
      Index: 1
      Name: * Linker *
    }
    Data CRC: 0
    Reloc CRC: 0
  }
  Contribution {
    ISect: 1
    Off: 16
    Size: 10
    Characteristics [ (0x60500020)
      IMAGE_SCN_ALIGN_16BYTES (0x500000)
      IMAGE_SCN_CNT_CODE (0x20)
      IMAGE_SCN_MEM_EXECUTE (0x20000000)
      IMAGE_SCN_MEM_READ (0x40000000)
    ]
    Module {
      Index: 0
      Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
    }
    Data CRC: 3617027124
    Reloc CRC: 0
  }

We have indices of 1 and 0. Now if I run with -modules, I get this:

Modules [
  {
    Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
    Debug Stream Index: 12
    Object File Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
    Num Files: 1
    Source File Name Idx: 0
    Pdb File Name Idx: 0
    Line Info Byte Size: 0
    C13 Line Info Byte Size: 88
    Symbol Byte Size: 208
    Type Server Index: 0
    Has EC Info: No
  }
  {
    Name: * Linker *
    Debug Stream Index: 14
    Object File Name:
    Num Files: 0
    Source File Name Idx: 0
    Pdb File Name Idx: 1
    Line Info Byte Size: 0
    C13 Line Info Byte Size: 0
    Symbol Byte Size: 516
    Type Server Index: 0
    Has EC Info: No
  }

and we can see that the IMod field matches up with the order of the module in the module info array.

[ruiu]

lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp

315 ↗

(On Diff #76619)

Thanks. But I'll do that later because we haven't added Modules yet.

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h

public:
 
   void setVersionHeader(PdbRaw_DbiVer V);
   void setAge(uint32_t A);
   void setBuildNumber(uint16_t B);
   void setPdbDllVersion(uint16_t V);
   void setPdbDllRbld(uint16_t R);
   void setFlags(uint16_t F);
   void setMachineType(PDB_Machine M);
+  void setSectionContribs(ArrayRef<SectionContrib> SecMap);
   void setSectionMap(ArrayRef<SecMapEntry> SecMap);
 
   // Add given bytes as a new stream.
   Error addDbgStream(pdb::DbgHeaderType Type, ArrayRef<uint8_t> Data);
 
   uint32_t calculateSerializedLength() const;
 
   Error addModuleInfo(StringRef ObjFile, StringRef Module);
   Error addModuleSourceFile(StringRef Module, StringRef File);
 
   Error finalizeMsfLayout();
 
   Expected<std::unique_ptr<DbiStream>> build(PDBFile &File);
   Error commit(const msf::MSFLayout &Layout,
                const msf::WritableStream &Buffer);
 
+  // A helper function to create Section Contributions from COFF input
+  // section headers.
+  static std::vector<SectionContrib>
+  createSectionContribs(ArrayRef<llvm::object::coff_section> SecHdrs);
+
   // A helper function to create a Section Map from a COFF section header.
   static std::vector<SecMapEntry>
   createSectionMap(ArrayRef<llvm::object::coff_section> SecHdrs);
 
 private:
   struct DebugStream {
     ArrayRef<uint8_t> Data;
     uint16_t StreamNumber = 0;
   };
 
   Error finalize();
   uint32_t calculateModiSubstreamSize() const;
+  uint32_t calculateSectionContribsStreamSize() const;
   uint32_t calculateSectionMapStreamSize() const;
   uint32_t calculateFileInfoSubstreamSize() const;
   uint32_t calculateNamesBufferSize() const;
   uint32_t calculateDbgStreamsSize() const;
 
   Error generateModiSubstream();
   Error generateFileInfoSubstream();
 
private:
   StringMap<std::unique_ptr<ModuleInfo>> ModuleInfos;
   std::vector<ModuleInfo *> ModuleInfoList;
 
   StringMap<uint32_t> SourceFileNames;
 
   msf::WritableStreamRef NamesBuffer;
   msf::MutableByteStream ModInfoBuffer;
   msf::MutableByteStream FileInfoBuffer;
+  ArrayRef<SectionContrib> SectionContribs;
   ArrayRef<SecMapEntry> SectionMap;
   llvm::SmallVector<DebugStream, (int)DbgHeaderType::Max> DbgStreams;
 };
 }
 }
 
 #endif

llvm/trunk/lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp

 void DbiStreamBuilder::setPdbDllVersion(uint16_t V) { PdbDllVersion = V; }
 
 void DbiStreamBuilder::setPdbDllRbld(uint16_t R) { PdbDllRbld = R; }
 
 void DbiStreamBuilder::setFlags(uint16_t F) { Flags = F; }
 
 void DbiStreamBuilder::setMachineType(PDB_Machine M) { MachineType = M; }
 
+void DbiStreamBuilder::setSectionContribs(ArrayRef<SectionContrib> Arr) {
+  SectionContribs = Arr;
+}
+
 void DbiStreamBuilder::setSectionMap(ArrayRef<SecMapEntry> SecMap) {
   SectionMap = SecMap;
 }
 
 Error DbiStreamBuilder::addDbgStream(pdb::DbgHeaderType Type,
                                      ArrayRef<uint8_t> Data) {
   if (DbgStreams[(int)Type].StreamNumber)
     return make_error<RawError>(raw_error_code::duplicate_entry,
                                 "The specified stream type already exists");
   auto ExpectedIndex = Msf.addStream(Data.size());
   if (!ExpectedIndex)
     return ExpectedIndex.takeError();
   uint32_t Index = std::move(*ExpectedIndex);
   DbgStreams[(int)Type].Data = Data;
   DbgStreams[(int)Type].StreamNumber = Index;
   return Error::success();
 }
 
 uint32_t DbiStreamBuilder::calculateSerializedLength() const {
   // For now we only support serializing the header.
   return sizeof(DbiStreamHeader) + calculateFileInfoSubstreamSize() +
-         calculateModiSubstreamSize() + calculateSectionMapStreamSize() +
-         calculateDbgStreamsSize();
+         calculateModiSubstreamSize() + calculateSectionContribsStreamSize() +
+         calculateSectionMapStreamSize() + calculateDbgStreamsSize();
 }
 
 Error DbiStreamBuilder::addModuleInfo(StringRef ObjFile, StringRef Module) {
   auto Entry = llvm::make_unique<ModuleInfo>();
   ModuleInfo *M = Entry.get();
   Entry->Mod = Module;
   Entry->Obj = ObjFile;
   auto Result = ModuleInfos.insert(std::make_pair(Module, std::move(Entry)));
uint32_t DbiStreamBuilder::calculateModiSubstreamSize() const {
   for (const auto &M : ModuleInfoList) {
     Size += sizeof(ModuleInfoHeader);
     Size += M->Mod.size() + 1;
     Size += M->Obj.size() + 1;
   }
   return Size;
 }
 
+uint32_t DbiStreamBuilder::calculateSectionContribsStreamSize() const {
+  if (SectionContribs.empty())
+    return 0;
+  return sizeof(enum PdbRaw_DbiSecContribVer) +
+         sizeof(SectionContribs[0]) * SectionContribs.size();
+};
+
 uint32_t DbiStreamBuilder::calculateSectionMapStreamSize() const {
   if (SectionMap.empty())
     return 0;
   return sizeof(SecMapHeader) + sizeof(SecMapEntry) * SectionMap.size();
 }
 
 uint32_t DbiStreamBuilder::calculateFileInfoSubstreamSize() const {
   uint32_t Size = 0;
Error DbiStreamBuilder::finalize() {
   H->PdbDllRbld = PdbDllRbld;
   H->PdbDllVersion = PdbDllVersion;
   H->MachineType = static_cast<uint16_t>(MachineType);
 
   H->ECSubstreamSize = 0;
   H->FileInfoSize = FileInfoBuffer.getLength();
   H->ModiSubstreamSize = ModInfoBuffer.getLength();
   H->OptionalDbgHdrSize = DbgStreams.size() * sizeof(uint16_t);
-  H->SecContrSubstreamSize = 0;
+  H->SecContrSubstreamSize = calculateSectionContribsStreamSize();
   H->SectionMapSize = calculateSectionMapStreamSize();
   H->TypeServerSize = 0;
   H->SymRecordStreamIndex = kInvalidStreamIndex;
   H->PublicSymbolStreamIndex = kInvalidStreamIndex;
   H->MFCTypeServerIndex = kInvalidStreamIndex;
   H->GlobalSymbolStreamIndex = kInvalidStreamIndex;
 
   Header = H;
if (!(Flags & COFF::IMAGE_SCN_MEM_16BIT))
     Ret |= static_cast<uint16_t>(OMFSegDescFlags::AddressIs32Bit);
 
   // This seems always 1.
   Ret |= static_cast<uint16_t>(OMFSegDescFlags::IsSelector);
 
   return Ret;
 }
 
+// A utility function to create Section Contributions
+// for a given input sections.
+std::vector<SectionContrib> DbiStreamBuilder::createSectionContribs(
+    ArrayRef<object::coff_section> SecHdrs) {
+  std::vector<SectionContrib> Ret;
+
+  // Create a SectionContrib for each input section.
+  for (auto &Sec : SecHdrs) {
+    Ret.emplace_back();
+    auto &Entry = Ret.back();
+    memset(&Entry, 0, sizeof(Entry));
+
+    Entry.Off = Sec.PointerToRawData;
+    Entry.Size = Sec.SizeOfRawData;
+    Entry.Characteristics = Sec.Characteristics;
+  }
+  return Ret;
+}
+
 // A utility function to create a Section Map for a given list of COFF sections.
 //
 // A Section Map seem to be a copy of a COFF section list in other format.
 // I don't know why a PDB file contains both a COFF section header and
 // a Section Map, but it seems it must be present in a PDB.
 std::vector<SecMapEntry> DbiStreamBuilder::createSectionMap(
     ArrayRef<llvm::object::coff_section> SecHdrs) {
   std::vector<SecMapEntry> Ret;
Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout,
 
   StreamWriter Writer(*InfoS);
   if (auto EC = Writer.writeObject(*Header))
     return EC;
 
   if (auto EC = Writer.writeStreamRef(ModInfoBuffer))
     return EC;
 
+  if (!SectionContribs.empty()) {
+    if (auto EC = Writer.writeEnum(DbiSecContribVer60))
+      return EC;
+    if (auto EC = Writer.writeArray(SectionContribs))
+      return EC;
+  }
+
   if (!SectionMap.empty()) {
     ulittle16_t Size = static_cast<ulittle16_t>(SectionMap.size());
     SecMapHeader SMHeader = {Size, Size};
     if (auto EC = Writer.writeObject(SMHeader))
       return EC;
     if (auto EC = Writer.writeArray(SectionMap))
       return EC;
   }