1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
//===- 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.
//
//===----------------------------------------------------------------------===//
#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/MSFError.h"
#include "llvm/DebugInfo/MSF/StreamInterface.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FileOutputBuffer.h"
#include "llvm/Support/MemoryBuffer.h"
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <memory>
namespace llvm {
namespace msf {
class ByteStream : public ReadableStream {
public:
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) const override {
if (Offset > Data.size())
return make_error<MSFError>(msf_error_code::insufficient_buffer);
if (Data.size() < Size + Offset)
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) const override {
if (Offset >= Data.size())
return make_error<MSFError>(msf_error_code::insufficient_buffer);
Buffer = Data.slice(Offset);
return Error::success();
}
uint32_t getLength() const override { return Data.size(); }
ArrayRef<uint8_t> data() const { return Data; }
StringRef str() const {
const char *CharData = reinterpret_cast<const char *>(Data.data());
return StringRef(CharData, Data.size());
}
protected:
ArrayRef<uint8_t> Data;
};
// MemoryBufferByteStream behaves like a read-only ByteStream, but has its data
// backed by an llvm::MemoryBuffer. It also owns the underlying MemoryBuffer.
class MemoryBufferByteStream : public ByteStream {
public:
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;
};
class MutableByteStream : public WritableStream {
public:
MutableByteStream() = default;
explicit MutableByteStream(MutableArrayRef<uint8_t> Data)
: Data(Data), ImmutableStream(Data) {}
Error readBytes(uint32_t Offset, uint32_t Size,
ArrayRef<uint8_t> &Buffer) const override {
return ImmutableStream.readBytes(Offset, Size, Buffer);
}
Error readLongestContiguousChunk(uint32_t Offset,
ArrayRef<uint8_t> &Buffer) const override {
return ImmutableStream.readLongestContiguousChunk(Offset, Buffer);
}
uint32_t getLength() const override { return ImmutableStream.getLength(); }
Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override {
if (Buffer.empty())
return Error::success();
if (Data.size() < Buffer.size())
return make_error<MSFError>(msf_error_code::insufficient_buffer);
if (Offset > Buffer.size() - Data.size())
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() const override { return Error::success(); }
MutableArrayRef<uint8_t> data() const { return Data; }
private:
MutableArrayRef<uint8_t> Data;
ByteStream ImmutableStream;
};
// A simple adapter that acts like a ByteStream but holds ownership over
// and underlying FileOutputBuffer.
class FileBufferByteStream : public WritableStream {
private:
class StreamImpl : public MutableByteStream {
public:
StreamImpl(std::unique_ptr<FileOutputBuffer> Buffer)
: MutableByteStream(MutableArrayRef<uint8_t>(Buffer->getBufferStart(),
Buffer->getBufferEnd())),
FileBuffer(std::move(Buffer)) {}
Error commit() const override {
if (FileBuffer->commit())
return llvm::make_error<MSFError>(msf_error_code::not_writable);
return Error::success();
}
private:
std::unique_ptr<FileOutputBuffer> FileBuffer;
};
public:
explicit FileBufferByteStream(std::unique_ptr<FileOutputBuffer> Buffer)
: Impl(std::move(Buffer)) {}
Error readBytes(uint32_t Offset, uint32_t Size,
ArrayRef<uint8_t> &Buffer) const override {
return Impl.readBytes(Offset, Size, Buffer);
}
Error readLongestContiguousChunk(uint32_t Offset,
ArrayRef<uint8_t> &Buffer) const override {
return Impl.readLongestContiguousChunk(Offset, Buffer);
}
uint32_t getLength() const override { return Impl.getLength(); }
Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const override {
return Impl.writeBytes(Offset, Data);
}
Error commit() const override { return Impl.commit(); }
private:
StreamImpl Impl;
};
} // end namespace msf
} // end namespace llvm
#endif // LLVM_DEBUGINFO_MSF_BYTESTREAM_H
|
