contrib/llvm-project/lldb/source/API/SBType.cpp

   1 //===-- SBType.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/SBType.h"
  10 #include "lldb/API/SBDefines.h"
  11 #include "lldb/API/SBModule.h"
  12 #include "lldb/API/SBStream.h"
  13 #include "lldb/API/SBTypeEnumMember.h"
  14 #include "lldb/Core/Mangled.h"
  15 #include "lldb/Symbol/CompilerType.h"
  16 #include "lldb/Symbol/Type.h"
  17 #include "lldb/Symbol/TypeSystem.h"
  18 #include "lldb/Utility/ConstString.h"
  19 #include "lldb/Utility/Instrumentation.h"
  20 #include "lldb/Utility/Stream.h"
  21
  22 #include "llvm/ADT/APSInt.h"
  23
  24 #include <memory>
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29 SBType::SBType() { LLDB_INSTRUMENT_VA(this); }
  30
  31 SBType::SBType(const CompilerType &type)
  32     : m_opaque_sp(new TypeImpl(
  33           CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {}
  34
  35 SBType::SBType(const lldb::TypeSP &type_sp)
  36     : m_opaque_sp(new TypeImpl(type_sp)) {}
  37
  38 SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
  39     : m_opaque_sp(type_impl_sp) {}
  40
  41 SBType::SBType(const SBType &rhs) {
  42   LLDB_INSTRUMENT_VA(this, rhs);
  43
  44   if (this != &rhs) {
  45     m_opaque_sp = rhs.m_opaque_sp;
  46   }
  47 }
  48
  49 // SBType::SBType (TypeImpl* impl) :
  50 //    m_opaque_up(impl)
  51 //{}
  52 //
  53 bool SBType::operator==(SBType &rhs) {
  54   LLDB_INSTRUMENT_VA(this, rhs);
  55
  56   if (!IsValid())
  57     return !rhs.IsValid();
  58
  59   if (!rhs.IsValid())
  60     return false;
  61
  62   return *m_opaque_sp.get() == *rhs.m_opaque_sp.get();
  63 }
  64
  65 bool SBType::operator!=(SBType &rhs) {
  66   LLDB_INSTRUMENT_VA(this, rhs);
  67
  68   if (!IsValid())
  69     return rhs.IsValid();
  70
  71   if (!rhs.IsValid())
  72     return true;
  73
  74   return *m_opaque_sp.get() != *rhs.m_opaque_sp.get();
  75 }
  76
  77 lldb::TypeImplSP SBType::GetSP() { return m_opaque_sp; }
  78
  79 void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
  80   m_opaque_sp = type_impl_sp;
  81 }
  82
  83 SBType &SBType::operator=(const SBType &rhs) {
  84   LLDB_INSTRUMENT_VA(this, rhs);
  85
  86   if (this != &rhs) {
  87     m_opaque_sp = rhs.m_opaque_sp;
  88   }
  89   return *this;
  90 }
  91
  92 SBType::~SBType() = default;
  93
  94 TypeImpl &SBType::ref() {
  95   if (m_opaque_sp.get() == nullptr)
  96     m_opaque_sp = std::make_shared<TypeImpl>();
  97   return *m_opaque_sp;
  98 }
  99
 100 const TypeImpl &SBType::ref() const {
 101   // "const SBAddress &addr" should already have checked "addr.IsValid()" prior
 102   // to calling this function. In case you didn't we will assert and die to let
 103   // you know.
 104   assert(m_opaque_sp.get());
 105   return *m_opaque_sp;
 106 }
 107
 108 bool SBType::IsValid() const {
 109   LLDB_INSTRUMENT_VA(this);
 110   return this->operator bool();
 111 }
 112 SBType::operator bool() const {
 113   LLDB_INSTRUMENT_VA(this);
 114
 115   if (m_opaque_sp.get() == nullptr)
 116     return false;
 117
 118   return m_opaque_sp->IsValid();
 119 }
 120
 121 uint64_t SBType::GetByteSize() {
 122   LLDB_INSTRUMENT_VA(this);
 123
 124   if (IsValid())
 125     if (llvm::Optional<uint64_t> size =
 126             m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr))
 127       return *size;
 128   return 0;
 129 }
 130
 131 bool SBType::IsPointerType() {
 132   LLDB_INSTRUMENT_VA(this);
 133
 134   if (!IsValid())
 135     return false;
 136   return m_opaque_sp->GetCompilerType(true).IsPointerType();
 137 }
 138
 139 bool SBType::IsArrayType() {
 140   LLDB_INSTRUMENT_VA(this);
 141
 142   if (!IsValid())
 143     return false;
 144   return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr,
 145                                                         nullptr);
 146 }
 147
 148 bool SBType::IsVectorType() {
 149   LLDB_INSTRUMENT_VA(this);
 150
 151   if (!IsValid())
 152     return false;
 153   return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr);
 154 }
 155
 156 bool SBType::IsReferenceType() {
 157   LLDB_INSTRUMENT_VA(this);
 158
 159   if (!IsValid())
 160     return false;
 161   return m_opaque_sp->GetCompilerType(true).IsReferenceType();
 162 }
 163
 164 SBType SBType::GetPointerType() {
 165   LLDB_INSTRUMENT_VA(this);
 166
 167   if (!IsValid())
 168     return SBType();
 169
 170   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
 171 }
 172
 173 SBType SBType::GetPointeeType() {
 174   LLDB_INSTRUMENT_VA(this);
 175
 176   if (!IsValid())
 177     return SBType();
 178   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())));
 179 }
 180
 181 SBType SBType::GetReferenceType() {
 182   LLDB_INSTRUMENT_VA(this);
 183
 184   if (!IsValid())
 185     return SBType();
 186   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())));
 187 }
 188
 189 SBType SBType::GetTypedefedType() {
 190   LLDB_INSTRUMENT_VA(this);
 191
 192   if (!IsValid())
 193     return SBType();
 194   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())));
 195 }
 196
 197 SBType SBType::GetDereferencedType() {
 198   LLDB_INSTRUMENT_VA(this);
 199
 200   if (!IsValid())
 201     return SBType();
 202   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
 203 }
 204
 205 SBType SBType::GetArrayElementType() {
 206   LLDB_INSTRUMENT_VA(this);
 207
 208   if (!IsValid())
 209     return SBType();
 210   return SBType(TypeImplSP(new TypeImpl(
 211       m_opaque_sp->GetCompilerType(true).GetArrayElementType(nullptr))));
 212 }
 213
 214 SBType SBType::GetArrayType(uint64_t size) {
 215   LLDB_INSTRUMENT_VA(this, size);
 216
 217   if (!IsValid())
 218     return SBType();
 219   return SBType(TypeImplSP(
 220       new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size))));
 221 }
 222
 223 SBType SBType::GetVectorElementType() {
 224   LLDB_INSTRUMENT_VA(this);
 225
 226   SBType type_sb;
 227   if (IsValid()) {
 228     CompilerType vector_element_type;
 229     if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type,
 230                                                         nullptr))
 231       type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
 232   }
 233   return type_sb;
 234 }
 235
 236 bool SBType::IsFunctionType() {
 237   LLDB_INSTRUMENT_VA(this);
 238
 239   if (!IsValid())
 240     return false;
 241   return m_opaque_sp->GetCompilerType(true).IsFunctionType();
 242 }
 243
 244 bool SBType::IsPolymorphicClass() {
 245   LLDB_INSTRUMENT_VA(this);
 246
 247   if (!IsValid())
 248     return false;
 249   return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass();
 250 }
 251
 252 bool SBType::IsTypedefType() {
 253   LLDB_INSTRUMENT_VA(this);
 254
 255   if (!IsValid())
 256     return false;
 257   return m_opaque_sp->GetCompilerType(true).IsTypedefType();
 258 }
 259
 260 bool SBType::IsAnonymousType() {
 261   LLDB_INSTRUMENT_VA(this);
 262
 263   if (!IsValid())
 264     return false;
 265   return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
 266 }
 267
 268 bool SBType::IsScopedEnumerationType() {
 269   LLDB_INSTRUMENT_VA(this);
 270
 271   if (!IsValid())
 272     return false;
 273   return m_opaque_sp->GetCompilerType(true).IsScopedEnumerationType();
 274 }
 275
 276 lldb::SBType SBType::GetFunctionReturnType() {
 277   LLDB_INSTRUMENT_VA(this);
 278
 279   if (IsValid()) {
 280     CompilerType return_type(
 281         m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
 282     if (return_type.IsValid())
 283       return SBType(return_type);
 284   }
 285   return lldb::SBType();
 286 }
 287
 288 lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
 289   LLDB_INSTRUMENT_VA(this);
 290
 291   SBTypeList sb_type_list;
 292   if (IsValid()) {
 293     CompilerType func_type(m_opaque_sp->GetCompilerType(true));
 294     size_t count = func_type.GetNumberOfFunctionArguments();
 295     for (size_t i = 0; i < count; i++) {
 296       sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
 297     }
 298   }
 299   return sb_type_list;
 300 }
 301
 302 uint32_t SBType::GetNumberOfMemberFunctions() {
 303   LLDB_INSTRUMENT_VA(this);
 304
 305   if (IsValid()) {
 306     return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
 307   }
 308   return 0;
 309 }
 310
 311 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
 312   LLDB_INSTRUMENT_VA(this, idx);
 313
 314   SBTypeMemberFunction sb_func_type;
 315   if (IsValid())
 316     sb_func_type.reset(new TypeMemberFunctionImpl(
 317         m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
 318   return sb_func_type;
 319 }
 320
 321 lldb::SBType SBType::GetUnqualifiedType() {
 322   LLDB_INSTRUMENT_VA(this);
 323
 324   if (!IsValid())
 325     return SBType();
 326   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())));
 327 }
 328
 329 lldb::SBType SBType::GetCanonicalType() {
 330   LLDB_INSTRUMENT_VA(this);
 331
 332   if (IsValid())
 333     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
 334   return SBType();
 335 }
 336
 337 SBType SBType::GetEnumerationIntegerType() {
 338   LLDB_INSTRUMENT_VA(this);
 339
 340   if (IsValid()) {
 341     return SBType(
 342         m_opaque_sp->GetCompilerType(true).GetEnumerationIntegerType());
 343   }
 344   return SBType();
 345 }
 346
 347 lldb::BasicType SBType::GetBasicType() {
 348   LLDB_INSTRUMENT_VA(this);
 349
 350   if (IsValid())
 351     return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
 352   return eBasicTypeInvalid;
 353 }
 354
 355 SBType SBType::GetBasicType(lldb::BasicType basic_type) {
 356   LLDB_INSTRUMENT_VA(this, basic_type);
 357
 358   if (IsValid() && m_opaque_sp->IsValid())
 359     return SBType(
 360         m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type));
 361   return SBType();
 362 }
 363
 364 uint32_t SBType::GetNumberOfDirectBaseClasses() {
 365   LLDB_INSTRUMENT_VA(this);
 366
 367   if (IsValid())
 368     return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
 369   return 0;
 370 }
 371
 372 uint32_t SBType::GetNumberOfVirtualBaseClasses() {
 373   LLDB_INSTRUMENT_VA(this);
 374
 375   if (IsValid())
 376     return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
 377   return 0;
 378 }
 379
 380 uint32_t SBType::GetNumberOfFields() {
 381   LLDB_INSTRUMENT_VA(this);
 382
 383   if (IsValid())
 384     return m_opaque_sp->GetCompilerType(true).GetNumFields();
 385   return 0;
 386 }
 387
 388 bool SBType::GetDescription(SBStream &description,
 389                             lldb::DescriptionLevel description_level) {
 390   LLDB_INSTRUMENT_VA(this, description, description_level);
 391
 392   Stream &strm = description.ref();
 393
 394   if (m_opaque_sp) {
 395     m_opaque_sp->GetDescription(strm, description_level);
 396   } else
 397     strm.PutCString("No value");
 398
 399   return true;
 400 }
 401
 402 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
 403   LLDB_INSTRUMENT_VA(this, idx);
 404
 405   SBTypeMember sb_type_member;
 406   if (IsValid()) {
 407     uint32_t bit_offset = 0;
 408     CompilerType base_class_type =
 409         m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex(
 410             idx, &bit_offset);
 411     if (base_class_type.IsValid())
 412       sb_type_member.reset(new TypeMemberImpl(
 413           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
 414   }
 415   return sb_type_member;
 416 }
 417
 418 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
 419   LLDB_INSTRUMENT_VA(this, idx);
 420
 421   SBTypeMember sb_type_member;
 422   if (IsValid()) {
 423     uint32_t bit_offset = 0;
 424     CompilerType base_class_type =
 425         m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex(
 426             idx, &bit_offset);
 427     if (base_class_type.IsValid())
 428       sb_type_member.reset(new TypeMemberImpl(
 429           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
 430   }
 431   return sb_type_member;
 432 }
 433
 434 SBTypeEnumMemberList SBType::GetEnumMembers() {
 435   LLDB_INSTRUMENT_VA(this);
 436
 437   SBTypeEnumMemberList sb_enum_member_list;
 438   if (IsValid()) {
 439     CompilerType this_type(m_opaque_sp->GetCompilerType(true));
 440     if (this_type.IsValid()) {
 441       this_type.ForEachEnumerator([&sb_enum_member_list](
 442                                       const CompilerType &integer_type,
 443                                       ConstString name,
 444                                       const llvm::APSInt &value) -> bool {
 445         SBTypeEnumMember enum_member(
 446             lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl(
 447                 lldb::TypeImplSP(new TypeImpl(integer_type)), name, value)));
 448         sb_enum_member_list.Append(enum_member);
 449         return true; // Keep iterating
 450       });
 451     }
 452   }
 453   return sb_enum_member_list;
 454 }
 455
 456 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
 457   LLDB_INSTRUMENT_VA(this, idx);
 458
 459   SBTypeMember sb_type_member;
 460   if (IsValid()) {
 461     CompilerType this_type(m_opaque_sp->GetCompilerType(false));
 462     if (this_type.IsValid()) {
 463       uint64_t bit_offset = 0;
 464       uint32_t bitfield_bit_size = 0;
 465       bool is_bitfield = false;
 466       std::string name_sstr;
 467       CompilerType field_type(this_type.GetFieldAtIndex(
 468           idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield));
 469       if (field_type.IsValid()) {
 470         ConstString name;
 471         if (!name_sstr.empty())
 472           name.SetCString(name_sstr.c_str());
 473         sb_type_member.reset(
 474             new TypeMemberImpl(TypeImplSP(new TypeImpl(field_type)), bit_offset,
 475                                name, bitfield_bit_size, is_bitfield));
 476       }
 477     }
 478   }
 479   return sb_type_member;
 480 }
 481
 482 bool SBType::IsTypeComplete() {
 483   LLDB_INSTRUMENT_VA(this);
 484
 485   if (!IsValid())
 486     return false;
 487   return m_opaque_sp->GetCompilerType(false).IsCompleteType();
 488 }
 489
 490 uint32_t SBType::GetTypeFlags() {
 491   LLDB_INSTRUMENT_VA(this);
 492
 493   if (!IsValid())
 494     return 0;
 495   return m_opaque_sp->GetCompilerType(true).GetTypeInfo();
 496 }
 497
 498 lldb::SBModule SBType::GetModule() {
 499   LLDB_INSTRUMENT_VA(this);
 500
 501   lldb::SBModule sb_module;
 502   if (!IsValid())
 503     return sb_module;
 504
 505   sb_module.SetSP(m_opaque_sp->GetModule());
 506   return sb_module;
 507 }
 508
 509 const char *SBType::GetName() {
 510   LLDB_INSTRUMENT_VA(this);
 511
 512   if (!IsValid())
 513     return "";
 514   return m_opaque_sp->GetName().GetCString();
 515 }
 516
 517 const char *SBType::GetDisplayTypeName() {
 518   LLDB_INSTRUMENT_VA(this);
 519
 520   if (!IsValid())
 521     return "";
 522   return m_opaque_sp->GetDisplayTypeName().GetCString();
 523 }
 524
 525 lldb::TypeClass SBType::GetTypeClass() {
 526   LLDB_INSTRUMENT_VA(this);
 527
 528   if (IsValid())
 529     return m_opaque_sp->GetCompilerType(true).GetTypeClass();
 530   return lldb::eTypeClassInvalid;
 531 }
 532
 533 uint32_t SBType::GetNumberOfTemplateArguments() {
 534   LLDB_INSTRUMENT_VA(this);
 535
 536   if (IsValid())
 537     return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
 538   return 0;
 539 }
 540
 541 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
 542   LLDB_INSTRUMENT_VA(this, idx);
 543
 544   if (!IsValid())
 545     return SBType();
 546
 547   CompilerType type;
 548   switch(GetTemplateArgumentKind(idx)) {
 549     case eTemplateArgumentKindType:
 550       type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx);
 551       break;
 552     case eTemplateArgumentKindIntegral:
 553       type = m_opaque_sp->GetCompilerType(false)
 554                  .GetIntegralTemplateArgument(idx)
 555                  ->type;
 556       break;
 557     default:
 558       break;
 559   }
 560   if (type.IsValid())
 561     return SBType(type);
 562   return SBType();
 563 }
 564
 565 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
 566   LLDB_INSTRUMENT_VA(this, idx);
 567
 568   if (IsValid())
 569     return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
 570   return eTemplateArgumentKindNull;
 571 }
 572
 573 SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
 574   LLDB_INSTRUMENT_VA(this);
 575 }
 576
 577 SBTypeList::SBTypeList(const SBTypeList &rhs)
 578     : m_opaque_up(new TypeListImpl()) {
 579   LLDB_INSTRUMENT_VA(this, rhs);
 580
 581   for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
 582        i < rhs_size; i++)
 583     Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
 584 }
 585
 586 bool SBTypeList::IsValid() {
 587   LLDB_INSTRUMENT_VA(this);
 588   return this->operator bool();
 589 }
 590 SBTypeList::operator bool() const {
 591   LLDB_INSTRUMENT_VA(this);
 592
 593   return (m_opaque_up != nullptr);
 594 }
 595
 596 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
 597   LLDB_INSTRUMENT_VA(this, rhs);
 598
 599   if (this != &rhs) {
 600     m_opaque_up = std::make_unique<TypeListImpl>();
 601     for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
 602          i < rhs_size; i++)
 603       Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
 604   }
 605   return *this;
 606 }
 607
 608 void SBTypeList::Append(SBType type) {
 609   LLDB_INSTRUMENT_VA(this, type);
 610
 611   if (type.IsValid())
 612     m_opaque_up->Append(type.m_opaque_sp);
 613 }
 614
 615 SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
 616   LLDB_INSTRUMENT_VA(this, index);
 617
 618   if (m_opaque_up)
 619     return SBType(m_opaque_up->GetTypeAtIndex(index));
 620   return SBType();
 621 }
 622
 623 uint32_t SBTypeList::GetSize() {
 624   LLDB_INSTRUMENT_VA(this);
 625
 626   return m_opaque_up->GetSize();
 627 }
 628
 629 SBTypeList::~SBTypeList() = default;
 630
 631 SBTypeMember::SBTypeMember() { LLDB_INSTRUMENT_VA(this); }
 632
 633 SBTypeMember::~SBTypeMember() = default;
 634
 635 SBTypeMember::SBTypeMember(const SBTypeMember &rhs) {
 636   LLDB_INSTRUMENT_VA(this, rhs);
 637
 638   if (this != &rhs) {
 639     if (rhs.IsValid())
 640       m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref());
 641   }
 642 }
 643
 644 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
 645   LLDB_INSTRUMENT_VA(this, rhs);
 646
 647   if (this != &rhs) {
 648     if (rhs.IsValid())
 649       m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref());
 650   }
 651   return *this;
 652 }
 653
 654 bool SBTypeMember::IsValid() const {
 655   LLDB_INSTRUMENT_VA(this);
 656   return this->operator bool();
 657 }
 658 SBTypeMember::operator bool() const {
 659   LLDB_INSTRUMENT_VA(this);
 660
 661   return m_opaque_up.get();
 662 }
 663
 664 const char *SBTypeMember::GetName() {
 665   LLDB_INSTRUMENT_VA(this);
 666
 667   if (m_opaque_up)
 668     return m_opaque_up->GetName().GetCString();
 669   return nullptr;
 670 }
 671
 672 SBType SBTypeMember::GetType() {
 673   LLDB_INSTRUMENT_VA(this);
 674
 675   SBType sb_type;
 676   if (m_opaque_up) {
 677     sb_type.SetSP(m_opaque_up->GetTypeImpl());
 678   }
 679   return sb_type;
 680 }
 681
 682 uint64_t SBTypeMember::GetOffsetInBytes() {
 683   LLDB_INSTRUMENT_VA(this);
 684
 685   if (m_opaque_up)
 686     return m_opaque_up->GetBitOffset() / 8u;
 687   return 0;
 688 }
 689
 690 uint64_t SBTypeMember::GetOffsetInBits() {
 691   LLDB_INSTRUMENT_VA(this);
 692
 693   if (m_opaque_up)
 694     return m_opaque_up->GetBitOffset();
 695   return 0;
 696 }
 697
 698 bool SBTypeMember::IsBitfield() {
 699   LLDB_INSTRUMENT_VA(this);
 700
 701   if (m_opaque_up)
 702     return m_opaque_up->GetIsBitfield();
 703   return false;
 704 }
 705
 706 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
 707   LLDB_INSTRUMENT_VA(this);
 708
 709   if (m_opaque_up)
 710     return m_opaque_up->GetBitfieldBitSize();
 711   return 0;
 712 }
 713
 714 bool SBTypeMember::GetDescription(lldb::SBStream &description,
 715                                   lldb::DescriptionLevel description_level) {
 716   LLDB_INSTRUMENT_VA(this, description, description_level);
 717
 718   Stream &strm = description.ref();
 719
 720   if (m_opaque_up) {
 721     const uint32_t bit_offset = m_opaque_up->GetBitOffset();
 722     const uint32_t byte_offset = bit_offset / 8u;
 723     const uint32_t byte_bit_offset = bit_offset % 8u;
 724     const char *name = m_opaque_up->GetName().GetCString();
 725     if (byte_bit_offset)
 726       strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset);
 727     else
 728       strm.Printf("+%u: (", byte_offset);
 729
 730     TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl());
 731     if (type_impl_sp)
 732       type_impl_sp->GetDescription(strm, description_level);
 733
 734     strm.Printf(") %s", name);
 735     if (m_opaque_up->GetIsBitfield()) {
 736       const uint32_t bitfield_bit_size = m_opaque_up->GetBitfieldBitSize();
 737       strm.Printf(" : %u", bitfield_bit_size);
 738     }
 739   } else {
 740     strm.PutCString("No value");
 741   }
 742   return true;
 743 }
 744
 745 void SBTypeMember::reset(TypeMemberImpl *type_member_impl) {
 746   m_opaque_up.reset(type_member_impl);
 747 }
 748
 749 TypeMemberImpl &SBTypeMember::ref() {
 750   if (m_opaque_up == nullptr)
 751     m_opaque_up = std::make_unique<TypeMemberImpl>();
 752   return *m_opaque_up;
 753 }
 754
 755 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
 756
 757 SBTypeMemberFunction::SBTypeMemberFunction() { LLDB_INSTRUMENT_VA(this); }
 758
 759 SBTypeMemberFunction::~SBTypeMemberFunction() = default;
 760
 761 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
 762     : m_opaque_sp(rhs.m_opaque_sp) {
 763   LLDB_INSTRUMENT_VA(this, rhs);
 764 }
 765
 766 lldb::SBTypeMemberFunction &SBTypeMemberFunction::
 767 operator=(const lldb::SBTypeMemberFunction &rhs) {
 768   LLDB_INSTRUMENT_VA(this, rhs);
 769
 770   if (this != &rhs)
 771     m_opaque_sp = rhs.m_opaque_sp;
 772   return *this;
 773 }
 774
 775 bool SBTypeMemberFunction::IsValid() const {
 776   LLDB_INSTRUMENT_VA(this);
 777   return this->operator bool();
 778 }
 779 SBTypeMemberFunction::operator bool() const {
 780   LLDB_INSTRUMENT_VA(this);
 781
 782   return m_opaque_sp.get();
 783 }
 784
 785 const char *SBTypeMemberFunction::GetName() {
 786   LLDB_INSTRUMENT_VA(this);
 787
 788   if (m_opaque_sp)
 789     return m_opaque_sp->GetName().GetCString();
 790   return nullptr;
 791 }
 792
 793 const char *SBTypeMemberFunction::GetDemangledName() {
 794   LLDB_INSTRUMENT_VA(this);
 795
 796   if (m_opaque_sp) {
 797     ConstString mangled_str = m_opaque_sp->GetMangledName();
 798     if (mangled_str) {
 799       Mangled mangled(mangled_str);
 800       return mangled.GetDemangledName().GetCString();
 801     }
 802   }
 803   return nullptr;
 804 }
 805
 806 const char *SBTypeMemberFunction::GetMangledName() {
 807   LLDB_INSTRUMENT_VA(this);
 808
 809   if (m_opaque_sp)
 810     return m_opaque_sp->GetMangledName().GetCString();
 811   return nullptr;
 812 }
 813
 814 SBType SBTypeMemberFunction::GetType() {
 815   LLDB_INSTRUMENT_VA(this);
 816
 817   SBType sb_type;
 818   if (m_opaque_sp) {
 819     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
 820   }
 821   return sb_type;
 822 }
 823
 824 lldb::SBType SBTypeMemberFunction::GetReturnType() {
 825   LLDB_INSTRUMENT_VA(this);
 826
 827   SBType sb_type;
 828   if (m_opaque_sp) {
 829     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
 830   }
 831   return sb_type;
 832 }
 833
 834 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
 835   LLDB_INSTRUMENT_VA(this);
 836
 837   if (m_opaque_sp)
 838     return m_opaque_sp->GetNumArguments();
 839   return 0;
 840 }
 841
 842 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
 843   LLDB_INSTRUMENT_VA(this, i);
 844
 845   SBType sb_type;
 846   if (m_opaque_sp) {
 847     sb_type.SetSP(
 848         lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
 849   }
 850   return sb_type;
 851 }
 852
 853 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
 854   LLDB_INSTRUMENT_VA(this);
 855
 856   if (m_opaque_sp)
 857     return m_opaque_sp->GetKind();
 858   return lldb::eMemberFunctionKindUnknown;
 859 }
 860
 861 bool SBTypeMemberFunction::GetDescription(
 862     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
 863   LLDB_INSTRUMENT_VA(this, description, description_level);
 864
 865   Stream &strm = description.ref();
 866
 867   if (m_opaque_sp)
 868     return m_opaque_sp->GetDescription(strm);
 869
 870   return false;
 871 }
 872
 873 void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) {
 874   m_opaque_sp.reset(type_member_impl);
 875 }
 876
 877 TypeMemberFunctionImpl &SBTypeMemberFunction::ref() {
 878   if (!m_opaque_sp)
 879     m_opaque_sp = std::make_shared<TypeMemberFunctionImpl>();
 880   return *m_opaque_sp.get();
 881 }
 882
 883 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const {
 884   return *m_opaque_sp.get();
 885 }