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
20using namespace lldb;
21using namespace lldb_private;
22
23SBData::SBData () :
24    m_opaque_sp(new DataExtractor())
25{
26}
27
28SBData::SBData (const lldb::DataExtractorSP& data_sp) :
29    m_opaque_sp (data_sp)
30{
31}
32
33SBData::SBData(const SBData &rhs) :
34    m_opaque_sp (rhs.m_opaque_sp)
35{
36}
37
38const SBData &
39SBData::operator = (const SBData &rhs)
40{
41    if (this != &rhs)
42        m_opaque_sp = rhs.m_opaque_sp;
43    return *this;
44}
45
46SBData::~SBData ()
47{
48}
49
50void
51SBData::SetOpaque (const lldb::DataExtractorSP &data_sp)
52{
53    m_opaque_sp = data_sp;
54}
55
56lldb_private::DataExtractor *
57SBData::get() const
58{
59    return m_opaque_sp.get();
60}
61
62lldb_private::DataExtractor *
63SBData::operator->() const
64{
65    return m_opaque_sp.operator->();
66}
67
68lldb::DataExtractorSP &
69SBData::operator*()
70{
71    return m_opaque_sp;
72}
73
74const lldb::DataExtractorSP &
75SBData::operator*() const
76{
77    return m_opaque_sp;
78}
79
80bool
81SBData::IsValid()
82{
83    return m_opaque_sp.get() != NULL;
84}
85
86uint8_t
87SBData::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
99void
100SBData::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
109void
110SBData::Clear ()
111{
112    if (m_opaque_sp.get())
113        m_opaque_sp->Clear();
114}
115
116size_t
117SBData::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
129lldb::ByteOrder
130SBData::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
142void
143SBData::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
153float
154SBData::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
175double
176SBData::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
197long double
198SBData::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
219lldb::addr_t
220SBData::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
241uint8_t
242SBData::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
263uint16_t
264SBData::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
285uint32_t
286SBData::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
307uint64_t
308SBData::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
329int8_t
330SBData::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
351int16_t
352SBData::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
373int32_t
374SBData::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
395int64_t
396SBData::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
417const char*
418SBData::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
439bool
440SBData::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
462size_t
463SBData::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
487void
488SBData::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
504bool
505SBData::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
517lldb::SBData
518SBData::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
533lldb::SBData
534SBData::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
549lldb::SBData
550SBData::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
565lldb::SBData
566SBData::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
581lldb::SBData
582SBData::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
597lldb::SBData
598SBData::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
613bool
614SBData::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
642bool
643SBData::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
671bool
672SBData::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
700bool
701SBData::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
729bool
730SBData::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
758bool
759SBData::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}
786