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