diff options
| author | Zachary Turner <zturner@google.com> | 2017-02-25 00:44:30 +0000 |
|---|---|---|
| committer | Zachary Turner <zturner@google.com> | 2017-02-25 00:44:30 +0000 |
| commit | af299ea5d456aa2fc19d7fdb041a0452d209fd4c (patch) | |
| tree | 2d863cba130306041941aeec5b44baa2e9c00ec1 /llvm | |
| parent | 42de38076517bc68a2b97c55dcbac7ea8d80b11b (diff) | |
| download | bcm5719-llvm-af299ea5d456aa2fc19d7fdb041a0452d209fd4c.tar.gz bcm5719-llvm-af299ea5d456aa2fc19d7fdb041a0452d209fd4c.zip | |
[PDB] General improvements to Stream library.
This adds various new functionality and cleanup surrounding the
use of the Stream library. Major changes include:
* Renaming of all classes for more consistency / meaningfulness
* Addition of some new methods for reading multiple values at once.
* Full suite of unit tests for reader / writer functionality.
* Full set of doxygen comments for all classes.
* Streams now store their own endianness.
* Fixed some bugs in a few of the classes that were discovered
by the unit tests.
llvm-svn: 296215
Diffstat (limited to 'llvm')
78 files changed, 1971 insertions, 841 deletions
diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h index d4cbc587e55..d56c490156f 100644 --- a/llvm/include/llvm/ADT/STLExtras.h +++ b/llvm/include/llvm/ADT/STLExtras.h @@ -640,6 +640,16 @@ detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) { // Extra additions to <utility> //===----------------------------------------------------------------------===// +/// \brief Template class to compute the sum of sizes of all items in a +/// parameter pack. +template <typename T, typename... Ts> struct sizeof_sum { + static const size_t value = sizeof(T) + sizeof_sum<Ts...>::value; +}; + +template <typename T> struct sizeof_sum<T> { + 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/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h b/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h index 94227ec5e7d..e038b13ee9b 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h +++ b/llvm/include/llvm/DebugInfo/CodeView/CVRecord.h @@ -48,15 +48,13 @@ public: } // end namespace codeview -namespace msf { - template <typename Kind> struct VarStreamArrayExtractor<codeview::CVRecord<Kind>> { - Error operator()(ReadableStreamRef Stream, uint32_t &Len, + Error operator()(BinaryStreamRef Stream, uint32_t &Len, codeview::CVRecord<Kind> &Item) const { using namespace codeview; const RecordPrefix *Prefix = nullptr; - StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); uint32_t Offset = Reader.getOffset(); if (auto EC = Reader.readObject(Prefix)) @@ -76,8 +74,6 @@ struct VarStreamArrayExtractor<codeview::CVRecord<Kind>> { } }; -} // end namespace msf - } // end namespace llvm #endif // LLVM_DEBUGINFO_CODEVIEW_RECORDITERATOR_H diff --git a/llvm/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h b/llvm/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h index ab4b0cbaf96..e9012db7602 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h +++ b/llvm/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h @@ -34,7 +34,7 @@ public: Error visitTypeStream(CVTypeRange Types); Error visitFieldListMemberStream(ArrayRef<uint8_t> FieldList); - Error visitFieldListMemberStream(msf::StreamReader Reader); + Error visitFieldListMemberStream(BinaryStreamReader Reader); private: /// The interface to the class that gets notified of each visitation. diff --git a/llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h b/llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h index 8c0506b8451..b7f621d2480 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h +++ b/llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h @@ -33,8 +33,8 @@ class CodeViewRecordIO { } public: - explicit CodeViewRecordIO(msf::StreamReader &Reader) : Reader(&Reader) {} - explicit CodeViewRecordIO(msf::StreamWriter &Writer) : Writer(&Writer) {} + explicit CodeViewRecordIO(BinaryStreamReader &Reader) : Reader(&Reader) {} + explicit CodeViewRecordIO(BinaryStreamWriter &Writer) : Writer(&Writer) {} Error beginRecord(Optional<uint32_t> MaxLength); Error endRecord(); @@ -59,9 +59,9 @@ public: template <typename T> Error mapInteger(T &Value) { if (isWriting()) - return Writer->writeInteger(Value, llvm::support::little); + return Writer->writeInteger(Value); - return Reader->readInteger(Value, llvm::support::little); + return Reader->readInteger(Value); } template <typename T> Error mapEnum(T &Value) { @@ -93,7 +93,7 @@ public: SizeType Size; if (isWriting()) { Size = static_cast<SizeType>(Items.size()); - if (auto EC = Writer->writeInteger(Size, llvm::support::little)) + if (auto EC = Writer->writeInteger(Size)) return EC; for (auto &X : Items) { @@ -101,7 +101,7 @@ public: return EC; } } else { - if (auto EC = Reader->readInteger(Size, llvm::support::little)) + if (auto EC = Reader->readInteger(Size)) return EC; for (SizeType I = 0; I < Size; ++I) { typename T::value_type Item; @@ -160,8 +160,8 @@ private: SmallVector<RecordLimit, 2> Limits; - msf::StreamReader *Reader = nullptr; - msf::StreamWriter *Writer = nullptr; + BinaryStreamReader *Reader = nullptr; + BinaryStreamWriter *Writer = nullptr; }; } // end namespace codeview diff --git a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h index 5bbcabaef88..eb881da8e69 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h +++ b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstream.h @@ -59,23 +59,22 @@ struct ColumnNumberEntry { class ModuleSubstream { public: ModuleSubstream(); - ModuleSubstream(ModuleSubstreamKind Kind, msf::ReadableStreamRef Data); - static Error initialize(msf::ReadableStreamRef Stream, ModuleSubstream &Info); + ModuleSubstream(ModuleSubstreamKind Kind, BinaryStreamRef Data); + static Error initialize(BinaryStreamRef Stream, ModuleSubstream &Info); uint32_t getRecordLength() const; ModuleSubstreamKind getSubstreamKind() const; - msf::ReadableStreamRef getRecordData() const; + BinaryStreamRef getRecordData() const; private: ModuleSubstreamKind Kind; - msf::ReadableStreamRef Data; + BinaryStreamRef Data; }; -typedef msf::VarStreamArray<ModuleSubstream> ModuleSubstreamArray; +typedef VarStreamArray<ModuleSubstream> ModuleSubstreamArray; } // namespace codeview -namespace msf { template <> struct VarStreamArrayExtractor<codeview::ModuleSubstream> { - Error operator()(ReadableStreamRef Stream, uint32_t &Length, + Error operator()(BinaryStreamRef Stream, uint32_t &Length, codeview::ModuleSubstream &Info) const { if (auto EC = codeview::ModuleSubstream::initialize(Stream, Info)) return EC; @@ -83,7 +82,6 @@ template <> struct VarStreamArrayExtractor<codeview::ModuleSubstream> { return Error::success(); } }; -} // namespace msf } // namespace llvm #endif // LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAM_H diff --git a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h index eecaa6e98c5..51e6ca04e41 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h +++ b/llvm/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h @@ -28,8 +28,8 @@ namespace codeview { struct LineColumnEntry { support::ulittle32_t NameIndex; - msf::FixedStreamArray<LineNumberEntry> LineNumbers; - msf::FixedStreamArray<ColumnNumberEntry> Columns; + FixedStreamArray<LineNumberEntry> LineNumbers; + FixedStreamArray<ColumnNumberEntry> Columns; }; struct FileChecksumEntry { @@ -38,49 +38,47 @@ struct FileChecksumEntry { ArrayRef<uint8_t> Checksum; // The bytes of the checksum. }; -typedef msf::VarStreamArray<LineColumnEntry> LineInfoArray; -typedef msf::VarStreamArray<FileChecksumEntry> FileChecksumArray; +typedef VarStreamArray<LineColumnEntry> LineInfoArray; +typedef VarStreamArray<FileChecksumEntry> FileChecksumArray; class IModuleSubstreamVisitor { public: virtual ~IModuleSubstreamVisitor() = default; virtual Error visitUnknown(ModuleSubstreamKind Kind, - msf::ReadableStreamRef Data) = 0; - virtual Error visitSymbols(msf::ReadableStreamRef Data); - virtual Error visitLines(msf::ReadableStreamRef Data, + BinaryStreamRef Data) = 0; + virtual Error visitSymbols(BinaryStreamRef Data); + virtual Error visitLines(BinaryStreamRef Data, const LineSubstreamHeader *Header, const LineInfoArray &Lines); - virtual Error visitStringTable(msf::ReadableStreamRef Data); - virtual Error visitFileChecksums(msf::ReadableStreamRef Data, + virtual Error visitStringTable(BinaryStreamRef Data); + virtual Error visitFileChecksums(BinaryStreamRef Data, const FileChecksumArray &Checksums); - 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); + 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); }; Error visitModuleSubstream(const ModuleSubstream &R, IModuleSubstreamVisitor &V); } // end namespace codeview -namespace msf { - template <> class VarStreamArrayExtractor<codeview::LineColumnEntry> { public: VarStreamArrayExtractor(const codeview::LineSubstreamHeader *Header) : Header(Header) {} - Error operator()(ReadableStreamRef Stream, uint32_t &Len, + Error operator()(BinaryStreamRef Stream, uint32_t &Len, codeview::LineColumnEntry &Item) const { using namespace codeview; const LineFileBlockHeader *BlockHeader; - StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); if (auto EC = Reader.readObject(BlockHeader)) return EC; bool HasColumn = Header->Flags & LineFlags::HaveColumns; @@ -113,11 +111,11 @@ private: template <> class VarStreamArrayExtractor<codeview::FileChecksumEntry> { public: - Error operator()(ReadableStreamRef Stream, uint32_t &Len, + Error operator()(BinaryStreamRef Stream, uint32_t &Len, codeview::FileChecksumEntry &Item) const { using namespace codeview; const FileChecksum *Header; - StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); if (auto EC = Reader.readObject(Header)) return EC; Item.FileNameOffset = Header->FileNameOffset; @@ -129,8 +127,6 @@ public: } }; -} // end namespace msf - } // end namespace llvm #endif // LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAMVISITOR_H diff --git a/llvm/include/llvm/DebugInfo/CodeView/RecordSerialization.h b/llvm/include/llvm/DebugInfo/CodeView/RecordSerialization.h index 6505fd6df6a..f6e49973f9d 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/RecordSerialization.h +++ b/llvm/include/llvm/DebugInfo/CodeView/RecordSerialization.h @@ -41,37 +41,37 @@ struct RecordPrefix { StringRef getBytesAsCharacters(ArrayRef<uint8_t> LeafData); StringRef getBytesAsCString(ArrayRef<uint8_t> LeafData); -inline Error consume(msf::StreamReader &Reader) { return Error::success(); } +inline Error consume(BinaryStreamReader &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(msf::StreamReader &Reader, APSInt &Num); +Error consume(BinaryStreamReader &Reader, APSInt &Num); /// Decodes a numeric leaf value that is known to be a particular type. -Error consume_numeric(msf::StreamReader &Reader, uint64_t &Value); +Error consume_numeric(BinaryStreamReader &Reader, uint64_t &Value); /// Decodes signed and unsigned fixed-length integers. -Error consume(msf::StreamReader &Reader, uint32_t &Item); -Error consume(msf::StreamReader &Reader, int32_t &Item); +Error consume(BinaryStreamReader &Reader, uint32_t &Item); +Error consume(BinaryStreamReader &Reader, int32_t &Item); /// Decodes a null terminated string. -Error consume(msf::StreamReader &Reader, StringRef &Item); +Error consume(BinaryStreamReader &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 <typename T> Error consume(msf::StreamReader &Reader, T *&Item) { +template <typename T> Error consume(BinaryStreamReader &Reader, T *&Item) { return Reader.readObject(Item); } template <typename T, typename U> struct serialize_conditional_impl { serialize_conditional_impl(T &Item, U Func) : Item(Item), Func(Func) {} - Error deserialize(msf::StreamReader &Reader) const { + Error deserialize(BinaryStreamReader &Reader) const { if (!Func()) return Error::success(); return consume(Reader, Item); @@ -89,7 +89,7 @@ serialize_conditional_impl<T, U> serialize_conditional(T &Item, U Func) { template <typename T, typename U> struct serialize_array_impl { serialize_array_impl(ArrayRef<T> &Item, U Func) : Item(Item), Func(Func) {} - Error deserialize(msf::StreamReader &Reader) const { + Error deserialize(BinaryStreamReader &Reader) const { return Reader.readArray(Item, Func()); } @@ -100,7 +100,7 @@ template <typename T, typename U> struct serialize_array_impl { template <typename T> struct serialize_vector_tail_impl { serialize_vector_tail_impl(std::vector<T> &Item) : Item(Item) {} - Error deserialize(msf::StreamReader &Reader) const { + Error deserialize(BinaryStreamReader &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<StringRef> &Item) : Item(Item) {} - Error deserialize(msf::StreamReader &Reader) const { + Error deserialize(BinaryStreamReader &Reader) const { if (Reader.empty()) return make_error<CodeViewError>(cv_error_code::insufficient_buffer, "Null terminated string is empty!"); while (Reader.peek() != 0) { StringRef Field; - if (auto EC = Reader.readZeroString(Field)) + if (auto EC = Reader.readCString(Field)) return EC; Item.push_back(Field); } @@ -138,7 +138,7 @@ struct serialize_null_term_string_array_impl { template <typename T> struct serialize_arrayref_tail_impl { serialize_arrayref_tail_impl(ArrayRef<T> &Item) : Item(Item) {} - Error deserialize(msf::StreamReader &Reader) const { + Error deserialize(BinaryStreamReader &Reader) const { uint32_t Count = Reader.bytesRemaining() / sizeof(T); return Reader.readArray(Item, Count); } @@ -149,7 +149,7 @@ template <typename T> struct serialize_arrayref_tail_impl { template <typename T> struct serialize_numeric_impl { serialize_numeric_impl(T &Item) : Item(Item) {} - Error deserialize(msf::StreamReader &Reader) const { + Error deserialize(BinaryStreamReader &Reader) const { return consume_numeric(Reader, Item); } @@ -201,42 +201,42 @@ template <typename T> serialize_numeric_impl<T> serialize_numeric(T &Item) { #define CV_NUMERIC_FIELD(I) serialize_numeric(I) template <typename T, typename U> -Error consume(msf::StreamReader &Reader, +Error consume(BinaryStreamReader &Reader, const serialize_conditional_impl<T, U> &Item) { return Item.deserialize(Reader); } template <typename T, typename U> -Error consume(msf::StreamReader &Reader, +Error consume(BinaryStreamReader &Reader, const serialize_array_impl<T, U> &Item) { return Item.deserialize(Reader); } -inline Error consume(msf::StreamReader &Reader, +inline Error consume(BinaryStreamReader &Reader, const serialize_null_term_string_array_impl &Item) { return Item.deserialize(Reader); } template <typename T> -Error consume(msf::StreamReader &Reader, +Error consume(BinaryStreamReader &Reader, const serialize_vector_tail_impl<T> &Item) { return Item.deserialize(Reader); } template <typename T> -Error consume(msf::StreamReader &Reader, +Error consume(BinaryStreamReader &Reader, const serialize_arrayref_tail_impl<T> &Item) { return Item.deserialize(Reader); } template <typename T> -Error consume(msf::StreamReader &Reader, +Error consume(BinaryStreamReader &Reader, const serialize_numeric_impl<T> &Item) { return Item.deserialize(Reader); } template <typename T, typename U, typename... Args> -Error consume(msf::StreamReader &Reader, T &&X, U &&Y, Args &&... Rest) { +Error consume(BinaryStreamReader &Reader, T &&X, U &&Y, Args &&... Rest) { if (auto EC = consume(Reader, X)) return EC; return consume(Reader, Y, std::forward<Args>(Rest)...); diff --git a/llvm/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h b/llvm/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h index 46eb789bcaa..2a5f20d88ed 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h +++ b/llvm/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h @@ -25,10 +25,11 @@ class SymbolVisitorDelegate; class SymbolDeserializer : public SymbolVisitorCallbacks { struct MappingInfo { explicit MappingInfo(ArrayRef<uint8_t> RecordData) - : Stream(RecordData), Reader(Stream), Mapping(Reader) {} + : Stream(RecordData, llvm::support::little), Reader(Stream), + Mapping(Reader) {} - msf::ByteStream Stream; - msf::StreamReader Reader; + BinaryByteStream Stream; + BinaryStreamReader Reader; SymbolRecordMapping Mapping; }; diff --git a/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h b/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h index cae349995ee..a3b9077e89c 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h +++ b/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h @@ -938,7 +938,7 @@ public: }; typedef CVRecord<SymbolKind> CVSymbol; -typedef msf::VarStreamArray<CVSymbol> CVSymbolArray; +typedef VarStreamArray<CVSymbol> CVSymbolArray; } // end namespace codeview } // end namespace llvm diff --git a/llvm/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h b/llvm/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h index 1bd14ed1347..0a1837a0d93 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h +++ b/llvm/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h @@ -14,16 +14,14 @@ #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h" namespace llvm { -namespace msf { -class StreamReader; -class StreamWriter; -} +class BinaryStreamReader; +class BinaryStreamWriter; namespace codeview { class SymbolRecordMapping : public SymbolVisitorCallbacks { public: - explicit SymbolRecordMapping(msf::StreamReader &Reader) : IO(Reader) {} - explicit SymbolRecordMapping(msf::StreamWriter &Writer) : IO(Writer) {} + explicit SymbolRecordMapping(BinaryStreamReader &Reader) : IO(Reader) {} + explicit SymbolRecordMapping(BinaryStreamWriter &Writer) : IO(Writer) {} Error visitSymbolBegin(CVSymbol &Record) override; Error visitSymbolEnd(CVSymbol &Record) override; diff --git a/llvm/include/llvm/DebugInfo/CodeView/SymbolSerializer.h b/llvm/include/llvm/DebugInfo/CodeView/SymbolSerializer.h index 73095ff7be5..eb25751a271 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/SymbolSerializer.h +++ b/llvm/include/llvm/DebugInfo/CodeView/SymbolSerializer.h @@ -20,6 +20,8 @@ #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" @@ -28,7 +30,7 @@ namespace codeview { class SymbolSerializer : public SymbolVisitorCallbacks { uint32_t RecordStart = 0; - msf::StreamWriter &Writer; + BinaryStreamWriter &Writer; SymbolRecordMapping Mapping; Optional<SymbolKind> CurrentSymbol; @@ -42,7 +44,7 @@ class SymbolSerializer : public SymbolVisitorCallbacks { } public: - explicit SymbolSerializer(msf::StreamWriter &Writer) + explicit SymbolSerializer(BinaryStreamWriter &Writer) : Writer(Writer), Mapping(Writer) {} virtual Error visitSymbolBegin(CVSymbol &Record) override { diff --git a/llvm/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h b/llvm/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h index 2b468a289fd..2bef3f61adf 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h +++ b/llvm/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h @@ -15,9 +15,7 @@ namespace llvm { -namespace msf { -class StreamReader; -} // end namespace msf +class BinaryStreamReader; namespace codeview { @@ -25,7 +23,7 @@ class SymbolVisitorDelegate { public: virtual ~SymbolVisitorDelegate() = default; - virtual uint32_t getRecordOffset(msf::StreamReader Reader) = 0; + virtual uint32_t getRecordOffset(BinaryStreamReader Reader) = 0; virtual StringRef getFileNameForFileOffset(uint32_t FileOffset) = 0; virtual StringRef getStringTable() = 0; }; diff --git a/llvm/include/llvm/DebugInfo/CodeView/TypeDeserializer.h b/llvm/include/llvm/DebugInfo/CodeView/TypeDeserializer.h index ab4f11f7111..92177a48d4c 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/TypeDeserializer.h +++ b/llvm/include/llvm/DebugInfo/CodeView/TypeDeserializer.h @@ -29,10 +29,11 @@ namespace codeview { class TypeDeserializer : public TypeVisitorCallbacks { struct MappingInfo { explicit MappingInfo(ArrayRef<uint8_t> RecordData) - : Stream(RecordData), Reader(Stream), Mapping(Reader) {} + : Stream(RecordData, llvm::support::little), Reader(Stream), + Mapping(Reader) {} - msf::ByteStream Stream; - msf::StreamReader Reader; + BinaryByteStream Stream; + BinaryStreamReader Reader; TypeRecordMapping Mapping; }; @@ -72,16 +73,16 @@ private: class FieldListDeserializer : public TypeVisitorCallbacks { struct MappingInfo { - explicit MappingInfo(msf::StreamReader &R) + explicit MappingInfo(BinaryStreamReader &R) : Reader(R), Mapping(Reader), StartOffset(0) {} - msf::StreamReader &Reader; + BinaryStreamReader &Reader; TypeRecordMapping Mapping; uint32_t StartOffset; }; public: - explicit FieldListDeserializer(msf::StreamReader &Reader) : Mapping(Reader) { + explicit FieldListDeserializer(BinaryStreamReader &Reader) : Mapping(Reader) { CVType FieldList; FieldList.Type = TypeLeafKind::LF_FIELDLIST; consumeError(Mapping.Mapping.visitTypeBegin(FieldList)); diff --git a/llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h b/llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h index 290a3f4185d..4cc0aa76ff6 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h +++ b/llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h @@ -26,9 +26,7 @@ namespace llvm { -namespace msf { -class StreamReader; -} // end namespace msf +class BinaryStreamReader; namespace codeview { @@ -42,7 +40,7 @@ struct CVMemberRecord { TypeLeafKind Kind; ArrayRef<uint8_t> Data; }; -typedef msf::VarStreamArray<CVType> CVTypeArray; +typedef VarStreamArray<CVType> CVTypeArray; typedef iterator_range<CVTypeArray::Iterator> CVTypeRange; /// Equvalent to CV_fldattr_t in cvinfo.h. diff --git a/llvm/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h b/llvm/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h index fe470a72abb..924ca0470fa 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h +++ b/llvm/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h @@ -16,15 +16,14 @@ #include "llvm/Support/Error.h" namespace llvm { -namespace msf { -class StreamReader; -class StreamWriter; -} +class BinaryStreamReader; +class BinaryStreamWriter; + namespace codeview { class TypeRecordMapping : public TypeVisitorCallbacks { public: - explicit TypeRecordMapping(msf::StreamReader &Reader) : IO(Reader) {} - explicit TypeRecordMapping(msf::StreamWriter &Writer) : IO(Writer) {} + explicit TypeRecordMapping(BinaryStreamReader &Reader) : IO(Reader) {} + explicit TypeRecordMapping(BinaryStreamWriter &Writer) : IO(Writer) {} Error visitTypeBegin(CVType &Record) override; Error visitTypeEnd(CVType &Record) override; diff --git a/llvm/include/llvm/DebugInfo/CodeView/TypeSerializer.h b/llvm/include/llvm/DebugInfo/CodeView/TypeSerializer.h index 9210758126b..80867ecb41f 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/TypeSerializer.h +++ b/llvm/include/llvm/DebugInfo/CodeView/TypeSerializer.h @@ -56,8 +56,8 @@ class TypeSerializer : public TypeVisitorCallbacks { Optional<TypeLeafKind> TypeKind; Optional<TypeLeafKind> MemberKind; std::vector<uint8_t> RecordBuffer; - msf::MutableByteStream Stream; - msf::StreamWriter Writer; + MutableBinaryByteStream Stream; + BinaryStreamWriter Writer; TypeRecordMapping Mapping; RecordList SeenRecords; @@ -109,7 +109,7 @@ private: Error visitKnownMemberImpl(CVMemberRecord &CVR, RecordType &Record) { assert(CVR.Kind == static_cast<TypeLeafKind>(Record.getKind())); - if (auto EC = Writer.writeEnum(CVR.Kind, llvm::support::little)) + if (auto EC = Writer.writeEnum(CVR.Kind)) return EC; if (auto EC = Mapping.visitKnownMember(CVR, Record)) diff --git a/llvm/include/llvm/DebugInfo/MSF/BinaryByteStream.h b/llvm/include/llvm/DebugInfo/MSF/BinaryByteStream.h index 13208f3325d..ee4056a83e2 100644 --- a/llvm/include/llvm/DebugInfo/MSF/BinaryByteStream.h +++ b/llvm/include/llvm/DebugInfo/MSF/BinaryByteStream.h @@ -1,19 +1,19 @@ -//===- ByteStream.h - Reads stream data from a byte sequence ----*- C++ -*-===// +//===- BinaryByteStream.h ---------------------------------------*- 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_DEBUGINFO_MSF_BYTESTREAM_H -#define LLVM_DEBUGINFO_MSF_BYTESTREAM_H +#ifndef LLVM_SUPPORT_BINARYBYTESTREAM_H +#define LLVM_SUPPORT_BINARYBYTESTREAM_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,34 +23,40 @@ #include <memory> namespace llvm { -namespace msf { -class ByteStream : public ReadableStream { +/// \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 { public: - ByteStream() = default; - explicit ByteStream(ArrayRef<uint8_t> Data) : Data(Data) {} - explicit ByteStream(StringRef Data) - : Data(Data.bytes_begin(), Data.bytes_end()) {} + BinaryByteStream() = default; + BinaryByteStream(ArrayRef<uint8_t> 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; } Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { if (Offset > Data.size()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); if (Data.size() < Size + Offset) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); Buffer = Data.slice(Offset, Size); return Error::success(); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { if (Offset >= Data.size()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); Buffer = Data.slice(Offset); return Error::success(); } - uint32_t getLength() const override { return Data.size(); } + uint32_t getLength() override { return Data.size(); } ArrayRef<uint8_t> data() const { return Data; } @@ -60,76 +66,91 @@ public: } protected: + llvm::support::endianness Endian; ArrayRef<uint8_t> Data; }; -// MemoryBufferByteStream behaves like a read-only ByteStream, but has its data -// backed by an llvm::MemoryBuffer. It also owns the underlying MemoryBuffer. -class MemoryBufferByteStream : public ByteStream { +/// \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 { public: - explicit MemoryBufferByteStream(std::unique_ptr<MemoryBuffer> Buffer) - : ByteStream(ArrayRef<uint8_t>(Buffer->getBuffer().bytes_begin(), - Buffer->getBuffer().bytes_end())), + explicit MemoryBufferByteStream(std::unique_ptr<MemoryBuffer> Buffer, + llvm::support::endianness Endian) + : BinaryByteStream(Buffer->getBuffer(), Endian), MemBuffer(std::move(Buffer)) {} std::unique_ptr<MemoryBuffer> MemBuffer; }; -class MutableByteStream : public WritableStream { +/// \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 { public: - MutableByteStream() = default; - explicit MutableByteStream(MutableArrayRef<uint8_t> Data) - : Data(Data), ImmutableStream(Data) {} + MutableBinaryByteStream() = default; + MutableBinaryByteStream(MutableArrayRef<uint8_t> Data, + llvm::support::endianness Endian) + : Data(Data), ImmutableStream(Data, Endian) {} + + llvm::support::endianness getEndian() const override { + return ImmutableStream.getEndian(); + } Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { return ImmutableStream.readBytes(Offset, Size, Buffer); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { return ImmutableStream.readLongestContiguousChunk(Offset, Buffer); } - uint32_t getLength() const override { return ImmutableStream.getLength(); } + uint32_t getLength() override { return ImmutableStream.getLength(); } - Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override { + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) override { if (Buffer.empty()) return Error::success(); if (Data.size() < Buffer.size()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); if (Offset > Buffer.size() - Data.size()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); uint8_t *DataPtr = const_cast<uint8_t *>(Data.data()); ::memcpy(DataPtr + Offset, Buffer.data(), Buffer.size()); return Error::success(); } - Error commit() const override { return Error::success(); } + Error commit() override { return Error::success(); } MutableArrayRef<uint8_t> data() const { return Data; } private: MutableArrayRef<uint8_t> Data; - ByteStream ImmutableStream; + BinaryByteStream ImmutableStream; }; -// A simple adapter that acts like a ByteStream but holds ownership over -// and underlying FileOutputBuffer. -class FileBufferByteStream : public WritableStream { +/// \brief An implementation of WritableBinaryStream backed by an llvm +/// FileOutputBuffer. +class FileBufferByteStream : public WritableBinaryStream { private: - class StreamImpl : public MutableByteStream { + class StreamImpl : public MutableBinaryByteStream { public: - StreamImpl(std::unique_ptr<FileOutputBuffer> Buffer) - : MutableByteStream(MutableArrayRef<uint8_t>(Buffer->getBufferStart(), - Buffer->getBufferEnd())), + StreamImpl(std::unique_ptr<FileOutputBuffer> Buffer, + llvm::support::endianness Endian) + : MutableBinaryByteStream( + MutableArrayRef<uint8_t>(Buffer->getBufferStart(), + Buffer->getBufferEnd()), + Endian), FileBuffer(std::move(Buffer)) {} - Error commit() const override { + Error commit() override { if (FileBuffer->commit()) - return llvm::make_error<MSFError>(msf_error_code::not_writable); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); return Error::success(); } @@ -138,32 +159,36 @@ private: }; public: - explicit FileBufferByteStream(std::unique_ptr<FileOutputBuffer> Buffer) - : Impl(std::move(Buffer)) {} + explicit FileBufferByteStream(std::unique_ptr<FileOutputBuffer> Buffer, + llvm::support::endianness Endian) + : Impl(std::move(Buffer), Endian) {} + + llvm::support::endianness getEndian() const override { + return Impl.getEndian(); + } Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { return Impl.readBytes(Offset, Size, Buffer); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { return Impl.readLongestContiguousChunk(Offset, Buffer); } - uint32_t getLength() const override { return Impl.getLength(); } + uint32_t getLength() override { return Impl.getLength(); } - Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const override { + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) override { return Impl.writeBytes(Offset, Data); } - Error commit() const override { return Impl.commit(); } + Error commit() override { return Impl.commit(); } private: StreamImpl Impl; }; -} // end namespace msf } // end namespace llvm -#endif // LLVM_DEBUGINFO_MSF_BYTESTREAM_H +#endif // LLVM_SUPPORT_BINARYBYTESTREAM_H diff --git a/llvm/include/llvm/DebugInfo/MSF/BinaryItemStream.h b/llvm/include/llvm/DebugInfo/MSF/BinaryItemStream.h index d76286d2850..15bb701d35d 100644 --- a/llvm/include/llvm/DebugInfo/MSF/BinaryItemStream.h +++ b/llvm/include/llvm/DebugInfo/MSF/BinaryItemStream.h @@ -1,4 +1,4 @@ -//===- SequencedItemStream.h ------------------------------------*- C++ -*-===// +//===- BinaryItemStream.h ---------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,87 +7,96 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_DEBUGINFO_MSF_SEQUENCEDITEMSTREAM_H -#define LLVM_DEBUGINFO_MSF_SEQUENCEDITEMSTREAM_H +#ifndef LLVM_SUPPORT_BINARYITEMSTREAM_H +#define LLVM_SUPPORT_BINARYITEMSTREAM_H #include "llvm/ADT/ArrayRef.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/MSFError.h" #include "llvm/Support/Error.h" #include <cstddef> #include <cstdint> namespace llvm { -namespace msf { -template <typename T> struct SequencedItemTraits { - static size_t length(const T &Item) = delete; - static ArrayRef<uint8_t> bytes(const T &Item) = delete; +template <typename T> struct BinaryItemTraits { + size_t length(const T &Item) = delete; + ArrayRef<uint8_t> bytes(const T &Item) = delete; }; -/// 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 <typename T, typename Traits = SequencedItemTraits<T>> -class SequencedItemStream : public ReadableStream { +/// 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 <typename T, typename ItemTraits = BinaryItemTraits<T>> +class BinaryItemStream : public BinaryStream { public: - SequencedItemStream() = default; + explicit BinaryItemStream(llvm::support::endianness Endian) + : Endian(Endian) {} + + llvm::support::endianness getEndian() const override { return Endian; } Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &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<MSFError>(msf_error_code::insufficient_buffer); - Buffer = Traits::bytes(Item).take_front(Size); + ArrayRef<uint8_t> &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); return Error::success(); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override { - auto ExpectedIndex = translateOffsetIndex(Offset); - if (!ExpectedIndex) - return ExpectedIndex.takeError(); - Buffer = Traits::bytes(Items[*ExpectedIndex]); + ArrayRef<uint8_t> &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); return Error::success(); } void setItems(ArrayRef<T> ItemArray) { Items = ItemArray; } - uint32_t getLength() const override { + uint32_t getLength() override { uint32_t Size = 0; for (const auto &Item : Items) - Size += Traits::length(Item); + Size += Traits.length(Item); return Size; } private: - Expected<uint32_t> translateOffsetIndex(uint32_t Offset) const { + Error translateOffsetIndex(uint32_t Offset, uint32_t &ItemIndex, + uint32_t &ByteOffset) { + ItemIndex = 0; + ByteOffset = 0; + uint32_t PrevOffset = 0; uint32_t CurrentOffset = 0; - uint32_t CurrentIndex = 0; - for (const auto &Item : Items) { - if (CurrentOffset >= Offset) - break; - CurrentOffset += Traits::length(Item); - ++CurrentIndex; + if (Offset > 0) { + for (const auto &Item : Items) { + PrevOffset = CurrentOffset; + CurrentOffset += Traits.length(Item); + if (CurrentOffset > Offset) + break; + ++ItemIndex; + } } - if (CurrentOffset != Offset) - return make_error<MSFError>(msf_error_code::insufficient_buffer); - return CurrentIndex; + if (CurrentOffset < Offset) + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + ByteOffset = Offset - PrevOffset; + return Error::success(); } + llvm::support::endianness Endian; + ItemTraits Traits; ArrayRef<T> Items; }; -} // end namespace msf } // end namespace llvm -#endif // LLVM_DEBUGINFO_MSF_SEQUENCEDITEMSTREAM_H +#endif // LLVM_SUPPORT_BINARYITEMSTREAM_H diff --git a/llvm/include/llvm/DebugInfo/MSF/BinaryStream.h b/llvm/include/llvm/DebugInfo/MSF/BinaryStream.h index 09782d8e3b3..129679f2825 100644 --- a/llvm/include/llvm/DebugInfo/MSF/BinaryStream.h +++ b/llvm/include/llvm/DebugInfo/MSF/BinaryStream.h @@ -1,4 +1,4 @@ -//===- StreamInterface.h - Base interface for a stream of data --*- C++ -*-===// +//===- BinaryStream.h - Base interface for a stream of data -----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,47 +7,62 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_DEBUGINFO_MSF_STREAMINTERFACE_H -#define LLVM_DEBUGINFO_MSF_STREAMINTERFACE_H +#ifndef LLVM_SUPPORT_BINARYSTREAM_H +#define LLVM_SUPPORT_BINARYSTREAM_H #include "llvm/ADT/ArrayRef.h" +#include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" #include <cstdint> namespace llvm { -namespace msf { -class ReadableStream { +/// \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 { public: - virtual ~ReadableStream() = default; + virtual ~BinaryStream() = default; - // 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 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. virtual Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const = 0; + ArrayRef<uint8_t> &Buffer) = 0; - // Given an offset into the stream, read as much as possible without copying - // any data. + /// \brief Given an offset into the stream, read as much as possible without + /// copying any data. virtual Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const = 0; + ArrayRef<uint8_t> &Buffer) = 0; - virtual uint32_t getLength() const = 0; + /// \brief Return the number of bytes of data in this stream. + virtual uint32_t getLength() = 0; }; -class WritableStream : public ReadableStream { +/// \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 { public: - ~WritableStream() override = default; + ~WritableBinaryStream() override = default; - // Attempt to write the given bytes into the stream at the desired offset. - // This will always necessitate a copy. Cannot shrink or grow the stream, - // only writes into existing allocated space. - virtual Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const = 0; + /// \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<uint8_t> Data) = 0; - virtual Error commit() const = 0; + /// \brief For buffered streams, commits changes to the backing store. + virtual Error commit() = 0; }; -} // end namespace msf } // end namespace llvm -#endif // LLVM_DEBUGINFO_MSF_STREAMINTERFACE_H +#endif // LLVM_SUPPORT_BINARYSTREAM_H diff --git a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamArray.h b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamArray.h index 66fbd3c5fe9..d0fbd77a137 100644 --- a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamArray.h +++ b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamArray.h @@ -1,4 +1,4 @@ -//===- StreamArray.h - Array backed by an arbitrary stream ------*- C++ -*-===// +//===- BinaryStreamArray.h - Array backed by an arbitrary stream *- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,8 +7,8 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_DEBUGINFO_MSF_STREAMARRAY_H -#define LLVM_DEBUGINFO_MSF_STREAMARRAY_H +#ifndef LLVM_SUPPORT_BINARYSTREAMARRAY_H +#define LLVM_SUPPORT_BINARYSTREAMARRAY_H #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/iterator.h" @@ -17,11 +17,20 @@ #include <cassert> #include <cstdint> +/// 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<T>, 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 StreamRef pointing to the +/// extraction logic. On input it receives a BinaryStreamRef 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 @@ -35,7 +44,7 @@ namespace msf { template <typename T> struct VarStreamArrayExtractor { // Method intentionally deleted. You must provide an explicit specialization // with the following method implemented. - Error operator()(ReadableStreamRef Stream, uint32_t &Len, + Error operator()(BinaryStreamRef Stream, uint32_t &Len, T &Item) const = delete; }; @@ -49,10 +58,10 @@ template <typename T> 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 -/// a VarStreamArray, no matter how large it may be. +/// or copying 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, it expects you to specialize +/// If you do not specify an Extractor type, you are expected to specialize /// VarStreamArrayExtractor<T> for your ValueType. /// /// By default an Extractor is default constructed in the class, but in some @@ -86,8 +95,8 @@ public: VarStreamArray() = default; explicit VarStreamArray(const Extractor &E) : E(E) {} - explicit VarStreamArray(ReadableStreamRef Stream) : Stream(Stream) {} - VarStreamArray(ReadableStreamRef Stream, const Extractor &E) + explicit VarStreamArray(BinaryStreamRef Stream) : Stream(Stream) {} + VarStreamArray(BinaryStreamRef Stream, const Extractor &E) : Stream(Stream), E(E) {} VarStreamArray(const VarStreamArray<ValueType, Extractor> &Other) @@ -101,10 +110,10 @@ public: const Extractor &getExtractor() const { return E; } - ReadableStreamRef getUnderlyingStream() const { return Stream; } + BinaryStreamRef getUnderlyingStream() const { return Stream; } private: - ReadableStreamRef Stream; + BinaryStreamRef Stream; Extractor E; }; @@ -153,23 +162,25 @@ public: return ThisValue; } - 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. + 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. 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; @@ -188,7 +199,7 @@ private: } ValueType ThisValue; - ReadableStreamRef IterRef; + BinaryStreamRef IterRef; const ArrayType *Array{nullptr}; uint32_t ThisLen{0}; bool HasError{false}; @@ -198,12 +209,17 @@ private: template <typename T> 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 <typename T> class FixedStreamArray { friend class FixedStreamArrayIterator<T>; public: FixedStreamArray() = default; - FixedStreamArray(ReadableStreamRef Stream) : Stream(Stream) { + explicit FixedStreamArray(BinaryStreamRef Stream) : Stream(Stream) { assert(Stream.getLength() % sizeof(T) == 0); } @@ -242,10 +258,10 @@ public: return FixedStreamArrayIterator<T>(*this, size()); } - ReadableStreamRef getUnderlyingStream() const { return Stream; } + BinaryStreamRef getUnderlyingStream() const { return Stream; } private: - ReadableStreamRef Stream; + BinaryStreamRef Stream; }; template <typename T> @@ -298,7 +314,6 @@ private: uint32_t Index; }; -} // namespace msf } // namespace llvm -#endif // LLVM_DEBUGINFO_MSF_STREAMARRAY_H +#endif // LLVM_SUPPORT_BINARYSTREAMARRAY_H diff --git a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamReader.h b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamReader.h index 14768af8ad6..f83076fada4 100644 --- a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamReader.h +++ b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamReader.h @@ -1,4 +1,4 @@ -//===- StreamReader.h - Reads bytes and objects from a stream ---*- C++ -*-===// +//===- BinaryStreamReader.h - Reads objects from a binary stream *- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,71 +7,166 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_DEBUGINFO_MSF_STREAMREADER_H -#define LLVM_DEBUGINFO_MSF_STREAMREADER_H +#ifndef LLVM_SUPPORT_BINARYSTREAMREADER_H +#define LLVM_SUPPORT_BINARYSTREAMREADER_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 <string> #include <type_traits> namespace llvm { -namespace msf { -class StreamReader { +/// \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 { public: - StreamReader(ReadableStreamRef Stream); + explicit BinaryStreamReader(BinaryStreamRef Stream); + virtual ~BinaryStreamReader() {} + /// 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<uint8_t> &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<uint8_t> &Buffer, uint32_t Size); - template <typename T> - Error readInteger(T &Dest, - llvm::support::endianness Endian = llvm::support::native) { + /// 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 <typename T> Error readInteger(T &Dest) { static_assert(std::is_integral<T>::value, "Cannot call readInteger with non-integral value!"); ArrayRef<uint8_t> Bytes; if (auto EC = readBytes(Bytes, sizeof(T))) return EC; + readIntegersImpl(Bytes, Dest); + return Error::success(); + } - Dest = llvm::support::endian::read<T, llvm::support::unaligned>( - Bytes.data(), Endian); + /// 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 <typename... Ts> Error readIntegers(Ts &... Dest) { + const size_t Size = sizeof_sum<Ts...>::value; + ArrayRef<uint8_t> 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); - template <typename T> - Error readEnum(T &Dest, - llvm::support::endianness Endian = llvm::support::native) { + /// Similar to readInteger. + template <typename T> Error readEnum(T &Dest) { static_assert(std::is_enum<T>::value, "Cannot call readEnum with non-enum value!"); typename std::underlying_type<T>::type N; - if (auto EC = readInteger(N, Endian)) + if (auto EC = readInteger(N)) return EC; Dest = static_cast<T>(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 <typename T> Error readObject(const T *&Dest) { ArrayRef<uint8_t> Buffer; if (auto EC = readBytes(Buffer, sizeof(T))) return EC; + assert(alignmentAdjustment(Buffer.data(), alignof(T)) == 0 && + "Reading at invalid alignment!"); Dest = reinterpret_cast<const T *>(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 <typename T> Error readArray(ArrayRef<T> &Array, uint32_t NumElements) { ArrayRef<uint8_t> Bytes; @@ -81,23 +176,43 @@ public: } if (NumElements > UINT32_MAX / sizeof(T)) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); if (auto EC = readBytes(Bytes, NumElements * sizeof(T))) return EC; + + assert(alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && + "Reading at invalid alignment!"); + Array = ArrayRef<T>(reinterpret_cast<const T *>(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 <typename T, typename U> Error readArray(VarStreamArray<T, U> &Array, uint32_t Size) { - ReadableStreamRef S; + BinaryStreamRef S; if (auto EC = readStreamRef(S, Size)) return EC; Array = VarStreamArray<T, U>(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 <typename T> Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) { if (NumItems == 0) { @@ -106,10 +221,11 @@ public: } uint32_t Length = NumItems * sizeof(T); if (Length / sizeof(T) != NumItems) - return make_error<MSFError>(msf_error_code::invalid_format); + return errorCodeToError( + make_error_code(std::errc::illegal_byte_sequence)); if (Offset + Length > Stream.getLength()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); - ReadableStreamRef View = Stream.slice(Offset, Length); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); + BinaryStreamRef View = Stream.slice(Offset, Length); Array = FixedStreamArray<T>(View); Offset += Length; return Error::success(); @@ -121,15 +237,36 @@ 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: - ReadableStreamRef Stream; + template <typename T> + void readIntegersImpl(ArrayRef<uint8_t> Bytes, T &Dest) { + Dest = llvm::support::endian::read<T, llvm::support::unaligned>( + Bytes.data(), Stream.getEndian()); + } + + template <typename T, typename... Ts> + void readIntegersImpl(ArrayRef<uint8_t> 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; uint32_t Offset; }; -} // namespace msf } // namespace llvm -#endif // LLVM_DEBUGINFO_MSF_STREAMREADER_H +#endif // LLVM_SUPPORT_BINARYSTREAMREADER_H diff --git a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamRef.h b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamRef.h index 6d0700bdd0b..dd20bbca2c1 100644 --- a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamRef.h +++ b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamRef.h @@ -1,4 +1,4 @@ -//===- StreamRef.h - A copyable reference to a stream -----------*- C++ -*-===// +//===- BinaryStreamRef.h - A copyable reference to a stream -----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,28 +7,30 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_DEBUGINFO_MSF_STREAMREF_H -#define LLVM_DEBUGINFO_MSF_STREAMREF_H +#ifndef LLVM_SUPPORT_BINARYSTREAMREF_H +#define LLVM_SUPPORT_BINARYSTREAMREF_H #include "llvm/ADT/ArrayRef.h" #include "llvm/DebugInfo/MSF/BinaryStream.h" -#include "llvm/DebugInfo/MSF/MSFError.h" #include "llvm/Support/Error.h" #include <algorithm> #include <cstdint> namespace llvm { -namespace msf { -template <class StreamType, class RefType> class StreamRefBase { +/// Common stuff for mutable and immutable StreamRefs. +template <class StreamType, class RefType> class BinaryStreamRefBase { public: - StreamRefBase() : Stream(nullptr), ViewOffset(0), Length(0) {} - StreamRefBase(const StreamType &Stream, uint32_t Offset, uint32_t Length) + BinaryStreamRefBase() : Stream(nullptr), ViewOffset(0), Length(0) {} + BinaryStreamRefBase(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(); @@ -37,6 +39,7 @@ 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(); @@ -44,6 +47,8 @@ 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); } @@ -59,40 +64,55 @@ public: } protected: - const StreamType *Stream; + StreamType *Stream; uint32_t ViewOffset; uint32_t Length; }; -class ReadableStreamRef - : public StreamRefBase<ReadableStream, ReadableStreamRef> { +/// \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<BinaryStream, BinaryStreamRef> { public: - 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 StreamRef.slice() instead. - ReadableStreamRef(const ReadableStreamRef &S, uint32_t Offset, - uint32_t Length) = delete; - + BinaryStreamRef() = default; + BinaryStreamRef(BinaryStream &Stream) + : BinaryStreamRefBase(Stream, 0, Stream.getLength()) {} + BinaryStreamRef(BinaryStream &Stream, uint32_t Offset, uint32_t Length) + : BinaryStreamRefBase(Stream, Offset, Length) {} + + // Use BinaryStreamRef.slice() instead. + BinaryStreamRef(BinaryStreamRef &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<uint8_t> &Buffer) const { if (ViewOffset + Offset < Offset) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); if (Size + Offset > Length) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); return Stream->readBytes(ViewOffset + Offset, Size, Buffer); } - // Given an offset into the stream, read as much as possible without copying - // any data. + /// 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. Error readLongestContiguousChunk(uint32_t Offset, ArrayRef<uint8_t> &Buffer) const { if (Offset >= Length) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); if (auto EC = Stream->readLongestContiguousChunk(Offset, Buffer)) return EC; @@ -106,30 +126,39 @@ public: } }; -class WritableStreamRef - : public StreamRefBase<WritableStream, WritableStreamRef> { +class WritableBinaryStreamRef + : public BinaryStreamRefBase<WritableBinaryStream, + WritableBinaryStreamRef> { public: - 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 StreamRef.slice() instead. - WritableStreamRef(const WritableStreamRef &S, uint32_t Offset, - uint32_t Length) = delete; - + WritableBinaryStreamRef() = default; + WritableBinaryStreamRef(WritableBinaryStream &Stream) + : BinaryStreamRefBase(Stream, 0, Stream.getLength()) {} + WritableBinaryStreamRef(WritableBinaryStream &Stream, uint32_t Offset, + uint32_t Length) + : BinaryStreamRefBase(Stream, Offset, Length) {} + + // Use WritableBinaryStreamRef.slice() instead. + WritableBinaryStreamRef(WritableBinaryStreamRef &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<uint8_t> Data) const { if (Data.size() + Offset > Length) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); return Stream->writeBytes(ViewOffset + Offset, Data); } - Error commit() const { return Stream->commit(); } + operator BinaryStreamRef() { return BinaryStreamRef(*Stream); } + + /// \brief For buffered streams, commits changes to the backing store. + Error commit() { return Stream->commit(); } }; -} // end namespace msf } // end namespace llvm -#endif // LLVM_DEBUGINFO_MSF_STREAMREF_H +#endif // LLVM_SUPPORT_BINARYSTREAMREF_H diff --git a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h index bf911a91684..5635fc91587 100644 --- a/llvm/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h +++ b/llvm/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h @@ -1,4 +1,4 @@ -//===- StreamWriter.h - Writes bytes and objects to a stream ----*- C++ -*-===// +//===- BinaryStreamWriter.h - Writes objects to a BinaryStream ---*- C++-*-===// // // The LLVM Compiler Infrastructure // @@ -7,55 +7,121 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_DEBUGINFO_MSF_STREAMWRITER_H -#define LLVM_DEBUGINFO_MSF_STREAMWRITER_H +#ifndef LLVM_SUPPORT_BINARYSTREAMWRITER_H +#define LLVM_SUPPORT_BINARYSTREAMWRITER_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 <cstdint> #include <type_traits> namespace llvm { -namespace msf { -class StreamWriter { +/// \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 { public: - StreamWriter() = default; - explicit StreamWriter(WritableStreamRef Stream); - + BinaryStreamWriter() = default; + explicit BinaryStreamWriter(WritableBinaryStreamRef Stream); + virtual ~BinaryStreamWriter() {} + + /// 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<uint8_t> Buffer); - template <typename T> - Error writeInteger(T Value, - llvm::support::endianness Endian = llvm::support::native) { - static_assert(std::is_integral<T>::value, - "Cannot call writeInteger with non-integral value!"); - uint8_t Buffer[sizeof(T)]; - llvm::support::endian::write<T, llvm::support::unaligned>(Buffer, Value, - Endian); - return writeBytes(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 <typename T> Error writeInteger(T Value) { + return writeIntegers(Value); } - Error writeZeroString(StringRef Str); - Error writeFixedString(StringRef Str); - Error writeStreamRef(ReadableStreamRef Ref); - Error writeStreamRef(ReadableStreamRef Ref, uint32_t Size); + /// 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 <typename... Ts> Error writeIntegers(Ts... Ints) { + uint8_t Buffer[sizeof_sum<Ts...>::value]; + + writeIntegersImpl(Buffer, Ints...); + return writeBytes(Buffer); + } - template <typename T> - Error writeEnum(T Num, - llvm::support::endianness Endian = llvm::support::native) { + /// Similar to writeInteger + template <typename T> Error writeEnum(T Num) { static_assert(std::is_enum<T>::value, "Cannot call writeEnum with non-Enum type"); using U = typename std::underlying_type<T>::type; - return writeInteger<U>(static_cast<U>(Num), Endian); + return writeInteger<U>(static_cast<U>(Num)); } + /// 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 <typename T> Error writeObject(const T &Obj) { static_assert(!std::is_pointer<T>::value, "writeObject should not be used with pointers, to write " @@ -65,23 +131,38 @@ public: ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&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 <typename T> Error writeArray(ArrayRef<T> Array) { if (Array.empty()) return Error::success(); if (Array.size() > UINT32_MAX / sizeof(T)) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); return writeBytes( ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(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 <typename T, typename U> Error writeArray(VarStreamArray<T, U> 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 <typename T> Error writeArray(FixedStreamArray<T> Array) { return writeStreamRef(Array.getUnderlyingStream()); } @@ -91,12 +172,28 @@ public: uint32_t getLength() const { return Stream.getLength(); } uint32_t bytesRemaining() const { return getLength() - getOffset(); } -private: - WritableStreamRef Stream; +protected: + template <typename T> + void writeIntegersImpl(MutableArrayRef<uint8_t> Buffer, T Value) { + static_assert(std::is_integral<T>::value, + "Cannot call writeInteger with non-integral value!"); + assert(Buffer.size() == sizeof(T)); + llvm::support::endian::write<T, llvm::support::unaligned>( + Buffer.data(), Value, Stream.getEndian()); + } + + template <typename T, typename... Ts> + void writeIntegersImpl(MutableArrayRef<uint8_t> 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; uint32_t Offset = 0; }; -} // end namespace msf } // end namespace llvm -#endif // LLVM_DEBUGINFO_MSF_STREAMWRITER_H +#endif // LLVM_SUPPORT_BINARYSTREAMWRITER_H diff --git a/llvm/include/llvm/DebugInfo/MSF/MappedBlockStream.h b/llvm/include/llvm/DebugInfo/MSF/MappedBlockStream.h index e4a0fd17a83..96342845378 100644 --- a/llvm/include/llvm/DebugInfo/MSF/MappedBlockStream.h +++ b/llvm/include/llvm/DebugInfo/MSF/MappedBlockStream.h @@ -15,6 +15,8 @@ #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" @@ -37,29 +39,33 @@ 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 ReadableStream { +class MappedBlockStream : public BinaryStream { friend class WritableMappedBlockStream; public: static std::unique_ptr<MappedBlockStream> createStream(uint32_t BlockSize, uint32_t NumBlocks, - const MSFStreamLayout &Layout, const ReadableStream &MsfData); + const MSFStreamLayout &Layout, BinaryStreamRef MsfData); static std::unique_ptr<MappedBlockStream> - createIndexedStream(const MSFLayout &Layout, const ReadableStream &MsfData, + createIndexedStream(const MSFLayout &Layout, BinaryStreamRef MsfData, uint32_t StreamIndex); static std::unique_ptr<MappedBlockStream> - createFpmStream(const MSFLayout &Layout, const ReadableStream &MsfData); + createFpmStream(const MSFLayout &Layout, BinaryStreamRef MsfData); static std::unique_ptr<MappedBlockStream> - createDirectoryStream(const MSFLayout &Layout, const ReadableStream &MsfData); + createDirectoryStream(const MSFLayout &Layout, BinaryStreamRef MsfData); + + llvm::support::endianness getEndian() const override { + return llvm::support::little; + } Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const override; + ArrayRef<uint8_t> &Buffer) override; Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override; + ArrayRef<uint8_t> &Buffer) override; - uint32_t getLength() const override; + uint32_t getLength() override; uint32_t getNumBytesCopied() const; @@ -74,51 +80,56 @@ public: protected: MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &StreamLayout, - const ReadableStream &MsfData); + BinaryStreamRef MsfData); private: const MSFStreamLayout &getStreamLayout() const { return StreamLayout; } void fixCacheAfterWrite(uint32_t Offset, ArrayRef<uint8_t> Data) const; - Error readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer) const; + Error readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer); bool tryReadContiguously(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const; + ArrayRef<uint8_t> &Buffer); const uint32_t BlockSize; const uint32_t NumBlocks; const MSFStreamLayout StreamLayout; - const ReadableStream &MsfData; + BinaryStreamRef MsfData; typedef MutableArrayRef<uint8_t> CacheEntry; - mutable llvm::BumpPtrAllocator Pool; - mutable DenseMap<uint32_t, std::vector<CacheEntry>> CacheMap; + llvm::BumpPtrAllocator Pool; + DenseMap<uint32_t, std::vector<CacheEntry>> CacheMap; }; -class WritableMappedBlockStream : public WritableStream { +class WritableMappedBlockStream : public WritableBinaryStream { public: static std::unique_ptr<WritableMappedBlockStream> createStream(uint32_t BlockSize, uint32_t NumBlocks, - const MSFStreamLayout &Layout, const WritableStream &MsfData); + const MSFStreamLayout &Layout, WritableBinaryStreamRef MsfData); static std::unique_ptr<WritableMappedBlockStream> - createIndexedStream(const MSFLayout &Layout, const WritableStream &MsfData, + createIndexedStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData, uint32_t StreamIndex); static std::unique_ptr<WritableMappedBlockStream> - createDirectoryStream(const MSFLayout &Layout, const WritableStream &MsfData); + createDirectoryStream(const MSFLayout &Layout, + WritableBinaryStreamRef MsfData); static std::unique_ptr<WritableMappedBlockStream> - createFpmStream(const MSFLayout &Layout, const WritableStream &MsfData); + createFpmStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData); + + llvm::support::endianness getEndian() const override { + return llvm::support::little; + } Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const override; + ArrayRef<uint8_t> &Buffer) override; Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override; - uint32_t getLength() const override; + ArrayRef<uint8_t> &Buffer) override; + uint32_t getLength() override; - Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override; + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) override; - Error commit() const override; + Error commit() override; const MSFStreamLayout &getStreamLayout() const { return ReadInterface.getStreamLayout(); @@ -130,12 +141,12 @@ public: protected: WritableMappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &StreamLayout, - const WritableStream &MsfData); + WritableBinaryStreamRef MsfData); private: MappedBlockStream ReadInterface; - const WritableStream &WriteInterface; + WritableBinaryStreamRef WriteInterface; }; } // end namespace pdb diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/DbiStream.h b/llvm/include/llvm/DebugInfo/PDB/Native/DbiStream.h index 977b114ca24..38d338d6d83 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/DbiStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/DbiStream.h @@ -12,6 +12,8 @@ #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" @@ -70,11 +72,11 @@ public: Expected<StringRef> getFileNameForIndex(uint32_t Index) const; - msf::FixedStreamArray<object::coff_section> getSectionHeaders(); + FixedStreamArray<object::coff_section> getSectionHeaders(); - msf::FixedStreamArray<object::FpoData> getFpoRecords(); + FixedStreamArray<object::FpoData> getFpoRecords(); - msf::FixedStreamArray<SecMapEntry> getSectionMap() const; + FixedStreamArray<SecMapEntry> getSectionMap() const; void visitSectionContributions(ISectionContribVisitor &Visitor) const; private: @@ -91,28 +93,28 @@ private: std::vector<ModuleInfoEx> ModuleInfos; StringTable ECNames; - msf::ReadableStreamRef ModInfoSubstream; - msf::ReadableStreamRef SecContrSubstream; - msf::ReadableStreamRef SecMapSubstream; - msf::ReadableStreamRef FileInfoSubstream; - msf::ReadableStreamRef TypeServerMapSubstream; - msf::ReadableStreamRef ECSubstream; + BinaryStreamRef ModInfoSubstream; + BinaryStreamRef SecContrSubstream; + BinaryStreamRef SecMapSubstream; + BinaryStreamRef FileInfoSubstream; + BinaryStreamRef TypeServerMapSubstream; + BinaryStreamRef ECSubstream; - msf::ReadableStreamRef NamesBuffer; + BinaryStreamRef NamesBuffer; - msf::FixedStreamArray<support::ulittle16_t> DbgStreams; + FixedStreamArray<support::ulittle16_t> DbgStreams; PdbRaw_DbiSecContribVer SectionContribVersion; - msf::FixedStreamArray<SectionContrib> SectionContribs; - msf::FixedStreamArray<SectionContrib2> SectionContribs2; - msf::FixedStreamArray<SecMapEntry> SectionMap; - msf::FixedStreamArray<support::little32_t> FileNameOffsets; + FixedStreamArray<SectionContrib> SectionContribs; + FixedStreamArray<SectionContrib2> SectionContribs2; + FixedStreamArray<SecMapEntry> SectionMap; + FixedStreamArray<support::little32_t> FileNameOffsets; std::unique_ptr<msf::MappedBlockStream> SectionHeaderStream; - msf::FixedStreamArray<object::coff_section> SectionHeaders; + FixedStreamArray<object::coff_section> SectionHeaders; std::unique_ptr<msf::MappedBlockStream> FpoStream; - msf::FixedStreamArray<object::FpoData> FpoRecords; + FixedStreamArray<object::FpoData> FpoRecords; const DbiStreamHeader *Header; }; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h index b1e8d5087d4..0090022cdcc 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h @@ -60,7 +60,7 @@ public: Error finalizeMsfLayout(); - Error commit(const msf::MSFLayout &Layout, const msf::WritableStream &Buffer); + Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef Buffer); // A helper function to create Section Contributions from COFF input // section headers. @@ -112,9 +112,9 @@ private: StringMap<uint32_t> SourceFileNames; - msf::WritableStreamRef NamesBuffer; - msf::MutableByteStream ModInfoBuffer; - msf::MutableByteStream FileInfoBuffer; + WritableBinaryStreamRef NamesBuffer; + MutableBinaryByteStream ModInfoBuffer; + MutableBinaryByteStream FileInfoBuffer; ArrayRef<SectionContrib> SectionContribs; ArrayRef<SecMapEntry> SectionMap; llvm::SmallVector<DebugStream, (int)DbgHeaderType::Max> DbgStreams; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h b/llvm/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h index 71aa0a5236e..de744255e44 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h @@ -11,6 +11,7 @@ #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" #include "llvm/DebugInfo/PDB/Native/RawTypes.h" @@ -27,15 +28,15 @@ public: explicit GlobalsStream(std::unique_ptr<msf::MappedBlockStream> Stream); ~GlobalsStream(); Error commit(); - msf::FixedStreamArray<support::ulittle32_t> getHashBuckets() const { + FixedStreamArray<support::ulittle32_t> getHashBuckets() const { return HashBuckets; } uint32_t getNumBuckets() const { return NumBuckets; } Error reload(); private: - msf::FixedStreamArray<support::ulittle32_t> HashBuckets; - msf::FixedStreamArray<PSHashRecord> HashRecords; + FixedStreamArray<support::ulittle32_t> HashBuckets; + FixedStreamArray<PSHashRecord> HashRecords; uint32_t NumBuckets; std::unique_ptr<msf::MappedBlockStream> Stream; }; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/HashTable.h b/llvm/include/llvm/DebugInfo/PDB/Native/HashTable.h index 101a5772e7c..74d5e4caed4 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/HashTable.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/HashTable.h @@ -42,10 +42,10 @@ public: HashTable(); explicit HashTable(uint32_t Capacity); - Error load(msf::StreamReader &Stream); + Error load(BinaryStreamReader &Stream); uint32_t calculateSerializedLength() const; - Error commit(msf::StreamWriter &Writer) const; + Error commit(BinaryStreamWriter &Writer) const; void clear(); @@ -71,9 +71,9 @@ private: static uint32_t maxLoad(uint32_t capacity); void grow(); - static Error readSparseBitVector(msf::StreamReader &Stream, + static Error readSparseBitVector(BinaryStreamReader &Stream, SparseBitVector<> &V); - static Error writeSparseBitVector(msf::StreamWriter &Writer, + static Error writeSparseBitVector(BinaryStreamWriter &Writer, SparseBitVector<> &Vec); }; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h index 1b182bc65aa..77d73cc859b 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h @@ -19,9 +19,10 @@ #include "llvm/DebugInfo/PDB/PDBTypes.h" namespace llvm { +class WritableBinaryStream; + namespace msf { class MSFBuilder; -class StreamWriter; } namespace pdb { class PDBFile; @@ -43,7 +44,7 @@ public: Error finalizeMsfLayout(); Error commit(const msf::MSFLayout &Layout, - const msf::WritableStream &Buffer) const; + WritableBinaryStreamRef Buffer) const; private: msf::MSFBuilder &Msf; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/ModInfo.h b/llvm/include/llvm/DebugInfo/PDB/Native/ModInfo.h index 391d61d2535..c6b977bd648 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/ModInfo.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/ModInfo.h @@ -30,7 +30,7 @@ public: ModInfo(const ModInfo &Info); ~ModInfo(); - static Error initialize(msf::ReadableStreamRef Stream, ModInfo &Info); + static Error initialize(BinaryStreamRef Stream, ModInfo &Info); bool hasECInfo() const; uint16_t getTypeServerIndex() const; @@ -63,10 +63,8 @@ struct ModuleInfoEx { } // end namespace pdb -namespace msf { - template <> struct VarStreamArrayExtractor<pdb::ModInfo> { - Error operator()(ReadableStreamRef Stream, uint32_t &Length, + Error operator()(BinaryStreamRef Stream, uint32_t &Length, pdb::ModInfo &Info) const { if (auto EC = pdb::ModInfo::initialize(Stream, Info)) return EC; @@ -75,8 +73,6 @@ template <> struct VarStreamArrayExtractor<pdb::ModInfo> { } }; -} // end namespace msf - } // end namespace llvm #endif // LLVM_DEBUGINFO_PDB_RAW_MODINFO_H diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/ModStream.h b/llvm/include/llvm/DebugInfo/PDB/Native/ModStream.h index f9ce63fc3c2..88312ac3958 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/ModStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/ModStream.h @@ -50,9 +50,9 @@ private: std::unique_ptr<msf::MappedBlockStream> Stream; codeview::CVSymbolArray SymbolsSubstream; - msf::ReadableStreamRef LinesSubstream; - msf::ReadableStreamRef C13LinesSubstream; - msf::ReadableStreamRef GlobalRefsSubstream; + BinaryStreamRef LinesSubstream; + BinaryStreamRef C13LinesSubstream; + BinaryStreamRef GlobalRefsSubstream; codeview::ModuleSubstreamArray LineInfo; }; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h b/llvm/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h index c5cf76e7740..2327bfadb69 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h @@ -17,10 +17,9 @@ #include <cstdint> namespace llvm { -namespace msf { -class StreamReader; -class StreamWriter; -} +class BinaryStreamReader; +class BinaryStreamWriter; + namespace pdb { class NamedStreamMapBuilder; class NamedStreamMap { @@ -33,8 +32,8 @@ class NamedStreamMap { public: NamedStreamMap(); - Error load(msf::StreamReader &Stream); - Error commit(msf::StreamWriter &Writer) const; + Error load(BinaryStreamReader &Stream); + Error commit(BinaryStreamWriter &Writer) const; uint32_t finalize(); bool get(StringRef Stream, uint32_t &StreamNo) const; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/PDBFile.h b/llvm/include/llvm/DebugInfo/PDB/Native/PDBFile.h index 6802e397622..9b7ba7aeea4 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/PDBFile.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/PDBFile.h @@ -12,6 +12,8 @@ #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" @@ -42,7 +44,7 @@ class PDBFile : public msf::IMSFFile { friend PDBFileBuilder; public: - PDBFile(StringRef Path, std::unique_ptr<msf::ReadableStream> PdbFileBuffer, + PDBFile(StringRef Path, std::unique_ptr<BinaryStream> PdbFileBuffer, BumpPtrAllocator &Allocator); ~PDBFile() override; @@ -80,7 +82,7 @@ public: } const msf::MSFLayout &getMsfLayout() const { return ContainerLayout; } - const msf::ReadableStream &getMsfBuffer() const { return *Buffer; } + BinaryStreamRef getMsfBuffer() const { return *Buffer; } ArrayRef<support::ulittle32_t> getDirectoryBlockArray() const; @@ -110,13 +112,13 @@ public: private: Expected<std::unique_ptr<msf::MappedBlockStream>> safelyCreateIndexedStream(const msf::MSFLayout &Layout, - const msf::ReadableStream &MsfData, + BinaryStreamRef MsfData, uint32_t StreamIndex) const; std::string FilePath; BumpPtrAllocator &Allocator; - std::unique_ptr<msf::ReadableStream> Buffer; + std::unique_ptr<BinaryStream> Buffer; std::vector<uint32_t> FpmPages; msf::MSFLayout ContainerLayout; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/PublicsStream.h b/llvm/include/llvm/DebugInfo/PDB/Native/PublicsStream.h index 13a9624fdcb..b93645ec945 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/PublicsStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/PublicsStream.h @@ -17,6 +17,7 @@ #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 { @@ -38,16 +39,16 @@ public: uint32_t getNumBuckets() const { return NumBuckets; } iterator_range<codeview::CVSymbolArray::Iterator> getSymbols(bool *HadError) const; - msf::FixedStreamArray<support::ulittle32_t> getHashBuckets() const { + FixedStreamArray<support::ulittle32_t> getHashBuckets() const { return HashBuckets; } - msf::FixedStreamArray<support::ulittle32_t> getAddressMap() const { + FixedStreamArray<support::ulittle32_t> getAddressMap() const { return AddressMap; } - msf::FixedStreamArray<support::ulittle32_t> getThunkMap() const { + FixedStreamArray<support::ulittle32_t> getThunkMap() const { return ThunkMap; } - msf::FixedStreamArray<SectionOffset> getSectionOffsets() const { + FixedStreamArray<SectionOffset> getSectionOffsets() const { return SectionOffsets; } @@ -59,11 +60,11 @@ private: std::unique_ptr<msf::MappedBlockStream> Stream; uint32_t NumBuckets = 0; ArrayRef<uint8_t> Bitmap; - msf::FixedStreamArray<PSHashRecord> HashRecords; - msf::FixedStreamArray<support::ulittle32_t> HashBuckets; - msf::FixedStreamArray<support::ulittle32_t> AddressMap; - msf::FixedStreamArray<support::ulittle32_t> ThunkMap; - msf::FixedStreamArray<SectionOffset> SectionOffsets; + FixedStreamArray<PSHashRecord> HashRecords; + FixedStreamArray<support::ulittle32_t> HashBuckets; + FixedStreamArray<support::ulittle32_t> AddressMap; + FixedStreamArray<support::ulittle32_t> ThunkMap; + FixedStreamArray<SectionOffset> SectionOffsets; const HeaderInfo *Header; const GSIHashHeader *HashHdr; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/StringTable.h b/llvm/include/llvm/DebugInfo/PDB/Native/StringTable.h index 4c71018f014..4073a2ebdfd 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/StringTable.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/StringTable.h @@ -20,16 +20,15 @@ #include <vector> namespace llvm { -namespace msf { -class StreamReader; -} +class BinaryStreamReader; + namespace pdb { class StringTable { public: StringTable(); - Error load(msf::StreamReader &Stream); + Error load(BinaryStreamReader &Stream); uint32_t getNameCount() const { return NameCount; } uint32_t getHashVersion() const { return HashVersion; } @@ -38,11 +37,11 @@ public: StringRef getStringForID(uint32_t ID) const; uint32_t getIDForString(StringRef Str) const; - msf::FixedStreamArray<support::ulittle32_t> name_ids() const; + FixedStreamArray<support::ulittle32_t> name_ids() const; private: - msf::ReadableStreamRef NamesBuffer; - msf::FixedStreamArray<support::ulittle32_t> IDs; + BinaryStreamRef NamesBuffer; + FixedStreamArray<support::ulittle32_t> IDs; uint32_t Signature; uint32_t HashVersion; uint32_t NameCount; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h index d6a20831b1e..dd0f40b1978 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h @@ -20,9 +20,8 @@ #include <vector> namespace llvm { -namespace msf { -class StreamWriter; -} +class BinaryStreamWriter; + namespace pdb { class StringTableBuilder { @@ -32,7 +31,7 @@ public: uint32_t insert(StringRef S); uint32_t finalize(); - Error commit(msf::StreamWriter &Writer) const; + Error commit(BinaryStreamWriter &Writer) const; private: DenseMap<StringRef, uint32_t> Strings; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/TpiHashing.h b/llvm/include/llvm/DebugInfo/PDB/Native/TpiHashing.h index 9aa6bb4e66e..f13b615d089 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/TpiHashing.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/TpiHashing.h @@ -57,7 +57,7 @@ private: class TpiHashVerifier : public codeview::TypeVisitorCallbacks { public: - TpiHashVerifier(msf::FixedStreamArray<support::ulittle32_t> &HashValues, + TpiHashVerifier(FixedStreamArray<support::ulittle32_t> &HashValues, uint32_t NumHashBuckets) : HashValues(HashValues), NumHashBuckets(NumHashBuckets) {} @@ -83,7 +83,7 @@ private: utohexstr(codeview::TypeIndex::FirstNonSimpleIndex + Index)); } - msf::FixedStreamArray<support::ulittle32_t> HashValues; + FixedStreamArray<support::ulittle32_t> HashValues; codeview::CVType RawRecord; uint32_t NumHashBuckets; uint32_t Index = -1; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/TpiStream.h b/llvm/include/llvm/DebugInfo/PDB/Native/TpiStream.h index 2ee2faa6d91..b2f66cb045d 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/TpiStream.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/TpiStream.h @@ -46,8 +46,8 @@ public: uint32_t getHashKeySize() const; uint32_t NumHashBuckets() const; - msf::FixedStreamArray<support::ulittle32_t> getHashValues() const; - msf::FixedStreamArray<TypeIndexOffset> getTypeIndexOffsets() const; + FixedStreamArray<support::ulittle32_t> getHashValues() const; + FixedStreamArray<TypeIndexOffset> getTypeIndexOffsets() const; HashTable &getHashAdjusters(); codeview::CVTypeRange types(bool *HadError) const; @@ -62,9 +62,9 @@ private: codeview::CVTypeArray TypeRecords; - std::unique_ptr<msf::ReadableStream> HashStream; - msf::FixedStreamArray<support::ulittle32_t> HashValues; - msf::FixedStreamArray<TypeIndexOffset> TypeIndexOffsets; + std::unique_ptr<BinaryStream> HashStream; + FixedStreamArray<support::ulittle32_t> HashValues; + FixedStreamArray<TypeIndexOffset> TypeIndexOffsets; HashTable HashAdjusters; const TpiStreamHeader *Header; diff --git a/llvm/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h b/llvm/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h index 2cedf56f621..a430c426af1 100644 --- a/llvm/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h +++ b/llvm/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h @@ -21,22 +21,22 @@ #include <vector> namespace llvm { -namespace codeview { -class TypeRecord; -} -namespace msf { -class ByteStream; -class MSFBuilder; -struct MSFLayout; -class ReadableStreamRef; -class WritableStream; +class BinaryStreamRef; +class WritableBinaryStream; -template <> struct SequencedItemTraits<llvm::codeview::CVType> { +template <> struct BinaryItemTraits<llvm::codeview::CVType> { static size_t length(const codeview::CVType &Item) { return Item.length(); } static ArrayRef<uint8_t> 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, const msf::WritableStream &Buffer); + Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef Buffer); - uint32_t calculateSerializedLength() const; + uint32_t calculateSerializedLength(); private: uint32_t calculateHashBufferSize() const; @@ -69,9 +69,9 @@ private: Optional<PdbRaw_TpiVer> VerHeader; std::vector<codeview::CVType> TypeRecords; - msf::SequencedItemStream<codeview::CVType> TypeRecordStream; + BinaryItemStream<codeview::CVType> TypeRecordStream; uint32_t HashStreamIndex = kInvalidStreamIndex; - std::unique_ptr<msf::ByteStream> HashValueStream; + std::unique_ptr<BinaryByteStream> HashValueStream; const TpiStreamHeader *Header; uint32_t Idx; diff --git a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp index 2d9b0139f4f..c1dfb900a8d 100644 --- a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp @@ -38,7 +38,6 @@ using namespace llvm; using namespace llvm::codeview; -using namespace llvm::msf; CodeViewDebug::CodeViewDebug(AsmPrinter *AP) : DebugHandlerBase(AP), OS(*Asm->OutStreamer), Allocator(), @@ -495,9 +494,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. - ByteStream Stream(Record); + BinaryByteStream Stream(Record, llvm::support::little); CVTypeArray Types; - StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); Error E = Reader.readArray(Types, Reader.getLength()); if (!E) { TypeVisitorCallbacks C; diff --git a/llvm/lib/DebugInfo/CodeView/CVTypeDumper.cpp b/llvm/lib/DebugInfo/CodeView/CVTypeDumper.cpp index f862c202b5d..a94516985b8 100644 --- a/llvm/lib/DebugInfo/CodeView/CVTypeDumper.cpp +++ b/llvm/lib/DebugInfo/CodeView/CVTypeDumper.cpp @@ -56,9 +56,9 @@ Error CVTypeDumper::dump(const CVTypeArray &Types, } Error CVTypeDumper::dump(ArrayRef<uint8_t> Data, TypeVisitorCallbacks &Dumper) { - msf::ByteStream Stream(Data); + BinaryByteStream Stream(Data, llvm::support::little); CVTypeArray Types; - msf::StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); if (auto EC = Reader.readArray(Types, Reader.getLength())) return EC; diff --git a/llvm/lib/DebugInfo/CodeView/CVTypeVisitor.cpp b/llvm/lib/DebugInfo/CodeView/CVTypeVisitor.cpp index aa0621273c5..74c60c78b8b 100644 --- a/llvm/lib/DebugInfo/CodeView/CVTypeVisitor.cpp +++ b/llvm/lib/DebugInfo/CodeView/CVTypeVisitor.cpp @@ -174,7 +174,7 @@ Error CVTypeVisitor::visitTypeStream(CVTypeRange Types) { return Error::success(); } -Error CVTypeVisitor::visitFieldListMemberStream(msf::StreamReader Reader) { +Error CVTypeVisitor::visitFieldListMemberStream(BinaryStreamReader Reader) { FieldListDeserializer Deserializer(Reader); TypeVisitorCallbackPipeline Pipeline; Pipeline.addCallbackToPipeline(Deserializer); @@ -182,7 +182,7 @@ Error CVTypeVisitor::visitFieldListMemberStream(msf::StreamReader Reader) { TypeLeafKind Leaf; while (!Reader.empty()) { - if (auto EC = Reader.readEnum(Leaf, llvm::support::little)) + if (auto EC = Reader.readEnum(Leaf)) return EC; CVMemberRecord Record; @@ -195,7 +195,7 @@ Error CVTypeVisitor::visitFieldListMemberStream(msf::StreamReader Reader) { } Error CVTypeVisitor::visitFieldListMemberStream(ArrayRef<uint8_t> Data) { - msf::ByteStream S(Data); - msf::StreamReader SR(S); + BinaryByteStream S(Data, llvm::support::little); + BinaryStreamReader SR(S); return visitFieldListMemberStream(SR); } diff --git a/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp b/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp index fd60059b5c6..a204d43ba13 100644 --- a/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp +++ b/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp @@ -87,14 +87,13 @@ Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes) { Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd) { if (isWriting()) { - if (auto EC = - Writer->writeInteger(TypeInd.getIndex(), llvm::support::little)) + if (auto EC = Writer->writeInteger(TypeInd.getIndex())) return EC; return Error::success(); } uint32_t I; - if (auto EC = Reader->readInteger(I, llvm::support::little)) + if (auto EC = Reader->readInteger(I)) return EC; TypeInd.setIndex(I); return Error::success(); @@ -146,10 +145,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->writeZeroString(S)) + if (auto EC = Writer->writeCString(S)) return EC; } else { - if (auto EC = Reader->readZeroString(Value)) + if (auto EC = Reader->readCString(Value)) return EC; } return Error::success(); @@ -177,7 +176,7 @@ Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value) { if (auto EC = mapStringZ(V)) return EC; } - if (auto EC = Writer->writeInteger<uint8_t>(0, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint8_t>(0)) return EC; } else { StringRef S; @@ -195,28 +194,24 @@ Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value) { Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) { assert(Value < 0 && "Encoded integer is not signed!"); if (Value >= std::numeric_limits<int8_t>::min()) { - if (auto EC = - Writer->writeInteger<uint16_t>(LF_CHAR, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR)) return EC; - if (auto EC = Writer->writeInteger<int8_t>(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger<int8_t>(Value)) return EC; } else if (Value >= std::numeric_limits<int16_t>::min()) { - if (auto EC = - Writer->writeInteger<uint16_t>(LF_SHORT, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(LF_SHORT)) return EC; - if (auto EC = Writer->writeInteger<int16_t>(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger<int16_t>(Value)) return EC; } else if (Value >= std::numeric_limits<int32_t>::min()) { - if (auto EC = - Writer->writeInteger<uint16_t>(LF_LONG, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(LF_LONG)) return EC; - if (auto EC = Writer->writeInteger<int32_t>(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger<int32_t>(Value)) return EC; } else { - if (auto EC = - Writer->writeInteger<uint16_t>(LF_QUADWORD, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(LF_QUADWORD)) return EC; - if (auto EC = Writer->writeInteger(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger(Value)) return EC; } return Error::success(); @@ -224,25 +219,22 @@ Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) { Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) { if (Value < LF_NUMERIC) { - if (auto EC = Writer->writeInteger<uint16_t>(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(Value)) return EC; } else if (Value <= std::numeric_limits<uint16_t>::max()) { - if (auto EC = - Writer->writeInteger<uint16_t>(LF_USHORT, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(LF_USHORT)) return EC; - if (auto EC = Writer->writeInteger<uint16_t>(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(Value)) return EC; } else if (Value <= std::numeric_limits<uint32_t>::max()) { - if (auto EC = - Writer->writeInteger<uint16_t>(LF_ULONG, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(LF_ULONG)) return EC; - if (auto EC = Writer->writeInteger<uint32_t>(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint32_t>(Value)) return EC; } else { - if (auto EC = - Writer->writeInteger<uint16_t>(LF_UQUADWORD, llvm::support::little)) + if (auto EC = Writer->writeInteger<uint16_t>(LF_UQUADWORD)) return EC; - if (auto EC = Writer->writeInteger(Value, llvm::support::little)) + if (auto EC = Writer->writeInteger(Value)) return EC; } diff --git a/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp b/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp index 74389f6e167..2dc14b92bca 100644 --- a/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp +++ b/llvm/lib/DebugInfo/CodeView/ModuleSubstream.cpp @@ -13,18 +13,16 @@ using namespace llvm; using namespace llvm::codeview; -using namespace llvm::msf; ModuleSubstream::ModuleSubstream() : Kind(ModuleSubstreamKind::None) {} -ModuleSubstream::ModuleSubstream(ModuleSubstreamKind Kind, - ReadableStreamRef Data) +ModuleSubstream::ModuleSubstream(ModuleSubstreamKind Kind, BinaryStreamRef Data) : Kind(Kind), Data(Data) {} -Error ModuleSubstream::initialize(ReadableStreamRef Stream, +Error ModuleSubstream::initialize(BinaryStreamRef Stream, ModuleSubstream &Info) { const ModuleSubsectionHeader *Header; - StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); if (auto EC = Reader.readObject(Header)) return EC; @@ -42,4 +40,4 @@ uint32_t ModuleSubstream::getRecordLength() const { ModuleSubstreamKind ModuleSubstream::getSubstreamKind() const { return Kind; } -ReadableStreamRef ModuleSubstream::getRecordData() const { return Data; } +BinaryStreamRef ModuleSubstream::getRecordData() const { return Data; } diff --git a/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp b/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp index 336fbda87e3..d552665d9d6 100644 --- a/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp +++ b/llvm/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp @@ -13,49 +13,47 @@ using namespace llvm; using namespace llvm::codeview; -using namespace llvm::msf; -Error IModuleSubstreamVisitor::visitSymbols(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitSymbols(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::Symbols, Data); } -Error IModuleSubstreamVisitor::visitLines(ReadableStreamRef Data, +Error IModuleSubstreamVisitor::visitLines(BinaryStreamRef Data, const LineSubstreamHeader *Header, const LineInfoArray &Lines) { return visitUnknown(ModuleSubstreamKind::Lines, Data); } -Error IModuleSubstreamVisitor::visitStringTable(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitStringTable(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::StringTable, Data); } Error IModuleSubstreamVisitor::visitFileChecksums( - ReadableStreamRef Data, const FileChecksumArray &Checksums) { + BinaryStreamRef Data, const FileChecksumArray &Checksums) { return visitUnknown(ModuleSubstreamKind::FileChecksums, Data); } -Error IModuleSubstreamVisitor::visitFrameData(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitFrameData(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::FrameData, Data); } -Error IModuleSubstreamVisitor::visitInlineeLines(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitInlineeLines(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::InlineeLines, Data); } -Error IModuleSubstreamVisitor::visitCrossScopeImports(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitCrossScopeImports(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CrossScopeExports, Data); } -Error IModuleSubstreamVisitor::visitCrossScopeExports(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitCrossScopeExports(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CrossScopeImports, Data); } -Error IModuleSubstreamVisitor::visitILLines(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitILLines(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::ILLines, Data); } -Error IModuleSubstreamVisitor::visitFuncMDTokenMap(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitFuncMDTokenMap(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::FuncMDTokenMap, Data); } -Error IModuleSubstreamVisitor::visitTypeMDTokenMap(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitTypeMDTokenMap(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::TypeMDTokenMap, Data); } -Error IModuleSubstreamVisitor::visitMergedAssemblyInput( - ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitMergedAssemblyInput(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::MergedAssemblyInput, Data); } -Error IModuleSubstreamVisitor::visitCoffSymbolRVA(ReadableStreamRef Data) { +Error IModuleSubstreamVisitor::visitCoffSymbolRVA(BinaryStreamRef Data) { return visitUnknown(ModuleSubstreamKind::CoffSymbolRVA, Data); } @@ -65,7 +63,7 @@ Error llvm::codeview::visitModuleSubstream(const ModuleSubstream &R, case ModuleSubstreamKind::Symbols: return V.visitSymbols(R.getRecordData()); case ModuleSubstreamKind::Lines: { - StreamReader Reader(R.getRecordData()); + BinaryStreamReader Reader(R.getRecordData()); const LineSubstreamHeader *Header; if (auto EC = Reader.readObject(Header)) return EC; @@ -78,7 +76,7 @@ Error llvm::codeview::visitModuleSubstream(const ModuleSubstream &R, case ModuleSubstreamKind::StringTable: return V.visitStringTable(R.getRecordData()); case ModuleSubstreamKind::FileChecksums: { - StreamReader Reader(R.getRecordData()); + BinaryStreamReader Reader(R.getRecordData()); FileChecksumArray Checksums; if (auto EC = Reader.readArray(Checksums, Reader.bytesRemaining())) return EC; diff --git a/llvm/lib/DebugInfo/CodeView/RecordSerialization.cpp b/llvm/lib/DebugInfo/CodeView/RecordSerialization.cpp index 98599c30b9f..eaa70f2b181 100644 --- a/llvm/lib/DebugInfo/CodeView/RecordSerialization.cpp +++ b/llvm/lib/DebugInfo/CodeView/RecordSerialization.cpp @@ -33,11 +33,11 @@ StringRef llvm::codeview::getBytesAsCString(ArrayRef<uint8_t> LeafData) { return getBytesAsCharacters(LeafData).split('\0').first; } -Error llvm::codeview::consume(msf::StreamReader &Reader, APSInt &Num) { +Error llvm::codeview::consume(BinaryStreamReader &Reader, APSInt &Num) { // Used to avoid overload ambiguity on APInt construtor. bool FalseVal = false; uint16_t Short; - if (auto EC = Reader.readInteger(Short, llvm::support::little)) + if (auto EC = Reader.readInteger(Short)) return EC; if (Short < LF_NUMERIC) { @@ -49,49 +49,49 @@ Error llvm::codeview::consume(msf::StreamReader &Reader, APSInt &Num) { switch (Short) { case LF_CHAR: { int8_t N; - if (auto EC = Reader.readInteger(N, llvm::support::little)) + if (auto EC = Reader.readInteger(N)) return EC; Num = APSInt(APInt(8, N, true), false); return Error::success(); } case LF_SHORT: { int16_t N; - if (auto EC = Reader.readInteger(N, llvm::support::little)) + if (auto EC = Reader.readInteger(N)) return EC; Num = APSInt(APInt(16, N, true), false); return Error::success(); } case LF_USHORT: { uint16_t N; - if (auto EC = Reader.readInteger(N, llvm::support::little)) + if (auto EC = Reader.readInteger(N)) return EC; Num = APSInt(APInt(16, N, false), true); return Error::success(); } case LF_LONG: { int32_t N; - if (auto EC = Reader.readInteger(N, llvm::support::little)) + if (auto EC = Reader.readInteger(N)) return EC; Num = APSInt(APInt(32, N, true), false); return Error::success(); } case LF_ULONG: { uint32_t N; - if (auto EC = Reader.readInteger(N, llvm::support::little)) + if (auto EC = Reader.readInteger(N)) return EC; Num = APSInt(APInt(32, N, FalseVal), true); return Error::success(); } case LF_QUADWORD: { int64_t N; - if (auto EC = Reader.readInteger(N, llvm::support::little)) + if (auto EC = Reader.readInteger(N)) return EC; Num = APSInt(APInt(64, N, true), false); return Error::success(); } case LF_UQUADWORD: { uint64_t N; - if (auto EC = Reader.readInteger(N, llvm::support::little)) + if (auto EC = Reader.readInteger(N)) return EC; Num = APSInt(APInt(64, N, false), true); return Error::success(); @@ -103,15 +103,15 @@ Error llvm::codeview::consume(msf::StreamReader &Reader, APSInt &Num) { Error llvm::codeview::consume(StringRef &Data, APSInt &Num) { ArrayRef<uint8_t> Bytes(Data.bytes_begin(), Data.bytes_end()); - msf::ByteStream S(Bytes); - msf::StreamReader SR(S); + BinaryByteStream S(Bytes, llvm::support::little); + BinaryStreamReader 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(msf::StreamReader &Reader, +Error llvm::codeview::consume_numeric(BinaryStreamReader &Reader, uint64_t &Num) { APSInt N; if (auto EC = consume(Reader, N)) @@ -123,27 +123,27 @@ Error llvm::codeview::consume_numeric(msf::StreamReader &Reader, return Error::success(); } -Error llvm::codeview::consume(msf::StreamReader &Reader, uint32_t &Item) { - return Reader.readInteger(Item, llvm::support::little); +Error llvm::codeview::consume(BinaryStreamReader &Reader, uint32_t &Item) { + return Reader.readInteger(Item); } Error llvm::codeview::consume(StringRef &Data, uint32_t &Item) { ArrayRef<uint8_t> Bytes(Data.bytes_begin(), Data.bytes_end()); - msf::ByteStream S(Bytes); - msf::StreamReader SR(S); + BinaryByteStream S(Bytes, llvm::support::little); + BinaryStreamReader SR(S); auto EC = consume(SR, Item); Data = Data.take_back(SR.bytesRemaining()); return EC; } -Error llvm::codeview::consume(msf::StreamReader &Reader, int32_t &Item) { - return Reader.readInteger(Item, llvm::support::little); +Error llvm::codeview::consume(BinaryStreamReader &Reader, int32_t &Item) { + return Reader.readInteger(Item); } -Error llvm::codeview::consume(msf::StreamReader &Reader, StringRef &Item) { +Error llvm::codeview::consume(BinaryStreamReader &Reader, StringRef &Item) { if (Reader.empty()) return make_error<CodeViewError>(cv_error_code::corrupt_record, "Null terminated string buffer is empty!"); - return Reader.readZeroString(Item); + return Reader.readCString(Item); } diff --git a/llvm/lib/DebugInfo/CodeView/TypeSerializer.cpp b/llvm/lib/DebugInfo/CodeView/TypeSerializer.cpp index 00eb6671214..4d0ce9e4da9 100644 --- a/llvm/lib/DebugInfo/CodeView/TypeSerializer.cpp +++ b/llvm/lib/DebugInfo/CodeView/TypeSerializer.cpp @@ -76,7 +76,7 @@ TypeSerializer::addPadding(MutableArrayRef<uint8_t> Record) { int N = PaddingBytes; while (PaddingBytes > 0) { uint8_t Pad = static_cast<uint8_t>(LF_PAD0 + PaddingBytes); - if (auto EC = Writer.writeInteger(Pad, llvm::support::little)) + if (auto EC = Writer.writeInteger(Pad)) return std::move(EC); --PaddingBytes; } @@ -85,7 +85,8 @@ TypeSerializer::addPadding(MutableArrayRef<uint8_t> Record) { TypeSerializer::TypeSerializer(BumpPtrAllocator &Storage) : RecordStorage(Storage), LastTypeIndex(), - RecordBuffer(MaxRecordLength * 2), Stream(RecordBuffer), Writer(Stream), + RecordBuffer(MaxRecordLength * 2), + Stream(RecordBuffer, llvm::support::little), 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, @@ -203,15 +204,15 @@ Error TypeSerializer::visitMemberEnd(CVMemberRecord &Record) { uint8_t *SegmentBytes = RecordStorage.Allocate<uint8_t>(LengthWithSize); auto SavedSegment = MutableArrayRef<uint8_t>(SegmentBytes, LengthWithSize); - msf::MutableByteStream CS(SavedSegment); - msf::StreamWriter CW(CS); + MutableBinaryByteStream CS(SavedSegment, llvm::support::little); + BinaryStreamWriter CW(CS); if (auto EC = CW.writeBytes(CopyData)) return EC; - if (auto EC = CW.writeEnum(TypeLeafKind::LF_INDEX, llvm::support::little)) + if (auto EC = CW.writeEnum(TypeLeafKind::LF_INDEX)) return EC; - if (auto EC = CW.writeInteger<uint16_t>(0, llvm::support::little)) + if (auto EC = CW.writeInteger<uint16_t>(0)) return EC; - if (auto EC = CW.writeInteger<uint32_t>(0xB0C0B0C0, llvm::support::little)) + if (auto EC = CW.writeInteger<uint32_t>(0xB0C0B0C0)) return EC; FieldListSegments.push_back(SavedSegment); diff --git a/llvm/lib/DebugInfo/MSF/BinaryStreamReader.cpp b/llvm/lib/DebugInfo/MSF/BinaryStreamReader.cpp index 567e6b1270e..ba5fd213c59 100644 --- a/llvm/lib/DebugInfo/MSF/BinaryStreamReader.cpp +++ b/llvm/lib/DebugInfo/MSF/BinaryStreamReader.cpp @@ -1,4 +1,4 @@ -//===- StreamReader.cpp - Reads bytes and objects from a stream -----------===// +//===- BinaryStreamReader.cpp - Reads objects from a binary stream --------===// // // The LLVM Compiler Infrastructure // @@ -10,53 +10,79 @@ #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; -StreamReader::StreamReader(ReadableStreamRef S) : Stream(S), Offset(0) {} +BinaryStreamReader::BinaryStreamReader(BinaryStreamRef S) + : Stream(S), Offset(0) {} -Error StreamReader::readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer) { +Error BinaryStreamReader::readLongestContiguousChunk( + ArrayRef<uint8_t> &Buffer) { if (auto EC = Stream.readLongestContiguousChunk(Offset, Buffer)) return EC; Offset += Buffer.size(); return Error::success(); } -Error StreamReader::readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size) { +Error BinaryStreamReader::readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size) { if (auto EC = Stream.readBytes(Offset, Size, Buffer)) return EC; Offset += Size; return Error::success(); } -Error StreamReader::readZeroString(StringRef &Dest) { +Error BinaryStreamReader::readInteger(uint64_t &Dest, uint32_t ByteSize) { + assert(ByteSize == 1 || ByteSize == 2 || ByteSize == 4 || ByteSize == 8); + ArrayRef<uint8_t> 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. + 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; - do { + while (true) { if (auto EC = readObject(C)) return EC; - if (*C != '\0') - ++Length; - } while (*C != '\0'); + if (*C == '\0') + break; + ++Length; + } // Now go back and request a reference for that many bytes. uint32_t NewOffset = getOffset(); setOffset(OriginalOffset); - ArrayRef<uint8_t> Data; - if (auto EC = readBytes(Data, Length)) + if (auto EC = readFixedString(Dest, Length)) return EC; - Dest = StringRef(reinterpret_cast<const char *>(Data.begin()), Data.size()); // Now set the offset back to where it was after we calculated the length. setOffset(NewOffset); return Error::success(); } -Error StreamReader::readFixedString(StringRef &Dest, uint32_t Length) { +Error BinaryStreamReader::readFixedString(StringRef &Dest, uint32_t Length) { ArrayRef<uint8_t> Bytes; if (auto EC = readBytes(Bytes, Length)) return EC; @@ -64,26 +90,26 @@ Error StreamReader::readFixedString(StringRef &Dest, uint32_t Length) { return Error::success(); } -Error StreamReader::readStreamRef(ReadableStreamRef &Ref) { +Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref) { return readStreamRef(Ref, bytesRemaining()); } -Error StreamReader::readStreamRef(ReadableStreamRef &Ref, uint32_t Length) { +Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref, uint32_t Length) { if (bytesRemaining() < Length) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); Ref = Stream.slice(Offset, Length); Offset += Length; return Error::success(); } -Error StreamReader::skip(uint32_t Amount) { +Error BinaryStreamReader::skip(uint32_t Amount) { if (Amount > bytesRemaining()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); Offset += Amount; return Error::success(); } -uint8_t StreamReader::peek() const { +uint8_t BinaryStreamReader::peek() const { ArrayRef<uint8_t> Buffer; auto EC = Stream.readBytes(Offset, 1, Buffer); assert(!EC && "Cannot peek an empty buffer!"); diff --git a/llvm/lib/DebugInfo/MSF/BinaryStreamWriter.cpp b/llvm/lib/DebugInfo/MSF/BinaryStreamWriter.cpp index 54415b96c0b..08e4aef6060 100644 --- a/llvm/lib/DebugInfo/MSF/BinaryStreamWriter.cpp +++ b/llvm/lib/DebugInfo/MSF/BinaryStreamWriter.cpp @@ -1,4 +1,4 @@ -//===- StreamWrite.cpp - Writes bytes and objects to a stream -------------===// +//===- BinaryStreamWriter.cpp - Writes objects to a BinaryStream ----------===// // // The LLVM Compiler Infrastructure // @@ -11,21 +11,42 @@ #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; -StreamWriter::StreamWriter(WritableStreamRef S) : Stream(S), Offset(0) {} +BinaryStreamWriter::BinaryStreamWriter(WritableBinaryStreamRef S) + : Stream(S), Offset(0) {} -Error StreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) { +Error BinaryStreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) { if (auto EC = Stream.writeBytes(Offset, Buffer)) return EC; Offset += Buffer.size(); return Error::success(); } -Error StreamWriter::writeZeroString(StringRef Str) { +Error BinaryStreamWriter::writeInteger(uint64_t Value, uint32_t ByteSize) { + assert(ByteSize == 1 || ByteSize == 2 || ByteSize == 4 || ByteSize == 8); + uint8_t Bytes[8]; + MutableArrayRef<uint8_t> Buffer(Bytes); + Buffer = Buffer.take_front(ByteSize); + switch (ByteSize) { + case 1: + Buffer[0] = static_cast<uint8_t>(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) { if (auto EC = writeFixedString(Str)) return EC; if (auto EC = writeObject('\0')) @@ -34,31 +55,21 @@ Error StreamWriter::writeZeroString(StringRef Str) { return Error::success(); } -Error StreamWriter::writeFixedString(StringRef Str) { - ArrayRef<uint8_t> Bytes(Str.bytes_begin(), Str.bytes_end()); - if (auto EC = Stream.writeBytes(Offset, Bytes)) - return EC; - - Offset += Str.size(); - return Error::success(); +Error BinaryStreamWriter::writeFixedString(StringRef Str) { + return writeBytes(ArrayRef<uint8_t>(Str.bytes_begin(), Str.bytes_end())); } -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) { + return writeStreamRef(Ref, Ref.getLength()); } -Error StreamWriter::writeStreamRef(ReadableStreamRef Ref, uint32_t Length) { - Ref = Ref.slice(0, Length); - - StreamReader SrcReader(Ref); +Error BinaryStreamWriter::writeStreamRef(BinaryStreamRef Ref, uint32_t Length) { + BinaryStreamReader SrcReader(Ref.slice(0, Length)); // This is a bit tricky. If we just call readBytes, we are requiring that it - // 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. + // 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. while (SrcReader.bytesRemaining() > 0) { ArrayRef<uint8_t> Chunk; if (auto EC = SrcReader.readLongestContiguousChunk(Chunk)) diff --git a/llvm/lib/DebugInfo/MSF/MappedBlockStream.cpp b/llvm/lib/DebugInfo/MSF/MappedBlockStream.cpp index e52c88a5bfb..c9ba25c0d7d 100644 --- a/llvm/lib/DebugInfo/MSF/MappedBlockStream.cpp +++ b/llvm/lib/DebugInfo/MSF/MappedBlockStream.cpp @@ -47,22 +47,20 @@ static Interval intersect(const Interval &I1, const Interval &I2) { MappedBlockStream::MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - const ReadableStream &MsfData) + BinaryStreamRef MsfData) : BlockSize(BlockSize), NumBlocks(NumBlocks), StreamLayout(Layout), MsfData(MsfData) {} std::unique_ptr<MappedBlockStream> MappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - const ReadableStream &MsfData) { + BinaryStreamRef MsfData) { return llvm::make_unique<MappedBlockStreamImpl<MappedBlockStream>>( BlockSize, NumBlocks, Layout, MsfData); } -std::unique_ptr<MappedBlockStream> -MappedBlockStream::createIndexedStream(const MSFLayout &Layout, - const ReadableStream &MsfData, - uint32_t StreamIndex) { +std::unique_ptr<MappedBlockStream> MappedBlockStream::createIndexedStream( + const MSFLayout &Layout, BinaryStreamRef MsfData, uint32_t StreamIndex) { assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index"); MSFStreamLayout SL; SL.Blocks = Layout.StreamMap[StreamIndex]; @@ -73,7 +71,7 @@ MappedBlockStream::createIndexedStream(const MSFLayout &Layout, std::unique_ptr<MappedBlockStream> MappedBlockStream::createDirectoryStream(const MSFLayout &Layout, - const ReadableStream &MsfData) { + BinaryStreamRef MsfData) { MSFStreamLayout SL; SL.Blocks = Layout.DirectoryBlocks; SL.Length = Layout.SB->NumDirectoryBytes; @@ -82,14 +80,14 @@ MappedBlockStream::createDirectoryStream(const MSFLayout &Layout, std::unique_ptr<MappedBlockStream> MappedBlockStream::createFpmStream(const MSFLayout &Layout, - const ReadableStream &MsfData) { + BinaryStreamRef 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<uint8_t> &Buffer) const { + ArrayRef<uint8_t> &Buffer) { // Make sure we aren't trying to read beyond the end of the stream. if (Size > StreamLayout.Length) return make_error<MSFError>(msf_error_code::insufficient_buffer); @@ -168,8 +166,8 @@ Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size, return Error::success(); } -Error MappedBlockStream::readLongestContiguousChunk( - uint32_t Offset, ArrayRef<uint8_t> &Buffer) const { +Error MappedBlockStream::readLongestContiguousChunk(uint32_t Offset, + ArrayRef<uint8_t> &Buffer) { // Make sure we aren't trying to read beyond the end of the stream. if (Offset >= StreamLayout.Length) return make_error<MSFError>(msf_error_code::insufficient_buffer); @@ -197,10 +195,10 @@ Error MappedBlockStream::readLongestContiguousChunk( return Error::success(); } -uint32_t MappedBlockStream::getLength() const { return StreamLayout.Length; } +uint32_t MappedBlockStream::getLength() { return StreamLayout.Length; } bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const { + ArrayRef<uint8_t> &Buffer) { if (Size == 0) { Buffer = ArrayRef<uint8_t>(); return true; @@ -241,7 +239,7 @@ bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size, } Error MappedBlockStream::readBytes(uint32_t Offset, - MutableArrayRef<uint8_t> Buffer) const { + MutableArrayRef<uint8_t> Buffer) { uint32_t BlockNum = Offset / BlockSize; uint32_t OffsetInBlock = Offset % BlockSize; @@ -319,21 +317,21 @@ void MappedBlockStream::fixCacheAfterWrite(uint32_t Offset, WritableMappedBlockStream::WritableMappedBlockStream( uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - const WritableStream &MsfData) + WritableBinaryStreamRef MsfData) : ReadInterface(BlockSize, NumBlocks, Layout, MsfData), WriteInterface(MsfData) {} std::unique_ptr<WritableMappedBlockStream> WritableMappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout, - const WritableStream &MsfData) { + WritableBinaryStreamRef MsfData) { return llvm::make_unique<MappedBlockStreamImpl<WritableMappedBlockStream>>( BlockSize, NumBlocks, Layout, MsfData); } std::unique_ptr<WritableMappedBlockStream> WritableMappedBlockStream::createIndexedStream(const MSFLayout &Layout, - const WritableStream &MsfData, + WritableBinaryStreamRef MsfData, uint32_t StreamIndex) { assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index"); MSFStreamLayout SL; @@ -344,7 +342,7 @@ WritableMappedBlockStream::createIndexedStream(const MSFLayout &Layout, std::unique_ptr<WritableMappedBlockStream> WritableMappedBlockStream::createDirectoryStream( - const MSFLayout &Layout, const WritableStream &MsfData) { + const MSFLayout &Layout, WritableBinaryStreamRef MsfData) { MSFStreamLayout SL; SL.Blocks = Layout.DirectoryBlocks; SL.Length = Layout.SB->NumDirectoryBytes; @@ -353,28 +351,28 @@ WritableMappedBlockStream::createDirectoryStream( std::unique_ptr<WritableMappedBlockStream> WritableMappedBlockStream::createFpmStream(const MSFLayout &Layout, - const WritableStream &MsfData) { + WritableBinaryStreamRef 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<uint8_t> &Buffer) const { + ArrayRef<uint8_t> &Buffer) { return ReadInterface.readBytes(Offset, Size, Buffer); } Error WritableMappedBlockStream::readLongestContiguousChunk( - uint32_t Offset, ArrayRef<uint8_t> &Buffer) const { + uint32_t Offset, ArrayRef<uint8_t> &Buffer) { return ReadInterface.readLongestContiguousChunk(Offset, Buffer); } -uint32_t WritableMappedBlockStream::getLength() const { +uint32_t WritableMappedBlockStream::getLength() { return ReadInterface.getLength(); } Error WritableMappedBlockStream::writeBytes(uint32_t Offset, - ArrayRef<uint8_t> Buffer) const { + ArrayRef<uint8_t> Buffer) { // Make sure we aren't trying to write beyond the end of the stream. if (Buffer.size() > getStreamLength()) return make_error<MSFError>(msf_error_code::insufficient_buffer); @@ -410,6 +408,4 @@ Error WritableMappedBlockStream::writeBytes(uint32_t Offset, return Error::success(); } -Error WritableMappedBlockStream::commit() const { - return WriteInterface.commit(); -} +Error WritableMappedBlockStream::commit() { return WriteInterface.commit(); } diff --git a/llvm/lib/DebugInfo/PDB/Native/DbiStream.cpp b/llvm/lib/DebugInfo/PDB/Native/DbiStream.cpp index d8169434143..51a868f8770 100644 --- a/llvm/lib/DebugInfo/PDB/Native/DbiStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/DbiStream.cpp @@ -10,6 +10,8 @@ #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" @@ -34,7 +36,7 @@ using namespace llvm::support; template <typename ContribType> static Error loadSectionContribs(FixedStreamArray<ContribType> &Output, - StreamReader &Reader) { + BinaryStreamReader &Reader) { if (Reader.bytesRemaining() % sizeof(ContribType) != 0) return make_error<RawError>( raw_error_code::corrupt_file, @@ -52,7 +54,7 @@ DbiStream::DbiStream(PDBFile &File, std::unique_ptr<MappedBlockStream> Stream) DbiStream::~DbiStream() = default; Error DbiStream::reload() { - StreamReader Reader(*Stream); + BinaryStreamReader Reader(*Stream); if (Stream->getLength() < sizeof(DbiStreamHeader)) return make_error<RawError>(raw_error_code::corrupt_file, @@ -145,7 +147,7 @@ Error DbiStream::reload() { "Found unexpected bytes in DBI Stream."); if (ECSubstream.getLength() > 0) { - StreamReader ECReader(ECSubstream); + BinaryStreamReader ECReader(ECSubstream); if (auto EC = ECNames.load(ECReader)) return EC; } @@ -207,16 +209,16 @@ PDB_Machine DbiStream::getMachineType() const { return static_cast<PDB_Machine>(Machine); } -msf::FixedStreamArray<object::coff_section> DbiStream::getSectionHeaders() { +FixedStreamArray<object::coff_section> DbiStream::getSectionHeaders() { return SectionHeaders; } -msf::FixedStreamArray<object::FpoData> DbiStream::getFpoRecords() { +FixedStreamArray<object::FpoData> DbiStream::getFpoRecords() { return FpoRecords; } ArrayRef<ModuleInfoEx> DbiStream::modules() const { return ModuleInfos; } -msf::FixedStreamArray<SecMapEntry> DbiStream::getSectionMap() const { +FixedStreamArray<SecMapEntry> DbiStream::getSectionMap() const { return SectionMap; } @@ -235,8 +237,8 @@ Error DbiStream::initializeSectionContributionData() { if (SecContrSubstream.getLength() == 0) return Error::success(); - StreamReader SCReader(SecContrSubstream); - if (auto EC = SCReader.readEnum(SectionContribVersion, llvm::support::little)) + BinaryStreamReader SCReader(SecContrSubstream); + if (auto EC = SCReader.readEnum(SectionContribVersion)) return EC; if (SectionContribVersion == DbiSecContribVer60) @@ -254,7 +256,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. - StreamReader Reader(ModInfoSubstream); + BinaryStreamReader Reader(ModInfoSubstream); VarStreamArray<ModInfo> ModInfoArray; if (auto EC = Reader.readArray(ModInfoArray, ModInfoSubstream.getLength())) @@ -284,7 +286,7 @@ Error DbiStream::initializeSectionHeadersData() { "Corrupted section header stream."); size_t NumSections = StreamLen / sizeof(object::coff_section); - msf::StreamReader Reader(*SHS); + BinaryStreamReader Reader(*SHS); if (auto EC = Reader.readArray(SectionHeaders, NumSections)) return make_error<RawError>(raw_error_code::corrupt_file, "Could not read a bitmap."); @@ -316,7 +318,7 @@ Error DbiStream::initializeFpoRecords() { "Corrupted New FPO stream."); size_t NumRecords = StreamLen / sizeof(object::FpoData); - msf::StreamReader Reader(*FS); + BinaryStreamReader Reader(*FS); if (auto EC = Reader.readArray(FpoRecords, NumRecords)) return make_error<RawError>(raw_error_code::corrupt_file, "Corrupted New FPO stream."); @@ -328,7 +330,7 @@ Error DbiStream::initializeSectionMapData() { if (SecMapSubstream.getLength() == 0) return Error::success(); - StreamReader SMReader(SecMapSubstream); + BinaryStreamReader SMReader(SecMapSubstream); const SecMapHeader *Header; if (auto EC = SMReader.readObject(Header)) return EC; @@ -342,7 +344,7 @@ Error DbiStream::initializeFileInfo() { return Error::success(); const FileInfoSubstreamHeader *FH; - StreamReader FISR(FileInfoSubstream); + BinaryStreamReader FISR(FileInfoSubstream); if (auto EC = FISR.readObject(FH)) return EC; @@ -411,14 +413,14 @@ uint32_t DbiStream::getDebugStreamIndex(DbgHeaderType Type) const { } Expected<StringRef> DbiStream::getFileNameForIndex(uint32_t Index) const { - StreamReader Names(NamesBuffer); + BinaryStreamReader Names(NamesBuffer); if (Index >= FileNameOffsets.size()) return make_error<RawError>(raw_error_code::index_out_of_bounds); uint32_t FileOffset = FileNameOffsets[Index]; Names.setOffset(FileOffset); StringRef Name; - if (auto EC = Names.readZeroString(Name)) + if (auto EC = Names.readCString(Name)) return std::move(EC); return Name; } diff --git a/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp b/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp index 60687ac23b0..ac40330c5dc 100644 --- a/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp @@ -11,6 +11,7 @@ #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" @@ -153,18 +154,19 @@ Error DbiStreamBuilder::generateModiSubstream() { uint32_t Size = calculateModiSubstreamSize(); auto Data = Allocator.Allocate<uint8_t>(Size); - ModInfoBuffer = MutableByteStream(MutableArrayRef<uint8_t>(Data, Size)); + ModInfoBuffer = MutableBinaryByteStream(MutableArrayRef<uint8_t>(Data, Size), + llvm::support::little); - StreamWriter ModiWriter(ModInfoBuffer); + BinaryStreamWriter 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.writeZeroString(M->Mod)) + if (auto EC = ModiWriter.writeCString(M->Mod)) return EC; - if (auto EC = ModiWriter.writeZeroString(M->Obj)) + if (auto EC = ModiWriter.writeCString(M->Obj)) return EC; } if (ModiWriter.bytesRemaining() > sizeof(uint32_t)) @@ -179,29 +181,26 @@ Error DbiStreamBuilder::generateFileInfoSubstream() { auto Data = Allocator.Allocate<uint8_t>(Size); uint32_t NamesOffset = Size - NameSize; - FileInfoBuffer = MutableByteStream(MutableArrayRef<uint8_t>(Data, Size)); + FileInfoBuffer = MutableBinaryByteStream(MutableArrayRef<uint8_t>(Data, Size), + llvm::support::little); - WritableStreamRef MetadataBuffer = - WritableStreamRef(FileInfoBuffer).keep_front(NamesOffset); - StreamWriter MetadataWriter(MetadataBuffer); + WritableBinaryStreamRef MetadataBuffer = + WritableBinaryStreamRef(FileInfoBuffer).keep_front(NamesOffset); + BinaryStreamWriter MetadataWriter(MetadataBuffer); uint16_t ModiCount = std::min<uint32_t>(UINT16_MAX, ModuleInfos.size()); uint16_t FileCount = std::min<uint32_t>(UINT16_MAX, SourceFileNames.size()); - if (auto EC = MetadataWriter.writeInteger( - ModiCount, llvm::support::little)) // NumModules + if (auto EC = MetadataWriter.writeInteger(ModiCount)) // NumModules return EC; - if (auto EC = MetadataWriter.writeInteger( - FileCount, llvm::support::little)) // NumSourceFiles + if (auto EC = MetadataWriter.writeInteger(FileCount)) // NumSourceFiles return EC; for (uint16_t I = 0; I < ModiCount; ++I) { - if (auto EC = MetadataWriter.writeInteger( - I, llvm::support::little)) // Mod Indices + if (auto EC = MetadataWriter.writeInteger(I)) // Mod Indices return EC; } for (const auto MI : ModuleInfoList) { FileCount = static_cast<uint16_t>(MI->SourceFiles.size()); - if (auto EC = MetadataWriter.writeInteger( - FileCount, llvm::support::little)) // Mod File Counts + if (auto EC = MetadataWriter.writeInteger(FileCount)) // Mod File Counts return EC; } @@ -209,11 +208,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 = WritableStreamRef(FileInfoBuffer).drop_front(NamesOffset); - StreamWriter NameBufferWriter(NamesBuffer); + NamesBuffer = WritableBinaryStreamRef(FileInfoBuffer).drop_front(NamesOffset); + BinaryStreamWriter NameBufferWriter(NamesBuffer); for (auto &Name : SourceFileNames) { Name.second = NameBufferWriter.getOffset(); - if (auto EC = NameBufferWriter.writeZeroString(Name.getKey())) + if (auto EC = NameBufferWriter.writeCString(Name.getKey())) return EC; } @@ -223,8 +222,7 @@ Error DbiStreamBuilder::generateFileInfoSubstream() { if (Result == SourceFileNames.end()) return make_error<RawError>(raw_error_code::no_entry, "The source file was not found."); - if (auto EC = MetadataWriter.writeInteger(Result->second, - llvm::support::little)) + if (auto EC = MetadataWriter.writeInteger(Result->second)) return EC; } } @@ -363,14 +361,14 @@ std::vector<SecMapEntry> DbiStreamBuilder::createSectionMap( } Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, - const msf::WritableStream &Buffer) { + WritableBinaryStreamRef Buffer) { if (auto EC = finalize()) return EC; auto InfoS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamDBI); - StreamWriter Writer(*InfoS); + BinaryStreamWriter Writer(*InfoS); if (auto EC = Writer.writeObject(*Header)) return EC; @@ -378,7 +376,7 @@ Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, return EC; if (!SectionContribs.empty()) { - if (auto EC = Writer.writeEnum(DbiSecContribVer60, llvm::support::little)) + if (auto EC = Writer.writeEnum(DbiSecContribVer60)) return EC; if (auto EC = Writer.writeArray(SectionContribs)) return EC; @@ -397,8 +395,7 @@ Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, return EC; for (auto &Stream : DbgStreams) - if (auto EC = - Writer.writeInteger(Stream.StreamNumber, llvm::support::little)) + if (auto EC = Writer.writeInteger(Stream.StreamNumber)) return EC; for (auto &Stream : DbgStreams) { @@ -406,7 +403,7 @@ Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, continue; auto WritableStream = WritableMappedBlockStream::createIndexedStream( Layout, Buffer, Stream.StreamNumber); - StreamWriter DbgStreamWriter(*WritableStream); + BinaryStreamWriter DbgStreamWriter(*WritableStream); if (auto EC = DbgStreamWriter.writeArray(Stream.Data)) return EC; } diff --git a/llvm/lib/DebugInfo/PDB/Native/GSI.cpp b/llvm/lib/DebugInfo/PDB/Native/GSI.cpp index 5a727910e20..3a7e1e1529f 100644 --- a/llvm/lib/DebugInfo/PDB/Native/GSI.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/GSI.cpp @@ -28,9 +28,9 @@ static Error checkHashHdrVersion(const GSIHashHeader *HashHdr) { return Error::success(); } -Error readGSIHashBuckets( - msf::FixedStreamArray<support::ulittle32_t> &HashBuckets, - const GSIHashHeader *HashHdr, msf::StreamReader &Reader) { +Error readGSIHashBuckets(FixedStreamArray<support::ulittle32_t> &HashBuckets, + const GSIHashHeader *HashHdr, + BinaryStreamReader &Reader) { if (auto EC = checkHashHdrVersion(HashHdr)) return EC; @@ -57,7 +57,7 @@ Error readGSIHashBuckets( } Error readGSIHashHeader(const GSIHashHeader *&HashHdr, - msf::StreamReader &Reader) { + BinaryStreamReader &Reader) { if (Reader.readObject(HashHdr)) return make_error<RawError>(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(msf::FixedStreamArray<PSHashRecord> &HashRecords, +Error readGSIHashRecords(FixedStreamArray<PSHashRecord> &HashRecords, const GSIHashHeader *HashHdr, - msf::StreamReader &Reader) { + BinaryStreamReader &Reader) { if (auto EC = checkHashHdrVersion(HashHdr)) return EC; diff --git a/llvm/lib/DebugInfo/PDB/Native/GSI.h b/llvm/lib/DebugInfo/PDB/Native/GSI.h index 5c5596c0484..f47321a2f14 100644 --- a/llvm/lib/DebugInfo/PDB/Native/GSI.h +++ b/llvm/lib/DebugInfo/PDB/Native/GSI.h @@ -33,9 +33,7 @@ namespace llvm { -namespace msf { -class StreamReader; -} +class BinaryStreamReader; namespace pdb { @@ -56,14 +54,14 @@ struct GSIHashHeader { support::ulittle32_t NumBuckets; }; -Error readGSIHashBuckets( - msf::FixedStreamArray<support::ulittle32_t> &HashBuckets, - const GSIHashHeader *HashHdr, msf::StreamReader &Reader); +Error readGSIHashBuckets(FixedStreamArray<support::ulittle32_t> &HashBuckets, + const GSIHashHeader *HashHdr, + BinaryStreamReader &Reader); Error readGSIHashHeader(const GSIHashHeader *&HashHdr, - msf::StreamReader &Reader); -Error readGSIHashRecords(msf::FixedStreamArray<PSHashRecord> &HashRecords, + BinaryStreamReader &Reader); +Error readGSIHashRecords(FixedStreamArray<PSHashRecord> &HashRecords, const GSIHashHeader *HashHdr, - msf::StreamReader &Reader); + BinaryStreamReader &Reader); } } diff --git a/llvm/lib/DebugInfo/PDB/Native/GlobalsStream.cpp b/llvm/lib/DebugInfo/PDB/Native/GlobalsStream.cpp index d5c80ba42b5..7d6d39d43d2 100644 --- a/llvm/lib/DebugInfo/PDB/Native/GlobalsStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/GlobalsStream.cpp @@ -23,7 +23,7 @@ GlobalsStream::GlobalsStream(std::unique_ptr<MappedBlockStream> Stream) GlobalsStream::~GlobalsStream() = default; Error GlobalsStream::reload() { - StreamReader Reader(*Stream); + BinaryStreamReader Reader(*Stream); const GSIHashHeader *HashHdr; if (auto EC = readGSIHashHeader(HashHdr, Reader)) diff --git a/llvm/lib/DebugInfo/PDB/Native/HashTable.cpp b/llvm/lib/DebugInfo/PDB/Native/HashTable.cpp index dd95c078d7e..ebf8c9c04db 100644 --- a/llvm/lib/DebugInfo/PDB/Native/HashTable.cpp +++ b/llvm/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(msf::StreamReader &Stream) { +Error HashTable::load(BinaryStreamReader &Stream) { const Header *H; if (auto EC = Stream.readObject(H)) return EC; @@ -48,9 +48,9 @@ Error HashTable::load(msf::StreamReader &Stream) { "Present bit vector interesects deleted!"); for (uint32_t P : Present) { - if (auto EC = Stream.readInteger(Buckets[P].first, llvm::support::little)) + if (auto EC = Stream.readInteger(Buckets[P].first)) return EC; - if (auto EC = Stream.readInteger(Buckets[P].second, llvm::support::little)) + if (auto EC = Stream.readInteger(Buckets[P].second)) return EC; } @@ -77,7 +77,7 @@ uint32_t HashTable::calculateSerializedLength() const { return Size; } -Error HashTable::commit(msf::StreamWriter &Writer) const { +Error HashTable::commit(BinaryStreamWriter &Writer) const { Header H; H.Size = size(); H.Capacity = capacity(); @@ -91,9 +91,9 @@ Error HashTable::commit(msf::StreamWriter &Writer) const { return EC; for (const auto &Entry : *this) { - if (auto EC = Writer.writeInteger(Entry.first, llvm::support::little)) + if (auto EC = Writer.writeInteger(Entry.first)) return EC; - if (auto EC = Writer.writeInteger(Entry.second, llvm::support::little)) + if (auto EC = Writer.writeInteger(Entry.second)) return EC; } return Error::success(); @@ -209,10 +209,10 @@ void HashTable::grow() { assert(size() == S); } -Error HashTable::readSparseBitVector(msf::StreamReader &Stream, +Error HashTable::readSparseBitVector(BinaryStreamReader &Stream, SparseBitVector<> &V) { uint32_t NumWords; - if (auto EC = Stream.readInteger(NumWords, llvm::support::little)) + if (auto EC = Stream.readInteger(NumWords)) return joinErrors( std::move(EC), make_error<RawError>(raw_error_code::corrupt_file, @@ -220,7 +220,7 @@ Error HashTable::readSparseBitVector(msf::StreamReader &Stream, for (uint32_t I = 0; I != NumWords; ++I) { uint32_t Word; - if (auto EC = Stream.readInteger(Word, llvm::support::little)) + if (auto EC = Stream.readInteger(Word)) return joinErrors(std::move(EC), make_error<RawError>(raw_error_code::corrupt_file, "Expected hash table word")); @@ -231,11 +231,11 @@ Error HashTable::readSparseBitVector(msf::StreamReader &Stream, return Error::success(); } -Error HashTable::writeSparseBitVector(msf::StreamWriter &Writer, +Error HashTable::writeSparseBitVector(BinaryStreamWriter &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, llvm::support::little)) + if (auto EC = Writer.writeInteger(NumWords)) return joinErrors( std::move(EC), make_error<RawError>(raw_error_code::corrupt_file, @@ -248,7 +248,7 @@ Error HashTable::writeSparseBitVector(msf::StreamWriter &Writer, if (Vec.test(Idx)) Word |= (1 << WordIdx); } - if (auto EC = Writer.writeInteger(Word, llvm::support::little)) + if (auto EC = Writer.writeInteger(Word)) return joinErrors(std::move(EC), make_error<RawError>( raw_error_code::corrupt_file, "Could not write linear map word")); diff --git a/llvm/lib/DebugInfo/PDB/Native/InfoStream.cpp b/llvm/lib/DebugInfo/PDB/Native/InfoStream.cpp index 692099256d8..9c4fca7aa5e 100644 --- a/llvm/lib/DebugInfo/PDB/Native/InfoStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/InfoStream.cpp @@ -26,7 +26,7 @@ InfoStream::InfoStream(std::unique_ptr<MappedBlockStream> Stream) : Stream(std::move(Stream)) {} Error InfoStream::reload() { - StreamReader Reader(*Stream); + BinaryStreamReader Reader(*Stream); const InfoStreamHeader *H; if (auto EC = Reader.readObject(H)) diff --git a/llvm/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp b/llvm/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp index 0b6a563b5a9..db7e18df1ab 100644 --- a/llvm/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp @@ -10,6 +10,7 @@ #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" #include "llvm/DebugInfo/PDB/Native/InfoStream.h" @@ -44,10 +45,10 @@ Error InfoStreamBuilder::finalizeMsfLayout() { } Error InfoStreamBuilder::commit(const msf::MSFLayout &Layout, - const msf::WritableStream &Buffer) const { + WritableBinaryStreamRef Buffer) const { auto InfoS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamPDB); - StreamWriter Writer(*InfoS); + BinaryStreamWriter Writer(*InfoS); InfoStreamHeader H; H.Age = Age; diff --git a/llvm/lib/DebugInfo/PDB/Native/ModInfo.cpp b/llvm/lib/DebugInfo/PDB/Native/ModInfo.cpp index 501188e96f6..5e229663844 100644 --- a/llvm/lib/DebugInfo/PDB/Native/ModInfo.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/ModInfo.cpp @@ -16,7 +16,6 @@ #include <cstdint> using namespace llvm; -using namespace llvm::msf; using namespace llvm::pdb; using namespace llvm::support; @@ -26,15 +25,15 @@ ModInfo::ModInfo(const ModInfo &Info) = default; ModInfo::~ModInfo() = default; -Error ModInfo::initialize(ReadableStreamRef Stream, ModInfo &Info) { - StreamReader Reader(Stream); +Error ModInfo::initialize(BinaryStreamRef Stream, ModInfo &Info) { + BinaryStreamReader Reader(Stream); if (auto EC = Reader.readObject(Info.Layout)) return EC; - if (auto EC = Reader.readZeroString(Info.ModuleName)) + if (auto EC = Reader.readCString(Info.ModuleName)) return EC; - if (auto EC = Reader.readZeroString(Info.ObjFileName)) + if (auto EC = Reader.readCString(Info.ObjFileName)) return EC; return Error::success(); } diff --git a/llvm/lib/DebugInfo/PDB/Native/ModStream.cpp b/llvm/lib/DebugInfo/PDB/Native/ModStream.cpp index 9f035cf3e94..df9ec818a1d 100644 --- a/llvm/lib/DebugInfo/PDB/Native/ModStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/ModStream.cpp @@ -31,7 +31,7 @@ ModStream::ModStream(const ModInfo &Module, ModStream::~ModStream() = default; Error ModStream::reload() { - StreamReader Reader(*Stream); + BinaryStreamReader Reader(*Stream); uint32_t SymbolSize = Mod.getSymbolDebugInfoByteSize(); uint32_t C11Size = Mod.getLineInfoByteSize(); @@ -41,9 +41,9 @@ Error ModStream::reload() { return make_error<RawError>(raw_error_code::corrupt_file, "Module has both C11 and C13 line info"); - ReadableStreamRef S; + BinaryStreamRef S; - if (auto EC = Reader.readInteger(Signature, llvm::support::little)) + if (auto EC = Reader.readInteger(Signature)) 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; - StreamReader LineReader(C13LinesSubstream); + BinaryStreamReader LineReader(C13LinesSubstream); if (auto EC = LineReader.readArray(LineInfo, LineReader.bytesRemaining())) return EC; uint32_t GlobalRefsSize; - if (auto EC = Reader.readInteger(GlobalRefsSize, llvm::support::little)) + if (auto EC = Reader.readInteger(GlobalRefsSize)) return EC; if (auto EC = Reader.readStreamRef(GlobalRefsSubstream, GlobalRefsSize)) return EC; diff --git a/llvm/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp b/llvm/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp index ceeca10c5c5..1fa9bc443ec 100644 --- a/llvm/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp @@ -21,23 +21,22 @@ #include <cstdint> using namespace llvm; -using namespace llvm::msf; using namespace llvm::pdb; NamedStreamMap::NamedStreamMap() = default; -Error NamedStreamMap::load(StreamReader &Stream) { +Error NamedStreamMap::load(BinaryStreamReader &Stream) { Mapping.clear(); FinalizedHashTable.clear(); FinalizedInfo.reset(); uint32_t StringBufferSize; - if (auto EC = Stream.readInteger(StringBufferSize, llvm::support::little)) + if (auto EC = Stream.readInteger(StringBufferSize)) return joinErrors(std::move(EC), make_error<RawError>(raw_error_code::corrupt_file, "Expected string buffer size")); - msf::ReadableStreamRef StringsBuffer; + BinaryStreamRef StringsBuffer; if (auto EC = Stream.readStreamRef(StringsBuffer, StringBufferSize)) return EC; @@ -51,11 +50,11 @@ Error NamedStreamMap::load(StreamReader &Stream) { std::tie(NameOffset, NameIndex) = Entry; // Compute the offset of the start of the string relative to the stream. - msf::StreamReader NameReader(StringsBuffer); + BinaryStreamReader NameReader(StringsBuffer); NameReader.setOffset(NameOffset); // Pump out our c-string from the stream. StringRef Str; - if (auto EC = NameReader.readZeroString(Str)) + if (auto EC = NameReader.readCString(Str)) return joinErrors(std::move(EC), make_error<RawError>(raw_error_code::corrupt_file, "Expected name map name")); @@ -67,17 +66,16 @@ Error NamedStreamMap::load(StreamReader &Stream) { return Error::success(); } -Error NamedStreamMap::commit(msf::StreamWriter &Writer) const { +Error NamedStreamMap::commit(BinaryStreamWriter &Writer) const { assert(FinalizedInfo.hasValue()); // The first field is the number of bytes of string data. - if (auto EC = Writer.writeInteger(FinalizedInfo->StringDataBytes, - llvm::support::little)) + if (auto EC = Writer.writeInteger(FinalizedInfo->StringDataBytes)) return EC; // Now all of the string data itself. for (const auto &Item : Mapping) { - if (auto EC = Writer.writeZeroString(Item.getKey())) + if (auto EC = Writer.writeCString(Item.getKey())) return EC; } diff --git a/llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp b/llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp index 4c858253b79..dff53344545 100644 --- a/llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp @@ -45,7 +45,8 @@ Error NativeSession::createFromPdb(StringRef Path, return make_error<GenericError>(generic_error_code::invalid_path); std::unique_ptr<MemoryBuffer> Buffer = std::move(*ErrorOrBuffer); - auto Stream = llvm::make_unique<MemoryBufferByteStream>(std::move(Buffer)); + auto Stream = llvm::make_unique<MemoryBufferByteStream>( + std::move(Buffer), llvm::support::little); auto Allocator = llvm::make_unique<BumpPtrAllocator>(); auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), *Allocator); diff --git a/llvm/lib/DebugInfo/PDB/Native/PDBFile.cpp b/llvm/lib/DebugInfo/PDB/Native/PDBFile.cpp index e1cf9102773..7e4f1652114 100644 --- a/llvm/lib/DebugInfo/PDB/Native/PDBFile.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/PDBFile.cpp @@ -11,8 +11,11 @@ #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" #include "llvm/DebugInfo/PDB/Native/DbiStream.h" @@ -39,7 +42,7 @@ namespace { typedef FixedStreamArray<support::ulittle32_t> ulittle_array; } // end anonymous namespace -PDBFile::PDBFile(StringRef Path, std::unique_ptr<ReadableStream> PdbFileBuffer, +PDBFile::PDBFile(StringRef Path, std::unique_ptr<BinaryStream> PdbFileBuffer, BumpPtrAllocator &Allocator) : FilePath(Path), Allocator(Allocator), Buffer(std::move(PdbFileBuffer)) {} @@ -113,7 +116,7 @@ Error PDBFile::setBlockData(uint32_t BlockIndex, uint32_t Offset, } Error PDBFile::parseFileHeaders() { - StreamReader Reader(*Buffer); + BinaryStreamReader Reader(*Buffer); // Initialize SB. const msf::SuperBlock *SB = nullptr; @@ -147,7 +150,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); - StreamReader FpmReader(*FpmStream); + BinaryStreamReader FpmReader(*FpmStream); ArrayRef<uint8_t> FpmBytes; if (auto EC = FpmReader.readBytes(FpmBytes, msf::getFullFpmByteSize(ContainerLayout))) @@ -185,8 +188,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); - StreamReader Reader(*DS); - if (auto EC = Reader.readInteger(NumStreams, llvm::support::little)) + BinaryStreamReader Reader(*DS); + if (auto EC = Reader.readInteger(NumStreams)) return EC; if (auto EC = Reader.readArray(ContainerLayout.StreamSizes, NumStreams)) @@ -350,7 +353,7 @@ Expected<StringTable &> PDBFile::getStringTable() { if (!NS) return NS.takeError(); - StreamReader Reader(**NS); + BinaryStreamReader Reader(**NS); auto N = llvm::make_unique<StringTable>(); if (auto EC = N->load(Reader)) return std::move(EC); @@ -403,7 +406,7 @@ bool PDBFile::hasStringTable() { /// contain the stream returned by createIndexedStream(). Expected<std::unique_ptr<MappedBlockStream>> PDBFile::safelyCreateIndexedStream(const MSFLayout &Layout, - const ReadableStream &MsfData, + BinaryStreamRef MsfData, uint32_t StreamIndex) const { if (StreamIndex >= getNumStreams()) return make_error<RawError>(raw_error_code::no_stream); diff --git a/llvm/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp b/llvm/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp index fde61ddc650..298382fdc7d 100644 --- a/llvm/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp @@ -12,6 +12,8 @@ #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" @@ -118,8 +120,9 @@ Error PDBFileBuilder::commit(StringRef Filename) { if (OutFileOrError.getError()) return llvm::make_error<pdb::GenericError>(generic_error_code::invalid_path, Filename); - FileBufferByteStream Buffer(std::move(*OutFileOrError)); - StreamWriter Writer(Buffer); + FileBufferByteStream Buffer(std::move(*OutFileOrError), + llvm::support::little); + BinaryStreamWriter Writer(Buffer); if (auto EC = Writer.writeObject(*Layout.SB)) return EC; @@ -131,9 +134,8 @@ Error PDBFileBuilder::commit(StringRef Filename) { auto DirStream = WritableMappedBlockStream::createDirectoryStream(Layout, Buffer); - StreamWriter DW(*DirStream); - if (auto EC = DW.writeInteger<uint32_t>(Layout.StreamSizes.size(), - llvm::support::little)) + BinaryStreamWriter DW(*DirStream); + if (auto EC = DW.writeInteger<uint32_t>(Layout.StreamSizes.size())) return EC; if (auto EC = DW.writeArray(Layout.StreamSizes)) @@ -150,7 +152,7 @@ Error PDBFileBuilder::commit(StringRef Filename) { auto NS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StringTableStreamNo); - StreamWriter NSWriter(*NS); + BinaryStreamWriter NSWriter(*NS); if (auto EC = Strings.commit(NSWriter)) return EC; diff --git a/llvm/lib/DebugInfo/PDB/Native/PublicsStream.cpp b/llvm/lib/DebugInfo/PDB/Native/PublicsStream.cpp index 57b77b8254d..fe85a329a58 100644 --- a/llvm/lib/DebugInfo/PDB/Native/PublicsStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/PublicsStream.cpp @@ -27,6 +27,7 @@ #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" @@ -69,7 +70,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() { - StreamReader Reader(*Stream); + BinaryStreamReader Reader(*Stream); // Check stream size. if (Reader.bytesRemaining() < sizeof(HeaderInfo) + sizeof(GSIHashHeader)) diff --git a/llvm/lib/DebugInfo/PDB/Native/StringTable.cpp b/llvm/lib/DebugInfo/PDB/Native/StringTable.cpp index c81bff48191..79a78c92598 100644 --- a/llvm/lib/DebugInfo/PDB/Native/StringTable.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/StringTable.cpp @@ -17,13 +17,12 @@ #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(StreamReader &Stream) { +Error StringTable::load(BinaryStreamReader &Stream) { const StringTableHeader *H; if (auto EC = Stream.readObject(H)) return EC; @@ -55,7 +54,7 @@ Error StringTable::load(StreamReader &Stream) { return make_error<RawError>(raw_error_code::corrupt_file, "Missing name count"); - if (auto EC = Stream.readInteger(NameCount, llvm::support::little)) + if (auto EC = Stream.readInteger(NameCount)) return EC; return Error::success(); } @@ -68,9 +67,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; - StreamReader NameReader(NamesBuffer); + BinaryStreamReader NameReader(NamesBuffer); NameReader.setOffset(ID); - if (auto EC = NameReader.readZeroString(Result)) + if (auto EC = NameReader.readCString(Result)) consumeError(std::move(EC)); return Result; } diff --git a/llvm/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp b/llvm/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp index 8fad775ecdc..9df97c9753e 100644 --- a/llvm/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp @@ -52,7 +52,7 @@ uint32_t StringTableBuilder::finalize() { return Size; } -Error StringTableBuilder::commit(msf::StreamWriter &Writer) const { +Error StringTableBuilder::commit(BinaryStreamWriter &Writer) const { // Write a header StringTableHeader H; H.Signature = StringTableSignature; @@ -67,14 +67,14 @@ Error StringTableBuilder::commit(msf::StreamWriter &Writer) const { StringRef S = Pair.first; uint32_t Offset = Pair.second; Writer.setOffset(StringStart + Offset); - if (auto EC = Writer.writeZeroString(S)) + if (auto EC = Writer.writeCString(S)) return EC; } Writer.setOffset(StringStart + StringSize); // Write a hash table. uint32_t BucketCount = computeBucketCount(Strings.size()); - if (auto EC = Writer.writeInteger(BucketCount, llvm::support::little)) + if (auto EC = Writer.writeInteger(BucketCount)) return EC; std::vector<ulittle32_t> Buckets(BucketCount); @@ -96,8 +96,7 @@ Error StringTableBuilder::commit(msf::StreamWriter &Writer) const { if (auto EC = Writer.writeArray(ArrayRef<ulittle32_t>(Buckets))) return EC; - if (auto EC = Writer.writeInteger(static_cast<uint32_t>(Strings.size()), - llvm::support::little)) + if (auto EC = Writer.writeInteger(static_cast<uint32_t>(Strings.size()))) return EC; return Error::success(); } diff --git a/llvm/lib/DebugInfo/PDB/Native/SymbolStream.cpp b/llvm/lib/DebugInfo/PDB/Native/SymbolStream.cpp index 3f0e07a99e1..e0b8924c306 100644 --- a/llvm/lib/DebugInfo/PDB/Native/SymbolStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/SymbolStream.cpp @@ -17,6 +17,7 @@ #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; @@ -30,7 +31,7 @@ SymbolStream::SymbolStream(std::unique_ptr<MappedBlockStream> Stream) SymbolStream::~SymbolStream() {} Error SymbolStream::reload() { - StreamReader Reader(*Stream); + BinaryStreamReader Reader(*Stream); if (auto EC = Reader.readArray(SymbolRecords, Stream->getLength())) return EC; diff --git a/llvm/lib/DebugInfo/PDB/Native/TpiStream.cpp b/llvm/lib/DebugInfo/PDB/Native/TpiStream.cpp index 8f9dd0a793b..954374ca4df 100644 --- a/llvm/lib/DebugInfo/PDB/Native/TpiStream.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/TpiStream.cpp @@ -14,6 +14,7 @@ #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" @@ -54,7 +55,7 @@ Error TpiStream::verifyHashValues() { } Error TpiStream::reload() { - StreamReader Reader(*Stream); + BinaryStreamReader Reader(*Stream); if (Reader.bytesRemaining() < sizeof(TpiStreamHeader)) return make_error<RawError>(raw_error_code::corrupt_file, @@ -93,7 +94,7 @@ Error TpiStream::reload() { auto HS = MappedBlockStream::createIndexedStream( Pdb.getMsfLayout(), Pdb.getMsfBuffer(), Header->HashStreamIndex); - StreamReader HSR(*HS); + BinaryStreamReader HSR(*HS); uint32_t NumHashValues = Header->HashValueBuffer.Length / sizeof(ulittle32_t); diff --git a/llvm/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp b/llvm/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp index 29c1ec00fc7..7d532ee56d8 100644 --- a/llvm/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp @@ -34,7 +34,8 @@ using namespace llvm::pdb; using namespace llvm::support; TpiStreamBuilder::TpiStreamBuilder(MSFBuilder &Msf, uint32_t StreamIdx) - : Msf(Msf), Allocator(Msf.getAllocator()), Header(nullptr), Idx(StreamIdx) { + : Msf(Msf), Allocator(Msf.getAllocator()), + TypeRecordStream(llvm::support::little), Header(nullptr), Idx(StreamIdx) { } TpiStreamBuilder::~TpiStreamBuilder() = default; @@ -82,7 +83,7 @@ Error TpiStreamBuilder::finalize() { return Error::success(); } -uint32_t TpiStreamBuilder::calculateSerializedLength() const { +uint32_t TpiStreamBuilder::calculateSerializedLength() { return sizeof(TpiStreamHeader) + TypeRecordStream.getLength(); } @@ -113,19 +114,20 @@ Error TpiStreamBuilder::finalizeMsfLayout() { } ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(HashBuffer.data()), HashBufferSize); - HashValueStream = llvm::make_unique<ByteStream>(Bytes); + HashValueStream = + llvm::make_unique<BinaryByteStream>(Bytes, llvm::support::little); return Error::success(); } Error TpiStreamBuilder::commit(const msf::MSFLayout &Layout, - const msf::WritableStream &Buffer) { + WritableBinaryStreamRef Buffer) { if (auto EC = finalize()) return EC; auto InfoS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, Idx); - StreamWriter Writer(*InfoS); + BinaryStreamWriter Writer(*InfoS); if (auto EC = Writer.writeObject(*Header)) return EC; @@ -136,7 +138,7 @@ Error TpiStreamBuilder::commit(const msf::MSFLayout &Layout, if (HashStreamIndex != kInvalidStreamIndex) { auto HVS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer, HashStreamIndex); - StreamWriter HW(*HVS); + BinaryStreamWriter HW(*HVS); if (auto EC = HW.writeStreamRef(*HashValueStream)) return EC; } diff --git a/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp b/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp index 1843a3c9e0f..11c566facb3 100644 --- a/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp +++ b/llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp @@ -22,6 +22,7 @@ #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" @@ -450,7 +451,7 @@ Error LLVMOutputStyle::dumpStreamBytes() { auto Blocks = File.getMsfLayout().StreamMap[SI]; P.printList("Blocks", Blocks); - StreamReader R(*S); + BinaryStreamReader R(*S); ArrayRef<uint8_t> StreamData; if (auto EC = R.readBytes(StreamData, S->getLength())) return EC; @@ -745,10 +746,10 @@ Error LLVMOutputStyle::dumpDbiStream() { public: RecordVisitor(ScopedPrinter &P, PDBFile &F) : P(P), F(F) {} Error visitUnknown(ModuleSubstreamKind Kind, - ReadableStreamRef Stream) override { + BinaryStreamRef Stream) override { DictScope DD(P, "Unknown"); ArrayRef<uint8_t> Data; - StreamReader R(Stream); + BinaryStreamReader R(Stream); if (auto EC = R.readBytes(Data, R.bytesRemaining())) { return make_error<RawError>( raw_error_code::corrupt_file, @@ -758,7 +759,7 @@ Error LLVMOutputStyle::dumpDbiStream() { return Error::success(); } Error - visitFileChecksums(ReadableStreamRef Data, + visitFileChecksums(BinaryStreamRef Data, const FileChecksumArray &Checksums) override { DictScope DD(P, "FileChecksums"); for (const auto &C : Checksums) { @@ -774,7 +775,7 @@ Error LLVMOutputStyle::dumpDbiStream() { return Error::success(); } - Error visitLines(ReadableStreamRef Data, + Error visitLines(BinaryStreamRef Data, const LineSubstreamHeader *Header, const LineInfoArray &Lines) override { DictScope DD(P, "Lines"); diff --git a/llvm/tools/llvm-pdbdump/YamlTypeDumper.cpp b/llvm/tools/llvm-pdbdump/YamlTypeDumper.cpp index 80bf9349b0c..e2b901be868 100644 --- a/llvm/tools/llvm-pdbdump/YamlTypeDumper.cpp +++ b/llvm/tools/llvm-pdbdump/YamlTypeDumper.cpp @@ -573,8 +573,8 @@ struct MappingContextTraits<pdb::yaml::PdbTpiFieldListRecord, assert(IO.outputting()); codeview::TypeVisitorCallbackPipeline Pipeline; - msf::ByteStream Data(Obj.Record.Data); - msf::StreamReader FieldReader(Data); + BinaryByteStream Data(Obj.Record.Data, llvm::support::little); + BinaryStreamReader FieldReader(Data); codeview::FieldListDeserializer Deserializer(FieldReader); // For PDB to Yaml, deserialize into a high level record type, then dump diff --git a/llvm/tools/llvm-readobj/COFFDumper.cpp b/llvm/tools/llvm-readobj/COFFDumper.cpp index 329768fcaa6..be90d18b121 100644 --- a/llvm/tools/llvm-readobj/COFFDumper.cpp +++ b/llvm/tools/llvm-readobj/COFFDumper.cpp @@ -56,7 +56,6 @@ using namespace llvm; using namespace llvm::object; using namespace llvm::codeview; -using namespace llvm::msf; using namespace llvm::support; using namespace llvm::Win64EH; @@ -155,7 +154,7 @@ public: Sec = Obj->getCOFFSection(SR); } - uint32_t getRecordOffset(msf::StreamReader Reader) override { + uint32_t getRecordOffset(BinaryStreamReader Reader) override { ArrayRef<uint8_t> Data; if (auto EC = Reader.readLongestContiguousChunk(Data)) { llvm::consumeError(std::move(EC)); @@ -841,13 +840,13 @@ void COFFDumper::printCodeViewSymbolSection(StringRef SectionName, } case ModuleSubstreamKind::FrameData: { // First four bytes is a relocation against the function. - msf::ByteStream S(Contents); - msf::StreamReader SR(S); - const uint32_t *CodePtr; - error(SR.readObject(CodePtr)); + BinaryByteStream S(Contents, llvm::support::little); + BinaryStreamReader SR(S); + StringRef CodePtr; + error(SR.readFixedString(CodePtr, 4)); StringRef LinkageName; error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents, - CodePtr, LinkageName)); + CodePtr.data(), LinkageName)); W.printString("LinkageName", LinkageName); // To find the active frame description, search this array for the @@ -966,9 +965,9 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, CVSymbolDumper CVSD(W, TypeDB, std::move(CODD), opts::CodeViewSubsectionBytes); - ByteStream Stream(BinaryData); + BinaryByteStream Stream(BinaryData, llvm::support::little); CVSymbolArray Symbols; - StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); if (auto EC = Reader.readArray(Symbols, Reader.getLength())) { consumeError(std::move(EC)); W.flush(); @@ -983,8 +982,8 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, } void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) { - msf::ByteStream S(Subsection); - msf::StreamReader SR(S); + BinaryByteStream S(Subsection, llvm::support::little); + BinaryStreamReader SR(S); while (!SR.empty()) { DictScope S(W, "FileChecksum"); const FileChecksum *FC; @@ -1012,10 +1011,10 @@ void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) { } void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) { - msf::ByteStream S(Subsection); - msf::StreamReader SR(S); + BinaryByteStream S(Subsection, llvm::support::little); + BinaryStreamReader SR(S); uint32_t Signature; - error(SR.readInteger(Signature, llvm::support::little)); + error(SR.readInteger(Signature)); bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles); while (!SR.empty()) { @@ -1028,12 +1027,12 @@ void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) { if (HasExtraFiles) { uint32_t ExtraFileCount; - error(SR.readInteger(ExtraFileCount, llvm::support::little)); + error(SR.readInteger(ExtraFileCount)); W.printNumber("ExtraFileCount", ExtraFileCount); ListScope ExtraFiles(W, "ExtraFiles"); for (unsigned I = 0; I < ExtraFileCount; ++I) { uint32_t FileID; - error(SR.readInteger(FileID, llvm::support::little)); + error(SR.readInteger(FileID)); printFileNameForOffset("FileID", FileID); } } @@ -1078,9 +1077,9 @@ void COFFDumper::mergeCodeViewTypes(TypeTableBuilder &CVTypes) { error(object_error::parse_failed); ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(Data.data()), Data.size()); - ByteStream Stream(Bytes); + BinaryByteStream Stream(Bytes, llvm::support::little); CVTypeArray Types; - StreamReader Reader(Stream); + BinaryStreamReader Reader(Stream); if (auto EC = Reader.readArray(Types, Reader.getLength())) { consumeError(std::move(EC)); W.flush(); diff --git a/llvm/unittests/DebugInfo/PDB/BinaryStreamTest.cpp b/llvm/unittests/DebugInfo/PDB/BinaryStreamTest.cpp new file mode 100644 index 00000000000..4c38fa48fe6 --- /dev/null +++ b/llvm/unittests/DebugInfo/PDB/BinaryStreamTest.cpp @@ -0,0 +1,764 @@ +//===- 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 <unordered_map> + +using namespace llvm; +using namespace llvm::support; + +#define EXPECT_NO_ERROR(Err) \ + { \ + auto E = Err; \ + EXPECT_FALSE(static_cast<bool>(E)); \ + if (E) \ + consumeError(std::move(E)); \ + } + +#define ASSERT_NO_ERROR(Err) \ + { \ + auto E = Err; \ + ASSERT_FALSE(static_cast<bool>(E)); \ + if (E) \ + consumeError(std::move(E)); \ + } + +#define EXPECT_ERROR(Err) \ + { \ + auto E = Err; \ + EXPECT_TRUE(static_cast<bool>(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<uint8_t> &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<uint8_t>(Size); + ::memcpy(Ptr, Ref.data(), Ref.size()); + ::memcpy(Ptr + Ref.size(), Data.data(), BytesLeft); + Buffer = makeArrayRef<uint8_t>(Ptr, Size); + return Error::success(); + } + + Error readLongestContiguousChunk(uint32_t Offset, + ArrayRef<uint8_t> &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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> InputData; + std::vector<uint8_t> OutputData; + + BinaryByteStream InputByteStream; + DiscontiguousStream InputBrokenStream; + + MutableBinaryByteStream OutputByteStream; + DiscontiguousStream OutputBrokenStream; + + std::vector<BinaryStream *> InputStreams; + std::vector<WritableBinaryStream *> OutputStreams; +}; + +// Tests that a we can read from a BinaryByteStream without a StreamReader. +TEST_F(BinaryStreamTest, BinaryByteStreamProperties) { + std::vector<uint8_t> InputData = {1, 2, 3, 4, 5}; + initialize(InputData, InputData.size()); + + for (auto Stream : InputStreams) { + ArrayRef<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> Data2; + ASSERT_NO_ERROR(OS->readBytes(Offset, ExpectedSize, Data2)); + EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2); + } + + std::vector<uint8_t> 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<uint32_t> Ints = {90823, 12908, 109823, 209823}; + ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(Ints.data()), + Ints.size() * sizeof(uint32_t)); + + initialize(IntBytes, 0); + ASSERT_EQ(2U, InputStreams.size()); + + for (auto IS : InputStreams) { + MutableArrayRef<uint8_t> Buffer; + ASSERT_EQ(InputData.size(), IS->getLength()); + + FixedStreamArray<uint32_t> 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<uint8_t> StringBytes( + reinterpret_cast<const uint8_t *>(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<uint8_t> Bytes; + if (auto EC = Stream.readBytes(0, Len, Bytes)) + return EC; + Item = + StringRef(reinterpret_cast<const char *>(Bytes.data()), Bytes.size()); + ++Index; + return Error::success(); + } + + private: + uint32_t Index = 0; + }; + + for (auto IS : InputStreams) { + VarStreamArray<StringRef, StringExtractor> 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<uint8_t> 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, 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<uint8_t> 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<int> Ints = {1, 2, 3, 4, 5}; + ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(&Ints[0]), + Ints.size() * sizeof(int)); + initialize(IntBytes, 0); + for (auto IS : InputStreams) { + BinaryStreamReader Reader(*IS); + ArrayRef<int> IntsRef; + ASSERT_NO_ERROR(Reader.readArray(IntsRef, Ints.size())); + ASSERT_EQ(0U, Reader.bytesRemaining()); + EXPECT_EQ(makeArrayRef(Ints), IntsRef); + + Reader.setOffset(0); + FixedStreamArray<int> FixedIntsRef; + ASSERT_NO_ERROR(Reader.readArray(FixedIntsRef, Ints.size())); + ASSERT_EQ(0U, Reader.bytesRemaining()); + ASSERT_EQ(Ints, std::vector<int>(FixedIntsRef.begin(), FixedIntsRef.end())); + } +} + +TEST_F(BinaryStreamTest, StreamReaderEnum) { + enum class MyEnum : int64_t { Foo = -10, Bar = 0, Baz = 10 }; + + std::vector<MyEnum> Enums = {MyEnum::Bar, MyEnum::Baz, MyEnum::Foo}; + + ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(&Enums[0]), + sizeof(MyEnum) * Enums.size()); + + initialize(Bytes, 0); + for (auto IS : InputStreams) { + BinaryStreamReader Reader(*IS); + + MyEnum V1; + MyEnum V2; + MyEnum V3; + ArrayRef<MyEnum> Array; + FixedStreamArray<MyEnum> 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<MyEnum>(FSA.begin(), FSA.end())); + } +} + +TEST_F(BinaryStreamTest, StreamReaderObject) { + struct Foo { + int X; + double Y; + char Z; + }; + + std::vector<Foo> Foos; + Foos.push_back({-42, 42.42, 42}); + Foos.push_back({100, 3.1415, -89}); + + std::vector<uint8_t> Bytes; + Bytes.resize(2 * sizeof(Foo)); + Foo *FPtr = reinterpret_cast<Foo *>(&Bytes[0]); + Foo *GPtr = FPtr + 1; + + ::memcpy(FPtr, &Foos[0], sizeof(Foo)); + ::memcpy(GPtr + sizeof(Foo), &Foos[1], sizeof(Foo)); + + initialize(Bytes, 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(FPtr, FPtrOut, sizeof(Foo))); + EXPECT_EQ(0, ::memcmp(GPtr, GPtrOut, sizeof(Foo))); + } +} + +TEST_F(BinaryStreamTest, StreamReaderStrings) { + std::vector<uint8_t> 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<int> SourceInts = {1, 2, 3, 4, 5}; + ArrayRef<uint8_t> SourceBytes(reinterpret_cast<uint8_t *>(&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<int> Ints; + ArrayRef<int> 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, StreamWriterEnum) { + enum class MyEnum : int64_t { Foo = -10, Bar = 0, Baz = 10 }; + + std::vector<MyEnum> Expected = {MyEnum::Bar, MyEnum::Foo, MyEnum::Baz}; + + initialize(Expected.size() * sizeof(MyEnum)); + + for (auto OS : OutputStreams) { + BinaryStreamWriter Writer(*OS); + ArrayRef<MyEnum> Enums; + ArrayRef<MyEnum> Enums2; + + // First read them, then write them, then read them back. + for (auto ME : Expected) + ASSERT_NO_ERROR(Writer.writeEnum(ME)); + + ArrayRef<MyEnum> 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<StringRef> 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<std::unique_ptr<BinaryItemStreamObject>> { + size_t length(const std::unique_ptr<BinaryItemStreamObject> &Item) { + size_t S = sizeof(Item->X); + S += sizeof(Item->Y); + return S; + } + + ArrayRef<uint8_t> bytes(const std::unique_ptr<BinaryItemStreamObject> &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<uint8_t>(Size); + MutableBinaryByteStream Stream(MutableArrayRef<uint8_t>(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<std::unique_ptr<BinaryItemStreamObject>> Objects; + Objects.push_back(llvm::make_unique<BinaryItemStreamObject>(1, 1.0)); + Objects.push_back(llvm::make_unique<BinaryItemStreamObject>(2, 2.0)); + Objects.push_back(llvm::make_unique<BinaryItemStreamObject>(3, 3.0)); + + BinaryItemStream<std::unique_ptr<BinaryItemStreamObject>> 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/llvm/unittests/DebugInfo/PDB/CMakeLists.txt b/llvm/unittests/DebugInfo/PDB/CMakeLists.txt index cbbbd817748..cb57ada5ee4 100644 --- a/llvm/unittests/DebugInfo/PDB/CMakeLists.txt +++ b/llvm/unittests/DebugInfo/PDB/CMakeLists.txt @@ -5,6 +5,7 @@ set(LLVM_LINK_COMPONENTS ) set(DebugInfoPDBSources + BinaryStreamTest.cpp HashTableTest.cpp MappedBlockStreamTest.cpp StringTableBuilderTest.cpp diff --git a/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp b/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp index bd86589b757..fae7d375e17 100644 --- a/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp +++ b/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp @@ -19,6 +19,7 @@ using namespace llvm; using namespace llvm::pdb; +using namespace llvm::support; namespace { class HashTableInternals : public HashTable { @@ -147,14 +148,14 @@ TEST(HashTableTest, Serialization) { } std::vector<uint8_t> Buffer(Table.calculateSerializedLength()); - msf::MutableByteStream Stream(Buffer); - msf::StreamWriter Writer(Stream); + MutableBinaryByteStream Stream(Buffer, little); + BinaryStreamWriter 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; - msf::StreamReader Reader(Stream); + BinaryStreamReader 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/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp b/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp index e7da6caed7c..9a713efd5be 100644 --- a/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp +++ b/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp @@ -22,13 +22,14 @@ 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 WritableStream { +class DiscontiguousStream : public WritableBinaryStream { public: DiscontiguousStream(ArrayRef<uint32_t> Blocks, MutableArrayRef<uint8_t> Data) : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(), Data.end()) {} @@ -36,31 +37,33 @@ public: uint32_t block_size() const { return 1; } uint32_t block_count() const { return Blocks.size(); } + endianness getEndian() const { return little; } + Error readBytes(uint32_t Offset, uint32_t Size, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { if (Offset + Size > Data.size()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); Buffer = Data.slice(Offset, Size); return Error::success(); } Error readLongestContiguousChunk(uint32_t Offset, - ArrayRef<uint8_t> &Buffer) const override { + ArrayRef<uint8_t> &Buffer) override { if (Offset >= Data.size()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); Buffer = Data.drop_front(Offset); return Error::success(); } - uint32_t getLength() const override { return Data.size(); } + uint32_t getLength() override { return Data.size(); } - Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> SrcData) const override { + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> SrcData) override { if (Offset + SrcData.size() > Data.size()) - return make_error<MSFError>(msf_error_code::insufficient_buffer); + return errorCodeToError(make_error_code(std::errc::no_buffer_space)); ::memcpy(&Data[Offset], SrcData.data(), SrcData.size()); return Error::success(); } - Error commit() const override { return Error::success(); } + Error commit() override { return Error::success(); } MSFStreamLayout layout() const { return MSFStreamLayout{static_cast<uint32_t>(Data.size()), Blocks}; @@ -78,8 +81,8 @@ TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) { auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); - ReadableStreamRef SR; + BinaryStreamReader R(*S); + BinaryStreamRef SR; EXPECT_NO_ERROR(R.readStreamRef(SR, 0U)); ArrayRef<uint8_t> Buffer; EXPECT_ERROR(SR.readBytes(0U, 1U, Buffer)); @@ -94,7 +97,7 @@ TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) { auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA"; EXPECT_NO_ERROR(R.readFixedString(Str, 1)); EXPECT_EQ(Str, StringRef("A")); @@ -108,7 +111,7 @@ TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 2)); EXPECT_EQ(Str, StringRef("AB")); @@ -127,7 +130,7 @@ TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 10)); EXPECT_EQ(Str, StringRef("ABCDEFGHIJ")); @@ -140,7 +143,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str; R.setOffset(10); @@ -154,7 +157,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str; R.setOffset(6); @@ -168,7 +171,7 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str; EXPECT_ERROR(R.readFixedString(Str, 11)); @@ -181,7 +184,7 @@ TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str; EXPECT_NO_ERROR(R.readFixedString(Str, 1)); EXPECT_EQ(Str, StringRef("A")); @@ -195,7 +198,7 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingRead) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str1; StringRef Str2; EXPECT_NO_ERROR(R.readFixedString(Str1, 7)); @@ -216,7 +219,7 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) { DiscontiguousStream F(BlocksAry, DataAry); auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(), F.layout(), F); - StreamReader R(*S); + BinaryStreamReader R(*S); StringRef Str1; StringRef Str2; EXPECT_NO_ERROR(R.readFixedString(Str1, 6)); @@ -323,10 +326,10 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { uint32_t intArr1[] = {890723408, 29082234}; ArrayRef<uint32_t> intArray[] = {intArr0, intArr1}; - 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)); + BinaryStreamReader Reader(*S); + BinaryStreamWriter Writer(*S); + EXPECT_NO_ERROR(Writer.writeInteger(u16[0])); + EXPECT_NO_ERROR(Reader.readInteger(u16[1])); EXPECT_EQ(u16[0], u16[1]); EXPECT_EQ(std::vector<uint8_t>({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}), DataBytes); @@ -334,8 +337,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { Reader.setOffset(0); Writer.setOffset(0); ::memset(DataBytes.data(), 0, 10); - EXPECT_NO_ERROR(Writer.writeInteger(u32[0], llvm::support::little)); - EXPECT_NO_ERROR(Reader.readInteger(u32[1], llvm::support::little)); + EXPECT_NO_ERROR(Writer.writeInteger(u32[0])); + EXPECT_NO_ERROR(Reader.readInteger(u32[1])); EXPECT_EQ(u32[0], u32[1]); EXPECT_EQ(std::vector<uint8_t>({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}), DataBytes); @@ -343,8 +346,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { Reader.setOffset(0); Writer.setOffset(0); ::memset(DataBytes.data(), 0, 10); - EXPECT_NO_ERROR(Writer.writeEnum(Enum[0], llvm::support::little)); - EXPECT_NO_ERROR(Reader.readEnum(Enum[1], llvm::support::little)); + EXPECT_NO_ERROR(Writer.writeEnum(Enum[0])); + EXPECT_NO_ERROR(Reader.readEnum(Enum[1])); EXPECT_EQ(Enum[0], Enum[1]); EXPECT_EQ(std::vector<uint8_t>({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}), DataBytes); @@ -352,8 +355,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { Reader.setOffset(0); Writer.setOffset(0); ::memset(DataBytes.data(), 0, 10); - EXPECT_NO_ERROR(Writer.writeZeroString(ZStr[0])); - EXPECT_NO_ERROR(Reader.readZeroString(ZStr[1])); + EXPECT_NO_ERROR(Writer.writeCString(ZStr[0])); + EXPECT_NO_ERROR(Reader.readCString(ZStr[1])); EXPECT_EQ(ZStr[0], ZStr[1]); EXPECT_EQ( std::vector<uint8_t>({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}), @@ -399,22 +402,22 @@ TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) { F.block_size(), F.block_count(), F.layout(), F); // First write "Test Str" into the source stream. - MutableByteStream SourceStream(SrcData); - StreamWriter SourceWriter(SourceStream); - EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str")); + MutableBinaryByteStream SourceStream(SrcData, little); + BinaryStreamWriter SourceWriter(SourceStream); + EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str")); EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>( {'T', 'e', 's', 't', ' ', 'S', 't', 'r', 0, 0})); // Then write the source stream into the dest stream. - StreamWriter DestWriter(*DestStream); + BinaryStreamWriter DestWriter(*DestStream); EXPECT_NO_ERROR(DestWriter.writeStreamRef(SourceStream)); EXPECT_EQ(DestDataBytes, std::vector<uint8_t>( {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0})); // Then read the string back out of the dest stream. StringRef Result; - StreamReader DestReader(*DestStream); - EXPECT_NO_ERROR(DestReader.readZeroString(Result)); + BinaryStreamReader DestReader(*DestStream); + EXPECT_NO_ERROR(DestReader.readCString(Result)); EXPECT_EQ(Result, "Test Str"); } @@ -436,21 +439,21 @@ TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) { SrcF.block_size(), SrcF.block_count(), SrcF.layout(), SrcF); // First write "Test Str" into the source stream. - StreamWriter SourceWriter(*Src); - EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str")); + BinaryStreamWriter SourceWriter(*Src); + EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str")); EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>( {'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0})); // Then write the source stream into the dest stream. - StreamWriter DestWriter(*Dest); + BinaryStreamWriter DestWriter(*Dest); EXPECT_NO_ERROR(DestWriter.writeStreamRef(*Src)); EXPECT_EQ(DestDataBytes, std::vector<uint8_t>( {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0})); // Then read the string back out of the dest stream. StringRef Result; - StreamReader DestReader(*Dest); - EXPECT_NO_ERROR(DestReader.readZeroString(Result)); + BinaryStreamReader DestReader(*Dest); + EXPECT_NO_ERROR(DestReader.readCString(Result)); EXPECT_EQ(Result, "Test Str"); } diff --git a/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp b/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp index 61b88f8615f..aecffbe9b01 100644 --- a/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp +++ b/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp @@ -19,6 +19,7 @@ using namespace llvm; using namespace llvm::pdb; +using namespace llvm::support; namespace { class StringTableBuilderTest : public ::testing::Test {}; @@ -33,13 +34,13 @@ TEST_F(StringTableBuilderTest, Simple) { EXPECT_EQ(9U, Builder.insert("baz")); std::vector<uint8_t> Buffer(Builder.finalize()); - msf::MutableByteStream OutStream(Buffer); - msf::StreamWriter Writer(OutStream); + MutableBinaryByteStream OutStream(Buffer, little); + BinaryStreamWriter Writer(OutStream); EXPECT_NO_ERROR(Builder.commit(Writer)); // Reads the contents back. - msf::ByteStream InStream(Buffer); - msf::StreamReader Reader(InStream); + BinaryByteStream InStream(Buffer, little); + BinaryStreamReader Reader(InStream); StringTable Table; EXPECT_NO_ERROR(Table.load(Reader)); |
