lib/Support/BinaryStreamReader.cpp

   1 //===- BinaryStreamReader.cpp - Reads objects from a binary stream --------===//
   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/BinaryStreamReader.h"
  10
  11 #include "llvm/Support/BinaryStreamError.h"
  12 #include "llvm/Support/BinaryStreamRef.h"
  13 #include "llvm/Support/LEB128.h"
  14
  15 using namespace llvm;
  16 using endianness = llvm::support::endianness;
  17
  18 BinaryStreamReader::BinaryStreamReader(BinaryStreamRef Ref) : Stream(Ref) {}
  19
  20 BinaryStreamReader::BinaryStreamReader(BinaryStream &Stream) : Stream(Stream) {}
  21
  22 BinaryStreamReader::BinaryStreamReader(ArrayRef<uint8_t> Data,
  23                                        endianness Endian)
  24     : Stream(Data, Endian) {}
  25
  26 BinaryStreamReader::BinaryStreamReader(StringRef Data, endianness Endian)
  27     : Stream(Data, Endian) {}
  28
  29 Error BinaryStreamReader::readLongestContiguousChunk(
  30     ArrayRef<uint8_t> &Buffer) {
  31   if (auto EC = Stream.readLongestContiguousChunk(Offset, Buffer))
  32     return EC;
  33   Offset += Buffer.size();
  34   return Error::success();
  35 }
  36
  37 Error BinaryStreamReader::readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size) {
  38   if (auto EC = Stream.readBytes(Offset, Size, Buffer))
  39     return EC;
  40   Offset += Size;
  41   return Error::success();
  42 }
  43
  44 Error BinaryStreamReader::readULEB128(uint64_t &Dest) {
  45   SmallVector<uint8_t, 10> EncodedBytes;
  46   ArrayRef<uint8_t> NextByte;
  47
  48   // Copy the encoded ULEB into the buffer.
  49   do {
  50     if (auto Err = readBytes(NextByte, 1))
  51       return Err;
  52     EncodedBytes.push_back(NextByte[0]);
  53   } while (NextByte[0] & 0x80);
  54
  55   Dest = decodeULEB128(EncodedBytes.begin(), nullptr, EncodedBytes.end());
  56   return Error::success();
  57 }
  58
  59 Error BinaryStreamReader::readSLEB128(int64_t &Dest) {
  60   SmallVector<uint8_t, 10> EncodedBytes;
  61   ArrayRef<uint8_t> NextByte;
  62
  63   // Copy the encoded ULEB into the buffer.
  64   do {
  65     if (auto Err = readBytes(NextByte, 1))
  66       return Err;
  67     EncodedBytes.push_back(NextByte[0]);
  68   } while (NextByte[0] & 0x80);
  69
  70   Dest = decodeSLEB128(EncodedBytes.begin(), nullptr, EncodedBytes.end());
  71   return Error::success();
  72 }
  73
  74 Error BinaryStreamReader::readCString(StringRef &Dest) {
  75   uint32_t OriginalOffset = getOffset();
  76   uint32_t FoundOffset = 0;
  77   while (true) {
  78     uint32_t ThisOffset = getOffset();
  79     ArrayRef<uint8_t> Buffer;
  80     if (auto EC = readLongestContiguousChunk(Buffer))
  81       return EC;
  82     StringRef S(reinterpret_cast<const char *>(Buffer.begin()), Buffer.size());
  83     size_t Pos = S.find_first_of('\0');
  84     if (LLVM_LIKELY(Pos != StringRef::npos)) {
  85       FoundOffset = Pos + ThisOffset;
  86       break;
  87     }
  88   }
  89   assert(FoundOffset >= OriginalOffset);
  90
  91   setOffset(OriginalOffset);
  92   size_t Length = FoundOffset - OriginalOffset;
  93
  94   if (auto EC = readFixedString(Dest, Length))
  95     return EC;
  96
  97   // Now set the offset back to after the null terminator.
  98   setOffset(FoundOffset + 1);
  99   return Error::success();
 100 }
 101
 102 Error BinaryStreamReader::readWideString(ArrayRef<UTF16> &Dest) {
 103   uint32_t Length = 0;
 104   uint32_t OriginalOffset = getOffset();
 105   const UTF16 *C;
 106   while (true) {
 107     if (auto EC = readObject(C))
 108       return EC;
 109     if (*C == 0x0000)
 110       break;
 111     ++Length;
 112   }
 113   uint32_t NewOffset = getOffset();
 114   setOffset(OriginalOffset);
 115
 116   if (auto EC = readArray(Dest, Length))
 117     return EC;
 118   setOffset(NewOffset);
 119   return Error::success();
 120 }
 121
 122 Error BinaryStreamReader::readFixedString(StringRef &Dest, uint32_t Length) {
 123   ArrayRef<uint8_t> Bytes;
 124   if (auto EC = readBytes(Bytes, Length))
 125     return EC;
 126   Dest = StringRef(reinterpret_cast<const char *>(Bytes.begin()), Bytes.size());
 127   return Error::success();
 128 }
 129
 130 Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref) {
 131   return readStreamRef(Ref, bytesRemaining());
 132 }
 133
 134 Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref, uint32_t Length) {
 135   if (bytesRemaining() < Length)
 136     return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
 137   Ref = Stream.slice(Offset, Length);
 138   Offset += Length;
 139   return Error::success();
 140 }
 141
 142 Error BinaryStreamReader::readSubstream(BinarySubstreamRef &Stream,
 143                                         uint32_t Size) {
 144   Stream.Offset = getOffset();
 145   return readStreamRef(Stream.StreamData, Size);
 146 }
 147
 148 Error BinaryStreamReader::skip(uint32_t Amount) {
 149   if (Amount > bytesRemaining())
 150     return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
 151   Offset += Amount;
 152   return Error::success();
 153 }
 154
 155 Error BinaryStreamReader::padToAlignment(uint32_t Align) {
 156   uint32_t NewOffset = alignTo(Offset, Align);
 157   return skip(NewOffset - Offset);
 158 }
 159
 160 uint8_t BinaryStreamReader::peek() const {
 161   ArrayRef<uint8_t> Buffer;
 162   auto EC = Stream.readBytes(Offset, 1, Buffer);
 163   assert(!EC && "Cannot peek an empty buffer!");
 164   llvm::consumeError(std::move(EC));
 165   return Buffer[0];
 166 }
 167
 168 std::pair<BinaryStreamReader, BinaryStreamReader>
 169 BinaryStreamReader::split(uint32_t Off) const {
 170   assert(getLength() >= Off);
 171
 172   BinaryStreamRef First = Stream.drop_front(Offset);
 173
 174   BinaryStreamRef Second = First.drop_front(Off);
 175   First = First.keep_front(Off);
 176   BinaryStreamReader W1{First};
 177   BinaryStreamReader W2{Second};
 178   return std::make_pair(W1, W2);
 179 }