LLVM 19.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
14#include "llvm/Support/LEB128.h"
15
16using namespace llvm;
17
19 : Stream(Ref) {}
20
22 : Stream(Stream) {}
23
25 llvm::endianness Endian)
26 : Stream(Data, Endian) {}
27
29 if (auto EC = Stream.writeBytes(Offset, Buffer))
30 return EC;
31 Offset += Buffer.size();
32 return Error::success();
33}
34
36 uint8_t EncodedBytes[10] = {0};
37 unsigned Size = encodeULEB128(Value, &EncodedBytes[0]);
38 return writeBytes({EncodedBytes, Size});
39}
40
42 uint8_t EncodedBytes[10] = {0};
43 unsigned Size = encodeSLEB128(Value, &EncodedBytes[0]);
44 return writeBytes({EncodedBytes, Size});
45}
46
48 if (auto EC = writeFixedString(Str))
49 return EC;
50 if (auto EC = writeObject('\0'))
51 return EC;
52
53 return Error::success();
54}
55
57
58 return writeBytes(arrayRefFromStringRef(Str));
59}
60
62 return writeStreamRef(Ref, Ref.getLength());
63}
64
66 BinaryStreamReader SrcReader(Ref.slice(0, Length));
67 // This is a bit tricky. If we just call readBytes, we are requiring that it
68 // return us the entire stream as a contiguous buffer. There is no guarantee
69 // this can be satisfied by returning a reference straight from the buffer, as
70 // an implementation may not store all data in a single contiguous buffer. So
71 // we iterate over each contiguous chunk, writing each one in succession.
72 while (SrcReader.bytesRemaining() > 0) {
74 if (auto EC = SrcReader.readLongestContiguousChunk(Chunk))
75 return EC;
76 if (auto EC = writeBytes(Chunk))
77 return EC;
78 }
79 return Error::success();
80}
81
82std::pair<BinaryStreamWriter, BinaryStreamWriter>
84 assert(getLength() >= Off);
85
87
88 WritableBinaryStreamRef Second = First.drop_front(Off);
89 First = First.keep_front(Off);
91 BinaryStreamWriter W2{Second};
92 return std::make_pair(W1, W2);
93}
94
96 uint64_t NewOffset = alignTo(Offset, Align);
97 const uint64_t ZerosSize = 64;
98 static constexpr char Zeros[ZerosSize] = {};
99 while (Offset < NewOffset)
100 if (auto E = writeArray(
101 ArrayRef<char>(Zeros, std::min(ZerosSize, NewOffset - Offset))))
102 return E;
103 return Error::success();
104}
uint64_t Size
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
endianness Endian
This file contains some functions that are useful when dealing with strings.
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:165
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:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
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:72
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Length
Definition: DWP.cpp:456
@ Ref
The access may reference the value stored in memory.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
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
endianness
Definition: bit.h:70
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39