contrib/llvm/tools/lldb/source/API/SBData.cpp

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