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