1 //===-- SBData.cpp --------------------------------------------------------===// 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/API/SBData.h" 10 #include "SBReproducerPrivate.h" 11 #include "lldb/API/SBError.h" 12 #include "lldb/API/SBStream.h" 13 14 #include "lldb/Core/DumpDataExtractor.h" 15 #include "lldb/Utility/DataBufferHeap.h" 16 #include "lldb/Utility/DataExtractor.h" 17 #include "lldb/Utility/Stream.h" 18 19 #include <cinttypes> 20 #include <memory> 21 22 using namespace lldb; 23 using namespace lldb_private; 24 25 SBData::SBData() : m_opaque_sp(new DataExtractor()) { 26 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData); 27 } 28 29 SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {} 30 31 SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) { 32 LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs); 33 } 34 35 const SBData &SBData::operator=(const SBData &rhs) { 36 LLDB_RECORD_METHOD(const lldb::SBData &, 37 SBData, operator=,(const lldb::SBData &), rhs); 38 39 if (this != &rhs) 40 m_opaque_sp = rhs.m_opaque_sp; 41 return LLDB_RECORD_RESULT(*this); 42 } 43 44 SBData::~SBData() = default; 45 46 void SBData::SetOpaque(const lldb::DataExtractorSP &data_sp) { 47 m_opaque_sp = data_sp; 48 } 49 50 lldb_private::DataExtractor *SBData::get() const { return m_opaque_sp.get(); } 51 52 lldb_private::DataExtractor *SBData::operator->() const { 53 return m_opaque_sp.operator->(); 54 } 55 56 lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; } 57 58 const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; } 59 60 bool SBData::IsValid() { 61 LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid); 62 return this->operator bool(); 63 } 64 SBData::operator bool() const { 65 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool); 66 67 return m_opaque_sp.get() != nullptr; 68 } 69 70 uint8_t SBData::GetAddressByteSize() { 71 LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize); 72 73 uint8_t value = 0; 74 if (m_opaque_sp.get()) 75 value = m_opaque_sp->GetAddressByteSize(); 76 return value; 77 } 78 79 void SBData::SetAddressByteSize(uint8_t addr_byte_size) { 80 LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t), 81 addr_byte_size); 82 83 if (m_opaque_sp.get()) 84 m_opaque_sp->SetAddressByteSize(addr_byte_size); 85 } 86 87 void SBData::Clear() { 88 LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear); 89 90 if (m_opaque_sp.get()) 91 m_opaque_sp->Clear(); 92 } 93 94 size_t SBData::GetByteSize() { 95 LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize); 96 97 size_t value = 0; 98 if (m_opaque_sp.get()) 99 value = m_opaque_sp->GetByteSize(); 100 return value; 101 } 102 103 lldb::ByteOrder SBData::GetByteOrder() { 104 LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder); 105 106 lldb::ByteOrder value = eByteOrderInvalid; 107 if (m_opaque_sp.get()) 108 value = m_opaque_sp->GetByteOrder(); 109 return value; 110 } 111 112 void SBData::SetByteOrder(lldb::ByteOrder endian) { 113 LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian); 114 115 if (m_opaque_sp.get()) 116 m_opaque_sp->SetByteOrder(endian); 117 } 118 119 float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) { 120 LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t), 121 error, offset); 122 123 float value = 0; 124 if (!m_opaque_sp.get()) { 125 error.SetErrorString("no value to read from"); 126 } else { 127 uint32_t old_offset = offset; 128 value = m_opaque_sp->GetFloat(&offset); 129 if (offset == old_offset) 130 error.SetErrorString("unable to read data"); 131 } 132 return value; 133 } 134 135 double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) { 136 LLDB_RECORD_METHOD(double, SBData, GetDouble, 137 (lldb::SBError &, lldb::offset_t), error, offset); 138 139 double value = 0; 140 if (!m_opaque_sp.get()) { 141 error.SetErrorString("no value to read from"); 142 } else { 143 uint32_t old_offset = offset; 144 value = m_opaque_sp->GetDouble(&offset); 145 if (offset == old_offset) 146 error.SetErrorString("unable to read data"); 147 } 148 return value; 149 } 150 151 long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) { 152 LLDB_RECORD_METHOD(long double, SBData, GetLongDouble, 153 (lldb::SBError &, lldb::offset_t), error, offset); 154 155 long double value = 0; 156 if (!m_opaque_sp.get()) { 157 error.SetErrorString("no value to read from"); 158 } else { 159 uint32_t old_offset = offset; 160 value = m_opaque_sp->GetLongDouble(&offset); 161 if (offset == old_offset) 162 error.SetErrorString("unable to read data"); 163 } 164 return value; 165 } 166 167 lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) { 168 LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress, 169 (lldb::SBError &, lldb::offset_t), error, offset); 170 171 lldb::addr_t value = 0; 172 if (!m_opaque_sp.get()) { 173 error.SetErrorString("no value to read from"); 174 } else { 175 uint32_t old_offset = offset; 176 value = m_opaque_sp->GetAddress(&offset); 177 if (offset == old_offset) 178 error.SetErrorString("unable to read data"); 179 } 180 return value; 181 } 182 183 uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) { 184 LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8, 185 (lldb::SBError &, lldb::offset_t), error, offset); 186 187 uint8_t value = 0; 188 if (!m_opaque_sp.get()) { 189 error.SetErrorString("no value to read from"); 190 } else { 191 uint32_t old_offset = offset; 192 value = m_opaque_sp->GetU8(&offset); 193 if (offset == old_offset) 194 error.SetErrorString("unable to read data"); 195 } 196 return value; 197 } 198 199 uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) { 200 LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16, 201 (lldb::SBError &, lldb::offset_t), error, offset); 202 203 uint16_t value = 0; 204 if (!m_opaque_sp.get()) { 205 error.SetErrorString("no value to read from"); 206 } else { 207 uint32_t old_offset = offset; 208 value = m_opaque_sp->GetU16(&offset); 209 if (offset == old_offset) 210 error.SetErrorString("unable to read data"); 211 } 212 return value; 213 } 214 215 uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) { 216 LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32, 217 (lldb::SBError &, lldb::offset_t), error, offset); 218 219 uint32_t value = 0; 220 if (!m_opaque_sp.get()) { 221 error.SetErrorString("no value to read from"); 222 } else { 223 uint32_t old_offset = offset; 224 value = m_opaque_sp->GetU32(&offset); 225 if (offset == old_offset) 226 error.SetErrorString("unable to read data"); 227 } 228 return value; 229 } 230 231 uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) { 232 LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64, 233 (lldb::SBError &, lldb::offset_t), error, offset); 234 235 uint64_t value = 0; 236 if (!m_opaque_sp.get()) { 237 error.SetErrorString("no value to read from"); 238 } else { 239 uint32_t old_offset = offset; 240 value = m_opaque_sp->GetU64(&offset); 241 if (offset == old_offset) 242 error.SetErrorString("unable to read data"); 243 } 244 return value; 245 } 246 247 int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) { 248 LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8, 249 (lldb::SBError &, lldb::offset_t), error, offset); 250 251 int8_t value = 0; 252 if (!m_opaque_sp.get()) { 253 error.SetErrorString("no value to read from"); 254 } else { 255 uint32_t old_offset = offset; 256 value = (int8_t)m_opaque_sp->GetMaxS64(&offset, 1); 257 if (offset == old_offset) 258 error.SetErrorString("unable to read data"); 259 } 260 return value; 261 } 262 263 int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) { 264 LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16, 265 (lldb::SBError &, lldb::offset_t), error, offset); 266 267 int16_t value = 0; 268 if (!m_opaque_sp.get()) { 269 error.SetErrorString("no value to read from"); 270 } else { 271 uint32_t old_offset = offset; 272 value = (int16_t)m_opaque_sp->GetMaxS64(&offset, 2); 273 if (offset == old_offset) 274 error.SetErrorString("unable to read data"); 275 } 276 return value; 277 } 278 279 int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) { 280 LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32, 281 (lldb::SBError &, lldb::offset_t), error, offset); 282 283 int32_t value = 0; 284 if (!m_opaque_sp.get()) { 285 error.SetErrorString("no value to read from"); 286 } else { 287 uint32_t old_offset = offset; 288 value = (int32_t)m_opaque_sp->GetMaxS64(&offset, 4); 289 if (offset == old_offset) 290 error.SetErrorString("unable to read data"); 291 } 292 return value; 293 } 294 295 int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) { 296 LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64, 297 (lldb::SBError &, lldb::offset_t), error, offset); 298 299 int64_t value = 0; 300 if (!m_opaque_sp.get()) { 301 error.SetErrorString("no value to read from"); 302 } else { 303 uint32_t old_offset = offset; 304 value = (int64_t)m_opaque_sp->GetMaxS64(&offset, 8); 305 if (offset == old_offset) 306 error.SetErrorString("unable to read data"); 307 } 308 return value; 309 } 310 311 const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) { 312 LLDB_RECORD_METHOD(const char *, SBData, GetString, 313 (lldb::SBError &, lldb::offset_t), error, offset); 314 315 const char *value = nullptr; 316 if (!m_opaque_sp.get()) { 317 error.SetErrorString("no value to read from"); 318 } else { 319 uint32_t old_offset = offset; 320 value = m_opaque_sp->GetCStr(&offset); 321 if (offset == old_offset || (value == nullptr)) 322 error.SetErrorString("unable to read data"); 323 } 324 return value; 325 } 326 327 bool SBData::GetDescription(lldb::SBStream &description, 328 lldb::addr_t base_addr) { 329 LLDB_RECORD_METHOD(bool, SBData, GetDescription, 330 (lldb::SBStream &, lldb::addr_t), description, base_addr); 331 332 Stream &strm = description.ref(); 333 334 if (m_opaque_sp) { 335 DumpDataExtractor(*m_opaque_sp, &strm, 0, lldb::eFormatBytesWithASCII, 1, 336 m_opaque_sp->GetByteSize(), 16, base_addr, 0, 0); 337 } else 338 strm.PutCString("No value"); 339 340 return true; 341 } 342 343 size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset, 344 void *buf, size_t size) { 345 LLDB_RECORD_DUMMY(size_t, SBData, ReadRawData, 346 (lldb::SBError &, lldb::offset_t, void *, size_t), error, 347 offset, buf, size); 348 349 void *ok = nullptr; 350 if (!m_opaque_sp.get()) { 351 error.SetErrorString("no value to read from"); 352 } else { 353 uint32_t old_offset = offset; 354 ok = m_opaque_sp->GetU8(&offset, buf, size); 355 if ((offset == old_offset) || (ok == nullptr)) 356 error.SetErrorString("unable to read data"); 357 } 358 return ok ? size : 0; 359 } 360 361 void SBData::SetData(lldb::SBError &error, const void *buf, size_t size, 362 lldb::ByteOrder endian, uint8_t addr_size) { 363 LLDB_RECORD_DUMMY( 364 void, SBData, SetData, 365 (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error, 366 buf, size, endian, addr_size); 367 368 if (!m_opaque_sp.get()) 369 m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size); 370 else 371 { 372 m_opaque_sp->SetData(buf, size, endian); 373 m_opaque_sp->SetAddressByteSize(addr_size); 374 } 375 } 376 377 void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf, 378 size_t size, lldb::ByteOrder endian, 379 uint8_t addr_size) { 380 LLDB_RECORD_DUMMY( 381 void, SBData, SetData, 382 (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool), 383 error, buf, size, endian, addr_size, copy); 384 385 lldb::DataBufferSP buffer_sp = std::make_shared<DataBufferHeap>(buf, size); 386 387 if (!m_opaque_sp.get()) 388 m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size); 389 else { 390 m_opaque_sp->SetData(buffer_sp); 391 m_opaque_sp->SetByteOrder(endian); 392 m_opaque_sp->SetAddressByteSize(addr_size); 393 } 394 } 395 396 bool SBData::Append(const SBData &rhs) { 397 LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs); 398 399 bool value = false; 400 if (m_opaque_sp.get() && rhs.m_opaque_sp.get()) 401 value = m_opaque_sp.get()->Append(*rhs.m_opaque_sp); 402 return value; 403 } 404 405 lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian, 406 uint32_t addr_byte_size, 407 const char *data) { 408 LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString, 409 (lldb::ByteOrder, uint32_t, const char *), endian, 410 addr_byte_size, data); 411 412 if (!data || !data[0]) 413 return LLDB_RECORD_RESULT(SBData()); 414 415 uint32_t data_len = strlen(data); 416 417 lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len)); 418 lldb::DataExtractorSP data_sp( 419 new DataExtractor(buffer_sp, endian, addr_byte_size)); 420 421 SBData ret(data_sp); 422 423 return LLDB_RECORD_RESULT(ret); 424 } 425 426 lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian, 427 uint32_t addr_byte_size, 428 uint64_t *array, 429 size_t array_len) { 430 LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array, 431 (lldb::ByteOrder, uint32_t, uint64_t *, size_t), 432 endian, addr_byte_size, array, array_len); 433 434 if (!array || array_len == 0) 435 return LLDB_RECORD_RESULT(SBData()); 436 437 size_t data_len = array_len * sizeof(uint64_t); 438 439 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 440 lldb::DataExtractorSP data_sp( 441 new DataExtractor(buffer_sp, endian, addr_byte_size)); 442 443 SBData ret(data_sp); 444 445 return LLDB_RECORD_RESULT(ret); 446 } 447 448 lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian, 449 uint32_t addr_byte_size, 450 uint32_t *array, 451 size_t array_len) { 452 LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array, 453 (lldb::ByteOrder, uint32_t, uint32_t *, size_t), 454 endian, addr_byte_size, array, array_len); 455 456 if (!array || array_len == 0) 457 return LLDB_RECORD_RESULT(SBData()); 458 459 size_t data_len = array_len * sizeof(uint32_t); 460 461 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 462 lldb::DataExtractorSP data_sp( 463 new DataExtractor(buffer_sp, endian, addr_byte_size)); 464 465 SBData ret(data_sp); 466 467 return LLDB_RECORD_RESULT(ret); 468 } 469 470 lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian, 471 uint32_t addr_byte_size, 472 int64_t *array, 473 size_t array_len) { 474 LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array, 475 (lldb::ByteOrder, uint32_t, int64_t *, size_t), 476 endian, addr_byte_size, array, array_len); 477 478 if (!array || array_len == 0) 479 return LLDB_RECORD_RESULT(SBData()); 480 481 size_t data_len = array_len * sizeof(int64_t); 482 483 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 484 lldb::DataExtractorSP data_sp( 485 new DataExtractor(buffer_sp, endian, addr_byte_size)); 486 487 SBData ret(data_sp); 488 489 return LLDB_RECORD_RESULT(ret); 490 } 491 492 lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian, 493 uint32_t addr_byte_size, 494 int32_t *array, 495 size_t array_len) { 496 LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array, 497 (lldb::ByteOrder, uint32_t, int32_t *, size_t), 498 endian, addr_byte_size, array, array_len); 499 500 if (!array || array_len == 0) 501 return LLDB_RECORD_RESULT(SBData()); 502 503 size_t data_len = array_len * sizeof(int32_t); 504 505 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 506 lldb::DataExtractorSP data_sp( 507 new DataExtractor(buffer_sp, endian, addr_byte_size)); 508 509 SBData ret(data_sp); 510 511 return LLDB_RECORD_RESULT(ret); 512 } 513 514 lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian, 515 uint32_t addr_byte_size, 516 double *array, 517 size_t array_len) { 518 LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray, 519 (lldb::ByteOrder, uint32_t, double *, size_t), 520 endian, addr_byte_size, array, array_len); 521 522 if (!array || array_len == 0) 523 return LLDB_RECORD_RESULT(SBData()); 524 525 size_t data_len = array_len * sizeof(double); 526 527 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 528 lldb::DataExtractorSP data_sp( 529 new DataExtractor(buffer_sp, endian, addr_byte_size)); 530 531 SBData ret(data_sp); 532 533 return LLDB_RECORD_RESULT(ret); 534 } 535 536 bool SBData::SetDataFromCString(const char *data) { 537 LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data); 538 539 540 if (!data) { 541 return false; 542 } 543 544 size_t data_len = strlen(data); 545 546 lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len)); 547 548 if (!m_opaque_sp.get()) 549 m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), 550 GetAddressByteSize()); 551 else 552 m_opaque_sp->SetData(buffer_sp); 553 554 555 return true; 556 } 557 558 bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) { 559 LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t), 560 array, array_len); 561 562 563 if (!array || array_len == 0) { 564 return false; 565 } 566 567 size_t data_len = array_len * sizeof(uint64_t); 568 569 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 570 571 if (!m_opaque_sp.get()) 572 m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), 573 GetAddressByteSize()); 574 else 575 m_opaque_sp->SetData(buffer_sp); 576 577 578 return true; 579 } 580 581 bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) { 582 LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t), 583 array, array_len); 584 585 586 if (!array || array_len == 0) { 587 return false; 588 } 589 590 size_t data_len = array_len * sizeof(uint32_t); 591 592 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 593 594 if (!m_opaque_sp.get()) 595 m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), 596 GetAddressByteSize()); 597 else 598 m_opaque_sp->SetData(buffer_sp); 599 600 return true; 601 } 602 603 bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) { 604 LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t), 605 array, array_len); 606 607 608 if (!array || array_len == 0) { 609 return false; 610 } 611 612 size_t data_len = array_len * sizeof(int64_t); 613 614 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 615 616 if (!m_opaque_sp.get()) 617 m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), 618 GetAddressByteSize()); 619 else 620 m_opaque_sp->SetData(buffer_sp); 621 622 return true; 623 } 624 625 bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) { 626 LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t), 627 array, array_len); 628 629 630 if (!array || array_len == 0) { 631 return false; 632 } 633 634 size_t data_len = array_len * sizeof(int32_t); 635 636 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 637 638 if (!m_opaque_sp.get()) 639 m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), 640 GetAddressByteSize()); 641 else 642 m_opaque_sp->SetData(buffer_sp); 643 644 return true; 645 } 646 647 bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) { 648 LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t), 649 array, array_len); 650 651 652 if (!array || array_len == 0) { 653 return false; 654 } 655 656 size_t data_len = array_len * sizeof(double); 657 658 lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); 659 660 if (!m_opaque_sp.get()) 661 m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), 662 GetAddressByteSize()); 663 else 664 m_opaque_sp->SetData(buffer_sp); 665 666 return true; 667 } 668 669 namespace lldb_private { 670 namespace repro { 671 672 template <> 673 void RegisterMethods<SBData>(Registry &R) { 674 LLDB_REGISTER_CONSTRUCTOR(SBData, ()); 675 LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &)); 676 LLDB_REGISTER_METHOD(const lldb::SBData &, 677 SBData, operator=,(const lldb::SBData &)); 678 LLDB_REGISTER_METHOD(bool, SBData, IsValid, ()); 679 LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ()); 680 LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ()); 681 LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t)); 682 LLDB_REGISTER_METHOD(void, SBData, Clear, ()); 683 LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ()); 684 LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ()); 685 LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder)); 686 LLDB_REGISTER_METHOD(float, SBData, GetFloat, 687 (lldb::SBError &, lldb::offset_t)); 688 LLDB_REGISTER_METHOD(double, SBData, GetDouble, 689 (lldb::SBError &, lldb::offset_t)); 690 LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble, 691 (lldb::SBError &, lldb::offset_t)); 692 LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress, 693 (lldb::SBError &, lldb::offset_t)); 694 LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8, 695 (lldb::SBError &, lldb::offset_t)); 696 LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16, 697 (lldb::SBError &, lldb::offset_t)); 698 LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32, 699 (lldb::SBError &, lldb::offset_t)); 700 LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64, 701 (lldb::SBError &, lldb::offset_t)); 702 LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8, 703 (lldb::SBError &, lldb::offset_t)); 704 LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16, 705 (lldb::SBError &, lldb::offset_t)); 706 LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32, 707 (lldb::SBError &, lldb::offset_t)); 708 LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64, 709 (lldb::SBError &, lldb::offset_t)); 710 LLDB_REGISTER_METHOD(const char *, SBData, GetString, 711 (lldb::SBError &, lldb::offset_t)); 712 LLDB_REGISTER_METHOD(bool, SBData, GetDescription, 713 (lldb::SBStream &, lldb::addr_t)); 714 LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &)); 715 LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString, 716 (lldb::ByteOrder, uint32_t, const char *)); 717 LLDB_REGISTER_STATIC_METHOD( 718 lldb::SBData, SBData, CreateDataFromUInt64Array, 719 (lldb::ByteOrder, uint32_t, uint64_t *, size_t)); 720 LLDB_REGISTER_STATIC_METHOD( 721 lldb::SBData, SBData, CreateDataFromUInt32Array, 722 (lldb::ByteOrder, uint32_t, uint32_t *, size_t)); 723 LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array, 724 (lldb::ByteOrder, uint32_t, int64_t *, size_t)); 725 LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array, 726 (lldb::ByteOrder, uint32_t, int32_t *, size_t)); 727 LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray, 728 (lldb::ByteOrder, uint32_t, double *, size_t)); 729 LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *)); 730 LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array, 731 (uint64_t *, size_t)); 732 LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array, 733 (uint32_t *, size_t)); 734 LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array, 735 (int64_t *, size_t)); 736 LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array, 737 (int32_t *, size_t)); 738 LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray, 739 (double *, size_t)); 740 } 741 742 } 743 } 744