//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_DEBUGINFO_PDB_RAW_BYTESTREAM_H
-#define LLVM_DEBUGINFO_PDB_RAW_BYTESTREAM_H
+#ifndef LLVM_DEBUGINFO_CODEVIEW_BYTESTREAM_H
+#define LLVM_DEBUGINFO_CODEVIEW_BYTESTREAM_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamInterface.h"
+#include "llvm/DebugInfo/CodeView/StreamInterface.h"
#include "llvm/Support/Error.h"
#include <cstdint>
#include <memory>
namespace llvm {
-namespace pdb {
-
+namespace codeview {
class StreamReader;
class ByteStream : public StreamInterface {
} // end namespace pdb
} // end namespace llvm
-#endif // LLVM_DEBUGINFO_PDB_RAW_BYTESTREAM_H
+#endif // LLVM_DEBUGINFO_CODEVIEW_BYTESTREAM_H
--- /dev/null
+//===- CodeViewError.h - Error extensions for CodeView ----------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_CODEVIEW_CODEVIEWERROR_H
+#define LLVM_DEBUGINFO_PDB_CODEVIEW_CODEVIEWERROR_H
+
+#include "llvm/Support/Error.h"
+
+#include <string>
+
+namespace llvm {
+namespace codeview {
+enum class cv_error_code {
+ unspecified = 1,
+ insufficient_buffer,
+ corrupt_record,
+};
+
+/// Base class for errors originating when parsing raw PDB files
+class CodeViewError : public ErrorInfo<CodeViewError> {
+public:
+ static char ID;
+ CodeViewError(cv_error_code C);
+ CodeViewError(const std::string &Context);
+ CodeViewError(cv_error_code C, const std::string &Context);
+
+ void log(raw_ostream &OS) const override;
+ const std::string &getErrorMessage() const;
+ std::error_code convertToErrorCode() const override;
+
+private:
+ std::string ErrMsg;
+ cv_error_code Code;
+};
+}
+}
+#endif
-//===- StreamInterface.h - Base interface for a PDB stream ------*- C++ -*-===//
+//===- StreamInterface.h - Base interface for a stream of data --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_DEBUGINFO_PDB_RAW_STREAMINTERFACE_H
-#define LLVM_DEBUGINFO_PDB_RAW_STREAMINTERFACE_H
+#ifndef LLVM_DEBUGINFO_CODEVIEW_STREAMINTERFACE_H
+#define LLVM_DEBUGINFO_CODEVIEW_STREAMINTERFACE_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Error.h"
#include <cstdint>
namespace llvm {
-namespace pdb {
+namespace codeview {
class StreamInterface {
public:
virtual uint32_t getLength() const = 0;
};
-} // end namespace pdb
+} // end namespace codeview
} // end namespace llvm
-#endif // LLVM_DEBUGINFO_PDB_RAW_STREAMINTERFACE_H
+#endif // LLVM_DEBUGINFO_CODEVIEW_STREAMINTERFACE_H
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_DEBUGINFO_PDB_RAW_STREAMREADER_H
-#define LLVM_DEBUGINFO_PDB_RAW_STREAMREADER_H
+#ifndef LLVM_DEBUGINFO_CODEVIEW_STREAMREADER_H
+#define LLVM_DEBUGINFO_CODEVIEW_STREAMREADER_H
#include "llvm/ADT/ArrayRef.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamInterface.h"
+#include "llvm/DebugInfo/CodeView/StreamInterface.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/Error.h"
#include <string>
namespace llvm {
-namespace pdb {
-class StreamInterface;
+namespace codeview {
+
class StreamReader {
public:
StreamReader(const StreamInterface &S);
}
template <typename T> Error readArray(MutableArrayRef<T> Array) {
- MutableArrayRef<uint8_t> Casted(reinterpret_cast<uint8_t*>(Array.data()), Array.size() * sizeof(T));
+ MutableArrayRef<uint8_t> Casted(reinterpret_cast<uint8_t *>(Array.data()),
+ Array.size() * sizeof(T));
return readBytes(Casted);
}
const StreamInterface &Stream;
uint32_t Offset;
};
-}
-}
+} // namespace codeview
+} // namespace llvm
-#endif
+#endif // LLVM_DEBUGINFO_CODEVIEW_STREAMREADER_H
#ifndef LLVM_DEBUGINFO_PDB_RAW_PDBDBISTREAM_H
#define LLVM_DEBUGINFO_PDB_RAW_PDBDBISTREAM_H
+#include "llvm/DebugInfo/CodeView/ByteStream.h"
#include "llvm/DebugInfo/PDB/PDBTypes.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
#include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
std::vector<ModuleInfoEx> ModuleInfos;
NameHashTable ECNames;
- ByteStream ModInfoSubstream;
- ByteStream SecContrSubstream;
- ByteStream SecMapSubstream;
- ByteStream FileInfoSubstream;
- ByteStream TypeServerMapSubstream;
- ByteStream ECSubstream;
- ByteStream DbgHeader;
+ codeview::ByteStream ModInfoSubstream;
+ codeview::ByteStream SecContrSubstream;
+ codeview::ByteStream SecMapSubstream;
+ codeview::ByteStream FileInfoSubstream;
+ codeview::ByteStream TypeServerMapSubstream;
+ codeview::ByteStream ECSubstream;
+ codeview::ByteStream DbgHeader;
std::unique_ptr<HeaderInfo> Header;
};
#define LLVM_DEBUGINFO_PDB_RAW_MAPPEDBLOCKSTREAM_H
#include "llvm/ADT/ArrayRef.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamInterface.h"
+#include "llvm/DebugInfo/CodeView/StreamInterface.h"
#include "llvm/Support/Error.h"
#include <cstdint>
#include <vector>
class PDBFile;
-class MappedBlockStream : public StreamInterface {
+class MappedBlockStream : public codeview::StreamInterface {
public:
MappedBlockStream(uint32_t StreamIdx, const PDBFile &File);
#define LLVM_DEBUGINFO_PDB_RAW_MODSTREAM_H
#include "llvm/ADT/iterator_range.h"
+#include "llvm/DebugInfo/CodeView/ByteStream.h"
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/Support/Error.h"
MappedBlockStream Stream;
- ByteStream SymbolsSubstream;
- ByteStream LinesSubstream;
- ByteStream C13LinesSubstream;
- ByteStream GlobalRefsSubstream;
+ codeview::ByteStream SymbolsSubstream;
+ codeview::ByteStream LinesSubstream;
+ codeview::ByteStream C13LinesSubstream;
+ codeview::ByteStream GlobalRefsSubstream;
};
}
}
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
+#include "llvm/DebugInfo/CodeView/ByteStream.h"
#include "llvm/Support/Error.h"
#include <cstdint>
#include <vector>
namespace llvm {
-namespace pdb {
-
+namespace codeview {
class StreamReader;
+}
+namespace pdb {
class NameHashTable {
public:
NameHashTable();
- Error load(StreamReader &Stream);
+ Error load(codeview::StreamReader &Stream);
uint32_t getNameCount() const { return NameCount; }
uint32_t getHashVersion() const { return HashVersion; }
ArrayRef<uint32_t> name_ids() const;
private:
- ByteStream NamesBuffer;
+ codeview::ByteStream NamesBuffer;
std::vector<uint32_t> IDs;
uint32_t Signature;
uint32_t HashVersion;
#include <cstdint>
namespace llvm {
-namespace pdb {
-
+namespace codeview {
class StreamReader;
+}
+namespace pdb {
class NameMap {
public:
NameMap();
- Error load(StreamReader &Stream);
+ Error load(codeview::StreamReader &Stream);
bool tryGetValue(StringRef Name, uint32_t &Value) const;
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
#include "llvm/DebugInfo/CodeView/TypeStream.h"
#include "llvm/DebugInfo/PDB/PDBTypes.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
#ifndef LLVM_DEBUGINFO_PDB_RAW_PDBSYMBOLSTREAM_H
#define LLVM_DEBUGINFO_PDB_RAW_PDBSYMBOLSTREAM_H
+#include "llvm/DebugInfo/CodeView/ByteStream.h"
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/Support/Error.h"
iterator_range<codeview::SymbolIterator> getSymbols() const;
private:
- ByteStream Stream;
+ codeview::ByteStream Stream;
MappedBlockStream MappedStream;
};
}
#ifndef LLVM_DEBUGINFO_PDB_RAW_PDBTPISTREAM_H
#define LLVM_DEBUGINFO_PDB_RAW_PDBTPISTREAM_H
+#include "llvm/DebugInfo/CodeView/ByteStream.h"
#include "llvm/DebugInfo/CodeView/TypeStream.h"
#include "llvm/DebugInfo/PDB/PDBTypes.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
MappedBlockStream Stream;
HashFunctionType HashFunction;
- ByteStream RecordsBuffer;
- ByteStream TypeIndexOffsetBuffer;
- ByteStream HashValuesBuffer;
- ByteStream HashAdjBuffer;
+ codeview::ByteStream RecordsBuffer;
+ codeview::ByteStream TypeIndexOffsetBuffer;
+ codeview::ByteStream HashValuesBuffer;
+ codeview::ByteStream HashAdjBuffer;
std::unique_ptr<HeaderInfo> Header;
};
//
//===----------------------------------------------------------------------===//
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
-#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
+#include "llvm/DebugInfo/CodeView/ByteStream.h"
+#include "llvm/DebugInfo/CodeView/CodeViewError.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include <cstring>
using namespace llvm;
-using namespace llvm::pdb;
+using namespace llvm::codeview;
ByteStream::ByteStream() {}
Error ByteStream::readBytes(uint32_t Offset,
MutableArrayRef<uint8_t> Buffer) const {
if (Data.size() < Buffer.size() + Offset)
- return make_error<RawError>(raw_error_code::insufficient_buffer);
+ return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
::memcpy(Buffer.data(), Data.data() + Offset, Buffer.size());
return Error::success();
}
Error ByteStream::getArrayRef(uint32_t Offset, ArrayRef<uint8_t> &Buffer,
uint32_t Length) const {
if (Data.size() < Length + Offset)
- return make_error<RawError>(raw_error_code::insufficient_buffer);
+ return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
Buffer = Data.slice(Offset, Length);
return Error::success();
}
add_llvm_library(LLVMDebugInfoCodeView
+ ByteStream.cpp
+ CodeViewError.cpp
FieldListRecordBuilder.cpp
Line.cpp
ListRecordBuilder.cpp
MemoryTypeTableBuilder.cpp
MethodListRecordBuilder.cpp
RecordSerialization.cpp
+ StreamReader.cpp
SymbolDumper.cpp
TypeDumper.cpp
TypeRecord.cpp
--- /dev/null
+//===- CodeViewError.cpp - Error extensions for CodeView --------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/CodeViewError.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ManagedStatic.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+namespace {
+// FIXME: This class is only here to support the transition to llvm::Error. It
+// will be removed once this transition is complete. Clients should prefer to
+// deal with the Error value directly, rather than converting to error_code.
+class CodeViewErrorCategory : public std::error_category {
+public:
+ const char *name() const LLVM_NOEXCEPT override { return "llvm.codeview"; }
+
+ std::string message(int Condition) const override {
+ switch (static_cast<cv_error_code>(Condition)) {
+ case cv_error_code::unspecified:
+ return "An unknown error has occurred.";
+ case cv_error_code::insufficient_buffer:
+ return "The buffer is not large enough to read the requested number of "
+ "bytes.";
+ case cv_error_code::corrupt_record:
+ return "The CodeView record is corrupted.";
+ }
+ llvm_unreachable("Unrecognized cv_error_code");
+ }
+};
+} // end anonymous namespace
+
+static ManagedStatic<CodeViewErrorCategory> Category;
+
+char CodeViewError::ID = 0;
+
+CodeViewError::CodeViewError(cv_error_code C) : CodeViewError(C, "") {}
+
+CodeViewError::CodeViewError(const std::string &Context)
+ : CodeViewError(cv_error_code::unspecified, Context) {}
+
+CodeViewError::CodeViewError(cv_error_code C, const std::string &Context)
+ : Code(C) {
+ ErrMsg = "CodeView Error: ";
+ std::error_code EC = convertToErrorCode();
+ if (Code != cv_error_code::unspecified)
+ ErrMsg += EC.message() + " ";
+ if (!Context.empty())
+ ErrMsg += Context;
+}
+
+void CodeViewError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+
+const std::string &CodeViewError::getErrorMessage() const { return ErrMsg; }
+
+std::error_code CodeViewError::convertToErrorCode() const {
+ return std::error_code(static_cast<int>(Code), *Category);
+}
//
//===----------------------------------------------------------------------===//
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
-#include "llvm/DebugInfo/PDB/Raw/RawError.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
+
+#include "llvm/DebugInfo/CodeView/CodeViewError.h"
using namespace llvm;
-using namespace llvm::pdb;
+using namespace llvm::codeview;
StreamReader::StreamReader(const StreamInterface &S) : Stream(S), Offset(0) {}
endif()
add_pdb_impl_folder(Raw
- Raw/ByteStream.cpp
Raw/DbiStream.cpp
Raw/InfoStream.cpp
Raw/MappedBlockStream.cpp
Raw/PublicsStream.cpp
Raw/RawError.cpp
Raw/RawSession.cpp
- Raw/StreamReader.cpp
Raw/SymbolStream.cpp
Raw/TpiStream.cpp)
#include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
#include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
#include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
#include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
using namespace llvm;
using namespace llvm::pdb;
DbiStream::~DbiStream() {}
Error DbiStream::reload() {
- StreamReader Reader(Stream);
+ codeview::StreamReader Reader(Stream);
Header.reset(new HeaderInfo());
return make_error<RawError>(raw_error_code::corrupt_file,
"Found unexpected bytes in DBI Stream.");
- StreamReader ECReader(ECSubstream);
+ codeview::StreamReader ECReader(ECSubstream);
if (auto EC = ECNames.load(ECReader))
return EC;
#include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
using namespace llvm;
using namespace llvm::pdb;
InfoStream::InfoStream(PDBFile &File) : Pdb(File), Stream(StreamPDB, File) {}
Error InfoStream::reload() {
- StreamReader Reader(Stream);
+ codeview::StreamReader Reader(Stream);
struct Header {
support::ulittle32_t Version;
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/PDB/Raw/ModStream.h"
+
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
using namespace llvm;
using namespace llvm::pdb;
ModStream::~ModStream() {}
Error ModStream::reload() {
- StreamReader Reader(Stream);
+ codeview::StreamReader Reader(Stream);
uint32_t SymbolSize = Mod.getSymbolDebugInfoByteSize();
uint32_t C11Size = Mod.getLineInfoByteSize();
#include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
#include "llvm/ADT/ArrayRef.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
#include "llvm/Support/Endian.h"
using namespace llvm;
NameHashTable::NameHashTable() : Signature(0), HashVersion(0), NameCount(0) {}
-Error NameHashTable::load(StreamReader &Stream) {
+Error NameHashTable::load(codeview::StreamReader &Stream) {
struct Header {
support::ulittle32_t Signature;
support::ulittle32_t HashVersion;
#include "llvm/DebugInfo/PDB/Raw/NameMap.h"
#include "llvm/ADT/BitVector.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
using namespace llvm;
using namespace llvm::pdb;
NameMap::NameMap() {}
-Error NameMap::load(StreamReader &Stream) {
+Error NameMap::load(codeview::StreamReader &Stream) {
// This is some sort of weird string-set/hash table encoded in the stream.
// It starts with the number of bytes in the table.
#include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/CodeView/TypeRecord.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
#include "llvm/DebugInfo/PDB/Raw/SymbolStream.h"
#include "llvm/ADT/BitVector.h"
// we skip over the hash table which we believe contains information about
// public symbols.
Error PublicsStream::reload() {
- StreamReader Reader(Stream);
+ codeview::StreamReader Reader(Stream);
// Check stream size.
if (Reader.bytesRemaining() < sizeof(HeaderInfo) + sizeof(GSIHashHeader))
#include "llvm/DebugInfo/PDB/Raw/SymbolStream.h"
#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/CodeView/TypeRecord.h"
-#include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
#include "llvm/Support/Endian.h"
SymbolStream::~SymbolStream() {}
Error SymbolStream::reload() {
- StreamReader Reader(MappedStream);
+ codeview::StreamReader Reader(MappedStream);
if (Stream.initialize(Reader, MappedStream.getLength()))
return make_error<RawError>(raw_error_code::corrupt_file,
#include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/CodeView/TypeRecord.h"
#include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
#include "llvm/Support/Endian.h"
TpiStream::~TpiStream() {}
Error TpiStream::reload() {
- StreamReader Reader(Stream);
+ codeview::StreamReader Reader(Stream);
if (Reader.bytesRemaining() < sizeof(HeaderInfo))
return make_error<RawError>(raw_error_code::corrupt_file,
// Hash indices, hash values, etc come from the hash stream.
MappedBlockStream HS(Header->HashStreamIndex, Pdb);
- StreamReader HSR(HS);
+ codeview::StreamReader HSR(HS);
HSR.setOffset(Header->HashValueBuffer.Off);
if (auto EC =
HashValuesBuffer.initialize(HSR, Header->HashValueBuffer.Length))
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Config/config.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
#include "llvm/DebugInfo/CodeView/SymbolDumper.h"
#include "llvm/DebugInfo/CodeView/TypeDumper.h"
#include "llvm/DebugInfo/PDB/GenericError.h"
#include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
#include "llvm/DebugInfo/PDB/Raw/RawSession.h"
-#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
#include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ConvertUTF.h"
return Error::success();
MappedBlockStream S(DumpStreamNum, File);
- StreamReader R(S);
+ codeview::StreamReader R(S);
while (R.bytesRemaining() > 0) {
ArrayRef<uint8_t> Data;
uint32_t BytesToReadInBlock = std::min(
P.printNumber("Index", NameStreamIndex);
MappedBlockStream NameStream(NameStreamIndex, File);
- StreamReader Reader(NameStream);
+ codeview::StreamReader Reader(NameStream);
NameHashTable NameTable;
if (auto EC = NameTable.load(Reader))