diff options
52 files changed, 957 insertions, 857 deletions
diff --git a/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h b/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h index 30c13ce5880..7cd6b45ef50 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h +++ b/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h @@ -32,7 +32,7 @@ namespace msf { template <typename Kind> struct VarStreamArrayExtractor<codeview::CVRecord<Kind>> { - Error operator()(StreamRef Stream, uint32_t &Len, + Error operator()(ReadableStreamRef Stream, uint32_t &Len, codeview::CVRecord<Kind> &Item) const { using namespace codeview; const RecordPrefix *Prefix = nullptr; diff --git a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h index a530a5d888a..073031f84a1 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h +++ b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h @@ -59,15 +59,15 @@ struct ColumnNumberEntry { class ModuleSubstream { public: ModuleSubstream(); - ModuleSubstream(ModuleSubstreamKind Kind, msf::StreamRef Data); - static Error initialize(msf::StreamRef Stream, ModuleSubstream &Info); + ModuleSubstream(ModuleSubstreamKind Kind, msf::ReadableStreamRef Data); + static Error initialize(msf::ReadableStreamRef Stream, ModuleSubstream &Info); uint32_t getRecordLength() const; ModuleSubstreamKind getSubstreamKind() const; - msf::StreamRef getRecordData() const; + msf::ReadableStreamRef getRecordData() const; private: ModuleSubstreamKind Kind; - msf::StreamRef Data; + msf::ReadableStreamRef Data; }; typedef msf::VarStreamArray<ModuleSubstream> ModuleSubstreamArray; @@ -75,7 +75,7 @@ typedef msf::VarStreamArray<ModuleSubstream> ModuleSubstreamArray; namespace msf { template <> struct VarStreamArrayExtractor<codeview::ModuleSubstream> { - Error operator()(StreamRef Stream, uint32_t &Length, + Error operator()(ReadableStreamRef Stream, uint32_t &Length, codeview::ModuleSubstream &Info) const { if (auto EC = codeview::ModuleSubstream::initialize(Stream, Info)) return EC; diff --git a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h index 697bc7d787a..e1bc68f80e2 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h +++ b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h @@ -38,23 +38,24 @@ class IModuleSubstreamVisitor { public: virtual ~IModuleSubstreamVisitor() {} - virtual Error visitUnknown(ModuleSubstreamKind Kind, msf::StreamRef Data) = 0; - virtual Error visitSymbols(msf::StreamRef Data); - virtual Error visitLines(msf::StreamRef Data, + virtual Error visitUnknown(ModuleSubstreamKind Kind, + msf::ReadableStreamRef Data) = 0; + virtual Error visitSymbols(msf::ReadableStreamRef Data); + virtual Error visitLines(msf::ReadableStreamRef Data, const LineSubstreamHeader *Header, const LineInfoArray &Lines); - virtual Error visitStringTable(msf::StreamRef Data); - virtual Error visitFileChecksums(msf::StreamRef Data, + virtual Error visitStringTable(msf::ReadableStreamRef Data); + virtual Error visitFileChecksums(msf::ReadableStreamRef Data, const FileChecksumArray &Checksums); - virtual Error visitFrameData(msf::StreamRef Data); - virtual Error visitInlineeLines(msf::StreamRef Data); - virtual Error visitCrossScopeImports(msf::StreamRef Data); - virtual Error visitCrossScopeExports(msf::StreamRef Data); - virtual Error visitILLines(msf::StreamRef Data); - virtual Error visitFuncMDTokenMap(msf::StreamRef Data); - virtual Error visitTypeMDTokenMap(msf::StreamRef Data); - virtual Error visitMergedAssemblyInput(msf::StreamRef Data); - virtual Error visitCoffSymbolRVA(msf::StreamRef Data); + virtual Error visitFrameData(msf::ReadableStreamRef Data); + virtual Error visitInlineeLines(msf::ReadableStreamRef Data); + virtual Error visitCrossScopeImports(msf::ReadableStreamRef Data); + virtual Error visitCrossScopeExports(msf::ReadableStreamRef Data); + virtual Error visitILLines(msf::ReadableStreamRef Data); + virtual Error visitFuncMDTokenMap(msf::ReadableStreamRef Data); + virtual Error visitTypeMDTokenMap(msf::ReadableStreamRef Data); + virtual Error visitMergedAssemblyInput(msf::ReadableStreamRef Data); + virtual Error visitCoffSymbolRVA(msf::ReadableStreamRef Data); }; Error visitModuleSubstream(const ModuleSubstream &R, @@ -67,7 +68,7 @@ public: VarStreamArrayExtractor(const codeview::LineSubstreamHeader *Header) : Header(Header) {} - Error operator()(StreamRef Stream, uint32_t &Len, + Error operator()(ReadableStreamRef Stream, uint32_t &Len, codeview::LineColumnEntry &Item) const { using namespace codeview; const LineFileBlockHeader *BlockHeader; @@ -104,7 +105,7 @@ private: template <> class VarStreamArrayExtractor<codeview::FileChecksumEntry> { public: - Error operator()(StreamRef Stream, uint32_t &Len, + Error operator()(ReadableStreamRef Stream, uint32_t &Len, codeview::FileChecksumEntry &Item) const { using namespace codeview; const FileChecksum *Header; diff --git a/llvm/include/llvm/DebugInfo/Msf/ByteStream.h b/llvm/include/llvm/DebugInfo/Msf/ByteStream.h index 621848cf3d2..78ea1111975 100644 --- a/llvm/include/llvm/DebugInfo/Msf/ByteStream.h +++ b/llvm/include/llvm/DebugInfo/Msf/ByteStream.h @@ -12,45 +12,147 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/StringRef.h" +#include "llvm/DebugInfo/Msf/MsfError.h" #include "llvm/DebugInfo/Msf/StreamInterface.h" #include "llvm/Support/Error.h" +#include "llvm/Support/FileOutputBuffer.h" +#include "llvm/Support/MemoryBuffer.h" #include <cstdint> #include <memory> #include <type_traits> namespace llvm { namespace msf { -class StreamReader; - -template <bool Writable = false> class ByteStream : public StreamInterface { - typedef typename std::conditional<Writable, MutableArrayRef<uint8_t>, - ArrayRef<uint8_t>>::type ArrayType; +class ByteStream : public ReadableStream { public: ByteStream() {} - explicit ByteStream(ArrayType Data) : Data(Data) {} - ~ByteStream() override {} + explicit ByteStream(ArrayRef<uint8_t> Data) : Data(Data) {} Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const override; + ArrayRef<uint8_t> &Buffer) const override { + if (Offset > Data.size()) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + if (Data.size() < Size + Offset) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + Buffer = Data.slice(Offset, Size); + return Error::success(); + } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override; + ArrayRef<uint8_t> &Buffer) const override { + if (Offset >= Data.size()) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + Buffer = Data.slice(Offset); + return Error::success(); + } - Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override; + uint32_t getLength() const override { return Data.size(); } - uint32_t getLength() const override; + ArrayRef<uint8_t> data() const { return Data; } - Error commit() const override; + StringRef str() const { + const char *CharData = reinterpret_cast<const char *>(Data.data()); + return StringRef(CharData, Data.size()); + } - ArrayRef<uint8_t> data() const { return Data; } - StringRef str() const; +protected: + ArrayRef<uint8_t> Data; +}; + +// MemoryBufferByteStream behaves like a read-only ByteStream, but has its data +// backed by an llvm::MemoryBuffer. It also owns the underlying MemoryBuffer. +class MemoryBufferByteStream : public ByteStream { +public: + explicit MemoryBufferByteStream(std::unique_ptr<MemoryBuffer> Buffer) + : ByteStream(ArrayRef<uint8_t>(Buffer->getBuffer().bytes_begin(), + Buffer->getBuffer().bytes_end())), + MemBuffer(std::move(Buffer)) {} + + std::unique_ptr<MemoryBuffer> MemBuffer; +}; + +class MutableByteStream : public WritableStream { +public: + MutableByteStream() {} + explicit MutableByteStream(MutableArrayRef<uint8_t> Data) + : Data(Data), ImmutableStream(Data) {} + + Error readBytes(uint32_t Offset, uint32_t Size, + ArrayRef<uint8_t> &Buffer) const override { + return ImmutableStream.readBytes(Offset, Size, Buffer); + } + Error readLongestContiguousChunk(uint32_t Offset, + ArrayRef<uint8_t> &Buffer) const override { + return ImmutableStream.readLongestContiguousChunk(Offset, Buffer); + } + + uint32_t getLength() const override { return ImmutableStream.getLength(); } + + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override { + if (Data.size() < Buffer.size()) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + if (Offset > Buffer.size() - Data.size()) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + + uint8_t *DataPtr = const_cast<uint8_t *>(Data.data()); + ::memcpy(DataPtr + Offset, Buffer.data(), Buffer.size()); + return Error::success(); + } + + Error commit() const override { return Error::success(); } + + MutableArrayRef<uint8_t> data() const { return Data; } + +private: + MutableArrayRef<uint8_t> Data; + ByteStream ImmutableStream; +}; + +// A simple adapter that acts like a ByteStream but holds ownership over +// and underlying FileOutputBuffer. +class FileBufferByteStream : public WritableStream { +private: + class StreamImpl : public MutableByteStream { + public: + StreamImpl(std::unique_ptr<FileOutputBuffer> Buffer) + : MutableByteStream(MutableArrayRef<uint8_t>(Buffer->getBufferStart(), + Buffer->getBufferEnd())), + FileBuffer(std::move(Buffer)) {} + + Error commit() const override { + if (FileBuffer->commit()) + return llvm::make_error<MsfError>(msf_error_code::not_writable); + return Error::success(); + } + + private: + std::unique_ptr<FileOutputBuffer> FileBuffer; + }; + +public: + explicit FileBufferByteStream(std::unique_ptr<FileOutputBuffer> Buffer) + : Impl(std::move(Buffer)) {} + + Error readBytes(uint32_t Offset, uint32_t Size, + ArrayRef<uint8_t> &Buffer) const override { + return Impl.readBytes(Offset, Size, Buffer); + } + Error readLongestContiguousChunk(uint32_t Offset, + ArrayRef<uint8_t> &Buffer) const override { + return Impl.readLongestContiguousChunk(Offset, Buffer); + } + + uint32_t getLength() const override { return Impl.getLength(); } + + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const override { + return Impl.writeBytes(Offset, Data); + } + Error commit() const override { return Impl.commit(); } private: - ArrayType Data; + StreamImpl Impl; }; -extern template class ByteStream<true>; -extern template class ByteStream<false>; } // end namespace msf } // end namespace llvm diff --git a/llvm/include/llvm/DebugInfo/Msf/MappedBlockStream.h b/llvm/include/llvm/DebugInfo/Msf/MappedBlockStream.h index 94cff45d72a..f66826ba804 100644 --- a/llvm/include/llvm/DebugInfo/Msf/MappedBlockStream.h +++ b/llvm/include/llvm/DebugInfo/Msf/MappedBlockStream.h @@ -25,7 +25,7 @@ namespace llvm { namespace msf { -class IMsfFile; +struct MsfLayout; /// MappedBlockStream represents data stored in an Msf file into chunks of a /// particular size (called the Block Size), and whose chunks may not be @@ -37,42 +37,102 @@ class IMsfFile; /// the Msf. MappedBlockStream provides methods for reading from and writing /// to one of these streams transparently, as if it were a contiguous sequence /// of bytes. -class MappedBlockStream : public StreamInterface { +class MappedBlockStream : public ReadableStream { + friend class WritableMappedBlockStream; + public: + static std::unique_ptr<MappedBlockStream> + createStream(uint32_t BlockSize, uint32_t NumBlocks, + const MsfStreamLayout &Layout, const ReadableStream &MsfData); + + static std::unique_ptr<MappedBlockStream> + createIndexedStream(const MsfLayout &Layout, const ReadableStream &MsfData, + uint32_t StreamIndex); + + static std::unique_ptr<MappedBlockStream> + createDirectoryStream(const MsfLayout &Layout, const ReadableStream &MsfData); + Error readBytes(uint32_t Offset, uint32_t Size, ArrayRef<uint8_t> &Buffer) const override; Error readLongestContiguousChunk(uint32_t Offset, ArrayRef<uint8_t> &Buffer) const override; - Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override; uint32_t getLength() const override; - Error commit() const override; uint32_t getNumBytesCopied() const; - static Expected<std::unique_ptr<MappedBlockStream>> - createIndexedStream(uint32_t StreamIdx, const IMsfFile &File); - static Expected<std::unique_ptr<MappedBlockStream>> - createDirectoryStream(uint32_t Length, ArrayRef<support::ulittle32_t> Blocks, - const IMsfFile &File); - llvm::BumpPtrAllocator &getAllocator() { return Pool; } + void invalidateCache(); + + uint32_t getBlockSize() const { return BlockSize; } + uint32_t getNumBlocks() const { return NumBlocks; } + uint32_t getStreamLength() const { return StreamLayout.Length; } + protected: - MappedBlockStream(const MsfStreamLayout &Layout, const IMsfFile &File); + MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, + const MsfStreamLayout &StreamLayout, + const ReadableStream &MsfData); + +private: + const MsfStreamLayout &getStreamLayout() const { return StreamLayout; } + void fixCacheAfterWrite(uint32_t Offset, ArrayRef<uint8_t> Data) const; Error readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer) const; bool tryReadContiguously(uint32_t Offset, uint32_t Size, ArrayRef<uint8_t> &Buffer) const; - const IMsfFile &Msf; - const MsfStreamLayout Layout; + const uint32_t BlockSize; + const uint32_t NumBlocks; + const MsfStreamLayout StreamLayout; + const ReadableStream &MsfData; typedef MutableArrayRef<uint8_t> CacheEntry; mutable llvm::BumpPtrAllocator Pool; mutable DenseMap<uint32_t, std::vector<CacheEntry>> CacheMap; }; +class WritableMappedBlockStream : public WritableStream { +public: + static std::unique_ptr<WritableMappedBlockStream> + createStream(uint32_t BlockSize, uint32_t NumBlocks, + const MsfStreamLayout &Layout, const WritableStream &MsfData); + + static std::unique_ptr<WritableMappedBlockStream> + createIndexedStream(const MsfLayout &Layout, const WritableStream &MsfData, + uint32_t StreamIndex); + + static std::unique_ptr<WritableMappedBlockStream> + createDirectoryStream(const MsfLayout &Layout, const WritableStream &MsfData); + + Error readBytes(uint32_t Offset, uint32_t Size, + ArrayRef<uint8_t> &Buffer) const override; + Error readLongestContiguousChunk(uint32_t Offset, + ArrayRef<uint8_t> &Buffer) const override; + uint32_t getLength() const override; + + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override; + + Error commit() const override; + + const MsfStreamLayout &getStreamLayout() const { + return ReadInterface.getStreamLayout(); + } + uint32_t getBlockSize() const { return ReadInterface.getBlockSize(); } + uint32_t getNumBlocks() const { return ReadInterface.getNumBlocks(); } + uint32_t getStreamLength() const { return ReadInterface.getStreamLength(); } + +protected: + WritableMappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, + const MsfStreamLayout &StreamLayout, + const WritableStream &MsfData); + +private: + MappedBlockStream ReadInterface; + + const WritableStream &WriteInterface; +}; + } // end namespace pdb } // end namespace llvm diff --git a/llvm/include/llvm/DebugInfo/Msf/MsfBuilder.h b/llvm/include/llvm/DebugInfo/Msf/MsfBuilder.h index 814e1655745..0ccdd6f0149 100644 --- a/llvm/include/llvm/DebugInfo/Msf/MsfBuilder.h +++ b/llvm/include/llvm/DebugInfo/Msf/MsfBuilder.h @@ -111,7 +111,7 @@ public: /// Finalize the layout and build the headers and structures that describe the /// MSF layout and can be written directly to the MSF file. - Expected<Layout> build(); + Expected<MsfLayout> build(); private: MsfBuilder(uint32_t BlockSize, uint32_t MinBlockCount, bool CanGrow, diff --git a/llvm/include/llvm/DebugInfo/Msf/MsfCommon.h b/llvm/include/llvm/DebugInfo/Msf/MsfCommon.h index a53316cb657..86f20bd1711 100644 --- a/llvm/include/llvm/DebugInfo/Msf/MsfCommon.h +++ b/llvm/include/llvm/DebugInfo/Msf/MsfCommon.h @@ -48,8 +48,8 @@ struct SuperBlock { support::ulittle32_t BlockMapAddr; }; -struct Layout { - Layout() : SB(nullptr) {} +struct MsfLayout { + MsfLayout() : SB(nullptr) {} const SuperBlock *SB; ArrayRef<support::ulittle32_t> DirectoryBlocks; ArrayRef<support::ulittle32_t> StreamSizes; diff --git a/llvm/include/llvm/DebugInfo/Msf/StreamArray.h b/llvm/include/llvm/DebugInfo/Msf/StreamArray.h index dcdae8f00a0..569fb9bdd89 100644 --- a/llvm/include/llvm/DebugInfo/Msf/StreamArray.h +++ b/llvm/include/llvm/DebugInfo/Msf/StreamArray.h @@ -34,7 +34,8 @@ namespace msf { template <typename T> struct VarStreamArrayExtractor { // Method intentionally deleted. You must provide an explicit specialization // with the following method implemented. - Error operator()(StreamRef Stream, uint32_t &Len, T &Item) const = delete; + Error operator()(ReadableStreamRef Stream, uint32_t &Len, + T &Item) const = delete; }; /// VarStreamArray represents an array of variable length records backed by a @@ -83,8 +84,9 @@ public: VarStreamArray() {} explicit VarStreamArray(const Extractor &E) : E(E) {} - explicit VarStreamArray(StreamRef Stream) : Stream(Stream) {} - VarStreamArray(StreamRef Stream, const Extractor &E) : Stream(Stream), E(E) {} + explicit VarStreamArray(ReadableStreamRef Stream) : Stream(Stream) {} + VarStreamArray(ReadableStreamRef Stream, const Extractor &E) + : Stream(Stream), E(E) {} VarStreamArray(const VarStreamArray<ValueType, Extractor> &Other) : Stream(Other.Stream), E(Other.E) {} @@ -97,10 +99,10 @@ public: const Extractor &getExtractor() const { return E; } - StreamRef getUnderlyingStream() const { return Stream; } + ReadableStreamRef getUnderlyingStream() const { return Stream; } private: - StreamRef Stream; + ReadableStreamRef Stream; Extractor E; }; @@ -189,7 +191,7 @@ private: } ValueType ThisValue; - StreamRef IterRef; + ReadableStreamRef IterRef; const ArrayType *Array{nullptr}; uint32_t ThisLen{0}; bool HasError{false}; @@ -204,7 +206,7 @@ template <typename T> class FixedStreamArray { public: FixedStreamArray() : Stream() {} - FixedStreamArray(StreamRef Stream) : Stream(Stream) { + FixedStreamArray(ReadableStreamRef Stream) : Stream(Stream) { assert(Stream.getLength() % sizeof(T) == 0); } @@ -230,10 +232,10 @@ public: return FixedStreamArrayIterator<T>(*this, size()); } - StreamRef getUnderlyingStream() const { return Stream; } + ReadableStreamRef getUnderlyingStream() const { return Stream; } private: - StreamRef Stream; + ReadableStreamRef Stream; }; template <typename T> class FixedStreamArrayIterator { diff --git a/llvm/include/llvm/DebugInfo/Msf/StreamInterface.h b/llvm/include/llvm/DebugInfo/Msf/StreamInterface.h index 7a886e39289..78347e46c22 100644 --- a/llvm/include/llvm/DebugInfo/Msf/StreamInterface.h +++ b/llvm/include/llvm/DebugInfo/Msf/StreamInterface.h @@ -17,16 +17,9 @@ namespace llvm { namespace msf { -/// StreamInterface abstracts the notion of a data stream. This way, an -/// implementation could implement trivial reading from a contiguous memory -/// buffer or, as in the case of PDB files, reading from a set of possibly -/// discontiguous blocks. The implementation is required to return references -/// to stable memory, so if this is not possible (for example in the case of -/// a PDB file with discontiguous blocks, it must keep its own pool of temp -/// storage. -class StreamInterface { +class ReadableStream { public: - virtual ~StreamInterface() {} + virtual ~ReadableStream() {} // Given an offset into the stream and a number of bytes, attempt to read // the bytes and set the output ArrayRef to point to a reference into the @@ -39,13 +32,18 @@ public: virtual Error readLongestContiguousChunk(uint32_t Offset, ArrayRef<uint8_t> &Buffer) const = 0; + virtual uint32_t getLength() const = 0; +}; + +class WritableStream : public ReadableStream { +public: + virtual ~WritableStream() {} + // Attempt to write the given bytes into the stream at the desired offset. // This will always necessitate a copy. Cannot shrink or grow the stream, // only writes into existing allocated space. virtual Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const = 0; - virtual uint32_t getLength() const = 0; - virtual Error commit() const = 0; }; diff --git a/llvm/include/llvm/DebugInfo/Msf/StreamReader.h b/llvm/include/llvm/DebugInfo/Msf/StreamReader.h index 3d03f406551..31f437f87c9 100644 --- a/llvm/include/llvm/DebugInfo/Msf/StreamReader.h +++ b/llvm/include/llvm/DebugInfo/Msf/StreamReader.h @@ -14,6 +14,7 @@ #include "llvm/DebugInfo/Msf/MsfError.h" #include "llvm/DebugInfo/Msf/StreamArray.h" #include "llvm/DebugInfo/Msf/StreamInterface.h" +#include "llvm/DebugInfo/Msf/StreamRef.h" #include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" @@ -22,11 +23,9 @@ namespace llvm { namespace msf { -class StreamRef; - class StreamReader { public: - StreamReader(StreamRef Stream); + StreamReader(ReadableStreamRef Stream); Error readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer); Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size); @@ -34,8 +33,8 @@ public: 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 readStreamRef(ReadableStreamRef &Ref); + Error readStreamRef(ReadableStreamRef &Ref, uint32_t Length); template <typename T> Error readEnum(T &Dest) { typename std::underlying_type<T>::type N; @@ -72,7 +71,7 @@ public: template <typename T, typename U> Error readArray(VarStreamArray<T, U> &Array, uint32_t Size) { - StreamRef S; + ReadableStreamRef S; if (auto EC = readStreamRef(S, Size)) return EC; Array = VarStreamArray<T, U>(S, Array.getExtractor()); @@ -90,7 +89,7 @@ public: return make_error<MsfError>(msf_error_code::invalid_format); if (Offset + Length > Stream.getLength()) return make_error<MsfError>(msf_error_code::insufficient_buffer); - StreamRef View = Stream.slice(Offset, Length); + ReadableStreamRef View = Stream.slice(Offset, Length); Array = FixedStreamArray<T>(View); Offset += Length; return Error::success(); @@ -102,7 +101,7 @@ public: uint32_t bytesRemaining() const { return getLength() - getOffset(); } private: - StreamRef Stream; + ReadableStreamRef Stream; uint32_t Offset; }; } // namespace msf diff --git a/llvm/include/llvm/DebugInfo/Msf/StreamRef.h b/llvm/include/llvm/DebugInfo/Msf/StreamRef.h index e87d298a834..87e53ce4fa4 100644 --- a/llvm/include/llvm/DebugInfo/Msf/StreamRef.h +++ b/llvm/include/llvm/DebugInfo/Msf/StreamRef.h @@ -15,17 +15,63 @@ namespace llvm { namespace msf { - -class StreamRef { +template <class StreamType, class RefType> class StreamRefBase { public: - StreamRef() : Stream(nullptr), ViewOffset(0), Length(0) {} - StreamRef(const StreamInterface &Stream) - : Stream(&Stream), ViewOffset(0), Length(Stream.getLength()) {} - StreamRef(const StreamInterface &Stream, uint32_t Offset, uint32_t Length) + StreamRefBase() : Stream(nullptr), Length(0), ViewOffset(0) {} + StreamRefBase(const StreamType &Stream, uint32_t Offset, uint32_t Length) : Stream(&Stream), ViewOffset(Offset), Length(Length) {} + uint32_t getLength() const { return Length; } + const StreamType *getStream() const { return Stream; } + + RefType drop_front(uint32_t N) const { + if (!Stream) + return RefType(); + + N = std::min(N, Length); + return RefType(*Stream, ViewOffset + N, Length - N); + } + + RefType keep_front(uint32_t N) const { + if (!Stream) + return RefType(); + N = std::min(N, Length); + return RefType(*Stream, ViewOffset, N); + } + + RefType slice(uint32_t Offset, uint32_t Len) const { + return drop_front(Offset).keep_front(Len); + } + + bool operator==(const RefType &Other) const { + if (Stream != Other.Stream) + return false; + if (ViewOffset != Other.ViewOffset) + return false; + if (Length != Other.Length) + return false; + return true; + } + +protected: + const StreamType *Stream; + uint32_t ViewOffset; + uint32_t Length; +}; + +class ReadableStreamRef + : public StreamRefBase<ReadableStream, ReadableStreamRef> { +public: + ReadableStreamRef() : StreamRefBase() {} + ReadableStreamRef(const ReadableStream &Stream) + : StreamRefBase(Stream, 0, Stream.getLength()) {} + ReadableStreamRef(const ReadableStream &Stream, uint32_t Offset, + uint32_t Length) + : StreamRefBase(Stream, Offset, Length) {} + // Use StreamRef.slice() instead. - StreamRef(const StreamRef &S, uint32_t Offset, uint32_t Length) = delete; + ReadableStreamRef(const ReadableStreamRef &S, uint32_t Offset, + uint32_t Length) = delete; Error readBytes(uint32_t Offset, uint32_t Size, ArrayRef<uint8_t> &Buffer) const { @@ -53,6 +99,21 @@ public: Buffer = Buffer.slice(0, MaxLength); return Error::success(); } +}; + +class WritableStreamRef + : public StreamRefBase<WritableStream, WritableStreamRef> { +public: + WritableStreamRef() : StreamRefBase() {} + WritableStreamRef(const WritableStream &Stream) + : StreamRefBase(Stream, 0, Stream.getLength()) {} + WritableStreamRef(const WritableStream &Stream, uint32_t Offset, + uint32_t Length) + : StreamRefBase(Stream, Offset, Length) {} + + // Use StreamRef.slice() instead. + WritableStreamRef(const WritableStreamRef &S, uint32_t Offset, + uint32_t Length) = delete; Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const { if (Data.size() + Offset > Length) @@ -60,44 +121,9 @@ public: return Stream->writeBytes(ViewOffset + Offset, Data); } - uint32_t getLength() const { return Length; } - Error commit() const { return Stream->commit(); } - - StreamRef drop_front(uint32_t N) const { - if (!Stream) - return StreamRef(); - - N = std::min(N, Length); - return StreamRef(*Stream, ViewOffset + N, Length - N); - } - - StreamRef keep_front(uint32_t N) const { - if (!Stream) - return StreamRef(); - N = std::min(N, Length); - return StreamRef(*Stream, ViewOffset, N); - } - - StreamRef slice(uint32_t Offset, uint32_t Len) const { - return drop_front(Offset).keep_front(Len); - } - - bool operator==(const StreamRef &Other) const { - if (Stream != Other.Stream) - return false; - if (ViewOffset != Other.ViewOffset) - return false; - if (Length != Other.Length) - return false; - return true; - } - -private: - const StreamInterface *Stream; - uint32_t ViewOffset; - uint32_t Length; }; + } // namespace msf } // namespace llvm diff --git a/llvm/include/llvm/DebugInfo/Msf/StreamWriter.h b/llvm/include/llvm/DebugInfo/Msf/StreamWriter.h index a4cf3576a3e..04194892e9b 100644 --- a/llvm/include/llvm/DebugInfo/Msf/StreamWriter.h +++ b/llvm/include/llvm/DebugInfo/Msf/StreamWriter.h @@ -14,6 +14,7 @@ #include "llvm/DebugInfo/Msf/MsfError.h" #include "llvm/DebugInfo/Msf/StreamArray.h" #include "llvm/DebugInfo/Msf/StreamInterface.h" +#include "llvm/DebugInfo/Msf/StreamRef.h" #include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" @@ -22,19 +23,17 @@ namespace llvm { namespace msf { -class StreamRef; - class StreamWriter { public: - StreamWriter(StreamRef Stream); + StreamWriter(WritableStreamRef Stream); Error writeBytes(ArrayRef<uint8_t> Buffer); Error writeInteger(uint16_t Dest); Error writeInteger(uint32_t Dest); Error writeZeroString(StringRef Str); Error writeFixedString(StringRef Str); - Error writeStreamRef(StreamRef Ref); - Error writeStreamRef(StreamRef Ref, uint32_t Size); + Error writeStreamRef(ReadableStreamRef Ref); + Error writeStreamRef(ReadableStreamRef Ref, uint32_t Size); template <typename T> Error writeEnum(T Num) { return writeInteger( @@ -77,7 +76,7 @@ public: uint32_t bytesRemaining() const { return getLength() - getOffset(); } private: - StreamRef Stream; + WritableStreamRef Stream; uint32_t Offset; }; } // namespace msf diff --git a/llvm/include/llvm/DebugInfo/PDB/PDBTypes.h b/llvm/include/llvm/DebugInfo/PDB/PDBTypes.h index a9325a43436..0d232f15d74 100644 --- a/llvm/include/llvm/DebugInfo/PDB/PDBTypes.h +++ b/llvm/include/llvm/DebugInfo/PDB/PDBTypes.h @@ -12,9 +12,10 @@ #include "llvm/Config/llvm-config.h" #include "llvm/DebugInfo/CodeView/CodeView.h" -#include <functional> +#include "llvm/DebugInfo/PDB/Raw/RawTypes.h" #include <cstdint> #include <cstring> +#include <functional> namespace llvm { namespace pdb { @@ -73,13 +74,6 @@ enum class PDB_ReaderType { Raw = 1, }; -/// Defines a 128-bit unique identifier. This maps to a GUID on Windows, but -/// is abstracted here for the purposes of non-Windows platforms that don't have -/// the GUID structure defined. -struct PDB_UniqueId { - char Guid[16]; -}; - /// An enumeration indicating the type of data contained in this table. enum class PDB_TableType { Symbols, diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStream.h b/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStream.h index bbdf0dfd562..7802f48be2c 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStream.h @@ -77,8 +77,6 @@ public: msf::FixedStreamArray<SecMapEntry> getSectionMap() const; void visitSectionContributions(ISectionContribVisitor &Visitor) const; - Error commit(); - private: Error initializeModInfoArray(); Error initializeSectionContributionData(); @@ -93,14 +91,14 @@ private: std::vector<ModuleInfoEx> ModuleInfos; NameHashTable ECNames; - msf::StreamRef ModInfoSubstream; - msf::StreamRef SecContrSubstream; - msf::StreamRef SecMapSubstream; - msf::StreamRef FileInfoSubstream; - msf::StreamRef TypeServerMapSubstream; - msf::StreamRef ECSubstream; + msf::ReadableStreamRef ModInfoSubstream; + msf::ReadableStreamRef SecContrSubstream; + msf::ReadableStreamRef SecMapSubstream; + msf::ReadableStreamRef FileInfoSubstream; + msf::ReadableStreamRef TypeServerMapSubstream; + msf::ReadableStreamRef ECSubstream; - msf::StreamRef NamesBuffer; + msf::ReadableStreamRef NamesBuffer; msf::FixedStreamArray<support::ulittle16_t> DbgStreams; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h index 7abe9546f88..a3c8fc5dbbb 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h @@ -23,6 +23,7 @@ namespace llvm { namespace pdb { class DbiStream; +struct DbiStreamHeader; class PDBFile; class DbiStreamBuilder { @@ -45,9 +46,13 @@ public: Error addModuleInfo(StringRef ObjFile, StringRef Module); Error addModuleSourceFile(StringRef Module, StringRef File); - Expected<std::unique_ptr<DbiStream>> build(PDBFile &File); + Expected<std::unique_ptr<DbiStream>> build(PDBFile &File, + const msf::WritableStream &Buffer); + Error commit(const msf::MsfLayout &Layout, + const msf::WritableStream &Buffer) const; private: + Error finalize(); uint32_t calculateModiSubstreamSize() const; uint32_t calculateFileInfoSubstreamSize() const; uint32_t calculateNamesBufferSize() const; @@ -71,14 +76,16 @@ private: uint16_t Flags; PDB_Machine MachineType; + const DbiStreamHeader *Header; + StringMap<std::unique_ptr<ModuleInfo>> ModuleInfos; std::vector<ModuleInfo *> ModuleInfoList; StringMap<uint32_t> SourceFileNames; - msf::StreamRef NamesBuffer; - msf::ByteStream<true> ModInfoBuffer; - msf::ByteStream<true> FileInfoBuffer; + msf::WritableStreamRef NamesBuffer; + msf::MutableByteStream ModInfoBuffer; + msf::MutableByteStream FileInfoBuffer; }; } } diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStream.h b/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStream.h index bc6aebb156a..e71c63d0552 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStream.h @@ -27,18 +27,10 @@ class PDBFile; class InfoStream { friend class InfoStreamBuilder; - struct HeaderInfo { - support::ulittle32_t Version; - support::ulittle32_t Signature; - support::ulittle32_t Age; - PDB_UniqueId Guid; - }; - public: InfoStream(std::unique_ptr<msf::MappedBlockStream> Stream); Error reload(); - Error commit(); PdbRaw_ImplVer getVersion() const; uint32_t getSignature() const; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStreamBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStreamBuilder.h index e9869bb2786..f3c3eadcec6 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStreamBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/InfoStreamBuilder.h @@ -19,6 +19,9 @@ #include "llvm/DebugInfo/PDB/Raw/RawConstants.h" namespace llvm { +namespace msf { +class StreamWriter; +} namespace pdb { class PDBFile; @@ -37,13 +40,17 @@ public: uint32_t calculateSerializedLength() const; - Expected<std::unique_ptr<InfoStream>> build(PDBFile &File); + Expected<std::unique_ptr<InfoStream>> + build(PDBFile &File, const msf::WritableStream &Buffer); + + Error commit(const msf::MsfLayout &Layout, + const msf::WritableStream &Buffer) const; private: - Optional<PdbRaw_ImplVer> Ver; - Optional<uint32_t> Sig; - Optional<uint32_t> Age; - Optional<PDB_UniqueId> Guid; + PdbRaw_ImplVer Ver; + uint32_t Sig; + uint32_t Age; + PDB_UniqueId Guid; NameMapBuilder NamedStreams; }; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/ModInfo.h b/llvm/include/llvm/DebugInfo/PDB/Raw/ModInfo.h index cdb3735fcb4..e48b6aa15fa 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/ModInfo.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/ModInfo.h @@ -29,7 +29,7 @@ public: ModInfo(const ModInfo &Info); ~ModInfo(); - static Error initialize(msf::StreamRef Stream, ModInfo &Info); + static Error initialize(msf::ReadableStreamRef Stream, ModInfo &Info); bool hasECInfo() const; uint16_t getTypeServerIndex() const; @@ -65,7 +65,7 @@ struct ModuleInfoEx { namespace msf { template <> struct VarStreamArrayExtractor<pdb::ModInfo> { - Error operator()(StreamRef Stream, uint32_t &Length, + Error operator()(ReadableStreamRef Stream, uint32_t &Length, pdb::ModInfo &Info) const { if (auto EC = pdb::ModInfo::initialize(Stream, Info)) return EC; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/ModStream.h b/llvm/include/llvm/DebugInfo/PDB/Raw/ModStream.h index bee4075aaf2..57e84edc1bb 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/ModStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/ModStream.h @@ -46,9 +46,9 @@ private: std::unique_ptr<msf::MappedBlockStream> Stream; codeview::CVSymbolArray SymbolsSubstream; - msf::StreamRef LinesSubstream; - msf::StreamRef C13LinesSubstream; - msf::StreamRef GlobalRefsSubstream; + msf::ReadableStreamRef LinesSubstream; + msf::ReadableStreamRef C13LinesSubstream; + msf::ReadableStreamRef GlobalRefsSubstream; codeview::ModuleSubstreamArray LineInfo; }; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/NameHashTable.h b/llvm/include/llvm/DebugInfo/PDB/Raw/NameHashTable.h index 7de26f3b270..c9dd95d01c1 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/NameHashTable.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/NameHashTable.h @@ -41,7 +41,7 @@ public: msf::FixedStreamArray<support::ulittle32_t> name_ids() const; private: - msf::StreamRef NamesBuffer; + msf::ReadableStreamRef NamesBuffer; msf::FixedStreamArray<support::ulittle32_t> IDs; uint32_t Signature; uint32_t HashVersion; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/NameMap.h b/llvm/include/llvm/DebugInfo/PDB/Raw/NameMap.h index ca1a6541dfb..de1163bc307 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/NameMap.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/NameMap.h @@ -29,7 +29,6 @@ public: NameMap(); Error load(msf::StreamReader &Stream); - Error commit(msf::StreamWriter &Writer); bool tryGetValue(StringRef Name, uint32_t &Value) const; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/NameMapBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Raw/NameMapBuilder.h index bf49bfd9bf2..f5244ac2180 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/NameMapBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/NameMapBuilder.h @@ -17,6 +17,9 @@ #include <memory> namespace llvm { +namespace msf { +class StreamWriter; +} namespace pdb { class NameMap; @@ -27,6 +30,7 @@ public: void addMapping(StringRef Name, uint32_t Mapping); Expected<std::unique_ptr<NameMap>> build(); + Error commit(msf::StreamWriter &Writer) const; uint32_t calculateSerializedLength() const; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFile.h b/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFile.h index 2aaef3af838..b0be4fb4705 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFile.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFile.h @@ -26,7 +26,7 @@ namespace llvm { namespace msf { class MappedBlockStream; -class StreamInterface; +class WritableStream; } namespace pdb { @@ -42,7 +42,7 @@ class PDBFile : public msf::IMsfFile { friend PDBFileBuilder; public: - PDBFile(std::unique_ptr<msf::StreamInterface> PdbFileBuffer, + PDBFile(std::unique_ptr<msf::ReadableStream> PdbFileBuffer, BumpPtrAllocator &Allocator); ~PDBFile() override; @@ -68,12 +68,15 @@ public: ArrayRef<uint8_t> Data) const override; ArrayRef<support::ulittle32_t> getStreamSizes() const { - return MsfLayout.StreamSizes; + return ContainerLayout.StreamSizes; } ArrayRef<ArrayRef<support::ulittle32_t>> getStreamMap() const { - return MsfLayout.StreamMap; + return ContainerLayout.StreamMap; } + const msf::MsfLayout &getMsfLayout() const { return ContainerLayout; } + const msf::ReadableStream &getMsfBuffer() const { return *Buffer; } + ArrayRef<support::ulittle32_t> getDirectoryBlockArray() const; Error parseFileHeaders(); @@ -87,14 +90,12 @@ public: Expected<SymbolStream &> getPDBSymbolStream(); Expected<NameHashTable &> getStringTable(); - Error commit(); - private: BumpPtrAllocator &Allocator; - std::unique_ptr<msf::StreamInterface> Buffer; + std::unique_ptr<msf::ReadableStream> Buffer; - msf::Layout MsfLayout; + msf::MsfLayout ContainerLayout; std::unique_ptr<InfoStream> Info; std::unique_ptr<DbiStream> Dbi; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFileBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFileBuilder.h index c2effd170fd..6242f42e991 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFileBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/PDBFileBuilder.h @@ -24,7 +24,6 @@ namespace llvm { namespace msf { class MsfBuilder; -class StreamInterface; } namespace pdb { class DbiStreamBuilder; @@ -43,10 +42,12 @@ public: DbiStreamBuilder &getDbiBuilder(); Expected<std::unique_ptr<PDBFile>> - build(std::unique_ptr<msf::StreamInterface> PdbFileBuffer); + build(std::unique_ptr<msf::WritableStream> PdbFileBuffer); + + Error commit(const msf::WritableStream &Buffer); private: - Expected<msf::Layout> finalizeMsfLayout() const; + Expected<msf::MsfLayout> finalizeMsfLayout() const; BumpPtrAllocator &Allocator; diff --git a/llvm/include/llvm/DebugInfo/PDB/Raw/RawTypes.h b/llvm/include/llvm/DebugInfo/PDB/Raw/RawTypes.h index 8567f827e70..7edfbf0d250 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Raw/RawTypes.h +++ b/llvm/include/llvm/DebugInfo/PDB/Raw/RawTypes.h @@ -259,6 +259,21 @@ struct ModuleInfoHeader { /// char ObjFileName[]; }; +/// Defines a 128-bit unique identifier. This maps to a GUID on Windows, but +/// is abstracted here for the purposes of non-Windows platforms that don't have +/// the GUID structure defined. +struct PDB_UniqueId { + char Guid[16]; +}; + +/// The header preceeding the global PDB Stream (Stream 1) +struct InfoStreamHeader { + support::ulittle32_t Version; + support::ulittle32_t Signature; + support::ulittle32_t Age; + PDB_UniqueId Guid; +}; + } // namespace pdb } // namespace llvm diff --git a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp index 7e8f46b0a2a..874a154a954 100644 --- a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp @@ -475,7 +475,7 @@ void CodeViewDebug::emitTypeInformation() { // comments. The MSVC linker doesn't do much type record validation, // so the first link of an invalid type record can succeed while // subsequent links will fail with LNK1285. - ByteStream<> Stream({Record.bytes_begin(), Record.bytes_end()}); + ByteStream Stream({Record.bytes_begin(), Record.bytes_end()}); CVTypeArray Types; StreamReader Reader(Stream); Error E = Reader.readArray(Types, Reader.getLength()); diff --git a/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp b/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp index 5ab8212d3bd..6473338a272 100644 --- a/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp +++ b/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp @@ -17,10 +17,12 @@ using namespace llvm::msf; ModuleSubstream::ModuleSubstream() : Kind(ModuleSubstreamKind::None) {} -ModuleSubstream::ModuleSubstream(ModuleSubstreamKind Kind, StreamRef Data) +ModuleSubstream::ModuleSubstream(ModuleSubstreamKind Kind, + ReadableStreamRef Data) : Kind(Kind), Data(Data) {} -Error ModuleSubstream::initialize(StreamRef Stream, ModuleSubstream &Info) { +Error ModuleSubstream::initialize(ReadableStreamRef Stream, + ModuleSubstream &Info) { const ModuleSubsectionHeader *Header; StreamReader Reader(Stream); if (auto EC = Reader.readObject(Header)) @@ -40,4 +42,4 @@ uint32_t ModuleSubstream::getRecordLength() const { ModuleSubstreamKind ModuleSubstream::getSubstreamKind() const { return Kind; } -StreamRef ModuleSubstream::getRecordData() const { return Data; } +ReadableStreamRef ModuleSubstream::getRecordData() const { return Data; } diff --git a/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp b/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp index e6dcbc75a13..f5afe61efc2 100644 --- a/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp +++ b/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp @@ -15,46 +15,47 @@ using namespace llvm; using namespace llvm::codeview; using namespace llvm::msf; -Error IModuleSubstreamVisitor::visitSymbols(StreamRef Data) { +Error IModuleSubstreamVisitor::visitSymbols(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::Symbols, Data); } -Error IModuleSubstreamVisitor::visitLines(StreamRef Data, +Error IModuleSubstreamVisitor::visitLines(ReadableStreamRef Data, const LineSubstreamHeader *Header, const LineInfoArray &Lines) { return visitUnknown(ModuleSubstreamKind::Lines, Data); } -Error IModuleSubstreamVisitor::visitStringTable(StreamRef Data) { +Error IModuleSubstreamVisitor::visitStringTable(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::StringTable, Data); } Error IModuleSubstreamVisitor::visitFileChecksums( - StreamRef Data, const FileChecksumArray &Checksums) { + ReadableStreamRef Data, const FileChecksumArray &Checksums) { return visitUnknown(ModuleSubstreamKind::FileChecksums, Data); } -Error IModuleSubstreamVisitor::visitFrameData(StreamRef Data) { +Error IModuleSubstreamVisitor::visitFrameData(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::FrameData, Data); } -Error IModuleSubstreamVisitor::visitInlineeLines(StreamRef Data) { +Error IModuleSubstreamVisitor::visitInlineeLines(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::InlineeLines, Data); } -Error IModuleSubstreamVisitor::visitCrossScopeImports(StreamRef Data) { +Error IModuleSubstreamVisitor::visitCrossScopeImports(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CrossScopeExports, Data); } -Error IModuleSubstreamVisitor::visitCrossScopeExports(StreamRef Data) { +Error IModuleSubstreamVisitor::visitCrossScopeExports(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CrossScopeImports, Data); } -Error IModuleSubstreamVisitor::visitILLines(StreamRef Data) { +Error IModuleSubstreamVisitor::visitILLines(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::ILLines, Data); } -Error IModuleSubstreamVisitor::visitFuncMDTokenMap(StreamRef Data) { +Error IModuleSubstreamVisitor::visitFuncMDTokenMap(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::FuncMDTokenMap, Data); } -Error IModuleSubstreamVisitor::visitTypeMDTokenMap(StreamRef Data) { +Error IModuleSubstreamVisitor::visitTypeMDTokenMap(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::TypeMDTokenMap, Data); } -Error IModuleSubstreamVisitor::visitMergedAssemblyInput(StreamRef Data) { +Error IModuleSubstreamVisitor::visitMergedAssemblyInput( + ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::MergedAssemblyInput, Data); } -Error IModuleSubstreamVisitor::visitCoffSymbolRVA(StreamRef Data) { +Error IModuleSubstreamVisitor::visitCoffSymbolRVA(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CoffSymbolRVA, Data); } diff --git a/llvm/lib/DebugInfo/CodeView/TypeDumper.cpp b/llvm/lib/DebugInfo/CodeView/TypeDumper.cpp index cf5adb6b75e..428914b59a9 100644 --- a/llvm/lib/DebugInfo/CodeView/TypeDumper.cpp +++ b/llvm/lib/DebugInfo/CodeView/TypeDumper.cpp @@ -681,7 +681,7 @@ Error CVTypeDumper::dump(const CVTypeArray &Types) { } Error CVTypeDumper::dump(ArrayRef<uint8_t> Data) { - msf::ByteStream<> Stream(Data); + msf::ByteStream Stream(Data); CVTypeArray Types; msf::StreamReader Reader(Stream); if (auto EC = Reader.readArray(Types, Reader.getLength())) diff --git a/llvm/lib/DebugInfo/Msf/ByteStream.cpp b/llvm/lib/DebugInfo/Msf/ByteStream.cpp deleted file mode 100644 index 32fcbccaacc..00000000000 --- a/llvm/lib/DebugInfo/Msf/ByteStream.cpp +++ /dev/null @@ -1,79 +0,0 @@ -//===- ByteStream.cpp - Reads stream data from a byte sequence ------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "llvm/DebugInfo/Msf/ByteStream.h" -#include "llvm/DebugInfo/Msf/MsfError.h" -#include "llvm/DebugInfo/Msf/StreamReader.h" -#include <cstring> - -using namespace llvm; -using namespace llvm::msf; - -static Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Src, - ArrayRef<uint8_t> Dest) { - return make_error<MsfError>(msf_error_code::not_writable, - "ByteStream is immutable."); -} - -static Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Src, - MutableArrayRef<uint8_t> Dest) { - if (Dest.size() < Src.size()) - return make_error<MsfError>(msf_error_code::insufficient_buffer); - if (Offset > Src.size() - Dest.size()) - return make_error<MsfError>(msf_error_code::insufficient_buffer); - - ::memcpy(Dest.data() + Offset, Src.data(), Src.size()); - return Error::success(); -} - -template <bool Writable> -Error ByteStream<Writable>::readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const { - if (Offset > Data.size()) - return make_error<MsfError>(msf_error_code::insufficient_buffer); - if (Data.size() < Size + Offset) - return make_error<MsfError>(msf_error_code::insufficient_buffer); - Buffer = Data.slice(Offset, Size); - return Error::success(); -} - -template <bool Writable> -Error ByteStream<Writable>::readLongestContiguousChunk( - uint32_t Offset, ArrayRef<uint8_t> &Buffer) const { - if (Offset >= Data.size()) - return make_error<MsfError>(msf_error_code::insufficient_buffer); - Buffer = Data.slice(Offset); - return Error::success(); -} - -template <bool Writable> -Error ByteStream<Writable>::writeBytes(uint32_t Offset, - ArrayRef<uint8_t> Buffer) const { - return ::writeBytes(Offset, Buffer, Data); -} - -template <bool Writable> uint32_t ByteStream<Writable>::getLength() const { - return Data.size(); -} - -template <bool Writable> Error ByteStream<Writable>::commit() const { - return Error::success(); -} - -template <bool Writable> StringRef ByteStream<Writable>::str() const { - const char *CharData = reinterpret_cast<const char *>(Data.data()); - return StringRef(CharData, Data.size()); -} - -namespace llvm { -namespace msf { -template class ByteStream<true>; -template class ByteStream<false>; -} -} diff --git a/llvm/lib/DebugInfo/Msf/CMakeLists.txt b/llvm/lib/DebugInfo/Msf/CMakeLists.txt index 3be398bbbeb..5342c54fd20 100644 --- a/llvm/lib/DebugInfo/Msf/CMakeLists.txt +++ b/llvm/lib/DebugInfo/Msf/CMakeLists.txt @@ -1,5 +1,4 @@ add_llvm_library(LLVMDebugInfoMsf - ByteStream.cpp MappedBlockStream.cpp MsfBuilder.cpp MsfCommon.cpp diff --git a/llvm/lib/DebugInfo/Msf/MappedBlockStream.cpp b/llvm/lib/DebugInfo/Msf/MappedBlockStream.cpp index 06ca694174b..7d5be88c4d1 100644 --- a/llvm/lib/DebugInfo/Msf/MappedBlockStream.cpp +++ b/llvm/lib/DebugInfo/Msf/MappedBlockStream.cpp @@ -10,6 +10,7 @@ #include "llvm/DebugInfo/Msf/MappedBlockStream.h" #include "llvm/DebugInfo/Msf/IMsfFile.h" +#include "llvm/DebugInfo/Msf/MsfCommon.h" #include "llvm/DebugInfo/Msf/MsfError.h" #include "llvm/DebugInfo/Msf/MsfStreamLayout.h" @@ -17,13 +18,11 @@ using namespace llvm; using namespace llvm::msf; namespace { -// This exists so that we can use make_unique (which requires a public default -// constructor, while still keeping the constructor of MappedBlockStream -// protected, forcing users to go through the `create` interface. -class MappedBlockStreamImpl : public MappedBlockStream { +template <typename Base> class MappedBlockStreamImpl : public Base { public: - MappedBlockStreamImpl(const MsfStreamLayout &Layout, const IMsfFile &File) - : MappedBlockStream(Layout, File) {} + template <typename... Args> + MappedBlockStreamImpl(Args &&... Params) + : Base(std::forward<Args>(Params)...) {} }; } @@ -33,16 +32,46 @@ static Interval intersect(const Interval &I1, const Interval &I2) { std::min(I1.second, I2.second)); } -MappedBlockStream::MappedBlockStream(const MsfStreamLayout &Layout, - const IMsfFile &File) - : Msf(File), Layout(Layout) {} +MappedBlockStream::MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, + const MsfStreamLayout &Layout, + const ReadableStream &MsfData) + : BlockSize(BlockSize), NumBlocks(NumBlocks), StreamLayout(Layout), + MsfData(MsfData) {} + +std::unique_ptr<MappedBlockStream> +MappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks, + const MsfStreamLayout &Layout, + const ReadableStream &MsfData) { + return llvm::make_unique<MappedBlockStreamImpl<MappedBlockStream>>( + BlockSize, NumBlocks, Layout, MsfData); +} + +std::unique_ptr<MappedBlockStream> +MappedBlockStream::createIndexedStream(const MsfLayout &Layout, + const ReadableStream &MsfData, + uint32_t StreamIndex) { + MsfStreamLayout SL; + SL.Blocks = Layout.StreamMap[StreamIndex]; + SL.Length = Layout.StreamSizes[StreamIndex]; + return llvm::make_unique<MappedBlockStreamImpl<MappedBlockStream>>( + Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData); +} + +std::unique_ptr<MappedBlockStream> +MappedBlockStream::createDirectoryStream(const MsfLayout &Layout, + const ReadableStream &MsfData) { + MsfStreamLayout SL; + SL.Blocks = Layout.DirectoryBlocks; + SL.Length = Layout.SB->NumDirectoryBytes; + return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData); +} Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size, ArrayRef<uint8_t> &Buffer) const { // Make sure we aren't trying to read beyond the end of the stream. - if (Size > Layout.Length) + if (Size > StreamLayout.Length) return make_error<MsfError>(msf_error_code::insufficient_buffer); - if (Offset > Layout.Length - Size) + if (Offset > StreamLayout.Length - Size) return make_error<MsfError>(msf_error_code::insufficient_buffer); if (tryReadContiguously(Offset, Size, Buffer)) @@ -120,33 +149,33 @@ Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size, Error MappedBlockStream::readLongestContiguousChunk( uint32_t Offset, ArrayRef<uint8_t> &Buffer) const { // Make sure we aren't trying to read beyond the end of the stream. - if (Offset >= Layout.Length) + if (Offset >= StreamLayout.Length) return make_error<MsfError>(msf_error_code::insufficient_buffer); - uint32_t First = Offset / Msf.getBlockSize(); + uint32_t First = Offset / BlockSize; uint32_t Last = First; - while (Last < Msf.getBlockCount() - 1) { - if (Layout.Blocks[Last] != Layout.Blocks[Last + 1] - 1) + while (Last < NumBlocks - 1) { + if (StreamLayout.Blocks[Last] != StreamLayout.Blocks[Last + 1] - 1) break; ++Last; } - uint32_t OffsetInFirstBlock = Offset % Msf.getBlockSize(); - uint32_t BytesFromFirstBlock = Msf.getBlockSize() - OffsetInFirstBlock; + uint32_t OffsetInFirstBlock = Offset % BlockSize; + uint32_t BytesFromFirstBlock = BlockSize - OffsetInFirstBlock; uint32_t BlockSpan = Last - First + 1; - uint32_t ByteSpan = - BytesFromFirstBlock + (BlockSpan - 1) * Msf.getBlockSize(); - auto Result = Msf.getBlockData(Layout.Blocks[First], Msf.getBlockSize()); - if (!Result) - return Result.takeError(); - Buffer = Result->drop_front(OffsetInFirstBlock); - Buffer = ArrayRef<uint8_t>(Buffer.data(), ByteSpan); + uint32_t ByteSpan = BytesFromFirstBlock + (BlockSpan - 1) * BlockSize; + + ArrayRef<uint8_t> BlockData; + uint32_t MsfOffset = blockToOffset(StreamLayout.Blocks[First], BlockSize); + if (auto EC = MsfData.readBytes(MsfOffset, BlockSize, BlockData)) + return EC; + + BlockData = BlockData.drop_front(OffsetInFirstBlock); + Buffer = ArrayRef<uint8_t>(BlockData.data(), ByteSpan); return Error::success(); } -uint32_t MappedBlockStream::getLength() const { return Layout.Length; } - -Error MappedBlockStream::commit() const { return Error::success(); } +uint32_t MappedBlockStream::getLength() const { return StreamLayout.Length; } bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size, ArrayRef<uint8_t> &Buffer) const { @@ -155,57 +184,60 @@ bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size, // all subsequent blocks are contiguous. For example, a 10k read with a 4k // block size can be filled with a reference if, from the starting offset, // 3 blocks in a row are contiguous. - uint32_t BlockNum = Offset / Msf.getBlockSize(); - uint32_t OffsetInBlock = Offset % Msf.getBlockSize(); - uint32_t BytesFromFirstBlock = - std::min(Size, Msf.getBlockSize() - OffsetInBlock); + uint32_t BlockNum = Offset / BlockSize; + uint32_t OffsetInBlock = Offset % BlockSize; + uint32_t BytesFromFirstBlock = std::min(Size, BlockSize - OffsetInBlock); uint32_t NumAdditionalBlocks = - llvm::alignTo(Size - BytesFromFirstBlock, Msf.getBlockSize()) / - Msf.getBlockSize(); + llvm::alignTo(Size - BytesFromFirstBlock, BlockSize) / BlockSize; uint32_t RequiredContiguousBlocks = NumAdditionalBlocks + 1; - uint32_t E = Layout.Blocks[BlockNum]; + uint32_t E = StreamLayout.Blocks[BlockNum]; for (uint32_t I = 0; I < RequiredContiguousBlocks; ++I, ++E) { - if (Layout.Blocks[I + BlockNum] != E) + if (StreamLayout.Blocks[I + BlockNum] != E) return false; } - uint32_t FirstBlockAddr = Layout.Blocks[BlockNum]; - auto Result = Msf.getBlockData(FirstBlockAddr, Msf.getBlockSize()); - if (!Result) { - consumeError(Result.takeError()); + // Read out the entire block where the requested offset starts. Then drop + // bytes from the beginning so that the actual starting byte lines up with + // the requested starting byte. Then, since we know this is a contiguous + // cross-block span, explicitly resize the ArrayRef to cover the entire + // request length. + ArrayRef<uint8_t> BlockData; + uint32_t FirstBlockAddr = StreamLayout.Blocks[BlockNum]; + uint32_t MsfOffset = blockToOffset(FirstBlockAddr, BlockSize); + if (auto EC = MsfData.readBytes(MsfOffset, BlockSize, BlockData)) { + consumeError(std::move(EC)); return false; } - auto Data = Result->drop_front(OffsetInBlock); - Buffer = ArrayRef<uint8_t>(Data.data(), Size); + BlockData = BlockData.drop_front(OffsetInBlock); + Buffer = ArrayRef<uint8_t>(BlockData.data(), Size); return true; } Error MappedBlockStream::readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer) const { - uint32_t BlockNum = Offset / Msf.getBlockSize(); - uint32_t OffsetInBlock = Offset % Msf.getBlockSize(); + uint32_t BlockNum = Offset / BlockSize; + uint32_t OffsetInBlock = Offset % BlockSize; // Make sure we aren't trying to read beyond the end of the stream. - if (Buffer.size() > Layout.Length) + if (Buffer.size() > StreamLayout.Length) return make_error<MsfError>(msf_error_code::insufficient_buffer); - if (Offset > Layout.Length - Buffer.size()) + if (Offset > StreamLayout.Length - Buffer.size()) return make_error<MsfError>(msf_error_code::insufficient_buffer); uint32_t BytesLeft = Buffer.size(); uint32_t BytesWritten = 0; uint8_t *WriteBuffer = Buffer.data(); while (BytesLeft > 0) { - uint32_t StreamBlockAddr = Layout.Blocks[BlockNum]; + uint32_t StreamBlockAddr = StreamLayout.Blocks[BlockNum]; - auto Result = Msf.getBlockData(StreamBlockAddr, Msf.getBlockSize()); - if (!Result) - return Result.takeError(); + ArrayRef<uint8_t> BlockData; + uint32_t Offset = blockToOffset(StreamBlockAddr, BlockSize); + if (auto EC = MsfData.readBytes(Offset, BlockSize, BlockData)) + return EC; - auto Data = *Result; - const uint8_t *ChunkStart = Data.data() + OffsetInBlock; - uint32_t BytesInChunk = - std::min(BytesLeft, Msf.getBlockSize() - OffsetInBlock); + const uint8_t *ChunkStart = BlockData.data() + OffsetInBlock; + uint32_t BytesInChunk = std::min(BytesLeft, BlockSize - OffsetInBlock); ::memcpy(WriteBuffer + BytesWritten, ChunkStart, BytesInChunk); BytesWritten += BytesInChunk; @@ -217,36 +249,14 @@ Error MappedBlockStream::readBytes(uint32_t Offset, return Error::success(); } -Error MappedBlockStream::writeBytes(uint32_t Offset, - ArrayRef<uint8_t> Buffer) const { - // Make sure we aren't trying to write beyond the end of the stream. - if (Buffer.size() > Layout.Length) - return make_error<MsfError>(msf_error_code::insufficient_buffer); - - if (Offset > Layout.Length - Buffer.size()) - return make_error<MsfError>(msf_error_code::insufficient_buffer); - - uint32_t BlockNum = Offset / Msf.getBlockSize(); - uint32_t OffsetInBlock = Offset % Msf.getBlockSize(); - - uint32_t BytesLeft = Buffer.size(); - uint32_t BytesWritten = 0; - while (BytesLeft > 0) { - uint32_t StreamBlockAddr = Layout.Blocks[BlockNum]; - uint32_t BytesToWriteInChunk = - std::min(BytesLeft, Msf.getBlockSize() - OffsetInBlock); - - const uint8_t *Chunk = Buffer.data() + BytesWritten; - ArrayRef<uint8_t> ChunkData(Chunk, BytesToWriteInChunk); - if (auto EC = Msf.setBlockData(StreamBlockAddr, OffsetInBlock, ChunkData)) - return EC; +uint32_t MappedBlockStream::getNumBytesCopied() const { + return static_cast<uint32_t>(Pool.getBytesAllocated()); +} - BytesLeft -= BytesToWriteInChunk; - BytesWritten += BytesToWriteInChunk; - ++BlockNum; - OffsetInBlock = 0; - } +void MappedBlockStream::invalidateCache() { CacheMap.shrink_and_clear(); } +void MappedBlockStream::fixCacheAfterWrite(uint32_t Offset, + ArrayRef<uint8_t> Data) const { // If this write overlapped a read which previously came from the pool, // someone may still be holding a pointer to that alloc which is now invalid. // Compute the overlapping range and update the cache entry, so any @@ -254,7 +264,7 @@ Error MappedBlockStream::writeBytes(uint32_t Offset, for (const auto &MapEntry : CacheMap) { // If the end of the written extent precedes the beginning of the cached // extent, ignore this map entry. - if (Offset + BytesWritten < MapEntry.first) + if (Offset + Data.size() < MapEntry.first) continue; for (const auto &Alloc : MapEntry.second) { // If the end of the cached extent precedes the beginning of the written @@ -263,7 +273,7 @@ Error MappedBlockStream::writeBytes(uint32_t Offset, continue; // If we get here, they are guaranteed to overlap. - Interval WriteInterval = std::make_pair(Offset, Offset + BytesWritten); + Interval WriteInterval = std::make_pair(Offset, Offset + Data.size()); Interval CachedInterval = std::make_pair(MapEntry.first, MapEntry.first + Alloc.size()); // If they overlap, we need to write the new data into the overlapping @@ -276,35 +286,95 @@ Error MappedBlockStream::writeBytes(uint32_t Offset, AbsoluteDifference(WriteInterval.first, Intersection.first); uint32_t DestOffset = AbsoluteDifference(CachedInterval.first, Intersection.first); - ::memcpy(Alloc.data() + DestOffset, Buffer.data() + SrcOffset, Length); + ::memcpy(Alloc.data() + DestOffset, Data.data() + SrcOffset, Length); } } +} - return Error::success(); +WritableMappedBlockStream::WritableMappedBlockStream( + uint32_t BlockSize, uint32_t NumBlocks, const MsfStreamLayout &Layout, + const WritableStream &MsfData) + : ReadInterface(BlockSize, NumBlocks, Layout, MsfData), + WriteInterface(MsfData) {} + +std::unique_ptr<WritableMappedBlockStream> +WritableMappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks, + const MsfStreamLayout &Layout, + const WritableStream &MsfData) { + return llvm::make_unique<MappedBlockStreamImpl<WritableMappedBlockStream>>( + BlockSize, NumBlocks, Layout, MsfData); } -uint32_t MappedBlockStream::getNumBytesCopied() const { - return static_cast<uint32_t>(Pool.getBytesAllocated()); +std::unique_ptr<WritableMappedBlockStream> +WritableMappedBlockStream::createIndexedStream(const MsfLayout &Layout, + const WritableStream &MsfData, + uint32_t StreamIndex) { + MsfStreamLayout SL; + SL.Blocks = Layout.StreamMap[StreamIndex]; + SL.Length = Layout.StreamSizes[StreamIndex]; + return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData); +} + +std::unique_ptr<WritableMappedBlockStream> +WritableMappedBlockStream::createDirectoryStream( + const MsfLayout &Layout, const WritableStream &MsfData) { + MsfStreamLayout SL; + SL.Blocks = Layout.DirectoryBlocks; + SL.Length = Layout.SB->NumDirectoryBytes; + return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData); +} + +Error WritableMappedBlockStream::readBytes(uint32_t Offset, uint32_t Size, + ArrayRef<uint8_t> &Buffer) const { + return ReadInterface.readBytes(Offset, Size, Buffer); +} + +Error WritableMappedBlockStream::readLongestContiguousChunk( + uint32_t Offset, ArrayRef<uint8_t> &Buffer) const { + return ReadInterface.readLongestContiguousChunk(Offset, Buffer); } -Expected<std::unique_ptr<MappedBlockStream>> -MappedBlockStream::createIndexedStream(uint32_t StreamIdx, - const IMsfFile &File) { - if (StreamIdx >= File.getNumStreams()) - return make_error<MsfError>(msf_error_code::no_stream); - MsfStreamLayout L; - L.Blocks = File.getStreamBlockList(StreamIdx); - L.Length = File.getStreamByteSize(StreamIdx); - return llvm::make_unique<MappedBlockStreamImpl>(L, File); +uint32_t WritableMappedBlockStream::getLength() const { + return ReadInterface.getLength(); } -Expected<std::unique_ptr<MappedBlockStream>> -MappedBlockStream::createDirectoryStream(uint32_t Length, - ArrayRef<support::ulittle32_t> Blocks, - const IMsfFile &File) { - MsfStreamLayout L; - L.Blocks = Blocks; - L.Length = Length; +Error WritableMappedBlockStream::writeBytes(uint32_t Offset, + ArrayRef<uint8_t> Buffer) const { + // Make sure we aren't trying to write beyond the end of the stream. + if (Buffer.size() > getStreamLength()) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + + if (Offset > getStreamLayout().Length - Buffer.size()) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + + uint32_t BlockNum = Offset / getBlockSize(); + uint32_t OffsetInBlock = Offset % getBlockSize(); + + uint32_t BytesLeft = Buffer.size(); + uint32_t BytesWritten = 0; + while (BytesLeft > 0) { + uint32_t StreamBlockAddr = getStreamLayout().Blocks[BlockNum]; + uint32_t BytesToWriteInChunk = + std::min(BytesLeft, getBlockSize() - OffsetInBlock); + + const uint8_t *Chunk = Buffer.data() + BytesWritten; + ArrayRef<uint8_t> ChunkData(Chunk, BytesToWriteInChunk); + uint32_t MsfOffset = blockToOffset(StreamBlockAddr, getBlockSize()); + MsfOffset += OffsetInBlock; + if (auto EC = WriteInterface.writeBytes(MsfOffset, ChunkData)) + return EC; + + BytesLeft -= BytesToWriteInChunk; + BytesWritten += BytesToWriteInChunk; + ++BlockNum; + OffsetInBlock = 0; + } + + ReadInterface.fixCacheAfterWrite(Offset, Buffer); + + return Error::success(); +} - return llvm::make_unique<MappedBlockStreamImpl>(L, File); +Error WritableMappedBlockStream::commit() const { + return WriteInterface.commit(); } diff --git a/llvm/lib/DebugInfo/Msf/MsfBuilder.cpp b/llvm/lib/DebugInfo/Msf/MsfBuilder.cpp index 9a780d138aa..0128264b9ec 100644 --- a/llvm/lib/DebugInfo/Msf/MsfBuilder.cpp +++ b/llvm/lib/DebugInfo/Msf/MsfBuilder.cpp @@ -1,4 +1,3 @@ -//===- MSFBuilder.cpp - MSF Directory & Metadata Builder --------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -218,9 +217,9 @@ uint32_t MsfBuilder::computeDirectoryByteSize() const { return Size; } -Expected<Layout> MsfBuilder::build() { +Expected<MsfLayout> MsfBuilder::build() { SuperBlock *SB = Allocator.Allocate<SuperBlock>(); - Layout L; + MsfLayout L; L.SB = SB; std::memcpy(SB->MagicBytes, Magic, sizeof(Magic)); diff --git a/llvm/lib/DebugInfo/Msf/StreamReader.cpp b/llvm/lib/DebugInfo/Msf/StreamReader.cpp index a2f0f49c3d9..1c7e8352130 100644 --- a/llvm/lib/DebugInfo/Msf/StreamReader.cpp +++ b/llvm/lib/DebugInfo/Msf/StreamReader.cpp @@ -15,7 +15,7 @@ using namespace llvm; using namespace llvm::msf; -StreamReader::StreamReader(StreamRef S) : Stream(S), Offset(0) {} +StreamReader::StreamReader(ReadableStreamRef S) : Stream(S), Offset(0) {} Error StreamReader::readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer) { if (auto EC = Stream.readLongestContiguousChunk(Offset, Buffer)) @@ -80,11 +80,11 @@ Error StreamReader::readFixedString(StringRef &Dest, uint32_t Length) { return Error::success(); } -Error StreamReader::readStreamRef(StreamRef &Ref) { +Error StreamReader::readStreamRef(ReadableStreamRef &Ref) { return readStreamRef(Ref, bytesRemaining()); } -Error StreamReader::readStreamRef(StreamRef &Ref, uint32_t Length) { +Error StreamReader::readStreamRef(ReadableStreamRef &Ref, uint32_t Length) { if (bytesRemaining() < Length) return make_error<MsfError>(msf_error_code::insufficient_buffer); Ref = Stream.slice(Offset, Length); diff --git a/llvm/lib/DebugInfo/Msf/StreamWriter.cpp b/llvm/lib/DebugInfo/Msf/StreamWriter.cpp index eb11012c475..40bc0394b11 100644 --- a/llvm/lib/DebugInfo/Msf/StreamWriter.cpp +++ b/llvm/lib/DebugInfo/Msf/StreamWriter.cpp @@ -16,7 +16,7 @@ using namespace llvm; using namespace llvm::msf; -StreamWriter::StreamWriter(StreamRef S) : Stream(S), Offset(0) {} +StreamWriter::StreamWriter(WritableStreamRef S) : Stream(S), Offset(0) {} Error StreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) { if (auto EC = Stream.writeBytes(Offset, Buffer)) @@ -51,7 +51,7 @@ Error StreamWriter::writeFixedString(StringRef Str) { return Error::success(); } -Error StreamWriter::writeStreamRef(StreamRef Ref) { +Error StreamWriter::writeStreamRef(ReadableStreamRef Ref) { if (auto EC = writeStreamRef(Ref, Ref.getLength())) return EC; // Don't increment Offset here, it is done by the overloaded call to @@ -59,7 +59,7 @@ Error StreamWriter::writeStreamRef(StreamRef Ref) { return Error::success(); } -Error StreamWriter::writeStreamRef(StreamRef Ref, uint32_t Length) { +Error StreamWriter::writeStreamRef(ReadableStreamRef Ref, uint32_t Length) { Ref = Ref.slice(0, Length); StreamReader SrcReader(Ref); diff --git a/llvm/lib/DebugInfo/PDB/Raw/DbiStream.cpp b/llvm/lib/DebugInfo/PDB/Raw/DbiStream.cpp index 35f79c801ba..564246a332d 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/DbiStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/DbiStream.cpp @@ -272,22 +272,21 @@ Error DbiStream::initializeSectionHeadersData() { if (StreamNum >= Pdb.getNumStreams()) return make_error<RawError>(raw_error_code::no_stream); - auto SHS = MappedBlockStream::createIndexedStream(StreamNum, Pdb); - if (!SHS) - return SHS.takeError(); + auto SHS = MappedBlockStream::createIndexedStream( + Pdb.getMsfLayout(), Pdb.getMsfBuffer(), StreamNum); - size_t StreamLen = (*SHS)->getLength(); + size_t StreamLen = SHS->getLength(); if (StreamLen % sizeof(object::coff_section)) return make_error<RawError>(raw_error_code::corrupt_file, "Corrupted section header stream."); size_t NumSections = StreamLen / sizeof(object::coff_section); - msf::StreamReader Reader(**SHS); + msf::StreamReader Reader(*SHS); if (auto EC = Reader.readArray(SectionHeaders, NumSections)) return make_error<RawError>(raw_error_code::corrupt_file, "Could not read a bitmap."); - SectionHeaderStream = std::move(*SHS); + SectionHeaderStream = std::move(SHS); return Error::success(); } @@ -305,21 +304,20 @@ Error DbiStream::initializeFpoRecords() { if (StreamNum >= Pdb.getNumStreams()) return make_error<RawError>(raw_error_code::no_stream); - auto FS = MappedBlockStream::createIndexedStream(StreamNum, Pdb); - if (!FS) - return FS.takeError(); + auto FS = MappedBlockStream::createIndexedStream( + Pdb.getMsfLayout(), Pdb.getMsfBuffer(), StreamNum); - size_t StreamLen = (*FS)->getLength(); + size_t StreamLen = FS->getLength(); if (StreamLen % sizeof(object::FpoData)) return make_error<RawError>(raw_error_code::corrupt_file, "Corrupted New FPO stream."); size_t NumRecords = StreamLen / sizeof(object::FpoData); - msf::StreamReader Reader(**FS); + msf::StreamReader Reader(*FS); if (auto EC = Reader.readArray(FpoRecords, NumRecords)) return make_error<RawError>(raw_error_code::corrupt_file, "Corrupted New FPO stream."); - FpoStream = std::move(*FS); + FpoStream = std::move(FS); return Error::success(); } @@ -421,32 +419,3 @@ Expected<StringRef> DbiStream::getFileNameForIndex(uint32_t Index) const { return std::move(EC); return Name; } - -Error DbiStream::commit() { - StreamWriter Writer(*Stream); - if (auto EC = Writer.writeObject(*Header)) - return EC; - - if (auto EC = Writer.writeStreamRef(ModInfoSubstream)) - return EC; - - if (auto EC = Writer.writeStreamRef(SecContrSubstream, - SecContrSubstream.getLength())) - return EC; - if (auto EC = - Writer.writeStreamRef(SecMapSubstream, SecMapSubstream.getLength())) - return EC; - if (auto EC = Writer.writeStreamRef(FileInfoSubstream, - FileInfoSubstream.getLength())) - return EC; - if (auto EC = Writer.writeStreamRef(TypeServerMapSubstream, - TypeServerMapSubstream.getLength())) - return EC; - if (auto EC = Writer.writeStreamRef(ECSubstream, ECSubstream.getLength())) - return EC; - - if (Writer.bytesRemaining() > 0) - return make_error<RawError>(raw_error_code::invalid_format, - "Unexpected bytes found in DBI Stream"); - return Error::success(); -} diff --git a/llvm/lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp b/llvm/lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp index 7a688cb8968..6e1282263f6 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/DbiStreamBuilder.cpp @@ -25,7 +25,7 @@ class ModiSubstreamBuilder {}; DbiStreamBuilder::DbiStreamBuilder(BumpPtrAllocator &Allocator) : Allocator(Allocator), Age(1), BuildNumber(0), PdbDllVersion(0), - PdbDllRbld(0), Flags(0), MachineType(PDB_Machine::x86) {} + PdbDllRbld(0), Flags(0), MachineType(PDB_Machine::x86), Header(nullptr) {} void DbiStreamBuilder::setVersionHeader(PdbRaw_DbiVer V) { VerHeader = V; } @@ -108,7 +108,7 @@ Error DbiStreamBuilder::generateModiSubstream() { uint32_t Size = calculateModiSubstreamSize(); auto Data = Allocator.Allocate<uint8_t>(Size); - ModInfoBuffer = ByteStream<true>(MutableArrayRef<uint8_t>(Data, Size)); + ModInfoBuffer = MutableByteStream(MutableArrayRef<uint8_t>(Data, Size)); StreamWriter ModiWriter(ModInfoBuffer); for (const auto &M : ModuleInfoList) { @@ -134,9 +134,10 @@ Error DbiStreamBuilder::generateFileInfoSubstream() { auto Data = Allocator.Allocate<uint8_t>(Size); uint32_t NamesOffset = Size - NameSize; - FileInfoBuffer = ByteStream<true>(MutableArrayRef<uint8_t>(Data, Size)); + FileInfoBuffer = MutableByteStream(MutableArrayRef<uint8_t>(Data, Size)); - StreamRef MetadataBuffer = StreamRef(FileInfoBuffer).keep_front(NamesOffset); + WritableStreamRef MetadataBuffer = + WritableStreamRef(FileInfoBuffer).keep_front(NamesOffset); StreamWriter MetadataWriter(MetadataBuffer); uint16_t ModiCount = std::min<uint16_t>(UINT16_MAX, ModuleInfos.size()); @@ -159,7 +160,7 @@ Error DbiStreamBuilder::generateFileInfoSubstream() { // A side effect of this is that this will actually compute the various // file name offsets, so we can then go back and write the FileNameOffsets // array to the other substream. - NamesBuffer = StreamRef(FileInfoBuffer).drop_front(NamesOffset); + NamesBuffer = WritableStreamRef(FileInfoBuffer).drop_front(NamesOffset); StreamWriter NameBufferWriter(NamesBuffer); for (auto &Name : SourceFileNames) { Name.second = NameBufferWriter.getOffset(); @@ -190,16 +191,11 @@ Error DbiStreamBuilder::generateFileInfoSubstream() { return Error::success(); } -Expected<std::unique_ptr<DbiStream>> DbiStreamBuilder::build(PDBFile &File) { - if (!VerHeader.hasValue()) - return make_error<RawError>(raw_error_code::unspecified, - "Missing DBI Stream Version"); +Error DbiStreamBuilder::finalize() { + if (Header) + return Error::success(); - auto DbiS = MappedBlockStream::createIndexedStream(StreamDBI, File); - if (!DbiS) - return DbiS.takeError(); - auto DS = std::move(*DbiS); - DbiStreamHeader *H = DS->getAllocator().Allocate<DbiStreamHeader>(1); + DbiStreamHeader *H = Allocator.Allocate<DbiStreamHeader>(); if (auto EC = generateModiSubstream()) return std::move(EC); @@ -227,13 +223,47 @@ Expected<std::unique_ptr<DbiStream>> DbiStreamBuilder::build(PDBFile &File) { H->MFCTypeServerIndex = kInvalidStreamIndex; H->GlobalSymbolStreamIndex = kInvalidStreamIndex; - auto Dbi = llvm::make_unique<DbiStream>(File, std::move(DS)); - Dbi->Header = H; - Dbi->FileInfoSubstream = StreamRef(FileInfoBuffer); - Dbi->ModInfoSubstream = StreamRef(ModInfoBuffer); + Header = H; + return Error::success(); +} + +Expected<std::unique_ptr<DbiStream>> +DbiStreamBuilder::build(PDBFile &File, const msf::WritableStream &Buffer) { + if (!VerHeader.hasValue()) + return make_error<RawError>(raw_error_code::unspecified, + "Missing DBI Stream Version"); + if (auto EC = finalize()) + return std::move(EC); + + auto StreamData = MappedBlockStream::createIndexedStream(File.getMsfLayout(), + Buffer, StreamDBI); + auto Dbi = llvm::make_unique<DbiStream>(File, std::move(StreamData)); + Dbi->Header = Header; + Dbi->FileInfoSubstream = ReadableStreamRef(FileInfoBuffer); + Dbi->ModInfoSubstream = ReadableStreamRef(ModInfoBuffer); if (auto EC = Dbi->initializeModInfoArray()) return std::move(EC); if (auto EC = Dbi->initializeFileInfo()) return std::move(EC); return std::move(Dbi); } + +Error DbiStreamBuilder::commit(const msf::MsfLayout &Layout, + const msf::WritableStream &Buffer) const { + auto InfoS = + WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamDBI); + + StreamWriter Writer(*InfoS); + if (auto EC = Writer.writeObject(*Header)) + return EC; + + if (auto EC = Writer.writeStreamRef(ModInfoBuffer)) + return EC; + if (auto EC = Writer.writeStreamRef(FileInfoBuffer)) + return EC; + + if (Writer.bytesRemaining() > 0) + return make_error<RawError>(raw_error_code::invalid_format, + "Unexpected bytes found in DBI Stream"); + return Error::success(); +} diff --git a/llvm/lib/DebugInfo/PDB/Raw/InfoStream.cpp b/llvm/lib/DebugInfo/PDB/Raw/InfoStream.cpp index c55f51d7d4a..4df24f240f3 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/InfoStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/InfoStream.cpp @@ -15,6 +15,7 @@ #include "llvm/DebugInfo/PDB/Raw/PDBFile.h" #include "llvm/DebugInfo/PDB/Raw/RawConstants.h" #include "llvm/DebugInfo/PDB/Raw/RawError.h" +#include "llvm/DebugInfo/PDB/Raw/RawTypes.h" using namespace llvm; using namespace llvm::codeview; @@ -27,7 +28,7 @@ InfoStream::InfoStream(std::unique_ptr<MappedBlockStream> Stream) Error InfoStream::reload() { StreamReader Reader(*Stream); - const HeaderInfo *H; + const InfoStreamHeader *H; if (auto EC = Reader.readObject(H)) return joinErrors( std::move(EC), @@ -74,17 +75,3 @@ uint32_t InfoStream::getSignature() const { return Signature; } uint32_t InfoStream::getAge() const { return Age; } PDB_UniqueId InfoStream::getGuid() const { return Guid; } - -Error InfoStream::commit() { - StreamWriter Writer(*Stream); - - HeaderInfo H; - H.Age = Age; - H.Signature = Signature; - H.Version = Version; - H.Guid = Guid; - if (auto EC = Writer.writeObject(H)) - return EC; - - return NamedStreams.commit(Writer); -} diff --git a/llvm/lib/DebugInfo/PDB/Raw/InfoStreamBuilder.cpp b/llvm/lib/DebugInfo/PDB/Raw/InfoStreamBuilder.cpp index 444aba6be0b..d20c37d9f29 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/InfoStreamBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/InfoStreamBuilder.cpp @@ -13,13 +13,15 @@ #include "llvm/DebugInfo/Msf/StreamWriter.h" #include "llvm/DebugInfo/PDB/Raw/InfoStream.h" #include "llvm/DebugInfo/PDB/Raw/RawError.h" +#include "llvm/DebugInfo/PDB/Raw/RawTypes.h" using namespace llvm; using namespace llvm::codeview; using namespace llvm::msf; using namespace llvm::pdb; -InfoStreamBuilder::InfoStreamBuilder() {} +InfoStreamBuilder::InfoStreamBuilder() + : Ver(PdbRaw_ImplVer::PdbImplVC70), Sig(-1), Age(0) {} void InfoStreamBuilder::setVersion(PdbRaw_ImplVer V) { Ver = V; } @@ -34,35 +36,38 @@ NameMapBuilder &InfoStreamBuilder::getNamedStreamsBuilder() { } uint32_t InfoStreamBuilder::calculateSerializedLength() const { - return sizeof(InfoStream::HeaderInfo) + - NamedStreams.calculateSerializedLength(); + return sizeof(InfoStreamHeader) + NamedStreams.calculateSerializedLength(); } -Expected<std::unique_ptr<InfoStream>> InfoStreamBuilder::build(PDBFile &File) { - if (!Ver.hasValue()) - return make_error<RawError>(raw_error_code::unspecified, - "Missing PDB Stream Version"); - if (!Sig.hasValue()) - return make_error<RawError>(raw_error_code::unspecified, - "Missing PDB Stream Signature"); - if (!Age.hasValue()) - return make_error<RawError>(raw_error_code::unspecified, - "Missing PDB Stream Age"); - if (!Guid.hasValue()) - return make_error<RawError>(raw_error_code::unspecified, - "Missing PDB Stream Guid"); - - auto InfoS = MappedBlockStream::createIndexedStream(StreamPDB, File); - if (!InfoS) - return InfoS.takeError(); - auto Info = llvm::make_unique<InfoStream>(std::move(*InfoS)); - Info->Version = *Ver; - Info->Signature = *Sig; - Info->Age = *Age; - Info->Guid = *Guid; +Expected<std::unique_ptr<InfoStream>> +InfoStreamBuilder::build(PDBFile &File, const msf::WritableStream &Buffer) { + auto StreamData = MappedBlockStream::createIndexedStream(File.getMsfLayout(), + Buffer, StreamPDB); + auto Info = llvm::make_unique<InfoStream>(std::move(StreamData)); + Info->Version = Ver; + Info->Signature = Sig; + Info->Age = Age; + Info->Guid = Guid; auto NS = NamedStreams.build(); if (!NS) return NS.takeError(); Info->NamedStreams = **NS; return std::move(Info); } + +Error InfoStreamBuilder::commit(const msf::MsfLayout &Layout, + const msf::WritableStream &Buffer) const { + auto InfoS = + WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamPDB); + StreamWriter Writer(*InfoS); + + InfoStreamHeader H; + H.Age = Age; + H.Signature = Sig; + H.Version = Ver; + H.Guid = Guid; + if (auto EC = Writer.writeObject(H)) + return EC; + + return NamedStreams.commit(Writer); +} diff --git a/llvm/lib/DebugInfo/PDB/Raw/ModInfo.cpp b/llvm/lib/DebugInfo/PDB/Raw/ModInfo.cpp index 89a03ec3a4d..7b77bcda421 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/ModInfo.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/ModInfo.cpp @@ -27,7 +27,7 @@ ModInfo::ModInfo(const ModInfo &Info) ModInfo::~ModInfo() {} -Error ModInfo::initialize(StreamRef Stream, ModInfo &Info) { +Error ModInfo::initialize(ReadableStreamRef Stream, ModInfo &Info) { StreamReader Reader(Stream); if (auto EC = Reader.readObject(Info.Layout)) return EC; diff --git a/llvm/lib/DebugInfo/PDB/Raw/ModStream.cpp b/llvm/lib/DebugInfo/PDB/Raw/ModStream.cpp index 65d59a5e894..25bb9d15165 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/ModStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/ModStream.cpp @@ -36,7 +36,7 @@ Error ModStream::reload() { return llvm::make_error<RawError>(raw_error_code::corrupt_file, "Module has both C11 and C13 line info"); - StreamRef S; + ReadableStreamRef S; uint32_t SymbolSubstreamSig = 0; if (auto EC = Reader.readInteger(SymbolSubstreamSig)) diff --git a/llvm/lib/DebugInfo/PDB/Raw/NameMap.cpp b/llvm/lib/DebugInfo/PDB/Raw/NameMap.cpp index e17600986c9..70b810f1522 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/NameMap.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/NameMap.cpp @@ -145,60 +145,6 @@ Error NameMap::load(StreamReader &Stream) { return Error::success(); } -Error NameMap::commit(StreamWriter &Writer) { - // The first field is the number of bytes of string data. So add - // up the length of all strings plus a null terminator for each - // one. - uint32_t NumBytes = 0; - for (auto B = Mapping.begin(), E = Mapping.end(); B != E; ++B) { - NumBytes += B->getKeyLength() + 1; - } - - if (auto EC = Writer.writeInteger(NumBytes)) // Number of bytes of string data - return EC; - // Now all of the string data itself. - for (auto B = Mapping.begin(), E = Mapping.end(); B != E; ++B) { - if (auto EC = Writer.writeZeroString(B->getKey())) - return EC; - } - - if (auto EC = Writer.writeInteger(Mapping.size())) // Hash Size - return EC; - - if (auto EC = Writer.writeInteger(Mapping.size())) // Max Number of Strings - return EC; - - if (auto EC = Writer.writeInteger(Mapping.size())) // Num Present Words - return EC; - - // For each entry in the mapping, write a bit mask which represents a bucket - // to store it in. We don't use this, so the value we write isn't important - // to us, it just has to be there. - for (auto B = Mapping.begin(), E = Mapping.end(); B != E; ++B) { - if (auto EC = Writer.writeInteger(1U)) - return EC; - } - - if (auto EC = Writer.writeInteger(0U)) // Num Deleted Words - return EC; - - // Mappings of each word. - uint32_t OffsetSoFar = 0; - for (auto B = Mapping.begin(), E = Mapping.end(); B != E; ++B) { - // This is a list of key value pairs where the key is the offset into the - // strings buffer, and the value is a stream number. Write each pair. - if (auto EC = Writer.writeInteger(OffsetSoFar)) - return EC; - - if (auto EC = Writer.writeInteger(B->second)) - return EC; - - OffsetSoFar += B->getKeyLength() + 1; - } - - return Error::success(); -} - iterator_range<StringMapConstIterator<uint32_t>> NameMap::entries() const { return llvm::make_range<StringMapConstIterator<uint32_t>>(Mapping.begin(), Mapping.end()); diff --git a/llvm/lib/DebugInfo/PDB/Raw/NameMapBuilder.cpp b/llvm/lib/DebugInfo/PDB/Raw/NameMapBuilder.cpp index 41c6c2cd810..3bb4503fe6a 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/NameMapBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/NameMapBuilder.cpp @@ -9,6 +9,7 @@ #include "llvm/DebugInfo/PDB/Raw/NameMapBuilder.h" +#include "llvm/DebugInfo/Msf/StreamWriter.h" #include "llvm/DebugInfo/PDB/Raw/NameMap.h" #include "llvm/Support/Endian.h" @@ -48,3 +49,57 @@ uint32_t NameMapBuilder::calculateSerializedLength() const { return TotalLength; } + +Error NameMapBuilder::commit(msf::StreamWriter &Writer) const { + // The first field is the number of bytes of string data. So add + // up the length of all strings plus a null terminator for each + // one. + uint32_t NumBytes = 0; + for (auto B = Map.begin(), E = Map.end(); B != E; ++B) { + NumBytes += B->getKeyLength() + 1; + } + + if (auto EC = Writer.writeInteger(NumBytes)) // Number of bytes of string data + return EC; + // Now all of the string data itself. + for (auto B = Map.begin(), E = Map.end(); B != E; ++B) { + if (auto EC = Writer.writeZeroString(B->getKey())) + return EC; + } + + if (auto EC = Writer.writeInteger(Map.size())) // Hash Size + return EC; + + if (auto EC = Writer.writeInteger(Map.size())) // Max Number of Strings + return EC; + + if (auto EC = Writer.writeInteger(Map.size())) // Num Present Words + return EC; + + // For each entry in the mapping, write a bit mask which represents a bucket + // to store it in. We don't use this, so the value we write isn't important + // to us, it just has to be there. + for (auto B = Map.begin(), E = Map.end(); B != E; ++B) { + if (auto EC = Writer.writeInteger(1U)) + return EC; + } + + if (auto EC = Writer.writeInteger(0U)) // Num Deleted Words + return EC; + + // Mappings of each word. + uint32_t OffsetSoFar = 0; + for (auto B = Map.begin(), E = Map.end(); B != E; ++B) { + // This is a list of key value pairs where the key is the offset into the + // strings buffer, and the value is a stream number. Write each pair. + if (auto EC = Writer.writeInteger(OffsetSoFar)) + return EC; + + if (auto EC = Writer.writeInteger(B->second)) + return EC; + + OffsetSoFar += B->getKeyLength() + 1; + } + + return Error::success(); +} diff --git a/llvm/lib/DebugInfo/PDB/Raw/PDBFile.cpp b/llvm/lib/DebugInfo/PDB/Raw/PDBFile.cpp index ea0a8c91304..3529860899e 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/PDBFile.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/PDBFile.cpp @@ -34,48 +34,53 @@ namespace { typedef FixedStreamArray<support::ulittle32_t> ulittle_array; } -PDBFile::PDBFile(std::unique_ptr<StreamInterface> PdbFileBuffer, +PDBFile::PDBFile(std::unique_ptr<ReadableStream> PdbFileBuffer, BumpPtrAllocator &Allocator) : Allocator(Allocator), Buffer(std::move(PdbFileBuffer)) {} PDBFile::~PDBFile() {} -uint32_t PDBFile::getBlockSize() const { return MsfLayout.SB->BlockSize; } +uint32_t PDBFile::getBlockSize() const { return ContainerLayout.SB->BlockSize; } uint32_t PDBFile::getFreeBlockMapBlock() const { - return MsfLayout.SB->FreeBlockMapBlock; + return ContainerLayout.SB->FreeBlockMapBlock; } -uint32_t PDBFile::getBlockCount() const { return MsfLayout.SB->NumBlocks; } +uint32_t PDBFile::getBlockCount() const { + return ContainerLayout.SB->NumBlocks; +} uint32_t PDBFile::getNumDirectoryBytes() const { - return MsfLayout.SB->NumDirectoryBytes; + return ContainerLayout.SB->NumDirectoryBytes; } uint32_t PDBFile::getBlockMapIndex() const { - return MsfLayout.SB->BlockMapAddr; + return ContainerLayout.SB->BlockMapAddr; } -uint32_t PDBFile::getUnknown1() const { return MsfLayout.SB->Unknown1; } +uint32_t PDBFile::getUnknown1() const { return ContainerLayout.SB->Unknown1; } uint32_t PDBFile::getNumDirectoryBlocks() const { - return msf::bytesToBlocks(MsfLayout.SB->NumDirectoryBytes, - MsfLayout.SB->BlockSize); + return msf::bytesToBlocks(ContainerLayout.SB->NumDirectoryBytes, + ContainerLayout.SB->BlockSize); } uint64_t PDBFile::getBlockMapOffset() const { - return (uint64_t)MsfLayout.SB->BlockMapAddr * MsfLayout.SB->BlockSize; + return (uint64_t)ContainerLayout.SB->BlockMapAddr * + ContainerLayout.SB->BlockSize; } -uint32_t PDBFile::getNumStreams() const { return MsfLayout.StreamSizes.size(); } +uint32_t PDBFile::getNumStreams() const { + return ContainerLayout.StreamSizes.size(); +} uint32_t PDBFile::getStreamByteSize(uint32_t StreamIndex) const { - return MsfLayout.StreamSizes[StreamIndex]; + return ContainerLayout.StreamSizes[StreamIndex]; } ArrayRef<support::ulittle32_t> PDBFile::getStreamBlockList(uint32_t StreamIndex) const { - return MsfLayout.StreamMap[StreamIndex]; + return ContainerLayout.StreamMap[StreamIndex]; } uint32_t PDBFile::getFileSize() const { return Buffer->getLength(); } @@ -92,18 +97,8 @@ Expected<ArrayRef<uint8_t>> PDBFile::getBlockData(uint32_t BlockIndex, Error PDBFile::setBlockData(uint32_t BlockIndex, uint32_t Offset, ArrayRef<uint8_t> Data) const { - if (Offset >= getBlockSize()) - return make_error<RawError>( - raw_error_code::invalid_block_address, - "setBlockData attempted to write out of block bounds."); - if (Data.size() > getBlockSize() - Offset) - return make_error<RawError>( - raw_error_code::invalid_block_address, - "setBlockData attempted to write out of block bounds."); - - uint64_t StreamBlockOffset = msf::blockToOffset(BlockIndex, getBlockSize()); - StreamBlockOffset += Offset; - return Buffer->writeBytes(StreamBlockOffset, Data); + return make_error<RawError>(raw_error_code::not_writable, + "PDBFile is immutable"); } Error PDBFile::parseFileHeaders() { @@ -122,18 +117,18 @@ Error PDBFile::parseFileHeaders() { if (Buffer->getLength() % SB->BlockSize != 0) return make_error<RawError>(raw_error_code::corrupt_file, "File size is not a multiple of block size"); - MsfLayout.SB = SB; + ContainerLayout.SB = SB; Reader.setOffset(getBlockMapOffset()); - if (auto EC = - Reader.readArray(MsfLayout.DirectoryBlocks, getNumDirectoryBlocks())) + if (auto EC = Reader.readArray(ContainerLayout.DirectoryBlocks, + getNumDirectoryBlocks())) return EC; return Error::success(); } Error PDBFile::parseStreamData() { - assert(MsfLayout.SB); + assert(ContainerLayout.SB); if (DirectoryStream) return Error::success(); @@ -144,15 +139,12 @@ Error PDBFile::parseStreamData() { // is exactly what we are attempting to parse. By specifying a custom // subclass of IPDBStreamData which only accesses the fields that have already // been parsed, we can avoid this and reuse MappedBlockStream. - auto DS = MappedBlockStream::createDirectoryStream( - MsfLayout.SB->NumDirectoryBytes, getDirectoryBlockArray(), *this); - if (!DS) - return DS.takeError(); - StreamReader Reader(**DS); + auto DS = MappedBlockStream::createDirectoryStream(ContainerLayout, *Buffer); + StreamReader Reader(*DS); if (auto EC = Reader.readInteger(NumStreams)) return EC; - if (auto EC = Reader.readArray(MsfLayout.StreamSizes, NumStreams)) + if (auto EC = Reader.readArray(ContainerLayout.StreamSizes, NumStreams)) return EC; for (uint32_t I = 0; I < NumStreams; ++I) { uint32_t StreamSize = getStreamByteSize(I); @@ -160,7 +152,7 @@ Error PDBFile::parseStreamData() { uint64_t NumExpectedStreamBlocks = StreamSize == UINT32_MAX ? 0 - : msf::bytesToBlocks(StreamSize, MsfLayout.SB->BlockSize); + : msf::bytesToBlocks(StreamSize, ContainerLayout.SB->BlockSize); // For convenience, we store the block array contiguously. This is because // if someone calls setStreamMap(), it is more convenient to be able to call @@ -172,30 +164,30 @@ Error PDBFile::parseStreamData() { if (auto EC = Reader.readArray(Blocks, NumExpectedStreamBlocks)) return EC; for (uint32_t Block : Blocks) { - uint64_t BlockEndOffset = (uint64_t)(Block + 1) * MsfLayout.SB->BlockSize; + uint64_t BlockEndOffset = + (uint64_t)(Block + 1) * ContainerLayout.SB->BlockSize; if (BlockEndOffset > getFileSize()) return make_error<RawError>(raw_error_code::corrupt_file, "Stream block map is corrupt."); } - MsfLayout.StreamMap.push_back(Blocks); + ContainerLayout.StreamMap.push_back(Blocks); } // We should have read exactly SB->NumDirectoryBytes bytes. assert(Reader.bytesRemaining() == 0); - DirectoryStream = std::move(*DS); + DirectoryStream = std::move(DS); return Error::success(); } llvm::ArrayRef<support::ulittle32_t> PDBFile::getDirectoryBlockArray() const { - return MsfLayout.DirectoryBlocks; + return ContainerLayout.DirectoryBlocks; } Expected<InfoStream &> PDBFile::getPDBInfoStream() { if (!Info) { - auto InfoS = MappedBlockStream::createIndexedStream(StreamPDB, *this); - if (!InfoS) - return InfoS.takeError(); - auto TempInfo = llvm::make_unique<InfoStream>(std::move(*InfoS)); + auto InfoS = MappedBlockStream::createIndexedStream(ContainerLayout, + *Buffer, StreamPDB); + auto TempInfo = llvm::make_unique<InfoStream>(std::move(InfoS)); if (auto EC = TempInfo->reload()) return std::move(EC); Info = std::move(TempInfo); @@ -205,10 +197,9 @@ Expected<InfoStream &> PDBFile::getPDBInfoStream() { Expected<DbiStream &> PDBFile::getPDBDbiStream() { if (!Dbi) { - auto DbiS = MappedBlockStream::createIndexedStream(StreamDBI, *this); - if (!DbiS) - return DbiS.takeError(); - auto TempDbi = llvm::make_unique<DbiStream>(*this, std::move(*DbiS)); + auto DbiS = MappedBlockStream::createIndexedStream(ContainerLayout, *Buffer, + StreamDBI); + auto TempDbi = llvm::make_unique<DbiStream>(*this, std::move(DbiS)); if (auto EC = TempDbi->reload()) return std::move(EC); Dbi = std::move(TempDbi); @@ -218,10 +209,9 @@ Expected<DbiStream &> PDBFile::getPDBDbiStream() { Expected<TpiStream &> PDBFile::getPDBTpiStream() { if (!Tpi) { - auto TpiS = MappedBlockStream::createIndexedStream(StreamTPI, *this); - if (!TpiS) - return TpiS.takeError(); - auto TempTpi = llvm::make_unique<TpiStream>(*this, std::move(*TpiS)); + auto TpiS = MappedBlockStream::createIndexedStream(ContainerLayout, *Buffer, + StreamTPI); + auto TempTpi = llvm::make_unique<TpiStream>(*this, std::move(TpiS)); if (auto EC = TempTpi->reload()) return std::move(EC); Tpi = std::move(TempTpi); @@ -231,10 +221,9 @@ Expected<TpiStream &> PDBFile::getPDBTpiStream() { Expected<TpiStream &> PDBFile::getPDBIpiStream() { if (!Ipi) { - auto IpiS = MappedBlockStream::createIndexedStream(StreamIPI, *this); - if (!IpiS) - return IpiS.takeError(); - auto TempIpi = llvm::make_unique<TpiStream>(*this, std::move(*IpiS)); + auto IpiS = MappedBlockStream::createIndexedStream(ContainerLayout, *Buffer, + StreamIPI); + auto TempIpi = llvm::make_unique<TpiStream>(*this, std::move(IpiS)); if (auto EC = TempIpi->reload()) return std::move(EC); Ipi = std::move(TempIpi); @@ -250,12 +239,10 @@ Expected<PublicsStream &> PDBFile::getPDBPublicsStream() { uint32_t PublicsStreamNum = DbiS->getPublicSymbolStreamIndex(); - auto PublicS = - MappedBlockStream::createIndexedStream(PublicsStreamNum, *this); - if (!PublicS) - return PublicS.takeError(); + auto PublicS = MappedBlockStream::createIndexedStream( + ContainerLayout, *Buffer, PublicsStreamNum); auto TempPublics = - llvm::make_unique<PublicsStream>(*this, std::move(*PublicS)); + llvm::make_unique<PublicsStream>(*this, std::move(PublicS)); if (auto EC = TempPublics->reload()) return std::move(EC); Publics = std::move(TempPublics); @@ -270,12 +257,10 @@ Expected<SymbolStream &> PDBFile::getPDBSymbolStream() { return DbiS.takeError(); uint32_t SymbolStreamNum = DbiS->getSymRecordStreamIndex(); + auto SymbolS = MappedBlockStream::createIndexedStream( + ContainerLayout, *Buffer, SymbolStreamNum); - auto SymbolS = - MappedBlockStream::createIndexedStream(SymbolStreamNum, *this); - if (!SymbolS) - return SymbolS.takeError(); - auto TempSymbols = llvm::make_unique<SymbolStream>(std::move(*SymbolS)); + auto TempSymbols = llvm::make_unique<SymbolStream>(std::move(SymbolS)); if (auto EC = TempSymbols->reload()) return std::move(EC); Symbols = std::move(TempSymbols); @@ -295,76 +280,15 @@ Expected<NameHashTable &> PDBFile::getStringTable() { return make_error<RawError>(raw_error_code::no_stream); if (NameStreamIndex >= getNumStreams()) return make_error<RawError>(raw_error_code::no_stream); + auto NS = MappedBlockStream::createIndexedStream(ContainerLayout, *Buffer, + NameStreamIndex); - auto NS = MappedBlockStream::createIndexedStream(NameStreamIndex, *this); - if (!NS) - return NS.takeError(); - - StreamReader Reader(**NS); + StreamReader Reader(*NS); auto N = llvm::make_unique<NameHashTable>(); if (auto EC = N->load(Reader)) return std::move(EC); StringTable = std::move(N); - StringTableStream = std::move(*NS); + StringTableStream = std::move(NS); } return *StringTable; } - -Error PDBFile::commit() { - StreamWriter Writer(*Buffer); - - if (auto EC = Writer.writeObject(*MsfLayout.SB)) - return EC; - Writer.setOffset(getBlockMapOffset()); - if (auto EC = Writer.writeArray(MsfLayout.DirectoryBlocks)) - return EC; - - auto DS = MappedBlockStream::createDirectoryStream( - MsfLayout.SB->NumDirectoryBytes, getDirectoryBlockArray(), *this); - if (!DS) - return DS.takeError(); - auto DirStream = std::move(*DS); - StreamWriter DW(*DirStream); - if (auto EC = DW.writeInteger(this->getNumStreams())) - return EC; - - if (auto EC = DW.writeArray(MsfLayout.StreamSizes)) - return EC; - - for (const auto &Blocks : MsfLayout.StreamMap) { - if (auto EC = DW.writeArray(Blocks)) - return EC; - } - - if (Info) { - if (auto EC = Info->commit()) - return EC; - } - - if (Dbi) { - if (auto EC = Dbi->commit()) - return EC; - } - - if (Symbols) { - if (auto EC = Symbols->commit()) - return EC; - } - - if (Publics) { - if (auto EC = Publics->commit()) - return EC; - } - - if (Tpi) { - if (auto EC = Tpi->commit()) - return EC; - } - - if (Ipi) { - if (auto EC = Ipi->commit()) - return EC; - } - - return Buffer->commit(); -} diff --git a/llvm/lib/DebugInfo/PDB/Raw/PDBFileBuilder.cpp b/llvm/lib/DebugInfo/PDB/Raw/PDBFileBuilder.cpp index 5007a56f276..6715f3d3fa1 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/PDBFileBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/PDBFileBuilder.cpp @@ -58,7 +58,7 @@ DbiStreamBuilder &PDBFileBuilder::getDbiBuilder() { return *Dbi; } -Expected<msf::Layout> PDBFileBuilder::finalizeMsfLayout() const { +Expected<msf::MsfLayout> PDBFileBuilder::finalizeMsfLayout() const { if (Info) { uint32_t Length = Info->calculateSerializedLength(); if (auto EC = Msf->setStreamSize(StreamPDB, Length)) @@ -74,23 +74,23 @@ Expected<msf::Layout> PDBFileBuilder::finalizeMsfLayout() const { } Expected<std::unique_ptr<PDBFile>> -PDBFileBuilder::build(std::unique_ptr<msf::StreamInterface> PdbFileBuffer) { +PDBFileBuilder::build(std::unique_ptr<msf::WritableStream> PdbFileBuffer) { auto ExpectedLayout = finalizeMsfLayout(); if (!ExpectedLayout) return ExpectedLayout.takeError(); auto File = llvm::make_unique<PDBFile>(std::move(PdbFileBuffer), Allocator); - File->MsfLayout = *ExpectedLayout; + File->ContainerLayout = *ExpectedLayout; if (Info) { - auto ExpectedInfo = Info->build(*File); + auto ExpectedInfo = Info->build(*File, *PdbFileBuffer); if (!ExpectedInfo) return ExpectedInfo.takeError(); File->Info = std::move(*ExpectedInfo); } if (Dbi) { - auto ExpectedDbi = Dbi->build(*File); + auto ExpectedDbi = Dbi->build(*File, *PdbFileBuffer); if (!ExpectedDbi) return ExpectedDbi.takeError(); File->Dbi = std::move(*ExpectedDbi); @@ -103,3 +103,45 @@ PDBFileBuilder::build(std::unique_ptr<msf::StreamInterface> PdbFileBuffer) { return std::move(File); } + +Error PDBFileBuilder::commit(const msf::WritableStream &Buffer) { + StreamWriter Writer(Buffer); + auto ExpectedLayout = finalizeMsfLayout(); + if (!ExpectedLayout) + return ExpectedLayout.takeError(); + auto &Layout = *ExpectedLayout; + + if (auto EC = Writer.writeObject(*Layout.SB)) + return EC; + uint32_t BlockMapOffset = + msf::blockToOffset(Layout.SB->BlockMapAddr, Layout.SB->BlockSize); + Writer.setOffset(BlockMapOffset); + if (auto EC = Writer.writeArray(Layout.DirectoryBlocks)) + return EC; + + auto DirStream = + WritableMappedBlockStream::createDirectoryStream(Layout, Buffer); + StreamWriter DW(*DirStream); + if (auto EC = DW.writeInteger(Layout.StreamSizes.size())) + return EC; + + if (auto EC = DW.writeArray(Layout.StreamSizes)) + return EC; + + for (const auto &Blocks : Layout.StreamMap) { + if (auto EC = DW.writeArray(Blocks)) + return EC; + } + + if (Info) { + if (auto EC = Info->commit(Layout, Buffer)) + return EC; + } + + if (Dbi) { + if (auto EC = Dbi->commit(Layout, Buffer)) + return EC; + } + + return Buffer.commit(); +}
\ No newline at end of file diff --git a/llvm/lib/DebugInfo/PDB/Raw/RawSession.cpp b/llvm/lib/DebugInfo/PDB/Raw/RawSession.cpp index e6d915fcaee..a83689f5741 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/RawSession.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/RawSession.cpp @@ -26,21 +26,6 @@ using namespace llvm; using namespace llvm::msf; using namespace llvm::pdb; -namespace { -// We need a class which behaves like an immutable ByteStream, but whose data -// is backed by an llvm::MemoryBuffer. It also needs to own the underlying -// MemoryBuffer, so this simple adapter is a good way to achieve that. -class InputByteStream : public ByteStream<false> { -public: - explicit InputByteStream(std::unique_ptr<MemoryBuffer> Buffer) - : ByteStream(ArrayRef<uint8_t>(Buffer->getBuffer().bytes_begin(), - Buffer->getBuffer().bytes_end())), - MemBuffer(std::move(Buffer)) {} - - std::unique_ptr<MemoryBuffer> MemBuffer; -}; -} - RawSession::RawSession(std::unique_ptr<PDBFile> PdbFile, std::unique_ptr<BumpPtrAllocator> Allocator) : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)) {} @@ -57,7 +42,7 @@ Error RawSession::createFromPdb(StringRef Path, return llvm::make_error<GenericError>(generic_error_code::invalid_path); std::unique_ptr<MemoryBuffer> Buffer = std::move(*ErrorOrBuffer); - auto Stream = llvm::make_unique<InputByteStream>(std::move(Buffer)); + auto Stream = llvm::make_unique<MemoryBufferByteStream>(std::move(Buffer)); auto Allocator = llvm::make_unique<BumpPtrAllocator>(); auto File = llvm::make_unique<PDBFile>(std::move(Stream), *Allocator); diff --git a/llvm/lib/DebugInfo/PDB/Raw/TpiStream.cpp b/llvm/lib/DebugInfo/PDB/Raw/TpiStream.cpp index 6756580547a..a39a040705b 100644 --- a/llvm/lib/DebugInfo/PDB/Raw/TpiStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Raw/TpiStream.cpp @@ -188,12 +188,9 @@ Error TpiStream::reload() { if (Header->HashStreamIndex >= Pdb.getNumStreams()) return make_error<RawError>(raw_error_code::corrupt_file, "Invalid TPI hash stream index."); - - auto HS = - MappedBlockStream::createIndexedStream(Header->HashStreamIndex, Pdb); - if (!HS) - return HS.takeError(); - StreamReader HSR(**HS); + auto HS = MappedBlockStream::createIndexedStream( + Pdb.getMsfLayout(), Pdb.getMsfBuffer(), Header->HashStreamIndex); + StreamReader HSR(*HS); uint32_t NumHashValues = Header->HashValueBuffer.Length / sizeof(ulittle32_t); if (NumHashValues != NumTypeRecords()) @@ -216,7 +213,7 @@ Error TpiStream::reload() { if (auto EC = HSR.readArray(HashAdjustments, NumHashAdjustments)) return EC; - HashStream = std::move(*HS); + HashStream = std::move(HS); // TPI hash table is a parallel array for the type records. // Verify that the hash values match with type records. diff --git a/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp b/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp index 6448b38cf47..95ea48d8f43 100644 --- a/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp +++ b/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp @@ -259,10 +259,9 @@ Error LLVMOutputStyle::dumpStreamData() { if (DumpStreamNum >= StreamCount) return make_error<RawError>(raw_error_code::no_stream); - auto S = MappedBlockStream::createIndexedStream(DumpStreamNum, File); - if (!S) - return S.takeError(); - StreamReader R(**S); + auto S = MappedBlockStream::createIndexedStream( + File.getMsfLayout(), File.getMsfBuffer(), DumpStreamNum); + StreamReader R(*S); while (R.bytesRemaining() > 0) { ArrayRef<uint8_t> Data; uint32_t BytesToReadInBlock = std::min( @@ -311,11 +310,9 @@ Error LLVMOutputStyle::dumpNamedStream() { DictScope D(P, Name); P.printNumber("Index", NameStreamIndex); - auto NameStream = - MappedBlockStream::createIndexedStream(NameStreamIndex, File); - if (!NameStream) - return NameStream.takeError(); - StreamReader Reader(**NameStream); + auto NameStream = MappedBlockStream::createIndexedStream( + File.getMsfLayout(), File.getMsfBuffer(), NameStreamIndex); + StreamReader Reader(*NameStream); NameHashTable NameTable; if (auto EC = NameTable.load(Reader)) @@ -486,10 +483,10 @@ Error LLVMOutputStyle::dumpDbiStream() { (opts::raw::DumpModuleSyms || opts::raw::DumpSymRecordBytes); if (HasModuleDI && (ShouldDumpSymbols || opts::raw::DumpLineInfo)) { auto ModStreamData = MappedBlockStream::createIndexedStream( - Modi.Info.getModuleStreamIndex(), File); - if (!ModStreamData) - return ModStreamData.takeError(); - ModStream ModS(Modi.Info, std::move(*ModStreamData)); + File.getMsfLayout(), File.getMsfBuffer(), + Modi.Info.getModuleStreamIndex()); + + ModStream ModS(Modi.Info, std::move(ModStreamData)); if (auto EC = ModS.reload()) return EC; @@ -519,7 +516,7 @@ Error LLVMOutputStyle::dumpDbiStream() { public: RecordVisitor(ScopedPrinter &P, PDBFile &F) : P(P), F(F) {} Error visitUnknown(ModuleSubstreamKind Kind, - StreamRef Stream) override { + ReadableStreamRef Stream) override { DictScope DD(P, "Unknown"); ArrayRef<uint8_t> Data; StreamReader R(Stream); @@ -532,7 +529,7 @@ Error LLVMOutputStyle::dumpDbiStream() { return Error::success(); } Error - visitFileChecksums(StreamRef Data, + visitFileChecksums(ReadableStreamRef Data, const FileChecksumArray &Checksums) override { DictScope DD(P, "FileChecksums"); for (const auto &C : Checksums) { @@ -548,7 +545,8 @@ Error LLVMOutputStyle::dumpDbiStream() { return Error::success(); } - Error visitLines(StreamRef Data, const LineSubstreamHeader *Header, + Error visitLines(ReadableStreamRef Data, + const LineSubstreamHeader *Header, const LineInfoArray &Lines) override { DictScope DD(P, "Lines"); for (const auto &L : Lines) { diff --git a/llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp b/llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp index 6c7d6058e8d..e8951886215 100644 --- a/llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp +++ b/llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp @@ -69,27 +69,6 @@ using namespace llvm::codeview; using namespace llvm::msf; using namespace llvm::pdb; -namespace { -// A simple adapter that acts like a ByteStream but holds ownership over -// and underlying FileOutputBuffer. -class FileBufferByteStream : public ByteStream<true> { -public: - FileBufferByteStream(std::unique_ptr<FileOutputBuffer> Buffer) - : ByteStream(MutableArrayRef<uint8_t>(Buffer->getBufferStart(), - Buffer->getBufferEnd())), - FileBuffer(std::move(Buffer)) {} - - Error commit() const override { - if (FileBuffer->commit()) - return llvm::make_error<RawError>(raw_error_code::not_writable); - return Error::success(); - } - -private: - std::unique_ptr<FileOutputBuffer> FileBuffer; -}; -} - namespace opts { cl::SubCommand RawSubcommand("raw", "Dump raw structure of the PDB file"); @@ -395,11 +374,7 @@ static void yamlToPdb(StringRef Path) { } } - auto Pdb = Builder.build(std::move(FileByteStream)); - ExitOnErr(Pdb.takeError()); - - auto &PdbFile = *Pdb; - ExitOnErr(PdbFile->commit()); + ExitOnErr(Builder.commit(*FileByteStream)); } static void pdb2Yaml(StringRef Path) { diff --git a/llvm/tools/llvm-readobj/COFFDumper.cpp b/llvm/tools/llvm-readobj/COFFDumper.cpp index b6f7d436168..12a4292e238 100644 --- a/llvm/tools/llvm-readobj/COFFDumper.cpp +++ b/llvm/tools/llvm-readobj/COFFDumper.cpp @@ -954,7 +954,7 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, SectionContents); CVSymbolDumper CVSD(W, CVTD, std::move(CODD), opts::CodeViewSubsectionBytes); - ByteStream<> Stream(BinaryData); + ByteStream Stream(BinaryData); CVSymbolArray Symbols; StreamReader Reader(Stream); if (auto EC = Reader.readArray(Symbols, Reader.getLength())) { @@ -1062,7 +1062,7 @@ void COFFDumper::mergeCodeViewTypes(MemoryTypeTableBuilder &CVTypes) { error(object_error::parse_failed); ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(Data.data()), Data.size()); - ByteStream<> Stream(Bytes); + ByteStream Stream(Bytes); CVTypeArray Types; StreamReader Reader(Stream); if (auto EC = Reader.readArray(Types, Reader.getLength())) { diff --git a/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp b/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp index f1bf031e019..0ed74a0f6a6 100644 --- a/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp +++ b/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp @@ -28,37 +28,43 @@ namespace { static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9}; static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H', 'I', 'J'}; -class DiscontiguousFile : public IMsfFile { +class DiscontiguousStream : public WritableStream { public: - DiscontiguousFile(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data) + DiscontiguousStream(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data) : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {} - uint32_t getBlockSize() const override { return 1; } - uint32_t getBlockCount() const override { return Blocks.size(); } - uint32_t getNumStreams() const override { return 1; } - uint32_t getStreamByteSize(uint32_t StreamIndex) const override { - return getBlockCount() * getBlockSize(); - } - ArrayRef<support::ulittle32_t> - getStreamBlockList(uint32_t StreamIndex) const override { - if (StreamIndex != 0) - return ArrayRef<support::ulittle32_t>(); - return Blocks; - } - Expected<ArrayRef<uint8_t>> getBlockData(uint32_t BlockIndex, - uint32_t NumBytes) const override { - return ArrayRef<uint8_t>(&Data[BlockIndex], NumBytes); + uint32_t block_size() const { return 1; } + uint32_t block_count() const { return Blocks.size(); } + + Error readBytes(uint32_t Offset, uint32_t Size, + ArrayRef<uint8_t> &Buffer) const override { + if (Offset + Size > Data.size()) + return make_error<MsfError>(msf_error_code::insufficient_buffer); + Buffer = Data.slice(Offset, Size); + return Error::success(); } - Error setBlockData(uint32_t BlockIndex, uint32_t Offset, - ArrayRef<uint8_t> SrcData) const override { - if (BlockIndex >= Blocks.size()) + Error readLongestContiguousChunk(uint32_t Offset, + ArrayRef<uint8_t> &Buffer) const override { + if (Offset >= Data.size()) return make_error<MsfError>(msf_error_code::insufficient_buffer); - if (Offset > getBlockSize() - SrcData.size()) + Buffer = Data.drop_front(Offset); + return Error::success(); + } + + uint32_t getLength() const override { return Data.size(); } + + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> SrcData) const override { + if (Offset + SrcData.size() > Data.size()) return make_error<MsfError>(msf_error_code::insufficient_buffer); - ::memcpy(&Data[BlockIndex] + Offset, SrcData.data(), SrcData.size()); + ::memcpy(&Data[Offset], SrcData.data(), SrcData.size()); return Error::success(); } + Error commit() const override { return Error::success(); } + + MsfStreamLayout layout() const { + return MsfStreamLayout{Data.size(), Blocks}; + } private: std::vector<support::ulittle32_t> Blocks; @@ -68,13 +74,12 @@ private: // Tests that a read which is entirely contained within a single block works // and does not allocate. TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); - StreamRef SR; + ReadableStreamRef SR; EXPECT_NO_ERROR(R.readStreamRef(SR, 0U)); ArrayRef<uint8_t> Buffer; EXPECT_ERROR(SR.readBytes(0U, 1U, Buffer)); @@ -85,10 +90,10 @@ TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) { // Tests that a read which outputs into a full destination buffer works and // does not fail due to the length of the output buffer. TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); + StreamReader R(*S); StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA"; EXPECT_NO_ERROR(R.readFixedString(Str, 1)); @@ -100,10 +105,9 @@ TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) { // blocks are still contiguous in memory to the previous block works and does // not allocate memory. TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 2)); @@ -120,10 +124,9 @@ TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) { // contiguously works and allocates only the precise amount of bytes // requested. TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 10)); @@ -134,10 +137,9 @@ TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) { // Test that an out of bounds read which doesn't cross a block boundary // fails and allocates no memory. TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str; @@ -149,10 +151,9 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) { // Test that an out of bounds read which crosses a contiguous block boundary // fails and allocates no memory. TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str; @@ -164,10 +165,9 @@ TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) { // Test that an out of bounds read which crosses a discontiguous block // boundary fails and allocates no memory. TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str; @@ -178,10 +178,9 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) { // Tests that a read which is entirely contained within a single block but // beyond the end of a StreamRef fails. TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 1)); @@ -193,10 +192,9 @@ TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) { // cached request, but which is known to overlap that request, shares the // previous allocation. TEST(MappedBlockStreamTest, UnalignedOverlappingRead) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str1; StringRef Str2; @@ -215,10 +213,9 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingRead) { // cached request, but which only partially overlaps a previous cached request, // still works correctly and allocates again from the shared pool. TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) { - DiscontiguousFile F(BlocksAry, DataAry); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, DataAry); + auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), + F.layout(), F); StreamReader R(*S); StringRef Str1; StringRef Str2; @@ -240,10 +237,9 @@ TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) { static_assert(sizeof(LargeBuffer) > sizeof(Data), "LargeBuffer is not big enough"); - DiscontiguousFile F(BlocksAry, Data); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, Data); + auto S = WritableMappedBlockStream::createStream( + F.block_size(), F.block_count(), F.layout(), F); ArrayRef<uint8_t> Buffer; EXPECT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>(LargeBuffer))); @@ -254,10 +250,9 @@ TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) { TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) { static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'}; - DiscontiguousFile F(BlocksAry, Data); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, Data); + auto S = WritableMappedBlockStream::createStream( + F.block_size(), F.block_count(), F.layout(), F); ArrayRef<uint8_t> Buffer; EXPECT_NO_ERROR(S->readBytes(0, 1, Buffer)); @@ -288,10 +283,9 @@ TEST(MappedBlockStreamTest, TestWriteBytesBreakBoundary) { static uint8_t Expected[] = {'T', 'E', 'S', 'N', 'I', 'T', 'G', '.', '0', '0'}; - DiscontiguousFile F(BlocksAry, Data); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(BlocksAry, Data); + auto S = WritableMappedBlockStream::createStream( + F.block_size(), F.block_count(), F.layout(), F); ArrayRef<uint8_t> Buffer; EXPECT_NO_ERROR(S->writeBytes(0, TestData)); @@ -308,10 +302,9 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { MutableArrayRef<uint8_t> Data(DataBytes); const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8}; - DiscontiguousFile F(Blocks, Data); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &S = *ExpectedS; + DiscontiguousStream F(Blocks, Data); + auto S = WritableMappedBlockStream::createStream( + F.block_size(), F.block_count(), F.layout(), F); enum class MyEnum : uint32_t { Val1 = 2908234, Val2 = 120891234 }; using support::ulittle32_t; @@ -401,13 +394,12 @@ TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) { std::vector<uint8_t> SrcDataBytes(10); MutableArrayRef<uint8_t> SrcData(SrcDataBytes); - DiscontiguousFile F(DestBlocks, DestData); - auto ExpectedS = MappedBlockStream::createIndexedStream(0, F); - EXPECT_EXPECTED(ExpectedS); - auto &DestStream = *ExpectedS; + DiscontiguousStream F(DestBlocks, DestData); + auto DestStream = WritableMappedBlockStream::createStream( + F.block_size(), F.block_count(), F.layout(), F); // First write "Test Str" into the source stream. - ByteStream<true> SourceStream(SrcData); + MutableByteStream SourceStream(SrcData); StreamWriter SourceWriter(SourceStream); EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str")); EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>( @@ -435,31 +427,29 @@ TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) { MutableArrayRef<uint8_t> SrcData(SrcDataBytes); const uint32_t SrcBlocks[] = {1, 0, 6, 3, 4, 5, 2, 7, 8, 9}; - DiscontiguousFile DestFile(DestBlocks, DestData); - DiscontiguousFile SrcFile(SrcBlocks, SrcData); + DiscontiguousStream DestF(DestBlocks, DestData); + DiscontiguousStream SrcF(SrcBlocks, SrcData); - auto ExpectedDest = MappedBlockStream::createIndexedStream(0, DestFile); - auto ExpectedSrc = MappedBlockStream::createIndexedStream(0, SrcFile); - EXPECT_EXPECTED(ExpectedDest); - EXPECT_EXPECTED(ExpectedSrc); - auto &DestStream = *ExpectedDest; - auto &SrcStream = *ExpectedSrc; + auto Dest = WritableMappedBlockStream::createStream( + DestF.block_size(), DestF.block_count(), DestF.layout(), DestF); + auto Src = WritableMappedBlockStream::createStream( + SrcF.block_size(), SrcF.block_count(), SrcF.layout(), SrcF); // First write "Test Str" into the source stream. - StreamWriter SourceWriter(*SrcStream); + StreamWriter SourceWriter(*Src); EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str")); EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>( {'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0})); // Then write the source stream into the dest stream. - StreamWriter DestWriter(*DestStream); - EXPECT_NO_ERROR(DestWriter.writeStreamRef(*SrcStream)); + StreamWriter DestWriter(*Dest); + EXPECT_NO_ERROR(DestWriter.writeStreamRef(*Src)); EXPECT_EQ(DestDataBytes, std::vector<uint8_t>( {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0})); // Then read the string back out of the dest stream. StringRef Result; - StreamReader DestReader(*DestStream); + StreamReader DestReader(*Dest); EXPECT_NO_ERROR(DestReader.readZeroString(Result)); EXPECT_EQ(Result, "Test Str"); } diff --git a/llvm/unittests/DebugInfo/PDB/MsfBuilderTest.cpp b/llvm/unittests/DebugInfo/PDB/MsfBuilderTest.cpp index bb337118de2..2f4e9aaa96e 100644 --- a/llvm/unittests/DebugInfo/PDB/MsfBuilderTest.cpp +++ b/llvm/unittests/DebugInfo/PDB/MsfBuilderTest.cpp @@ -110,7 +110,7 @@ TEST_F(MsfBuilderTest, TestAddStreamNoDirectoryBlockIncrease) { auto ExpectedL1 = Msf.build(); EXPECT_EXPECTED(ExpectedL1); - Layout &L1 = *ExpectedL1; + MsfLayout &L1 = *ExpectedL1; auto OldDirBlocks = L1.DirectoryBlocks; EXPECT_EQ(1U, OldDirBlocks.size()); @@ -127,7 +127,7 @@ TEST_F(MsfBuilderTest, TestAddStreamNoDirectoryBlockIncrease) { auto ExpectedL2 = Msf2.build(); EXPECT_EXPECTED(ExpectedL2); - Layout &L2 = *ExpectedL2; + MsfLayout &L2 = *ExpectedL2; auto NewDirBlocks = L2.DirectoryBlocks; EXPECT_EQ(1U, NewDirBlocks.size()); } @@ -146,7 +146,7 @@ TEST_F(MsfBuilderTest, TestAddStreamWithDirectoryBlockIncrease) { auto ExpectedL1 = Msf.build(); EXPECT_EXPECTED(ExpectedL1); - Layout &L1 = *ExpectedL1; + MsfLayout &L1 = *ExpectedL1; auto DirBlocks = L1.DirectoryBlocks; EXPECT_EQ(2U, DirBlocks.size()); } @@ -270,7 +270,7 @@ TEST_F(MsfBuilderTest, TestBlockCountsWhenAddingStreams) { } TEST_F(MsfBuilderTest, BuildMsfLayout) { - // Test that we can generate an Msf Layout structure from a valid layout + // Test that we can generate an Msf MsfLayout structure from a valid layout // specification. auto ExpectedMsf = MsfBuilder::create(Allocator, 4096); EXPECT_EXPECTED(ExpectedMsf); @@ -286,7 +286,7 @@ TEST_F(MsfBuilderTest, BuildMsfLayout) { auto ExpectedLayout = Msf.build(); EXPECT_EXPECTED(ExpectedLayout); - Layout &L = *ExpectedLayout; + MsfLayout &L = *ExpectedLayout; EXPECT_EQ(4096U, L.SB->BlockSize); EXPECT_EQ(ExpectedNumBlocks, L.SB->NumBlocks); @@ -313,7 +313,7 @@ TEST_F(MsfBuilderTest, UseDirectoryBlockHint) { auto ExpectedLayout = Msf.build(); EXPECT_EXPECTED(ExpectedLayout); - Layout &L = *ExpectedLayout; + MsfLayout &L = *ExpectedLayout; EXPECT_EQ(msf::getMinimumBlockCount() + 2, L.SB->NumBlocks); EXPECT_EQ(1U, L.DirectoryBlocks.size()); EXPECT_EQ(1U, L.StreamMap[0].size()); @@ -335,7 +335,7 @@ TEST_F(MsfBuilderTest, DirectoryBlockHintInsufficient) { auto ExpectedLayout = Msf.build(); EXPECT_EXPECTED(ExpectedLayout); - Layout &L = *ExpectedLayout; + MsfLayout &L = *ExpectedLayout; EXPECT_EQ(2U, L.DirectoryBlocks.size()); EXPECT_EQ(B + 1, L.DirectoryBlocks[0]); } @@ -353,7 +353,7 @@ TEST_F(MsfBuilderTest, DirectoryBlockHintOverestimated) { auto ExpectedLayout = Msf.build(); EXPECT_EXPECTED(ExpectedLayout); - Layout &L = *ExpectedLayout; + MsfLayout &L = *ExpectedLayout; EXPECT_EQ(1U, L.DirectoryBlocks.size()); EXPECT_EQ(B + 1, L.DirectoryBlocks[0]); } |
