1 //===- BinaryStreamWriter.cpp - Writes objects to a BinaryStream ----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/Support/BinaryStreamWriter.h"
10
11 #include "llvm/Support/BinaryStreamReader.h"
12 #include "llvm/Support/BinaryStreamRef.h"
13 #include "llvm/Support/LEB128.h"
14
15 using namespace llvm;
16
BinaryStreamWriter(WritableBinaryStreamRef Ref)17 BinaryStreamWriter::BinaryStreamWriter(WritableBinaryStreamRef Ref)
18 : Stream(Ref) {}
19
BinaryStreamWriter(WritableBinaryStream & Stream)20 BinaryStreamWriter::BinaryStreamWriter(WritableBinaryStream &Stream)
21 : Stream(Stream) {}
22
BinaryStreamWriter(MutableArrayRef<uint8_t> Data,llvm::support::endianness Endian)23 BinaryStreamWriter::BinaryStreamWriter(MutableArrayRef<uint8_t> Data,
24 llvm::support::endianness Endian)
25 : Stream(Data, Endian) {}
26
writeBytes(ArrayRef<uint8_t> Buffer)27 Error BinaryStreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) {
28 if (auto EC = Stream.writeBytes(Offset, Buffer))
29 return EC;
30 Offset += Buffer.size();
31 return Error::success();
32 }
33
writeULEB128(uint64_t Value)34 Error BinaryStreamWriter::writeULEB128(uint64_t Value) {
35 uint8_t EncodedBytes[10] = {0};
36 unsigned Size = encodeULEB128(Value, &EncodedBytes[0]);
37 return writeBytes({EncodedBytes, Size});
38 }
39
writeSLEB128(int64_t Value)40 Error BinaryStreamWriter::writeSLEB128(int64_t Value) {
41 uint8_t EncodedBytes[10] = {0};
42 unsigned Size = encodeSLEB128(Value, &EncodedBytes[0]);
43 return writeBytes({EncodedBytes, Size});
44 }
45
writeCString(StringRef Str)46 Error BinaryStreamWriter::writeCString(StringRef Str) {
47 if (auto EC = writeFixedString(Str))
48 return EC;
49 if (auto EC = writeObject('\0'))
50 return EC;
51
52 return Error::success();
53 }
54
writeFixedString(StringRef Str)55 Error BinaryStreamWriter::writeFixedString(StringRef Str) {
56
57 return writeBytes(arrayRefFromStringRef(Str));
58 }
59
writeStreamRef(BinaryStreamRef Ref)60 Error BinaryStreamWriter::writeStreamRef(BinaryStreamRef Ref) {
61 return writeStreamRef(Ref, Ref.getLength());
62 }
63
writeStreamRef(BinaryStreamRef Ref,uint64_t Length)64 Error BinaryStreamWriter::writeStreamRef(BinaryStreamRef Ref, uint64_t Length) {
65 BinaryStreamReader SrcReader(Ref.slice(0, Length));
66 // This is a bit tricky. If we just call readBytes, we are requiring that it
67 // return us the entire stream as a contiguous buffer. There is no guarantee
68 // this can be satisfied by returning a reference straight from the buffer, as
69 // an implementation may not store all data in a single contiguous buffer. So
70 // we iterate over each contiguous chunk, writing each one in succession.
71 while (SrcReader.bytesRemaining() > 0) {
72 ArrayRef<uint8_t> Chunk;
73 if (auto EC = SrcReader.readLongestContiguousChunk(Chunk))
74 return EC;
75 if (auto EC = writeBytes(Chunk))
76 return EC;
77 }
78 return Error::success();
79 }
80
81 std::pair<BinaryStreamWriter, BinaryStreamWriter>
split(uint64_t Off) const82 BinaryStreamWriter::split(uint64_t Off) const {
83 assert(getLength() >= Off);
84
85 WritableBinaryStreamRef First = Stream.drop_front(Offset);
86
87 WritableBinaryStreamRef Second = First.drop_front(Off);
88 First = First.keep_front(Off);
89 BinaryStreamWriter W1{First};
90 BinaryStreamWriter W2{Second};
91 return std::make_pair(W1, W2);
92 }
93
padToAlignment(uint32_t Align)94 Error BinaryStreamWriter::padToAlignment(uint32_t Align) {
95 uint64_t NewOffset = alignTo(Offset, Align);
96 const uint64_t ZerosSize = 64;
97 static constexpr char Zeros[ZerosSize] = {};
98 while (Offset < NewOffset)
99 if (auto E = writeArray(
100 ArrayRef<char>(Zeros, std::min(ZerosSize, NewOffset - Offset))))
101 return E;
102 return Error::success();
103 }
104