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
SBData()25 SBData::SBData () :
26 m_opaque_sp(new DataExtractor())
27 {
28 }
29
SBData(const lldb::DataExtractorSP & data_sp)30 SBData::SBData (const lldb::DataExtractorSP& data_sp) :
31 m_opaque_sp (data_sp)
32 {
33 }
34
SBData(const SBData & rhs)35 SBData::SBData(const SBData &rhs) :
36 m_opaque_sp (rhs.m_opaque_sp)
37 {
38 }
39
40 const SBData &
operator =(const SBData & rhs)41 SBData::operator = (const SBData &rhs)
42 {
43 if (this != &rhs)
44 m_opaque_sp = rhs.m_opaque_sp;
45 return *this;
46 }
47
~SBData()48 SBData::~SBData ()
49 {
50 }
51
52 void
SetOpaque(const lldb::DataExtractorSP & data_sp)53 SBData::SetOpaque (const lldb::DataExtractorSP &data_sp)
54 {
55 m_opaque_sp = data_sp;
56 }
57
58 lldb_private::DataExtractor *
get() const59 SBData::get() const
60 {
61 return m_opaque_sp.get();
62 }
63
64 lldb_private::DataExtractor *
operator ->() const65 SBData::operator->() const
66 {
67 return m_opaque_sp.operator->();
68 }
69
70 lldb::DataExtractorSP &
operator *()71 SBData::operator*()
72 {
73 return m_opaque_sp;
74 }
75
76 const lldb::DataExtractorSP &
operator *() const77 SBData::operator*() const
78 {
79 return m_opaque_sp;
80 }
81
82 bool
IsValid()83 SBData::IsValid()
84 {
85 return m_opaque_sp.get() != NULL;
86 }
87
88 uint8_t
GetAddressByteSize()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
SetAddressByteSize(uint8_t addr_byte_size)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
Clear()112 SBData::Clear ()
113 {
114 if (m_opaque_sp.get())
115 m_opaque_sp->Clear();
116 }
117
118 size_t
GetByteSize()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
GetByteOrder()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
SetByteOrder(lldb::ByteOrder endian)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
GetFloat(lldb::SBError & error,lldb::offset_t offset)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
GetDouble(lldb::SBError & error,lldb::offset_t offset)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
GetLongDouble(lldb::SBError & error,lldb::offset_t offset)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
GetAddress(lldb::SBError & error,lldb::offset_t offset)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
GetUnsignedInt8(lldb::SBError & error,lldb::offset_t offset)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
GetUnsignedInt16(lldb::SBError & error,lldb::offset_t offset)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
GetUnsignedInt32(lldb::SBError & error,lldb::offset_t offset)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
GetUnsignedInt64(lldb::SBError & error,lldb::offset_t offset)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
GetSignedInt8(lldb::SBError & error,lldb::offset_t offset)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
GetSignedInt16(lldb::SBError & error,lldb::offset_t offset)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
GetSignedInt32(lldb::SBError & error,lldb::offset_t offset)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
GetSignedInt64(lldb::SBError & error,lldb::offset_t offset)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*
GetString(lldb::SBError & error,lldb::offset_t offset)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
GetDescription(lldb::SBStream & description,lldb::addr_t base_addr)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
ReadRawData(lldb::SBError & error,lldb::offset_t offset,void * buf,size_t size)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
SetData(lldb::SBError & error,const void * buf,size_t size,lldb::ByteOrder endian,uint8_t addr_size)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
Append(const SBData & rhs)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
CreateDataFromCString(lldb::ByteOrder endian,uint32_t addr_byte_size,const char * data)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
CreateDataFromUInt64Array(lldb::ByteOrder endian,uint32_t addr_byte_size,uint64_t * array,size_t array_len)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
CreateDataFromUInt32Array(lldb::ByteOrder endian,uint32_t addr_byte_size,uint32_t * array,size_t array_len)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
CreateDataFromSInt64Array(lldb::ByteOrder endian,uint32_t addr_byte_size,int64_t * array,size_t array_len)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
CreateDataFromSInt32Array(lldb::ByteOrder endian,uint32_t addr_byte_size,int32_t * array,size_t array_len)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
CreateDataFromDoubleArray(lldb::ByteOrder endian,uint32_t addr_byte_size,double * array,size_t array_len)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
SetDataFromCString(const char * data)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
SetDataFromUInt64Array(uint64_t * array,size_t array_len)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
SetDataFromUInt32Array(uint32_t * array,size_t array_len)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
SetDataFromSInt64Array(int64_t * array,size_t array_len)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
SetDataFromSInt32Array(int32_t * array,size_t array_len)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
SetDataFromDoubleArray(double * array,size_t array_len)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