[llvm] r296215 - [PDB] General improvements to Stream library.
Vedant Kumar via llvm-commits
llvm-commits at lists.llvm.org
Sat Feb 25 23:29:39 PST 2017
Also, I'd appreciate it if you could separate the NFC renaming/doc update changes, test additions, and bug fixes into separate commits to make them easier to follow.
thanks,
vedant
> On Feb 24, 2017, at 4:44 PM, Zachary Turner via llvm-commits <llvm-commits at lists.llvm.org> wrote:
>
> Author: zturner
> Date: Fri Feb 24 18:44:30 2017
> New Revision: 296215
>
> URL: http://llvm.org/viewvc/llvm-project?rev=296215&view=rev
> Log:
> [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.
>
> Added:
> llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp
> Modified:
> llvm/trunk/include/llvm/ADT/STLExtras.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/CVRecord.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstream.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/RecordSerialization.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecord.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolSerializer.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/TypeDeserializer.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecord.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h
> llvm/trunk/include/llvm/DebugInfo/CodeView/TypeSerializer.h
> llvm/trunk/include/llvm/DebugInfo/MSF/BinaryByteStream.h
> llvm/trunk/include/llvm/DebugInfo/MSF/BinaryItemStream.h
> llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStream.h
> llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h
> llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamReader.h
> llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamRef.h
> llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h
> llvm/trunk/include/llvm/DebugInfo/MSF/MappedBlockStream.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStream.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/HashTable.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModInfo.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModStream.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/PDBFile.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/PublicsStream.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTable.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiHashing.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStream.h
> llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h
> llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
> llvm/trunk/lib/DebugInfo/CodeView/CVTypeDumper.cpp
> llvm/trunk/lib/DebugInfo/CodeView/CVTypeVisitor.cpp
> llvm/trunk/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp
> llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstream.cpp
> llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp
> llvm/trunk/lib/DebugInfo/CodeView/RecordSerialization.cpp
> llvm/trunk/lib/DebugInfo/CodeView/TypeSerializer.cpp
> llvm/trunk/lib/DebugInfo/MSF/BinaryStreamReader.cpp
> llvm/trunk/lib/DebugInfo/MSF/BinaryStreamWriter.cpp
> llvm/trunk/lib/DebugInfo/MSF/MappedBlockStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/DbiStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/GSI.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/GSI.h
> llvm/trunk/lib/DebugInfo/PDB/Native/GlobalsStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/HashTable.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/InfoStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/ModInfo.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/ModStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/PDBFile.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/PublicsStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/StringTable.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/SymbolStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/TpiStream.cpp
> llvm/trunk/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp
> llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.cpp
> llvm/trunk/tools/llvm-pdbdump/YamlTypeDumper.cpp
> llvm/trunk/tools/llvm-readobj/COFFDumper.cpp
> llvm/trunk/unittests/DebugInfo/PDB/CMakeLists.txt
> llvm/trunk/unittests/DebugInfo/PDB/HashTableTest.cpp
> llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
> llvm/trunk/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp
>
> Modified: llvm/trunk/include/llvm/ADT/STLExtras.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/STLExtras.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/STLExtras.h (original)
> +++ llvm/trunk/include/llvm/ADT/STLExtras.h Fri Feb 24 18:44:30 2017
> @@ -640,6 +640,16 @@ detail::concat_range<ValueT, RangeTs...>
> // 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 {
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/CVRecord.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/CVRecord.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/CVRecord.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/CVRecord.h Fri Feb 24 18:44:30 2017
> @@ -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:
> }
> };
>
> -} // end namespace msf
> -
> } // end namespace llvm
>
> #endif // LLVM_DEBUGINFO_CODEVIEW_RECORDITERATOR_H
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h Fri Feb 24 18:44:30 2017
> @@ -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.
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstream.h Fri Feb 24 18:44:30 2017
> @@ -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 VarStreamArrayExtract
> return Error::success();
> }
> };
> -} // namespace msf
> } // namespace llvm
>
> #endif // LLVM_DEBUGINFO_CODEVIEW_MODULESUBSTREAM_H
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/RecordSerialization.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/RecordSerialization.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/RecordSerialization.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/RecordSerialization.h Fri Feb 24 18:44:30 2017
> @@ -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> seriali
> 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
> 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_
> 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_
> 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_a
> 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_
> #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)...);
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h Fri Feb 24 18:44:30 2017
> @@ -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;
> };
>
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecord.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecord.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecord.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecord.h Fri Feb 24 18:44:30 2017
> @@ -938,7 +938,7 @@ public:
> };
>
> typedef CVRecord<SymbolKind> CVSymbol;
> -typedef msf::VarStreamArray<CVSymbol> CVSymbolArray;
> +typedef VarStreamArray<CVSymbol> CVSymbolArray;
>
> } // end namespace codeview
> } // end namespace llvm
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolSerializer.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolSerializer.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolSerializer.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolSerializer.h Fri Feb 24 18:44:30 2017
> @@ -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 SymbolVi
> }
>
> public:
> - explicit SymbolSerializer(msf::StreamWriter &Writer)
> + explicit SymbolSerializer(BinaryStreamWriter &Writer)
> : Writer(Writer), Mapping(Writer) {}
>
> virtual Error visitSymbolBegin(CVSymbol &Record) override {
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h Fri Feb 24 18:44:30 2017
> @@ -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;
> };
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/TypeDeserializer.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/TypeDeserializer.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/TypeDeserializer.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/TypeDeserializer.h Fri Feb 24 18:44:30 2017
> @@ -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));
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecord.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecord.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecord.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecord.h Fri Feb 24 18:44:30 2017
> @@ -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.
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/TypeSerializer.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/TypeSerializer.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/CodeView/TypeSerializer.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/CodeView/TypeSerializer.h Fri Feb 24 18:44:30 2017
> @@ -56,8 +56,8 @@ class TypeSerializer : public TypeVisito
> 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))
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryByteStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryByteStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryByteStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryByteStream.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryItemStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryItemStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryItemStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryItemStream.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStream.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h Fri Feb 24 18:44:30 2017
> @@ -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 VarStreamAr
> /// 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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamReader.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamReader.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamReader.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamReader.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamRef.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamRef.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamRef.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamRef.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamWriter.h Fri Feb 24 18:44:30 2017
> @@ -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);
> + /// 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);
> + }
> +
> + /// 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);
> }
>
> - Error writeZeroString(StringRef Str);
> - Error writeFixedString(StringRef Str);
> - Error writeStreamRef(ReadableStreamRef Ref);
> - Error writeStreamRef(ReadableStreamRef Ref, uint32_t Size);
> -
> - 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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/MSF/MappedBlockStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/MappedBlockStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/MSF/MappedBlockStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/MSF/MappedBlockStream.h Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStream.h Fri Feb 24 18:44:30 2017
> @@ -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;
> };
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/GlobalsStream.h Fri Feb 24 18:44:30 2017
> @@ -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;
> };
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/HashTable.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/HashTable.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/HashTable.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/HashTable.h Fri Feb 24 18:44:30 2017
> @@ -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);
> };
>
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModInfo.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModInfo.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModInfo.h Fri Feb 24 18:44:30 2017
> @@ -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 VarStreamArrayExtract
> }
> };
>
> -} // end namespace msf
> -
> } // end namespace llvm
>
> #endif // LLVM_DEBUGINFO_PDB_RAW_MODINFO_H
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/ModStream.h Fri Feb 24 18:44:30 2017
> @@ -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;
> };
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/PDBFile.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/PDBFile.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/PDBFile.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/PDBFile.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/PublicsStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/PublicsStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/PublicsStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/PublicsStream.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTable.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTable.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTable.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTable.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/StringTableBuilder.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiHashing.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiHashing.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiHashing.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiHashing.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStream.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStream.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStream.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp (original)
> +++ llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp Fri Feb 24 18:44:30 2017
> @@ -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;
>
> Modified: llvm/trunk/lib/DebugInfo/CodeView/CVTypeDumper.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/CVTypeDumper.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/CodeView/CVTypeDumper.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/CodeView/CVTypeDumper.cpp Fri Feb 24 18:44:30 2017
> @@ -56,9 +56,9 @@ Error CVTypeDumper::dump(const CVTypeArr
> }
>
> 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;
>
>
> Modified: llvm/trunk/lib/DebugInfo/CodeView/CVTypeVisitor.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/CVTypeVisitor.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/CodeView/CVTypeVisitor.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/CodeView/CVTypeVisitor.cpp Fri Feb 24 18:44:30 2017
> @@ -174,7 +174,7 @@ Error CVTypeVisitor::visitTypeStream(CVT
> 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::visitFieldListMembe
>
> 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::visitFieldListMembe
> }
>
> 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);
> }
>
> Modified: llvm/trunk/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp Fri Feb 24 18:44:30 2017
> @@ -87,14 +87,13 @@ Error CodeViewRecordIO::mapByteVectorTai
>
> 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(Strin
> 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::mapStringZVector
> 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::mapStringZVector
> 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::writeEncodedSign
>
> 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;
> }
>
>
> Modified: llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstream.cpp Fri Feb 24 18:44:30 2017
> @@ -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::getRecordLengt
>
> ModuleSubstreamKind ModuleSubstream::getSubstreamKind() const { return Kind; }
>
> -ReadableStreamRef ModuleSubstream::getRecordData() const { return Data; }
> +BinaryStreamRef ModuleSubstream::getRecordData() const { return Data; }
>
> Modified: llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/CodeView/ModuleSubstreamVisitor.cpp Fri Feb 24 18:44:30 2017
> @@ -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::visitModuleSubstre
> 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::visitModuleSubstre
> 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;
>
> Modified: llvm/trunk/lib/DebugInfo/CodeView/RecordSerialization.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/RecordSerialization.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/CodeView/RecordSerialization.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/CodeView/RecordSerialization.cpp Fri Feb 24 18:44:30 2017
> @@ -33,11 +33,11 @@ StringRef llvm::codeview::getBytesAsCStr
> 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::Strea
> 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::Strea
>
> 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(ms
> 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);
> }
>
> Modified: llvm/trunk/lib/DebugInfo/CodeView/TypeSerializer.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/TypeSerializer.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/CodeView/TypeSerializer.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/CodeView/TypeSerializer.cpp Fri Feb 24 18:44:30 2017
> @@ -76,7 +76,7 @@ TypeSerializer::addPadding(MutableArrayR
> 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(MutableArrayR
>
> 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(CVM
>
> 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);
>
>
> Modified: llvm/trunk/lib/DebugInfo/MSF/BinaryStreamReader.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/MSF/BinaryStreamReader.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/MSF/BinaryStreamReader.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/MSF/BinaryStreamReader.cpp Fri Feb 24 18:44:30 2017
> @@ -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(Stri
> 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!");
>
> Modified: llvm/trunk/lib/DebugInfo/MSF/BinaryStreamWriter.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/MSF/BinaryStreamWriter.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/MSF/BinaryStreamWriter.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/MSF/BinaryStreamWriter.cpp Fri Feb 24 18:44:30 2017
> @@ -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(Stri
> 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))
>
> Modified: llvm/trunk/lib/DebugInfo/MSF/MappedBlockStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/MSF/MappedBlockStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/MSF/MappedBlockStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/MSF/MappedBlockStream.cpp Fri Feb 24 18:44:30 2017
> @@ -47,22 +47,20 @@ static Interval intersect(const Interval
>
> 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(c
>
> 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
>
> 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(uint3
> 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::readLongestCont
> 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::tryReadContiguou
> }
>
> 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::fixCacheAfterWri
>
> 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::createIndexed
>
> 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::createDirecto
>
> 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::writeBy
> return Error::success();
> }
>
> -Error WritableMappedBlockStream::commit() const {
> - return WriteInterface.commit();
> -}
> +Error WritableMappedBlockStream::commit() { return WriteInterface.commit(); }
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/DbiStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/DbiStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/DbiStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/DbiStream.cpp Fri Feb 24 18:44:30 2017
> @@ -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:
> 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()
> 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::initializeSectionContri
> 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::initializeSectionHeader
> "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::initializeSectionMapDat
> 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(
> }
>
> 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;
> }
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp Fri Feb 24 18:44:30 2017
> @@ -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::generateModiSubs
> 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::generateFileInfo
> 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::generateFileInfo
> // 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::generateFileInfo
> 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> DbiStreamBuilde
> }
>
> 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
> 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
> 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
> continue;
> auto WritableStream = WritableMappedBlockStream::createIndexedStream(
> Layout, Buffer, Stream.StreamNumber);
> - StreamWriter DbgStreamWriter(*WritableStream);
> + BinaryStreamWriter DbgStreamWriter(*WritableStream);
> if (auto EC = DbgStreamWriter.writeArray(Stream.Data))
> return EC;
> }
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/GSI.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/GSI.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/GSI.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/GSI.cpp Fri Feb 24 18:44:30 2017
> @@ -28,9 +28,9 @@ static Error checkHashHdrVersion(const G
> 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 GSIHashHea
> 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;
>
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/GSI.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/GSI.h?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/GSI.h (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/GSI.h Fri Feb 24 18:44:30 2017
> @@ -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);
> }
> }
>
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/GlobalsStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/GlobalsStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/GlobalsStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/GlobalsStream.cpp Fri Feb 24 18:44:30 2017
> @@ -23,7 +23,7 @@ GlobalsStream::GlobalsStream(std::unique
> GlobalsStream::~GlobalsStream() = default;
>
> Error GlobalsStream::reload() {
> - StreamReader Reader(*Stream);
> + BinaryStreamReader Reader(*Stream);
>
> const GSIHashHeader *HashHdr;
> if (auto EC = readGSIHashHeader(HashHdr, Reader))
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/HashTable.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/HashTable.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/HashTable.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/HashTable.cpp Fri Feb 24 18:44:30 2017
> @@ -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
> "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::calculateSerializedL
> 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::StreamWrite
> 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
>
> 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
> 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(ms
> 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"));
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/InfoStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/InfoStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/InfoStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/InfoStream.cpp Fri Feb 24 18:44:30 2017
> @@ -26,7 +26,7 @@ InfoStream::InfoStream(std::unique_ptr<M
> : Stream(std::move(Stream)) {}
>
> Error InfoStream::reload() {
> - StreamReader Reader(*Stream);
> + BinaryStreamReader Reader(*Stream);
>
> const InfoStreamHeader *H;
> if (auto EC = Reader.readObject(H))
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp Fri Feb 24 18:44:30 2017
> @@ -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::finalizeMsfLayo
> }
>
> 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;
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/ModInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/ModInfo.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/ModInfo.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/ModInfo.cpp Fri Feb 24 18:44:30 2017
> @@ -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) =
>
> 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();
> }
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/ModStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/ModStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/ModStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/ModStream.cpp Fri Feb 24 18:44:30 2017
> @@ -31,7 +31,7 @@ ModStream::ModStream(const ModInfo &Modu
> 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;
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/NamedStreamMap.cpp Fri Feb 24 18:44:30 2017
> @@ -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
> 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
> 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;
> }
>
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp Fri Feb 24 18:44:30 2017
> @@ -45,7 +45,8 @@ Error NativeSession::createFromPdb(Strin
> 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);
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/PDBFile.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/PDBFile.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/PDBFile.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/PDBFile.cpp Fri Feb 24 18:44:30 2017
> @@ -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 Blo
> }
>
> 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::getStri
> 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);
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp Fri Feb 24 18:44:30 2017
> @@ -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 F
> 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 F
>
> 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 F
>
> auto NS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer,
> StringTableStreamNo);
> - StreamWriter NSWriter(*NS);
> + BinaryStreamWriter NSWriter(*NS);
> if (auto EC = Strings.commit(NSWriter))
> return EC;
>
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/PublicsStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/PublicsStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/PublicsStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/PublicsStream.cpp Fri Feb 24 18:44:30 2017
> @@ -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() con
> // 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))
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/StringTable.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/StringTable.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/StringTable.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/StringTable.cpp Fri Feb 24 18:44:30 2017
> @@ -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 &St
> 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(ui
> // 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;
> }
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/StringTableBuilder.cpp Fri Feb 24 18:44:30 2017
> @@ -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::St
> 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::St
>
> 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();
> }
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/SymbolStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/SymbolStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/SymbolStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/SymbolStream.cpp Fri Feb 24 18:44:30 2017
> @@ -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_p
> SymbolStream::~SymbolStream() {}
>
> Error SymbolStream::reload() {
> - StreamReader Reader(*Stream);
> + BinaryStreamReader Reader(*Stream);
>
> if (auto EC = Reader.readArray(SymbolRecords, Stream->getLength()))
> return EC;
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/TpiStream.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/TpiStream.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/TpiStream.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/TpiStream.cpp Fri Feb 24 18:44:30 2017
> @@ -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);
>
> Modified: llvm/trunk/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp Fri Feb 24 18:44:30 2017
> @@ -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::finalizeMsfLayou
> }
> 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
> if (HashStreamIndex != kInvalidStreamIndex) {
> auto HVS = WritableMappedBlockStream::createIndexedStream(Layout, Buffer,
> HashStreamIndex);
> - StreamWriter HW(*HVS);
> + BinaryStreamWriter HW(*HVS);
> if (auto EC = HW.writeStreamRef(*HashValueStream))
> return EC;
> }
>
> Modified: llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.cpp (original)
> +++ llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.cpp Fri Feb 24 18:44:30 2017
> @@ -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");
>
> Modified: llvm/trunk/tools/llvm-pdbdump/YamlTypeDumper.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/YamlTypeDumper.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/tools/llvm-pdbdump/YamlTypeDumper.cpp (original)
> +++ llvm/trunk/tools/llvm-pdbdump/YamlTypeDumper.cpp Fri Feb 24 18:44:30 2017
> @@ -573,8 +573,8 @@ struct MappingContextTraits<pdb::yaml::P
> 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
>
> Modified: llvm/trunk/tools/llvm-readobj/COFFDumper.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-readobj/COFFDumper.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/tools/llvm-readobj/COFFDumper.cpp (original)
> +++ llvm/trunk/tools/llvm-readobj/COFFDumper.cpp Fri Feb 24 18:44:30 2017
> @@ -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::printCodeViewSymbolSect
> }
> 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::printCodeViewSymbolsSub
>
> 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::printCodeViewSymbolsSub
> }
>
> 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::printCodeViewFileChecks
> }
>
> 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::printCodeViewInlineeLin
>
> 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(Type
> 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();
>
> Added: llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp?rev=296215&view=auto
> ==============================================================================
> --- llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp (added)
> +++ llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp Fri Feb 24 18:44:30 2017
> @@ -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
>
> Modified: llvm/trunk/unittests/DebugInfo/PDB/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/PDB/CMakeLists.txt?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/unittests/DebugInfo/PDB/CMakeLists.txt (original)
> +++ llvm/trunk/unittests/DebugInfo/PDB/CMakeLists.txt Fri Feb 24 18:44:30 2017
> @@ -5,6 +5,7 @@ set(LLVM_LINK_COMPONENTS
> )
>
> set(DebugInfoPDBSources
> + BinaryStreamTest.cpp
> HashTableTest.cpp
> MappedBlockStreamTest.cpp
> StringTableBuilderTest.cpp
>
> Modified: llvm/trunk/unittests/DebugInfo/PDB/HashTableTest.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/PDB/HashTableTest.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/unittests/DebugInfo/PDB/HashTableTest.cpp (original)
> +++ llvm/trunk/unittests/DebugInfo/PDB/HashTableTest.cpp Fri Feb 24 18:44:30 2017
> @@ -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());
>
> Modified: llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp (original)
> +++ llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp Fri Feb 24 18:44:30 2017
> @@ -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, ReadBeyondEn
> 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, ReadOntoNonE
> 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, ZeroCopyRead
> 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, CopyReadNonC
> 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, InvalidReadS
> 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, InvalidReadS
> 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, InvalidReadS
> 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, ZeroCopyRead
> 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, UnalignedOve
> 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, UnalignedOve
> 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, TestWriteThe
> 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, TestWriteThe
> 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, TestWriteThe
> 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, TestWriteThe
> 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, TestWriteCon
> 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, TestWriteDis
> 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");
> }
>
>
> Modified: llvm/trunk/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp?rev=296215&r1=296214&r2=296215&view=diff
> ==============================================================================
> --- llvm/trunk/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp (original)
> +++ llvm/trunk/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp Fri Feb 24 18:44:30 2017
> @@ -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));
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list