#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;
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
enum class cv_error_code {
unspecified = 1,
insufficient_buffer,
+ operation_unsupported,
corrupt_record,
};
const Extractor &getExtractor() const { return E; }
+ StreamRef getUnderlyingStream() const { return Stream; }
+
private:
StreamRef Stream;
Extractor E;
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;
};
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);
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 {
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();
--- /dev/null
+//===- 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
#include "llvm/ADT/StringRef.h"
#include "llvm/DebugInfo/CodeView/StreamArray.h"
#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
#include <stdint.h>
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;
};
}
}
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;
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
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;
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
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
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>;
+}
+}
ModuleSubstreamVisitor.cpp
RecordSerialization.cpp
StreamReader.cpp
+ StreamWriter.cpp
SymbolDumper.cpp
TypeDumper.cpp
TypeRecord.cpp
"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");
}
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;
--- /dev/null
+//===- 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();
+}
}
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())) {
};
}
+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)) {}
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,
}
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 {
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;
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");
}
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())) {
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())) {
#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"
}
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 {
// 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;
// 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";
// 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;
// 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;
// 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;
// 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;
// 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;
// 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;
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
projects / llvm / commitdiff