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