[pdb] Convert more reads to zero-copy reads.

[zturner]

Summary

These are not particularly important memory wise, but I'd like to remove all the copying interfaces, so these come next.

[ruiu]

LGTM

[Eugene.Zelenko]

Committed in r270960.

include/llvm/DebugInfo/CodeView/StreamReader.h

 
 class StreamRef;
 
 class StreamReader {
 public:
   StreamReader(const StreamInterface &S);
 
   Error readBytes(uint32_t Size, ArrayRef<uint8_t> &Buffer);
-  Error readBytes(MutableArrayRef<uint8_t> Buffer);
   Error readInteger(uint16_t &Dest);
   Error readInteger(uint32_t &Dest);
   Error readZeroString(StringRef &Dest);
   Error readFixedString(StringRef &Dest, uint32_t Length);
   Error readStreamRef(StreamRef &Ref);
   Error readStreamRef(StreamRef &Ref, uint32_t Length);
+  Error readBytes(MutableArrayRef<uint8_t> Buffer);
 
   template <typename T> Error readObject(const T *&Dest) {
     ArrayRef<uint8_t> Buffer;
     if (auto EC = readBytes(sizeof(T), Buffer))
       return EC;
     Dest = reinterpret_cast<const T *>(Buffer.data());
     return Error::success();
   }
 
   template <typename T>
   Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) {
     if (NumItems == 0) {
       Array = FixedStreamArray<T>();
       return Error::success();
     }
     uint32_t Length = NumItems * sizeof(T);
     if (Offset + Length > Stream.getLength())
       return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
     StreamRef View(Stream, Offset, Length);
     Array = FixedStreamArray<T>(View);
     Offset += Length;
     return Error::success();
   }
 
-  template <typename T> Error readArray(MutableArrayRef<T> Array) {
-    MutableArrayRef<uint8_t> Casted(reinterpret_cast<uint8_t *>(Array.data()),
-                                    Array.size() * sizeof(T));
-    return readBytes(Casted);
-  }
-
   void setOffset(uint32_t Off) { Offset = Off; }
   uint32_t getOffset() const { return Offset; }
   uint32_t getLength() const { return Stream.getLength(); }
   uint32_t bytesRemaining() const { return getLength() - getOffset(); }
 
 private:
   const StreamInterface &Stream;
   uint32_t Offset;
 };
 } // namespace codeview
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_STREAMREADER_H

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

 //===- NameHashTable.h - PDB Name Hash Table --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_NAMEHASHTABLE_H
 #define LLVM_DEBUGINFO_PDB_RAW_NAMEHASHTABLE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/StreamRef.h"
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace codeview {
 class StreamReader;
 }
 namespace pdb {
 
 class NameHashTable {
 public:
   NameHashTable();
 
   Error load(codeview::StreamReader &Stream);
 
   uint32_t getNameCount() const { return NameCount; }
   uint32_t getHashVersion() const { return HashVersion; }
   uint32_t getSignature() const { return Signature; }
 
   StringRef getStringForID(uint32_t ID) const;
   uint32_t getIDForString(StringRef Str) const;
 
-  ArrayRef<uint32_t> name_ids() const;
+  codeview::FixedStreamArray<support::ulittle32_t> name_ids() const;
 
 private:
   codeview::StreamRef NamesBuffer;
-  std::vector<uint32_t> IDs;
+  codeview::FixedStreamArray<support::ulittle32_t> IDs;
   uint32_t Signature;
   uint32_t HashVersion;
   uint32_t NameCount;
 };
 
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_NAMEHASHTABLE_H

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

 //===- PublicsStream.h - PDB Public Symbol Stream -------- ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PUBLICSSTREAM_H
 #define LLVM_DEBUGINFO_PDB_RAW_PUBLICSSTREAM_H
 
+#include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeStream.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class DbiStream;
 class PDBFile;
 
 class PublicsStream {
   struct GSIHashHeader;
-  struct HashRecord;
   struct HeaderInfo;
 
 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; }
   iterator_range<codeview::SymbolIterator> getSymbols() const;
-  ArrayRef<uint32_t> getHashBuckets() const { return HashBuckets; }
-  ArrayRef<uint32_t> getAddressMap() const { return AddressMap; }
-  ArrayRef<uint32_t> getThunkMap() const { return ThunkMap; }
-  ArrayRef<uint32_t> getSectionOffsets() const { return SectionOffsets; }
+  codeview::FixedStreamArray<support::ulittle32_t> getHashBuckets() const {
+    return HashBuckets;
+  }
+  codeview::FixedStreamArray<support::ulittle32_t> getAddressMap() const {
+    return AddressMap;
+  }
+  codeview::FixedStreamArray<support::ulittle32_t> getThunkMap() const {
+    return ThunkMap;
+  }
+  codeview::FixedStreamArray<SectionOffset> getSectionOffsets() const {
+    return SectionOffsets;
+  }
 
 private:
   Error readSymbols();
 
   PDBFile &Pdb;
 
   uint32_t StreamNum;
   MappedBlockStream Stream;
   uint32_t NumBuckets = 0;
-  std::vector<HashRecord> HashRecords;
-  std::vector<uint32_t> HashBuckets;
-  std::vector<uint32_t> AddressMap;
-  std::vector<uint32_t> ThunkMap;
-  std::vector<uint32_t> SectionOffsets;
+  ArrayRef<uint8_t> Bitmap;
+  codeview::FixedStreamArray<PSHashRecord> HashRecords;
+  codeview::FixedStreamArray<support::ulittle32_t> HashBuckets;
+  codeview::FixedStreamArray<support::ulittle32_t> AddressMap;
+  codeview::FixedStreamArray<support::ulittle32_t> ThunkMap;
+  codeview::FixedStreamArray<SectionOffset> SectionOffsets;
 
   const HeaderInfo *Header;
   const GSIHashHeader *HashHdr;
 };
 }
 }
 
 #endif

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

 //===- PDBRawConstants.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 #define LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 
