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