[llvm] r272369 - Add support for writing through StreamInterface.
Zachary Turner via llvm-commits
llvm-commits at lists.llvm.org
Fri Jun 10 08:55:04 PDT 2016
If you're curious, The unit test writes a string followed by an integer at
an unaligned address. I have a fix in mind, just can't do it until I get in
On Fri, Jun 10, 2016 at 8:50 AM Zachary Turner <zturner at google.com> wrote:
> The bug is definitely in the unit test, fairly certain I already know the
> problem, but I'm not at a computer for ~3 more hours
> On Fri, Jun 10, 2016 at 8:48 AM Adrian Prantl <aprantl at apple.com> wrote:
>
>>
>> > On Jun 10, 2016, at 8:42 AM, Zachary Turner <zturner at google.com> wrote:
>> >
>> > Ok. You can comment this unit test out if you need to get the tree green
>>
>> Just commenting out the unit test sounds a bit dangerous to me :-)
>> Would you mind reverting atomically the commit until we can be sure that
>> the bug is in the unit test and not in the new code?
>>
>> Let me know if I can help you gathering any diagnostics if you’re having
>> trouble reproducing the failure.
>>
>> thanks,
>> adrian
>>
>>
>> > On Fri, Jun 10, 2016 at 8:33 AM Adrian Prantl <aprantl at apple.com>
>> wrote:
>> > Hi Zachary,
>> >
>> > it looks like the
>> >
>> DebugInfo/PDB/DebugInfoPDBTests/MappedBlockStreamTest.TestWriteThenRead
>> > unit test is failing under ASAN.
>> >
>> >
>> http://lab.llvm.org:8080/green/job/clang-stage2-cmake-RgSan_check/1892/consoleFull#5318301998254eaf0-7326-4999-85b0-388101f2d404
>> >
>> > > Note: Google Test filter = MappedBlockStreamTest.TestWriteThenRead
>> > > [==========] Running 1 test from 1 test case.
>> > > [----------] Global test environment set-up.
>> > > [----------] 1 test from MappedBlockStreamTest
>> > > [ RUN ] MappedBlockStreamTest.TestWriteThenRead
>> > > /Users/buildslave/jenkins/sharedspace/clang-stage2-cmake-RgSan at 2/host-compiler/bin/../include/c++/v1/algorithm:1199:32:
>> runtime error: reference binding to misaligned address 0x62100001cd06 for
>> type 'const unsigned int', which requires 4 byte alignment
>> > > 0x62100001cd06: note: pointer points here
>> > > 50 5c 17 35 50 5c 17 35 7a c2 bb 01 50 5c 17 35 7a c2 bb 01 72 be
>> be be be be be be be be be be
>> > > ^
>> > > SUMMARY: AddressSanitizer: undefined-behavior
>> /Users/buildslave/jenkins/sharedspace/clang-stage2-cmake-RgSan at 2/host-compiler/bin/../include/c++/v1/algorithm:1199:32
>> in
>> >
>> >
>> > Could you please investigate?
>> >
>> > thanks,
>> > adrian
>> >
>> > > On Jun 9, 2016, at 10:09 PM, Zachary Turner via llvm-commits <
>> llvm-commits at lists.llvm.org> wrote:
>> > >
>> > > Author: zturner
>> > > Date: Fri Jun 10 00:09:12 2016
>> > > New Revision: 272369
>> > >
>> > > URL: http://llvm.org/viewvc/llvm-project?rev=272369&view=rev
>> > > Log:
>> > > Add support for writing through StreamInterface.
>> > >
>> > > This adds method and tests for writing to a PDB stream. With
>> > > this, even a PDB stream which is discontiguous can be treated
>> > > as a sequential stream of bytes for the purposes of writing.
>> > >
>> > > Reviewed By: ruiu
>> > > Differential Revision: http://reviews.llvm.org/D21157
>> > >
>> > > Added:
>> > > llvm/trunk/include/llvm/DebugInfo/CodeView/StreamWriter.h
>> > > llvm/trunk/lib/DebugInfo/CodeView/StreamWriter.cpp
>> > > Modified:
>> > > llvm/trunk/include/llvm/DebugInfo/CodeView/ByteStream.h
>> > > llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewError.h
>> > > llvm/trunk/include/llvm/DebugInfo/CodeView/StreamArray.h
>> > > llvm/trunk/include/llvm/DebugInfo/CodeView/StreamInterface.h
>> > > llvm/trunk/include/llvm/DebugInfo/CodeView/StreamReader.h
>> > > llvm/trunk/include/llvm/DebugInfo/CodeView/StreamRef.h
>> > > llvm/trunk/include/llvm/DebugInfo/PDB/Raw/IPDBFile.h
>> > > llvm/trunk/include/llvm/DebugInfo/PDB/Raw/MappedBlockStream.h
>> > > llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h
>> > > llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawError.h
>> > > llvm/trunk/include/llvm/Support/MathExtras.h
>> > > llvm/trunk/lib/DebugInfo/CodeView/ByteStream.cpp
>> > > llvm/trunk/lib/DebugInfo/CodeView/CMakeLists.txt
>> > > llvm/trunk/lib/DebugInfo/CodeView/CodeViewError.cpp
>> > > llvm/trunk/lib/DebugInfo/CodeView/StreamReader.cpp
>> > > llvm/trunk/lib/DebugInfo/CodeView/TypeDumper.cpp
>> > > llvm/trunk/lib/DebugInfo/PDB/Raw/MappedBlockStream.cpp
>> > > llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp
>> > > llvm/trunk/lib/DebugInfo/PDB/Raw/RawError.cpp
>> > > llvm/trunk/tools/llvm-readobj/COFFDumper.cpp
>> > > llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/ByteStream.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/ByteStream.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/CodeView/ByteStream.h (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/CodeView/ByteStream.h Fri Jun
>> 10 00:09:12 2016
>> > > @@ -16,19 +16,27 @@
>> > > #include "llvm/Support/Error.h"
>> > > #include <cstdint>
>> > > #include <memory>
>> > > +#include <type_traits>
>> > >
>> > > namespace llvm {
>> > > namespace codeview {
>> > > class StreamReader;
>> > >
>> > > -class ByteStream : public StreamInterface {
>> > > +template <bool Writable = false> class ByteStream : public
>> StreamInterface {
>> > > + typedef typename std::conditional<Writable,
>> MutableArrayRef<uint8_t>,
>> > > + ArrayRef<uint8_t>>::type
>> ArrayType;
>> > > +
>> > > public:
>> > > - ByteStream();
>> > > - explicit ByteStream(ArrayRef<uint8_t> Data);
>> > > - ~ByteStream() override;
>> > > + ByteStream() {}
>> > > + explicit ByteStream(ArrayType Data) : Data(Data) {}
>> > > + ~ByteStream() override {}
>> > >
>> > > Error readBytes(uint32_t Offset, uint32_t Size,
>> > > ArrayRef<uint8_t> &Buffer) const override;
>> > > + Error readLongestContiguousChunk(uint32_t Offset,
>> > > + ArrayRef<uint8_t> &Buffer) const
>> override;
>> > > +
>> > > + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const
>> override;
>> > >
>> > > uint32_t getLength() const override;
>> > >
>> > > @@ -36,9 +44,12 @@ public:
>> > > StringRef str() const;
>> > >
>> > > private:
>> > > - ArrayRef<uint8_t> Data;
>> > > + ArrayType Data;
>> > > };
>> > >
>> > > +extern template class ByteStream<true>;
>> > > +extern template class ByteStream<false>;
>> > > +
>> > > } // end namespace pdb
>> > > } // end namespace llvm
>> > >
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewError.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewError.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewError.h
>> (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewError.h Fri
>> Jun 10 00:09:12 2016
>> > > @@ -19,6 +19,7 @@ namespace codeview {
>> > > enum class cv_error_code {
>> > > unspecified = 1,
>> > > insufficient_buffer,
>> > > + operation_unsupported,
>> > > corrupt_record,
>> > > };
>> > >
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/StreamArray.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/StreamArray.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/CodeView/StreamArray.h
>> (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/CodeView/StreamArray.h Fri Jun
>> 10 00:09:12 2016
>> > > @@ -97,6 +97,8 @@ public:
>> > >
>> > > const Extractor &getExtractor() const { return E; }
>> > >
>> > > + StreamRef getUnderlyingStream() const { return Stream; }
>> > > +
>> > > private:
>> > > StreamRef Stream;
>> > > Extractor E;
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/StreamInterface.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/StreamInterface.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/CodeView/StreamInterface.h
>> (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/CodeView/StreamInterface.h Fri
>> Jun 10 00:09:12 2016
>> > > @@ -28,9 +28,22 @@ class StreamInterface {
>> > > public:
>> > > virtual ~StreamInterface() {}
>> > >
>> > > + // Given an offset into the stream and a number of bytes, attempt
>> to read
>> > > + // the bytes and set the output ArrayRef to point to a reference
>> into the
>> > > + // stream, without copying any data.
>> > > virtual Error readBytes(uint32_t Offset, uint32_t Size,
>> > > ArrayRef<uint8_t> &Buffer) const = 0;
>> > >
>> > > + // 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;
>> > > +
>> > > + // Attempt to write the given bytes into the stream at the desired
>> offset.
>> > > + // This will always necessitate a copy. Cannot shrink or grow the
>> stream,
>> > > + // only writes into existing allocated space.
>> > > + virtual Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data)
>> const = 0;
>> > > +
>> > > virtual uint32_t getLength() const = 0;
>> > > };
>> > >
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/StreamReader.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/StreamReader.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/CodeView/StreamReader.h
>> (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/CodeView/StreamReader.h Fri Jun
>> 10 00:09:12 2016
>> > > @@ -28,6 +28,7 @@ class StreamReader {
>> > > public:
>> > > StreamReader(StreamRef Stream);
>> > >
>> > > + Error readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer);
>> > > Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);
>> > > Error readInteger(uint16_t &Dest);
>> > > Error readInteger(uint32_t &Dest);
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/CodeView/StreamRef.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/StreamRef.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/CodeView/StreamRef.h (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/CodeView/StreamRef.h Fri Jun 10
>> 00:09:12 2016
>> > > @@ -24,7 +24,8 @@ public:
>> > > StreamRef(const StreamInterface &Stream, uint32_t Offset, uint32_t
>> Length)
>> > > : Stream(&Stream), ViewOffset(Offset), Length(Length) {}
>> > >
>> > > - StreamRef(const StreamRef &Stream, uint32_t Offset, uint32_t
>> Length) = delete;
>> > > + // Use StreamRef.slice() instead.
>> > > + StreamRef(const StreamRef &S, uint32_t Offset, uint32_t Length) =
>> delete;
>> > >
>> > > Error readBytes(uint32_t Offset, uint32_t Size,
>> > > ArrayRef<uint8_t> &Buffer) const override {
>> > > @@ -33,7 +34,32 @@ public:
>> > > return Stream->readBytes(ViewOffset + Offset, Size, Buffer);
>> > > }
>> > >
>> > > + // Given an offset into the stream, read as much as possible
>> without copying
>> > > + // any data.
>> > > + Error readLongestContiguousChunk(uint32_t Offset,
>> > > + ArrayRef<uint8_t> &Buffer) const
>> override {
>> > > + if (Offset >= Length)
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > +
>> > > + if (auto EC = Stream->readLongestContiguousChunk(Offset, Buffer))
>> > > + return EC;
>> > > + // This StreamRef might refer to a smaller window over a larger
>> stream. In
>> > > + // that case we will have read out more bytes than we should
>> return, because
>> > > + // we should not read past the end of the current view.
>> > > + uint32_t MaxLength = Length - Offset;
>> > > + if (Buffer.size() > MaxLength)
>> > > + Buffer = Buffer.slice(0, MaxLength);
>> > > + return Error::success();
>> > > + }
>> > > +
>> > > + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const
>> override {
>> > > + if (Data.size() + Offset > Length)
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > + return Stream->writeBytes(ViewOffset + Offset, Data);
>> > > + }
>> > > +
>> > > uint32_t getLength() const override { return Length; }
>> > > +
>> > > StreamRef drop_front(uint32_t N) const {
>> > > if (!Stream)
>> > > return StreamRef();
>> > >
>> > > Added: llvm/trunk/include/llvm/DebugInfo/CodeView/StreamWriter.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/CodeView/StreamWriter.h?rev=272369&view=auto
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/CodeView/StreamWriter.h (added)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/CodeView/StreamWriter.h Fri Jun
>> 10 00:09:12 2016
>> > > @@ -0,0 +1,82 @@
>> > > +//===- StreamWriter.h - Writes bytes and objects to a stream ----*-
>> C++ -*-===//
>> > > +//
>> > > +// The LLVM Compiler Infrastructure
>> > > +//
>> > > +// This file is distributed under the University of Illinois Open
>> Source
>> > > +// License. See LICENSE.TXT for details.
>> > > +//
>> > >
>> +//===----------------------------------------------------------------------===//
>> > > +
>> > > +#ifndef LLVM_DEBUGINFO_CODEVIEW_STREAMWRITER_H
>> > > +#define LLVM_DEBUGINFO_CODEVIEW_STREAMWRITER_H
>> > > +
>> > > +#include "llvm/ADT/ArrayRef.h"
>> > > +#include "llvm/DebugInfo/CodeView/CodeViewError.h"
>> > > +#include "llvm/DebugInfo/CodeView/StreamArray.h"
>> > > +#include "llvm/DebugInfo/CodeView/StreamInterface.h"
>> > > +#include "llvm/Support/Endian.h"
>> > > +#include "llvm/Support/Error.h"
>> > > +
>> > > +#include <string>
>> > > +
>> > > +namespace llvm {
>> > > +namespace codeview {
>> > > +
>> > > +class StreamRef;
>> > > +
>> > > +class StreamWriter {
>> > > +public:
>> > > + StreamWriter(StreamRef Stream);
>> > > +
>> > > + Error writeBytes(ArrayRef<uint8_t> Buffer);
>> > > + Error writeInteger(uint16_t Dest);
>> > > + Error writeInteger(uint32_t Dest);
>> > > + Error writeZeroString(StringRef Str);
>> > > + Error writeFixedString(StringRef Str);
>> > > + Error writeStreamRef(StreamRef Ref);
>> > > + Error writeStreamRef(StreamRef Ref, uint32_t Size);
>> > > +
>> > > + template <typename T> Error writeEnum(T Num) {
>> > > + return writeInteger(
>> > > + static_cast<typename std::underlying_type<T>::type>(Num));
>> > > + }
>> > > +
>> > > + template <typename T> Error writeObject(const T &Obj) {
>> > > + return writeBytes(
>> > > + ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&Obj),
>> sizeof(T)));
>> > > + }
>> > > +
>> > > + template <typename T> Error writeArray(ArrayRef<T> Array) {
>> > > + if (Array.size() == 0)
>> > > + return Error::success();
>> > > +
>> > > + if (Array.size() > UINT32_MAX / sizeof(T))
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > +
>> > > + return writeBytes(
>> > > + ArrayRef<uint8_t>(reinterpret_cast<const uint8_t
>> *>(Array.data()),
>> > > + Array.size() * sizeof(T)));
>> > > + }
>> > > +
>> > > + template <typename T, typename U>
>> > > + Error writeArray(VarStreamArray<T, U> Array) {
>> > > + return writeStreamRef(Array.getUnderlyingStream());
>> > > + }
>> > > +
>> > > + template <typename T> Error writeArray(FixedStreamArray<T> Array) {
>> > > + return writeStreamRef(Array.getUnderlyingStream());
>> > > + }
>> > > +
>> > > + void setOffset(uint32_t Off) { Offset = Off; }
>> > > + uint32_t getOffset() const { return Offset; }
>> > > + uint32_t getLength() const { return Stream.getLength(); }
>> > > + uint32_t bytesRemaining() const { return getLength() -
>> getOffset(); }
>> > > +
>> > > +private:
>> > > + StreamRef Stream;
>> > > + uint32_t Offset;
>> > > +};
>> > > +} // namespace codeview
>> > > +} // namespace llvm
>> > > +
>> > > +#endif // LLVM_DEBUGINFO_CODEVIEW_STREAMREADER_H
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Raw/IPDBFile.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Raw/IPDBFile.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/PDB/Raw/IPDBFile.h (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/PDB/Raw/IPDBFile.h Fri Jun 10
>> 00:09:12 2016
>> > > @@ -14,6 +14,7 @@
>> > > #include "llvm/ADT/StringRef.h"
>> > > #include "llvm/DebugInfo/CodeView/StreamArray.h"
>> > > #include "llvm/Support/Endian.h"
>> > > +#include "llvm/Support/Error.h"
>> > >
>> > > #include <stdint.h>
>> > >
>> > > @@ -34,6 +35,8 @@ public:
>> > >
>> > > virtual ArrayRef<uint8_t> getBlockData(uint32_t BlockIndex,
>> > > uint32_t NumBytes) const = 0;
>> > > + virtual Error setBlockData(uint32_t BlockIndex, uint32_t Offset,
>> > > + ArrayRef<uint8_t> Data) const = 0;
>> > > };
>> > > }
>> > > }
>> > >
>> > > Modified:
>> llvm/trunk/include/llvm/DebugInfo/PDB/Raw/MappedBlockStream.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Raw/MappedBlockStream.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/PDB/Raw/MappedBlockStream.h
>> (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/PDB/Raw/MappedBlockStream.h Fri
>> Jun 10 00:09:12 2016
>> > > @@ -31,6 +31,9 @@ class MappedBlockStream : public codevie
>> > > public:
>> > > Error readBytes(uint32_t Offset, uint32_t Size,
>> > > ArrayRef<uint8_t> &Buffer) const override;
>> > > + Error readLongestContiguousChunk(uint32_t Offset,
>> > > + ArrayRef<uint8_t> &Buffer) const
>> override;
>> > > + Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const
>> override;
>> > >
>> > > uint32_t getLength() const override;
>> > >
>> > > @@ -51,8 +54,9 @@ protected:
>> > > const IPDBFile &Pdb;
>> > > std::unique_ptr<IPDBStreamData> Data;
>> > >
>> > > + typedef MutableArrayRef<uint8_t> CacheEntry;
>> > > mutable llvm::BumpPtrAllocator Pool;
>> > > - mutable DenseMap<uint32_t, uint8_t *> CacheMap;
>> > > + mutable DenseMap<uint32_t, std::vector<CacheEntry>> CacheMap;
>> > > };
>> > >
>> > > } // end namespace pdb
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h Fri Jun 10
>> 00:09:12 2016
>> > > @@ -54,6 +54,8 @@ public:
>> > >
>> > > ArrayRef<uint8_t> getBlockData(uint32_t BlockIndex,
>> > > uint32_t NumBytes) const override;
>> > > + Error setBlockData(uint32_t BlockIndex, uint32_t Offset,
>> > > + ArrayRef<uint8_t> Data) const override;
>> > >
>> > > ArrayRef<support::ulittle32_t> getDirectoryBlockArray() const;
>> > >
>> > >
>> > > Modified: llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawError.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawError.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawError.h (original)
>> > > +++ llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawError.h Fri Jun 10
>> 00:09:12 2016
>> > > @@ -22,7 +22,9 @@ enum class raw_error_code {
>> > > corrupt_file,
>> > > insufficient_buffer,
>> > > no_stream,
>> > > - index_out_of_bounds
>> > > + index_out_of_bounds,
>> > > + invalid_block_address,
>> > > + not_writable,
>> > > };
>> > >
>> > > /// Base class for errors originating when parsing raw PDB files
>> > >
>> > > Modified: llvm/trunk/include/llvm/Support/MathExtras.h
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/MathExtras.h?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/include/llvm/Support/MathExtras.h (original)
>> > > +++ llvm/trunk/include/llvm/Support/MathExtras.h Fri Jun 10 00:09:12
>> 2016
>> > > @@ -681,6 +681,14 @@ inline int64_t SignExtend64(uint64_t X,
>> > > return int64_t(X << (64 - B)) >> (64 - B);
>> > > }
>> > >
>> > > +/// \brief Subtract two unsigned integers, X and Y, of type T and
>> return their
>> > > +/// absolute value.
>> > > +template <typename T>
>> > > +typename std::enable_if<std::is_unsigned<T>::value, T>::type
>> > > +AbsoluteDifference(T X, T Y) {
>> > > + return std::max(X, Y) - std::min(X, Y);
>> > > +}
>> > > +
>> > > /// \brief Add two unsigned integers, X and Y, of type T.
>> > > /// Clamp the result to the maximum representable value of T on
>> overflow.
>> > > /// ResultOverflowed indicates if the result is larger than the
>> maximum
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/CodeView/ByteStream.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/ByteStream.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/CodeView/ByteStream.cpp (original)
>> > > +++ llvm/trunk/lib/DebugInfo/CodeView/ByteStream.cpp Fri Jun 10
>> 00:09:12 2016
>> > > @@ -15,23 +15,61 @@
>> > > using namespace llvm;
>> > > using namespace llvm::codeview;
>> > >
>> > > -ByteStream::ByteStream() {}
>> > > +static Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Src,
>> > > + ArrayRef<uint8_t> Dest) {
>> > > + return
>> make_error<CodeViewError>(cv_error_code::operation_unsupported,
>> > > + "ByteStream is immutable.");
>> > > +}
>> > >
>> > > -ByteStream::ByteStream(ArrayRef<uint8_t> Data) : Data(Data) {}
>> > > +static Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Src,
>> > > + MutableArrayRef<uint8_t> Dest) {
>> > > + if (Dest.size() < Src.size())
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > + if (Offset > Src.size() - Dest.size())
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > >
>> > > -ByteStream::~ByteStream() {}
>> > > + ::memcpy(Dest.data() + Offset, Src.data(), Src.size());
>> > > + return Error::success();
>> > > +}
>> > >
>> > > -Error ByteStream::readBytes(uint32_t Offset, uint32_t Size,
>> > > - ArrayRef<uint8_t> &Buffer) const {
>> > > +template <bool Writable>
>> > > +Error ByteStream<Writable>::readBytes(uint32_t Offset, uint32_t Size,
>> > > + ArrayRef<uint8_t> &Buffer)
>> const {
>> > > + if (Offset > Data.size())
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > if (Data.size() < Size + Offset)
>> > > return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > Buffer = Data.slice(Offset, Size);
>> > > return Error::success();
>> > > }
>> > >
>> > > -uint32_t ByteStream::getLength() const { return Data.size(); }
>> > > +template <bool Writable>
>> > > +Error ByteStream<Writable>::readLongestContiguousChunk(
>> > > + uint32_t Offset, ArrayRef<uint8_t> &Buffer) const {
>> > > + if (Offset >= Data.size())
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > + Buffer = Data.slice(Offset);
>> > > + return Error::success();
>> > > +}
>> > > +
>> > > +template <bool Writable>
>> > > +Error ByteStream<Writable>::writeBytes(uint32_t Offset,
>> > > + ArrayRef<uint8_t> Buffer)
>> const {
>> > > + return ::writeBytes(Offset, Buffer, Data);
>> > > +}
>> > > +
>> > > +template <bool Writable> uint32_t ByteStream<Writable>::getLength()
>> const {
>> > > + return Data.size();
>> > > +}
>> > >
>> > > -StringRef ByteStream::str() const {
>> > > +template <bool Writable> StringRef ByteStream<Writable>::str() const
>> {
>> > > const char *CharData = reinterpret_cast<const char *>(Data.data());
>> > > return StringRef(CharData, Data.size());
>> > > }
>> > > +
>> > > +namespace llvm {
>> > > +namespace codeview {
>> > > +template class ByteStream<true>;
>> > > +template class ByteStream<false>;
>> > > +}
>> > > +}
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/CodeView/CMakeLists.txt
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/CMakeLists.txt?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/CodeView/CMakeLists.txt (original)
>> > > +++ llvm/trunk/lib/DebugInfo/CodeView/CMakeLists.txt Fri Jun 10
>> 00:09:12 2016
>> > > @@ -11,6 +11,7 @@ add_llvm_library(LLVMDebugInfoCodeView
>> > > ModuleSubstreamVisitor.cpp
>> > > RecordSerialization.cpp
>> > > StreamReader.cpp
>> > > + StreamWriter.cpp
>> > > SymbolDumper.cpp
>> > > TypeDumper.cpp
>> > > TypeRecord.cpp
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/CodeView/CodeViewError.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/CodeViewError.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/CodeView/CodeViewError.cpp (original)
>> > > +++ llvm/trunk/lib/DebugInfo/CodeView/CodeViewError.cpp Fri Jun 10
>> 00:09:12 2016
>> > > @@ -31,6 +31,8 @@ public:
>> > > "bytes.";
>> > > case cv_error_code::corrupt_record:
>> > > return "The CodeView record is corrupted.";
>> > > + case cv_error_code::operation_unsupported:
>> > > + return "The requested operation is not supported.";
>> > > }
>> > > llvm_unreachable("Unrecognized cv_error_code");
>> > > }
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/CodeView/StreamReader.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/StreamReader.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/CodeView/StreamReader.cpp (original)
>> > > +++ llvm/trunk/lib/DebugInfo/CodeView/StreamReader.cpp Fri Jun 10
>> 00:09:12 2016
>> > > @@ -17,6 +17,13 @@ using namespace llvm::codeview;
>> > >
>> > > StreamReader::StreamReader(StreamRef S) : Stream(S), Offset(0) {}
>> > >
>> > > +Error StreamReader::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) {
>> > > if (auto EC = Stream.readBytes(Offset, Size, Buffer))
>> > > return EC;
>> > >
>> > > Added: llvm/trunk/lib/DebugInfo/CodeView/StreamWriter.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/StreamWriter.cpp?rev=272369&view=auto
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/CodeView/StreamWriter.cpp (added)
>> > > +++ llvm/trunk/lib/DebugInfo/CodeView/StreamWriter.cpp Fri Jun 10
>> 00:09:12 2016
>> > > @@ -0,0 +1,77 @@
>> > > +//===- StreamWrite.cpp - Writes bytes and objects to a stream
>> -------------===//
>> > > +//
>> > > +// The LLVM Compiler Infrastructure
>> > > +//
>> > > +// This file is distributed under the University of Illinois Open
>> Source
>> > > +// License. See LICENSE.TXT for details.
>> > > +//
>> > >
>> +//===----------------------------------------------------------------------===//
>> > > +
>> > > +#include "llvm/DebugInfo/CodeView/StreamWriter.h"
>> > > +
>> > > +#include "llvm/DebugInfo/CodeView/CodeViewError.h"
>> > > +#include "llvm/DebugInfo/CodeView/StreamReader.h"
>> > > +#include "llvm/DebugInfo/CodeView/StreamRef.h"
>> > > +
>> > > +using namespace llvm;
>> > > +using namespace llvm::codeview;
>> > > +
>> > > +StreamWriter::StreamWriter(StreamRef S) : Stream(S), Offset(0) {}
>> > > +
>> > > +Error StreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) {
>> > > + if (auto EC = Stream.writeBytes(Offset, Buffer))
>> > > + return EC;
>> > > + Offset += Buffer.size();
>> > > + return Error::success();
>> > > +}
>> > > +
>> > > +Error StreamWriter::writeInteger(uint16_t Int) {
>> > > + return writeObject(support::ulittle16_t(Int));
>> > > +}
>> > > +
>> > > +Error StreamWriter::writeInteger(uint32_t Int) {
>> > > + return writeObject(support::ulittle32_t(Int));
>> > > +}
>> > > +
>> > > +Error StreamWriter::writeZeroString(StringRef Str) {
>> > > + if (auto EC = writeFixedString(Str))
>> > > + return EC;
>> > > + if (auto EC = writeObject('\0'))
>> > > + return EC;
>> > > +
>> > > + 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 StreamWriter::writeStreamRef(StreamRef Ref) {
>> > > + if (auto EC = writeStreamRef(Ref, Ref.getLength()))
>> > > + return EC;
>> > > + Offset += Ref.getLength();
>> > > + return Error::success();
>> > > +}
>> > > +
>> > > +Error StreamWriter::writeStreamRef(StreamRef Ref, uint32_t Length) {
>> > > + Ref = Ref.slice(0, Length);
>> > > +
>> > > + StreamReader SrcReader(Ref);
>> > > + // This is a bit tricky. If we just call readBytes, we are
>> requiring that it
>> > > + // return us the entire stream as a contiguous buffer. For large
>> streams this
>> > > + // will allocate a huge amount of space from the pool. Instead,
>> iterate over
>> > > + // each contiguous chunk until we've consumed the entire stream.
>> > > + while (SrcReader.bytesRemaining() > 0) {
>> > > + ArrayRef<uint8_t> Chunk;
>> > > + if (auto EC = SrcReader.readLongestContiguousChunk(Chunk))
>> > > + return EC;
>> > > + if (auto EC = writeBytes(Chunk))
>> > > + return EC;
>> > > + }
>> > > + return Error::success();
>> > > +}
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/CodeView/TypeDumper.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/CodeView/TypeDumper.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/CodeView/TypeDumper.cpp (original)
>> > > +++ llvm/trunk/lib/DebugInfo/CodeView/TypeDumper.cpp Fri Jun 10
>> 00:09:12 2016
>> > > @@ -692,7 +692,7 @@ bool CVTypeDumper::dump(const CVTypeArra
>> > > }
>> > >
>> > > bool CVTypeDumper::dump(ArrayRef<uint8_t> Data) {
>> > > - ByteStream Stream(Data);
>> > > + ByteStream<> Stream(Data);
>> > > CVTypeArray Types;
>> > > StreamReader Reader(Stream);
>> > > if (auto EC = Reader.readArray(Types, Reader.getLength())) {
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/PDB/Raw/MappedBlockStream.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Raw/MappedBlockStream.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/PDB/Raw/MappedBlockStream.cpp (original)
>> > > +++ llvm/trunk/lib/DebugInfo/PDB/Raw/MappedBlockStream.cpp Fri Jun 10
>> 00:09:12 2016
>> > > @@ -29,6 +29,12 @@ public:
>> > > };
>> > > }
>> > >
>> > > +typedef std::pair<uint32_t, uint32_t> Interval;
>> > > +static Interval intersect(const Interval &I1, const Interval &I2) {
>> > > + return std::make_pair(std::max(I1.first, I2.first),
>> > > + std::min(I1.second, I2.second));
>> > > +}
>> > > +
>> > > MappedBlockStream::MappedBlockStream(std::unique_ptr<IPDBStreamData>
>> Data,
>> > > const IPDBFile &Pdb)
>> > > : Pdb(Pdb), Data(std::move(Data)) {}
>> > > @@ -46,26 +52,99 @@ Error MappedBlockStream::readBytes(uint3
>> > >
>> > > auto CacheIter = CacheMap.find(Offset);
>> > > if (CacheIter != CacheMap.end()) {
>> > > - // In a more general solution, we would need to guarantee that
>> the
>> > > - // cached allocation is at least the requested size. In
>> practice, since
>> > > - // these are CodeView / PDB records, we know they are always
>> formatted
>> > > - // the same way and never change, so we should never be
>> requesting two
>> > > - // allocations from the same address with different sizes.
>> > > - Buffer = ArrayRef<uint8_t>(CacheIter->second, Size);
>> > > + // Try to find an alloc that was large enough for this request.
>> > > + for (auto &Entry : CacheIter->second) {
>> > > + if (Entry.size() >= Size) {
>> > > + Buffer = Entry.slice(0, Size);
>> > > + return Error::success();
>> > > + }
>> > > + }
>> > > + }
>> > > +
>> > > + // We couldn't find a buffer that started at the correct offset
>> (the most
>> > > + // common scenario). Try to see if there is a buffer that starts
>> at some
>> > > + // other offset but overlaps the desired range.
>> > > + for (auto &CacheItem : CacheMap) {
>> > > + Interval RequestExtent = std::make_pair(Offset, Offset + Size);
>> > > +
>> > > + // We already checked this one on the fast path above.
>> > > + if (CacheItem.first == Offset)
>> > > + continue;
>> > > + // If the initial extent of the cached item is beyond the ending
>> extent
>> > > + // of the request, there is no overlap.
>> > > + if (CacheItem.first >= Offset + Size)
>> > > + continue;
>> > > +
>> > > + // We really only have to check the last item in the list, since
>> we append
>> > > + // in order of increasing length.
>> > > + if (CacheItem.second.empty())
>> > > + continue;
>> > > +
>> > > + auto CachedAlloc = CacheItem.second.back();
>> > > + // If the initial extent of the request is beyond the ending
>> extent of
>> > > + // the cached item, there is no overlap.
>> > > + Interval CachedExtent =
>> > > + std::make_pair(CacheItem.first, CacheItem.first +
>> CachedAlloc.size());
>> > > + if (RequestExtent.first >= CachedExtent.first +
>> CachedExtent.second)
>> > > + continue;
>> > > +
>> > > + Interval Intersection = intersect(CachedExtent, RequestExtent);
>> > > + // Only use this if the entire request extent is contained in
>> the cached
>> > > + // extent.
>> > > + if (Intersection != RequestExtent)
>> > > + continue;
>> > > +
>> > > + uint32_t CacheRangeOffset =
>> > > + AbsoluteDifference(CachedExtent.first, Intersection.first);
>> > > + Buffer = CachedAlloc.slice(CacheRangeOffset, Size);
>> > > return Error::success();
>> > > }
>> > >
>> > > // Otherwise allocate a large enough buffer in the pool, memcpy the
>> data
>> > > - // into it, and return an ArrayRef to that.
>> > > + // into it, and return an ArrayRef to that. Do not touch existing
>> pool
>> > > + // allocations, as existing clients may be holding a pointer which
>> must
>> > > + // not be invalidated.
>> > > uint8_t *WriteBuffer = Pool.Allocate<uint8_t>(Size);
>> > > -
>> > > if (auto EC = readBytes(Offset,
>> MutableArrayRef<uint8_t>(WriteBuffer, Size)))
>> > > return EC;
>> > > - CacheMap.insert(std::make_pair(Offset, WriteBuffer));
>> > > +
>> > > + if (CacheIter != CacheMap.end()) {
>> > > + CacheIter->second.emplace_back(WriteBuffer, Size);
>> > > + } else {
>> > > + std::vector<CacheEntry> List;
>> > > + List.emplace_back(WriteBuffer, Size);
>> > > + CacheMap.insert(std::make_pair(Offset, List));
>> > > + }
>> > > Buffer = ArrayRef<uint8_t>(WriteBuffer, Size);
>> > > return Error::success();
>> > > }
>> > >
>> > > +Error MappedBlockStream::readLongestContiguousChunk(
>> > > + uint32_t Offset, ArrayRef<uint8_t> &Buffer) const {
>> > > + // Make sure we aren't trying to read beyond the end of the stream.
>> > > + if (Offset >= Data->getLength())
>> > > + return make_error<RawError>(raw_error_code::insufficient_buffer);
>> > > + uint32_t First = Offset / Pdb.getBlockSize();
>> > > + uint32_t Last = First;
>> > > +
>> > > + auto BlockList = Data->getStreamBlocks();
>> > > + while (Last < Pdb.getBlockCount() - 1) {
>> > > + if (BlockList[Last] != BlockList[Last + 1] - 1)
>> > > + break;
>> > > + ++Last;
>> > > + }
>> > > +
>> > > + uint32_t OffsetInFirstBlock = Offset % Pdb.getBlockSize();
>> > > + uint32_t BytesFromFirstBlock = Pdb.getBlockSize() -
>> OffsetInFirstBlock;
>> > > + uint32_t BlockSpan = Last - First + 1;
>> > > + uint32_t ByteSpan =
>> > > + BytesFromFirstBlock + (BlockSpan - 1) * Pdb.getBlockSize();
>> > > + Buffer = Pdb.getBlockData(BlockList[First], Pdb.getBlockSize());
>> > > + Buffer = Buffer.drop_front(OffsetInFirstBlock);
>> > > + Buffer = ArrayRef<uint8_t>(Buffer.data(), ByteSpan);
>> > > + return Error::success();
>> > > +}
>> > > +
>> > > uint32_t MappedBlockStream::getLength() const { return
>> Data->getLength(); }
>> > >
>> > > bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t
>> Size,
>> > > @@ -130,7 +209,73 @@ Error MappedBlockStream::readBytes(uint3
>> > > }
>> > >
>> > > return Error::success();
>> > > +}
>> > > +
>> > > +Error MappedBlockStream::writeBytes(uint32_t Offset,
>> > > + ArrayRef<uint8_t> Buffer) const {
>> > > + // Make sure we aren't trying to write beyond the end of the
>> stream.
>> > > + if (Buffer.size() > Data->getLength())
>> > > + return make_error<RawError>(raw_error_code::insufficient_buffer);
>> > >
>> > > + if (Offset > Data->getLength() - Buffer.size())
>> > > + return make_error<RawError>(raw_error_code::insufficient_buffer);
>> > > +
>> > > + uint32_t BlockNum = Offset / Pdb.getBlockSize();
>> > > + uint32_t OffsetInBlock = Offset % Pdb.getBlockSize();
>> > > +
>> > > + uint32_t BytesLeft = Buffer.size();
>> > > + auto BlockList = Data->getStreamBlocks();
>> > > + uint32_t BytesWritten = 0;
>> > > + while (BytesLeft > 0) {
>> > > + uint32_t StreamBlockAddr = BlockList[BlockNum];
>> > > + uint32_t BytesToWriteInChunk =
>> > > + std::min(BytesLeft, Pdb.getBlockSize() - OffsetInBlock);
>> > > +
>> > > + const uint8_t *Chunk = Buffer.data() + BytesWritten;
>> > > + ArrayRef<uint8_t> ChunkData(Chunk, BytesToWriteInChunk);
>> > > + if (auto EC = Pdb.setBlockData(StreamBlockAddr, OffsetInBlock,
>> ChunkData))
>> > > + return EC;
>> > > +
>> > > + BytesLeft -= BytesToWriteInChunk;
>> > > + BytesWritten += BytesToWriteInChunk;
>> > > + ++BlockNum;
>> > > + OffsetInBlock = 0;
>> > > + }
>> > > +
>> > > + // If this write overlapped a read which previously came from the
>> pool,
>> > > + // someone may still be holding a pointer to that alloc which is
>> now invalid.
>> > > + // Compute the overlapping range and update the cache entry, so any
>> > > + // outstanding buffers are automatically updated.
>> > > + for (const auto &MapEntry : CacheMap) {
>> > > + // If the end of the written extent precedes the beginning of
>> the cached
>> > > + // extent, ignore this map entry.
>> > > + if (Offset + BytesWritten < MapEntry.first)
>> > > + continue;
>> > > + for (const auto &Alloc : MapEntry.second) {
>> > > + // If the end of the cached extent precedes the beginning of
>> the written
>> > > + // extent, ignore this alloc.
>> > > + if (MapEntry.first + Alloc.size() < Offset)
>> > > + continue;
>> > > +
>> > > + // If we get here, they are guaranteed to overlap.
>> > > + Interval WriteInterval = std::make_pair(Offset, Offset +
>> BytesWritten);
>> > > + Interval CachedInterval =
>> > > + std::make_pair(MapEntry.first, MapEntry.first +
>> Alloc.size());
>> > > + // If they overlap, we need to write the new data into the
>> overlapping
>> > > + // range.
>> > > + auto Intersection = intersect(WriteInterval, CachedInterval);
>> > > + assert(Intersection.first <= Intersection.second);
>> > > +
>> > > + uint32_t Length = Intersection.second - Intersection.first;
>> > > + uint32_t SrcOffset =
>> > > + AbsoluteDifference(WriteInterval.first,
>> Intersection.first);
>> > > + uint32_t DestOffset =
>> > > + AbsoluteDifference(CachedInterval.first,
>> Intersection.first);
>> > > + ::memcpy(Alloc.data() + DestOffset, Buffer.data() + SrcOffset,
>> Length);
>> > > + }
>> > > + }
>> > > +
>> > > + return Error::success();
>> > > }
>> > >
>> > > uint32_t MappedBlockStream::getNumBytesCopied() const {
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp (original)
>> > > +++ llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp Fri Jun 10 00:09:12
>> 2016
>> > > @@ -136,6 +136,17 @@ ArrayRef<uint8_t> PDBFile::getBlockData(
>> > > NumBytes);
>> > > }
>> > >
>> > > +Error PDBFile::setBlockData(uint32_t BlockIndex, uint32_t Offset,
>> > > + ArrayRef<uint8_t> Data) const {
>> > > + if (BlockIndex >= getBlockCount())
>> > > + return
>> make_error<RawError>(raw_error_code::invalid_block_address);
>> > > +
>> > > + if (Offset > getBlockSize() - Data.size())
>> > > + return make_error<RawError>(raw_error_code::insufficient_buffer);
>> > > +
>> > > + return make_error<RawError>(raw_error_code::not_writable);
>> > > +}
>> > > +
>> > > Error PDBFile::parseFileHeaders() {
>> > > std::error_code EC;
>> > > MemoryBufferRef BufferRef = *Context->Buffer;
>> > >
>> > > Modified: llvm/trunk/lib/DebugInfo/PDB/Raw/RawError.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Raw/RawError.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/lib/DebugInfo/PDB/Raw/RawError.cpp (original)
>> > > +++ llvm/trunk/lib/DebugInfo/PDB/Raw/RawError.cpp Fri Jun 10 00:09:12
>> 2016
>> > > @@ -28,6 +28,10 @@ public:
>> > > return "The specified stream could not be loaded.";
>> > > case raw_error_code::index_out_of_bounds:
>> > > return "The specified item does not exist in the array.";
>> > > + case raw_error_code::invalid_block_address:
>> > > + return "The specified block address is not valid.";
>> > > + case raw_error_code::not_writable:
>> > > + return "The PDB does not support writing.";
>> > > }
>> > > llvm_unreachable("Unrecognized raw_error_code");
>> > > }
>> > >
>> > > Modified: llvm/trunk/tools/llvm-readobj/COFFDumper.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-readobj/COFFDumper.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/tools/llvm-readobj/COFFDumper.cpp (original)
>> > > +++ llvm/trunk/tools/llvm-readobj/COFFDumper.cpp Fri Jun 10 00:09:12
>> 2016
>> > > @@ -969,7 +969,7 @@ void COFFDumper::printCodeViewSymbolsSub
>> > >
>> SectionContents);
>> > >
>> > > CVSymbolDumper CVSD(W, CVTD, std::move(CODD),
>> opts::CodeViewSubsectionBytes);
>> > > - ByteStream Stream(BinaryData);
>> > > + ByteStream<> Stream(BinaryData);
>> > > CVSymbolArray Symbols;
>> > > StreamReader Reader(Stream);
>> > > if (auto EC = Reader.readArray(Symbols, Reader.getLength())) {
>> > > @@ -1077,7 +1077,7 @@ void COFFDumper::mergeCodeViewTypes(Memo
>> > > error(object_error::parse_failed);
>> > > ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t
>> *>(Data.data()),
>> > > Data.size());
>> > > - ByteStream Stream(Bytes);
>> > > + ByteStream<> Stream(Bytes);
>> > > CVTypeArray Types;
>> > > StreamReader Reader(Stream);
>> > > if (auto EC = Reader.readArray(Types, Reader.getLength())) {
>> > >
>> > > Modified: llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
>> > > URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp?rev=272369&r1=272368&r2=272369&view=diff
>> > >
>> ==============================================================================
>> > > --- llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
>> (original)
>> > > +++ llvm/trunk/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp Fri
>> Jun 10 00:09:12 2016
>> > > @@ -9,8 +9,10 @@
>> > >
>> > > #include <unordered_map>
>> > >
>> > > +#include "llvm/DebugInfo/CodeView/ByteStream.h"
>> > > #include "llvm/DebugInfo/CodeView/StreamReader.h"
>> > > #include "llvm/DebugInfo/CodeView/StreamRef.h"
>> > > +#include "llvm/DebugInfo/CodeView/StreamWriter.h"
>> > > #include "llvm/DebugInfo/PDB/Raw/IPDBFile.h"
>> > > #include "llvm/DebugInfo/PDB/Raw/IPDBStreamData.h"
>> > > #include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
>> > > @@ -40,35 +42,43 @@ namespace {
>> > > }
>> > >
>> > > static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9};
>> > > -static const char DataAry[] = {'A', 'B', 'C', 'F', 'E',
>> > > - 'D', 'G', 'H', 'I', 'J'};
>> > > +static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H',
>> 'I', 'J'};
>> > >
>> > > class DiscontiguousFile : public IPDBFile {
>> > > public:
>> > > - DiscontiguousFile()
>> > > - : Blocks(std::begin(BlocksAry), std::end(BlocksAry)),
>> > > - Data(std::begin(DataAry), std::end(DataAry)) {}
>> > > -
>> > > - virtual uint32_t getBlockSize() const override { return 1; }
>> > > - virtual uint32_t getBlockCount() const override { return 10; }
>> > > - virtual uint32_t getNumStreams() const override { return 1; }
>> > > - virtual uint32_t getStreamByteSize(uint32_t StreamIndex) const
>> override {
>> > > + DiscontiguousFile(ArrayRef<uint32_t> Blocks,
>> MutableArrayRef<uint8_t> Data)
>> > > + : Blocks(Blocks.begin(), Blocks.end()), Data(Data.begin(),
>> Data.end()) {}
>> > > +
>> > > + uint32_t getBlockSize() const override { return 1; }
>> > > + uint32_t getBlockCount() const override { return Blocks.size(); }
>> > > + uint32_t getNumStreams() const override { return 1; }
>> > > + uint32_t getStreamByteSize(uint32_t StreamIndex) const override {
>> > > return getBlockCount() * getBlockSize();
>> > > }
>> > > - virtual ArrayRef<support::ulittle32_t>
>> > > + ArrayRef<support::ulittle32_t>
>> > > getStreamBlockList(uint32_t StreamIndex) const override {
>> > > if (StreamIndex != 0)
>> > > return ArrayRef<support::ulittle32_t>();
>> > > return Blocks;
>> > > }
>> > > - virtual ArrayRef<uint8_t> getBlockData(uint32_t BlockIndex,
>> > > - uint32_t NumBytes) const
>> override {
>> > > + ArrayRef<uint8_t> getBlockData(uint32_t BlockIndex,
>> > > + uint32_t NumBytes) const override {
>> > > return ArrayRef<uint8_t>(&Data[BlockIndex], NumBytes);
>> > > }
>> > >
>> > > + Error setBlockData(uint32_t BlockIndex, uint32_t Offset,
>> > > + ArrayRef<uint8_t> SrcData) const override {
>> > > + if (BlockIndex >= Blocks.size())
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > + if (Offset > getBlockSize() - SrcData.size())
>> > > + return
>> make_error<CodeViewError>(cv_error_code::insufficient_buffer);
>> > > + ::memcpy(&Data[BlockIndex] + Offset, SrcData.data(),
>> SrcData.size());
>> > > + return Error::success();
>> > > + }
>> > > +
>> > > private:
>> > > std::vector<support::ulittle32_t> Blocks;
>> > > - std::vector<uint8_t> Data;
>> > > + MutableArrayRef<uint8_t> Data;
>> > > };
>> > >
>> > > class MappedBlockStreamImpl : public MappedBlockStream {
>> > > @@ -81,7 +91,7 @@ public:
>> > > // Tests that a read which is entirely contained within a single
>> block works
>> > > // and does not allocate.
>> > > TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StreamRef SR;
>> > > @@ -95,7 +105,7 @@ TEST(MappedBlockStreamTest, ReadBeyondEn
>> > > // Tests that a read which outputs into a full destination buffer
>> works and
>> > > // does not fail due to the length of the output buffer.
>> > > TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
>> > > @@ -108,7 +118,7 @@ TEST(MappedBlockStreamTest, ReadOntoNonE
>> > > // blocks are still contiguous in memory to the previous block works
>> and does
>> > > // not allocate memory.
>> > > TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StringRef Str;
>> > > @@ -126,7 +136,7 @@ TEST(MappedBlockStreamTest, ZeroCopyRead
>> > > // contiguously works and allocates only the precise amount of bytes
>> > > // requested.
>> > > TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StringRef Str;
>> > > @@ -138,7 +148,7 @@ TEST(MappedBlockStreamTest, CopyReadNonC
>> > > // Test that an out of bounds read which doesn't cross a block
>> boundary
>> > > // fails and allocates no memory.
>> > > TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StringRef Str;
>> > > @@ -151,7 +161,7 @@ TEST(MappedBlockStreamTest, InvalidReadS
>> > > // Test that an out of bounds read which crosses a contiguous block
>> boundary
>> > > // fails and allocates no memory.
>> > > TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StringRef Str;
>> > > @@ -164,7 +174,7 @@ TEST(MappedBlockStreamTest, InvalidReadS
>> > > // Test that an out of bounds read which crosses a discontiguous block
>> > > // boundary fails and allocates no memory.
>> > > TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StringRef Str;
>> > > @@ -176,7 +186,7 @@ TEST(MappedBlockStreamTest, InvalidReadS
>> > > // Tests that a read which is entirely contained within a single
>> block but
>> > > // beyond the end of a StreamRef fails.
>> > > TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) {
>> > > - DiscontiguousFile F;
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0, F),
>> F);
>> > > StreamReader R(S);
>> > > StringRef Str;
>> > > @@ -185,4 +195,257 @@ TEST(MappedBlockStreamTest, ZeroCopyRead
>> > > EXPECT_EQ(0U, S.getNumBytesCopied());
>> > > }
>> > >
>> > > +// Tests that a read which is not aligned on the same boundary as a
>> previous
>> > > +// cached request, but which is known to overlap that request,
>> shares the
>> > > +// previous allocation.
>> > > +TEST(MappedBlockStreamTest, UnalignedOverlappingRead) {
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > + MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0,
>> F), F);
>> > > + StreamReader R(S);
>> > > + StringRef Str1;
>> > > + StringRef Str2;
>> > > + EXPECT_NO_ERROR(R.readFixedString(Str1, 7));
>> > > + EXPECT_EQ(Str1, StringRef("ABCDEFG"));
>> > > + EXPECT_EQ(7U, S.getNumBytesCopied());
>> > > +
>> > > + R.setOffset(2);
>> > > + EXPECT_NO_ERROR(R.readFixedString(Str2, 3));
>> > > + EXPECT_EQ(Str2, StringRef("CDE"));
>> > > + EXPECT_EQ(Str1.data() + 2, Str2.data());
>> > > + EXPECT_EQ(7U, S.getNumBytesCopied());
>> > > +}
>> > > +
>> > > +// Tests that a read which is not aligned on the same boundary as a
>> previous
>> > > +// cached request, but which only partially overlaps a previous
>> cached request,
>> > > +// still works correctly and allocates again from the shared pool.
>> > > +TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) {
>> > > + DiscontiguousFile F(BlocksAry, DataAry);
>> > > + MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0,
>> F), F);
>> > > + StreamReader R(S);
>> > > + StringRef Str1;
>> > > + StringRef Str2;
>> > > + EXPECT_NO_ERROR(R.readFixedString(Str1, 6));
>> > > + EXPECT_EQ(Str1, StringRef("ABCDEF"));
>> > > + EXPECT_EQ(6U, S.getNumBytesCopied());
>> > > +
>> > > + R.setOffset(4);
>> > > + EXPECT_NO_ERROR(R.readFixedString(Str2, 4));
>> > > + EXPECT_EQ(Str2, StringRef("EFGH"));
>> > > + EXPECT_EQ(10U, S.getNumBytesCopied());
>> > > +}
>> > > +
>> > > +TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) {
>> > > + static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
>> 'I', 'J'};
>> > > + static uint8_t LargeBuffer[] = {'0', '1', '2', '3', '4', '5',
>> > > + '6', '7', '8', '9', 'A'};
>> > > + static uint8_t SmallBuffer[] = {'0', '1', '2'};
>> > > + static_assert(sizeof(LargeBuffer) > sizeof(Data),
>> > > + "LargeBuffer is not big enough");
>> > > +
>> > > + DiscontiguousFile F(BlocksAry, Data);
>> > > + MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0,
>> F), F);
>> > > + ArrayRef<uint8_t> Buffer;
>> > > +
>> > > + EXPECT_ERROR(S.writeBytes(0, ArrayRef<uint8_t>(LargeBuffer)));
>> > > + EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>(SmallBuffer)));
>> > > + EXPECT_NO_ERROR(S.writeBytes(7, ArrayRef<uint8_t>(SmallBuffer)));
>> > > + EXPECT_ERROR(S.writeBytes(8, ArrayRef<uint8_t>(SmallBuffer)));
>> > > +}
>> > > +
>> > > +TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) {
>> > > + static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
>> 'I', 'J'};
>> > > + DiscontiguousFile F(BlocksAry, Data);
>> > > + MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0,
>> F), F);
>> > > + ArrayRef<uint8_t> Buffer;
>> > > +
>> > > + EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
>> > > + EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
>> > > + EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
>> > > + EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
>> > > +
>> > > + EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>('J')));
>> > > + EXPECT_NO_ERROR(S.writeBytes(9, ArrayRef<uint8_t>('A')));
>> > > +
>> > > + EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
>> > > + EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
>> > > + EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
>> > > + EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
>> > > +
>> > > + EXPECT_NO_ERROR(S.writeBytes(0, ArrayRef<uint8_t>('A')));
>> > > + EXPECT_NO_ERROR(S.writeBytes(9, ArrayRef<uint8_t>('J')));
>> > > +
>> > > + EXPECT_NO_ERROR(S.readBytes(0, 1, Buffer));
>> > > + EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
>> > > + EXPECT_NO_ERROR(S.readBytes(9, 1, Buffer));
>> > > + EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
>> > > +}
>> > > +
>> > > +TEST(MappedBlockStreamTest, TestWriteBytesBreakBoundary) {
>> > > + static uint8_t Data[] = {'0', '0', '0', '0', '0', '0', '0', '0',
>> '0', '0'};
>> > > + static uint8_t TestData[] = {'T', 'E', 'S', 'T', 'I', 'N', 'G',
>> '.'};
>> > > + static uint8_t Expected[] = {'T', 'E', 'S', 'N', 'I',
>> > > + 'T', 'G', '.', '0', '0'};
>> > > +
>> > > + DiscontiguousFile F(BlocksAry, Data);
>> > > + MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0,
>> F), F);
>> > > + ArrayRef<uint8_t> Buffer;
>> > > +
>> > > + EXPECT_NO_ERROR(S.writeBytes(0, TestData));
>> > > + // First just compare the memory, then compare the result of
>> reading the
>> > > + // string out.
>> > > + EXPECT_EQ(ArrayRef<uint8_t>(Data), ArrayRef<uint8_t>(Expected));
>> > > +
>> > > + EXPECT_NO_ERROR(S.readBytes(0, 8, Buffer));
>> > > + EXPECT_EQ(Buffer, ArrayRef<uint8_t>(TestData));
>> > > +}
>> > > +
>> > > +TEST(MappedBlockStreamTest, TestWriteThenRead) {
>> > > + std::vector<uint8_t> DataBytes(10);
>> > > + MutableArrayRef<uint8_t> Data(DataBytes);
>> > > + const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
>> > > +
>> > > + DiscontiguousFile F(Blocks, Data);
>> > > + MappedBlockStreamImpl S(llvm::make_unique<IndexedStreamData>(0,
>> F), F);
>> > > +
>> > > + enum class MyEnum : uint32_t { Val1 = 2908234, Val2 = 120891234 };
>> > > +
>> > > + uint16_t u16[] = {31468, 0};
>> > > + uint32_t u32[] = {890723408, 0};
>> > > + MyEnum Enum[] = {MyEnum::Val1, MyEnum::Val2};
>> > > + StringRef ZStr[] = {"Zero Str", ""};
>> > > + StringRef FStr[] = {"Fixed Str", ""};
>> > > + ArrayRef<uint8_t> byteArray[] = {{'1', '2'}, {'0', '0'}};
>> > > + ArrayRef<uint32_t> intArray[] = {{890723408, 29082234}, {0, 0}};
>> > > +
>> > > + StreamReader Reader(S);
>> > > + StreamWriter Writer(S);
>> > > + EXPECT_NO_ERROR(Writer.writeInteger(u16[0]));
>> > > + EXPECT_NO_ERROR(Reader.readInteger(u16[1]));
>> > > + EXPECT_EQ(u16[0], u16[1]);
>> > > + EXPECT_EQ(DataBytes,
>> > > + std::vector<uint8_t>({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0,
>> 0}));
>> > > +
>> > > + Reader.setOffset(0);
>> > > + Writer.setOffset(0);
>> > > + ::memset(DataBytes.data(), 0, 10);
>> > > + EXPECT_NO_ERROR(Writer.writeInteger(u32[0]));
>> > > + EXPECT_NO_ERROR(Reader.readInteger(u32[1]));
>> > > + EXPECT_EQ(u32[0], u32[1]);
>> > > + EXPECT_EQ(DataBytes,
>> > > + std::vector<uint8_t>({0x17, 0x5C, 0x50, 0, 0, 0, 0x35,
>> 0, 0, 0}));
>> > > +
>> > > + Reader.setOffset(0);
>> > > + Writer.setOffset(0);
>> > > + ::memset(DataBytes.data(), 0, 10);
>> > > + EXPECT_NO_ERROR(Writer.writeEnum(Enum[0]));
>> > > + EXPECT_NO_ERROR(Reader.readEnum(Enum[1]));
>> > > + EXPECT_EQ(Enum[0], Enum[1]);
>> > > + EXPECT_EQ(DataBytes,
>> > > + std::vector<uint8_t>({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0,
>> 0, 0}));
>> > > +
>> > > + 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_EQ(ZStr[0], ZStr[1]);
>> > > + EXPECT_EQ(DataBytes, std::vector<uint8_t>(
>> > > + {'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r',
>> 0, 0}));
>> > > +
>> > > + Reader.setOffset(0);
>> > > + Writer.setOffset(0);
>> > > + ::memset(DataBytes.data(), 0, 10);
>> > > + EXPECT_NO_ERROR(Writer.writeFixedString(FStr[0]));
>> > > + EXPECT_NO_ERROR(Reader.readFixedString(FStr[1], FStr[0].size()));
>> > > + EXPECT_EQ(FStr[0], FStr[1]);
>> > > + EXPECT_EQ(DataBytes, std::vector<uint8_t>(
>> > > + {'x', 'i', 'F', 'd', ' ', 'S', 'e', 't',
>> 0, 'r'}));
>> > > +
>> > > + Reader.setOffset(0);
>> > > + Writer.setOffset(0);
>> > > + ::memset(DataBytes.data(), 0, 10);
>> > > + EXPECT_NO_ERROR(Writer.writeArray(byteArray[0]));
>> > > + EXPECT_NO_ERROR(Reader.readArray(byteArray[1],
>> byteArray[0].size()));
>> > > + EXPECT_EQ(byteArray[0], byteArray[1]);
>> > > + EXPECT_EQ(DataBytes,
>> > > + std::vector<uint8_t>({0, 0x32, 0x31, 0, 0, 0, 0, 0, 0,
>> 0}));
>> > > +
>> > > + Reader.setOffset(0);
>> > > + Writer.setOffset(0);
>> > > + ::memset(DataBytes.data(), 0, 10);
>> > > + EXPECT_NO_ERROR(Writer.writeArray(intArray[0]));
>> > > + EXPECT_NO_ERROR(Reader.readArray(intArray[1], intArray[0].size()));
>> > > + EXPECT_EQ(intArray[0], intArray[1]);
>> > > + EXPECT_EQ(DataBytes, std::vector<uint8_t>({0x17, 0x5C, 0x50, 0x7A,
>> 0xC2, 0xBB,
>> > > + 0x35, 0x01, 0, 0}));
>> > > +}
>> > > +
>> > > +TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) {
>> > > + std::vector<uint8_t> DestDataBytes(10);
>> > > + MutableArrayRef<uint8_t> DestData(DestDataBytes);
>> > > + const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
>> > > +
>> > > + std::vector<uint8_t> SrcDataBytes(10);
>> > > + MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
>> > > +
>> > > + DiscontiguousFile F(DestBlocks, DestData);
>> > > + MappedBlockStreamImpl
>> DestStream(llvm::make_unique<IndexedStreamData>(0, F),
>> > > + F);
>> > > +
>> > > + // First write "Test Str" into the source stream.
>> > > + ByteStream<true> SourceStream(SrcData);
>> > > + StreamWriter SourceWriter(SourceStream);
>> > > + EXPECT_NO_ERROR(SourceWriter.writeZeroString("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);
>> > > + 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));
>> > > + EXPECT_EQ(Result, "Test Str");
>> > > +}
>> > > +
>> > > +TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) {
>> > > + std::vector<uint8_t> DestDataBytes(10);
>> > > + MutableArrayRef<uint8_t> DestData(DestDataBytes);
>> > > + const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
>> > > +
>> > > + std::vector<uint8_t> SrcDataBytes(10);
>> > > + MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
>> > > + const uint32_t SrcBlocks[] = {1, 0, 6, 3, 4, 5, 2, 7, 8, 9};
>> > > +
>> > > + DiscontiguousFile DestFile(DestBlocks, DestData);
>> > > + DiscontiguousFile SrcFile(SrcBlocks, SrcData);
>> > > +
>> > > + MappedBlockStreamImpl DestStream(
>> > > + llvm::make_unique<IndexedStreamData>(0, DestFile), DestFile);
>> > > + MappedBlockStreamImpl SrcStream(
>> > > + llvm::make_unique<IndexedStreamData>(0, SrcFile), SrcFile);
>> > > +
>> > > + // First write "Test Str" into the source stream.
>> > > + StreamWriter SourceWriter(SrcStream);
>> > > + EXPECT_NO_ERROR(SourceWriter.writeZeroString("Test Str"));
>> > > + EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
>> > > + {'e', 'T', 't', 't', ' ', 'S', 's',
>> 'r', 0, 0}));
>> > > +
>> > > + // Then write the source stream into the dest stream.
>> > > + StreamWriter DestWriter(DestStream);
>> > > + EXPECT_NO_ERROR(DestWriter.writeStreamRef(SrcStream));
>> > > + 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));
>> > > + EXPECT_EQ(Result, "Test Str");
>> > > +}
>> > > +
>> > > } // end anonymous namespace
>> > >
>> > >
>> > > _______________________________________________
>> > > llvm-commits mailing list
>> > > llvm-commits at lists.llvm.org
>> > > http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>> >
>>
>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160610/df67b73d/attachment.html>
More information about the llvm-commits
mailing list