lldb/source/API/SBData.cpp

   1 //===-- SBData.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/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() {}
  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 bool SBData::Append(const SBData &rhs) {
 378   LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
 379
 380   bool value = false;
 381   if (m_opaque_sp.get() && rhs.m_opaque_sp.get())
 382     value = m_opaque_sp.get()->Append(*rhs.m_opaque_sp);
 383   return value;
 384 }
 385
 386 lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
 387                                            uint32_t addr_byte_size,
 388                                            const char *data) {
 389   LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
 390                             (lldb::ByteOrder, uint32_t, const char *), endian,
 391                             addr_byte_size, data);
 392
 393   if (!data || !data[0])
 394     return LLDB_RECORD_RESULT(SBData());
 395
 396   uint32_t data_len = strlen(data);
 397
 398   lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len));
 399   lldb::DataExtractorSP data_sp(
 400       new DataExtractor(buffer_sp, endian, addr_byte_size));
 401
 402   SBData ret(data_sp);
 403
 404   return LLDB_RECORD_RESULT(ret);
 405 }
 406
 407 lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
 408                                                uint32_t addr_byte_size,
 409                                                uint64_t *array,
 410                                                size_t array_len) {
 411   LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array,
 412                             (lldb::ByteOrder, uint32_t, uint64_t *, size_t),
 413                             endian, addr_byte_size, array, array_len);
 414
 415   if (!array || array_len == 0)
 416     return LLDB_RECORD_RESULT(SBData());
 417
 418   size_t data_len = array_len * sizeof(uint64_t);
 419
 420   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 421   lldb::DataExtractorSP data_sp(
 422       new DataExtractor(buffer_sp, endian, addr_byte_size));
 423
 424   SBData ret(data_sp);
 425
 426   return LLDB_RECORD_RESULT(ret);
 427 }
 428
 429 lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
 430                                                uint32_t addr_byte_size,
 431                                                uint32_t *array,
 432                                                size_t array_len) {
 433   LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array,
 434                             (lldb::ByteOrder, uint32_t, uint32_t *, size_t),
 435                             endian, addr_byte_size, array, array_len);
 436
 437   if (!array || array_len == 0)
 438     return LLDB_RECORD_RESULT(SBData());
 439
 440   size_t data_len = array_len * sizeof(uint32_t);
 441
 442   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 443   lldb::DataExtractorSP data_sp(
 444       new DataExtractor(buffer_sp, endian, addr_byte_size));
 445
 446   SBData ret(data_sp);
 447
 448   return LLDB_RECORD_RESULT(ret);
 449 }
 450
 451 lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
 452                                                uint32_t addr_byte_size,
 453                                                int64_t *array,
 454                                                size_t array_len) {
 455   LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
 456                             (lldb::ByteOrder, uint32_t, int64_t *, size_t),
 457                             endian, addr_byte_size, array, array_len);
 458
 459   if (!array || array_len == 0)
 460     return LLDB_RECORD_RESULT(SBData());
 461
 462   size_t data_len = array_len * sizeof(int64_t);
 463
 464   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 465   lldb::DataExtractorSP data_sp(
 466       new DataExtractor(buffer_sp, endian, addr_byte_size));
 467
 468   SBData ret(data_sp);
 469
 470   return LLDB_RECORD_RESULT(ret);
 471 }
 472
 473 lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
 474                                                uint32_t addr_byte_size,
 475                                                int32_t *array,
 476                                                size_t array_len) {
 477   LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
 478                             (lldb::ByteOrder, uint32_t, int32_t *, size_t),
 479                             endian, addr_byte_size, array, array_len);
 480
 481   if (!array || array_len == 0)
 482     return LLDB_RECORD_RESULT(SBData());
 483
 484   size_t data_len = array_len * sizeof(int32_t);
 485
 486   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 487   lldb::DataExtractorSP data_sp(
 488       new DataExtractor(buffer_sp, endian, addr_byte_size));
 489
 490   SBData ret(data_sp);
 491
 492   return LLDB_RECORD_RESULT(ret);
 493 }
 494
 495 lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
 496                                                uint32_t addr_byte_size,
 497                                                double *array,
 498                                                size_t array_len) {
 499   LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
 500                             (lldb::ByteOrder, uint32_t, double *, size_t),
 501                             endian, addr_byte_size, array, array_len);
 502
 503   if (!array || array_len == 0)
 504     return LLDB_RECORD_RESULT(SBData());
 505
 506   size_t data_len = array_len * sizeof(double);
 507
 508   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 509   lldb::DataExtractorSP data_sp(
 510       new DataExtractor(buffer_sp, endian, addr_byte_size));
 511
 512   SBData ret(data_sp);
 513
 514   return LLDB_RECORD_RESULT(ret);
 515 }
 516
 517 bool SBData::SetDataFromCString(const char *data) {
 518   LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
 519
 520
 521   if (!data) {
 522     return false;
 523   }
 524
 525   size_t data_len = strlen(data);
 526
 527   lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len));
 528
 529   if (!m_opaque_sp.get())
 530     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 531                                                   GetAddressByteSize());
 532   else
 533     m_opaque_sp->SetData(buffer_sp);
 534
 535
 536   return true;
 537 }
 538
 539 bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
 540   LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
 541                      array, array_len);
 542
 543
 544   if (!array || array_len == 0) {
 545     return false;
 546   }
 547
 548   size_t data_len = array_len * sizeof(uint64_t);
 549
 550   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 551
 552   if (!m_opaque_sp.get())
 553     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 554                                                   GetAddressByteSize());
 555   else
 556     m_opaque_sp->SetData(buffer_sp);
 557
 558
 559   return true;
 560 }
 561
 562 bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
 563   LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
 564                      array, array_len);
 565
 566
 567   if (!array || array_len == 0) {
 568     return false;
 569   }
 570
 571   size_t data_len = array_len * sizeof(uint32_t);
 572
 573   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 574
 575   if (!m_opaque_sp.get())
 576     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 577                                                   GetAddressByteSize());
 578   else
 579     m_opaque_sp->SetData(buffer_sp);
 580
 581   return true;
 582 }
 583
 584 bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
 585   LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
 586                      array, array_len);
 587
 588
 589   if (!array || array_len == 0) {
 590     return false;
 591   }
 592
 593   size_t data_len = array_len * sizeof(int64_t);
 594
 595   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 596
 597   if (!m_opaque_sp.get())
 598     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 599                                                   GetAddressByteSize());
 600   else
 601     m_opaque_sp->SetData(buffer_sp);
 602
 603   return true;
 604 }
 605
 606 bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
 607   LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
 608                      array, array_len);
 609
 610
 611   if (!array || array_len == 0) {
 612     return false;
 613   }
 614
 615   size_t data_len = array_len * sizeof(int32_t);
 616
 617   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 618
 619   if (!m_opaque_sp.get())
 620     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 621                                                   GetAddressByteSize());
 622   else
 623     m_opaque_sp->SetData(buffer_sp);
 624
 625   return true;
 626 }
 627
 628 bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
 629   LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),
 630                      array, array_len);
 631
 632
 633   if (!array || array_len == 0) {
 634     return false;
 635   }
 636
 637   size_t data_len = array_len * sizeof(double);
 638
 639   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 640
 641   if (!m_opaque_sp.get())
 642     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 643                                                   GetAddressByteSize());
 644   else
 645     m_opaque_sp->SetData(buffer_sp);
 646
 647   return true;
 648 }
 649
 650 namespace lldb_private {
 651 namespace repro {
 652
 653 template <>
 654 void RegisterMethods<SBData>(Registry &R) {
 655   LLDB_REGISTER_CONSTRUCTOR(SBData, ());
 656   LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
 657   LLDB_REGISTER_METHOD(const lldb::SBData &,
 658                        SBData, operator=,(const lldb::SBData &));
 659   LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
 660   LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ());
 661   LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
 662   LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
 663   LLDB_REGISTER_METHOD(void, SBData, Clear, ());
 664   LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
 665   LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
 666   LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
 667   LLDB_REGISTER_METHOD(float, SBData, GetFloat,
 668                        (lldb::SBError &, lldb::offset_t));
 669   LLDB_REGISTER_METHOD(double, SBData, GetDouble,
 670                        (lldb::SBError &, lldb::offset_t));
 671   LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble,
 672                        (lldb::SBError &, lldb::offset_t));
 673   LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress,
 674                        (lldb::SBError &, lldb::offset_t));
 675   LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8,
 676                        (lldb::SBError &, lldb::offset_t));
 677   LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16,
 678                        (lldb::SBError &, lldb::offset_t));
 679   LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32,
 680                        (lldb::SBError &, lldb::offset_t));
 681   LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64,
 682                        (lldb::SBError &, lldb::offset_t));
 683   LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8,
 684                        (lldb::SBError &, lldb::offset_t));
 685   LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16,
 686                        (lldb::SBError &, lldb::offset_t));
 687   LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32,
 688                        (lldb::SBError &, lldb::offset_t));
 689   LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64,
 690                        (lldb::SBError &, lldb::offset_t));
 691   LLDB_REGISTER_METHOD(const char *, SBData, GetString,
 692                        (lldb::SBError &, lldb::offset_t));
 693   LLDB_REGISTER_METHOD(bool, SBData, GetDescription,
 694                        (lldb::SBStream &, lldb::addr_t));
 695   LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &));
 696   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
 697                               (lldb::ByteOrder, uint32_t, const char *));
 698   LLDB_REGISTER_STATIC_METHOD(
 699       lldb::SBData, SBData, CreateDataFromUInt64Array,
 700       (lldb::ByteOrder, uint32_t, uint64_t *, size_t));
 701   LLDB_REGISTER_STATIC_METHOD(
 702       lldb::SBData, SBData, CreateDataFromUInt32Array,
 703       (lldb::ByteOrder, uint32_t, uint32_t *, size_t));
 704   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
 705                               (lldb::ByteOrder, uint32_t, int64_t *, size_t));
 706   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
 707                               (lldb::ByteOrder, uint32_t, int32_t *, size_t));
 708   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
 709                               (lldb::ByteOrder, uint32_t, double *, size_t));
 710   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *));
 711   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array,
 712                        (uint64_t *, size_t));
 713   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array,
 714                        (uint32_t *, size_t));
 715   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array,
 716                        (int64_t *, size_t));
 717   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array,
 718                        (int32_t *, size_t));
 719   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray,
 720                        (double *, size_t));
 721 }
 722
 723 }
 724 }