+#include "llvm/Support/Endian.h"
+
 #include <cstdint>
 
 namespace llvm {
 namespace pdb {
 
 enum PdbRaw_ImplVer : uint32_t {
   PdbImplVC2 = 19941610,
   PdbImplVC4 = 19950623,
enum class DbgHeaderType : uint16_t {
   TokenRidMap,
   Xdata,
   Pdata,
   NewFPO,
   SectionHdrOrig,
   Max
 };
 
+// This struct is defined as "SO" in langapi/include/pdb.h.
+struct SectionOffset {
+  support::ulittle32_t Off;
+  support::ulittle16_t Isect;
+  char Padding[2];
+};
+
+// This is HRFile.
+struct PSHashRecord {
+  support::ulittle32_t Off; // Offset in the symbol record stream
+  support::ulittle32_t CRef;
+};
+
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H

include/llvm/Support/ScopedPrinter.h

for (const auto &Item : List) {
       if (Comma)
         OS << ", ";
       OS << Item;
       Comma = true;
     }
     OS << "]\n";
   }
 
+  template <typename T, typename U>
+  void printList(StringRef Label, const T &List, const U &Printer) {
+    startLine() << Label << ": [";
+    bool Comma = false;
+    for (const auto &Item : List) {
+      if (Comma)
+        OS << ", ";
+      Printer(OS, Item);
+      Comma = true;
+    }
+    OS << "]\n";
+  }
+
   template <typename T> void printHexList(StringRef Label, const T &List) {
     startLine() << Label << ": [";
     bool Comma = false;
     for (const auto &Item : List) {
       if (Comma)
         OS << ", ";
       OS << hex(Item);
       Comma = true;

lib/DebugInfo/PDB/Raw/NameHashTable.cpp

Error NameHashTable::load(codeview::StreamReader &Stream) {
   if (auto EC = Stream.readStreamRef(NamesBuffer, H->ByteSize))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Invalid hash table byte length");
 
   const support::ulittle32_t *HashCount;
   if (auto EC = Stream.readObject(HashCount))
     return EC;
 
-  std::vector<support::ulittle32_t> BucketArray(*HashCount);
-  if (auto EC = Stream.readArray<support::ulittle32_t>(BucketArray))
+  if (auto EC = Stream.readArray(IDs, *HashCount))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read bucket array");
-  IDs.assign(BucketArray.begin(), BucketArray.end());
 
   if (Stream.bytesRemaining() < sizeof(support::ulittle32_t))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Missing name count");
 
   if (auto EC = Stream.readInteger(NameCount))
     return EC;
   return Error::success();
for (size_t I = 0; I < Count; ++I) {
     StringRef S = getStringForID(ID);
     if (S == Str)
       return ID;
   }
   // IDs[0] contains the ID of the "invalid" entry.
   return IDs[0];
 }
 
-ArrayRef<uint32_t> NameHashTable::name_ids() const { return IDs; }
+codeview::FixedStreamArray<support::ulittle32_t>
+NameHashTable::name_ids() const {
+  return IDs;
+}

lib/DebugInfo/PDB/Raw/PublicsStream.cpp

enum : unsigned {
     HdrVersion = 0xeffe0000 + 19990810,
   };
   ulittle32_t VerSignature;
   ulittle32_t VerHdr;
   ulittle32_t HrSize;
   ulittle32_t NumBuckets;
 };
 
-// This is HRFile.
-struct PublicsStream::HashRecord {
-  ulittle32_t Off; // Offset in the symbol record stream
-  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)
     : Pdb(File), StreamNum(StreamNum), Stream(StreamNum, File) {}
 
 PublicsStream::~PublicsStream() {}
 
 uint32_t PublicsStream::getSymHash() const { return Header->SymHash; }
 uint32_t PublicsStream::getAddrMap() const { return Header->AddrMap; }
 
if (Reader.readObject(Header))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Publics Stream does not contain a header.");
 
   if (Reader.readObject(HashHdr))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Publics Stream does not contain a header.");
 
   // An array of HashRecord follows. Read them.
-  if (HashHdr->HrSize % sizeof(HashRecord))
+  if (HashHdr->HrSize % sizeof(PSHashRecord))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Invalid HR array size.");
-  HashRecords.resize(HashHdr->HrSize / sizeof(HashRecord));
-  if (auto EC = Reader.readArray<HashRecord>(HashRecords))
+  uint32_t NumHashRecords = HashHdr->HrSize / sizeof(PSHashRecord);
+  if (auto EC = Reader.readArray(HashRecords, NumHashRecords))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read an HR array");
 
   // A bitmap of a fixed length follows.
   size_t BitmapSizeInBits = alignTo(IPHR_HASH + 1, 32);
-  std::vector<uint8_t> Bitmap(BitmapSizeInBits / 8);
-  if (auto EC = Reader.readArray<uint8_t>(Bitmap))
+  uint32_t NumBitmapEntries = BitmapSizeInBits / 8;
+  if (auto EC = Reader.readBytes(NumBitmapEntries, Bitmap))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read a bitmap.");
   for (uint8_t B : Bitmap)
     NumBuckets += countPopulation(B);
 
   // 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.
-  std::vector<ulittle32_t> TempHashBuckets(NumBuckets);
-  if (auto EC = Reader.readArray<ulittle32_t>(TempHashBuckets))
+  if (auto EC = Reader.readArray(HashBuckets, NumBuckets))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Hash buckets corrupted.");
-  HashBuckets.resize(NumBuckets);
-  std::copy(TempHashBuckets.begin(), TempHashBuckets.end(),
-            HashBuckets.begin());
 
   // Something called "address map" follows.
-  std::vector<ulittle32_t> TempAddressMap(Header->AddrMap / sizeof(uint32_t));
-  if (auto EC = Reader.readArray<ulittle32_t>(TempAddressMap))
+  uint32_t NumAddressMapEntries = Header->AddrMap / sizeof(uint32_t);
+  if (auto EC = Reader.readArray(AddressMap, NumAddressMapEntries))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read an address map.");
-  AddressMap.resize(Header->AddrMap / sizeof(uint32_t));
-  std::copy(TempAddressMap.begin(), TempAddressMap.end(), AddressMap.begin());
 
   // Something called "thunk map" follows.
-  std::vector<ulittle32_t> TempThunkMap(Header->NumThunks);
-  ThunkMap.resize(Header->NumThunks);
-  if (auto EC = Reader.readArray<ulittle32_t>(TempThunkMap))
+  if (auto EC = Reader.readArray(ThunkMap, Header->NumThunks))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read a thunk map.");
-  ThunkMap.resize(Header->NumThunks);
-  std::copy(TempThunkMap.begin(), TempThunkMap.end(), ThunkMap.begin());
 
   // Something called "section map" follows.
-  std::vector<SectionOffset> Offsets(Header->NumSections);
-  if (auto EC = Reader.readArray<SectionOffset>(Offsets))
+  if (auto EC = Reader.readArray(SectionOffsets, Header->NumSections))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read a section map.");
-  for (auto &SO : Offsets) {
-    SectionOffsets.push_back(SO.Off);
-    SectionOffsets.push_back(SO.Isect);
-  }
 
   if (Reader.bytesRemaining() > 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Corrupted publics stream.");
   return Error::success();
 }
 
 iterator_range<codeview::SymbolIterator> PublicsStream::getSymbols() const {

tools/llvm-pdbdump/llvm-pdbdump.cpp

auto TpiS = (StreamIdx == StreamTPI) ? File.getPDBTpiStream()
     if (HadError)
       return make_error<RawError>(raw_error_code::corrupt_file,
                                   "TPI stream contained corrupt record");
   }
   P.flush();
   return Error::success();
 }
 
+static void printSectionOffset(llvm::raw_ostream &OS,
+                               const SectionOffset &Off) {
+  OS << Off.Off << ", " << Off.Isect;
+}
+
 static Error dumpPublicsStream(ScopedPrinter &P, PDBFile &File,
                                codeview::CVTypeDumper &TD) {
   if (!opts::DumpPublics)
     return Error::success();
 
   DictScope D(P, "Publics Stream");
   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());
-  P.printList("Section Offsets", Publics.getSectionOffsets());
+  P.printList("Section Offsets", Publics.getSectionOffsets(),
+              printSectionOffset);
   ListScope L(P, "Symbols");
   codeview::CVSymbolDumper SD(P, TD, nullptr, false);
   for (auto S : Publics.getSymbols()) {
     DictScope DD(P, "");
 
     SD.dump(S);
     if (opts::DumpSymRecordBytes)
       P.printBinaryBlock("Bytes", S.Data);