pdbdump: Print out more strcutures.

[ruiu]

Summary

I don't yet fully understand the meaning of these data strcutures,
but at least it seems that their sizes and types are correct.
With this change, we can read publics streams till end.

[zturner]

lib/DebugInfo/PDB/Raw/PublicsStream.cpp

77–81 ↗

(On Diff #57535)

Almost certainly "section / offset".

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

public:
   PublicsStream(PDBFile &File, uint32_t StreamNum);
   ~PublicsStream();
   Error reload();
 
   uint32_t getStreamNum() const { return StreamNum; }
   uint32_t getSymHash() const;
   uint32_t getAddrMap() const;
   uint32_t getNumBuckets() const { return NumBuckets; }
+  ArrayRef<uint32_t> getHashBuckets() const { return HashBuckets; }
+  ArrayRef<uint32_t> getAddressMap() const { return AddressMap; }
+  ArrayRef<uint32_t> getThunkMap() const { return ThunkMap; }
 
 private:
   uint32_t StreamNum;
   MappedBlockStream Stream;
   uint32_t NumBuckets = 0;
+  std::vector<uint32_t> HashBuckets;
+  std::vector<uint32_t> AddressMap;
+  std::vector<uint32_t> ThunkMap;
 
   std::unique_ptr<HeaderInfo> Header;
   std::unique_ptr<GSIHashHeader> HashHdr;
 };
 }
 }
 
 #endif

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

 struct PublicsStream::HeaderInfo {
   ulittle32_t SymHash;
   ulittle32_t AddrMap;
   ulittle32_t NumThunks;
   ulittle32_t SizeOfThunk;
   ulittle16_t ISectThunkTable;
   char Padding[2];
   ulittle32_t OffThunkTable;
-  ulittle32_t NumSects;
+  ulittle32_t NumSections;
 };
 
 
 // This is GSIHashHdr struct defined in
 struct PublicsStream::GSIHashHeader {
   enum {
     HdrSignature = -1,
     HdrVersion = 0xeffe0000 + 19990810,
   };
   ulittle32_t VerSignature;
   ulittle32_t VerHdr;
   ulittle32_t HrSize;
   ulittle32_t NumBuckets;
 };
 
 struct PublicsStream::HRFile {
   ulittle32_t Off;
   ulittle32_t CRef;
 };
 
+// This struct is defined as "SO" in langapi/include/pdb.h.
+namespace {
+struct SectionOffset {
+  ulittle32_t Off;
+  ulittle16_t Isect;
+  char Padding[2];
+};
+}
+
 PublicsStream::PublicsStream(PDBFile &File, uint32_t StreamNum)
     : StreamNum(StreamNum), Stream(StreamNum, File) {}
 
 PublicsStream::~PublicsStream() {}
 
 uint32_t PublicsStream::getSymHash() const { return Header->SymHash; }
 uint32_t PublicsStream::getAddrMap() const { return Header->AddrMap; }
 
Error PublicsStream::reload() {
   size_t BitmapSizeInBits = alignTo(IPHR_HASH + 1, 32);
   std::vector<uint8_t> Bitmap(BitmapSizeInBits / 8);
   if (auto EC = Reader.readArray<uint8_t>(Bitmap))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read a bitmap.");
   for (uint8_t B : Bitmap)
     NumBuckets += countPopulation(B);
 
-  // Buckets follow.
-  if (Reader.bytesRemaining() < NumBuckets * sizeof(uint32_t))
+  // We don't yet understand the following data structures completely,
+  // but we at least know the types and sizes. Here we are trying
+  // to read the stream till end so that we at least can detect
+  // corrupted streams.
+
+  // Hash buckets follow.
+  HashBuckets.resize(NumBuckets);
+  if (auto EC = Reader.readArray<uint32_t>(HashBuckets))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Hash buckets corrupted.");
 
+  // Something called "address map" follows.
+  AddressMap.resize(Header->AddrMap / sizeof(uint32_t));
+  if (auto EC = Reader.readArray<uint32_t>(AddressMap))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Could not read an address map.");
+
+  // Something called "thunk map" follows.
+  ThunkMap.resize(Header->NumThunks);
+  if (auto EC = Reader.readArray<uint32_t>(ThunkMap))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Could not read a thunk map.");
+
+  // Something called "section map" follows.
+  std::vector<SectionOffset> SectionMap(Header->NumSections);
+  if (auto EC = Reader.readArray<SectionOffset>(SectionMap))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Could not read a section map.");
+
+  if (Reader.bytesRemaining() > 0)
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Corrupted publics stream.");
   return Error::success();
 }

llvm/trunk/test/DebugInfo/PDB/pdbdump-headers.test

 ; EMPTY-NEXT:       )
 ; EMPTY-NEXT:     }
 
 ; EMPTY:      Publics Stream {
 ; EMPTY-NEXT:   Stream number: 7
 ; EMPTY-NEXT:   SymHash: 556
 ; EMPTY-NEXT:   AddrMap: 8
 ; EMPTY-NEXT:   Number of buckets: 2
+; EMPTY-NEXT:   Hash Buckets: [0, 12]
+; EMPTY-NEXT:   Address Map: [36, 0]
+; EMPTY-NEXT:   Thunk Map: [4112]
 ; EMPTY-NEXT: }
 
 ; BIG:      FileHeaders {
 ; BIG-NEXT:   BlockSize: 4096
 ; BIG-NEXT:   Unknown0: 2
 ; BIG-NEXT:   NumBlocks: 99
 ; BIG-NEXT:   NumDirectoryBytes: 616
 ; BIG-NEXT:   Unknown1: 0

llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp

static Error dumpPublicsStream(ScopedPrinter &P, PDBFile &File) {
   auto PublicsS = File.getPDBPublicsStream();
   if (auto EC = PublicsS.takeError())
     return EC;
   PublicsStream &Publics = PublicsS.get();
   P.printNumber("Stream number", Publics.getStreamNum());
   P.printNumber("SymHash", Publics.getSymHash());
   P.printNumber("AddrMap", Publics.getAddrMap());
   P.printNumber("Number of buckets", Publics.getNumBuckets());
+  P.printList("Hash Buckets", Publics.getHashBuckets());
+  P.printList("Address Map", Publics.getAddressMap());
+  P.printList("Thunk Map", Publics.getThunkMap());
   return Error::success();
 }
 
 static Error dumpStructure(RawSession &RS) {
   PDBFile &File = RS.getPDBFile();
   ScopedPrinter P(outs());
 
   if (auto EC = dumpFileHeaders(P, File))