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