From 96678fa6d875c6aa7378aafd41194e17dd8fab74 Mon Sep 17 00:00:00 2001 From: NAKAMURA Takumi Date: Sat, 25 Feb 2017 17:04:23 +0000 Subject: [PATCH] Revert r296215, "[PDB] General improvements to Stream library." and followings. r296215, "[PDB] General improvements to Stream library." r296217, "Disable BinaryStreamTest.StreamReaderObject temporarily." r296220, "Re-enable BinaryStreamTest.StreamReaderObject." r296244, "[PDB] Disable some tests that are breaking bots." r296249, "Add static_cast to silence -Wc++11-narrowing." std::errc::no_buffer_space should be used for OS-oriented errors for socket transmission. (Seek discussions around llvm/xray.) I could substitute s/no_buffer_space/others/g, but I revert whole them ATM. Could we define and use LLVM errors there? git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@296258 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/ADT/STLExtras.h | 10 - include/llvm/DebugInfo/CodeView/CVRecord.h | 8 +- .../llvm/DebugInfo/CodeView/CVTypeVisitor.h | 2 +- .../DebugInfo/CodeView/CodeViewRecordIO.h | 16 +- .../llvm/DebugInfo/CodeView/ModuleSubstream.h | 14 +- .../CodeView/ModuleSubstreamVisitor.h | 48 +- .../DebugInfo/CodeView/RecordSerialization.h | 42 +- .../DebugInfo/CodeView/SymbolDeserializer.h | 7 +- .../llvm/DebugInfo/CodeView/SymbolRecord.h | 2 +- .../DebugInfo/CodeView/SymbolRecordMapping.h | 10 +- .../DebugInfo/CodeView/SymbolSerializer.h | 6 +- .../CodeView/SymbolVisitorDelegate.h | 6 +- .../DebugInfo/CodeView/TypeDeserializer.h | 13 +- include/llvm/DebugInfo/CodeView/TypeRecord.h | 6 +- .../DebugInfo/CodeView/TypeRecordMapping.h | 11 +- .../llvm/DebugInfo/CodeView/TypeSerializer.h | 6 +- include/llvm/DebugInfo/MSF/BinaryByteStream.h | 131 ++- include/llvm/DebugInfo/MSF/BinaryItemStream.h | 103 ++- include/llvm/DebugInfo/MSF/BinaryStream.h | 61 +- .../llvm/DebugInfo/MSF/BinaryStreamArray.h | 83 +- .../llvm/DebugInfo/MSF/BinaryStreamReader.h | 195 +---- include/llvm/DebugInfo/MSF/BinaryStreamRef.h | 109 +-- .../llvm/DebugInfo/MSF/BinaryStreamWriter.h | 157 +--- .../llvm/DebugInfo/MSF/MappedBlockStream.h | 63 +- include/llvm/DebugInfo/PDB/Native/DbiStream.h | 36 +- .../DebugInfo/PDB/Native/DbiStreamBuilder.h | 8 +- .../llvm/DebugInfo/PDB/Native/GlobalsStream.h | 7 +- include/llvm/DebugInfo/PDB/Native/HashTable.h | 8 +- .../DebugInfo/PDB/Native/InfoStreamBuilder.h | 5 +- include/llvm/DebugInfo/PDB/Native/ModInfo.h | 8 +- include/llvm/DebugInfo/PDB/Native/ModStream.h | 6 +- .../DebugInfo/PDB/Native/NamedStreamMap.h | 11 +- include/llvm/DebugInfo/PDB/Native/PDBFile.h | 10 +- .../llvm/DebugInfo/PDB/Native/PublicsStream.h | 19 +- .../llvm/DebugInfo/PDB/Native/StringTable.h | 13 +- .../DebugInfo/PDB/Native/StringTableBuilder.h | 7 +- .../llvm/DebugInfo/PDB/Native/TpiHashing.h | 4 +- include/llvm/DebugInfo/PDB/Native/TpiStream.h | 10 +- .../DebugInfo/PDB/Native/TpiStreamBuilder.h | 28 +- lib/CodeGen/AsmPrinter/CodeViewDebug.cpp | 5 +- lib/DebugInfo/CodeView/CVTypeDumper.cpp | 4 +- lib/DebugInfo/CodeView/CVTypeVisitor.cpp | 8 +- lib/DebugInfo/CodeView/CodeViewRecordIO.cpp | 48 +- lib/DebugInfo/CodeView/ModuleSubstream.cpp | 10 +- .../CodeView/ModuleSubstreamVisitor.cpp | 32 +- .../CodeView/RecordSerialization.cpp | 40 +- lib/DebugInfo/CodeView/TypeSerializer.cpp | 15 +- lib/DebugInfo/MSF/BinaryStreamReader.cpp | 68 +- lib/DebugInfo/MSF/BinaryStreamWriter.cpp | 63 +- lib/DebugInfo/MSF/MappedBlockStream.cpp | 48 +- lib/DebugInfo/PDB/Native/DbiStream.cpp | 32 +- lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp | 51 +- lib/DebugInfo/PDB/Native/GSI.cpp | 12 +- lib/DebugInfo/PDB/Native/GSI.h | 16 +- lib/DebugInfo/PDB/Native/GlobalsStream.cpp | 2 +- lib/DebugInfo/PDB/Native/HashTable.cpp | 24 +- lib/DebugInfo/PDB/Native/InfoStream.cpp | 2 +- .../PDB/Native/InfoStreamBuilder.cpp | 5 +- lib/DebugInfo/PDB/Native/ModInfo.cpp | 9 +- lib/DebugInfo/PDB/Native/ModStream.cpp | 10 +- lib/DebugInfo/PDB/Native/NamedStreamMap.cpp | 18 +- lib/DebugInfo/PDB/Native/NativeSession.cpp | 3 +- lib/DebugInfo/PDB/Native/PDBFile.cpp | 17 +- lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp | 14 +- lib/DebugInfo/PDB/Native/PublicsStream.cpp | 3 +- lib/DebugInfo/PDB/Native/StringTable.cpp | 9 +- .../PDB/Native/StringTableBuilder.cpp | 9 +- lib/DebugInfo/PDB/Native/SymbolStream.cpp | 3 +- lib/DebugInfo/PDB/Native/TpiStream.cpp | 5 +- lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp | 14 +- tools/llvm-pdbdump/LLVMOutputStyle.cpp | 11 +- tools/llvm-pdbdump/YamlTypeDumper.cpp | 4 +- tools/llvm-readobj/COFFDumper.cpp | 35 +- unittests/DebugInfo/PDB/BinaryStreamTest.cpp | 758 ------------------ unittests/DebugInfo/PDB/CMakeLists.txt | 1 - unittests/DebugInfo/PDB/HashTableTest.cpp | 7 +- .../DebugInfo/PDB/MappedBlockStreamTest.cpp | 85 +- .../DebugInfo/PDB/StringTableBuilderTest.cpp | 9 +- 78 files changed, 837 insertions(+), 1961 deletions(-) delete mode 100644 unittests/DebugInfo/PDB/BinaryStreamTest.cpp diff --git a/include/llvm/ADT/STLExtras.h b/include/llvm/ADT/STLExtras.h index d56c490156f..d4cbc587e55 100644 --- a/include/llvm/ADT/STLExtras.h +++ b/include/llvm/ADT/STLExtras.h @@ -640,16 +640,6 @@ detail::concat_range concat(RangeTs &&... Ranges) { // Extra additions to //===----------------------------------------------------------------------===// -/// \brief Template class to compute the sum of sizes of all items in a -/// parameter pack. -template struct sizeof_sum { - static const size_t value = sizeof(T) + sizeof_sum::value; -}; - -template struct sizeof_sum { - static const size_t value = sizeof(T); -}; - /// \brief Function object to check whether the first component of a std::pair /// compares less than the first component of another std::pair. struct less_first { diff --git a/include/llvm/DebugInfo/CodeView/CVRecord.h b/include/llvm/DebugInfo/CodeView/CVRecord.h index e038b13ee9b..94227ec5e7d 100644 --- a/include/llvm/DebugInfo/CodeView/CVRecord.h +++ b/include/llvm/DebugInfo/CodeView/CVRecord.h @@ -48,13 +48,15 @@ public: } // end namespace codeview +namespace msf { + template struct VarStreamArrayExtractor> { - Error operator()(BinaryStreamRef Stream, uint32_t &Len, + Error operator()(ReadableStreamRef Stream, uint32_t &Len, codeview::CVRecord &Item) const { using namespace codeview; const RecordPrefix *Prefix = nullptr; - BinaryStreamReader Reader(Stream); + StreamReader Reader(Stream); uint32_t Offset = Reader.getOffset(); if (auto EC = Reader.readObject(Prefix)) @@ -74,6 +76,8 @@ struct VarStreamArrayExtractor> { } }; +} // end namespace msf + } // end namespace llvm #endif // LLVM_DEBUGINFO_CODEVIEW_RECORDITERATOR_H diff --git a/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h b/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h index e9012db7602..ab4b0cbaf96 100644 --- a/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h +++ b/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h @@ -34,7 +34,7 @@ public: Error visitTypeStream(CVTypeRange Types); Error visitFieldListMemberStream(ArrayRef FieldList); - Error visitFieldListMemberStream(BinaryStreamReader Reader); + Error visitFieldListMemberStream(msf::StreamReader Reader); private: /// The interface to the class that gets notified of each visitation. diff --git a/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h b/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h index b7f621d2480..8c0506b8451 100644 --- a/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h +++ b/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h @@ -33,8 +33,8 @@ class CodeViewRecordIO { } public: - explicit CodeViewRecordIO(BinaryStreamReader &Reader) : Reader(&Reader) {} - explicit CodeViewRecordIO(BinaryStreamWriter &Writer) : Writer(&Writer) {} + explicit CodeViewRecordIO(msf::StreamReader &Reader) : Reader(&Reader) {} + explicit CodeViewRecordIO(msf::StreamWriter &Writer) : Writer(&Writer) {} Error beginRecord(Optional MaxLength); Error endRecord(); @@ -59,9 +59,9 @@ public: template Error mapInteger(T &Value) { if (isWriting()) - return Writer->writeInteger(Value); + return Writer->writeInteger(Value, llvm::support::little); - return Reader->readInteger(Value); + return Reader->readInteger(Value, llvm::support::little); } template Error mapEnum(T &Value) { @@ -93,7 +93,7 @@ public: SizeType Size; if (isWriting()) { Size = static_cast(Items.size()); - if (auto EC = Writer->writeInteger(Size)) + if (auto EC = Writer->writeInteger(Size, llvm::support::little)) return EC; for (auto &X : Items) { @@ -101,7 +101,7 @@ public: return EC; } } else { - if (auto EC = Reader->readInteger(Size)) + if (auto EC = Reader->readInteger(Size, llvm::support::little)) return EC; for (SizeType I = 0; I < Size; ++I) { typename T::value_type Item; @@ -160,8 +160,8 @@ private: SmallVector Limits; - BinaryStreamReader *Reader = nullptr; - BinaryStreamWriter *Writer = nullptr; + msf::StreamReader *Reader = nullptr; + msf::StreamWriter *Writer = nullptr; }; } // end namespace codeview diff --git a/include/llvm/DebugInfo/CodeView/ModuleSubstream.h b/include/llvm/DebugInfo/CodeView/ModuleSubstream.h index eb881da8e69..5bbcabaef88 100644 --- a/include/llvm/DebugInfo/CodeView/ModuleSubstream.h +++ b/include/llvm/DebugInfo/CodeView/ModuleSubstream.h @@ -59,22 +59,23 @@ struct ColumnNumberEntry { class ModuleSubstream { public: ModuleSubstream(); - ModuleSubstream(ModuleSubstreamKind Kind, BinaryStreamRef Data); - static Error initialize(BinaryStreamRef Stream, ModuleSubstream &Info); + ModuleSubstream(ModuleSubstreamKind Kind, msf::ReadableStreamRef Data); + static Error initialize(msf::ReadableStreamRef Stream, ModuleSubstream &Info); uint32_t getRecordLength() const; ModuleSubstreamKind getSubstreamKind() const; - BinaryStreamRef getRecordData() const; + msf::ReadableStreamRef getRecordData() const; private: ModuleSubstreamKind Kind; - BinaryStreamRef Data; + msf::ReadableStreamRef Data; }; -typedef VarStreamArray ModuleSubstreamArray; +typedef msf::VarStreamArray ModuleSubstreamArray; } // namespace codeview +namespace msf { template <> struct VarStreamArrayExtractor { - Error operator()(BinaryStreamRef 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; @@ -82,6 +83,7 @@ template <> struct VarStreamArrayExtractor { return Error::success(); } }; +} // namespace msf } // namespace llvm #endif // LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAM_H diff --git a/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h b/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h index 51e6ca04e41..eecaa6e98c5 100644 --- a/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h +++ b/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h @@ -28,8 +28,8 @@ namespace codeview { struct LineColumnEntry { support::ulittle32_t NameIndex; - FixedStreamArray LineNumbers; - FixedStreamArray Columns; + msf::FixedStreamArray LineNumbers; + msf::FixedStreamArray Columns; }; struct FileChecksumEntry { @@ -38,47 +38,49 @@ struct FileChecksumEntry { ArrayRef Checksum; // The bytes of the checksum. }; -typedef VarStreamArray LineInfoArray; -typedef VarStreamArray FileChecksumArray; +typedef msf::VarStreamArray LineInfoArray; +typedef msf::VarStreamArray FileChecksumArray; class IModuleSubstreamVisitor { public: virtual ~IModuleSubstreamVisitor() = default; virtual Error visitUnknown(ModuleSubstreamKind Kind, - BinaryStreamRef Data) = 0; - virtual Error visitSymbols(BinaryStreamRef Data); - virtual Error visitLines(BinaryStreamRef Data, + 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(BinaryStreamRef Data); - virtual Error visitFileChecksums(BinaryStreamRef Data, + virtual Error visitStringTable(msf::ReadableStreamRef Data); + virtual Error visitFileChecksums(msf::ReadableStreamRef Data, const FileChecksumArray &Checksums); - virtual Error visitFrameData(BinaryStreamRef Data); - virtual Error visitInlineeLines(BinaryStreamRef Data); - virtual Error visitCrossScopeImports(BinaryStreamRef Data); - virtual Error visitCrossScopeExports(BinaryStreamRef Data); - virtual Error visitILLines(BinaryStreamRef Data); - virtual Error visitFuncMDTokenMap(BinaryStreamRef Data); - virtual Error visitTypeMDTokenMap(BinaryStreamRef Data); - virtual Error visitMergedAssemblyInput(BinaryStreamRef Data); - virtual Error visitCoffSymbolRVA(BinaryStreamRef 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, IModuleSubstreamVisitor &V); } // end namespace codeview +namespace msf { + template <> class VarStreamArrayExtractor { public: VarStreamArrayExtractor(const codeview::LineSubstreamHeader *Header) : Header(Header) {} - Error operator()(BinaryStreamRef Stream, uint32_t &Len, + Error operator()(ReadableStreamRef Stream, uint32_t &Len, codeview::LineColumnEntry &Item) const { using namespace codeview; const LineFileBlockHeader *BlockHeader; - BinaryStreamReader Reader(Stream); + StreamReader Reader(Stream); if (auto EC = Reader.readObject(BlockHeader)) return EC; bool HasColumn = Header->Flags & LineFlags::HaveColumns; @@ -111,11 +113,11 @@ private: template <> class VarStreamArrayExtractor { public: - Error operator()(BinaryStreamRef Stream, uint32_t &Len, + Error operator()(ReadableStreamRef Stream, uint32_t &Len, codeview::FileChecksumEntry &Item) const { using namespace codeview; const FileChecksum *Header; - BinaryStreamReader Reader(Stream); + StreamReader Reader(Stream); if (auto EC = Reader.readObject(Header)) return EC; Item.FileNameOffset = Header->FileNameOffset; @@ -127,6 +129,8 @@ public: } }; +} // end namespace msf + } // end namespace llvm #endif // LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAMVISITOR_H diff --git a/include/llvm/DebugInfo/CodeView/RecordSerialization.h b/include/llvm/DebugInfo/CodeView/RecordSerialization.h index f6e49973f9d..6505fd6df6a 100644 --- a/include/llvm/DebugInfo/CodeView/RecordSerialization.h +++ b/include/llvm/DebugInfo/CodeView/RecordSerialization.h @@ -41,37 +41,37 @@ struct RecordPrefix { StringRef getBytesAsCharacters(ArrayRef LeafData); StringRef getBytesAsCString(ArrayRef LeafData); -inline Error consume(BinaryStreamReader &Reader) { return Error::success(); } +inline Error consume(msf::StreamReader &Reader) { return Error::success(); } /// Decodes a numeric "leaf" value. These are integer literals encountered in /// the type stream. If the value is positive and less than LF_NUMERIC (1 << /// 15), it is emitted directly in Data. Otherwise, it has a tag like LF_CHAR /// that indicates the bitwidth and sign of the numeric data. -Error consume(BinaryStreamReader &Reader, APSInt &Num); +Error consume(msf::StreamReader &Reader, APSInt &Num); /// Decodes a numeric leaf value that is known to be a particular type. -Error consume_numeric(BinaryStreamReader &Reader, uint64_t &Value); +Error consume_numeric(msf::StreamReader &Reader, uint64_t &Value); /// Decodes signed and unsigned fixed-length integers. -Error consume(BinaryStreamReader &Reader, uint32_t &Item); -Error consume(BinaryStreamReader &Reader, int32_t &Item); +Error consume(msf::StreamReader &Reader, uint32_t &Item); +Error consume(msf::StreamReader &Reader, int32_t &Item); /// Decodes a null terminated string. -Error consume(BinaryStreamReader &Reader, StringRef &Item); +Error consume(msf::StreamReader &Reader, StringRef &Item); Error consume(StringRef &Data, APSInt &Num); Error consume(StringRef &Data, uint32_t &Item); /// Decodes an arbitrary object whose layout matches that of the underlying /// byte sequence, and returns a pointer to the object. -template Error consume(BinaryStreamReader &Reader, T *&Item) { +template Error consume(msf::StreamReader &Reader, T *&Item) { return Reader.readObject(Item); } template struct serialize_conditional_impl { serialize_conditional_impl(T &Item, U Func) : Item(Item), Func(Func) {} - Error deserialize(BinaryStreamReader &Reader) const { + Error deserialize(msf::StreamReader &Reader) const { if (!Func()) return Error::success(); return consume(Reader, Item); @@ -89,7 +89,7 @@ serialize_conditional_impl serialize_conditional(T &Item, U Func) { template struct serialize_array_impl { serialize_array_impl(ArrayRef &Item, U Func) : Item(Item), Func(Func) {} - Error deserialize(BinaryStreamReader &Reader) const { + Error deserialize(msf::StreamReader &Reader) const { return Reader.readArray(Item, Func()); } @@ -100,7 +100,7 @@ template struct serialize_array_impl { template struct serialize_vector_tail_impl { serialize_vector_tail_impl(std::vector &Item) : Item(Item) {} - Error deserialize(BinaryStreamReader &Reader) const { + Error deserialize(msf::StreamReader &Reader) const { T Field; // Stop when we run out of bytes or we hit record padding bytes. while (!Reader.empty() && Reader.peek() < LF_PAD0) { @@ -118,14 +118,14 @@ struct serialize_null_term_string_array_impl { serialize_null_term_string_array_impl(std::vector &Item) : Item(Item) {} - Error deserialize(BinaryStreamReader &Reader) const { + Error deserialize(msf::StreamReader &Reader) const { if (Reader.empty()) return make_error(cv_error_code::insufficient_buffer, "Null terminated string is empty!"); while (Reader.peek() != 0) { StringRef Field; - if (auto EC = Reader.readCString(Field)) + if (auto EC = Reader.readZeroString(Field)) return EC; Item.push_back(Field); } @@ -138,7 +138,7 @@ struct serialize_null_term_string_array_impl { template struct serialize_arrayref_tail_impl { serialize_arrayref_tail_impl(ArrayRef &Item) : Item(Item) {} - Error deserialize(BinaryStreamReader &Reader) const { + Error deserialize(msf::StreamReader &Reader) const { uint32_t Count = Reader.bytesRemaining() / sizeof(T); return Reader.readArray(Item, Count); } @@ -149,7 +149,7 @@ template struct serialize_arrayref_tail_impl { template struct serialize_numeric_impl { serialize_numeric_impl(T &Item) : Item(Item) {} - Error deserialize(BinaryStreamReader &Reader) const { + Error deserialize(msf::StreamReader &Reader) const { return consume_numeric(Reader, Item); } @@ -201,42 +201,42 @@ template serialize_numeric_impl serialize_numeric(T &Item) { #define CV_NUMERIC_FIELD(I) serialize_numeric(I) template -Error consume(BinaryStreamReader &Reader, +Error consume(msf::StreamReader &Reader, const serialize_conditional_impl &Item) { return Item.deserialize(Reader); } template -Error consume(BinaryStreamReader &Reader, +Error consume(msf::StreamReader &Reader, const serialize_array_impl &Item) { return Item.deserialize(Reader); } -inline Error consume(BinaryStreamReader &Reader, +inline Error consume(msf::StreamReader &Reader, const serialize_null_term_string_array_impl &Item) { return Item.deserialize(Reader); } template -Error consume(BinaryStreamReader &Reader, +Error consume(msf::StreamReader &Reader, const serialize_vector_tail_impl &Item) { return Item.deserialize(Reader); } template -Error consume(BinaryStreamReader &Reader, +Error consume(msf::StreamReader &Reader, const serialize_arrayref_tail_impl &Item) { return Item.deserialize(Reader); } template -Error consume(BinaryStreamReader &Reader, +Error consume(msf::StreamReader &Reader, const serialize_numeric_impl &Item) { return Item.deserialize(Reader); } template -Error consume(BinaryStreamReader &Reader, T &&X, U &&Y, Args &&... Rest) { +Error consume(msf::StreamReader &Reader, T &&X, U &&Y, Args &&... Rest) { if (auto EC = consume(Reader, X)) return EC; return consume(Reader, Y, std::forward(Rest)...); diff --git a/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h b/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h index 2a5f20d88ed..46eb789bcaa 100644 --- a/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h +++ b/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h @@ -25,11 +25,10 @@ class SymbolVisitorDelegate; class SymbolDeserializer : public SymbolVisitorCallbacks { struct MappingInfo { explicit MappingInfo(ArrayRef RecordData) - : Stream(RecordData, llvm::support::little), Reader(Stream), - Mapping(Reader) {} + : Stream(RecordData), Reader(Stream), Mapping(Reader) {} - BinaryByteStream Stream; - BinaryStreamReader Reader; + msf::ByteStream Stream; + msf::StreamReader Reader; SymbolRecordMapping Mapping; }; diff --git a/include/llvm/DebugInfo/CodeView/SymbolRecord.h b/include/llvm/DebugInfo/CodeView/SymbolRecord.h index a3b9077e89c..cae349995ee 100644 --- a/include/llvm/DebugInfo/CodeView/SymbolRecord.h +++ b/include/llvm/DebugInfo/CodeView/SymbolRecord.h @@ -938,7 +938,7 @@ public: }; typedef CVRecord CVSymbol; -typedef VarStreamArray CVSymbolArray; +typedef msf::VarStreamArray CVSymbolArray; } // end namespace codeview } // end namespace llvm diff --git a/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h b/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h index 0a1837a0d93..1bd14ed1347 100644 --- a/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h +++ b/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h @@ -14,14 +14,16 @@ #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h" namespace llvm { -class BinaryStreamReader; -class BinaryStreamWriter; +namespace msf { +class StreamReader; +class StreamWriter; +} namespace codeview { class SymbolRecordMapping : public SymbolVisitorCallbacks { public: - explicit SymbolRecordMapping(BinaryStreamReader &Reader) : IO(Reader) {} - explicit SymbolRecordMapping(BinaryStreamWriter &Writer) : IO(Writer) {} + explicit SymbolRecordMapping(msf::StreamReader &Reader) : IO(Reader) {} + explicit SymbolRecordMapping(msf::StreamWriter &Writer) : IO(Writer) {} Error visitSymbolBegin(CVSymbol &Record) override; Error visitSymbolEnd(CVSymbol &Record) override; diff --git a/include/llvm/DebugInfo/CodeView/SymbolSerializer.h b/include/llvm/DebugInfo/CodeView/SymbolSerializer.h index eb25751a271..73095ff7be5 100644 --- a/include/llvm/DebugInfo/CodeView/SymbolSerializer.h +++ b/include/llvm/DebugInfo/CodeView/SymbolSerializer.h @@ -20,8 +20,6 @@ #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/iterator_range.h" -#include "llvm/DebugInfo/MSF/BinaryByteStream.h" -#include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Error.h" @@ -30,7 +28,7 @@ namespace codeview { class SymbolSerializer : public SymbolVisitorCallbacks { uint32_t RecordStart = 0; - BinaryStreamWriter &Writer; + msf::StreamWriter &Writer; SymbolRecordMapping Mapping; Optional CurrentSymbol; @@ -44,7 +42,7 @@ class SymbolSerializer : public SymbolVisitorCallbacks { } public: - explicit SymbolSerializer(BinaryStreamWriter &Writer) + explicit SymbolSerializer(msf::StreamWriter &Writer) : Writer(Writer), Mapping(Writer) {} virtual Error visitSymbolBegin(CVSymbol &Record) override { diff --git a/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h b/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h index 2bef3f61adf..2b468a289fd 100644 --- a/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h +++ b/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h @@ -15,7 +15,9 @@ namespace llvm { -class BinaryStreamReader; +namespace msf { +class StreamReader; +} // end namespace msf namespace codeview { @@ -23,7 +25,7 @@ class SymbolVisitorDelegate { public: virtual ~SymbolVisitorDelegate() = default; - virtual uint32_t getRecordOffset(BinaryStreamReader Reader) = 0; + virtual uint32_t getRecordOffset(msf::StreamReader Reader) = 0; virtual StringRef getFileNameForFileOffset(uint32_t FileOffset) = 0; virtual StringRef getStringTable() = 0; }; diff --git a/include/llvm/DebugInfo/CodeView/TypeDeserializer.h b/include/llvm/DebugInfo/CodeView/TypeDeserializer.h index 92177a48d4c..ab4f11f7111 100644 --- a/include/llvm/DebugInfo/CodeView/TypeDeserializer.h +++ b/include/llvm/DebugInfo/CodeView/TypeDeserializer.h @@ -29,11 +29,10 @@ namespace codeview { class TypeDeserializer : public TypeVisitorCallbacks { struct MappingInfo { explicit MappingInfo(ArrayRef RecordData) - : Stream(RecordData, llvm::support::little), Reader(Stream), - Mapping(Reader) {} + : Stream(RecordData), Reader(Stream), Mapping(Reader) {} - BinaryByteStream Stream; - BinaryStreamReader Reader; + msf::ByteStream Stream; + msf::StreamReader Reader; TypeRecordMapping Mapping; }; @@ -73,16 +72,16 @@ private: class FieldListDeserializer : public TypeVisitorCallbacks { struct MappingInfo { - explicit MappingInfo(BinaryStreamReader &R) + explicit MappingInfo(msf::StreamReader &R) : Reader(R), Mapping(Reader), StartOffset(0) {} - BinaryStreamReader &Reader; + msf::StreamReader &Reader; TypeRecordMapping Mapping; uint32_t StartOffset; }; public: - explicit FieldListDeserializer(BinaryStreamReader &Reader) : Mapping(Reader) { + explicit FieldListDeserializer(msf::StreamReader &Reader) : Mapping(Reader) { CVType FieldList; FieldList.Type = TypeLeafKind::LF_FIELDLIST; consumeError(Mapping.Mapping.visitTypeBegin(FieldList)); diff --git a/include/llvm/DebugInfo/CodeView/TypeRecord.h b/include/llvm/DebugInfo/CodeView/TypeRecord.h index 4cc0aa76ff6..290a3f4185d 100644 --- a/include/llvm/DebugInfo/CodeView/TypeRecord.h +++ b/include/llvm/DebugInfo/CodeView/TypeRecord.h @@ -26,7 +26,9 @@ namespace llvm { -class BinaryStreamReader; +namespace msf { +class StreamReader; +} // end namespace msf namespace codeview { @@ -40,7 +42,7 @@ struct CVMemberRecord { TypeLeafKind Kind; ArrayRef Data; }; -typedef VarStreamArray CVTypeArray; +typedef msf::VarStreamArray CVTypeArray; typedef iterator_range CVTypeRange; /// Equvalent to CV_fldattr_t in cvinfo.h. diff --git a/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h b/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h index 924ca0470fa..fe470a72abb 100644 --- a/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h +++ b/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h @@ -16,14 +16,15 @@ #include "llvm/Support/Error.h" namespace llvm { -class BinaryStreamReader; -class BinaryStreamWriter; - +namespace msf { +class StreamReader; +class StreamWriter; +} namespace codeview { class TypeRecordMapping : public TypeVisitorCallbacks { public: - explicit TypeRecordMapping(BinaryStreamReader &Reader) : IO(Reader) {} - explicit TypeRecordMapping(BinaryStreamWriter &Writer) : IO(Writer) {} + explicit TypeRecordMapping(msf::StreamReader &Reader) : IO(Reader) {} + explicit TypeRecordMapping(msf::StreamWriter &Writer) : IO(Writer) {} Error visitTypeBegin(CVType &Record) override; Error visitTypeEnd(CVType &Record) override; diff --git a/include/llvm/DebugInfo/CodeView/TypeSerializer.h b/include/llvm/DebugInfo/CodeView/TypeSerializer.h index 80867ecb41f..9210758126b 100644 --- a/include/llvm/DebugInfo/CodeView/TypeSerializer.h +++ b/include/llvm/DebugInfo/CodeView/TypeSerializer.h @@ -56,8 +56,8 @@ class TypeSerializer : public TypeVisitorCallbacks { Optional TypeKind; Optional MemberKind; std::vector RecordBuffer; - MutableBinaryByteStream Stream; - BinaryStreamWriter Writer; + msf::MutableByteStream Stream; + msf::StreamWriter Writer; TypeRecordMapping Mapping; RecordList SeenRecords; @@ -109,7 +109,7 @@ private: Error visitKnownMemberImpl(CVMemberRecord &CVR, RecordType &Record) { assert(CVR.Kind == static_cast(Record.getKind())); - if (auto EC = Writer.writeEnum(CVR.Kind)) + if (auto EC = Writer.writeEnum(CVR.Kind, llvm::support::little)) return EC; if (auto EC = Mapping.visitKnownMember(CVR, Record)) diff --git a/include/llvm/DebugInfo/MSF/BinaryByteStream.h b/include/llvm/DebugInfo/MSF/BinaryByteStream.h index ee4056a83e2..13208f3325d 100644 --- a/include/llvm/DebugInfo/MSF/BinaryByteStream.h +++ b/include/llvm/DebugInfo/MSF/BinaryByteStream.h @@ -1,19 +1,19 @@ -//===- BinaryByteStream.h ---------------------------------------*- C++ -*-===// +//===- ByteStream.h - Reads stream data from a byte sequence ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -//===----------------------------------------------------------------------===// -// A BinaryStream which stores data in a single continguous memory buffer. +// //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_BINARYBYTESTREAM_H -#define LLVM_SUPPORT_BINARYBYTESTREAM_H +#ifndef LLVM_DEBUGINFO_MSF_BYTESTREAM_H +#define LLVM_DEBUGINFO_MSF_BYTESTREAM_H #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/StringRef.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" +#include "llvm/DebugInfo/MSF/MSFError.h" #include "llvm/Support/Error.h" #include "llvm/Support/FileOutputBuffer.h" #include "llvm/Support/MemoryBuffer.h" @@ -23,40 +23,34 @@ #include namespace llvm { +namespace msf { -/// \brief An implementation of BinaryStream which holds its entire data set -/// in a single contiguous buffer. BinaryByteStream guarantees that no read -/// operation will ever incur a copy. Note that BinaryByteStream does not -/// own the underlying buffer. -class BinaryByteStream : public BinaryStream { +class ByteStream : public ReadableStream { public: - BinaryByteStream() = default; - BinaryByteStream(ArrayRef Data, llvm::support::endianness Endian) - : Endian(Endian), Data(Data) {} - BinaryByteStream(StringRef Data, llvm::support::endianness Endian) - : Endian(Endian), Data(Data.bytes_begin(), Data.bytes_end()) {} - - llvm::support::endianness getEndian() const override { return Endian; } + ByteStream() = default; + explicit ByteStream(ArrayRef Data) : Data(Data) {} + explicit ByteStream(StringRef Data) + : Data(Data.bytes_begin(), Data.bytes_end()) {} Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { if (Offset > Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); if (Data.size() < Size + Offset) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); Buffer = Data.slice(Offset, Size); return Error::success(); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { if (Offset >= Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); Buffer = Data.slice(Offset); return Error::success(); } - uint32_t getLength() override { return Data.size(); } + uint32_t getLength() const override { return Data.size(); } ArrayRef data() const { return Data; } @@ -66,91 +60,76 @@ public: } protected: - llvm::support::endianness Endian; ArrayRef Data; }; -/// \brief An implementation of BinaryStream whose data is backed by an llvm -/// MemoryBuffer object. MemoryBufferByteStream owns the MemoryBuffer in -/// question. As with BinaryByteStream, reading from a MemoryBufferByteStream -/// will never cause a copy. -class MemoryBufferByteStream : public BinaryByteStream { +// 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 Buffer, - llvm::support::endianness Endian) - : BinaryByteStream(Buffer->getBuffer(), Endian), + explicit MemoryBufferByteStream(std::unique_ptr Buffer) + : ByteStream(ArrayRef(Buffer->getBuffer().bytes_begin(), + Buffer->getBuffer().bytes_end())), MemBuffer(std::move(Buffer)) {} std::unique_ptr MemBuffer; }; -/// \brief An implementation of BinaryStream which holds its entire data set -/// in a single contiguous buffer. As with BinaryByteStream, the mutable -/// version also guarantees that no read operation will ever incur a copy, -/// and similarly it does not own the underlying buffer. -class MutableBinaryByteStream : public WritableBinaryStream { +class MutableByteStream : public WritableStream { public: - MutableBinaryByteStream() = default; - MutableBinaryByteStream(MutableArrayRef Data, - llvm::support::endianness Endian) - : Data(Data), ImmutableStream(Data, Endian) {} - - llvm::support::endianness getEndian() const override { - return ImmutableStream.getEndian(); - } + MutableByteStream() = default; + explicit MutableByteStream(MutableArrayRef Data) + : Data(Data), ImmutableStream(Data) {} Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { return ImmutableStream.readBytes(Offset, Size, Buffer); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { return ImmutableStream.readLongestContiguousChunk(Offset, Buffer); } - uint32_t getLength() override { return ImmutableStream.getLength(); } + uint32_t getLength() const override { return ImmutableStream.getLength(); } - Error writeBytes(uint32_t Offset, ArrayRef Buffer) override { + Error writeBytes(uint32_t Offset, ArrayRef Buffer) const override { if (Buffer.empty()) return Error::success(); if (Data.size() < Buffer.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); if (Offset > Buffer.size() - Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); uint8_t *DataPtr = const_cast(Data.data()); ::memcpy(DataPtr + Offset, Buffer.data(), Buffer.size()); return Error::success(); } - Error commit() override { return Error::success(); } + Error commit() const override { return Error::success(); } MutableArrayRef data() const { return Data; } private: MutableArrayRef Data; - BinaryByteStream ImmutableStream; + ByteStream ImmutableStream; }; -/// \brief An implementation of WritableBinaryStream backed by an llvm -/// FileOutputBuffer. -class FileBufferByteStream : public WritableBinaryStream { +// A simple adapter that acts like a ByteStream but holds ownership over +// and underlying FileOutputBuffer. +class FileBufferByteStream : public WritableStream { private: - class StreamImpl : public MutableBinaryByteStream { + class StreamImpl : public MutableByteStream { public: - StreamImpl(std::unique_ptr Buffer, - llvm::support::endianness Endian) - : MutableBinaryByteStream( - MutableArrayRef(Buffer->getBufferStart(), - Buffer->getBufferEnd()), - Endian), + StreamImpl(std::unique_ptr Buffer) + : MutableByteStream(MutableArrayRef(Buffer->getBufferStart(), + Buffer->getBufferEnd())), FileBuffer(std::move(Buffer)) {} - Error commit() override { + Error commit() const override { if (FileBuffer->commit()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return llvm::make_error(msf_error_code::not_writable); return Error::success(); } @@ -159,36 +138,32 @@ private: }; public: - explicit FileBufferByteStream(std::unique_ptr Buffer, - llvm::support::endianness Endian) - : Impl(std::move(Buffer), Endian) {} - - llvm::support::endianness getEndian() const override { - return Impl.getEndian(); - } + explicit FileBufferByteStream(std::unique_ptr Buffer) + : Impl(std::move(Buffer)) {} Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { return Impl.readBytes(Offset, Size, Buffer); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { return Impl.readLongestContiguousChunk(Offset, Buffer); } - uint32_t getLength() override { return Impl.getLength(); } + uint32_t getLength() const override { return Impl.getLength(); } - Error writeBytes(uint32_t Offset, ArrayRef Data) override { + Error writeBytes(uint32_t Offset, ArrayRef Data) const override { return Impl.writeBytes(Offset, Data); } - Error commit() override { return Impl.commit(); } + Error commit() const override { return Impl.commit(); } private: StreamImpl Impl; }; +} // end namespace msf } // end namespace llvm -#endif // LLVM_SUPPORT_BINARYBYTESTREAM_H +#endif // LLVM_DEBUGINFO_MSF_BYTESTREAM_H diff --git a/include/llvm/DebugInfo/MSF/BinaryItemStream.h b/include/llvm/DebugInfo/MSF/BinaryItemStream.h index 15bb701d35d..d76286d2850 100644 --- a/include/llvm/DebugInfo/MSF/BinaryItemStream.h +++ b/include/llvm/DebugInfo/MSF/BinaryItemStream.h @@ -1,4 +1,4 @@ -//===- BinaryItemStream.h ---------------------------------------*- C++ -*-===// +//===- SequencedItemStream.h ------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,96 +7,87 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_BINARYITEMSTREAM_H -#define LLVM_SUPPORT_BINARYITEMSTREAM_H +#ifndef LLVM_DEBUGINFO_MSF_SEQUENCEDITEMSTREAM_H +#define LLVM_DEBUGINFO_MSF_SEQUENCEDITEMSTREAM_H #include "llvm/ADT/ArrayRef.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" +#include "llvm/DebugInfo/MSF/MSFError.h" #include "llvm/Support/Error.h" #include #include namespace llvm { +namespace msf { -template struct BinaryItemTraits { - size_t length(const T &Item) = delete; - ArrayRef bytes(const T &Item) = delete; +template struct SequencedItemTraits { + static size_t length(const T &Item) = delete; + static ArrayRef bytes(const T &Item) = delete; }; -/// BinaryItemStream represents a sequence of objects stored in some kind of -/// external container but for which it is useful to view as a stream of -/// contiguous bytes. An example of this might be if you have a collection of -/// records and you serialize each one into a buffer, and store these serialized -/// records in a container. The pointers themselves are not laid out -/// contiguously in memory, but we may wish to read from or write to these -/// records as if they were. -template > -class BinaryItemStream : public BinaryStream { +/// SequencedItemStream represents a sequence of objects stored in a +/// standard container but for which it is useful to view as a stream of +/// contiguous bytes. An example of this might be if you have a std::vector +/// of TPI records, where each record contains a byte sequence that +/// represents that one record serialized, but where each consecutive item +/// might not be allocated immediately after the previous item. Using a +/// SequencedItemStream, we can adapt the VarStreamArray class to trivially +/// extract one item at a time, allowing the data to be used anywhere a +/// VarStreamArray could be used. +template > +class SequencedItemStream : public ReadableStream { public: - explicit BinaryItemStream(llvm::support::endianness Endian) - : Endian(Endian) {} - - llvm::support::endianness getEndian() const override { return Endian; } + SequencedItemStream() = default; Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override { - if (auto EC = readLongestContiguousChunk(Offset, Buffer)) - return EC; - - if (Size > Buffer.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); - - Buffer = Buffer.take_front(Size); + ArrayRef &Buffer) const override { + auto ExpectedIndex = translateOffsetIndex(Offset); + if (!ExpectedIndex) + return ExpectedIndex.takeError(); + const auto &Item = Items[*ExpectedIndex]; + if (Size > Traits::length(Item)) + return make_error(msf_error_code::insufficient_buffer); + Buffer = Traits::bytes(Item).take_front(Size); return Error::success(); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override { - uint32_t Index; - uint32_t ByteOffset; - if (auto EC = translateOffsetIndex(Offset, Index, ByteOffset)) - return EC; - const auto &Item = Items[Index]; - Buffer = Traits.bytes(Item).drop_front(ByteOffset); + ArrayRef &Buffer) const override { + auto ExpectedIndex = translateOffsetIndex(Offset); + if (!ExpectedIndex) + return ExpectedIndex.takeError(); + Buffer = Traits::bytes(Items[*ExpectedIndex]); return Error::success(); } void setItems(ArrayRef ItemArray) { Items = ItemArray; } - uint32_t getLength() override { + uint32_t getLength() const override { uint32_t Size = 0; for (const auto &Item : Items) - Size += Traits.length(Item); + Size += Traits::length(Item); return Size; } private: - Error translateOffsetIndex(uint32_t Offset, uint32_t &ItemIndex, - uint32_t &ByteOffset) { - ItemIndex = 0; - ByteOffset = 0; - uint32_t PrevOffset = 0; + Expected translateOffsetIndex(uint32_t Offset) const { uint32_t CurrentOffset = 0; - if (Offset > 0) { - for (const auto &Item : Items) { - PrevOffset = CurrentOffset; - CurrentOffset += Traits.length(Item); - if (CurrentOffset > Offset) - break; - ++ItemIndex; - } + uint32_t CurrentIndex = 0; + for (const auto &Item : Items) { + if (CurrentOffset >= Offset) + break; + CurrentOffset += Traits::length(Item); + ++CurrentIndex; } - if (CurrentOffset < Offset) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); - ByteOffset = Offset - PrevOffset; - return Error::success(); + if (CurrentOffset != Offset) + return make_error(msf_error_code::insufficient_buffer); + return CurrentIndex; } - llvm::support::endianness Endian; - ItemTraits Traits; ArrayRef Items; }; +} // end namespace msf } // end namespace llvm -#endif // LLVM_SUPPORT_BINARYITEMSTREAM_H +#endif // LLVM_DEBUGINFO_MSF_SEQUENCEDITEMSTREAM_H diff --git a/include/llvm/DebugInfo/MSF/BinaryStream.h b/include/llvm/DebugInfo/MSF/BinaryStream.h index 129679f2825..09782d8e3b3 100644 --- a/include/llvm/DebugInfo/MSF/BinaryStream.h +++ b/include/llvm/DebugInfo/MSF/BinaryStream.h @@ -1,4 +1,4 @@ -//===- BinaryStream.h - Base interface for a stream of data -----*- C++ -*-===// +//===- StreamInterface.h - Base interface for a stream of data --*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,62 +7,47 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_BINARYSTREAM_H -#define LLVM_SUPPORT_BINARYSTREAM_H +#ifndef LLVM_DEBUGINFO_MSF_STREAMINTERFACE_H +#define LLVM_DEBUGINFO_MSF_STREAMINTERFACE_H #include "llvm/ADT/ArrayRef.h" -#include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" #include namespace llvm { +namespace msf { -/// \brief An interface for accessing data in a stream-like format, but which -/// discourages copying. Instead of specifying a buffer in which to copy -/// data on a read, the API returns an ArrayRef to data owned by the stream's -/// implementation. Since implementations may not necessarily store data in a -/// single contiguous buffer (or even in memory at all), in such cases a it may -/// be necessary for an implementation to cache such a buffer so that it can -/// return it. -class BinaryStream { +class ReadableStream { public: - virtual ~BinaryStream() = default; + virtual ~ReadableStream() = default; - virtual llvm::support::endianness getEndian() const = 0; - - /// \brief Given an offset into the stream and a number of bytes, attempt to - /// read the bytes and set the output ArrayRef to point to data owned by the - /// stream. + // 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 + // stream, without copying any data. virtual Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) = 0; + ArrayRef &Buffer) const = 0; - /// \brief Given an offset into the stream, read as much as possible without - /// copying any data. + // Given an offset into the stream, read as much as possible without copying + // any data. virtual Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) = 0; + ArrayRef &Buffer) const = 0; - /// \brief Return the number of bytes of data in this stream. - virtual uint32_t getLength() = 0; + virtual uint32_t getLength() const = 0; }; -/// \brief A BinaryStream which can be read from as well as written to. Note -/// that writing to a BinaryStream always necessitates copying from the input -/// buffer to the stream's backing store. Streams are assumed to be buffered -/// so that to be portable it is necessary to call commit() on the stream when -/// all data has been written. -class WritableBinaryStream : public BinaryStream { +class WritableStream : public ReadableStream { public: - ~WritableBinaryStream() override = default; + ~WritableStream() override = default; - /// \brief 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 Data) = 0; + // 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 Data) const = 0; - /// \brief For buffered streams, commits changes to the backing store. - virtual Error commit() = 0; + virtual Error commit() const = 0; }; +} // end namespace msf } // end namespace llvm -#endif // LLVM_SUPPORT_BINARYSTREAM_H +#endif // LLVM_DEBUGINFO_MSF_STREAMINTERFACE_H diff --git a/include/llvm/DebugInfo/MSF/BinaryStreamArray.h b/include/llvm/DebugInfo/MSF/BinaryStreamArray.h index d0fbd77a137..66fbd3c5fe9 100644 --- a/include/llvm/DebugInfo/MSF/BinaryStreamArray.h +++ b/include/llvm/DebugInfo/MSF/BinaryStreamArray.h @@ -1,4 +1,4 @@ -//===- BinaryStreamArray.h - Array backed by an arbitrary stream *- C++ -*-===// +//===- StreamArray.h - Array backed by an arbitrary stream ------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,8 +7,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_BINARYSTREAMARRAY_H -#define LLVM_SUPPORT_BINARYSTREAMARRAY_H +#ifndef LLVM_DEBUGINFO_MSF_STREAMARRAY_H +#define LLVM_DEBUGINFO_MSF_STREAMARRAY_H #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/iterator.h" @@ -17,20 +17,11 @@ #include #include -/// Lightweight arrays that are backed by an arbitrary BinaryStream. This file -/// provides two different array implementations. -/// -/// VarStreamArray - Arrays of variable length records. The user specifies -/// an Extractor type that can extract a record from a given offset and -/// return the number of bytes consumed by the record. -/// -/// FixedStreamArray - Arrays of fixed length records. This is similar in -/// spirit to ArrayRef, but since it is backed by a BinaryStream, the -/// elements of the array need not be laid out in contiguous memory. namespace llvm { +namespace msf { /// VarStreamArrayExtractor is intended to be specialized to provide customized -/// extraction logic. On input it receives a BinaryStreamRef pointing to the +/// extraction logic. On input it receives a StreamRef pointing to the /// beginning of the next record, but where the length of the record is not yet /// known. Upon completion, it should return an appropriate Error instance if /// a record could not be extracted, or if one could be extracted it should @@ -44,7 +35,7 @@ namespace llvm { template struct VarStreamArrayExtractor { // Method intentionally deleted. You must provide an explicit specialization // with the following method implemented. - Error operator()(BinaryStreamRef Stream, uint32_t &Len, + Error operator()(ReadableStreamRef Stream, uint32_t &Len, T &Item) const = delete; }; @@ -58,10 +49,10 @@ template struct VarStreamArrayExtractor { /// abstracting this out, we need not duplicate this memory, and we can /// iterate over arrays in arbitrarily formatted streams. Elements are parsed /// lazily on iteration, so there is no upfront cost associated with building -/// or copying a VarStreamArray, no matter how large it may be. +/// a VarStreamArray, no matter how large it may be. /// /// You create a VarStreamArray by specifying a ValueType and an Extractor type. -/// If you do not specify an Extractor type, you are expected to specialize +/// If you do not specify an Extractor type, it expects you to specialize /// VarStreamArrayExtractor for your ValueType. /// /// By default an Extractor is default constructed in the class, but in some @@ -95,8 +86,8 @@ public: VarStreamArray() = default; explicit VarStreamArray(const Extractor &E) : E(E) {} - explicit VarStreamArray(BinaryStreamRef Stream) : Stream(Stream) {} - VarStreamArray(BinaryStreamRef Stream, const Extractor &E) + explicit VarStreamArray(ReadableStreamRef Stream) : Stream(Stream) {} + VarStreamArray(ReadableStreamRef Stream, const Extractor &E) : Stream(Stream), E(E) {} VarStreamArray(const VarStreamArray &Other) @@ -110,10 +101,10 @@ public: const Extractor &getExtractor() const { return E; } - BinaryStreamRef getUnderlyingStream() const { return Stream; } + ReadableStreamRef getUnderlyingStream() const { return Stream; } private: - BinaryStreamRef Stream; + ReadableStreamRef Stream; Extractor E; }; @@ -162,25 +153,23 @@ public: return ThisValue; } - IterType &operator+=(unsigned N) { - for (unsigned I = 0; I < N; ++I) { - // We are done with the current record, discard it so that we are - // positioned at the next record. - IterRef = IterRef.drop_front(ThisLen); - if (IterRef.getLength() == 0) { - // There is nothing after the current record, we must make this an end - // iterator. + IterType &operator++() { + // We are done with the current record, discard it so that we are + // positioned at the next record. + IterRef = IterRef.drop_front(ThisLen); + if (IterRef.getLength() == 0) { + // There is nothing after the current record, we must make this an end + // iterator. + moveToEnd(); + } else { + // There is some data after the current record. + auto EC = Extract(IterRef, ThisLen, ThisValue); + if (EC) { + consumeError(std::move(EC)); + markError(); + } else if (ThisLen == 0) { + // An empty record? Make this an end iterator. moveToEnd(); - } else { - // There is some data after the current record. - auto EC = Extract(IterRef, ThisLen, ThisValue); - if (EC) { - consumeError(std::move(EC)); - markError(); - } else if (ThisLen == 0) { - // An empty record? Make this an end iterator. - moveToEnd(); - } } } return *this; @@ -199,7 +188,7 @@ private: } ValueType ThisValue; - BinaryStreamRef IterRef; + ReadableStreamRef IterRef; const ArrayType *Array{nullptr}; uint32_t ThisLen{0}; bool HasError{false}; @@ -209,17 +198,12 @@ private: template class FixedStreamArrayIterator; -/// FixedStreamArray is similar to VarStreamArray, except with each record -/// having a fixed-length. As with VarStreamArray, there is no upfront -/// cost associated with building or copying a FixedStreamArray, as the -/// memory for each element is not read from the backing stream until that -/// element is iterated. template class FixedStreamArray { friend class FixedStreamArrayIterator; public: FixedStreamArray() = default; - explicit FixedStreamArray(BinaryStreamRef Stream) : Stream(Stream) { + FixedStreamArray(ReadableStreamRef Stream) : Stream(Stream) { assert(Stream.getLength() % sizeof(T) == 0); } @@ -258,10 +242,10 @@ public: return FixedStreamArrayIterator(*this, size()); } - BinaryStreamRef getUnderlyingStream() const { return Stream; } + ReadableStreamRef getUnderlyingStream() const { return Stream; } private: - BinaryStreamRef Stream; + ReadableStreamRef Stream; }; template @@ -314,6 +298,7 @@ private: uint32_t Index; }; +} // namespace msf } // namespace llvm -#endif // LLVM_SUPPORT_BINARYSTREAMARRAY_H +#endif // LLVM_DEBUGINFO_MSF_STREAMARRAY_H diff --git a/include/llvm/DebugInfo/MSF/BinaryStreamReader.h b/include/llvm/DebugInfo/MSF/BinaryStreamReader.h index f83076fada4..14768af8ad6 100644 --- a/include/llvm/DebugInfo/MSF/BinaryStreamReader.h +++ b/include/llvm/DebugInfo/MSF/BinaryStreamReader.h @@ -1,4 +1,4 @@ -//===- BinaryStreamReader.h - Reads objects from a binary stream *- C++ -*-===// +//===- StreamReader.h - Reads bytes and objects from a stream ---*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,166 +7,71 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_BINARYSTREAMREADER_H -#define LLVM_SUPPORT_BINARYSTREAMREADER_H +#ifndef LLVM_DEBUGINFO_MSF_STREAMREADER_H +#define LLVM_DEBUGINFO_MSF_STREAMREADER_H #include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/STLExtras.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" #include "llvm/DebugInfo/MSF/BinaryStreamArray.h" #include "llvm/DebugInfo/MSF/BinaryStreamRef.h" +#include "llvm/DebugInfo/MSF/MSFError.h" #include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" -#include "llvm/Support/MathExtras.h" #include "llvm/Support/type_traits.h" #include #include namespace llvm { +namespace msf { -/// \brief Provides read only access to a subclass of `BinaryStream`. Provides -/// bounds checking and helpers for writing certain common data types such as -/// null-terminated strings, integers in various flavors of endianness, etc. -/// Can be subclassed to provide reading of custom datatypes, although no -/// are overridable. -class BinaryStreamReader { +class StreamReader { public: - explicit BinaryStreamReader(BinaryStreamRef Stream); - virtual ~BinaryStreamReader() {} + StreamReader(ReadableStreamRef Stream); - /// Read as much as possible from the underlying string at the current offset - /// without invoking a copy, and set \p Buffer to the resulting data slice. - /// Updates the stream's offset to point after the newly read data. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. Error readLongestContiguousChunk(ArrayRef &Buffer); - - /// Read \p Size bytes from the underlying stream at the current offset and - /// and set \p Buffer to the resulting data slice. Whether a copy occurs - /// depends on the implementation of the underlying stream. Updates the - /// stream's offset to point after the newly read data. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. Error readBytes(ArrayRef &Buffer, uint32_t Size); - /// Read an integer of the specified endianness into \p Dest and update the - /// stream's offset. The data is always copied from the stream's underlying - /// buffer into \p Dest. Updates the stream's offset to point after the newly - /// read data. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. - template Error readInteger(T &Dest) { + template + Error readInteger(T &Dest, + llvm::support::endianness Endian = llvm::support::native) { static_assert(std::is_integral::value, "Cannot call readInteger with non-integral value!"); ArrayRef Bytes; if (auto EC = readBytes(Bytes, sizeof(T))) return EC; - readIntegersImpl(Bytes, Dest); + + Dest = llvm::support::endian::read( + Bytes.data(), Endian); return Error::success(); } - /// Read a list of integers into \p Dest and update the stream's offset. - /// The data is always copied from the stream's underlying into \p Dest. - /// Updates the stream's offset to point after the newly read data. Use of - /// this method is more efficient than calling `readInteger` multiple times - /// because this performs bounds checking only once, and requires only a - /// single error check by the user. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. - template Error readIntegers(Ts &... Dest) { - const size_t Size = sizeof_sum::value; - ArrayRef Bytes; - if (auto EC = readBytes(Bytes, Size)) - return EC; - readIntegersImpl(Bytes, Dest...); - return Error::success(); - } + Error readZeroString(StringRef &Dest); + Error readFixedString(StringRef &Dest, uint32_t Length); + Error readStreamRef(ReadableStreamRef &Ref); + Error readStreamRef(ReadableStreamRef &Ref, uint32_t Length); - /// Read a \p ByteSize byte integer and store the result in \p Dest, updating - /// the reader's position if successful. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. - Error readInteger(uint64_t &Dest, uint32_t ByteSize); - - /// Similar to readInteger. - template Error readEnum(T &Dest) { + template + Error readEnum(T &Dest, + llvm::support::endianness Endian = llvm::support::native) { static_assert(std::is_enum::value, "Cannot call readEnum with non-enum value!"); typename std::underlying_type::type N; - if (auto EC = readInteger(N)) + if (auto EC = readInteger(N, Endian)) return EC; Dest = static_cast(N); return Error::success(); } - /// Read a null terminated string from \p Dest. Whether a copy occurs depends - /// on the implementation of the underlying stream. Updates the stream's - /// offset to point after the newly read data. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. - Error readCString(StringRef &Dest); - - /// Read a \p Length byte string into \p Dest. Whether a copy occurs depends - /// on the implementation of the underlying stream. Updates the stream's - /// offset to point after the newly read data. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. - Error readFixedString(StringRef &Dest, uint32_t Length); - - /// Read the entire remainder of the underlying stream into \p Ref. This is - /// equivalent to calling getUnderlyingStream().slice(Offset). Updates the - /// stream's offset to point to the end of the stream. Never causes a copy. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. - Error readStreamRef(BinaryStreamRef &Ref); - - /// Read \p Length bytes from the underlying stream into \p Ref. This is - /// equivalent to calling getUnderlyingStream().slice(Offset, Length). - /// Updates the stream's offset to point after the newly read object. Never - /// causes a copy. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. - Error readStreamRef(BinaryStreamRef &Ref, uint32_t Length); - - /// Get a pointer to an object of type T from the underlying stream, as if by - /// memcpy, and store the result into \p Dest. It is up to the caller to - /// ensure that objects of type T can be safely treated in this manner. - /// Updates the stream's offset to point after the newly read object. Whether - /// a copy occurs depends upon the implementation of the underlying - /// stream. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. template Error readObject(const T *&Dest) { ArrayRef Buffer; if (auto EC = readBytes(Buffer, sizeof(T))) return EC; - assert(alignmentAdjustment(Buffer.data(), alignof(T)) == 0 && - "Reading at invalid alignment!"); Dest = reinterpret_cast(Buffer.data()); return Error::success(); } - /// Get a reference to a \p NumElements element array of objects of type T - /// from the underlying stream as if by memcpy, and store the resulting array - /// slice into \p array. It is up to the caller to ensure that objects of - /// type T can be safely treated in this manner. Updates the stream's offset - /// to point after the newly read object. Whether a copy occurs depends upon - /// the implementation of the underlying stream. - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. template Error readArray(ArrayRef &Array, uint32_t NumElements) { ArrayRef Bytes; @@ -176,43 +81,23 @@ public: } if (NumElements > UINT32_MAX / sizeof(T)) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); if (auto EC = readBytes(Bytes, NumElements * sizeof(T))) return EC; - - assert(alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && - "Reading at invalid alignment!"); - Array = ArrayRef(reinterpret_cast(Bytes.data()), NumElements); return Error::success(); } - /// Read a VarStreamArray of size \p Size bytes and store the result into - /// \p Array. Updates the stream's offset to point after the newly read - /// array. Never causes a copy (although iterating the elements of the - /// VarStreamArray may, depending upon the implementation of the underlying - /// stream). - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. template Error readArray(VarStreamArray &Array, uint32_t Size) { - BinaryStreamRef S; + ReadableStreamRef S; if (auto EC = readStreamRef(S, Size)) return EC; Array = VarStreamArray(S, Array.getExtractor()); return Error::success(); } - /// Read a FixedStreamArray of \p NumItems elements and store the result into - /// \p Array. Updates the stream's offset to point after the newly read - /// array. Never causes a copy (although iterating the elements of the - /// FixedStreamArray may, depending upon the implementation of the underlying - /// stream). - /// - /// \returns a success error code if the data was successfully read, otherwise - /// returns an appropriate error code. template Error readArray(FixedStreamArray &Array, uint32_t NumItems) { if (NumItems == 0) { @@ -221,11 +106,10 @@ public: } uint32_t Length = NumItems * sizeof(T); if (Length / sizeof(T) != NumItems) - return errorCodeToError( - make_error_code(std::errc::illegal_byte_sequence)); + return make_error(msf_error_code::invalid_format); if (Offset + Length > Stream.getLength()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); - BinaryStreamRef View = Stream.slice(Offset, Length); + return make_error(msf_error_code::insufficient_buffer); + ReadableStreamRef View = Stream.slice(Offset, Length); Array = FixedStreamArray(View); Offset += Length; return Error::success(); @@ -237,36 +121,15 @@ public: uint32_t getLength() const { return Stream.getLength(); } uint32_t bytesRemaining() const { return getLength() - getOffset(); } - /// Advance the stream's offset by \p Amount bytes. - /// - /// \returns a success error code if at least \p Amount bytes remain in the - /// stream, otherwise returns an appropriate error code. Error skip(uint32_t Amount); - /// Examine the next byte of the underlying stream without advancing the - /// stream's offset. If the stream is empty the behavior is undefined. - /// - /// \returns the next byte in the stream. uint8_t peek() const; private: - template - void readIntegersImpl(ArrayRef Bytes, T &Dest) { - Dest = llvm::support::endian::read( - Bytes.data(), Stream.getEndian()); - } - - template - void readIntegersImpl(ArrayRef Bytes, T &Dest, Ts &... Rest) { - auto Car = Bytes.take_front(sizeof(T)); - auto Cdr = Bytes.drop_front(sizeof(T)); - readIntegersImpl(Car, Dest); - readIntegersImpl(Cdr, Rest...); - } - - BinaryStreamRef Stream; + ReadableStreamRef Stream; uint32_t Offset; }; +} // namespace msf } // namespace llvm -#endif // LLVM_SUPPORT_BINARYSTREAMREADER_H +#endif // LLVM_DEBUGINFO_MSF_STREAMREADER_H diff --git a/include/llvm/DebugInfo/MSF/BinaryStreamRef.h b/include/llvm/DebugInfo/MSF/BinaryStreamRef.h index dd20bbca2c1..6d0700bdd0b 100644 --- a/include/llvm/DebugInfo/MSF/BinaryStreamRef.h +++ b/include/llvm/DebugInfo/MSF/BinaryStreamRef.h @@ -1,4 +1,4 @@ -//===- BinaryStreamRef.h - A copyable reference to a stream -----*- C++ -*-===// +//===- StreamRef.h - A copyable reference to a stream -----------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,30 +7,28 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_BINARYSTREAMREF_H -#define LLVM_SUPPORT_BINARYSTREAMREF_H +#ifndef LLVM_DEBUGINFO_MSF_STREAMREF_H +#define LLVM_DEBUGINFO_MSF_STREAMREF_H #include "llvm/ADT/ArrayRef.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" +#include "llvm/DebugInfo/MSF/MSFError.h" #include "llvm/Support/Error.h" #include #include namespace llvm { +namespace msf { -/// Common stuff for mutable and immutable StreamRefs. -template class BinaryStreamRefBase { +template class StreamRefBase { public: - BinaryStreamRefBase() : Stream(nullptr), ViewOffset(0), Length(0) {} - BinaryStreamRefBase(StreamType &Stream, uint32_t Offset, uint32_t Length) + StreamRefBase() : Stream(nullptr), ViewOffset(0), Length(0) {} + StreamRefBase(const StreamType &Stream, uint32_t Offset, uint32_t Length) : Stream(&Stream), ViewOffset(Offset), Length(Length) {} - llvm::support::endianness getEndian() const { return Stream->getEndian(); } - uint32_t getLength() const { return Length; } const StreamType *getStream() const { return Stream; } - /// Return a new BinaryStreamRef with the first \p N elements removed. RefType drop_front(uint32_t N) const { if (!Stream) return RefType(); @@ -39,7 +37,6 @@ public: return RefType(*Stream, ViewOffset + N, Length - N); } - /// Return a new BinaryStreamRef with only the first \p N elements remaining. RefType keep_front(uint32_t N) const { if (!Stream) return RefType(); @@ -47,8 +44,6 @@ public: return RefType(*Stream, ViewOffset, N); } - /// Return a new BinaryStreamRef with the first \p Offset elements removed, - /// and retaining exactly \p Len elements. RefType slice(uint32_t Offset, uint32_t Len) const { return drop_front(Offset).keep_front(Len); } @@ -64,55 +59,40 @@ public: } protected: - StreamType *Stream; + const StreamType *Stream; uint32_t ViewOffset; uint32_t Length; }; -/// \brief BinaryStreamRef is to BinaryStream what ArrayRef is to an Array. It -/// provides copy-semantics and read only access to a "window" of the underlying -/// BinaryStream. Note that BinaryStreamRef is *not* a BinaryStream. That is to -/// say, it does not inherit and override the methods of BinaryStream. In -/// general, you should not pass around pointers or references to BinaryStreams -/// and use inheritance to achieve polymorphism. Instead, you should pass -/// around BinaryStreamRefs by value and achieve polymorphism that way. -class BinaryStreamRef - : public BinaryStreamRefBase { +class ReadableStreamRef + : public StreamRefBase { public: - BinaryStreamRef() = default; - BinaryStreamRef(BinaryStream &Stream) - : BinaryStreamRefBase(Stream, 0, Stream.getLength()) {} - BinaryStreamRef(BinaryStream &Stream, uint32_t Offset, uint32_t Length) - : BinaryStreamRefBase(Stream, Offset, Length) {} + ReadableStreamRef() = default; + ReadableStreamRef(const ReadableStream &Stream) + : StreamRefBase(Stream, 0, Stream.getLength()) {} + ReadableStreamRef(const ReadableStream &Stream, uint32_t Offset, + uint32_t Length) + : StreamRefBase(Stream, Offset, Length) {} - // Use BinaryStreamRef.slice() instead. - BinaryStreamRef(BinaryStreamRef &S, uint32_t Offset, - uint32_t Length) = delete; + // Use StreamRef.slice() instead. + ReadableStreamRef(const ReadableStreamRef &S, uint32_t Offset, + uint32_t Length) = delete; - /// Given an Offset into this StreamRef and a Size, return a reference to a - /// buffer owned by the stream. - /// - /// \returns a success error code if the entire range of data is within the - /// bounds of this BinaryStreamRef's view and the implementation could read - /// the data, and an appropriate error code otherwise. Error readBytes(uint32_t Offset, uint32_t Size, ArrayRef &Buffer) const { if (ViewOffset + Offset < Offset) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); if (Size + Offset > Length) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); return Stream->readBytes(ViewOffset + Offset, Size, Buffer); } - /// Given an Offset into this BinaryStreamRef, return a reference to the - /// largest buffer the stream could support without necessitating a copy. - /// - /// \returns a success error code if implementation could read the data, - /// and an appropriate error code otherwise. + // Given an offset into the stream, read as much as possible without copying + // any data. Error readLongestContiguousChunk(uint32_t Offset, ArrayRef &Buffer) const { if (Offset >= Length) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); if (auto EC = Stream->readLongestContiguousChunk(Offset, Buffer)) return EC; @@ -126,39 +106,30 @@ public: } }; -class WritableBinaryStreamRef - : public BinaryStreamRefBase { +class WritableStreamRef + : public StreamRefBase { public: - WritableBinaryStreamRef() = default; - WritableBinaryStreamRef(WritableBinaryStream &Stream) - : BinaryStreamRefBase(Stream, 0, Stream.getLength()) {} - WritableBinaryStreamRef(WritableBinaryStream &Stream, uint32_t Offset, - uint32_t Length) - : BinaryStreamRefBase(Stream, Offset, Length) {} + WritableStreamRef() = default; + WritableStreamRef(const WritableStream &Stream) + : StreamRefBase(Stream, 0, Stream.getLength()) {} + WritableStreamRef(const WritableStream &Stream, uint32_t Offset, + uint32_t Length) + : StreamRefBase(Stream, Offset, Length) {} - // Use WritableBinaryStreamRef.slice() instead. - WritableBinaryStreamRef(WritableBinaryStreamRef &S, uint32_t Offset, - uint32_t Length) = delete; + // Use StreamRef.slice() instead. + WritableStreamRef(const WritableStreamRef &S, uint32_t Offset, + uint32_t Length) = delete; - /// Given an Offset into this WritableBinaryStreamRef and some input data, - /// writes the data to the underlying stream. - /// - /// \returns a success error code if the data could fit within the underlying - /// stream at the specified location and the implementation could write the - /// data, and an appropriate error code otherwise. Error writeBytes(uint32_t Offset, ArrayRef Data) const { if (Data.size() + Offset > Length) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); return Stream->writeBytes(ViewOffset + Offset, Data); } - operator BinaryStreamRef() { return BinaryStreamRef(*Stream); } - - /// \brief For buffered streams, commits changes to the backing store. - Error commit() { return Stream->commit(); } + Error commit() const { return Stream->commit(); } }; +} // end namespace msf } // end namespace llvm -#endif // LLVM_SUPPORT_BINARYSTREAMREF_H +#endif // LLVM_DEBUGINFO_MSF_STREAMREF_H diff --git a/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h b/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h index 5635fc91587..bf911a91684 100644 --- a/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h +++ b/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h @@ -1,4 +1,4 @@ -//===- BinaryStreamWriter.h - Writes objects to a BinaryStream ---*- C++-*-===// +//===- StreamWriter.h - Writes bytes and objects to a stream ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,121 +7,55 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_SUPPORT_BINARYSTREAMWRITER_H -#define LLVM_SUPPORT_BINARYSTREAMWRITER_H +#ifndef LLVM_DEBUGINFO_MSF_STREAMWRITER_H +#define LLVM_DEBUGINFO_MSF_STREAMWRITER_H #include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringRef.h" #include "llvm/DebugInfo/MSF/BinaryStreamArray.h" #include "llvm/DebugInfo/MSF/BinaryStreamRef.h" +#include "llvm/DebugInfo/MSF/MSFError.h" #include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" #include #include namespace llvm { +namespace msf { -/// \brief Provides write only access to a subclass of `WritableBinaryStream`. -/// Provides bounds checking and helpers for writing certain common data types -/// such as null-terminated strings, integers in various flavors of endianness, -/// etc. Can be subclassed to provide reading and writing of custom datatypes, -/// although no methods are overridable. -class BinaryStreamWriter { +class StreamWriter { public: - BinaryStreamWriter() = default; - explicit BinaryStreamWriter(WritableBinaryStreamRef Stream); - virtual ~BinaryStreamWriter() {} + StreamWriter() = default; + explicit StreamWriter(WritableStreamRef Stream); - /// Write the bytes specified in \p Buffer to the underlying stream. - /// On success, updates the offset so that subsequent writes will occur - /// at the next unwritten position. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. Error writeBytes(ArrayRef Buffer); - /// Write the the integer \p Value to the underlying stream in the - /// specified endianness. On success, updates the offset so that - /// subsequent writes occur at the next unwritten position. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. - template Error writeInteger(T Value) { - return writeIntegers(Value); - } - - /// Write a \p ByteSize byte integer to the stream, updating the writer's - /// position if successful. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. - Error writeInteger(uint64_t Value, uint32_t ByteSize); - - /// Write a list of integers into the underlying stream and update the - /// stream's offset. On success, updates the offset so that subsequent writes - /// occur at the next unwritten position. Use of this method is more - /// efficient than calling `writeInteger` multiple times because this performs - /// bounds checking only once, and requires only a single error check by the - /// user. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. - template Error writeIntegers(Ts... Ints) { - uint8_t Buffer[sizeof_sum::value]; - - writeIntegersImpl(Buffer, Ints...); + template + Error writeInteger(T Value, + llvm::support::endianness Endian = llvm::support::native) { + static_assert(std::is_integral::value, + "Cannot call writeInteger with non-integral value!"); + uint8_t Buffer[sizeof(T)]; + llvm::support::endian::write(Buffer, Value, + Endian); return writeBytes(Buffer); } - /// Similar to writeInteger - template Error writeEnum(T Num) { + Error writeZeroString(StringRef Str); + Error writeFixedString(StringRef Str); + Error writeStreamRef(ReadableStreamRef Ref); + Error writeStreamRef(ReadableStreamRef Ref, uint32_t Size); + + template + Error writeEnum(T Num, + llvm::support::endianness Endian = llvm::support::native) { static_assert(std::is_enum::value, "Cannot call writeEnum with non-Enum type"); using U = typename std::underlying_type::type; - return writeInteger(static_cast(Num)); + return writeInteger(static_cast(Num), Endian); } - /// Write the the string \p Str to the underlying stream followed by a null - /// terminator. On success, updates the offset so that subsequent writes - /// occur at the next unwritten position. \p Str need not be null terminated - /// on input. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. - Error writeCString(StringRef Str); - - /// Write the the string \p Str to the underlying stream without a null - /// terminator. On success, updates the offset so that subsequent writes - /// occur at the next unwritten position. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. - Error writeFixedString(StringRef Str); - - /// Efficiently reads all data from \p Ref, and writes it to this stream. - /// This operation will not invoke any copies of the source data, regardless - /// of the source stream's implementation. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. - Error writeStreamRef(BinaryStreamRef Ref); - - /// Efficiently reads \p Size bytes from \p Ref, and writes it to this stream. - /// This operation will not invoke any copies of the source data, regardless - /// of the source stream's implementation. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. - Error writeStreamRef(BinaryStreamRef Ref, uint32_t Size); - - /// Writes the object \p Obj to the underlying stream, as if by using memcpy. - /// It is up to the caller to ensure that type of \p Obj can be safely copied - /// in this fashion, as no checks are made to ensure that this is safe. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. template Error writeObject(const T &Obj) { static_assert(!std::is_pointer::value, "writeObject should not be used with pointers, to write " @@ -131,38 +65,23 @@ public: ArrayRef(reinterpret_cast(&Obj), sizeof(T))); } - /// Writes an array of objects of type T to the underlying stream, as if by - /// using memcpy. It is up to the caller to ensure that type of \p Obj can - /// be safely copied in this fashion, as no checks are made to ensure that - /// this is safe. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. template Error writeArray(ArrayRef Array) { if (Array.empty()) return Error::success(); if (Array.size() > UINT32_MAX / sizeof(T)) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); return writeBytes( ArrayRef(reinterpret_cast(Array.data()), Array.size() * sizeof(T))); } - /// Writes all data from the array \p Array to the underlying stream. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. template Error writeArray(VarStreamArray Array) { return writeStreamRef(Array.getUnderlyingStream()); } - /// Writes all elements from the array \p Array to the underlying stream. - /// - /// \returns a success error code if the data was successfully written, - /// otherwise returns an appropriate error code. template Error writeArray(FixedStreamArray Array) { return writeStreamRef(Array.getUnderlyingStream()); } @@ -172,28 +91,12 @@ public: uint32_t getLength() const { return Stream.getLength(); } uint32_t bytesRemaining() const { return getLength() - getOffset(); } -protected: - template - void writeIntegersImpl(MutableArrayRef Buffer, T Value) { - static_assert(std::is_integral::value, - "Cannot call writeInteger with non-integral value!"); - assert(Buffer.size() == sizeof(T)); - llvm::support::endian::write( - Buffer.data(), Value, Stream.getEndian()); - } - - template - void writeIntegersImpl(MutableArrayRef Buffer, T Car, Ts... Cdr) { - auto First = Buffer.take_front(sizeof(T)); - auto Rest = Buffer.drop_front(sizeof(T)); - writeIntegersImpl(First, Car); - writeIntegersImpl(Rest, Cdr...); - } - - WritableBinaryStreamRef Stream; +private: + WritableStreamRef Stream; uint32_t Offset = 0; }; +} // end namespace msf } // end namespace llvm -#endif // LLVM_SUPPORT_BINARYSTREAMWRITER_H +#endif // LLVM_DEBUGINFO_MSF_STREAMWRITER_H diff --git a/include/llvm/DebugInfo/MSF/MappedBlockStream.h b/include/llvm/DebugInfo/MSF/MappedBlockStream.h index 96342845378..e4a0fd17a83 100644 --- a/include/llvm/DebugInfo/MSF/MappedBlockStream.h +++ b/include/llvm/DebugInfo/MSF/MappedBlockStream.h @@ -15,8 +15,6 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/STLExtras.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/BinaryStreamRef.h" #include "llvm/DebugInfo/MSF/MSFStreamLayout.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Endian.h" @@ -39,33 +37,29 @@ struct MSFLayout; /// 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 BinaryStream { +class MappedBlockStream : public ReadableStream { friend class WritableMappedBlockStream; public: static std::unique_ptr createStream(uint32_t BlockSize, uint32_t NumBlocks, - const MSFStreamLayout &Layout, BinaryStreamRef MsfData); + const MSFStreamLayout &Layout, const ReadableStream &MsfData); static std::unique_ptr - createIndexedStream(const MSFLayout &Layout, BinaryStreamRef MsfData, + createIndexedStream(const MSFLayout &Layout, const ReadableStream &MsfData, uint32_t StreamIndex); static std::unique_ptr - createFpmStream(const MSFLayout &Layout, BinaryStreamRef MsfData); + createFpmStream(const MSFLayout &Layout, const ReadableStream &MsfData); static std::unique_ptr - createDirectoryStream(const MSFLayout &Layout, BinaryStreamRef MsfData); - - llvm::support::endianness getEndian() const override { - return llvm::support::little; - } + createDirectoryStream(const MSFLayout &Layout, const ReadableStream &MsfData); Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override; + ArrayRef &Buffer) const override; Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override; + ArrayRef &Buffer) const override; - uint32_t getLength() override; + uint32_t getLength() const override; uint32_t getNumBytesCopied() const; @@ -80,56 +74,51 @@ public: protected: MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &StreamLayout, - BinaryStreamRef MsfData); + const ReadableStream &MsfData); private: const MSFStreamLayout &getStreamLayout() const { return StreamLayout; } void fixCacheAfterWrite(uint32_t Offset, ArrayRef Data) const; - Error readBytes(uint32_t Offset, MutableArrayRef Buffer); + Error readBytes(uint32_t Offset, MutableArrayRef Buffer) const; bool tryReadContiguously(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer); + ArrayRef &Buffer) const; const uint32_t BlockSize; const uint32_t NumBlocks; const MSFStreamLayout StreamLayout; - BinaryStreamRef MsfData; + const ReadableStream &MsfData; typedef MutableArrayRef CacheEntry; - llvm::BumpPtrAllocator Pool; - DenseMap> CacheMap; + mutable llvm::BumpPtrAllocator Pool; + mutable DenseMap> CacheMap; }; -class WritableMappedBlockStream : public WritableBinaryStream { +class WritableMappedBlockStream : public WritableStream { public: static std::unique_ptr createStream(uint32_t BlockSize, uint32_t NumBlocks, - const MSFStreamLayout &Layout, WritableBinaryStreamRef MsfData); + const MSFStreamLayout &Layout, const WritableStream &MsfData); static std::unique_ptr - createIndexedStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData, + createIndexedStream(const MSFLayout &Layout, const WritableStream &MsfData, uint32_t StreamIndex); static std::unique_ptr - createDirectoryStream(const MSFLayout &Layout, - WritableBinaryStreamRef MsfData); + createDirectoryStream(const MSFLayout &Layout, const WritableStream &MsfData); static std::unique_ptr - createFpmStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData); - - llvm::support::endianness getEndian() const override { - return llvm::support::little; - } + createFpmStream(const MSFLayout &Layout, const WritableStream &MsfData); Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override; + ArrayRef &Buffer) const override; Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override; - uint32_t getLength() override; + ArrayRef &Buffer) const override; + uint32_t getLength() const override; - Error writeBytes(uint32_t Offset, ArrayRef Buffer) override; + Error writeBytes(uint32_t Offset, ArrayRef Buffer) const override; - Error commit() override; + Error commit() const override; const MSFStreamLayout &getStreamLayout() const { return ReadInterface.getStreamLayout(); @@ -141,12 +130,12 @@ public: protected: WritableMappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &StreamLayout, - WritableBinaryStreamRef MsfData); + const WritableStream &MsfData); private: MappedBlockStream ReadInterface; - WritableBinaryStreamRef WriteInterface; + const WritableStream &WriteInterface; }; } // end namespace pdb diff --git a/include/llvm/DebugInfo/PDB/Native/DbiStream.h b/include/llvm/DebugInfo/PDB/Native/DbiStream.h index 38d338d6d83..977b114ca24 100644 --- a/include/llvm/DebugInfo/PDB/Native/DbiStream.h +++ b/include/llvm/DebugInfo/PDB/Native/DbiStream.h @@ -12,8 +12,6 @@ #include "llvm/DebugInfo/CodeView/ModuleSubstream.h" #include "llvm/DebugInfo/MSF/BinaryStreamArray.h" -#include "llvm/DebugInfo/MSF/BinaryStreamArray.h" -#include "llvm/DebugInfo/MSF/BinaryStreamRef.h" #include "llvm/DebugInfo/MSF/BinaryStreamRef.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" #include "llvm/DebugInfo/PDB/Native/ModInfo.h" @@ -72,11 +70,11 @@ public: Expected getFileNameForIndex(uint32_t Index) const; - FixedStreamArray getSectionHeaders(); + msf::FixedStreamArray getSectionHeaders(); - FixedStreamArray getFpoRecords(); + msf::FixedStreamArray getFpoRecords(); - FixedStreamArray getSectionMap() const; + msf::FixedStreamArray getSectionMap() const; void visitSectionContributions(ISectionContribVisitor &Visitor) const; private: @@ -93,28 +91,28 @@ private: std::vector ModuleInfos; StringTable ECNames; - BinaryStreamRef ModInfoSubstream; - BinaryStreamRef SecContrSubstream; - BinaryStreamRef SecMapSubstream; - BinaryStreamRef FileInfoSubstream; - BinaryStreamRef TypeServerMapSubstream; - BinaryStreamRef ECSubstream; + msf::ReadableStreamRef ModInfoSubstream; + msf::ReadableStreamRef SecContrSubstream; + msf::ReadableStreamRef SecMapSubstream; + msf::ReadableStreamRef FileInfoSubstream; + msf::ReadableStreamRef TypeServerMapSubstream; + msf::ReadableStreamRef ECSubstream; - BinaryStreamRef NamesBuffer; + msf::ReadableStreamRef NamesBuffer; - FixedStreamArray DbgStreams; + msf::FixedStreamArray DbgStreams; PdbRaw_DbiSecContribVer SectionContribVersion; - FixedStreamArray SectionContribs; - FixedStreamArray SectionContribs2; - FixedStreamArray SectionMap; - FixedStreamArray FileNameOffsets; + msf::FixedStreamArray SectionContribs; + msf::FixedStreamArray SectionContribs2; + msf::FixedStreamArray SectionMap; + msf::FixedStreamArray FileNameOffsets; std::unique_ptr SectionHeaderStream; - FixedStreamArray SectionHeaders; + msf::FixedStreamArray SectionHeaders; std::unique_ptr FpoStream; - FixedStreamArray FpoRecords; + msf::FixedStreamArray FpoRecords; const DbiStreamHeader *Header; }; diff --git a/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h b/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h index 0090022cdcc..b1e8d5087d4 100644 --- a/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h +++ b/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h @@ -60,7 +60,7 @@ public: Error finalizeMsfLayout(); - Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef Buffer); + Error commit(const msf::MSFLayout &Layout, const msf::WritableStream &Buffer); // A helper function to create Section Contributions from COFF input // section headers. @@ -112,9 +112,9 @@ private: StringMap SourceFileNames; - WritableBinaryStreamRef NamesBuffer; - MutableBinaryByteStream ModInfoBuffer; - MutableBinaryByteStream FileInfoBuffer; + msf::WritableStreamRef NamesBuffer; + msf::MutableByteStream ModInfoBuffer; + msf::MutableByteStream FileInfoBuffer; ArrayRef SectionContribs; ArrayRef SectionMap; llvm::SmallVector DbgStreams; diff --git a/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h b/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h index de744255e44..71aa0a5236e 100644 --- a/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h +++ b/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h @@ -10,7 +10,6 @@ #ifndef LLVM_DEBUGINFO_PDB_RAW_GLOBALS_STREAM_H #define LLVM_DEBUGINFO_PDB_RAW_GLOBALS_STREAM_H -#include "llvm/DebugInfo/MSF/BinaryStreamArray.h" #include "llvm/DebugInfo/MSF/BinaryStreamArray.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" #include "llvm/DebugInfo/PDB/Native/RawConstants.h" @@ -28,15 +27,15 @@ public: explicit GlobalsStream(std::unique_ptr Stream); ~GlobalsStream(); Error commit(); - FixedStreamArray getHashBuckets() const { + msf::FixedStreamArray getHashBuckets() const { return HashBuckets; } uint32_t getNumBuckets() const { return NumBuckets; } Error reload(); private: - FixedStreamArray HashBuckets; - FixedStreamArray HashRecords; + msf::FixedStreamArray HashBuckets; + msf::FixedStreamArray HashRecords; uint32_t NumBuckets; std::unique_ptr Stream; }; diff --git a/include/llvm/DebugInfo/PDB/Native/HashTable.h b/include/llvm/DebugInfo/PDB/Native/HashTable.h index 74d5e4caed4..101a5772e7c 100644 --- a/include/llvm/DebugInfo/PDB/Native/HashTable.h +++ b/include/llvm/DebugInfo/PDB/Native/HashTable.h @@ -42,10 +42,10 @@ public: HashTable(); explicit HashTable(uint32_t Capacity); - Error load(BinaryStreamReader &Stream); + Error load(msf::StreamReader &Stream); uint32_t calculateSerializedLength() const; - Error commit(BinaryStreamWriter &Writer) const; + Error commit(msf::StreamWriter &Writer) const; void clear(); @@ -71,9 +71,9 @@ private: static uint32_t maxLoad(uint32_t capacity); void grow(); - static Error readSparseBitVector(BinaryStreamReader &Stream, + static Error readSparseBitVector(msf::StreamReader &Stream, SparseBitVector<> &V); - static Error writeSparseBitVector(BinaryStreamWriter &Writer, + static Error writeSparseBitVector(msf::StreamWriter &Writer, SparseBitVector<> &Vec); }; diff --git a/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h b/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h index 77d73cc859b..1b182bc65aa 100644 --- a/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h +++ b/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h @@ -19,10 +19,9 @@ #include "llvm/DebugInfo/PDB/PDBTypes.h" namespace llvm { -class WritableBinaryStream; - namespace msf { class MSFBuilder; +class StreamWriter; } namespace pdb { class PDBFile; @@ -44,7 +43,7 @@ public: Error finalizeMsfLayout(); Error commit(const msf::MSFLayout &Layout, - WritableBinaryStreamRef Buffer) const; + const msf::WritableStream &Buffer) const; private: msf::MSFBuilder &Msf; diff --git a/include/llvm/DebugInfo/PDB/Native/ModInfo.h b/include/llvm/DebugInfo/PDB/Native/ModInfo.h index c6b977bd648..391d61d2535 100644 --- a/include/llvm/DebugInfo/PDB/Native/ModInfo.h +++ b/include/llvm/DebugInfo/PDB/Native/ModInfo.h @@ -30,7 +30,7 @@ public: ModInfo(const ModInfo &Info); ~ModInfo(); - static Error initialize(BinaryStreamRef Stream, ModInfo &Info); + static Error initialize(msf::ReadableStreamRef Stream, ModInfo &Info); bool hasECInfo() const; uint16_t getTypeServerIndex() const; @@ -63,8 +63,10 @@ struct ModuleInfoEx { } // end namespace pdb +namespace msf { + template <> struct VarStreamArrayExtractor { - Error operator()(BinaryStreamRef 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; @@ -73,6 +75,8 @@ template <> struct VarStreamArrayExtractor { } }; +} // end namespace msf + } // end namespace llvm #endif // LLVM_DEBUGINFO_PDB_RAW_MODINFO_H diff --git a/include/llvm/DebugInfo/PDB/Native/ModStream.h b/include/llvm/DebugInfo/PDB/Native/ModStream.h index 88312ac3958..f9ce63fc3c2 100644 --- a/include/llvm/DebugInfo/PDB/Native/ModStream.h +++ b/include/llvm/DebugInfo/PDB/Native/ModStream.h @@ -50,9 +50,9 @@ private: std::unique_ptr Stream; codeview::CVSymbolArray SymbolsSubstream; - BinaryStreamRef LinesSubstream; - BinaryStreamRef C13LinesSubstream; - BinaryStreamRef GlobalRefsSubstream; + msf::ReadableStreamRef LinesSubstream; + msf::ReadableStreamRef C13LinesSubstream; + msf::ReadableStreamRef GlobalRefsSubstream; codeview::ModuleSubstreamArray LineInfo; }; diff --git a/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h b/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h index 2327bfadb69..c5cf76e7740 100644 --- a/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h +++ b/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h @@ -17,9 +17,10 @@ #include namespace llvm { -class BinaryStreamReader; -class BinaryStreamWriter; - +namespace msf { +class StreamReader; +class StreamWriter; +} namespace pdb { class NamedStreamMapBuilder; class NamedStreamMap { @@ -32,8 +33,8 @@ class NamedStreamMap { public: NamedStreamMap(); - Error load(BinaryStreamReader &Stream); - Error commit(BinaryStreamWriter &Writer) const; + Error load(msf::StreamReader &Stream); + Error commit(msf::StreamWriter &Writer) const; uint32_t finalize(); bool get(StringRef Stream, uint32_t &StreamNo) const; diff --git a/include/llvm/DebugInfo/PDB/Native/PDBFile.h b/include/llvm/DebugInfo/PDB/Native/PDBFile.h index 9b7ba7aeea4..6802e397622 100644 --- a/include/llvm/DebugInfo/PDB/Native/PDBFile.h +++ b/include/llvm/DebugInfo/PDB/Native/PDBFile.h @@ -12,8 +12,6 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/BinaryStreamArray.h" #include "llvm/DebugInfo/MSF/BinaryStreamArray.h" #include "llvm/DebugInfo/MSF/IMSFFile.h" #include "llvm/DebugInfo/MSF/MSFCommon.h" @@ -44,7 +42,7 @@ class PDBFile : public msf::IMSFFile { friend PDBFileBuilder; public: - PDBFile(StringRef Path, std::unique_ptr PdbFileBuffer, + PDBFile(StringRef Path, std::unique_ptr PdbFileBuffer, BumpPtrAllocator &Allocator); ~PDBFile() override; @@ -82,7 +80,7 @@ public: } const msf::MSFLayout &getMsfLayout() const { return ContainerLayout; } - BinaryStreamRef getMsfBuffer() const { return *Buffer; } + const msf::ReadableStream &getMsfBuffer() const { return *Buffer; } ArrayRef getDirectoryBlockArray() const; @@ -112,13 +110,13 @@ public: private: Expected> safelyCreateIndexedStream(const msf::MSFLayout &Layout, - BinaryStreamRef MsfData, + const msf::ReadableStream &MsfData, uint32_t StreamIndex) const; std::string FilePath; BumpPtrAllocator &Allocator; - std::unique_ptr Buffer; + std::unique_ptr Buffer; std::vector FpmPages; msf::MSFLayout ContainerLayout; diff --git a/include/llvm/DebugInfo/PDB/Native/PublicsStream.h b/include/llvm/DebugInfo/PDB/Native/PublicsStream.h index b93645ec945..13a9624fdcb 100644 --- a/include/llvm/DebugInfo/PDB/Native/PublicsStream.h +++ b/include/llvm/DebugInfo/PDB/Native/PublicsStream.h @@ -17,7 +17,6 @@ #include "llvm/DebugInfo/PDB/Native/RawTypes.h" #include "llvm/DebugInfo/PDB/PDBTypes.h" -#include "llvm/DebugInfo/MSF/BinaryStreamArray.h" #include "llvm/Support/Error.h" namespace llvm { @@ -39,16 +38,16 @@ public: uint32_t getNumBuckets() const { return NumBuckets; } iterator_range getSymbols(bool *HadError) const; - FixedStreamArray getHashBuckets() const { + msf::FixedStreamArray getHashBuckets() const { return HashBuckets; } - FixedStreamArray getAddressMap() const { + msf::FixedStreamArray getAddressMap() const { return AddressMap; } - FixedStreamArray getThunkMap() const { + msf::FixedStreamArray getThunkMap() const { return ThunkMap; } - FixedStreamArray getSectionOffsets() const { + msf::FixedStreamArray getSectionOffsets() const { return SectionOffsets; } @@ -60,11 +59,11 @@ private: std::unique_ptr Stream; uint32_t NumBuckets = 0; ArrayRef Bitmap; - FixedStreamArray HashRecords; - FixedStreamArray HashBuckets; - FixedStreamArray AddressMap; - FixedStreamArray ThunkMap; - FixedStreamArray SectionOffsets; + msf::FixedStreamArray HashRecords; + msf::FixedStreamArray HashBuckets; + msf::FixedStreamArray AddressMap; + msf::FixedStreamArray ThunkMap; + msf::FixedStreamArray SectionOffsets; const HeaderInfo *Header; const GSIHashHeader *HashHdr; diff --git a/include/llvm/DebugInfo/PDB/Native/StringTable.h b/include/llvm/DebugInfo/PDB/Native/StringTable.h index 4073a2ebdfd..4c71018f014 100644 --- a/include/llvm/DebugInfo/PDB/Native/StringTable.h +++ b/include/llvm/DebugInfo/PDB/Native/StringTable.h @@ -20,15 +20,16 @@ #include namespace llvm { -class BinaryStreamReader; - +namespace msf { +class StreamReader; +} namespace pdb { class StringTable { public: StringTable(); - Error load(BinaryStreamReader &Stream); + Error load(msf::StreamReader &Stream); uint32_t getNameCount() const { return NameCount; } uint32_t getHashVersion() const { return HashVersion; } @@ -37,11 +38,11 @@ public: StringRef getStringForID(uint32_t ID) const; uint32_t getIDForString(StringRef Str) const; - FixedStreamArray name_ids() const; + msf::FixedStreamArray name_ids() const; private: - BinaryStreamRef NamesBuffer; - FixedStreamArray IDs; + msf::ReadableStreamRef NamesBuffer; + msf::FixedStreamArray IDs; uint32_t Signature; uint32_t HashVersion; uint32_t NameCount; diff --git a/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h b/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h index dd0f40b1978..d6a20831b1e 100644 --- a/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h +++ b/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h @@ -20,8 +20,9 @@ #include namespace llvm { -class BinaryStreamWriter; - +namespace msf { +class StreamWriter; +} namespace pdb { class StringTableBuilder { @@ -31,7 +32,7 @@ public: uint32_t insert(StringRef S); uint32_t finalize(); - Error commit(BinaryStreamWriter &Writer) const; + Error commit(msf::StreamWriter &Writer) const; private: DenseMap Strings; diff --git a/include/llvm/DebugInfo/PDB/Native/TpiHashing.h b/include/llvm/DebugInfo/PDB/Native/TpiHashing.h index f13b615d089..9aa6bb4e66e 100644 --- a/include/llvm/DebugInfo/PDB/Native/TpiHashing.h +++ b/include/llvm/DebugInfo/PDB/Native/TpiHashing.h @@ -57,7 +57,7 @@ private: class TpiHashVerifier : public codeview::TypeVisitorCallbacks { public: - TpiHashVerifier(FixedStreamArray &HashValues, + TpiHashVerifier(msf::FixedStreamArray &HashValues, uint32_t NumHashBuckets) : HashValues(HashValues), NumHashBuckets(NumHashBuckets) {} @@ -83,7 +83,7 @@ private: utohexstr(codeview::TypeIndex::FirstNonSimpleIndex + Index)); } - FixedStreamArray HashValues; + msf::FixedStreamArray HashValues; codeview::CVType RawRecord; uint32_t NumHashBuckets; uint32_t Index = -1; diff --git a/include/llvm/DebugInfo/PDB/Native/TpiStream.h b/include/llvm/DebugInfo/PDB/Native/TpiStream.h index b2f66cb045d..2ee2faa6d91 100644 --- a/include/llvm/DebugInfo/PDB/Native/TpiStream.h +++ b/include/llvm/DebugInfo/PDB/Native/TpiStream.h @@ -46,8 +46,8 @@ public: uint32_t getHashKeySize() const; uint32_t NumHashBuckets() const; - FixedStreamArray getHashValues() const; - FixedStreamArray getTypeIndexOffsets() const; + msf::FixedStreamArray getHashValues() const; + msf::FixedStreamArray getTypeIndexOffsets() const; HashTable &getHashAdjusters(); codeview::CVTypeRange types(bool *HadError) const; @@ -62,9 +62,9 @@ private: codeview::CVTypeArray TypeRecords; - std::unique_ptr HashStream; - FixedStreamArray HashValues; - FixedStreamArray TypeIndexOffsets; + std::unique_ptr HashStream; + msf::FixedStreamArray HashValues; + msf::FixedStreamArray TypeIndexOffsets; HashTable HashAdjusters; const TpiStreamHeader *Header; diff --git a/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h b/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h index a430c426af1..2cedf56f621 100644 --- a/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h +++ b/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h @@ -21,22 +21,22 @@ #include namespace llvm { -class BinaryStreamRef; -class WritableBinaryStream; +namespace codeview { +class TypeRecord; +} +namespace msf { +class ByteStream; +class MSFBuilder; +struct MSFLayout; +class ReadableStreamRef; +class WritableStream; -template <> struct BinaryItemTraits { +template <> struct SequencedItemTraits { static size_t length(const codeview::CVType &Item) { return Item.length(); } static ArrayRef bytes(const codeview::CVType &Item) { return Item.data(); } }; - -namespace codeview { -class TypeRecord; -} -namespace msf { -class MSFBuilder; -struct MSFLayout; } namespace pdb { class PDBFile; @@ -56,9 +56,9 @@ public: Error finalizeMsfLayout(); - Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef Buffer); + Error commit(const msf::MSFLayout &Layout, const msf::WritableStream &Buffer); - uint32_t calculateSerializedLength(); + uint32_t calculateSerializedLength() const; private: uint32_t calculateHashBufferSize() const; @@ -69,9 +69,9 @@ private: Optional VerHeader; std::vector TypeRecords; - BinaryItemStream TypeRecordStream; + msf::SequencedItemStream TypeRecordStream; uint32_t HashStreamIndex = kInvalidStreamIndex; - std::unique_ptr HashValueStream; + std::unique_ptr HashValueStream; const TpiStreamHeader *Header; uint32_t Idx; diff --git a/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp b/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp index c1dfb900a8d..2d9b0139f4f 100644 --- a/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp +++ b/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp @@ -38,6 +38,7 @@ using namespace llvm; using namespace llvm::codeview; +using namespace llvm::msf; CodeViewDebug::CodeViewDebug(AsmPrinter *AP) : DebugHandlerBase(AP), OS(*Asm->OutStreamer), Allocator(), @@ -494,9 +495,9 @@ 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. - BinaryByteStream Stream(Record, llvm::support::little); + ByteStream Stream(Record); CVTypeArray Types; - BinaryStreamReader Reader(Stream); + StreamReader Reader(Stream); Error E = Reader.readArray(Types, Reader.getLength()); if (!E) { TypeVisitorCallbacks C; diff --git a/lib/DebugInfo/CodeView/CVTypeDumper.cpp b/lib/DebugInfo/CodeView/CVTypeDumper.cpp index a94516985b8..f862c202b5d 100644 --- a/lib/DebugInfo/CodeView/CVTypeDumper.cpp +++ b/lib/DebugInfo/CodeView/CVTypeDumper.cpp @@ -56,9 +56,9 @@ Error CVTypeDumper::dump(const CVTypeArray &Types, } Error CVTypeDumper::dump(ArrayRef Data, TypeVisitorCallbacks &Dumper) { - BinaryByteStream Stream(Data, llvm::support::little); + msf::ByteStream Stream(Data); CVTypeArray Types; - BinaryStreamReader Reader(Stream); + msf::StreamReader Reader(Stream); if (auto EC = Reader.readArray(Types, Reader.getLength())) return EC; diff --git a/lib/DebugInfo/CodeView/CVTypeVisitor.cpp b/lib/DebugInfo/CodeView/CVTypeVisitor.cpp index 74c60c78b8b..aa0621273c5 100644 --- a/lib/DebugInfo/CodeView/CVTypeVisitor.cpp +++ b/lib/DebugInfo/CodeView/CVTypeVisitor.cpp @@ -174,7 +174,7 @@ Error CVTypeVisitor::visitTypeStream(CVTypeRange Types) { return Error::success(); } -Error CVTypeVisitor::visitFieldListMemberStream(BinaryStreamReader Reader) { +Error CVTypeVisitor::visitFieldListMemberStream(msf::StreamReader Reader) { FieldListDeserializer Deserializer(Reader); TypeVisitorCallbackPipeline Pipeline; Pipeline.addCallbackToPipeline(Deserializer); @@ -182,7 +182,7 @@ Error CVTypeVisitor::visitFieldListMemberStream(BinaryStreamReader Reader) { TypeLeafKind Leaf; while (!Reader.empty()) { - if (auto EC = Reader.readEnum(Leaf)) + if (auto EC = Reader.readEnum(Leaf, llvm::support::little)) return EC; CVMemberRecord Record; @@ -195,7 +195,7 @@ Error CVTypeVisitor::visitFieldListMemberStream(BinaryStreamReader Reader) { } Error CVTypeVisitor::visitFieldListMemberStream(ArrayRef Data) { - BinaryByteStream S(Data, llvm::support::little); - BinaryStreamReader SR(S); + msf::ByteStream S(Data); + msf::StreamReader SR(S); return visitFieldListMemberStream(SR); } diff --git a/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp b/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp index a204d43ba13..fd60059b5c6 100644 --- a/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp +++ b/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp @@ -87,13 +87,14 @@ Error CodeViewRecordIO::mapByteVectorTail(std::vector &Bytes) { Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd) { if (isWriting()) { - if (auto EC = Writer->writeInteger(TypeInd.getIndex())) + if (auto EC = + Writer->writeInteger(TypeInd.getIndex(), llvm::support::little)) return EC; return Error::success(); } uint32_t I; - if (auto EC = Reader->readInteger(I)) + if (auto EC = Reader->readInteger(I, llvm::support::little)) return EC; TypeInd.setIndex(I); return Error::success(); @@ -145,10 +146,10 @@ Error CodeViewRecordIO::mapStringZ(StringRef &Value) { if (isWriting()) { // Truncate if we attempt to write too much. StringRef S = Value.take_front(maxFieldLength() - 1); - if (auto EC = Writer->writeCString(S)) + if (auto EC = Writer->writeZeroString(S)) return EC; } else { - if (auto EC = Reader->readCString(Value)) + if (auto EC = Reader->readZeroString(Value)) return EC; } return Error::success(); @@ -176,7 +177,7 @@ Error CodeViewRecordIO::mapStringZVectorZ(std::vector &Value) { if (auto EC = mapStringZ(V)) return EC; } - if (auto EC = Writer->writeInteger(0)) + if (auto EC = Writer->writeInteger(0, llvm::support::little)) return EC; } else { StringRef S; @@ -194,24 +195,28 @@ Error CodeViewRecordIO::mapStringZVectorZ(std::vector &Value) { Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) { assert(Value < 0 && "Encoded integer is not signed!"); if (Value >= std::numeric_limits::min()) { - if (auto EC = Writer->writeInteger(LF_CHAR)) + if (auto EC = + Writer->writeInteger(LF_CHAR, llvm::support::little)) return EC; - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } else if (Value >= std::numeric_limits::min()) { - if (auto EC = Writer->writeInteger(LF_SHORT)) + if (auto EC = + Writer->writeInteger(LF_SHORT, llvm::support::little)) return EC; - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } else if (Value >= std::numeric_limits::min()) { - if (auto EC = Writer->writeInteger(LF_LONG)) + if (auto EC = + Writer->writeInteger(LF_LONG, llvm::support::little)) return EC; - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } else { - if (auto EC = Writer->writeInteger(LF_QUADWORD)) + if (auto EC = + Writer->writeInteger(LF_QUADWORD, llvm::support::little)) return EC; - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } return Error::success(); @@ -219,22 +224,25 @@ Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) { Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) { if (Value < LF_NUMERIC) { - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } else if (Value <= std::numeric_limits::max()) { - if (auto EC = Writer->writeInteger(LF_USHORT)) + if (auto EC = + Writer->writeInteger(LF_USHORT, llvm::support::little)) return EC; - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } else if (Value <= std::numeric_limits::max()) { - if (auto EC = Writer->writeInteger(LF_ULONG)) + if (auto EC = + Writer->writeInteger(LF_ULONG, llvm::support::little)) return EC; - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } else { - if (auto EC = Writer->writeInteger(LF_UQUADWORD)) + if (auto EC = + Writer->writeInteger(LF_UQUADWORD, llvm::support::little)) return EC; - if (auto EC = Writer->writeInteger(Value)) + if (auto EC = Writer->writeInteger(Value, llvm::support::little)) return EC; } diff --git a/lib/DebugInfo/CodeView/ModuleSubstream.cpp b/lib/DebugInfo/CodeView/ModuleSubstream.cpp index 2dc14b92bca..74389f6e167 100644 --- a/lib/DebugInfo/CodeView/ModuleSubstream.cpp +++ b/lib/DebugInfo/CodeView/ModuleSubstream.cpp @@ -13,16 +13,18 @@ using namespace llvm; using namespace llvm::codeview; +using namespace llvm::msf; ModuleSubstream::ModuleSubstream() : Kind(ModuleSubstreamKind::None) {} -ModuleSubstream::ModuleSubstream(ModuleSubstreamKind Kind, BinaryStreamRef Data) +ModuleSubstream::ModuleSubstream(ModuleSubstreamKind Kind, + ReadableStreamRef Data) : Kind(Kind), Data(Data) {} -Error ModuleSubstream::initialize(BinaryStreamRef Stream, +Error ModuleSubstream::initialize(ReadableStreamRef Stream, ModuleSubstream &Info) { const ModuleSubsectionHeader *Header; - BinaryStreamReader Reader(Stream); + StreamReader Reader(Stream); if (auto EC = Reader.readObject(Header)) return EC; @@ -40,4 +42,4 @@ uint32_t ModuleSubstream::getRecordLength() const { ModuleSubstreamKind ModuleSubstream::getSubstreamKind() const { return Kind; } -BinaryStreamRef ModuleSubstream::getRecordData() const { return Data; } +ReadableStreamRef ModuleSubstream::getRecordData() const { return Data; } diff --git a/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp b/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp index d552665d9d6..336fbda87e3 100644 --- a/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp +++ b/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp @@ -13,47 +13,49 @@ using namespace llvm; using namespace llvm::codeview; +using namespace llvm::msf; -Error IModuleSubstreamVisitor::visitSymbols(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitSymbols(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::Symbols, Data); } -Error IModuleSubstreamVisitor::visitLines(BinaryStreamRef Data, +Error IModuleSubstreamVisitor::visitLines(ReadableStreamRef Data, const LineSubstreamHeader *Header, const LineInfoArray &Lines) { return visitUnknown(ModuleSubstreamKind::Lines, Data); } -Error IModuleSubstreamVisitor::visitStringTable(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitStringTable(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::StringTable, Data); } Error IModuleSubstreamVisitor::visitFileChecksums( - BinaryStreamRef Data, const FileChecksumArray &Checksums) { + ReadableStreamRef Data, const FileChecksumArray &Checksums) { return visitUnknown(ModuleSubstreamKind::FileChecksums, Data); } -Error IModuleSubstreamVisitor::visitFrameData(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitFrameData(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::FrameData, Data); } -Error IModuleSubstreamVisitor::visitInlineeLines(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitInlineeLines(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::InlineeLines, Data); } -Error IModuleSubstreamVisitor::visitCrossScopeImports(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitCrossScopeImports(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CrossScopeExports, Data); } -Error IModuleSubstreamVisitor::visitCrossScopeExports(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitCrossScopeExports(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CrossScopeImports, Data); } -Error IModuleSubstreamVisitor::visitILLines(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitILLines(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::ILLines, Data); } -Error IModuleSubstreamVisitor::visitFuncMDTokenMap(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitFuncMDTokenMap(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::FuncMDTokenMap, Data); } -Error IModuleSubstreamVisitor::visitTypeMDTokenMap(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitTypeMDTokenMap(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::TypeMDTokenMap, Data); } -Error IModuleSubstreamVisitor::visitMergedAssemblyInput(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitMergedAssemblyInput( + ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::MergedAssemblyInput, Data); } -Error IModuleSubstreamVisitor::visitCoffSymbolRVA(BinaryStreamRef Data) { +Error IModuleSubstreamVisitor::visitCoffSymbolRVA(ReadableStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CoffSymbolRVA, Data); } @@ -63,7 +65,7 @@ Error llvm::codeview::visitModuleSubstream(const ModuleSubstream &R, case ModuleSubstreamKind::Symbols: return V.visitSymbols(R.getRecordData()); case ModuleSubstreamKind::Lines: { - BinaryStreamReader Reader(R.getRecordData()); + StreamReader Reader(R.getRecordData()); const LineSubstreamHeader *Header; if (auto EC = Reader.readObject(Header)) return EC; @@ -76,7 +78,7 @@ Error llvm::codeview::visitModuleSubstream(const ModuleSubstream &R, case ModuleSubstreamKind::StringTable: return V.visitStringTable(R.getRecordData()); case ModuleSubstreamKind::FileChecksums: { - BinaryStreamReader Reader(R.getRecordData()); + StreamReader Reader(R.getRecordData()); FileChecksumArray Checksums; if (auto EC = Reader.readArray(Checksums, Reader.bytesRemaining())) return EC; diff --git a/lib/DebugInfo/CodeView/RecordSerialization.cpp b/lib/DebugInfo/CodeView/RecordSerialization.cpp index eaa70f2b181..98599c30b9f 100644 --- a/lib/DebugInfo/CodeView/RecordSerialization.cpp +++ b/lib/DebugInfo/CodeView/RecordSerialization.cpp @@ -33,11 +33,11 @@ StringRef llvm::codeview::getBytesAsCString(ArrayRef LeafData) { return getBytesAsCharacters(LeafData).split('\0').first; } -Error llvm::codeview::consume(BinaryStreamReader &Reader, APSInt &Num) { +Error llvm::codeview::consume(msf::StreamReader &Reader, APSInt &Num) { // Used to avoid overload ambiguity on APInt construtor. bool FalseVal = false; uint16_t Short; - if (auto EC = Reader.readInteger(Short)) + if (auto EC = Reader.readInteger(Short, llvm::support::little)) return EC; if (Short < LF_NUMERIC) { @@ -49,49 +49,49 @@ Error llvm::codeview::consume(BinaryStreamReader &Reader, APSInt &Num) { switch (Short) { case LF_CHAR: { int8_t N; - if (auto EC = Reader.readInteger(N)) + if (auto EC = Reader.readInteger(N, llvm::support::little)) return EC; Num = APSInt(APInt(8, N, true), false); return Error::success(); } case LF_SHORT: { int16_t N; - if (auto EC = Reader.readInteger(N)) + if (auto EC = Reader.readInteger(N, llvm::support::little)) return EC; Num = APSInt(APInt(16, N, true), false); return Error::success(); } case LF_USHORT: { uint16_t N; - if (auto EC = Reader.readInteger(N)) + if (auto EC = Reader.readInteger(N, llvm::support::little)) return EC; Num = APSInt(APInt(16, N, false), true); return Error::success(); } case LF_LONG: { int32_t N; - if (auto EC = Reader.readInteger(N)) + if (auto EC = Reader.readInteger(N, llvm::support::little)) return EC; Num = APSInt(APInt(32, N, true), false); return Error::success(); } case LF_ULONG: { uint32_t N; - if (auto EC = Reader.readInteger(N)) + if (auto EC = Reader.readInteger(N, llvm::support::little)) return EC; Num = APSInt(APInt(32, N, FalseVal), true); return Error::success(); } case LF_QUADWORD: { int64_t N; - if (auto EC = Reader.readInteger(N)) + if (auto EC = Reader.readInteger(N, llvm::support::little)) return EC; Num = APSInt(APInt(64, N, true), false); return Error::success(); } case LF_UQUADWORD: { uint64_t N; - if (auto EC = Reader.readInteger(N)) + if (auto EC = Reader.readInteger(N, llvm::support::little)) return EC; Num = APSInt(APInt(64, N, false), true); return Error::success(); @@ -103,15 +103,15 @@ Error llvm::codeview::consume(BinaryStreamReader &Reader, APSInt &Num) { Error llvm::codeview::consume(StringRef &Data, APSInt &Num) { ArrayRef Bytes(Data.bytes_begin(), Data.bytes_end()); - BinaryByteStream S(Bytes, llvm::support::little); - BinaryStreamReader SR(S); + msf::ByteStream S(Bytes); + msf::StreamReader SR(S); auto EC = consume(SR, Num); Data = Data.take_back(SR.bytesRemaining()); return EC; } /// Decode a numeric leaf value that is known to be a uint64_t. -Error llvm::codeview::consume_numeric(BinaryStreamReader &Reader, +Error llvm::codeview::consume_numeric(msf::StreamReader &Reader, uint64_t &Num) { APSInt N; if (auto EC = consume(Reader, N)) @@ -123,27 +123,27 @@ Error llvm::codeview::consume_numeric(BinaryStreamReader &Reader, return Error::success(); } -Error llvm::codeview::consume(BinaryStreamReader &Reader, uint32_t &Item) { - return Reader.readInteger(Item); +Error llvm::codeview::consume(msf::StreamReader &Reader, uint32_t &Item) { + return Reader.readInteger(Item, llvm::support::little); } Error llvm::codeview::consume(StringRef &Data, uint32_t &Item) { ArrayRef Bytes(Data.bytes_begin(), Data.bytes_end()); - BinaryByteStream S(Bytes, llvm::support::little); - BinaryStreamReader SR(S); + msf::ByteStream S(Bytes); + msf::StreamReader SR(S); auto EC = consume(SR, Item); Data = Data.take_back(SR.bytesRemaining()); return EC; } -Error llvm::codeview::consume(BinaryStreamReader &Reader, int32_t &Item) { - return Reader.readInteger(Item); +Error llvm::codeview::consume(msf::StreamReader &Reader, int32_t &Item) { + return Reader.readInteger(Item, llvm::support::little); } -Error llvm::codeview::consume(BinaryStreamReader &Reader, StringRef &Item) { +Error llvm::codeview::consume(msf::StreamReader &Reader, StringRef &Item) { if (Reader.empty()) return make_error(cv_error_code::corrupt_record, "Null terminated string buffer is empty!"); - return Reader.readCString(Item); + return Reader.readZeroString(Item); } diff --git a/lib/DebugInfo/CodeView/TypeSerializer.cpp b/lib/DebugInfo/CodeView/TypeSerializer.cpp index 4d0ce9e4da9..00eb6671214 100644 --- a/lib/DebugInfo/CodeView/TypeSerializer.cpp +++ b/lib/DebugInfo/CodeView/TypeSerializer.cpp @@ -76,7 +76,7 @@ TypeSerializer::addPadding(MutableArrayRef Record) { int N = PaddingBytes; while (PaddingBytes > 0) { uint8_t Pad = static_cast(LF_PAD0 + PaddingBytes); - if (auto EC = Writer.writeInteger(Pad)) + if (auto EC = Writer.writeInteger(Pad, llvm::support::little)) return std::move(EC); --PaddingBytes; } @@ -85,8 +85,7 @@ TypeSerializer::addPadding(MutableArrayRef Record) { TypeSerializer::TypeSerializer(BumpPtrAllocator &Storage) : RecordStorage(Storage), LastTypeIndex(), - RecordBuffer(MaxRecordLength * 2), - Stream(RecordBuffer, llvm::support::little), Writer(Stream), + RecordBuffer(MaxRecordLength * 2), Stream(RecordBuffer), Writer(Stream), Mapping(Writer) { // RecordBuffer needs to be able to hold enough data so that if we are 1 // byte short of MaxRecordLen, and then we try to write MaxRecordLen bytes, @@ -204,15 +203,15 @@ Error TypeSerializer::visitMemberEnd(CVMemberRecord &Record) { uint8_t *SegmentBytes = RecordStorage.Allocate(LengthWithSize); auto SavedSegment = MutableArrayRef(SegmentBytes, LengthWithSize); - MutableBinaryByteStream CS(SavedSegment, llvm::support::little); - BinaryStreamWriter CW(CS); + msf::MutableByteStream CS(SavedSegment); + msf::StreamWriter CW(CS); if (auto EC = CW.writeBytes(CopyData)) return EC; - if (auto EC = CW.writeEnum(TypeLeafKind::LF_INDEX)) + if (auto EC = CW.writeEnum(TypeLeafKind::LF_INDEX, llvm::support::little)) return EC; - if (auto EC = CW.writeInteger(0)) + if (auto EC = CW.writeInteger(0, llvm::support::little)) return EC; - if (auto EC = CW.writeInteger(0xB0C0B0C0)) + if (auto EC = CW.writeInteger(0xB0C0B0C0, llvm::support::little)) return EC; FieldListSegments.push_back(SavedSegment); diff --git a/lib/DebugInfo/MSF/BinaryStreamReader.cpp b/lib/DebugInfo/MSF/BinaryStreamReader.cpp index ba5fd213c59..567e6b1270e 100644 --- a/lib/DebugInfo/MSF/BinaryStreamReader.cpp +++ b/lib/DebugInfo/MSF/BinaryStreamReader.cpp @@ -1,4 +1,4 @@ -//===- BinaryStreamReader.cpp - Reads objects from a binary stream --------===// +//===- StreamReader.cpp - Reads bytes and objects from a stream -----------===// // // The LLVM Compiler Infrastructure // @@ -10,79 +10,53 @@ #include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/BinaryStreamRef.h" +#include "llvm/DebugInfo/MSF/MSFError.h" using namespace llvm; +using namespace llvm::msf; -BinaryStreamReader::BinaryStreamReader(BinaryStreamRef S) - : Stream(S), Offset(0) {} +StreamReader::StreamReader(ReadableStreamRef S) : Stream(S), Offset(0) {} -Error BinaryStreamReader::readLongestContiguousChunk( - ArrayRef &Buffer) { +Error StreamReader::readLongestContiguousChunk(ArrayRef &Buffer) { if (auto EC = Stream.readLongestContiguousChunk(Offset, Buffer)) return EC; Offset += Buffer.size(); return Error::success(); } -Error BinaryStreamReader::readBytes(ArrayRef &Buffer, uint32_t Size) { +Error StreamReader::readBytes(ArrayRef &Buffer, uint32_t Size) { if (auto EC = Stream.readBytes(Offset, Size, Buffer)) return EC; Offset += Size; return Error::success(); } -Error BinaryStreamReader::readInteger(uint64_t &Dest, uint32_t ByteSize) { - assert(ByteSize == 1 || ByteSize == 2 || ByteSize == 4 || ByteSize == 8); - ArrayRef Bytes; - - if (auto EC = readBytes(Bytes, ByteSize)) - return EC; - switch (ByteSize) { - case 1: - Dest = Bytes[0]; - return Error::success(); - case 2: - Dest = llvm::support::endian::read16(Bytes.data(), Stream.getEndian()); - return Error::success(); - case 4: - Dest = llvm::support::endian::read32(Bytes.data(), Stream.getEndian()); - return Error::success(); - case 8: - Dest = llvm::support::endian::read64(Bytes.data(), Stream.getEndian()); - return Error::success(); - } - llvm_unreachable("Unreachable!"); - return Error::success(); -} - -Error BinaryStreamReader::readCString(StringRef &Dest) { - // TODO: This could be made more efficient by using readLongestContiguousChunk - // and searching for null terminators in the resulting buffer. - +Error StreamReader::readZeroString(StringRef &Dest) { uint32_t Length = 0; // First compute the length of the string by reading 1 byte at a time. uint32_t OriginalOffset = getOffset(); const char *C; - while (true) { + do { if (auto EC = readObject(C)) return EC; - if (*C == '\0') - break; - ++Length; - } + if (*C != '\0') + ++Length; + } while (*C != '\0'); // Now go back and request a reference for that many bytes. uint32_t NewOffset = getOffset(); setOffset(OriginalOffset); - if (auto EC = readFixedString(Dest, Length)) + ArrayRef Data; + if (auto EC = readBytes(Data, Length)) return EC; + Dest = StringRef(reinterpret_cast(Data.begin()), Data.size()); // Now set the offset back to where it was after we calculated the length. setOffset(NewOffset); return Error::success(); } -Error BinaryStreamReader::readFixedString(StringRef &Dest, uint32_t Length) { +Error StreamReader::readFixedString(StringRef &Dest, uint32_t Length) { ArrayRef Bytes; if (auto EC = readBytes(Bytes, Length)) return EC; @@ -90,26 +64,26 @@ Error BinaryStreamReader::readFixedString(StringRef &Dest, uint32_t Length) { return Error::success(); } -Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref) { +Error StreamReader::readStreamRef(ReadableStreamRef &Ref) { return readStreamRef(Ref, bytesRemaining()); } -Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref, uint32_t Length) { +Error StreamReader::readStreamRef(ReadableStreamRef &Ref, uint32_t Length) { if (bytesRemaining() < Length) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); Ref = Stream.slice(Offset, Length); Offset += Length; return Error::success(); } -Error BinaryStreamReader::skip(uint32_t Amount) { +Error StreamReader::skip(uint32_t Amount) { if (Amount > bytesRemaining()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); Offset += Amount; return Error::success(); } -uint8_t BinaryStreamReader::peek() const { +uint8_t StreamReader::peek() const { ArrayRef Buffer; auto EC = Stream.readBytes(Offset, 1, Buffer); assert(!EC && "Cannot peek an empty buffer!"); diff --git a/lib/DebugInfo/MSF/BinaryStreamWriter.cpp b/lib/DebugInfo/MSF/BinaryStreamWriter.cpp index 08e4aef6060..54415b96c0b 100644 --- a/lib/DebugInfo/MSF/BinaryStreamWriter.cpp +++ b/lib/DebugInfo/MSF/BinaryStreamWriter.cpp @@ -1,4 +1,4 @@ -//===- BinaryStreamWriter.cpp - Writes objects to a BinaryStream ----------===// +//===- StreamWrite.cpp - Writes bytes and objects to a stream -------------===// // // The LLVM Compiler Infrastructure // @@ -11,42 +11,21 @@ #include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/BinaryStreamRef.h" +#include "llvm/DebugInfo/MSF/MSFError.h" using namespace llvm; +using namespace llvm::msf; -BinaryStreamWriter::BinaryStreamWriter(WritableBinaryStreamRef S) - : Stream(S), Offset(0) {} +StreamWriter::StreamWriter(WritableStreamRef S) : Stream(S), Offset(0) {} -Error BinaryStreamWriter::writeBytes(ArrayRef Buffer) { +Error StreamWriter::writeBytes(ArrayRef Buffer) { if (auto EC = Stream.writeBytes(Offset, Buffer)) return EC; Offset += Buffer.size(); return Error::success(); } -Error BinaryStreamWriter::writeInteger(uint64_t Value, uint32_t ByteSize) { - assert(ByteSize == 1 || ByteSize == 2 || ByteSize == 4 || ByteSize == 8); - uint8_t Bytes[8]; - MutableArrayRef Buffer(Bytes); - Buffer = Buffer.take_front(ByteSize); - switch (ByteSize) { - case 1: - Buffer[0] = static_cast(Value); - break; - case 2: - llvm::support::endian::write16(Buffer.data(), Value, Stream.getEndian()); - break; - case 4: - llvm::support::endian::write32(Buffer.data(), Value, Stream.getEndian()); - break; - case 8: - llvm::support::endian::write64(Buffer.data(), Value, Stream.getEndian()); - break; - } - return writeBytes(Buffer); -} - -Error BinaryStreamWriter::writeCString(StringRef Str) { +Error StreamWriter::writeZeroString(StringRef Str) { if (auto EC = writeFixedString(Str)) return EC; if (auto EC = writeObject('\0')) @@ -55,21 +34,31 @@ Error BinaryStreamWriter::writeCString(StringRef Str) { return Error::success(); } -Error BinaryStreamWriter::writeFixedString(StringRef Str) { - return writeBytes(ArrayRef(Str.bytes_begin(), Str.bytes_end())); +Error StreamWriter::writeFixedString(StringRef Str) { + ArrayRef Bytes(Str.bytes_begin(), Str.bytes_end()); + if (auto EC = Stream.writeBytes(Offset, Bytes)) + return EC; + + Offset += Str.size(); + return Error::success(); } -Error BinaryStreamWriter::writeStreamRef(BinaryStreamRef Ref) { - return writeStreamRef(Ref, Ref.getLength()); +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 + // writeStreamRef. + return Error::success(); } -Error BinaryStreamWriter::writeStreamRef(BinaryStreamRef Ref, uint32_t Length) { - BinaryStreamReader SrcReader(Ref.slice(0, Length)); +Error StreamWriter::writeStreamRef(ReadableStreamRef Ref, uint32_t Length) { + Ref = Ref.slice(0, Length); + + StreamReader SrcReader(Ref); // This is a bit tricky. If we just call readBytes, we are requiring that it - // return us the entire stream as a contiguous buffer. There is no guarantee - // this can be satisfied by returning a reference straight from the buffer, as - // an implementation may not store all data in a single contiguous buffer. So - // we iterate over each contiguous chunk, writing each one in succession. + // return us the entire stream as a contiguous buffer. For large streams this + // will allocate a huge amount of space from the pool. Instead, iterate over + // each contiguous chunk until we've consumed the entire stream. while (SrcReader.bytesRemaining() > 0) { ArrayRef Chunk; if (auto EC = SrcReader.readLongestContiguousChunk(Chunk)) diff --git a/lib/DebugInfo/MSF/MappedBlockStream.cpp b/lib/DebugInfo/MSF/MappedBlockStream.cpp index c9ba25c0d7d..e52c88a5bfb 100644 --- a/lib/DebugInfo/MSF/MappedBlockStream.cpp +++ b/lib/DebugInfo/MSF/MappedBlockStream.cpp @@ -47,20 +47,22 @@ static Interval intersect(const Interval &I1, const Interval &I2) { MappedBlockStream::MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - BinaryStreamRef MsfData) + const ReadableStream &MsfData) : BlockSize(BlockSize), NumBlocks(NumBlocks), StreamLayout(Layout), MsfData(MsfData) {} std::unique_ptr MappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - BinaryStreamRef MsfData) { + const ReadableStream &MsfData) { return llvm::make_unique>( BlockSize, NumBlocks, Layout, MsfData); } -std::unique_ptr MappedBlockStream::createIndexedStream( - const MSFLayout &Layout, BinaryStreamRef MsfData, uint32_t StreamIndex) { +std::unique_ptr +MappedBlockStream::createIndexedStream(const MSFLayout &Layout, + const ReadableStream &MsfData, + uint32_t StreamIndex) { assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index"); MSFStreamLayout SL; SL.Blocks = Layout.StreamMap[StreamIndex]; @@ -71,7 +73,7 @@ std::unique_ptr MappedBlockStream::createIndexedStream( std::unique_ptr MappedBlockStream::createDirectoryStream(const MSFLayout &Layout, - BinaryStreamRef MsfData) { + const ReadableStream &MsfData) { MSFStreamLayout SL; SL.Blocks = Layout.DirectoryBlocks; SL.Length = Layout.SB->NumDirectoryBytes; @@ -80,14 +82,14 @@ MappedBlockStream::createDirectoryStream(const MSFLayout &Layout, std::unique_ptr MappedBlockStream::createFpmStream(const MSFLayout &Layout, - BinaryStreamRef MsfData) { + const ReadableStream &MsfData) { MSFStreamLayout SL; initializeFpmStreamLayout(Layout, SL); return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData); } Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) { + ArrayRef &Buffer) const { // Make sure we aren't trying to read beyond the end of the stream. if (Size > StreamLayout.Length) return make_error(msf_error_code::insufficient_buffer); @@ -166,8 +168,8 @@ Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size, return Error::success(); } -Error MappedBlockStream::readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) { +Error MappedBlockStream::readLongestContiguousChunk( + uint32_t Offset, ArrayRef &Buffer) const { // Make sure we aren't trying to read beyond the end of the stream. if (Offset >= StreamLayout.Length) return make_error(msf_error_code::insufficient_buffer); @@ -195,10 +197,10 @@ Error MappedBlockStream::readLongestContiguousChunk(uint32_t Offset, return Error::success(); } -uint32_t MappedBlockStream::getLength() { return StreamLayout.Length; } +uint32_t MappedBlockStream::getLength() const { return StreamLayout.Length; } bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) { + ArrayRef &Buffer) const { if (Size == 0) { Buffer = ArrayRef(); return true; @@ -239,7 +241,7 @@ bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size, } Error MappedBlockStream::readBytes(uint32_t Offset, - MutableArrayRef Buffer) { + MutableArrayRef Buffer) const { uint32_t BlockNum = Offset / BlockSize; uint32_t OffsetInBlock = Offset % BlockSize; @@ -317,21 +319,21 @@ void MappedBlockStream::fixCacheAfterWrite(uint32_t Offset, WritableMappedBlockStream::WritableMappedBlockStream( uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - WritableBinaryStreamRef MsfData) + const WritableStream &MsfData) : ReadInterface(BlockSize, NumBlocks, Layout, MsfData), WriteInterface(MsfData) {} std::unique_ptr WritableMappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - WritableBinaryStreamRef MsfData) { + const WritableStream &MsfData) { return llvm::make_unique>( BlockSize, NumBlocks, Layout, MsfData); } std::unique_ptr WritableMappedBlockStream::createIndexedStream(const MSFLayout &Layout, - WritableBinaryStreamRef MsfData, + const WritableStream &MsfData, uint32_t StreamIndex) { assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index"); MSFStreamLayout SL; @@ -342,7 +344,7 @@ WritableMappedBlockStream::createIndexedStream(const MSFLayout &Layout, std::unique_ptr WritableMappedBlockStream::createDirectoryStream( - const MSFLayout &Layout, WritableBinaryStreamRef MsfData) { + const MSFLayout &Layout, const WritableStream &MsfData) { MSFStreamLayout SL; SL.Blocks = Layout.DirectoryBlocks; SL.Length = Layout.SB->NumDirectoryBytes; @@ -351,28 +353,28 @@ WritableMappedBlockStream::createDirectoryStream( std::unique_ptr WritableMappedBlockStream::createFpmStream(const MSFLayout &Layout, - WritableBinaryStreamRef MsfData) { + const WritableStream &MsfData) { MSFStreamLayout SL; initializeFpmStreamLayout(Layout, SL); return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData); } Error WritableMappedBlockStream::readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) { + ArrayRef &Buffer) const { return ReadInterface.readBytes(Offset, Size, Buffer); } Error WritableMappedBlockStream::readLongestContiguousChunk( - uint32_t Offset, ArrayRef &Buffer) { + uint32_t Offset, ArrayRef &Buffer) const { return ReadInterface.readLongestContiguousChunk(Offset, Buffer); } -uint32_t WritableMappedBlockStream::getLength() { +uint32_t WritableMappedBlockStream::getLength() const { return ReadInterface.getLength(); } Error WritableMappedBlockStream::writeBytes(uint32_t Offset, - ArrayRef Buffer) { + ArrayRef Buffer) const { // Make sure we aren't trying to write beyond the end of the stream. if (Buffer.size() > getStreamLength()) return make_error(msf_error_code::insufficient_buffer); @@ -408,4 +410,6 @@ Error WritableMappedBlockStream::writeBytes(uint32_t Offset, return Error::success(); } -Error WritableMappedBlockStream::commit() { return WriteInterface.commit(); } +Error WritableMappedBlockStream::commit() const { + return WriteInterface.commit(); +} diff --git a/lib/DebugInfo/PDB/Native/DbiStream.cpp b/lib/DebugInfo/PDB/Native/DbiStream.cpp index 51a868f8770..d8169434143 100644 --- a/lib/DebugInfo/PDB/Native/DbiStream.cpp +++ b/lib/DebugInfo/PDB/Native/DbiStream.cpp @@ -10,8 +10,6 @@ #include "llvm/DebugInfo/PDB/Native/DbiStream.h" #include "llvm/ADT/StringRef.h" #include "llvm/DebugInfo/MSF/BinaryStreamArray.h" -#include "llvm/DebugInfo/MSF/BinaryStreamArray.h" -#include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h" @@ -36,7 +34,7 @@ using namespace llvm::support; template static Error loadSectionContribs(FixedStreamArray &Output, - BinaryStreamReader &Reader) { + StreamReader &Reader) { if (Reader.bytesRemaining() % sizeof(ContribType) != 0) return make_error( raw_error_code::corrupt_file, @@ -54,7 +52,7 @@ DbiStream::DbiStream(PDBFile &File, std::unique_ptr Stream) DbiStream::~DbiStream() = default; Error DbiStream::reload() { - BinaryStreamReader Reader(*Stream); + StreamReader Reader(*Stream); if (Stream->getLength() < sizeof(DbiStreamHeader)) return make_error(raw_error_code::corrupt_file, @@ -147,7 +145,7 @@ Error DbiStream::reload() { "Found unexpected bytes in DBI Stream."); if (ECSubstream.getLength() > 0) { - BinaryStreamReader ECReader(ECSubstream); + StreamReader ECReader(ECSubstream); if (auto EC = ECNames.load(ECReader)) return EC; } @@ -209,16 +207,16 @@ PDB_Machine DbiStream::getMachineType() const { return static_cast(Machine); } -FixedStreamArray DbiStream::getSectionHeaders() { +msf::FixedStreamArray DbiStream::getSectionHeaders() { return SectionHeaders; } -FixedStreamArray DbiStream::getFpoRecords() { +msf::FixedStreamArray DbiStream::getFpoRecords() { return FpoRecords; } ArrayRef DbiStream::modules() const { return ModuleInfos; } -FixedStreamArray DbiStream::getSectionMap() const { +msf::FixedStreamArray DbiStream::getSectionMap() const { return SectionMap; } @@ -237,8 +235,8 @@ Error DbiStream::initializeSectionContributionData() { if (SecContrSubstream.getLength() == 0) return Error::success(); - BinaryStreamReader SCReader(SecContrSubstream); - if (auto EC = SCReader.readEnum(SectionContribVersion)) + StreamReader SCReader(SecContrSubstream); + if (auto EC = SCReader.readEnum(SectionContribVersion, llvm::support::little)) return EC; if (SectionContribVersion == DbiSecContribVer60) @@ -256,7 +254,7 @@ Error DbiStream::initializeModInfoArray() { // Since each ModInfo in the stream is a variable length, we have to iterate // them to know how many there actually are. - BinaryStreamReader Reader(ModInfoSubstream); + StreamReader Reader(ModInfoSubstream); VarStreamArray ModInfoArray; if (auto EC = Reader.readArray(ModInfoArray, ModInfoSubstream.getLength())) @@ -286,7 +284,7 @@ Error DbiStream::initializeSectionHeadersData() { "Corrupted section header stream."); size_t NumSections = StreamLen / sizeof(object::coff_section); - BinaryStreamReader Reader(*SHS); + msf::StreamReader Reader(*SHS); if (auto EC = Reader.readArray(SectionHeaders, NumSections)) return make_error(raw_error_code::corrupt_file, "Could not read a bitmap."); @@ -318,7 +316,7 @@ Error DbiStream::initializeFpoRecords() { "Corrupted New FPO stream."); size_t NumRecords = StreamLen / sizeof(object::FpoData); - BinaryStreamReader Reader(*FS); + msf::StreamReader Reader(*FS); if (auto EC = Reader.readArray(FpoRecords, NumRecords)) return make_error(raw_error_code::corrupt_file, "Corrupted New FPO stream."); @@ -330,7 +328,7 @@ Error DbiStream::initializeSectionMapData() { if (SecMapSubstream.getLength() == 0) return Error::success(); - BinaryStreamReader SMReader(SecMapSubstream); + StreamReader SMReader(SecMapSubstream); const SecMapHeader *Header; if (auto EC = SMReader.readObject(Header)) return EC; @@ -344,7 +342,7 @@ Error DbiStream::initializeFileInfo() { return Error::success(); const FileInfoSubstreamHeader *FH; - BinaryStreamReader FISR(FileInfoSubstream); + StreamReader FISR(FileInfoSubstream); if (auto EC = FISR.readObject(FH)) return EC; @@ -413,14 +411,14 @@ uint32_t DbiStream::getDebugStreamIndex(DbgHeaderType Type) const { } Expected DbiStream::getFileNameForIndex(uint32_t Index) const { - BinaryStreamReader Names(NamesBuffer); + StreamReader Names(NamesBuffer); if (Index >= FileNameOffsets.size()) return make_error(raw_error_code::index_out_of_bounds); uint32_t FileOffset = FileNameOffsets[Index]; Names.setOffset(FileOffset); StringRef Name; - if (auto EC = Names.readCString(Name)) + if (auto EC = Names.readZeroString(Name)) return std::move(EC); return Name; } diff --git a/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp b/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp index ac40330c5dc..60687ac23b0 100644 --- a/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp +++ b/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp @@ -11,7 +11,6 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" -#include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" #include "llvm/DebugInfo/MSF/MSFBuilder.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" #include "llvm/DebugInfo/PDB/Native/DbiStream.h" @@ -154,19 +153,18 @@ Error DbiStreamBuilder::generateModiSubstream() { uint32_t Size = calculateModiSubstreamSize(); auto Data = Allocator.Allocate(Size); - ModInfoBuffer = MutableBinaryByteStream(MutableArrayRef(Data, Size), - llvm::support::little); + ModInfoBuffer = MutableByteStream(MutableArrayRef(Data, Size)); - BinaryStreamWriter ModiWriter(ModInfoBuffer); + StreamWriter ModiWriter(ModInfoBuffer); for (const auto &M : ModuleInfoList) { ModuleInfoHeader Layout = {}; Layout.ModDiStream = kInvalidStreamIndex; Layout.NumFiles = M->SourceFiles.size(); if (auto EC = ModiWriter.writeObject(Layout)) return EC; - if (auto EC = ModiWriter.writeCString(M->Mod)) + if (auto EC = ModiWriter.writeZeroString(M->Mod)) return EC; - if (auto EC = ModiWriter.writeCString(M->Obj)) + if (auto EC = ModiWriter.writeZeroString(M->Obj)) return EC; } if (ModiWriter.bytesRemaining() > sizeof(uint32_t)) @@ -181,26 +179,29 @@ Error DbiStreamBuilder::generateFileInfoSubstream() { auto Data = Allocator.Allocate(Size); uint32_t NamesOffset = Size - NameSize; - FileInfoBuffer = MutableBinaryByteStream(MutableArrayRef(Data, Size), - llvm::support::little); + FileInfoBuffer = MutableByteStream(MutableArrayRef(Data, Size)); - WritableBinaryStreamRef MetadataBuffer = - WritableBinaryStreamRef(FileInfoBuffer).keep_front(NamesOffset); - BinaryStreamWriter MetadataWriter(MetadataBuffer); + WritableStreamRef MetadataBuffer = + WritableStreamRef(FileInfoBuffer).keep_front(NamesOffset); + StreamWriter MetadataWriter(MetadataBuffer); uint16_t ModiCount = std::min(UINT16_MAX, ModuleInfos.size()); uint16_t FileCount = std::min(UINT16_MAX, SourceFileNames.size()); - if (auto EC = MetadataWriter.writeInteger(ModiCount)) // NumModules + if (auto EC = MetadataWriter.writeInteger( + ModiCount, llvm::support::little)) // NumModules return EC; - if (auto EC = MetadataWriter.writeInteger(FileCount)) // NumSourceFiles + if (auto EC = MetadataWriter.writeInteger( + FileCount, llvm::support::little)) // NumSourceFiles return EC; for (uint16_t I = 0; I < ModiCount; ++I) { - if (auto EC = MetadataWriter.writeInteger(I)) // Mod Indices + if (auto EC = MetadataWriter.writeInteger( + I, llvm::support::little)) // Mod Indices return EC; } for (const auto MI : ModuleInfoList) { FileCount = static_cast(MI->SourceFiles.size()); - if (auto EC = MetadataWriter.writeInteger(FileCount)) // Mod File Counts + if (auto EC = MetadataWriter.writeInteger( + FileCount, llvm::support::little)) // Mod File Counts return EC; } @@ -208,11 +209,11 @@ 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 = WritableBinaryStreamRef(FileInfoBuffer).drop_front(NamesOffset); - BinaryStreamWriter NameBufferWriter(NamesBuffer); + NamesBuffer = WritableStreamRef(FileInfoBuffer).drop_front(NamesOffset); + StreamWriter NameBufferWriter(NamesBuffer); for (auto &Name : SourceFileNames) { Name.second = NameBufferWriter.getOffset(); - if (auto EC = NameBufferWriter.writeCString(Name.getKey())) + if (auto EC = NameBufferWriter.writeZeroString(Name.getKey())) return EC; } @@ -222,7 +223,8 @@ Error DbiStreamBuilder::generateFileInfoSubstream() { if (Result == SourceFileNames.end()) return make_error(raw_error_code::no_entry, "The source file was not found."); - if (auto EC = MetadataWriter.writeInteger(Result->second)) + if (auto EC = MetadataWriter.writeInteger(Result->second, + llvm::support::little)) return EC; } } @@ -361,14 +363,14 @@ std::vector DbiStreamBuilder::createSectionMap( } Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, - WritableBinaryStreamRef Buffer) { + const msf::WritableStream &Buffer) { if (auto EC = finalize()) return EC; auto InfoS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamDBI); - BinaryStreamWriter Writer(*InfoS); + StreamWriter Writer(*InfoS); if (auto EC = Writer.writeObject(*Header)) return EC; @@ -376,7 +378,7 @@ Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, return EC; if (!SectionContribs.empty()) { - if (auto EC = Writer.writeEnum(DbiSecContribVer60)) + if (auto EC = Writer.writeEnum(DbiSecContribVer60, llvm::support::little)) return EC; if (auto EC = Writer.writeArray(SectionContribs)) return EC; @@ -395,7 +397,8 @@ Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, return EC; for (auto &Stream : DbgStreams) - if (auto EC = Writer.writeInteger(Stream.StreamNumber)) + if (auto EC = + Writer.writeInteger(Stream.StreamNumber, llvm::support::little)) return EC; for (auto &Stream : DbgStreams) { @@ -403,7 +406,7 @@ Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, continue; auto WritableStream = WritableMappedBlockStream::createIndexedStream( Layout, Buffer, Stream.StreamNumber); - BinaryStreamWriter DbgStreamWriter(*WritableStream); + StreamWriter DbgStreamWriter(*WritableStream); if (auto EC = DbgStreamWriter.writeArray(Stream.Data)) return EC; } diff --git a/lib/DebugInfo/PDB/Native/GSI.cpp b/lib/DebugInfo/PDB/Native/GSI.cpp index 3a7e1e1529f..5a727910e20 100644 --- a/lib/DebugInfo/PDB/Native/GSI.cpp +++ b/lib/DebugInfo/PDB/Native/GSI.cpp @@ -28,9 +28,9 @@ static Error checkHashHdrVersion(const GSIHashHeader *HashHdr) { return Error::success(); } -Error readGSIHashBuckets(FixedStreamArray &HashBuckets, - const GSIHashHeader *HashHdr, - BinaryStreamReader &Reader) { +Error readGSIHashBuckets( + msf::FixedStreamArray &HashBuckets, + const GSIHashHeader *HashHdr, msf::StreamReader &Reader) { if (auto EC = checkHashHdrVersion(HashHdr)) return EC; @@ -57,7 +57,7 @@ Error readGSIHashBuckets(FixedStreamArray &HashBuckets, } Error readGSIHashHeader(const GSIHashHeader *&HashHdr, - BinaryStreamReader &Reader) { + msf::StreamReader &Reader) { if (Reader.readObject(HashHdr)) return make_error(raw_error_code::corrupt_file, "Stream does not contain a GSIHashHeader."); @@ -70,9 +70,9 @@ Error readGSIHashHeader(const GSIHashHeader *&HashHdr, return Error::success(); } -Error readGSIHashRecords(FixedStreamArray &HashRecords, +Error readGSIHashRecords(msf::FixedStreamArray &HashRecords, const GSIHashHeader *HashHdr, - BinaryStreamReader &Reader) { + msf::StreamReader &Reader) { if (auto EC = checkHashHdrVersion(HashHdr)) return EC; diff --git a/lib/DebugInfo/PDB/Native/GSI.h b/lib/DebugInfo/PDB/Native/GSI.h index f47321a2f14..5c5596c0484 100644 --- a/lib/DebugInfo/PDB/Native/GSI.h +++ b/lib/DebugInfo/PDB/Native/GSI.h @@ -33,7 +33,9 @@ namespace llvm { -class BinaryStreamReader; +namespace msf { +class StreamReader; +} namespace pdb { @@ -54,14 +56,14 @@ struct GSIHashHeader { support::ulittle32_t NumBuckets; }; -Error readGSIHashBuckets(FixedStreamArray &HashBuckets, - const GSIHashHeader *HashHdr, - BinaryStreamReader &Reader); +Error readGSIHashBuckets( + msf::FixedStreamArray &HashBuckets, + const GSIHashHeader *HashHdr, msf::StreamReader &Reader); Error readGSIHashHeader(const GSIHashHeader *&HashHdr, - BinaryStreamReader &Reader); -Error readGSIHashRecords(FixedStreamArray &HashRecords, + msf::StreamReader &Reader); +Error readGSIHashRecords(msf::FixedStreamArray &HashRecords, const GSIHashHeader *HashHdr, - BinaryStreamReader &Reader); + msf::StreamReader &Reader); } } diff --git a/lib/DebugInfo/PDB/Native/GlobalsStream.cpp b/lib/DebugInfo/PDB/Native/GlobalsStream.cpp index 7d6d39d43d2..d5c80ba42b5 100644 --- a/lib/DebugInfo/PDB/Native/GlobalsStream.cpp +++ b/lib/DebugInfo/PDB/Native/GlobalsStream.cpp @@ -23,7 +23,7 @@ GlobalsStream::GlobalsStream(std::unique_ptr Stream) GlobalsStream::~GlobalsStream() = default; Error GlobalsStream::reload() { - BinaryStreamReader Reader(*Stream); + StreamReader Reader(*Stream); const GSIHashHeader *HashHdr; if (auto EC = readGSIHashHeader(HashHdr, Reader)) diff --git a/lib/DebugInfo/PDB/Native/HashTable.cpp b/lib/DebugInfo/PDB/Native/HashTable.cpp index ebf8c9c04db..dd95c078d7e 100644 --- a/lib/DebugInfo/PDB/Native/HashTable.cpp +++ b/lib/DebugInfo/PDB/Native/HashTable.cpp @@ -22,7 +22,7 @@ HashTable::HashTable() : HashTable(8) {} HashTable::HashTable(uint32_t Capacity) { Buckets.resize(Capacity); } -Error HashTable::load(BinaryStreamReader &Stream) { +Error HashTable::load(msf::StreamReader &Stream) { const Header *H; if (auto EC = Stream.readObject(H)) return EC; @@ -48,9 +48,9 @@ Error HashTable::load(BinaryStreamReader &Stream) { "Present bit vector interesects deleted!"); for (uint32_t P : Present) { - if (auto EC = Stream.readInteger(Buckets[P].first)) + if (auto EC = Stream.readInteger(Buckets[P].first, llvm::support::little)) return EC; - if (auto EC = Stream.readInteger(Buckets[P].second)) + if (auto EC = Stream.readInteger(Buckets[P].second, llvm::support::little)) return EC; } @@ -77,7 +77,7 @@ uint32_t HashTable::calculateSerializedLength() const { return Size; } -Error HashTable::commit(BinaryStreamWriter &Writer) const { +Error HashTable::commit(msf::StreamWriter &Writer) const { Header H; H.Size = size(); H.Capacity = capacity(); @@ -91,9 +91,9 @@ Error HashTable::commit(BinaryStreamWriter &Writer) const { return EC; for (const auto &Entry : *this) { - if (auto EC = Writer.writeInteger(Entry.first)) + if (auto EC = Writer.writeInteger(Entry.first, llvm::support::little)) return EC; - if (auto EC = Writer.writeInteger(Entry.second)) + if (auto EC = Writer.writeInteger(Entry.second, llvm::support::little)) return EC; } return Error::success(); @@ -209,10 +209,10 @@ void HashTable::grow() { assert(size() == S); } -Error HashTable::readSparseBitVector(BinaryStreamReader &Stream, +Error HashTable::readSparseBitVector(msf::StreamReader &Stream, SparseBitVector<> &V) { uint32_t NumWords; - if (auto EC = Stream.readInteger(NumWords)) + if (auto EC = Stream.readInteger(NumWords, llvm::support::little)) return joinErrors( std::move(EC), make_error(raw_error_code::corrupt_file, @@ -220,7 +220,7 @@ Error HashTable::readSparseBitVector(BinaryStreamReader &Stream, for (uint32_t I = 0; I != NumWords; ++I) { uint32_t Word; - if (auto EC = Stream.readInteger(Word)) + if (auto EC = Stream.readInteger(Word, llvm::support::little)) return joinErrors(std::move(EC), make_error(raw_error_code::corrupt_file, "Expected hash table word")); @@ -231,11 +231,11 @@ Error HashTable::readSparseBitVector(BinaryStreamReader &Stream, return Error::success(); } -Error HashTable::writeSparseBitVector(BinaryStreamWriter &Writer, +Error HashTable::writeSparseBitVector(msf::StreamWriter &Writer, SparseBitVector<> &Vec) { int ReqBits = Vec.find_last() + 1; uint32_t NumWords = alignTo(ReqBits, sizeof(uint32_t)) / sizeof(uint32_t); - if (auto EC = Writer.writeInteger(NumWords)) + if (auto EC = Writer.writeInteger(NumWords, llvm::support::little)) return joinErrors( std::move(EC), make_error(raw_error_code::corrupt_file, @@ -248,7 +248,7 @@ Error HashTable::writeSparseBitVector(BinaryStreamWriter &Writer, if (Vec.test(Idx)) Word |= (1 << WordIdx); } - if (auto EC = Writer.writeInteger(Word)) + if (auto EC = Writer.writeInteger(Word, llvm::support::little)) return joinErrors(std::move(EC), make_error( raw_error_code::corrupt_file, "Could not write linear map word")); diff --git a/lib/DebugInfo/PDB/Native/InfoStream.cpp b/lib/DebugInfo/PDB/Native/InfoStream.cpp index 9c4fca7aa5e..692099256d8 100644 --- a/lib/DebugInfo/PDB/Native/InfoStream.cpp +++ b/lib/DebugInfo/PDB/Native/InfoStream.cpp @@ -26,7 +26,7 @@ InfoStream::InfoStream(std::unique_ptr Stream) : Stream(std::move(Stream)) {} Error InfoStream::reload() { - BinaryStreamReader Reader(*Stream); + StreamReader Reader(*Stream); const InfoStreamHeader *H; if (auto EC = Reader.readObject(H)) diff --git a/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp b/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp index db7e18df1ab..0b6a563b5a9 100644 --- a/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp +++ b/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp @@ -9,7 +9,6 @@ #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h" -#include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" #include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" #include "llvm/DebugInfo/MSF/MSFBuilder.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" @@ -45,10 +44,10 @@ Error InfoStreamBuilder::finalizeMsfLayout() { } Error InfoStreamBuilder::commit(const msf::MSFLayout &Layout, - WritableBinaryStreamRef Buffer) const { + const msf::WritableStream &Buffer) const { auto InfoS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamPDB); - BinaryStreamWriter Writer(*InfoS); + StreamWriter Writer(*InfoS); InfoStreamHeader H; H.Age = Age; diff --git a/lib/DebugInfo/PDB/Native/ModInfo.cpp b/lib/DebugInfo/PDB/Native/ModInfo.cpp index 5e229663844..501188e96f6 100644 --- a/lib/DebugInfo/PDB/Native/ModInfo.cpp +++ b/lib/DebugInfo/PDB/Native/ModInfo.cpp @@ -16,6 +16,7 @@ #include using namespace llvm; +using namespace llvm::msf; using namespace llvm::pdb; using namespace llvm::support; @@ -25,15 +26,15 @@ ModInfo::ModInfo(const ModInfo &Info) = default; ModInfo::~ModInfo() = default; -Error ModInfo::initialize(BinaryStreamRef Stream, ModInfo &Info) { - BinaryStreamReader Reader(Stream); +Error ModInfo::initialize(ReadableStreamRef Stream, ModInfo &Info) { + StreamReader Reader(Stream); if (auto EC = Reader.readObject(Info.Layout)) return EC; - if (auto EC = Reader.readCString(Info.ModuleName)) + if (auto EC = Reader.readZeroString(Info.ModuleName)) return EC; - if (auto EC = Reader.readCString(Info.ObjFileName)) + if (auto EC = Reader.readZeroString(Info.ObjFileName)) return EC; return Error::success(); } diff --git a/lib/DebugInfo/PDB/Native/ModStream.cpp b/lib/DebugInfo/PDB/Native/ModStream.cpp index df9ec818a1d..9f035cf3e94 100644 --- a/lib/DebugInfo/PDB/Native/ModStream.cpp +++ b/lib/DebugInfo/PDB/Native/ModStream.cpp @@ -31,7 +31,7 @@ ModStream::ModStream(const ModInfo &Module, ModStream::~ModStream() = default; Error ModStream::reload() { - BinaryStreamReader Reader(*Stream); + StreamReader Reader(*Stream); uint32_t SymbolSize = Mod.getSymbolDebugInfoByteSize(); uint32_t C11Size = Mod.getLineInfoByteSize(); @@ -41,9 +41,9 @@ Error ModStream::reload() { return make_error(raw_error_code::corrupt_file, "Module has both C11 and C13 line info"); - BinaryStreamRef S; + ReadableStreamRef S; - if (auto EC = Reader.readInteger(Signature)) + if (auto EC = Reader.readInteger(Signature, llvm::support::little)) return EC; if (auto EC = Reader.readArray(SymbolsSubstream, SymbolSize - 4)) return EC; @@ -53,12 +53,12 @@ Error ModStream::reload() { if (auto EC = Reader.readStreamRef(C13LinesSubstream, C13Size)) return EC; - BinaryStreamReader LineReader(C13LinesSubstream); + StreamReader LineReader(C13LinesSubstream); if (auto EC = LineReader.readArray(LineInfo, LineReader.bytesRemaining())) return EC; uint32_t GlobalRefsSize; - if (auto EC = Reader.readInteger(GlobalRefsSize)) + if (auto EC = Reader.readInteger(GlobalRefsSize, llvm::support::little)) return EC; if (auto EC = Reader.readStreamRef(GlobalRefsSubstream, GlobalRefsSize)) return EC; diff --git a/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp b/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp index 1fa9bc443ec..ceeca10c5c5 100644 --- a/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp +++ b/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp @@ -21,22 +21,23 @@ #include using namespace llvm; +using namespace llvm::msf; using namespace llvm::pdb; NamedStreamMap::NamedStreamMap() = default; -Error NamedStreamMap::load(BinaryStreamReader &Stream) { +Error NamedStreamMap::load(StreamReader &Stream) { Mapping.clear(); FinalizedHashTable.clear(); FinalizedInfo.reset(); uint32_t StringBufferSize; - if (auto EC = Stream.readInteger(StringBufferSize)) + if (auto EC = Stream.readInteger(StringBufferSize, llvm::support::little)) return joinErrors(std::move(EC), make_error(raw_error_code::corrupt_file, "Expected string buffer size")); - BinaryStreamRef StringsBuffer; + msf::ReadableStreamRef StringsBuffer; if (auto EC = Stream.readStreamRef(StringsBuffer, StringBufferSize)) return EC; @@ -50,11 +51,11 @@ Error NamedStreamMap::load(BinaryStreamReader &Stream) { std::tie(NameOffset, NameIndex) = Entry; // Compute the offset of the start of the string relative to the stream. - BinaryStreamReader NameReader(StringsBuffer); + msf::StreamReader NameReader(StringsBuffer); NameReader.setOffset(NameOffset); // Pump out our c-string from the stream. StringRef Str; - if (auto EC = NameReader.readCString(Str)) + if (auto EC = NameReader.readZeroString(Str)) return joinErrors(std::move(EC), make_error(raw_error_code::corrupt_file, "Expected name map name")); @@ -66,16 +67,17 @@ Error NamedStreamMap::load(BinaryStreamReader &Stream) { return Error::success(); } -Error NamedStreamMap::commit(BinaryStreamWriter &Writer) const { +Error NamedStreamMap::commit(msf::StreamWriter &Writer) const { assert(FinalizedInfo.hasValue()); // The first field is the number of bytes of string data. - if (auto EC = Writer.writeInteger(FinalizedInfo->StringDataBytes)) + if (auto EC = Writer.writeInteger(FinalizedInfo->StringDataBytes, + llvm::support::little)) return EC; // Now all of the string data itself. for (const auto &Item : Mapping) { - if (auto EC = Writer.writeCString(Item.getKey())) + if (auto EC = Writer.writeZeroString(Item.getKey())) return EC; } diff --git a/lib/DebugInfo/PDB/Native/NativeSession.cpp b/lib/DebugInfo/PDB/Native/NativeSession.cpp index dff53344545..4c858253b79 100644 --- a/lib/DebugInfo/PDB/Native/NativeSession.cpp +++ b/lib/DebugInfo/PDB/Native/NativeSession.cpp @@ -45,8 +45,7 @@ Error NativeSession::createFromPdb(StringRef Path, return make_error(generic_error_code::invalid_path); std::unique_ptr Buffer = std::move(*ErrorOrBuffer); - auto Stream = llvm::make_unique( - std::move(Buffer), llvm::support::little); + auto Stream = llvm::make_unique(std::move(Buffer)); auto Allocator = llvm::make_unique(); auto File = llvm::make_unique(Path, std::move(Stream), *Allocator); diff --git a/lib/DebugInfo/PDB/Native/PDBFile.cpp b/lib/DebugInfo/PDB/Native/PDBFile.cpp index 7e4f1652114..e1cf9102773 100644 --- a/lib/DebugInfo/PDB/Native/PDBFile.cpp +++ b/lib/DebugInfo/PDB/Native/PDBFile.cpp @@ -11,10 +11,7 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/STLExtras.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/BinaryStream.h" #include "llvm/DebugInfo/MSF/BinaryStreamArray.h" -#include "llvm/DebugInfo/MSF/BinaryStreamArray.h" -#include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/MSFCommon.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" @@ -42,7 +39,7 @@ namespace { typedef FixedStreamArray ulittle_array; } // end anonymous namespace -PDBFile::PDBFile(StringRef Path, std::unique_ptr PdbFileBuffer, +PDBFile::PDBFile(StringRef Path, std::unique_ptr PdbFileBuffer, BumpPtrAllocator &Allocator) : FilePath(Path), Allocator(Allocator), Buffer(std::move(PdbFileBuffer)) {} @@ -116,7 +113,7 @@ Error PDBFile::setBlockData(uint32_t BlockIndex, uint32_t Offset, } Error PDBFile::parseFileHeaders() { - BinaryStreamReader Reader(*Buffer); + StreamReader Reader(*Buffer); // Initialize SB. const msf::SuperBlock *SB = nullptr; @@ -150,7 +147,7 @@ Error PDBFile::parseFileHeaders() { // See the function fpmPn() for more information: // https://github.com/Microsoft/microsoft-pdb/blob/master/PDB/msf/msf.cpp#L489 auto FpmStream = MappedBlockStream::createFpmStream(ContainerLayout, *Buffer); - BinaryStreamReader FpmReader(*FpmStream); + StreamReader FpmReader(*FpmStream); ArrayRef FpmBytes; if (auto EC = FpmReader.readBytes(FpmBytes, msf::getFullFpmByteSize(ContainerLayout))) @@ -188,8 +185,8 @@ Error PDBFile::parseStreamData() { // subclass of IPDBStreamData which only accesses the fields that have already // been parsed, we can avoid this and reuse MappedBlockStream. auto DS = MappedBlockStream::createDirectoryStream(ContainerLayout, *Buffer); - BinaryStreamReader Reader(*DS); - if (auto EC = Reader.readInteger(NumStreams)) + StreamReader Reader(*DS); + if (auto EC = Reader.readInteger(NumStreams, llvm::support::little)) return EC; if (auto EC = Reader.readArray(ContainerLayout.StreamSizes, NumStreams)) @@ -353,7 +350,7 @@ Expected PDBFile::getStringTable() { if (!NS) return NS.takeError(); - BinaryStreamReader Reader(**NS); + StreamReader Reader(**NS); auto N = llvm::make_unique(); if (auto EC = N->load(Reader)) return std::move(EC); @@ -406,7 +403,7 @@ bool PDBFile::hasStringTable() { /// contain the stream returned by createIndexedStream(). Expected> PDBFile::safelyCreateIndexedStream(const MSFLayout &Layout, - BinaryStreamRef MsfData, + const ReadableStream &MsfData, uint32_t StreamIndex) const { if (StreamIndex >= getNumStreams()) return make_error(raw_error_code::no_stream); diff --git a/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp b/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp index 298382fdc7d..fde61ddc650 100644 --- a/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp +++ b/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp @@ -12,8 +12,6 @@ #include "llvm/ADT/BitVector.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" #include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" #include "llvm/DebugInfo/MSF/MSFBuilder.h" #include "llvm/DebugInfo/PDB/GenericError.h" @@ -120,9 +118,8 @@ Error PDBFileBuilder::commit(StringRef Filename) { if (OutFileOrError.getError()) return llvm::make_error(generic_error_code::invalid_path, Filename); - FileBufferByteStream Buffer(std::move(*OutFileOrError), - llvm::support::little); - BinaryStreamWriter Writer(Buffer); + FileBufferByteStream Buffer(std::move(*OutFileOrError)); + StreamWriter Writer(Buffer); if (auto EC = Writer.writeObject(*Layout.SB)) return EC; @@ -134,8 +131,9 @@ Error PDBFileBuilder::commit(StringRef Filename) { auto DirStream = WritableMappedBlockStream::createDirectoryStream(Layout, Buffer); - BinaryStreamWriter DW(*DirStream); - if (auto EC = DW.writeInteger(Layout.StreamSizes.size())) + StreamWriter DW(*DirStream); + if (auto EC = DW.writeInteger(Layout.StreamSizes.size(), + llvm::support::little)) return EC; if (auto EC = DW.writeArray(Layout.StreamSizes)) @@ -152,7 +150,7 @@ Error PDBFileBuilder::commit(StringRef Filename) { auto NS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StringTableStreamNo); - BinaryStreamWriter NSWriter(*NS); + StreamWriter NSWriter(*NS); if (auto EC = Strings.commit(NSWriter)) return EC; diff --git a/lib/DebugInfo/PDB/Native/PublicsStream.cpp b/lib/DebugInfo/PDB/Native/PublicsStream.cpp index fe85a329a58..57b77b8254d 100644 --- a/lib/DebugInfo/PDB/Native/PublicsStream.cpp +++ b/lib/DebugInfo/PDB/Native/PublicsStream.cpp @@ -27,7 +27,6 @@ #include "llvm/ADT/iterator_range.h" #include "llvm/DebugInfo/CodeView/SymbolRecord.h" #include "llvm/DebugInfo/MSF/BinaryStreamReader.h" -#include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" #include "llvm/DebugInfo/PDB/Native/PDBFile.h" #include "llvm/DebugInfo/PDB/Native/RawError.h" @@ -70,7 +69,7 @@ uint32_t PublicsStream::getAddrMap() const { return Header->AddrMap; } // we skip over the hash table which we believe contains information about // public symbols. Error PublicsStream::reload() { - BinaryStreamReader Reader(*Stream); + StreamReader Reader(*Stream); // Check stream size. if (Reader.bytesRemaining() < sizeof(HeaderInfo) + sizeof(GSIHashHeader)) diff --git a/lib/DebugInfo/PDB/Native/StringTable.cpp b/lib/DebugInfo/PDB/Native/StringTable.cpp index 79a78c92598..c81bff48191 100644 --- a/lib/DebugInfo/PDB/Native/StringTable.cpp +++ b/lib/DebugInfo/PDB/Native/StringTable.cpp @@ -17,12 +17,13 @@ #include "llvm/Support/Endian.h" using namespace llvm; +using namespace llvm::msf; using namespace llvm::support; using namespace llvm::pdb; StringTable::StringTable() : Signature(0), HashVersion(0), NameCount(0) {} -Error StringTable::load(BinaryStreamReader &Stream) { +Error StringTable::load(StreamReader &Stream) { const StringTableHeader *H; if (auto EC = Stream.readObject(H)) return EC; @@ -54,7 +55,7 @@ Error StringTable::load(BinaryStreamReader &Stream) { return make_error(raw_error_code::corrupt_file, "Missing name count"); - if (auto EC = Stream.readInteger(NameCount)) + if (auto EC = Stream.readInteger(NameCount, llvm::support::little)) return EC; return Error::success(); } @@ -67,9 +68,9 @@ StringRef StringTable::getStringForID(uint32_t ID) const { // the starting offset of the string we're looking for. So just seek into // the desired offset and a read a null terminated stream from that offset. StringRef Result; - BinaryStreamReader NameReader(NamesBuffer); + StreamReader NameReader(NamesBuffer); NameReader.setOffset(ID); - if (auto EC = NameReader.readCString(Result)) + if (auto EC = NameReader.readZeroString(Result)) consumeError(std::move(EC)); return Result; } diff --git a/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp b/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp index 9df97c9753e..8fad775ecdc 100644 --- a/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp +++ b/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp @@ -52,7 +52,7 @@ uint32_t StringTableBuilder::finalize() { return Size; } -Error StringTableBuilder::commit(BinaryStreamWriter &Writer) const { +Error StringTableBuilder::commit(msf::StreamWriter &Writer) const { // Write a header StringTableHeader H; H.Signature = StringTableSignature; @@ -67,14 +67,14 @@ Error StringTableBuilder::commit(BinaryStreamWriter &Writer) const { StringRef S = Pair.first; uint32_t Offset = Pair.second; Writer.setOffset(StringStart + Offset); - if (auto EC = Writer.writeCString(S)) + if (auto EC = Writer.writeZeroString(S)) return EC; } Writer.setOffset(StringStart + StringSize); // Write a hash table. uint32_t BucketCount = computeBucketCount(Strings.size()); - if (auto EC = Writer.writeInteger(BucketCount)) + if (auto EC = Writer.writeInteger(BucketCount, llvm::support::little)) return EC; std::vector Buckets(BucketCount); @@ -96,7 +96,8 @@ Error StringTableBuilder::commit(BinaryStreamWriter &Writer) const { if (auto EC = Writer.writeArray(ArrayRef(Buckets))) return EC; - if (auto EC = Writer.writeInteger(static_cast(Strings.size()))) + if (auto EC = Writer.writeInteger(static_cast(Strings.size()), + llvm::support::little)) return EC; return Error::success(); } diff --git a/lib/DebugInfo/PDB/Native/SymbolStream.cpp b/lib/DebugInfo/PDB/Native/SymbolStream.cpp index e0b8924c306..3f0e07a99e1 100644 --- a/lib/DebugInfo/PDB/Native/SymbolStream.cpp +++ b/lib/DebugInfo/PDB/Native/SymbolStream.cpp @@ -17,7 +17,6 @@ #include "llvm/DebugInfo/PDB/Native/RawConstants.h" #include "llvm/DebugInfo/PDB/Native/RawError.h" -#include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/Support/Endian.h" using namespace llvm; @@ -31,7 +30,7 @@ SymbolStream::SymbolStream(std::unique_ptr Stream) SymbolStream::~SymbolStream() {} Error SymbolStream::reload() { - BinaryStreamReader Reader(*Stream); + StreamReader Reader(*Stream); if (auto EC = Reader.readArray(SymbolRecords, Stream->getLength())) return EC; diff --git a/lib/DebugInfo/PDB/Native/TpiStream.cpp b/lib/DebugInfo/PDB/Native/TpiStream.cpp index 954374ca4df..8f9dd0a793b 100644 --- a/lib/DebugInfo/PDB/Native/TpiStream.cpp +++ b/lib/DebugInfo/PDB/Native/TpiStream.cpp @@ -14,7 +14,6 @@ #include "llvm/DebugInfo/CodeView/TypeRecord.h" #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h" #include "llvm/DebugInfo/MSF/BinaryStreamReader.h" -#include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" #include "llvm/DebugInfo/PDB/Native/PDBFile.h" #include "llvm/DebugInfo/PDB/Native/PDBTypeServerHandler.h" @@ -55,7 +54,7 @@ Error TpiStream::verifyHashValues() { } Error TpiStream::reload() { - BinaryStreamReader Reader(*Stream); + StreamReader Reader(*Stream); if (Reader.bytesRemaining() < sizeof(TpiStreamHeader)) return make_error(raw_error_code::corrupt_file, @@ -94,7 +93,7 @@ Error TpiStream::reload() { auto HS = MappedBlockStream::createIndexedStream( Pdb.getMsfLayout(), Pdb.getMsfBuffer(), Header->HashStreamIndex); - BinaryStreamReader HSR(*HS); + StreamReader HSR(*HS); uint32_t NumHashValues = Header->HashValueBuffer.Length / sizeof(ulittle32_t); diff --git a/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp b/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp index 7d532ee56d8..29c1ec00fc7 100644 --- a/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp +++ b/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp @@ -34,8 +34,7 @@ using namespace llvm::pdb; using namespace llvm::support; TpiStreamBuilder::TpiStreamBuilder(MSFBuilder &Msf, uint32_t StreamIdx) - : Msf(Msf), Allocator(Msf.getAllocator()), - TypeRecordStream(llvm::support::little), Header(nullptr), Idx(StreamIdx) { + : Msf(Msf), Allocator(Msf.getAllocator()), Header(nullptr), Idx(StreamIdx) { } TpiStreamBuilder::~TpiStreamBuilder() = default; @@ -83,7 +82,7 @@ Error TpiStreamBuilder::finalize() { return Error::success(); } -uint32_t TpiStreamBuilder::calculateSerializedLength() { +uint32_t TpiStreamBuilder::calculateSerializedLength() const { return sizeof(TpiStreamHeader) + TypeRecordStream.getLength(); } @@ -114,20 +113,19 @@ Error TpiStreamBuilder::finalizeMsfLayout() { } ArrayRef Bytes(reinterpret_cast(HashBuffer.data()), HashBufferSize); - HashValueStream = - llvm::make_unique(Bytes, llvm::support::little); + HashValueStream = llvm::make_unique(Bytes); return Error::success(); } Error TpiStreamBuilder::commit(const msf::MSFLayout &Layout, - WritableBinaryStreamRef Buffer) { + const msf::WritableStream &Buffer) { if (auto EC = finalize()) return EC; auto InfoS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, Idx); - BinaryStreamWriter Writer(*InfoS); + StreamWriter Writer(*InfoS); if (auto EC = Writer.writeObject(*Header)) return EC; @@ -138,7 +136,7 @@ Error TpiStreamBuilder::commit(const msf::MSFLayout &Layout, if (HashStreamIndex != kInvalidStreamIndex) { auto HVS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, HashStreamIndex); - BinaryStreamWriter HW(*HVS); + StreamWriter HW(*HVS); if (auto EC = HW.writeStreamRef(*HashValueStream)) return EC; } diff --git a/tools/llvm-pdbdump/LLVMOutputStyle.cpp b/tools/llvm-pdbdump/LLVMOutputStyle.cpp index 11c566facb3..1843a3c9e0f 100644 --- a/tools/llvm-pdbdump/LLVMOutputStyle.cpp +++ b/tools/llvm-pdbdump/LLVMOutputStyle.cpp @@ -22,7 +22,6 @@ #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h" #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h" #include "llvm/DebugInfo/MSF/BinaryStreamReader.h" -#include "llvm/DebugInfo/MSF/BinaryStreamReader.h" #include "llvm/DebugInfo/MSF/MappedBlockStream.h" #include "llvm/DebugInfo/PDB/Native/DbiStream.h" #include "llvm/DebugInfo/PDB/Native/EnumTables.h" @@ -451,7 +450,7 @@ Error LLVMOutputStyle::dumpStreamBytes() { auto Blocks = File.getMsfLayout().StreamMap[SI]; P.printList("Blocks", Blocks); - BinaryStreamReader R(*S); + StreamReader R(*S); ArrayRef StreamData; if (auto EC = R.readBytes(StreamData, S->getLength())) return EC; @@ -746,10 +745,10 @@ Error LLVMOutputStyle::dumpDbiStream() { public: RecordVisitor(ScopedPrinter &P, PDBFile &F) : P(P), F(F) {} Error visitUnknown(ModuleSubstreamKind Kind, - BinaryStreamRef Stream) override { + ReadableStreamRef Stream) override { DictScope DD(P, "Unknown"); ArrayRef Data; - BinaryStreamReader R(Stream); + StreamReader R(Stream); if (auto EC = R.readBytes(Data, R.bytesRemaining())) { return make_error( raw_error_code::corrupt_file, @@ -759,7 +758,7 @@ Error LLVMOutputStyle::dumpDbiStream() { return Error::success(); } Error - visitFileChecksums(BinaryStreamRef Data, + visitFileChecksums(ReadableStreamRef Data, const FileChecksumArray &Checksums) override { DictScope DD(P, "FileChecksums"); for (const auto &C : Checksums) { @@ -775,7 +774,7 @@ Error LLVMOutputStyle::dumpDbiStream() { return Error::success(); } - Error visitLines(BinaryStreamRef Data, + Error visitLines(ReadableStreamRef Data, const LineSubstreamHeader *Header, const LineInfoArray &Lines) override { DictScope DD(P, "Lines"); diff --git a/tools/llvm-pdbdump/YamlTypeDumper.cpp b/tools/llvm-pdbdump/YamlTypeDumper.cpp index e2b901be868..80bf9349b0c 100644 --- a/tools/llvm-pdbdump/YamlTypeDumper.cpp +++ b/tools/llvm-pdbdump/YamlTypeDumper.cpp @@ -573,8 +573,8 @@ struct MappingContextTraitsgetCOFFSection(SR); } - uint32_t getRecordOffset(BinaryStreamReader Reader) override { + uint32_t getRecordOffset(msf::StreamReader Reader) override { ArrayRef Data; if (auto EC = Reader.readLongestContiguousChunk(Data)) { llvm::consumeError(std::move(EC)); @@ -840,13 +841,13 @@ void COFFDumper::printCodeViewSymbolSection(StringRef SectionName, } case ModuleSubstreamKind::FrameData: { // First four bytes is a relocation against the function. - BinaryByteStream S(Contents, llvm::support::little); - BinaryStreamReader SR(S); - StringRef CodePtr; - error(SR.readFixedString(CodePtr, 4)); + msf::ByteStream S(Contents); + msf::StreamReader SR(S); + const uint32_t *CodePtr; + error(SR.readObject(CodePtr)); StringRef LinkageName; error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents, - CodePtr.data(), LinkageName)); + CodePtr, LinkageName)); W.printString("LinkageName", LinkageName); // To find the active frame description, search this array for the @@ -965,9 +966,9 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, CVSymbolDumper CVSD(W, TypeDB, std::move(CODD), opts::CodeViewSubsectionBytes); - BinaryByteStream Stream(BinaryData, llvm::support::little); + ByteStream Stream(BinaryData); CVSymbolArray Symbols; - BinaryStreamReader Reader(Stream); + StreamReader Reader(Stream); if (auto EC = Reader.readArray(Symbols, Reader.getLength())) { consumeError(std::move(EC)); W.flush(); @@ -982,8 +983,8 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, } void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) { - BinaryByteStream S(Subsection, llvm::support::little); - BinaryStreamReader SR(S); + msf::ByteStream S(Subsection); + msf::StreamReader SR(S); while (!SR.empty()) { DictScope S(W, "FileChecksum"); const FileChecksum *FC; @@ -1011,10 +1012,10 @@ void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) { } void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) { - BinaryByteStream S(Subsection, llvm::support::little); - BinaryStreamReader SR(S); + msf::ByteStream S(Subsection); + msf::StreamReader SR(S); uint32_t Signature; - error(SR.readInteger(Signature)); + error(SR.readInteger(Signature, llvm::support::little)); bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles); while (!SR.empty()) { @@ -1027,12 +1028,12 @@ void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) { if (HasExtraFiles) { uint32_t ExtraFileCount; - error(SR.readInteger(ExtraFileCount)); + error(SR.readInteger(ExtraFileCount, llvm::support::little)); W.printNumber("ExtraFileCount", ExtraFileCount); ListScope ExtraFiles(W, "ExtraFiles"); for (unsigned I = 0; I < ExtraFileCount; ++I) { uint32_t FileID; - error(SR.readInteger(FileID)); + error(SR.readInteger(FileID, llvm::support::little)); printFileNameForOffset("FileID", FileID); } } @@ -1077,9 +1078,9 @@ void COFFDumper::mergeCodeViewTypes(TypeTableBuilder &CVTypes) { error(object_error::parse_failed); ArrayRef Bytes(reinterpret_cast(Data.data()), Data.size()); - BinaryByteStream Stream(Bytes, llvm::support::little); + ByteStream Stream(Bytes); CVTypeArray Types; - BinaryStreamReader Reader(Stream); + StreamReader Reader(Stream); if (auto EC = Reader.readArray(Types, Reader.getLength())) { consumeError(std::move(EC)); W.flush(); diff --git a/unittests/DebugInfo/PDB/BinaryStreamTest.cpp b/unittests/DebugInfo/PDB/BinaryStreamTest.cpp deleted file mode 100644 index e9e8ab8c973..00000000000 --- a/unittests/DebugInfo/PDB/BinaryStreamTest.cpp +++ /dev/null @@ -1,758 +0,0 @@ -//===- llvm/unittest/Support/BinaryStreamTest.cpp -------------------------===// -// -// 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/BinaryByteStream.h" -#include "llvm/DebugInfo/MSF/BinaryItemStream.h" -#include "llvm/DebugInfo/MSF/BinaryStreamArray.h" -#include "llvm/DebugInfo/MSF/BinaryStreamReader.h" -#include "llvm/DebugInfo/MSF/BinaryStreamRef.h" -#include "llvm/DebugInfo/MSF/BinaryStreamWriter.h" -#include "gtest/gtest.h" - -#include - -using namespace llvm; -using namespace llvm::support; - -#define EXPECT_NO_ERROR(Err) \ - { \ - auto E = Err; \ - EXPECT_FALSE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define ASSERT_NO_ERROR(Err) \ - { \ - auto E = Err; \ - ASSERT_FALSE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define EXPECT_ERROR(Err) \ - { \ - auto E = Err; \ - EXPECT_TRUE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -namespace { - -class DiscontiguousStream : public WritableBinaryStream { -public: - explicit DiscontiguousStream(uint32_t Size = 0) : PartitionIndex(Size / 2) { - Data.resize(Size); - } - - endianness getEndian() const override { return little; } - - Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override { - if (Offset + Size > Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); - uint32_t S = startIndex(Offset); - auto Ref = makeArrayRef(Data).drop_front(S); - if (Ref.size() >= Size) { - Buffer = Ref.take_front(Size); - return Error::success(); - } - - uint32_t BytesLeft = Size - Ref.size(); - uint8_t *Ptr = Allocator.Allocate(Size); - ::memcpy(Ptr, Ref.data(), Ref.size()); - ::memcpy(Ptr + Ref.size(), Data.data(), BytesLeft); - Buffer = makeArrayRef(Ptr, Size); - return Error::success(); - } - - Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override { - if (Offset >= Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); - uint32_t S = startIndex(Offset); - Buffer = makeArrayRef(Data).drop_front(S); - return Error::success(); - } - - uint32_t getLength() override { return Data.size(); } - - Error writeBytes(uint32_t Offset, ArrayRef SrcData) override { - if (Offset + SrcData.size() > Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); - if (SrcData.empty()) - return Error::success(); - - uint32_t S = startIndex(Offset); - MutableArrayRef Ref(Data); - Ref = Ref.drop_front(S); - if (Ref.size() >= SrcData.size()) { - ::memcpy(Ref.data(), SrcData.data(), SrcData.size()); - return Error::success(); - } - - uint32_t BytesLeft = SrcData.size() - Ref.size(); - ::memcpy(Ref.data(), SrcData.data(), Ref.size()); - ::memcpy(&Data[0], SrcData.data() + Ref.size(), BytesLeft); - return Error::success(); - } - Error commit() override { return Error::success(); } - -private: - uint32_t startIndex(uint32_t Offset) const { - return (Offset + PartitionIndex) % Data.size(); - } - - uint32_t endIndex(uint32_t Offset, uint32_t Size) const { - return (startIndex(Offset) + Size - 1) % Data.size(); - } - - uint32_t PartitionIndex = 0; - // Buffer is organized like this: - // ------------------------------------------------- - // | N/2 | N/2+1 | ... | N-1 | 0 | 1 | ... | N-2-1 | - // ------------------------------------------------- - // So reads from the beginning actually come from the middle. - std::vector Data; - BumpPtrAllocator Allocator; -}; - -class BinaryStreamTest : public testing::Test { -public: - BinaryStreamTest() {} - - void SetUp() override { - InputData.clear(); - OutputData.clear(); - InputByteStream = BinaryByteStream(); - InputBrokenStream = DiscontiguousStream(); - OutputByteStream = MutableBinaryByteStream(); - OutputBrokenStream = DiscontiguousStream(); - } - -protected: - void initialize(ArrayRef Input, uint32_t OutputSize) { - InputData = Input; - - InputByteStream = BinaryByteStream(InputData, little); - InputBrokenStream = DiscontiguousStream(InputData.size()); - consumeError(InputBrokenStream.writeBytes(0, Input)); - - OutputData.resize(OutputSize); - OutputByteStream = MutableBinaryByteStream(OutputData, little); - OutputBrokenStream = DiscontiguousStream(OutputSize); - - InputStreams.push_back(&InputByteStream); - InputStreams.push_back(&InputBrokenStream); - OutputStreams.push_back(&OutputByteStream); - OutputStreams.push_back(&OutputBrokenStream); - } - - void initialize(uint32_t OutputSize) { - OutputData.resize(OutputSize); - OutputByteStream = MutableBinaryByteStream(OutputData, little); - OutputBrokenStream = DiscontiguousStream(OutputSize); - OutputStreams.push_back(&OutputByteStream); - OutputStreams.push_back(&OutputBrokenStream); - - InputByteStream = BinaryByteStream(OutputData, little); - InputBrokenStream = DiscontiguousStream(OutputData.size()); - } - - std::vector InputData; - std::vector OutputData; - - BinaryByteStream InputByteStream; - DiscontiguousStream InputBrokenStream; - - MutableBinaryByteStream OutputByteStream; - DiscontiguousStream OutputBrokenStream; - - std::vector InputStreams; - std::vector OutputStreams; -}; - -// Tests that a we can read from a BinaryByteStream without a StreamReader. -TEST_F(BinaryStreamTest, BinaryByteStreamProperties) { - std::vector InputData = {1, 2, 3, 4, 5}; - initialize(InputData, InputData.size()); - - for (auto Stream : InputStreams) { - ArrayRef Buffer; - - // 1. If the read fits it should work. - ASSERT_EQ(InputData.size(), Stream->getLength()); - ASSERT_NO_ERROR(Stream->readBytes(2, 1, Buffer)); - EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer); - ASSERT_NO_ERROR(Stream->readBytes(0, 4, Buffer)); - EXPECT_EQ(makeArrayRef(InputData).slice(0, 4), Buffer); - - // 2. Reading past the bounds of the input should fail. - EXPECT_ERROR(Stream->readBytes(4, 2, Buffer)); - } -} - -// Test that we can write to a BinaryStream without a StreamWriter. -TEST_F(BinaryStreamTest, MutableBinaryByteStreamProperties) { - std::vector InputData = {'T', 'e', 's', 't', '\0'}; - initialize(InputData, InputData.size()); - ASSERT_EQ(2U, InputStreams.size()); - ASSERT_EQ(2U, OutputStreams.size()); - - // For every combination of input stream and output stream. - for (auto IS : InputStreams) { - MutableArrayRef Buffer; - ASSERT_EQ(InputData.size(), IS->getLength()); - - for (auto OS : OutputStreams) { - - // 1. Try two reads that are supposed to work. One from offset 0, and one - // from the middle. - uint32_t Offsets[] = {0, 3}; - for (auto Offset : Offsets) { - uint32_t ExpectedSize = IS->getLength() - Offset; - - // Read everything from Offset until the end of the input data. - ArrayRef Data; - ASSERT_NO_ERROR(IS->readBytes(Offset, ExpectedSize, Data)); - ASSERT_EQ(ExpectedSize, Data.size()); - - // Then write it to the destination. - ASSERT_NO_ERROR(OS->writeBytes(0, Data)); - - // Then we read back what we wrote, it should match the corresponding - // slice - // of the original input data. - ArrayRef Data2; - ASSERT_NO_ERROR(OS->readBytes(Offset, ExpectedSize, Data2)); - EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2); - } - - std::vector BigData = {0, 1, 2, 3, 4}; - // 2. If the write is too big, it should fail. - EXPECT_ERROR(OS->writeBytes(3, BigData)); - } - } -} - -// Test that FixedStreamArray works correctly. -TEST_F(BinaryStreamTest, FixedStreamArray) { - std::vector Ints = {90823, 12908, 109823, 209823}; - ArrayRef IntBytes(reinterpret_cast(Ints.data()), - Ints.size() * sizeof(uint32_t)); - - initialize(IntBytes, 0); - ASSERT_EQ(2U, InputStreams.size()); - - for (auto IS : InputStreams) { - MutableArrayRef Buffer; - ASSERT_EQ(InputData.size(), IS->getLength()); - - FixedStreamArray Array(*IS); - auto Iter = Array.begin(); - ASSERT_EQ(Ints[0], *Iter++); - ASSERT_EQ(Ints[1], *Iter++); - ASSERT_EQ(Ints[2], *Iter++); - ASSERT_EQ(Ints[3], *Iter++); - ASSERT_EQ(Array.end(), Iter); - } -} - -// Test that VarStreamArray works correctly. -TEST_F(BinaryStreamTest, VarStreamArray) { - StringLiteral Strings("1. Test2. Longer Test3. Really Long Test4. Super " - "Extra Longest Test Of All"); - ArrayRef StringBytes( - reinterpret_cast(Strings.data()), Strings.size()); - initialize(StringBytes, 0); - - struct StringExtractor { - public: - Error operator()(BinaryStreamRef Stream, uint32_t &Len, StringRef &Item) { - if (Index == 0) - Len = strlen("1. Test"); - else if (Index == 1) - Len = strlen("2. Longer Test"); - else if (Index == 2) - Len = strlen("3. Really Long Test"); - else - Len = strlen("4. Super Extra Longest Test Of All"); - ArrayRef Bytes; - if (auto EC = Stream.readBytes(0, Len, Bytes)) - return EC; - Item = - StringRef(reinterpret_cast(Bytes.data()), Bytes.size()); - ++Index; - return Error::success(); - } - - private: - uint32_t Index = 0; - }; - - for (auto IS : InputStreams) { - VarStreamArray Array(*IS); - auto Iter = Array.begin(); - ASSERT_EQ("1. Test", *Iter++); - ASSERT_EQ("2. Longer Test", *Iter++); - ASSERT_EQ("3. Really Long Test", *Iter++); - ASSERT_EQ("4. Super Extra Longest Test Of All", *Iter++); - ASSERT_EQ(Array.end(), Iter); - } -} - -TEST_F(BinaryStreamTest, StreamReaderBounds) { - std::vector Bytes; - - initialize(Bytes, 0); - for (auto IS : InputStreams) { - StringRef S; - BinaryStreamReader Reader(*IS); - EXPECT_EQ(0U, Reader.bytesRemaining()); - EXPECT_ERROR(Reader.readFixedString(S, 1)); - } - - Bytes.resize(5); - initialize(Bytes, 0); - for (auto IS : InputStreams) { - StringRef S; - BinaryStreamReader Reader(*IS); - EXPECT_EQ(Bytes.size(), Reader.bytesRemaining()); - EXPECT_NO_ERROR(Reader.readFixedString(S, 5)); - EXPECT_ERROR(Reader.readFixedString(S, 6)); - } -} - -TEST_F(BinaryStreamTest, DISABLED_StreamReaderIntegers) { - support::ulittle64_t Little{908234}; - support::ubig32_t Big{28907823}; - short NS = 2897; - int NI = -89723; - unsigned long NUL = 902309023UL; - constexpr uint32_t Size = - sizeof(Little) + sizeof(Big) + sizeof(NS) + sizeof(NI) + sizeof(NUL); - std::vector Bytes(Size); - uint8_t *Ptr = &Bytes[0]; - memcpy(Ptr, &Little, sizeof(Little)); - Ptr += sizeof(Little); - memcpy(Ptr, &Big, sizeof(Big)); - Ptr += sizeof(Big); - memcpy(Ptr, &NS, sizeof(NS)); - Ptr += sizeof(NS); - memcpy(Ptr, &NI, sizeof(NI)); - Ptr += sizeof(NI); - memcpy(Ptr, &NUL, sizeof(NUL)); - Ptr += sizeof(NUL); - - initialize(Bytes, 0); - for (auto IS : InputStreams) { - const support::ulittle64_t *Little2; - const support::ubig32_t *Big2; - short NS2; - int NI2; - unsigned long NUL2; - - // 1. Reading fields individually. - BinaryStreamReader Reader(*IS); - ASSERT_NO_ERROR(Reader.readObject(Little2)); - ASSERT_NO_ERROR(Reader.readObject(Big2)); - ASSERT_NO_ERROR(Reader.readInteger(NS2)); - ASSERT_NO_ERROR(Reader.readInteger(NI2)); - ASSERT_NO_ERROR(Reader.readInteger(NUL2)); - ASSERT_EQ(0U, Reader.bytesRemaining()); - - EXPECT_EQ(Little, *Little2); - EXPECT_EQ(Big, *Big2); - EXPECT_EQ(NS, NS2); - EXPECT_EQ(NI, NI2); - EXPECT_EQ(NUL, NUL2); - - // 2. Reading with explicit endianness. - Reader.setOffset(0); - const ulittle64_t *Little3; - const ubig32_t *Big3; - ASSERT_NO_ERROR(Reader.readObject(Little3)); - ASSERT_NO_ERROR(Reader.readObject(Big3)); - EXPECT_EQ(Little, *Little3); - EXPECT_EQ(Big, *Big3); - } -} - -TEST_F(BinaryStreamTest, StreamReaderIntegerArray) { - // 1. Arrays of integers - std::vector Ints = {1, 2, 3, 4, 5}; - ArrayRef IntBytes(reinterpret_cast(&Ints[0]), - Ints.size() * sizeof(int)); - initialize(IntBytes, 0); - for (auto IS : InputStreams) { - BinaryStreamReader Reader(*IS); - ArrayRef IntsRef; - ASSERT_NO_ERROR(Reader.readArray(IntsRef, Ints.size())); - ASSERT_EQ(0U, Reader.bytesRemaining()); - EXPECT_EQ(makeArrayRef(Ints), IntsRef); - - Reader.setOffset(0); - FixedStreamArray FixedIntsRef; - ASSERT_NO_ERROR(Reader.readArray(FixedIntsRef, Ints.size())); - ASSERT_EQ(0U, Reader.bytesRemaining()); - ASSERT_EQ(Ints, std::vector(FixedIntsRef.begin(), FixedIntsRef.end())); - } -} - -TEST_F(BinaryStreamTest, DISABLED_StreamReaderEnum) { - enum class MyEnum : int64_t { Foo = -10, Bar = 0, Baz = 10 }; - - std::vector Enums = {MyEnum::Bar, MyEnum::Baz, MyEnum::Foo}; - - ArrayRef Bytes(reinterpret_cast(&Enums[0]), - sizeof(MyEnum) * Enums.size()); - - initialize(Bytes, 0); - for (auto IS : InputStreams) { - BinaryStreamReader Reader(*IS); - - MyEnum V1; - MyEnum V2; - MyEnum V3; - ArrayRef Array; - FixedStreamArray FSA; - - ASSERT_NO_ERROR(Reader.readEnum(V1)); - ASSERT_NO_ERROR(Reader.readEnum(V2)); - ASSERT_NO_ERROR(Reader.readEnum(V3)); - ASSERT_EQ(0U, Reader.bytesRemaining()); - - EXPECT_EQ(MyEnum::Bar, V1); - EXPECT_EQ(MyEnum::Baz, V2); - EXPECT_EQ(MyEnum::Foo, V3); - - Reader.setOffset(0); - ASSERT_NO_ERROR(Reader.readArray(Array, 3)); - EXPECT_EQ(makeArrayRef(Enums), Array); - - Reader.setOffset(0); - ASSERT_NO_ERROR(Reader.readArray(FSA, 3)); - EXPECT_EQ(Enums, std::vector(FSA.begin(), FSA.end())); - } -} - -TEST_F(BinaryStreamTest, StreamReaderObject) { - struct Foo { - int X; - double Y; - char Z; - }; - - std::vector Foos; - Foos.push_back({-42, 42.42, 42}); - Foos.push_back({100, 3.1415, static_cast(-89)}); - - const uint8_t *Bytes = reinterpret_cast(&Foos[0]); - - initialize(makeArrayRef(Bytes, 2 * sizeof(Foo)), 0); - - for (auto IS : InputStreams) { - // 1. Reading object pointers. - BinaryStreamReader Reader(*IS); - const Foo *FPtrOut = nullptr; - const Foo *GPtrOut = nullptr; - ASSERT_NO_ERROR(Reader.readObject(FPtrOut)); - ASSERT_NO_ERROR(Reader.readObject(GPtrOut)); - EXPECT_EQ(0U, Reader.bytesRemaining()); - EXPECT_EQ(0, ::memcmp(&Foos[0], FPtrOut, sizeof(Foo))); - EXPECT_EQ(0, ::memcmp(&Foos[1], GPtrOut, sizeof(Foo))); - } -} - -TEST_F(BinaryStreamTest, StreamReaderStrings) { - std::vector Bytes = {'O', 'n', 'e', '\0', 'T', 'w', 'o', - '\0', 'T', 'h', 'r', 'e', 'e', '\0', - 'F', 'o', 'u', 'r', '\0'}; - initialize(Bytes, 0); - - for (auto IS : InputStreams) { - BinaryStreamReader Reader(*IS); - - StringRef S1; - StringRef S2; - StringRef S3; - StringRef S4; - ASSERT_NO_ERROR(Reader.readCString(S1)); - ASSERT_NO_ERROR(Reader.readCString(S2)); - ASSERT_NO_ERROR(Reader.readCString(S3)); - ASSERT_NO_ERROR(Reader.readCString(S4)); - ASSERT_EQ(0U, Reader.bytesRemaining()); - - EXPECT_EQ("One", S1); - EXPECT_EQ("Two", S2); - EXPECT_EQ("Three", S3); - EXPECT_EQ("Four", S4); - - S1 = S2 = S3 = S4 = ""; - Reader.setOffset(0); - ASSERT_NO_ERROR(Reader.readFixedString(S1, 3)); - ASSERT_NO_ERROR(Reader.skip(1)); - ASSERT_NO_ERROR(Reader.readFixedString(S2, 3)); - ASSERT_NO_ERROR(Reader.skip(1)); - ASSERT_NO_ERROR(Reader.readFixedString(S3, 5)); - ASSERT_NO_ERROR(Reader.skip(1)); - ASSERT_NO_ERROR(Reader.readFixedString(S4, 4)); - ASSERT_NO_ERROR(Reader.skip(1)); - ASSERT_EQ(0U, Reader.bytesRemaining()); - - EXPECT_EQ("One", S1); - EXPECT_EQ("Two", S2); - EXPECT_EQ("Three", S3); - EXPECT_EQ("Four", S4); - } -} - -TEST_F(BinaryStreamTest, StreamWriterBounds) { - initialize(5); - - for (auto OS : OutputStreams) { - BinaryStreamWriter Writer(*OS); - - // 1. Can write a string that exactly fills the buffer. - EXPECT_EQ(5U, Writer.bytesRemaining()); - EXPECT_NO_ERROR(Writer.writeFixedString("abcde")); - EXPECT_EQ(0U, Writer.bytesRemaining()); - - // 2. Can write an empty string even when you're full - EXPECT_NO_ERROR(Writer.writeFixedString("")); - EXPECT_ERROR(Writer.writeFixedString("a")); - - // 3. Can't write a string that is one character too long. - Writer.setOffset(0); - EXPECT_ERROR(Writer.writeFixedString("abcdef")); - } -} - -TEST_F(BinaryStreamTest, StreamWriterIntegers) { - support::ulittle64_t Little{908234}; - support::ubig32_t Big{28907823}; - short NS = 2897; - int NI = -89723; - unsigned long NUL = 902309023UL; - constexpr uint32_t Size = - sizeof(Little) + sizeof(Big) + sizeof(NS) + sizeof(NI) + sizeof(NUL); - - initialize(Size); - - for (auto OS : OutputStreams) { - BinaryStreamWriter Writer(*OS); - - // 1. Writing fields individually. - ASSERT_NO_ERROR(Writer.writeObject(Little)); - ASSERT_NO_ERROR(Writer.writeObject(Big)); - ASSERT_NO_ERROR(Writer.writeInteger(NS)); - ASSERT_NO_ERROR(Writer.writeInteger(NI)); - ASSERT_NO_ERROR(Writer.writeInteger(NUL)); - ASSERT_EQ(0U, Writer.bytesRemaining()); - - // Read them back in and confirm they're correct. - const ulittle64_t *Little2; - const ubig32_t *Big2; - short NS2; - int NI2; - unsigned long NUL2; - BinaryStreamReader Reader(*OS); - ASSERT_NO_ERROR(Reader.readObject(Little2)); - ASSERT_NO_ERROR(Reader.readObject(Big2)); - ASSERT_NO_ERROR(Reader.readInteger(NS2)); - ASSERT_NO_ERROR(Reader.readInteger(NI2)); - ASSERT_NO_ERROR(Reader.readInteger(NUL2)); - EXPECT_EQ(Little, *Little2); - EXPECT_EQ(Big, *Big2); - EXPECT_EQ(NS, NS2); - EXPECT_EQ(NI, NI2); - EXPECT_EQ(NUL, NUL2); - } -} - -TEST_F(BinaryStreamTest, StreamWriterIntegerArrays) { - // 3. Arrays of integers - std::vector SourceInts = {1, 2, 3, 4, 5}; - ArrayRef SourceBytes(reinterpret_cast(&SourceInts[0]), - SourceInts.size() * sizeof(int)); - - initialize(SourceBytes, SourceBytes.size()); - - for (auto IS : InputStreams) { - for (auto OS : OutputStreams) { - BinaryStreamReader Reader(*IS); - BinaryStreamWriter Writer(*OS); - ArrayRef Ints; - ArrayRef Ints2; - // First read them, then write them, then read them back. - ASSERT_NO_ERROR(Reader.readArray(Ints, SourceInts.size())); - ASSERT_NO_ERROR(Writer.writeArray(Ints)); - - BinaryStreamReader ReaderBacker(*OS); - ASSERT_NO_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size())); - - EXPECT_EQ(makeArrayRef(SourceInts), Ints2); - } - } -} - -TEST_F(BinaryStreamTest, DISABLED_StreamWriterEnum) { - enum class MyEnum : int64_t { Foo = -10, Bar = 0, Baz = 10 }; - - std::vector Expected = {MyEnum::Bar, MyEnum::Foo, MyEnum::Baz}; - - initialize(Expected.size() * sizeof(MyEnum)); - - for (auto OS : OutputStreams) { - BinaryStreamWriter Writer(*OS); - ArrayRef Enums; - ArrayRef Enums2; - - // First read them, then write them, then read them back. - for (auto ME : Expected) - ASSERT_NO_ERROR(Writer.writeEnum(ME)); - - ArrayRef Array; - BinaryStreamReader Reader(*OS); - ASSERT_NO_ERROR(Reader.readArray(Array, Expected.size())); - - EXPECT_EQ(makeArrayRef(Expected), Array); - } -} - -TEST_F(BinaryStreamTest, StringWriterStrings) { - StringRef Strings[] = {"First", "Second", "Third", "Fourth"}; - - size_t Length = 0; - for (auto S : Strings) - Length += S.size() + 1; - initialize(Length); - - for (auto OS : OutputStreams) { - BinaryStreamWriter Writer(*OS); - for (auto S : Strings) - ASSERT_NO_ERROR(Writer.writeCString(S)); - - for (auto IS : InputStreams) { - std::vector InStrings; - BinaryStreamReader Reader(*IS); - while (!Reader.empty()) { - StringRef S; - ASSERT_NO_ERROR(Reader.readCString(S)); - InStrings.push_back(S); - } - EXPECT_EQ(makeArrayRef(Strings), makeArrayRef(InStrings)); - } - } -} - -TEST_F(BinaryStreamTest, StreamReaderIntegersVariadic) { - uint8_t A = 201; - int8_t A2 = -92; - uint16_t B = 20823; - int16_t B2 = -20823; - uint32_t C = 8978251; - int32_t C2 = -8978251; - uint64_t D = 90278410232ULL; - int64_t D2 = -90278410232LL; - - initialize(2 * (sizeof(A) + sizeof(B) + sizeof(C) + sizeof(D))); - - for (auto OS : OutputStreams) { - BinaryStreamWriter Writer(*OS); - ASSERT_NO_ERROR(Writer.writeIntegers(A, A2, B, B2, C, C2, D, D2)); - - for (auto IS : InputStreams) { - BinaryStreamReader Reader(*IS); - uint8_t AX; - int8_t AX2; - uint16_t BX; - int16_t BX2; - uint32_t CX; - int32_t CX2; - uint64_t DX; - int64_t DX2; - - ASSERT_NO_ERROR(Reader.readIntegers(AX, AX2, BX, BX2, CX, CX2, DX, DX2)); - EXPECT_EQ(A, AX); - EXPECT_EQ(A2, AX2); - EXPECT_EQ(B, BX); - EXPECT_EQ(B2, BX2); - EXPECT_EQ(C, CX); - EXPECT_EQ(C2, CX2); - EXPECT_EQ(D, DX); - EXPECT_EQ(D2, DX2); - } - } -} -} - -namespace { -struct BinaryItemStreamObject { - BinaryItemStreamObject(int X, float Y) : X(X), Y(Y) {} - - int X; - float Y; -}; -} - -namespace llvm { -template <> struct BinaryItemTraits> { - size_t length(const std::unique_ptr &Item) { - size_t S = sizeof(Item->X); - S += sizeof(Item->Y); - return S; - } - - ArrayRef bytes(const std::unique_ptr &Item) { - // In practice we probably would use a more cheaply serializable type, - // or at the very least not allocate every single time. This is just - // for illustration and testing though. - size_t Size = length(Item); - uint8_t *Buffer = Alloc.Allocate(Size); - MutableBinaryByteStream Stream(MutableArrayRef(Buffer, Size), - little); - BinaryStreamWriter Writer(Stream); - consumeError(Writer.writeInteger(Item->X)); - consumeError(Writer.writeObject(Item->Y)); - return makeArrayRef(Buffer, Size); - } - -private: - BumpPtrAllocator Alloc; -}; -} - -namespace { - -TEST_F(BinaryStreamTest, BinaryItemStream) { - // Note that this is a vector of pointers, so individual records do not live - // contiguously in memory. - std::vector> Objects; - Objects.push_back(llvm::make_unique(1, 1.0)); - Objects.push_back(llvm::make_unique(2, 2.0)); - Objects.push_back(llvm::make_unique(3, 3.0)); - - BinaryItemStream> ItemStream(little); - ItemStream.setItems(Objects); - BinaryStreamReader Reader(ItemStream); - - for (int I = 0; I < 3; ++I) { - int X; - const float *Y; - ASSERT_NO_ERROR(Reader.readInteger(X)); - ASSERT_NO_ERROR(Reader.readObject(Y)); - - EXPECT_EQ(Objects[I]->X, X); - EXPECT_DOUBLE_EQ(Objects[I]->Y, *Y); - } -} - -} // end anonymous namespace diff --git a/unittests/DebugInfo/PDB/CMakeLists.txt b/unittests/DebugInfo/PDB/CMakeLists.txt index cb57ada5ee4..cbbbd817748 100644 --- a/unittests/DebugInfo/PDB/CMakeLists.txt +++ b/unittests/DebugInfo/PDB/CMakeLists.txt @@ -5,7 +5,6 @@ set(LLVM_LINK_COMPONENTS ) set(DebugInfoPDBSources - BinaryStreamTest.cpp HashTableTest.cpp MappedBlockStreamTest.cpp StringTableBuilderTest.cpp diff --git a/unittests/DebugInfo/PDB/HashTableTest.cpp b/unittests/DebugInfo/PDB/HashTableTest.cpp index fae7d375e17..bd86589b757 100644 --- a/unittests/DebugInfo/PDB/HashTableTest.cpp +++ b/unittests/DebugInfo/PDB/HashTableTest.cpp @@ -19,7 +19,6 @@ using namespace llvm; using namespace llvm::pdb; -using namespace llvm::support; namespace { class HashTableInternals : public HashTable { @@ -148,14 +147,14 @@ TEST(HashTableTest, Serialization) { } std::vector Buffer(Table.calculateSerializedLength()); - MutableBinaryByteStream Stream(Buffer, little); - BinaryStreamWriter Writer(Stream); + msf::MutableByteStream Stream(Buffer); + msf::StreamWriter Writer(Stream); EXPECT_NO_ERROR(Table.commit(Writer)); // We should have written precisely the number of bytes we calculated earlier. EXPECT_EQ(Buffer.size(), Writer.getOffset()); HashTableInternals Table2; - BinaryStreamReader Reader(Stream); + msf::StreamReader Reader(Stream); EXPECT_NO_ERROR(Table2.load(Reader)); // We should have read precisely the number of bytes we calculated earlier. EXPECT_EQ(Buffer.size(), Reader.getOffset()); diff --git a/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp b/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp index fc938d4418d..e7da6caed7c 100644 --- a/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp +++ b/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp @@ -22,14 +22,13 @@ using namespace llvm; using namespace llvm::msf; -using namespace llvm::support; 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 DiscontiguousStream : public WritableBinaryStream { +class DiscontiguousStream : public WritableStream { public: DiscontiguousStream(ArrayRef Blocks, MutableArrayRef Data) : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {} @@ -37,33 +36,31 @@ public: uint32_t block_size() const { return 1; } uint32_t block_count() const { return Blocks.size(); } - endianness getEndian() const override { return little; } - Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { if (Offset + Size > Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); Buffer = Data.slice(Offset, Size); return Error::success(); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef &Buffer) override { + ArrayRef &Buffer) const override { if (Offset >= Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); Buffer = Data.drop_front(Offset); return Error::success(); } - uint32_t getLength() override { return Data.size(); } + uint32_t getLength() const override { return Data.size(); } - Error writeBytes(uint32_t Offset, ArrayRef SrcData) override { + Error writeBytes(uint32_t Offset, ArrayRef SrcData) const override { if (Offset + SrcData.size() > Data.size()) - return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + return make_error(msf_error_code::insufficient_buffer); ::memcpy(&Data[Offset], SrcData.data(), SrcData.size()); return Error::success(); } - Error commit() override { return Error::success(); } + Error commit() const override { return Error::success(); } MSFStreamLayout layout() const { return MSFStreamLayout{static_cast(Data.size()), Blocks}; @@ -81,8 +78,8 @@ TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) { auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); - BinaryStreamRef SR; + StreamReader R(*S); + ReadableStreamRef SR; EXPECT_NO_ERROR(R.readStreamRef(SR, 0U)); ArrayRef Buffer; EXPECT_ERROR(SR.readBytes(0U, 1U, Buffer)); @@ -97,7 +94,7 @@ TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) { auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA"; EXPECT_NO_ERROR(R.readFixedString(Str, 1)); EXPECT_EQ(Str, StringRef("A")); @@ -111,7 +108,7 @@ TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 2)); EXPECT_EQ(Str, StringRef("AB")); @@ -130,7 +127,7 @@ TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 10)); EXPECT_EQ(Str, StringRef("ABCDEFGHIJ")); @@ -143,7 +140,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str; R.setOffset(10); @@ -157,7 +154,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str; R.setOffset(6); @@ -171,7 +168,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str; EXPECT_ERROR(R.readFixedString(Str, 11)); @@ -184,7 +181,7 @@ TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 1)); EXPECT_EQ(Str, StringRef("A")); @@ -198,7 +195,7 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingRead) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str1; StringRef Str2; EXPECT_NO_ERROR(R.readFixedString(Str1, 7)); @@ -219,7 +216,7 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - BinaryStreamReader R(*S); + StreamReader R(*S); StringRef Str1; StringRef Str2; EXPECT_NO_ERROR(R.readFixedString(Str1, 6)); @@ -326,10 +323,10 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { uint32_t intArr1[] = {890723408, 29082234}; ArrayRef intArray[] = {intArr0, intArr1}; - BinaryStreamReader Reader(*S); - BinaryStreamWriter Writer(*S); - EXPECT_NO_ERROR(Writer.writeInteger(u16[0])); - EXPECT_NO_ERROR(Reader.readInteger(u16[1])); + StreamReader Reader(*S); + StreamWriter Writer(*S); + EXPECT_NO_ERROR(Writer.writeInteger(u16[0], llvm::support::little)); + EXPECT_NO_ERROR(Reader.readInteger(u16[1], llvm::support::little)); EXPECT_EQ(u16[0], u16[1]); EXPECT_EQ(std::vector({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}), DataBytes); @@ -337,8 +334,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { Reader.setOffset(0); Writer.setOffset(0); ::memset(DataBytes.data(), 0, 10); - EXPECT_NO_ERROR(Writer.writeInteger(u32[0])); - EXPECT_NO_ERROR(Reader.readInteger(u32[1])); + EXPECT_NO_ERROR(Writer.writeInteger(u32[0], llvm::support::little)); + EXPECT_NO_ERROR(Reader.readInteger(u32[1], llvm::support::little)); EXPECT_EQ(u32[0], u32[1]); EXPECT_EQ(std::vector({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}), DataBytes); @@ -346,8 +343,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { Reader.setOffset(0); Writer.setOffset(0); ::memset(DataBytes.data(), 0, 10); - EXPECT_NO_ERROR(Writer.writeEnum(Enum[0])); - EXPECT_NO_ERROR(Reader.readEnum(Enum[1])); + EXPECT_NO_ERROR(Writer.writeEnum(Enum[0], llvm::support::little)); + EXPECT_NO_ERROR(Reader.readEnum(Enum[1], llvm::support::little)); EXPECT_EQ(Enum[0], Enum[1]); EXPECT_EQ(std::vector({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}), DataBytes); @@ -355,8 +352,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { Reader.setOffset(0); Writer.setOffset(0); ::memset(DataBytes.data(), 0, 10); - EXPECT_NO_ERROR(Writer.writeCString(ZStr[0])); - EXPECT_NO_ERROR(Reader.readCString(ZStr[1])); + EXPECT_NO_ERROR(Writer.writeZeroString(ZStr[0])); + EXPECT_NO_ERROR(Reader.readZeroString(ZStr[1])); EXPECT_EQ(ZStr[0], ZStr[1]); EXPECT_EQ( std::vector({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}), @@ -402,22 +399,22 @@ TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) { F.block_size(), F.block_count(), F.layout(), F); // First write "Test Str" into the source stream. - MutableBinaryByteStream SourceStream(SrcData, little); - BinaryStreamWriter SourceWriter(SourceStream); - EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str")); + MutableByteStream SourceStream(SrcData); + StreamWriter SourceWriter(SourceStream); + EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str")); EXPECT_EQ(SrcDataBytes, std::vector( {'T', 'e', 's', 't', ' ', 'S', 't', 'r', 0, 0})); // Then write the source stream into the dest stream. - BinaryStreamWriter DestWriter(*DestStream); + StreamWriter DestWriter(*DestStream); EXPECT_NO_ERROR(DestWriter.writeStreamRef(SourceStream)); EXPECT_EQ(DestDataBytes, std::vector( {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0})); // Then read the string back out of the dest stream. StringRef Result; - BinaryStreamReader DestReader(*DestStream); - EXPECT_NO_ERROR(DestReader.readCString(Result)); + StreamReader DestReader(*DestStream); + EXPECT_NO_ERROR(DestReader.readZeroString(Result)); EXPECT_EQ(Result, "Test Str"); } @@ -439,21 +436,21 @@ TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) { SrcF.block_size(), SrcF.block_count(), SrcF.layout(), SrcF); // First write "Test Str" into the source stream. - BinaryStreamWriter SourceWriter(*Src); - EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str")); + StreamWriter SourceWriter(*Src); + EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str")); EXPECT_EQ(SrcDataBytes, std::vector( {'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0})); // Then write the source stream into the dest stream. - BinaryStreamWriter DestWriter(*Dest); + StreamWriter DestWriter(*Dest); EXPECT_NO_ERROR(DestWriter.writeStreamRef(*Src)); EXPECT_EQ(DestDataBytes, std::vector( {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0})); // Then read the string back out of the dest stream. StringRef Result; - BinaryStreamReader DestReader(*Dest); - EXPECT_NO_ERROR(DestReader.readCString(Result)); + StreamReader DestReader(*Dest); + EXPECT_NO_ERROR(DestReader.readZeroString(Result)); EXPECT_EQ(Result, "Test Str"); } diff --git a/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp b/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp index aecffbe9b01..61b88f8615f 100644 --- a/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp +++ b/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp @@ -19,7 +19,6 @@ using namespace llvm; using namespace llvm::pdb; -using namespace llvm::support; namespace { class StringTableBuilderTest : public ::testing::Test {}; @@ -34,13 +33,13 @@ TEST_F(StringTableBuilderTest, Simple) { EXPECT_EQ(9U, Builder.insert("baz")); std::vector Buffer(Builder.finalize()); - MutableBinaryByteStream OutStream(Buffer, little); - BinaryStreamWriter Writer(OutStream); + msf::MutableByteStream OutStream(Buffer); + msf::StreamWriter Writer(OutStream); EXPECT_NO_ERROR(Builder.commit(Writer)); // Reads the contents back. - BinaryByteStream InStream(Buffer, little); - BinaryStreamReader Reader(InStream); + msf::ByteStream InStream(Buffer); + msf::StreamReader Reader(InStream); StringTable Table; EXPECT_NO_ERROR(Table.load(Reader));