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