DataExtractor.cpp revision 360784
1//===-- DataExtractor.cpp ---------------------------------------*- C++ -*-===// 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 "lldb/Utility/DataExtractor.h" 10 11#include "lldb/lldb-defines.h" 12#include "lldb/lldb-enumerations.h" 13#include "lldb/lldb-forward.h" 14#include "lldb/lldb-types.h" 15 16#include "lldb/Utility/DataBuffer.h" 17#include "lldb/Utility/DataBufferHeap.h" 18#include "lldb/Utility/Endian.h" 19#include "lldb/Utility/LLDBAssert.h" 20#include "lldb/Utility/Log.h" 21#include "lldb/Utility/Stream.h" 22#include "lldb/Utility/StreamString.h" 23#include "lldb/Utility/UUID.h" 24 25#include "llvm/ADT/ArrayRef.h" 26#include "llvm/ADT/SmallVector.h" 27#include "llvm/Support/MD5.h" 28#include "llvm/Support/MathExtras.h" 29 30#include <algorithm> 31#include <array> 32#include <cassert> 33#include <cstdint> 34#include <string> 35 36#include <ctype.h> 37#include <inttypes.h> 38#include <string.h> 39 40using namespace lldb; 41using namespace lldb_private; 42 43static inline uint16_t ReadInt16(const unsigned char *ptr, offset_t offset) { 44 uint16_t value; 45 memcpy(&value, ptr + offset, 2); 46 return value; 47} 48 49static inline uint32_t ReadInt32(const unsigned char *ptr, 50 offset_t offset = 0) { 51 uint32_t value; 52 memcpy(&value, ptr + offset, 4); 53 return value; 54} 55 56static inline uint64_t ReadInt64(const unsigned char *ptr, 57 offset_t offset = 0) { 58 uint64_t value; 59 memcpy(&value, ptr + offset, 8); 60 return value; 61} 62 63static inline uint16_t ReadInt16(const void *ptr) { 64 uint16_t value; 65 memcpy(&value, ptr, 2); 66 return value; 67} 68 69static inline uint16_t ReadSwapInt16(const unsigned char *ptr, 70 offset_t offset) { 71 uint16_t value; 72 memcpy(&value, ptr + offset, 2); 73 return llvm::ByteSwap_16(value); 74} 75 76static inline uint32_t ReadSwapInt32(const unsigned char *ptr, 77 offset_t offset) { 78 uint32_t value; 79 memcpy(&value, ptr + offset, 4); 80 return llvm::ByteSwap_32(value); 81} 82 83static inline uint64_t ReadSwapInt64(const unsigned char *ptr, 84 offset_t offset) { 85 uint64_t value; 86 memcpy(&value, ptr + offset, 8); 87 return llvm::ByteSwap_64(value); 88} 89 90static inline uint16_t ReadSwapInt16(const void *ptr) { 91 uint16_t value; 92 memcpy(&value, ptr, 2); 93 return llvm::ByteSwap_16(value); 94} 95 96static inline uint32_t ReadSwapInt32(const void *ptr) { 97 uint32_t value; 98 memcpy(&value, ptr, 4); 99 return llvm::ByteSwap_32(value); 100} 101 102static inline uint64_t ReadSwapInt64(const void *ptr) { 103 uint64_t value; 104 memcpy(&value, ptr, 8); 105 return llvm::ByteSwap_64(value); 106} 107 108static inline uint64_t ReadMaxInt64(const uint8_t *data, size_t byte_size, 109 ByteOrder byte_order) { 110 uint64_t res = 0; 111 if (byte_order == eByteOrderBig) 112 for (size_t i = 0; i < byte_size; ++i) 113 res = (res << 8) | data[i]; 114 else { 115 assert(byte_order == eByteOrderLittle); 116 for (size_t i = 0; i < byte_size; ++i) 117 res = (res << 8) | data[byte_size - 1 - i]; 118 } 119 return res; 120} 121 122DataExtractor::DataExtractor() 123 : m_start(nullptr), m_end(nullptr), 124 m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)), 125 m_data_sp(), m_target_byte_size(1) {} 126 127// This constructor allows us to use data that is owned by someone else. The 128// data must stay around as long as this object is valid. 129DataExtractor::DataExtractor(const void *data, offset_t length, 130 ByteOrder endian, uint32_t addr_size, 131 uint32_t target_byte_size /*=1*/) 132 : m_start(const_cast<uint8_t *>(static_cast<const uint8_t *>(data))), 133 m_end(const_cast<uint8_t *>(static_cast<const uint8_t *>(data)) + length), 134 m_byte_order(endian), m_addr_size(addr_size), m_data_sp(), 135 m_target_byte_size(target_byte_size) { 136 assert(addr_size == 4 || addr_size == 8); 137} 138 139// Make a shared pointer reference to the shared data in "data_sp" and set the 140// endian swapping setting to "swap", and the address size to "addr_size". The 141// shared data reference will ensure the data lives as long as any 142// DataExtractor objects exist that have a reference to this data. 143DataExtractor::DataExtractor(const DataBufferSP &data_sp, ByteOrder endian, 144 uint32_t addr_size, 145 uint32_t target_byte_size /*=1*/) 146 : m_start(nullptr), m_end(nullptr), m_byte_order(endian), 147 m_addr_size(addr_size), m_data_sp(), 148 m_target_byte_size(target_byte_size) { 149 assert(addr_size == 4 || addr_size == 8); 150 SetData(data_sp); 151} 152 153// Initialize this object with a subset of the data bytes in "data". If "data" 154// contains shared data, then a reference to this shared data will added and 155// the shared data will stay around as long as any object contains a reference 156// to that data. The endian swap and address size settings are copied from 157// "data". 158DataExtractor::DataExtractor(const DataExtractor &data, offset_t offset, 159 offset_t length, uint32_t target_byte_size /*=1*/) 160 : m_start(nullptr), m_end(nullptr), m_byte_order(data.m_byte_order), 161 m_addr_size(data.m_addr_size), m_data_sp(), 162 m_target_byte_size(target_byte_size) { 163 assert(m_addr_size == 4 || m_addr_size == 8); 164 if (data.ValidOffset(offset)) { 165 offset_t bytes_available = data.GetByteSize() - offset; 166 if (length > bytes_available) 167 length = bytes_available; 168 SetData(data, offset, length); 169 } 170} 171 172DataExtractor::DataExtractor(const DataExtractor &rhs) 173 : m_start(rhs.m_start), m_end(rhs.m_end), m_byte_order(rhs.m_byte_order), 174 m_addr_size(rhs.m_addr_size), m_data_sp(rhs.m_data_sp), 175 m_target_byte_size(rhs.m_target_byte_size) { 176 assert(m_addr_size == 4 || m_addr_size == 8); 177} 178 179// Assignment operator 180const DataExtractor &DataExtractor::operator=(const DataExtractor &rhs) { 181 if (this != &rhs) { 182 m_start = rhs.m_start; 183 m_end = rhs.m_end; 184 m_byte_order = rhs.m_byte_order; 185 m_addr_size = rhs.m_addr_size; 186 m_data_sp = rhs.m_data_sp; 187 } 188 return *this; 189} 190 191DataExtractor::~DataExtractor() = default; 192 193// Clears the object contents back to a default invalid state, and release any 194// references to shared data that this object may contain. 195void DataExtractor::Clear() { 196 m_start = nullptr; 197 m_end = nullptr; 198 m_byte_order = endian::InlHostByteOrder(); 199 m_addr_size = sizeof(void *); 200 m_data_sp.reset(); 201} 202 203// If this object contains shared data, this function returns the offset into 204// that shared data. Else zero is returned. 205size_t DataExtractor::GetSharedDataOffset() const { 206 if (m_start != nullptr) { 207 const DataBuffer *data = m_data_sp.get(); 208 if (data != nullptr) { 209 const uint8_t *data_bytes = data->GetBytes(); 210 if (data_bytes != nullptr) { 211 assert(m_start >= data_bytes); 212 return m_start - data_bytes; 213 } 214 } 215 } 216 return 0; 217} 218 219// Set the data with which this object will extract from to data starting at 220// BYTES and set the length of the data to LENGTH bytes long. The data is 221// externally owned must be around at least as long as this object points to 222// the data. No copy of the data is made, this object just refers to this data 223// and can extract from it. If this object refers to any shared data upon 224// entry, the reference to that data will be released. Is SWAP is set to true, 225// any data extracted will be endian swapped. 226lldb::offset_t DataExtractor::SetData(const void *bytes, offset_t length, 227 ByteOrder endian) { 228 m_byte_order = endian; 229 m_data_sp.reset(); 230 if (bytes == nullptr || length == 0) { 231 m_start = nullptr; 232 m_end = nullptr; 233 } else { 234 m_start = const_cast<uint8_t *>(static_cast<const uint8_t *>(bytes)); 235 m_end = m_start + length; 236 } 237 return GetByteSize(); 238} 239 240// Assign the data for this object to be a subrange in "data" starting 241// "data_offset" bytes into "data" and ending "data_length" bytes later. If 242// "data_offset" is not a valid offset into "data", then this object will 243// contain no bytes. If "data_offset" is within "data" yet "data_length" is too 244// large, the length will be capped at the number of bytes remaining in "data". 245// If "data" contains a shared pointer to other data, then a ref counted 246// pointer to that data will be made in this object. If "data" doesn't contain 247// a shared pointer to data, then the bytes referred to in "data" will need to 248// exist at least as long as this object refers to those bytes. The address 249// size and endian swap settings are copied from the current values in "data". 250lldb::offset_t DataExtractor::SetData(const DataExtractor &data, 251 offset_t data_offset, 252 offset_t data_length) { 253 m_addr_size = data.m_addr_size; 254 assert(m_addr_size == 4 || m_addr_size == 8); 255 // If "data" contains shared pointer to data, then we can use that 256 if (data.m_data_sp) { 257 m_byte_order = data.m_byte_order; 258 return SetData(data.m_data_sp, data.GetSharedDataOffset() + data_offset, 259 data_length); 260 } 261 262 // We have a DataExtractor object that just has a pointer to bytes 263 if (data.ValidOffset(data_offset)) { 264 if (data_length > data.GetByteSize() - data_offset) 265 data_length = data.GetByteSize() - data_offset; 266 return SetData(data.GetDataStart() + data_offset, data_length, 267 data.GetByteOrder()); 268 } 269 return 0; 270} 271 272// Assign the data for this object to be a subrange of the shared data in 273// "data_sp" starting "data_offset" bytes into "data_sp" and ending 274// "data_length" bytes later. If "data_offset" is not a valid offset into 275// "data_sp", then this object will contain no bytes. If "data_offset" is 276// within "data_sp" yet "data_length" is too large, the length will be capped 277// at the number of bytes remaining in "data_sp". A ref counted pointer to the 278// data in "data_sp" will be made in this object IF the number of bytes this 279// object refers to in greater than zero (if at least one byte was available 280// starting at "data_offset") to ensure the data stays around as long as it is 281// needed. The address size and endian swap settings will remain unchanged from 282// their current settings. 283lldb::offset_t DataExtractor::SetData(const DataBufferSP &data_sp, 284 offset_t data_offset, 285 offset_t data_length) { 286 m_start = m_end = nullptr; 287 288 if (data_length > 0) { 289 m_data_sp = data_sp; 290 if (data_sp) { 291 const size_t data_size = data_sp->GetByteSize(); 292 if (data_offset < data_size) { 293 m_start = data_sp->GetBytes() + data_offset; 294 const size_t bytes_left = data_size - data_offset; 295 // Cap the length of we asked for too many 296 if (data_length <= bytes_left) 297 m_end = m_start + data_length; // We got all the bytes we wanted 298 else 299 m_end = m_start + bytes_left; // Not all the bytes requested were 300 // available in the shared data 301 } 302 } 303 } 304 305 size_t new_size = GetByteSize(); 306 307 // Don't hold a shared pointer to the data buffer if we don't share any valid 308 // bytes in the shared buffer. 309 if (new_size == 0) 310 m_data_sp.reset(); 311 312 return new_size; 313} 314 315// Extract a single unsigned char from the binary data and update the offset 316// pointed to by "offset_ptr". 317// 318// RETURNS the byte that was extracted, or zero on failure. 319uint8_t DataExtractor::GetU8(offset_t *offset_ptr) const { 320 const uint8_t *data = static_cast<const uint8_t *>(GetData(offset_ptr, 1)); 321 if (data) 322 return *data; 323 return 0; 324} 325 326// Extract "count" unsigned chars from the binary data and update the offset 327// pointed to by "offset_ptr". The extracted data is copied into "dst". 328// 329// RETURNS the non-nullptr buffer pointer upon successful extraction of 330// all the requested bytes, or nullptr when the data is not available in the 331// buffer due to being out of bounds, or insufficient data. 332void *DataExtractor::GetU8(offset_t *offset_ptr, void *dst, 333 uint32_t count) const { 334 const uint8_t *data = 335 static_cast<const uint8_t *>(GetData(offset_ptr, count)); 336 if (data) { 337 // Copy the data into the buffer 338 memcpy(dst, data, count); 339 // Return a non-nullptr pointer to the converted data as an indicator of 340 // success 341 return dst; 342 } 343 return nullptr; 344} 345 346// Extract a single uint16_t from the data and update the offset pointed to by 347// "offset_ptr". 348// 349// RETURNS the uint16_t that was extracted, or zero on failure. 350uint16_t DataExtractor::GetU16(offset_t *offset_ptr) const { 351 uint16_t val = 0; 352 const uint8_t *data = 353 static_cast<const uint8_t *>(GetData(offset_ptr, sizeof(val))); 354 if (data) { 355 if (m_byte_order != endian::InlHostByteOrder()) 356 val = ReadSwapInt16(data); 357 else 358 val = ReadInt16(data); 359 } 360 return val; 361} 362 363uint16_t DataExtractor::GetU16_unchecked(offset_t *offset_ptr) const { 364 uint16_t val; 365 if (m_byte_order == endian::InlHostByteOrder()) 366 val = ReadInt16(m_start, *offset_ptr); 367 else 368 val = ReadSwapInt16(m_start, *offset_ptr); 369 *offset_ptr += sizeof(val); 370 return val; 371} 372 373uint32_t DataExtractor::GetU32_unchecked(offset_t *offset_ptr) const { 374 uint32_t val; 375 if (m_byte_order == endian::InlHostByteOrder()) 376 val = ReadInt32(m_start, *offset_ptr); 377 else 378 val = ReadSwapInt32(m_start, *offset_ptr); 379 *offset_ptr += sizeof(val); 380 return val; 381} 382 383uint64_t DataExtractor::GetU64_unchecked(offset_t *offset_ptr) const { 384 uint64_t val; 385 if (m_byte_order == endian::InlHostByteOrder()) 386 val = ReadInt64(m_start, *offset_ptr); 387 else 388 val = ReadSwapInt64(m_start, *offset_ptr); 389 *offset_ptr += sizeof(val); 390 return val; 391} 392 393// Extract "count" uint16_t values from the binary data and update the offset 394// pointed to by "offset_ptr". The extracted data is copied into "dst". 395// 396// RETURNS the non-nullptr buffer pointer upon successful extraction of 397// all the requested bytes, or nullptr when the data is not available in the 398// buffer due to being out of bounds, or insufficient data. 399void *DataExtractor::GetU16(offset_t *offset_ptr, void *void_dst, 400 uint32_t count) const { 401 const size_t src_size = sizeof(uint16_t) * count; 402 const uint16_t *src = 403 static_cast<const uint16_t *>(GetData(offset_ptr, src_size)); 404 if (src) { 405 if (m_byte_order != endian::InlHostByteOrder()) { 406 uint16_t *dst_pos = static_cast<uint16_t *>(void_dst); 407 uint16_t *dst_end = dst_pos + count; 408 const uint16_t *src_pos = src; 409 while (dst_pos < dst_end) { 410 *dst_pos = ReadSwapInt16(src_pos); 411 ++dst_pos; 412 ++src_pos; 413 } 414 } else { 415 memcpy(void_dst, src, src_size); 416 } 417 // Return a non-nullptr pointer to the converted data as an indicator of 418 // success 419 return void_dst; 420 } 421 return nullptr; 422} 423 424// Extract a single uint32_t from the data and update the offset pointed to by 425// "offset_ptr". 426// 427// RETURNS the uint32_t that was extracted, or zero on failure. 428uint32_t DataExtractor::GetU32(offset_t *offset_ptr) const { 429 uint32_t val = 0; 430 const uint8_t *data = 431 static_cast<const uint8_t *>(GetData(offset_ptr, sizeof(val))); 432 if (data) { 433 if (m_byte_order != endian::InlHostByteOrder()) { 434 val = ReadSwapInt32(data); 435 } else { 436 memcpy(&val, data, 4); 437 } 438 } 439 return val; 440} 441 442// Extract "count" uint32_t values from the binary data and update the offset 443// pointed to by "offset_ptr". The extracted data is copied into "dst". 444// 445// RETURNS the non-nullptr buffer pointer upon successful extraction of 446// all the requested bytes, or nullptr when the data is not available in the 447// buffer due to being out of bounds, or insufficient data. 448void *DataExtractor::GetU32(offset_t *offset_ptr, void *void_dst, 449 uint32_t count) const { 450 const size_t src_size = sizeof(uint32_t) * count; 451 const uint32_t *src = 452 static_cast<const uint32_t *>(GetData(offset_ptr, src_size)); 453 if (src) { 454 if (m_byte_order != endian::InlHostByteOrder()) { 455 uint32_t *dst_pos = static_cast<uint32_t *>(void_dst); 456 uint32_t *dst_end = dst_pos + count; 457 const uint32_t *src_pos = src; 458 while (dst_pos < dst_end) { 459 *dst_pos = ReadSwapInt32(src_pos); 460 ++dst_pos; 461 ++src_pos; 462 } 463 } else { 464 memcpy(void_dst, src, src_size); 465 } 466 // Return a non-nullptr pointer to the converted data as an indicator of 467 // success 468 return void_dst; 469 } 470 return nullptr; 471} 472 473// Extract a single uint64_t from the data and update the offset pointed to by 474// "offset_ptr". 475// 476// RETURNS the uint64_t that was extracted, or zero on failure. 477uint64_t DataExtractor::GetU64(offset_t *offset_ptr) const { 478 uint64_t val = 0; 479 const uint8_t *data = 480 static_cast<const uint8_t *>(GetData(offset_ptr, sizeof(val))); 481 if (data) { 482 if (m_byte_order != endian::InlHostByteOrder()) { 483 val = ReadSwapInt64(data); 484 } else { 485 memcpy(&val, data, 8); 486 } 487 } 488 return val; 489} 490 491// GetU64 492// 493// Get multiple consecutive 64 bit values. Return true if the entire read 494// succeeds and increment the offset pointed to by offset_ptr, else return 495// false and leave the offset pointed to by offset_ptr unchanged. 496void *DataExtractor::GetU64(offset_t *offset_ptr, void *void_dst, 497 uint32_t count) const { 498 const size_t src_size = sizeof(uint64_t) * count; 499 const uint64_t *src = 500 static_cast<const uint64_t *>(GetData(offset_ptr, src_size)); 501 if (src) { 502 if (m_byte_order != endian::InlHostByteOrder()) { 503 uint64_t *dst_pos = static_cast<uint64_t *>(void_dst); 504 uint64_t *dst_end = dst_pos + count; 505 const uint64_t *src_pos = src; 506 while (dst_pos < dst_end) { 507 *dst_pos = ReadSwapInt64(src_pos); 508 ++dst_pos; 509 ++src_pos; 510 } 511 } else { 512 memcpy(void_dst, src, src_size); 513 } 514 // Return a non-nullptr pointer to the converted data as an indicator of 515 // success 516 return void_dst; 517 } 518 return nullptr; 519} 520 521uint32_t DataExtractor::GetMaxU32(offset_t *offset_ptr, 522 size_t byte_size) const { 523 lldbassert(byte_size > 0 && byte_size <= 4 && "GetMaxU32 invalid byte_size!"); 524 return GetMaxU64(offset_ptr, byte_size); 525} 526 527uint64_t DataExtractor::GetMaxU64(offset_t *offset_ptr, 528 size_t byte_size) const { 529 lldbassert(byte_size > 0 && byte_size <= 8 && "GetMaxU64 invalid byte_size!"); 530 switch (byte_size) { 531 case 1: 532 return GetU8(offset_ptr); 533 case 2: 534 return GetU16(offset_ptr); 535 case 4: 536 return GetU32(offset_ptr); 537 case 8: 538 return GetU64(offset_ptr); 539 default: { 540 // General case. 541 const uint8_t *data = 542 static_cast<const uint8_t *>(GetData(offset_ptr, byte_size)); 543 if (data == nullptr) 544 return 0; 545 return ReadMaxInt64(data, byte_size, m_byte_order); 546 } 547 } 548 return 0; 549} 550 551uint64_t DataExtractor::GetMaxU64_unchecked(offset_t *offset_ptr, 552 size_t byte_size) const { 553 switch (byte_size) { 554 case 1: 555 return GetU8_unchecked(offset_ptr); 556 case 2: 557 return GetU16_unchecked(offset_ptr); 558 case 4: 559 return GetU32_unchecked(offset_ptr); 560 case 8: 561 return GetU64_unchecked(offset_ptr); 562 default: { 563 uint64_t res = ReadMaxInt64(&m_start[*offset_ptr], byte_size, m_byte_order); 564 *offset_ptr += byte_size; 565 return res; 566 } 567 } 568 return 0; 569} 570 571int64_t DataExtractor::GetMaxS64(offset_t *offset_ptr, size_t byte_size) const { 572 uint64_t u64 = GetMaxU64(offset_ptr, byte_size); 573 return llvm::SignExtend64(u64, 8 * byte_size); 574} 575 576uint64_t DataExtractor::GetMaxU64Bitfield(offset_t *offset_ptr, size_t size, 577 uint32_t bitfield_bit_size, 578 uint32_t bitfield_bit_offset) const { 579 assert(bitfield_bit_size <= 64); 580 uint64_t uval64 = GetMaxU64(offset_ptr, size); 581 582 if (bitfield_bit_size == 0) 583 return uval64; 584 585 int32_t lsbcount = bitfield_bit_offset; 586 if (m_byte_order == eByteOrderBig) 587 lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size; 588 589 if (lsbcount > 0) 590 uval64 >>= lsbcount; 591 592 uint64_t bitfield_mask = 593 (bitfield_bit_size == 64 594 ? std::numeric_limits<uint64_t>::max() 595 : ((static_cast<uint64_t>(1) << bitfield_bit_size) - 1)); 596 if (!bitfield_mask && bitfield_bit_offset == 0 && bitfield_bit_size == 64) 597 return uval64; 598 599 uval64 &= bitfield_mask; 600 601 return uval64; 602} 603 604int64_t DataExtractor::GetMaxS64Bitfield(offset_t *offset_ptr, size_t size, 605 uint32_t bitfield_bit_size, 606 uint32_t bitfield_bit_offset) const { 607 int64_t sval64 = GetMaxS64(offset_ptr, size); 608 if (bitfield_bit_size > 0) { 609 int32_t lsbcount = bitfield_bit_offset; 610 if (m_byte_order == eByteOrderBig) 611 lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size; 612 if (lsbcount > 0) 613 sval64 >>= lsbcount; 614 uint64_t bitfield_mask = 615 ((static_cast<uint64_t>(1)) << bitfield_bit_size) - 1; 616 sval64 &= bitfield_mask; 617 // sign extend if needed 618 if (sval64 & ((static_cast<uint64_t>(1)) << (bitfield_bit_size - 1))) 619 sval64 |= ~bitfield_mask; 620 } 621 return sval64; 622} 623 624float DataExtractor::GetFloat(offset_t *offset_ptr) const { 625 typedef float float_type; 626 float_type val = 0.0; 627 const size_t src_size = sizeof(float_type); 628 const float_type *src = 629 static_cast<const float_type *>(GetData(offset_ptr, src_size)); 630 if (src) { 631 if (m_byte_order != endian::InlHostByteOrder()) { 632 const uint8_t *src_data = reinterpret_cast<const uint8_t *>(src); 633 uint8_t *dst_data = reinterpret_cast<uint8_t *>(&val); 634 for (size_t i = 0; i < sizeof(float_type); ++i) 635 dst_data[sizeof(float_type) - 1 - i] = src_data[i]; 636 } else { 637 val = *src; 638 } 639 } 640 return val; 641} 642 643double DataExtractor::GetDouble(offset_t *offset_ptr) const { 644 typedef double float_type; 645 float_type val = 0.0; 646 const size_t src_size = sizeof(float_type); 647 const float_type *src = 648 static_cast<const float_type *>(GetData(offset_ptr, src_size)); 649 if (src) { 650 if (m_byte_order != endian::InlHostByteOrder()) { 651 const uint8_t *src_data = reinterpret_cast<const uint8_t *>(src); 652 uint8_t *dst_data = reinterpret_cast<uint8_t *>(&val); 653 for (size_t i = 0; i < sizeof(float_type); ++i) 654 dst_data[sizeof(float_type) - 1 - i] = src_data[i]; 655 } else { 656 val = *src; 657 } 658 } 659 return val; 660} 661 662long double DataExtractor::GetLongDouble(offset_t *offset_ptr) const { 663 long double val = 0.0; 664#if defined(__i386__) || defined(__amd64__) || defined(__x86_64__) || \ 665 defined(_M_IX86) || defined(_M_IA64) || defined(_M_X64) 666 *offset_ptr += CopyByteOrderedData(*offset_ptr, 10, &val, sizeof(val), 667 endian::InlHostByteOrder()); 668#else 669 *offset_ptr += CopyByteOrderedData(*offset_ptr, sizeof(val), &val, 670 sizeof(val), endian::InlHostByteOrder()); 671#endif 672 return val; 673} 674 675// Extract a single address from the data and update the offset pointed to by 676// "offset_ptr". The size of the extracted address comes from the 677// "this->m_addr_size" member variable and should be set correctly prior to 678// extracting any address values. 679// 680// RETURNS the address that was extracted, or zero on failure. 681uint64_t DataExtractor::GetAddress(offset_t *offset_ptr) const { 682 assert(m_addr_size == 4 || m_addr_size == 8); 683 return GetMaxU64(offset_ptr, m_addr_size); 684} 685 686uint64_t DataExtractor::GetAddress_unchecked(offset_t *offset_ptr) const { 687 assert(m_addr_size == 4 || m_addr_size == 8); 688 return GetMaxU64_unchecked(offset_ptr, m_addr_size); 689} 690 691// Extract a single pointer from the data and update the offset pointed to by 692// "offset_ptr". The size of the extracted pointer comes from the 693// "this->m_addr_size" member variable and should be set correctly prior to 694// extracting any pointer values. 695// 696// RETURNS the pointer that was extracted, or zero on failure. 697uint64_t DataExtractor::GetPointer(offset_t *offset_ptr) const { 698 assert(m_addr_size == 4 || m_addr_size == 8); 699 return GetMaxU64(offset_ptr, m_addr_size); 700} 701 702size_t DataExtractor::ExtractBytes(offset_t offset, offset_t length, 703 ByteOrder dst_byte_order, void *dst) const { 704 const uint8_t *src = PeekData(offset, length); 705 if (src) { 706 if (dst_byte_order != GetByteOrder()) { 707 // Validate that only a word- or register-sized dst is byte swapped 708 assert(length == 1 || length == 2 || length == 4 || length == 8 || 709 length == 10 || length == 16 || length == 32); 710 711 for (uint32_t i = 0; i < length; ++i) 712 (static_cast<uint8_t *>(dst))[i] = src[length - i - 1]; 713 } else 714 ::memcpy(dst, src, length); 715 return length; 716 } 717 return 0; 718} 719 720// Extract data as it exists in target memory 721lldb::offset_t DataExtractor::CopyData(offset_t offset, offset_t length, 722 void *dst) const { 723 const uint8_t *src = PeekData(offset, length); 724 if (src) { 725 ::memcpy(dst, src, length); 726 return length; 727 } 728 return 0; 729} 730 731// Extract data and swap if needed when doing the copy 732lldb::offset_t 733DataExtractor::CopyByteOrderedData(offset_t src_offset, offset_t src_len, 734 void *dst_void_ptr, offset_t dst_len, 735 ByteOrder dst_byte_order) const { 736 // Validate the source info 737 if (!ValidOffsetForDataOfSize(src_offset, src_len)) 738 assert(ValidOffsetForDataOfSize(src_offset, src_len)); 739 assert(src_len > 0); 740 assert(m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle); 741 742 // Validate the destination info 743 assert(dst_void_ptr != nullptr); 744 assert(dst_len > 0); 745 assert(dst_byte_order == eByteOrderBig || dst_byte_order == eByteOrderLittle); 746 747 // Validate that only a word- or register-sized dst is byte swapped 748 assert(dst_byte_order == m_byte_order || dst_len == 1 || dst_len == 2 || 749 dst_len == 4 || dst_len == 8 || dst_len == 10 || dst_len == 16 || 750 dst_len == 32); 751 752 // Must have valid byte orders set in this object and for destination 753 if (!(dst_byte_order == eByteOrderBig || 754 dst_byte_order == eByteOrderLittle) || 755 !(m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle)) 756 return 0; 757 758 uint8_t *dst = static_cast<uint8_t *>(dst_void_ptr); 759 const uint8_t *src = PeekData(src_offset, src_len); 760 if (src) { 761 if (dst_len >= src_len) { 762 // We are copying the entire value from src into dst. Calculate how many, 763 // if any, zeroes we need for the most significant bytes if "dst_len" is 764 // greater than "src_len"... 765 const size_t num_zeroes = dst_len - src_len; 766 if (dst_byte_order == eByteOrderBig) { 767 // Big endian, so we lead with zeroes... 768 if (num_zeroes > 0) 769 ::memset(dst, 0, num_zeroes); 770 // Then either copy or swap the rest 771 if (m_byte_order == eByteOrderBig) { 772 ::memcpy(dst + num_zeroes, src, src_len); 773 } else { 774 for (uint32_t i = 0; i < src_len; ++i) 775 dst[i + num_zeroes] = src[src_len - 1 - i]; 776 } 777 } else { 778 // Little endian destination, so we lead the value bytes 779 if (m_byte_order == eByteOrderBig) { 780 for (uint32_t i = 0; i < src_len; ++i) 781 dst[i] = src[src_len - 1 - i]; 782 } else { 783 ::memcpy(dst, src, src_len); 784 } 785 // And zero the rest... 786 if (num_zeroes > 0) 787 ::memset(dst + src_len, 0, num_zeroes); 788 } 789 return src_len; 790 } else { 791 // We are only copying some of the value from src into dst.. 792 793 if (dst_byte_order == eByteOrderBig) { 794 // Big endian dst 795 if (m_byte_order == eByteOrderBig) { 796 // Big endian dst, with big endian src 797 ::memcpy(dst, src + (src_len - dst_len), dst_len); 798 } else { 799 // Big endian dst, with little endian src 800 for (uint32_t i = 0; i < dst_len; ++i) 801 dst[i] = src[dst_len - 1 - i]; 802 } 803 } else { 804 // Little endian dst 805 if (m_byte_order == eByteOrderBig) { 806 // Little endian dst, with big endian src 807 for (uint32_t i = 0; i < dst_len; ++i) 808 dst[i] = src[src_len - 1 - i]; 809 } else { 810 // Little endian dst, with big endian src 811 ::memcpy(dst, src, dst_len); 812 } 813 } 814 return dst_len; 815 } 816 } 817 return 0; 818} 819 820// Extracts a variable length NULL terminated C string from the data at the 821// offset pointed to by "offset_ptr". The "offset_ptr" will be updated with 822// the offset of the byte that follows the NULL terminator byte. 823// 824// If the offset pointed to by "offset_ptr" is out of bounds, or if "length" is 825// non-zero and there aren't enough available bytes, nullptr will be returned 826// and "offset_ptr" will not be updated. 827const char *DataExtractor::GetCStr(offset_t *offset_ptr) const { 828 const char *start = reinterpret_cast<const char *>(PeekData(*offset_ptr, 1)); 829 // Already at the end of the data. 830 if (!start) 831 return nullptr; 832 833 const char *end = reinterpret_cast<const char *>(m_end); 834 835 // Check all bytes for a null terminator that terminates a C string. 836 const char *terminator_or_end = std::find(start, end, '\0'); 837 838 // We didn't find a null terminator, so return nullptr to indicate that there 839 // is no valid C string at that offset. 840 if (terminator_or_end == end) 841 return nullptr; 842 843 // Update offset_ptr for the caller to point to the data behind the 844 // terminator (which is 1 byte long). 845 *offset_ptr += (terminator_or_end - start + 1UL); 846 return start; 847} 848 849// Extracts a NULL terminated C string from the fixed length field of length 850// "len" at the offset pointed to by "offset_ptr". The "offset_ptr" will be 851// updated with the offset of the byte that follows the fixed length field. 852// 853// If the offset pointed to by "offset_ptr" is out of bounds, or if the offset 854// plus the length of the field is out of bounds, or if the field does not 855// contain a NULL terminator byte, nullptr will be returned and "offset_ptr" 856// will not be updated. 857const char *DataExtractor::GetCStr(offset_t *offset_ptr, offset_t len) const { 858 const char *cstr = reinterpret_cast<const char *>(PeekData(*offset_ptr, len)); 859 if (cstr != nullptr) { 860 if (memchr(cstr, '\0', len) == nullptr) { 861 return nullptr; 862 } 863 *offset_ptr += len; 864 return cstr; 865 } 866 return nullptr; 867} 868 869// Peeks at a string in the contained data. No verification is done to make 870// sure the entire string lies within the bounds of this object's data, only 871// "offset" is verified to be a valid offset. 872// 873// Returns a valid C string pointer if "offset" is a valid offset in this 874// object's data, else nullptr is returned. 875const char *DataExtractor::PeekCStr(offset_t offset) const { 876 return reinterpret_cast<const char *>(PeekData(offset, 1)); 877} 878 879// Extracts an unsigned LEB128 number from this object's data starting at the 880// offset pointed to by "offset_ptr". The offset pointed to by "offset_ptr" 881// will be updated with the offset of the byte following the last extracted 882// byte. 883// 884// Returned the extracted integer value. 885uint64_t DataExtractor::GetULEB128(offset_t *offset_ptr) const { 886 const uint8_t *src = PeekData(*offset_ptr, 1); 887 if (src == nullptr) 888 return 0; 889 890 const uint8_t *end = m_end; 891 892 if (src < end) { 893 uint64_t result = *src++; 894 if (result >= 0x80) { 895 result &= 0x7f; 896 int shift = 7; 897 while (src < end) { 898 uint8_t byte = *src++; 899 result |= static_cast<uint64_t>(byte & 0x7f) << shift; 900 if ((byte & 0x80) == 0) 901 break; 902 shift += 7; 903 } 904 } 905 *offset_ptr = src - m_start; 906 return result; 907 } 908 909 return 0; 910} 911 912// Extracts an signed LEB128 number from this object's data starting at the 913// offset pointed to by "offset_ptr". The offset pointed to by "offset_ptr" 914// will be updated with the offset of the byte following the last extracted 915// byte. 916// 917// Returned the extracted integer value. 918int64_t DataExtractor::GetSLEB128(offset_t *offset_ptr) const { 919 const uint8_t *src = PeekData(*offset_ptr, 1); 920 if (src == nullptr) 921 return 0; 922 923 const uint8_t *end = m_end; 924 925 if (src < end) { 926 int64_t result = 0; 927 int shift = 0; 928 int size = sizeof(int64_t) * 8; 929 930 uint8_t byte = 0; 931 int bytecount = 0; 932 933 while (src < end) { 934 bytecount++; 935 byte = *src++; 936 result |= static_cast<int64_t>(byte & 0x7f) << shift; 937 shift += 7; 938 if ((byte & 0x80) == 0) 939 break; 940 } 941 942 // Sign bit of byte is 2nd high order bit (0x40) 943 if (shift < size && (byte & 0x40)) 944 result |= -(1 << shift); 945 946 *offset_ptr += bytecount; 947 return result; 948 } 949 return 0; 950} 951 952// Skips a ULEB128 number (signed or unsigned) from this object's data starting 953// at the offset pointed to by "offset_ptr". The offset pointed to by 954// "offset_ptr" will be updated with the offset of the byte following the last 955// extracted byte. 956// 957// Returns the number of bytes consumed during the extraction. 958uint32_t DataExtractor::Skip_LEB128(offset_t *offset_ptr) const { 959 uint32_t bytes_consumed = 0; 960 const uint8_t *src = PeekData(*offset_ptr, 1); 961 if (src == nullptr) 962 return 0; 963 964 const uint8_t *end = m_end; 965 966 if (src < end) { 967 const uint8_t *src_pos = src; 968 while ((src_pos < end) && (*src_pos++ & 0x80)) 969 ++bytes_consumed; 970 *offset_ptr += src_pos - src; 971 } 972 return bytes_consumed; 973} 974 975// Dumps bytes from this object's data to the stream "s" starting 976// "start_offset" bytes into this data, and ending with the byte before 977// "end_offset". "base_addr" will be added to the offset into the dumped data 978// when showing the offset into the data in the output information. 979// "num_per_line" objects of type "type" will be dumped with the option to 980// override the format for each object with "type_format". "type_format" is a 981// printf style formatting string. If "type_format" is nullptr, then an 982// appropriate format string will be used for the supplied "type". If the 983// stream "s" is nullptr, then the output will be send to Log(). 984lldb::offset_t DataExtractor::PutToLog(Log *log, offset_t start_offset, 985 offset_t length, uint64_t base_addr, 986 uint32_t num_per_line, 987 DataExtractor::Type type) const { 988 if (log == nullptr) 989 return start_offset; 990 991 offset_t offset; 992 offset_t end_offset; 993 uint32_t count; 994 StreamString sstr; 995 for (offset = start_offset, end_offset = offset + length, count = 0; 996 ValidOffset(offset) && offset < end_offset; ++count) { 997 if ((count % num_per_line) == 0) { 998 // Print out any previous string 999 if (sstr.GetSize() > 0) { 1000 log->PutString(sstr.GetString()); 1001 sstr.Clear(); 1002 } 1003 // Reset string offset and fill the current line string with address: 1004 if (base_addr != LLDB_INVALID_ADDRESS) 1005 sstr.Printf("0x%8.8" PRIx64 ":", 1006 static_cast<uint64_t>(base_addr + (offset - start_offset))); 1007 } 1008 1009 switch (type) { 1010 case TypeUInt8: 1011 sstr.Printf(" %2.2x", GetU8(&offset)); 1012 break; 1013 case TypeChar: { 1014 char ch = GetU8(&offset); 1015 sstr.Printf(" %c", isprint(ch) ? ch : ' '); 1016 } break; 1017 case TypeUInt16: 1018 sstr.Printf(" %4.4x", GetU16(&offset)); 1019 break; 1020 case TypeUInt32: 1021 sstr.Printf(" %8.8x", GetU32(&offset)); 1022 break; 1023 case TypeUInt64: 1024 sstr.Printf(" %16.16" PRIx64, GetU64(&offset)); 1025 break; 1026 case TypePointer: 1027 sstr.Printf(" 0x%" PRIx64, GetAddress(&offset)); 1028 break; 1029 case TypeULEB128: 1030 sstr.Printf(" 0x%" PRIx64, GetULEB128(&offset)); 1031 break; 1032 case TypeSLEB128: 1033 sstr.Printf(" %" PRId64, GetSLEB128(&offset)); 1034 break; 1035 } 1036 } 1037 1038 if (!sstr.Empty()) 1039 log->PutString(sstr.GetString()); 1040 1041 return offset; // Return the offset at which we ended up 1042} 1043 1044size_t DataExtractor::Copy(DataExtractor &dest_data) const { 1045 if (m_data_sp) { 1046 // we can pass along the SP to the data 1047 dest_data.SetData(m_data_sp); 1048 } else { 1049 const uint8_t *base_ptr = m_start; 1050 size_t data_size = GetByteSize(); 1051 dest_data.SetData(DataBufferSP(new DataBufferHeap(base_ptr, data_size))); 1052 } 1053 return GetByteSize(); 1054} 1055 1056bool DataExtractor::Append(DataExtractor &rhs) { 1057 if (rhs.GetByteOrder() != GetByteOrder()) 1058 return false; 1059 1060 if (rhs.GetByteSize() == 0) 1061 return true; 1062 1063 if (GetByteSize() == 0) 1064 return (rhs.Copy(*this) > 0); 1065 1066 size_t bytes = GetByteSize() + rhs.GetByteSize(); 1067 1068 DataBufferHeap *buffer_heap_ptr = nullptr; 1069 DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0)); 1070 1071 if (!buffer_sp || buffer_heap_ptr == nullptr) 1072 return false; 1073 1074 uint8_t *bytes_ptr = buffer_heap_ptr->GetBytes(); 1075 1076 memcpy(bytes_ptr, GetDataStart(), GetByteSize()); 1077 memcpy(bytes_ptr + GetByteSize(), rhs.GetDataStart(), rhs.GetByteSize()); 1078 1079 SetData(buffer_sp); 1080 1081 return true; 1082} 1083 1084bool DataExtractor::Append(void *buf, offset_t length) { 1085 if (buf == nullptr) 1086 return false; 1087 1088 if (length == 0) 1089 return true; 1090 1091 size_t bytes = GetByteSize() + length; 1092 1093 DataBufferHeap *buffer_heap_ptr = nullptr; 1094 DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0)); 1095 1096 if (!buffer_sp || buffer_heap_ptr == nullptr) 1097 return false; 1098 1099 uint8_t *bytes_ptr = buffer_heap_ptr->GetBytes(); 1100 1101 if (GetByteSize() > 0) 1102 memcpy(bytes_ptr, GetDataStart(), GetByteSize()); 1103 1104 memcpy(bytes_ptr + GetByteSize(), buf, length); 1105 1106 SetData(buffer_sp); 1107 1108 return true; 1109} 1110 1111void DataExtractor::Checksum(llvm::SmallVectorImpl<uint8_t> &dest, 1112 uint64_t max_data) { 1113 if (max_data == 0) 1114 max_data = GetByteSize(); 1115 else 1116 max_data = std::min(max_data, GetByteSize()); 1117 1118 llvm::MD5 md5; 1119 1120 const llvm::ArrayRef<uint8_t> data(GetDataStart(), max_data); 1121 md5.update(data); 1122 1123 llvm::MD5::MD5Result result; 1124 md5.final(result); 1125 1126 dest.clear(); 1127 dest.append(result.Bytes.begin(), result.Bytes.end()); 1128} 1129