Differential D109923 Diff 373100 llvm/lib/Support/BinaryStreamReader.cpp

Changeset View

Standalone View

llvm/lib/Support/BinaryStreamReader.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines	do {
EncodedBytes.push_back(NextByte[0]);		EncodedBytes.push_back(NextByte[0]);
} while (NextByte[0] & 0x80);		} while (NextByte[0] & 0x80);

Dest = decodeSLEB128(EncodedBytes.begin(), nullptr, EncodedBytes.end());		Dest = decodeSLEB128(EncodedBytes.begin(), nullptr, EncodedBytes.end());
return Error::success();		return Error::success();
}		}

Error BinaryStreamReader::readCString(StringRef &Dest) {		Error BinaryStreamReader::readCString(StringRef &Dest) {
uint32_t OriginalOffset = getOffset();		uint64_t OriginalOffset = getOffset();
uint32_t FoundOffset = 0;		uint64_t FoundOffset = 0;
while (true) {		while (true) {
uint32_t ThisOffset = getOffset();		uint64_t ThisOffset = getOffset();
ArrayRef<uint8_t> Buffer;		ArrayRef<uint8_t> Buffer;
if (auto EC = readLongestContiguousChunk(Buffer))		if (auto EC = readLongestContiguousChunk(Buffer))
return EC;		return EC;
StringRef S(reinterpret_cast<const char *>(Buffer.begin()), Buffer.size());		StringRef S(reinterpret_cast<const char *>(Buffer.begin()), Buffer.size());
size_t Pos = S.find_first_of('\0');		size_t Pos = S.find_first_of('\0');
if (LLVM_LIKELY(Pos != StringRef::npos)) {		if (LLVM_LIKELY(Pos != StringRef::npos)) {
FoundOffset = Pos + ThisOffset;		FoundOffset = Pos + ThisOffset;
break;		break;
}		}
}		}
assert(FoundOffset >= OriginalOffset);		assert(FoundOffset >= OriginalOffset);

setOffset(OriginalOffset);		setOffset(OriginalOffset);
size_t Length = FoundOffset - OriginalOffset;		size_t Length = FoundOffset - OriginalOffset;

if (auto EC = readFixedString(Dest, Length))		if (auto EC = readFixedString(Dest, Length))
return EC;		return EC;

// Now set the offset back to after the null terminator.		// Now set the offset back to after the null terminator.
setOffset(FoundOffset + 1);		setOffset(FoundOffset + 1);
return Error::success();		return Error::success();
}		}

Error BinaryStreamReader::readWideString(ArrayRef<UTF16> &Dest) {		Error BinaryStreamReader::readWideString(ArrayRef<UTF16> &Dest) {
uint32_t Length = 0;		uint64_t Length = 0;
uint32_t OriginalOffset = getOffset();		uint64_t OriginalOffset = getOffset();
const UTF16 *C;		const UTF16 *C;
while (true) {		while (true) {
if (auto EC = readObject(C))		if (auto EC = readObject(C))
return EC;		return EC;
if (*C == 0x0000)		if (*C == 0x0000)
break;		break;
++Length;		++Length;
}		}
uint32_t NewOffset = getOffset();		uint64_t NewOffset = getOffset();
setOffset(OriginalOffset);		setOffset(OriginalOffset);

if (auto EC = readArray(Dest, Length))		if (auto EC = readArray(Dest, Length))
return EC;		return EC;
setOffset(NewOffset);		setOffset(NewOffset);
return Error::success();		return Error::success();
}		}

Show All 18 Lines
}		}

Error BinaryStreamReader::readSubstream(BinarySubstreamRef &Ref,		Error BinaryStreamReader::readSubstream(BinarySubstreamRef &Ref,
uint32_t Length) {		uint32_t Length) {
Ref.Offset = getOffset();		Ref.Offset = getOffset();
return readStreamRef(Ref.StreamData, Length);		return readStreamRef(Ref.StreamData, Length);
}		}

Error BinaryStreamReader::skip(uint32_t Amount) {		Error BinaryStreamReader::skip(uint64_t Amount) {
if (Amount > bytesRemaining())		if (Amount > bytesRemaining())
return make_error<BinaryStreamError>(stream_error_code::stream_too_short);		return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
Offset += Amount;		Offset += Amount;
return Error::success();		return Error::success();
}		}

Error BinaryStreamReader::padToAlignment(uint32_t Align) {		Error BinaryStreamReader::padToAlignment(uint32_t Align) {
uint32_t NewOffset = alignTo(Offset, Align);		uint32_t NewOffset = alignTo(Offset, Align);
return skip(NewOffset - Offset);		return skip(NewOffset - Offset);
}		}

uint8_t BinaryStreamReader::peek() const {		uint8_t BinaryStreamReader::peek() const {
ArrayRef<uint8_t> Buffer;		ArrayRef<uint8_t> Buffer;
auto EC = Stream.readBytes(Offset, 1, Buffer);		auto EC = Stream.readBytes(Offset, 1, Buffer);
assert(!EC && "Cannot peek an empty buffer!");		assert(!EC && "Cannot peek an empty buffer!");
llvm::consumeError(std::move(EC));		llvm::consumeError(std::move(EC));
return Buffer[0];		return Buffer[0];
}		}

std::pair<BinaryStreamReader, BinaryStreamReader>		std::pair<BinaryStreamReader, BinaryStreamReader>
BinaryStreamReader::split(uint32_t Off) const {		BinaryStreamReader::split(uint64_t Off) const {
assert(getLength() >= Off);		assert(getLength() >= Off);

BinaryStreamRef First = Stream.drop_front(Offset);		BinaryStreamRef First = Stream.drop_front(Offset);

BinaryStreamRef Second = First.drop_front(Off);		BinaryStreamRef Second = First.drop_front(Off);
First = First.keep_front(Off);		First = First.keep_front(Off);
BinaryStreamReader W1{First};		BinaryStreamReader W1{First};
BinaryStreamReader W2{Second};		BinaryStreamReader W2{Second};
return std::make_pair(W1, W2);		return std::make_pair(W1, W2);
}		}