lldb/source/API/SBData.cpp

   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 "lldb/API/SBError.h"
  11 #include "lldb/API/SBStream.h"
  12 #include "lldb/Utility/Instrumentation.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_INSTRUMENT_VA(this);
  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_INSTRUMENT_VA(this, rhs);
  33 }
  34
  35 const SBData &SBData::operator=(const SBData &rhs) {
  36   LLDB_INSTRUMENT_VA(this, rhs);
  37
  38   if (this != &rhs)
  39     m_opaque_sp = rhs.m_opaque_sp;
  40   return *this;
  41 }
  42
  43 SBData::~SBData() = default;
  44
  45 void SBData::SetOpaque(const lldb::DataExtractorSP &data_sp) {
  46   m_opaque_sp = data_sp;
  47 }
  48
  49 lldb_private::DataExtractor *SBData::get() const { return m_opaque_sp.get(); }
  50
  51 lldb_private::DataExtractor *SBData::operator->() const {
  52   return m_opaque_sp.operator->();
  53 }
  54
  55 lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
  56
  57 const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
  58
  59 bool SBData::IsValid() {
  60   LLDB_INSTRUMENT_VA(this);
  61   return this->operator bool();
  62 }
  63 SBData::operator bool() const {
  64   LLDB_INSTRUMENT_VA(this);
  65
  66   return m_opaque_sp.get() != nullptr;
  67 }
  68
  69 uint8_t SBData::GetAddressByteSize() {
  70   LLDB_INSTRUMENT_VA(this);
  71
  72   uint8_t value = 0;
  73   if (m_opaque_sp.get())
  74     value = m_opaque_sp->GetAddressByteSize();
  75   return value;
  76 }
  77
  78 void SBData::SetAddressByteSize(uint8_t addr_byte_size) {
  79   LLDB_INSTRUMENT_VA(this, addr_byte_size);
  80
  81   if (m_opaque_sp.get())
  82     m_opaque_sp->SetAddressByteSize(addr_byte_size);
  83 }
  84
  85 void SBData::Clear() {
  86   LLDB_INSTRUMENT_VA(this);
  87
  88   if (m_opaque_sp.get())
  89     m_opaque_sp->Clear();
  90 }
  91
  92 size_t SBData::GetByteSize() {
  93   LLDB_INSTRUMENT_VA(this);
  94
  95   size_t value = 0;
  96   if (m_opaque_sp.get())
  97     value = m_opaque_sp->GetByteSize();
  98   return value;
  99 }
 100
 101 lldb::ByteOrder SBData::GetByteOrder() {
 102   LLDB_INSTRUMENT_VA(this);
 103
 104   lldb::ByteOrder value = eByteOrderInvalid;
 105   if (m_opaque_sp.get())
 106     value = m_opaque_sp->GetByteOrder();
 107   return value;
 108 }
 109
 110 void SBData::SetByteOrder(lldb::ByteOrder endian) {
 111   LLDB_INSTRUMENT_VA(this, endian);
 112
 113   if (m_opaque_sp.get())
 114     m_opaque_sp->SetByteOrder(endian);
 115 }
 116
 117 float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
 118   LLDB_INSTRUMENT_VA(this, error, offset);
 119
 120   float value = 0;
 121   if (!m_opaque_sp.get()) {
 122     error.SetErrorString("no value to read from");
 123   } else {
 124     uint32_t old_offset = offset;
 125     value = m_opaque_sp->GetFloat(&offset);
 126     if (offset == old_offset)
 127       error.SetErrorString("unable to read data");
 128   }
 129   return value;
 130 }
 131
 132 double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
 133   LLDB_INSTRUMENT_VA(this, error, offset);
 134
 135   double value = 0;
 136   if (!m_opaque_sp.get()) {
 137     error.SetErrorString("no value to read from");
 138   } else {
 139     uint32_t old_offset = offset;
 140     value = m_opaque_sp->GetDouble(&offset);
 141     if (offset == old_offset)
 142       error.SetErrorString("unable to read data");
 143   }
 144   return value;
 145 }
 146
 147 long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
 148   LLDB_INSTRUMENT_VA(this, error, offset);
 149
 150   long double value = 0;
 151   if (!m_opaque_sp.get()) {
 152     error.SetErrorString("no value to read from");
 153   } else {
 154     uint32_t old_offset = offset;
 155     value = m_opaque_sp->GetLongDouble(&offset);
 156     if (offset == old_offset)
 157       error.SetErrorString("unable to read data");
 158   }
 159   return value;
 160 }
 161
 162 lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
 163   LLDB_INSTRUMENT_VA(this, error, offset);
 164
 165   lldb::addr_t value = 0;
 166   if (!m_opaque_sp.get()) {
 167     error.SetErrorString("no value to read from");
 168   } else {
 169     uint32_t old_offset = offset;
 170     value = m_opaque_sp->GetAddress(&offset);
 171     if (offset == old_offset)
 172       error.SetErrorString("unable to read data");
 173   }
 174   return value;
 175 }
 176
 177 uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
 178   LLDB_INSTRUMENT_VA(this, error, offset);
 179
 180   uint8_t value = 0;
 181   if (!m_opaque_sp.get()) {
 182     error.SetErrorString("no value to read from");
 183   } else {
 184     uint32_t old_offset = offset;
 185     value = m_opaque_sp->GetU8(&offset);
 186     if (offset == old_offset)
 187       error.SetErrorString("unable to read data");
 188   }
 189   return value;
 190 }
 191
 192 uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
 193   LLDB_INSTRUMENT_VA(this, error, offset);
 194
 195   uint16_t value = 0;
 196   if (!m_opaque_sp.get()) {
 197     error.SetErrorString("no value to read from");
 198   } else {
 199     uint32_t old_offset = offset;
 200     value = m_opaque_sp->GetU16(&offset);
 201     if (offset == old_offset)
 202       error.SetErrorString("unable to read data");
 203   }
 204   return value;
 205 }
 206
 207 uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
 208   LLDB_INSTRUMENT_VA(this, error, offset);
 209
 210   uint32_t value = 0;
 211   if (!m_opaque_sp.get()) {
 212     error.SetErrorString("no value to read from");
 213   } else {
 214     uint32_t old_offset = offset;
 215     value = m_opaque_sp->GetU32(&offset);
 216     if (offset == old_offset)
 217       error.SetErrorString("unable to read data");
 218   }
 219   return value;
 220 }
 221
 222 uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
 223   LLDB_INSTRUMENT_VA(this, error, offset);
 224
 225   uint64_t value = 0;
 226   if (!m_opaque_sp.get()) {
 227     error.SetErrorString("no value to read from");
 228   } else {
 229     uint32_t old_offset = offset;
 230     value = m_opaque_sp->GetU64(&offset);
 231     if (offset == old_offset)
 232       error.SetErrorString("unable to read data");
 233   }
 234   return value;
 235 }
 236
 237 int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
 238   LLDB_INSTRUMENT_VA(this, error, offset);
 239
 240   int8_t value = 0;
 241   if (!m_opaque_sp.get()) {
 242     error.SetErrorString("no value to read from");
 243   } else {
 244     uint32_t old_offset = offset;
 245     value = (int8_t)m_opaque_sp->GetMaxS64(&offset, 1);
 246     if (offset == old_offset)
 247       error.SetErrorString("unable to read data");
 248   }
 249   return value;
 250 }
 251
 252 int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
 253   LLDB_INSTRUMENT_VA(this, error, offset);
 254
 255   int16_t value = 0;
 256   if (!m_opaque_sp.get()) {
 257     error.SetErrorString("no value to read from");
 258   } else {
 259     uint32_t old_offset = offset;
 260     value = (int16_t)m_opaque_sp->GetMaxS64(&offset, 2);
 261     if (offset == old_offset)
 262       error.SetErrorString("unable to read data");
 263   }
 264   return value;
 265 }
 266
 267 int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
 268   LLDB_INSTRUMENT_VA(this, error, offset);
 269
 270   int32_t value = 0;
 271   if (!m_opaque_sp.get()) {
 272     error.SetErrorString("no value to read from");
 273   } else {
 274     uint32_t old_offset = offset;
 275     value = (int32_t)m_opaque_sp->GetMaxS64(&offset, 4);
 276     if (offset == old_offset)
 277       error.SetErrorString("unable to read data");
 278   }
 279   return value;
 280 }
 281
 282 int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
 283   LLDB_INSTRUMENT_VA(this, error, offset);
 284
 285   int64_t value = 0;
 286   if (!m_opaque_sp.get()) {
 287     error.SetErrorString("no value to read from");
 288   } else {
 289     uint32_t old_offset = offset;
 290     value = (int64_t)m_opaque_sp->GetMaxS64(&offset, 8);
 291     if (offset == old_offset)
 292       error.SetErrorString("unable to read data");
 293   }
 294   return value;
 295 }
 296
 297 const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
 298   LLDB_INSTRUMENT_VA(this, error, offset);
 299
 300   if (!m_opaque_sp) {
 301     error.SetErrorString("no value to read from");
 302     return nullptr;
 303   }
 304
 305   lldb::offset_t old_offset = offset;
 306   const char *value = m_opaque_sp->GetCStr(&offset);
 307   if (offset == old_offset || value == nullptr) {
 308     error.SetErrorString("unable to read data");
 309     return nullptr;
 310   }
 311
 312   return ConstString(value).GetCString();
 313 }
 314
 315 bool SBData::GetDescription(lldb::SBStream &description,
 316                             lldb::addr_t base_addr) {
 317   LLDB_INSTRUMENT_VA(this, description, base_addr);
 318
 319   Stream &strm = description.ref();
 320
 321   if (m_opaque_sp) {
 322     DumpDataExtractor(*m_opaque_sp, &strm, 0, lldb::eFormatBytesWithASCII, 1,
 323                       m_opaque_sp->GetByteSize(), 16, base_addr, 0, 0);
 324   } else
 325     strm.PutCString("No value");
 326
 327   return true;
 328 }
 329
 330 size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
 331                            void *buf, size_t size) {
 332   LLDB_INSTRUMENT_VA(this, error, offset, buf, size);
 333
 334   void *ok = nullptr;
 335   if (!m_opaque_sp.get()) {
 336     error.SetErrorString("no value to read from");
 337   } else {
 338     uint32_t old_offset = offset;
 339     ok = m_opaque_sp->GetU8(&offset, buf, size);
 340     if ((offset == old_offset) || (ok == nullptr))
 341       error.SetErrorString("unable to read data");
 342   }
 343   return ok ? size : 0;
 344 }
 345
 346 void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
 347                      lldb::ByteOrder endian, uint8_t addr_size) {
 348   LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
 349
 350   if (!m_opaque_sp.get())
 351     m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
 352   else
 353   {
 354     m_opaque_sp->SetData(buf, size, endian);
 355     m_opaque_sp->SetAddressByteSize(addr_size);
 356   }
 357 }
 358
 359 void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
 360                                   size_t size, lldb::ByteOrder endian,
 361                                   uint8_t addr_size) {
 362   LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
 363
 364   lldb::DataBufferSP buffer_sp = std::make_shared<DataBufferHeap>(buf, size);
 365
 366   if (!m_opaque_sp.get())
 367     m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
 368   else {
 369     m_opaque_sp->SetData(buffer_sp);
 370     m_opaque_sp->SetByteOrder(endian);
 371     m_opaque_sp->SetAddressByteSize(addr_size);
 372   }
 373 }
 374
 375 bool SBData::Append(const SBData &rhs) {
 376   LLDB_INSTRUMENT_VA(this, rhs);
 377
 378   bool value = false;
 379   if (m_opaque_sp.get() && rhs.m_opaque_sp.get())
 380     value = m_opaque_sp.get()->Append(*rhs.m_opaque_sp);
 381   return value;
 382 }
 383
 384 lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
 385                                            uint32_t addr_byte_size,
 386                                            const char *data) {
 387   LLDB_INSTRUMENT_VA(endian, addr_byte_size, data);
 388
 389   if (!data || !data[0])
 390     return SBData();
 391
 392   uint32_t data_len = strlen(data);
 393
 394   lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len));
 395   lldb::DataExtractorSP data_sp(
 396       new DataExtractor(buffer_sp, endian, addr_byte_size));
 397
 398   SBData ret(data_sp);
 399
 400   return ret;
 401 }
 402
 403 lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
 404                                                uint32_t addr_byte_size,
 405                                                uint64_t *array,
 406                                                size_t array_len) {
 407   LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 408
 409   if (!array || array_len == 0)
 410     return SBData();
 411
 412   size_t data_len = array_len * sizeof(uint64_t);
 413
 414   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 415   lldb::DataExtractorSP data_sp(
 416       new DataExtractor(buffer_sp, endian, addr_byte_size));
 417
 418   SBData ret(data_sp);
 419
 420   return ret;
 421 }
 422
 423 lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
 424                                                uint32_t addr_byte_size,
 425                                                uint32_t *array,
 426                                                size_t array_len) {
 427   LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 428
 429   if (!array || array_len == 0)
 430     return SBData();
 431
 432   size_t data_len = array_len * sizeof(uint32_t);
 433
 434   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 435   lldb::DataExtractorSP data_sp(
 436       new DataExtractor(buffer_sp, endian, addr_byte_size));
 437
 438   SBData ret(data_sp);
 439
 440   return ret;
 441 }
 442
 443 lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
 444                                                uint32_t addr_byte_size,
 445                                                int64_t *array,
 446                                                size_t array_len) {
 447   LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 448
 449   if (!array || array_len == 0)
 450     return SBData();
 451
 452   size_t data_len = array_len * sizeof(int64_t);
 453
 454   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 455   lldb::DataExtractorSP data_sp(
 456       new DataExtractor(buffer_sp, endian, addr_byte_size));
 457
 458   SBData ret(data_sp);
 459
 460   return ret;
 461 }
 462
 463 lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
 464                                                uint32_t addr_byte_size,
 465                                                int32_t *array,
 466                                                size_t array_len) {
 467   LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 468
 469   if (!array || array_len == 0)
 470     return SBData();
 471
 472   size_t data_len = array_len * sizeof(int32_t);
 473
 474   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 475   lldb::DataExtractorSP data_sp(
 476       new DataExtractor(buffer_sp, endian, addr_byte_size));
 477
 478   SBData ret(data_sp);
 479
 480   return ret;
 481 }
 482
 483 lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
 484                                                uint32_t addr_byte_size,
 485                                                double *array,
 486                                                size_t array_len) {
 487   LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 488
 489   if (!array || array_len == 0)
 490     return SBData();
 491
 492   size_t data_len = array_len * sizeof(double);
 493
 494   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 495   lldb::DataExtractorSP data_sp(
 496       new DataExtractor(buffer_sp, endian, addr_byte_size));
 497
 498   SBData ret(data_sp);
 499
 500   return ret;
 501 }
 502
 503 bool SBData::SetDataFromCString(const char *data) {
 504   LLDB_INSTRUMENT_VA(this, data);
 505
 506   if (!data) {
 507     return false;
 508   }
 509
 510   size_t data_len = strlen(data);
 511
 512   lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len));
 513
 514   if (!m_opaque_sp.get())
 515     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 516                                                   GetAddressByteSize());
 517   else
 518     m_opaque_sp->SetData(buffer_sp);
 519
 520
 521   return true;
 522 }
 523
 524 bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
 525   LLDB_INSTRUMENT_VA(this, array, array_len);
 526
 527   if (!array || array_len == 0) {
 528     return false;
 529   }
 530
 531   size_t data_len = array_len * sizeof(uint64_t);
 532
 533   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 534
 535   if (!m_opaque_sp.get())
 536     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 537                                                   GetAddressByteSize());
 538   else
 539     m_opaque_sp->SetData(buffer_sp);
 540
 541
 542   return true;
 543 }
 544
 545 bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
 546   LLDB_INSTRUMENT_VA(this, array, array_len);
 547
 548   if (!array || array_len == 0) {
 549     return false;
 550   }
 551
 552   size_t data_len = array_len * sizeof(uint32_t);
 553
 554   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 555
 556   if (!m_opaque_sp.get())
 557     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 558                                                   GetAddressByteSize());
 559   else
 560     m_opaque_sp->SetData(buffer_sp);
 561
 562   return true;
 563 }
 564
 565 bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
 566   LLDB_INSTRUMENT_VA(this, array, array_len);
 567
 568   if (!array || array_len == 0) {
 569     return false;
 570   }
 571
 572   size_t data_len = array_len * sizeof(int64_t);
 573
 574   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 575
 576   if (!m_opaque_sp.get())
 577     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 578                                                   GetAddressByteSize());
 579   else
 580     m_opaque_sp->SetData(buffer_sp);
 581
 582   return true;
 583 }
 584
 585 bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
 586   LLDB_INSTRUMENT_VA(this, array, array_len);
 587
 588   if (!array || array_len == 0) {
 589     return false;
 590   }
 591
 592   size_t data_len = array_len * sizeof(int32_t);
 593
 594   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 595
 596   if (!m_opaque_sp.get())
 597     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 598                                                   GetAddressByteSize());
 599   else
 600     m_opaque_sp->SetData(buffer_sp);
 601
 602   return true;
 603 }
 604
 605 bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
 606   LLDB_INSTRUMENT_VA(this, array, array_len);
 607
 608   if (!array || array_len == 0) {
 609     return false;
 610   }
 611
 612   size_t data_len = array_len * sizeof(double);
 613
 614   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 615
 616   if (!m_opaque_sp.get())
 617     m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
 618                                                   GetAddressByteSize());
 619   else
 620     m_opaque_sp->SetData(buffer_sp);
 621
 622   return true;
 623 }