LLVM  14.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 
16 using namespace llvm;
17 
19  : Stream(Ref) {}
20 
22  : Stream(Stream) {}
23 
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) {
73  ArrayRef<uint8_t> Chunk;
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 
82 std::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  if (NewOffset > getLength())
98  return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
99  while (Offset < NewOffset)
100  if (auto EC = writeInteger('\0'))
101  return EC;
102  return Error::success();
103 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:148
BinaryStreamReader.h
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::BinaryStreamWriter::writeInteger
Error writeInteger(T Value)
Write the integer Value to the underlying stream in the specified endianness.
Definition: BinaryStreamWriter.h:64
llvm::BinaryStreamWriter::Stream
WritableBinaryStreamRef Stream
Definition: BinaryStreamWriter.h:190
llvm::BinaryStreamWriter::writeFixedString
Error writeFixedString(StringRef Str)
Write the string Str to the underlying stream without a null terminator.
Definition: BinaryStreamWriter.cpp:56
llvm::BinaryStreamWriter
Provides write only access to a subclass of WritableBinaryStream.
Definition: BinaryStreamWriter.h:31
llvm::BinaryStreamReader::readLongestContiguousChunk
Error readLongestContiguousChunk(ArrayRef< uint8_t > &Buffer)
Read as much as possible from the underlying string at the current offset without invoking a copy,...
Definition: BinaryStreamReader.cpp:29
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
llvm::BinaryStreamWriter::writeStreamRef
Error writeStreamRef(BinaryStreamRef Ref)
Efficiently reads all data from Ref, and writes it to this stream.
Definition: BinaryStreamWriter.cpp:61
llvm::BinaryStreamReader::bytesRemaining
uint64_t bytesRemaining() const
Definition: BinaryStreamReader.h:257
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::MutableArrayRef< uint8_t >
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
llvm::encodeSLEB128
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
BinaryStreamError.h
First
into llvm powi allowing the code generator to produce balanced multiplication trees First
Definition: README.txt:54
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::BinaryStreamReader
Provides read only access to a subclass of BinaryStream.
Definition: BinaryStreamReader.h:31
llvm::BinaryStreamWriter::Offset
uint64_t Offset
Definition: BinaryStreamWriter.h:191
uint64_t
LEB128.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::BinaryStreamWriter::writeSLEB128
Error writeSLEB128(int64_t Value)
Write the unsigned integer Value to the underlying stream using ULEB128 encoding.
Definition: BinaryStreamWriter.cpp:41
llvm::BinaryStreamWriter::writeCString
Error writeCString(StringRef Str)
Write the string Str to the underlying stream followed by a null terminator.
Definition: BinaryStreamWriter.cpp:47
llvm::BinaryStreamWriter::writeULEB128
Error writeULEB128(uint64_t Value)
Write the unsigned integer Value to the underlying stream using ULEB128 encoding.
Definition: BinaryStreamWriter.cpp:35
llvm::ArrayRef< uint8_t >
llvm::BinaryStreamWriter::writeObject
Error writeObject(const T &Obj)
Writes the object Obj to the underlying stream, as if by using memcpy.
Definition: BinaryStreamWriter.h:135
llvm::BinaryStreamWriter::writeBytes
Error writeBytes(ArrayRef< uint8_t > Buffer)
Write the bytes specified in Buffer to the underlying stream.
Definition: BinaryStreamWriter.cpp:28
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
BinaryStreamRef.h
uint32_t
llvm::BinaryStreamWriter::padToAlignment
Error padToAlignment(uint32_t Align)
Definition: BinaryStreamWriter.cpp:95
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::BinaryStreamWriter::split
std::pair< BinaryStreamWriter, BinaryStreamWriter > split(uint64_t Off) const
Splits the Writer into two Writers at a given offset.
Definition: BinaryStreamWriter.cpp:83
llvm::WritableBinaryStreamRef::writeBytes
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...
Definition: BinaryStreamRef.cpp:116
llvm::BinaryStreamWriter::getLength
uint64_t getLength() const
Definition: BinaryStreamWriter.h:185
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::stream_error_code::stream_too_short
@ stream_too_short
llvm::encodeULEB128
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
llvm::support::endianness
endianness
Definition: Endian.h:27
BinaryStreamWriter.h
llvm::BinaryStreamWriter::BinaryStreamWriter
BinaryStreamWriter()=default
llvm::WritableBinaryStream
A BinaryStream which can be read from as well as written to.
Definition: BinaryStream.h:73
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::WritableBinaryStreamRef
Definition: BinaryStreamRef.h:221
llvm::BinaryStreamRefBase::drop_front
RefType drop_front(uint64_t N) const
Return a new BinaryStreamRef with the first N elements removed.
Definition: BinaryStreamRef.h:61
llvm::BinaryStreamRef
BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.
Definition: BinaryStreamRef.h:156