LLVM 18.0.0git
Go to the documentation of this file.
1//===- BinaryStreamWriter.cpp - Writes objects to a BinaryStream ----------===//
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
14#include "llvm/Support/LEB128.h"
16using namespace llvm;
19 : Stream(Ref) {}
22 : Stream(Stream) {}
25 llvm::endianness Endian)
26 : Stream(Data, Endian) {}
29 if (auto EC = Stream.writeBytes(Offset, Buffer))
30 return EC;
31 Offset += Buffer.size();
32 return Error::success();
36 uint8_t EncodedBytes[10] = {0};
37 unsigned Size = encodeULEB128(Value, &EncodedBytes[0]);
38 return writeBytes({EncodedBytes, Size});
42 uint8_t EncodedBytes[10] = {0};
43 unsigned Size = encodeSLEB128(Value, &EncodedBytes[0]);
44 return writeBytes({EncodedBytes, Size});
48 if (auto EC = writeFixedString(Str))
49 return EC;
50 if (auto EC = writeObject('\0'))
51 return EC;
53 return Error::success();
58 return writeBytes(arrayRefFromStringRef(Str));
62 return writeStreamRef(Ref, Ref.getLength());
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();
82std::pair<BinaryStreamWriter, BinaryStreamWriter>
84 assert(getLength() >= Off);
88 WritableBinaryStreamRef Second = First.drop_front(Off);
89 First = First.keep_front(Off);
91 BinaryStreamWriter W2{Second};
92 return std::make_pair(W1, W2);
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();
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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:334
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
Definition: bit.h:70
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39