2011-09-14 03:42:16 +08:00
|
|
|
//===-- DataExtractor.cpp -------------------------------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2011-09-14 03:42:16 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Support/DataExtractor.h"
|
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/Host.h"
|
|
|
|
#include "llvm/Support/SwapByteOrder.h"
|
2019-06-25 04:43:36 +08:00
|
|
|
#include "llvm/Support/LEB128.h"
|
2011-09-14 03:42:16 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
template <typename T>
|
2019-08-06 18:47:20 +08:00
|
|
|
static T getU(uint64_t *offset_ptr, const DataExtractor *de,
|
2011-09-14 03:42:16 +08:00
|
|
|
bool isLittleEndian, const char *Data) {
|
|
|
|
T val = 0;
|
2019-08-06 18:47:20 +08:00
|
|
|
uint64_t offset = *offset_ptr;
|
2011-09-14 03:42:16 +08:00
|
|
|
if (de->isValidOffsetForDataOfSize(offset, sizeof(val))) {
|
|
|
|
std::memcpy(&val, &Data[offset], sizeof(val));
|
2013-04-15 22:44:24 +08:00
|
|
|
if (sys::IsLittleEndianHost != isLittleEndian)
|
2014-06-14 21:18:07 +08:00
|
|
|
sys::swapByteOrder(val);
|
2011-09-14 03:42:16 +08:00
|
|
|
|
|
|
|
// Advance the offset
|
|
|
|
*offset_ptr += sizeof(val);
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
2019-08-06 18:47:20 +08:00
|
|
|
static T *getUs(uint64_t *offset_ptr, T *dst, uint32_t count,
|
2011-09-14 03:42:16 +08:00
|
|
|
const DataExtractor *de, bool isLittleEndian, const char *Data){
|
2019-08-06 18:47:20 +08:00
|
|
|
uint64_t offset = *offset_ptr;
|
2011-09-14 03:42:16 +08:00
|
|
|
|
|
|
|
if (count > 0 && de->isValidOffsetForDataOfSize(offset, sizeof(*dst)*count)) {
|
|
|
|
for (T *value_ptr = dst, *end = dst + count; value_ptr != end;
|
|
|
|
++value_ptr, offset += sizeof(*dst))
|
|
|
|
*value_ptr = getU<T>(offset_ptr, de, isLittleEndian, Data);
|
|
|
|
// Advance the offset
|
|
|
|
*offset_ptr = offset;
|
|
|
|
// Return a non-NULL pointer to the converted data as an indicator of
|
|
|
|
// success
|
|
|
|
return dst;
|
|
|
|
}
|
2014-04-07 12:17:22 +08:00
|
|
|
return nullptr;
|
2011-09-14 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint8_t DataExtractor::getU8(uint64_t *offset_ptr) const {
|
2011-09-14 03:42:16 +08:00
|
|
|
return getU<uint8_t>(offset_ptr, this, IsLittleEndian, Data.data());
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t *
|
2019-08-06 18:47:20 +08:00
|
|
|
DataExtractor::getU8(uint64_t *offset_ptr, uint8_t *dst, uint32_t count) const {
|
2011-09-14 03:42:16 +08:00
|
|
|
return getUs<uint8_t>(offset_ptr, dst, count, this, IsLittleEndian,
|
|
|
|
Data.data());
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint16_t DataExtractor::getU16(uint64_t *offset_ptr) const {
|
2011-09-14 03:42:16 +08:00
|
|
|
return getU<uint16_t>(offset_ptr, this, IsLittleEndian, Data.data());
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint16_t *DataExtractor::getU16(uint64_t *offset_ptr, uint16_t *dst,
|
2011-09-14 03:42:16 +08:00
|
|
|
uint32_t count) const {
|
|
|
|
return getUs<uint16_t>(offset_ptr, dst, count, this, IsLittleEndian,
|
|
|
|
Data.data());
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint32_t DataExtractor::getU24(uint64_t *offset_ptr) const {
|
2017-06-22 03:37:44 +08:00
|
|
|
uint24_t ExtractedVal =
|
|
|
|
getU<uint24_t>(offset_ptr, this, IsLittleEndian, Data.data());
|
|
|
|
// The 3 bytes are in the correct byte order for the host.
|
|
|
|
return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint32_t DataExtractor::getU32(uint64_t *offset_ptr) const {
|
2011-09-14 03:42:16 +08:00
|
|
|
return getU<uint32_t>(offset_ptr, this, IsLittleEndian, Data.data());
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint32_t *DataExtractor::getU32(uint64_t *offset_ptr, uint32_t *dst,
|
2011-09-14 03:42:16 +08:00
|
|
|
uint32_t count) const {
|
|
|
|
return getUs<uint32_t>(offset_ptr, dst, count, this, IsLittleEndian,
|
2012-02-23 01:25:00 +08:00
|
|
|
Data.data());
|
2011-09-14 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint64_t DataExtractor::getU64(uint64_t *offset_ptr) const {
|
2011-09-14 03:42:16 +08:00
|
|
|
return getU<uint64_t>(offset_ptr, this, IsLittleEndian, Data.data());
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint64_t *DataExtractor::getU64(uint64_t *offset_ptr, uint64_t *dst,
|
2011-09-14 03:42:16 +08:00
|
|
|
uint32_t count) const {
|
|
|
|
return getUs<uint64_t>(offset_ptr, dst, count, this, IsLittleEndian,
|
|
|
|
Data.data());
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t
|
2019-08-06 18:47:20 +08:00
|
|
|
DataExtractor::getUnsigned(uint64_t *offset_ptr, uint32_t byte_size) const {
|
2011-09-14 03:42:16 +08:00
|
|
|
switch (byte_size) {
|
|
|
|
case 1:
|
|
|
|
return getU8(offset_ptr);
|
|
|
|
case 2:
|
|
|
|
return getU16(offset_ptr);
|
|
|
|
case 4:
|
|
|
|
return getU32(offset_ptr);
|
|
|
|
case 8:
|
|
|
|
return getU64(offset_ptr);
|
|
|
|
}
|
|
|
|
llvm_unreachable("getUnsigned unhandled case!");
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t
|
2019-08-06 18:47:20 +08:00
|
|
|
DataExtractor::getSigned(uint64_t *offset_ptr, uint32_t byte_size) const {
|
2011-09-14 03:42:16 +08:00
|
|
|
switch (byte_size) {
|
|
|
|
case 1:
|
|
|
|
return (int8_t)getU8(offset_ptr);
|
|
|
|
case 2:
|
|
|
|
return (int16_t)getU16(offset_ptr);
|
|
|
|
case 4:
|
|
|
|
return (int32_t)getU32(offset_ptr);
|
|
|
|
case 8:
|
|
|
|
return (int64_t)getU64(offset_ptr);
|
|
|
|
}
|
|
|
|
llvm_unreachable("getSigned unhandled case!");
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
const char *DataExtractor::getCStr(uint64_t *offset_ptr) const {
|
|
|
|
uint64_t offset = *offset_ptr;
|
2011-09-14 03:42:16 +08:00
|
|
|
StringRef::size_type pos = Data.find('\0', offset);
|
|
|
|
if (pos != StringRef::npos) {
|
|
|
|
*offset_ptr = pos + 1;
|
|
|
|
return Data.data() + offset;
|
|
|
|
}
|
2014-04-07 12:17:22 +08:00
|
|
|
return nullptr;
|
2011-09-14 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
StringRef DataExtractor::getCStrRef(uint64_t *offset_ptr) const {
|
|
|
|
uint64_t Start = *offset_ptr;
|
2017-05-03 01:37:32 +08:00
|
|
|
StringRef::size_type Pos = Data.find('\0', Start);
|
|
|
|
if (Pos != StringRef::npos) {
|
2019-08-06 18:47:20 +08:00
|
|
|
*offset_ptr = Pos + 1;
|
2017-05-03 01:37:32 +08:00
|
|
|
return StringRef(Data.data() + Start, Pos - Start);
|
|
|
|
}
|
|
|
|
return StringRef();
|
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
uint64_t DataExtractor::getULEB128(uint64_t *offset_ptr) const {
|
2019-06-25 04:43:36 +08:00
|
|
|
assert(*offset_ptr <= Data.size());
|
|
|
|
|
|
|
|
const char *error;
|
|
|
|
unsigned bytes_read;
|
|
|
|
uint64_t result = decodeULEB128(
|
|
|
|
reinterpret_cast<const uint8_t *>(Data.data() + *offset_ptr), &bytes_read,
|
|
|
|
reinterpret_cast<const uint8_t *>(Data.data() + Data.size()), &error);
|
|
|
|
if (error)
|
2011-09-14 03:42:16 +08:00
|
|
|
return 0;
|
2019-06-25 04:43:36 +08:00
|
|
|
*offset_ptr += bytes_read;
|
|
|
|
return result;
|
2011-09-14 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2019-08-06 18:47:20 +08:00
|
|
|
int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr) const {
|
2019-06-25 07:45:18 +08:00
|
|
|
assert(*offset_ptr <= Data.size());
|
2011-09-14 03:42:16 +08:00
|
|
|
|
2019-06-25 07:45:18 +08:00
|
|
|
const char *error;
|
|
|
|
unsigned bytes_read;
|
|
|
|
int64_t result = decodeSLEB128(
|
|
|
|
reinterpret_cast<const uint8_t *>(Data.data() + *offset_ptr), &bytes_read,
|
|
|
|
reinterpret_cast<const uint8_t *>(Data.data() + Data.size()), &error);
|
|
|
|
if (error)
|
|
|
|
return 0;
|
|
|
|
*offset_ptr += bytes_read;
|
|
|
|
return result;
|
2011-09-14 03:42:16 +08:00
|
|
|
}
|