blob: cdae7c5acc04323327b1b03831f298cb877568bb (
plain)
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
|
//===- StreamWrite.cpp - Writes bytes and objects to a stream -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/MSF/StreamWriter.h"
#include "llvm/DebugInfo/MSF/MSFError.h"
#include "llvm/DebugInfo/MSF/StreamReader.h"
#include "llvm/DebugInfo/MSF/StreamRef.h"
using namespace llvm;
using namespace llvm::msf;
StreamWriter::StreamWriter(WritableStreamRef S) : Stream(S), Offset(0) {}
Error StreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) {
if (auto EC = Stream.writeBytes(Offset, Buffer))
return EC;
Offset += Buffer.size();
return Error::success();
}
Error StreamWriter::writeInteger(uint8_t Int) { return writeObject(Int); }
Error StreamWriter::writeInteger(uint16_t Int) {
return writeObject(support::ulittle16_t(Int));
}
Error StreamWriter::writeInteger(uint32_t Int) {
return writeObject(support::ulittle32_t(Int));
}
Error StreamWriter::writeInteger(uint64_t Int) {
return writeObject(support::ulittle64_t(Int));
}
Error StreamWriter::writeInteger(int8_t Int) { return writeObject(Int); }
Error StreamWriter::writeInteger(int16_t Int) {
return writeObject(support::little16_t(Int));
}
Error StreamWriter::writeInteger(int32_t Int) {
return writeObject(support::little32_t(Int));
}
Error StreamWriter::writeInteger(int64_t Int) {
return writeObject(support::little64_t(Int));
}
Error StreamWriter::writeZeroString(StringRef Str) {
if (auto EC = writeFixedString(Str))
return EC;
if (auto EC = writeObject('\0'))
return EC;
return Error::success();
}
Error StreamWriter::writeFixedString(StringRef Str) {
ArrayRef<uint8_t> Bytes(Str.bytes_begin(), Str.bytes_end());
if (auto EC = Stream.writeBytes(Offset, Bytes))
return EC;
Offset += Str.size();
return Error::success();
}
Error StreamWriter::writeStreamRef(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 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. For large streams this
// will allocate a huge amount of space from the pool. Instead, iterate over
// each contiguous chunk until we've consumed the entire stream.
while (SrcReader.bytesRemaining() > 0) {
ArrayRef<uint8_t> Chunk;
if (auto EC = SrcReader.readLongestContiguousChunk(Chunk))
return EC;
if (auto EC = writeBytes(Chunk))
return EC;
}
return Error::success();
}
|
