[PDB] Fix alignment of symbol record string

[zturner]

Summary

The symbol record substream needs to be written at a multiple of 4 bytes. This is because the next field that is read is the beginning of the module debug subsections (checksums, lines, etc) and the first field is a uint32.

I found this by round-tripping empty.pdb from the test folder and seeing it give me an error. To determine the correct fix, I stepped through the reading code of empty.pdb and saw that the Symbol Record Substream consisted of 208 bytes, a multiple of 4. This is the value that the header reported for the "symbol record substream size", as well as the number of subsequent bytes we read and attributed to the symbol record substream. When I converted this file to yaml, and then converted it back to pdb, we were writing 206 bytes for this value, and then writing 206 bytes of data.

[inglorion]

This change is no longer necessary, right?

llvm/lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp

template <> struct BinaryItemTraits<CVSymbol> {
   static ArrayRef<uint8_t> bytes(const CVSymbol &Item) {
     return Item.RecordData;
   }
 };
 }
 
 static uint32_t calculateDiSymbolStreamSize(uint32_t SymbolByteSize,
                                             uint32_t C13Size) {
-  uint32_t Size = sizeof(uint32_t); // Signature
-  Size += SymbolByteSize;           // Symbol Data
-  Size += 0;                        // TODO: Layout.C11Bytes
-  Size += C13Size;                  // C13 Debug Info Size
-  Size += sizeof(uint32_t);         // GlobalRefs substream size (always 0)
-  Size += 0;                        // GlobalRefs substream bytes
+  uint32_t Size = sizeof(uint32_t);   // Signature
+  Size += alignTo(SymbolByteSize, 4); // Symbol Data
+  Size += 0;                          // TODO: Layout.C11Bytes
+  Size += C13Size;                    // C13 Debug Info Size
+  Size += sizeof(uint32_t);           // GlobalRefs substream size (always 0)
+  Size += 0;                          // GlobalRefs substream bytes
   return Size;
 }
 
 DbiModuleDescriptorBuilder::DbiModuleDescriptorBuilder(StringRef ModuleName,
                                                        uint32_t ModIndex,
                                                        msf::MSFBuilder &Msf)
     : MSF(Msf), ModuleName(ModuleName) {
   Layout.Mod = ModIndex;
void DbiModuleDescriptorBuilder::finalize() {
   (void)Layout.Mod;         // Set in constructor
   (void)Layout.ModDiStream; // Set in finalizeMsfLayout
   Layout.NumFiles = SourceFiles.size();
   Layout.PdbFilePathNI = 0;
   Layout.SrcFileNameNI = 0;
 
   // This value includes both the signature field as well as the record bytes
   // from the symbol stream.
-  Layout.SymBytes = SymbolByteSize + sizeof(uint32_t);
+  Layout.SymBytes = alignTo(SymbolByteSize + sizeof(uint32_t), 4);
 }
 
 Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
   this->Layout.ModDiStream = kInvalidStreamIndex;
   uint32_t C13Size = calculateC13DebugInfoSize();
   auto ExpectedSN =
       MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
   if (!ExpectedSN)
if (Layout.ModDiStream != kInvalidStreamIndex) {
     if (auto EC =
             SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
       return EC;
     BinaryItemStream<CVSymbol> Records(llvm::support::endianness::little);
     Records.setItems(Symbols);
     BinaryStreamRef RecordsRef(Records);
     if (auto EC = SymbolWriter.writeStreamRef(RecordsRef))
       return EC;
+    if (auto EC = SymbolWriter.padToAlignment(4))
+      return EC;
     // TODO: Write C11 Line data
 
     for (const auto &Builder : C13Builders) {
+      assert(SymbolWriter.getOffset() % 4 == 0);
       assert(Builder && "Empty C13 Fragment Builder!");
       if (auto EC = Builder->commit(SymbolWriter))
         return EC;
     }
+    assert(SymbolWriter.getOffset() % 4 == 0);
 
     // TODO: Figure out what GlobalRefs substream actually is and populate it.
     if (auto EC = SymbolWriter.writeInteger<uint32_t>(0))
       return EC;
     if (SymbolWriter.bytesRemaining() > 0)
       return make_error<RawError>(raw_error_code::stream_too_long);
   }
   return Error::success();