LLVM 17.0.0git
BinaryStreamWriter.cpp
Go to the documentation of this file.
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
10
13#include "llvm/Support/LEB128.h"
14
15using namespace llvm;
16
18 : Stream(Ref) {}
19
21 : Stream(Stream) {}
22
25 : Stream(Data, Endian) {}
26
28 if (auto EC = Stream.writeBytes(Offset, Buffer))
29 return EC;
30 Offset += Buffer.size();
31 return Error::success();
32}
33
35 uint8_t EncodedBytes[10] = {0};
36 unsigned Size = encodeULEB128(Value, &EncodedBytes[0]);
37 return writeBytes({EncodedBytes, Size});
38}
39
41 uint8_t EncodedBytes[10] = {0};
42 unsigned Size = encodeSLEB128(Value, &EncodedBytes[0]);
43 return writeBytes({EncodedBytes, Size});
44}
45
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
56
57 return writeBytes(arrayRefFromStringRef(Str));
58}
59
61 return writeStreamRef(Ref, Ref.getLength());
62}
63
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) {
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
81std::pair<BinaryStreamWriter, BinaryStreamWriter>
83 assert(getLength() >= Off);
84
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
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}
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
uint64_t Size
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
Provides read only access to a subclass of BinaryStream.
uint64_t bytesRemaining() const
Error readLongestContiguousChunk(ArrayRef< uint8_t > &Buffer)
Read as much as possible from the underlying string at the current offset without invoking a copy,...
RefType drop_front(uint64_t N) const
Return a new BinaryStreamRef with the first N elements removed.
BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.
Provides write only access to a subclass of WritableBinaryStream.
Error writeCString(StringRef Str)
Write the string Str to the underlying stream followed by a null terminator.
Error writeArray(ArrayRef< T > Array)
Writes an array of objects of type T to the underlying stream, as if by using memcpy.
Error writeSLEB128(int64_t Value)
Write the unsigned integer Value to the underlying stream using ULEB128 encoding.
std::pair< BinaryStreamWriter, BinaryStreamWriter > split(uint64_t Off) const
Splits the Writer into two Writers at a given offset.
Error writeStreamRef(BinaryStreamRef Ref)
Efficiently reads all data from Ref, and writes it to this stream.
Error writeBytes(ArrayRef< uint8_t > Buffer)
Write the bytes specified in Buffer to the underlying stream.
Error writeFixedString(StringRef Str)
Write the string Str to the underlying stream without a null terminator.
Error writeULEB128(uint64_t Value)
Write the unsigned integer Value to the underlying stream using ULEB128 encoding.
WritableBinaryStreamRef Stream
Error writeObject(const T &Obj)
Writes the object Obj to the underlying stream, as if by using memcpy.
Error padToAlignment(uint32_t Align)
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:305
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
LLVM Value Representation.
Definition: Value.h:74
Error writeBytes(uint64_t Offset, ArrayRef< uint8_t > Data) const
Given an Offset into this WritableBinaryStreamRef and some input data, writes the data to the underly...
A BinaryStream which can be read from as well as written to.
Definition: BinaryStream.h:73
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Length
Definition: DWP.cpp:406
@ Ref
The access may reference the value stored in memory.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
unsigned encodeSLEB128(int64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a SLEB128 value to an output stream.
Definition: LEB128.h:23
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
Definition: LEB128.h:80
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39