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 bool SBType::IsAggregateType() { 277 LLDB_INSTRUMENT_VA(this); 278 279 if (!IsValid()) 280 return false; 281 return m_opaque_sp->GetCompilerType(true).IsAggregateType(); 282 } 283 284 lldb::SBType SBType::GetFunctionReturnType() { 285 LLDB_INSTRUMENT_VA(this); 286 287 if (IsValid()) { 288 CompilerType return_type( 289 m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); 290 if (return_type.IsValid()) 291 return SBType(return_type); 292 } 293 return lldb::SBType(); 294 } 295 296 lldb::SBTypeList SBType::GetFunctionArgumentTypes() { 297 LLDB_INSTRUMENT_VA(this); 298 299 SBTypeList sb_type_list; 300 if (IsValid()) { 301 CompilerType func_type(m_opaque_sp->GetCompilerType(true)); 302 size_t count = func_type.GetNumberOfFunctionArguments(); 303 for (size_t i = 0; i < count; i++) { 304 sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i))); 305 } 306 } 307 return sb_type_list; 308 } 309 310 uint32_t SBType::GetNumberOfMemberFunctions() { 311 LLDB_INSTRUMENT_VA(this); 312 313 if (IsValid()) { 314 return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions(); 315 } 316 return 0; 317 } 318 319 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) { 320 LLDB_INSTRUMENT_VA(this, idx); 321 322 SBTypeMemberFunction sb_func_type; 323 if (IsValid()) 324 sb_func_type.reset(new TypeMemberFunctionImpl( 325 m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx))); 326 return sb_func_type; 327 } 328 329 lldb::SBType SBType::GetUnqualifiedType() { 330 LLDB_INSTRUMENT_VA(this); 331 332 if (!IsValid()) 333 return SBType(); 334 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))); 335 } 336 337 lldb::SBType SBType::GetCanonicalType() { 338 LLDB_INSTRUMENT_VA(this); 339 340 if (IsValid()) 341 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))); 342 return SBType(); 343 } 344 345 SBType SBType::GetEnumerationIntegerType() { 346 LLDB_INSTRUMENT_VA(this); 347 348 if (IsValid()) { 349 return SBType( 350 m_opaque_sp->GetCompilerType(true).GetEnumerationIntegerType()); 351 } 352 return SBType(); 353 } 354 355 lldb::BasicType SBType::GetBasicType() { 356 LLDB_INSTRUMENT_VA(this); 357 358 if (IsValid()) 359 return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration(); 360 return eBasicTypeInvalid; 361 } 362 363 SBType SBType::GetBasicType(lldb::BasicType basic_type) { 364 LLDB_INSTRUMENT_VA(this, basic_type); 365 366 if (IsValid() && m_opaque_sp->IsValid()) 367 return SBType( 368 m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)); 369 return SBType(); 370 } 371 372 uint32_t SBType::GetNumberOfDirectBaseClasses() { 373 LLDB_INSTRUMENT_VA(this); 374 375 if (IsValid()) 376 return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses(); 377 return 0; 378 } 379 380 uint32_t SBType::GetNumberOfVirtualBaseClasses() { 381 LLDB_INSTRUMENT_VA(this); 382 383 if (IsValid()) 384 return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses(); 385 return 0; 386 } 387 388 uint32_t SBType::GetNumberOfFields() { 389 LLDB_INSTRUMENT_VA(this); 390 391 if (IsValid()) 392 return m_opaque_sp->GetCompilerType(true).GetNumFields(); 393 return 0; 394 } 395 396 bool SBType::GetDescription(SBStream &description, 397 lldb::DescriptionLevel description_level) { 398 LLDB_INSTRUMENT_VA(this, description, description_level); 399 400 Stream &strm = description.ref(); 401 402 if (m_opaque_sp) { 403 m_opaque_sp->GetDescription(strm, description_level); 404 } else 405 strm.PutCString("No value"); 406 407 return true; 408 } 409 410 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { 411 LLDB_INSTRUMENT_VA(this, idx); 412 413 SBTypeMember sb_type_member; 414 if (IsValid()) { 415 uint32_t bit_offset = 0; 416 CompilerType base_class_type = 417 m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex( 418 idx, &bit_offset); 419 if (base_class_type.IsValid()) 420 sb_type_member.reset(new TypeMemberImpl( 421 TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); 422 } 423 return sb_type_member; 424 } 425 426 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { 427 LLDB_INSTRUMENT_VA(this, idx); 428 429 SBTypeMember sb_type_member; 430 if (IsValid()) { 431 uint32_t bit_offset = 0; 432 CompilerType base_class_type = 433 m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex( 434 idx, &bit_offset); 435 if (base_class_type.IsValid()) 436 sb_type_member.reset(new TypeMemberImpl( 437 TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); 438 } 439 return sb_type_member; 440 } 441 442 SBTypeEnumMemberList SBType::GetEnumMembers() { 443 LLDB_INSTRUMENT_VA(this); 444 445 SBTypeEnumMemberList sb_enum_member_list; 446 if (IsValid()) { 447 CompilerType this_type(m_opaque_sp->GetCompilerType(true)); 448 if (this_type.IsValid()) { 449 this_type.ForEachEnumerator([&sb_enum_member_list]( 450 const CompilerType &integer_type, 451 ConstString name, 452 const llvm::APSInt &value) -> bool { 453 SBTypeEnumMember enum_member( 454 lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl( 455 lldb::TypeImplSP(new TypeImpl(integer_type)), name, value))); 456 sb_enum_member_list.Append(enum_member); 457 return true; // Keep iterating 458 }); 459 } 460 } 461 return sb_enum_member_list; 462 } 463 464 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { 465 LLDB_INSTRUMENT_VA(this, idx); 466 467 SBTypeMember sb_type_member; 468 if (IsValid()) { 469 CompilerType this_type(m_opaque_sp->GetCompilerType(false)); 470 if (this_type.IsValid()) { 471 uint64_t bit_offset = 0; 472 uint32_t bitfield_bit_size = 0; 473 bool is_bitfield = false; 474 std::string name_sstr; 475 CompilerType field_type(this_type.GetFieldAtIndex( 476 idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield)); 477 if (field_type.IsValid()) { 478 ConstString name; 479 if (!name_sstr.empty()) 480 name.SetCString(name_sstr.c_str()); 481 sb_type_member.reset( 482 new TypeMemberImpl(TypeImplSP(new TypeImpl(field_type)), bit_offset, 483 name, bitfield_bit_size, is_bitfield)); 484 } 485 } 486 } 487 return sb_type_member; 488 } 489 490 bool SBType::IsTypeComplete() { 491 LLDB_INSTRUMENT_VA(this); 492 493 if (!IsValid()) 494 return false; 495 return m_opaque_sp->GetCompilerType(false).IsCompleteType(); 496 } 497 498 uint32_t SBType::GetTypeFlags() { 499 LLDB_INSTRUMENT_VA(this); 500 501 if (!IsValid()) 502 return 0; 503 return m_opaque_sp->GetCompilerType(true).GetTypeInfo(); 504 } 505 506 lldb::SBModule SBType::GetModule() { 507 LLDB_INSTRUMENT_VA(this); 508 509 lldb::SBModule sb_module; 510 if (!IsValid()) 511 return sb_module; 512 513 sb_module.SetSP(m_opaque_sp->GetModule()); 514 return sb_module; 515 } 516 517 const char *SBType::GetName() { 518 LLDB_INSTRUMENT_VA(this); 519 520 if (!IsValid()) 521 return ""; 522 return m_opaque_sp->GetName().GetCString(); 523 } 524 525 const char *SBType::GetDisplayTypeName() { 526 LLDB_INSTRUMENT_VA(this); 527 528 if (!IsValid()) 529 return ""; 530 return m_opaque_sp->GetDisplayTypeName().GetCString(); 531 } 532 533 lldb::TypeClass SBType::GetTypeClass() { 534 LLDB_INSTRUMENT_VA(this); 535 536 if (IsValid()) 537 return m_opaque_sp->GetCompilerType(true).GetTypeClass(); 538 return lldb::eTypeClassInvalid; 539 } 540 541 uint32_t SBType::GetNumberOfTemplateArguments() { 542 LLDB_INSTRUMENT_VA(this); 543 544 if (IsValid()) 545 return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments( 546 /*expand_pack=*/true); 547 return 0; 548 } 549 550 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { 551 LLDB_INSTRUMENT_VA(this, idx); 552 553 if (!IsValid()) 554 return SBType(); 555 556 CompilerType type; 557 const bool expand_pack = true; 558 switch(GetTemplateArgumentKind(idx)) { 559 case eTemplateArgumentKindType: 560 type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument( 561 idx, expand_pack); 562 break; 563 case eTemplateArgumentKindIntegral: 564 type = m_opaque_sp->GetCompilerType(false) 565 .GetIntegralTemplateArgument(idx, expand_pack) 566 ->type; 567 break; 568 default: 569 break; 570 } 571 if (type.IsValid()) 572 return SBType(type); 573 return SBType(); 574 } 575 576 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { 577 LLDB_INSTRUMENT_VA(this, idx); 578 579 if (IsValid()) 580 return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind( 581 idx, /*expand_pack=*/true); 582 return eTemplateArgumentKindNull; 583 } 584 585 SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) { 586 LLDB_INSTRUMENT_VA(this); 587 } 588 589 SBTypeList::SBTypeList(const SBTypeList &rhs) 590 : m_opaque_up(new TypeListImpl()) { 591 LLDB_INSTRUMENT_VA(this, rhs); 592 593 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); 594 i < rhs_size; i++) 595 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); 596 } 597 598 bool SBTypeList::IsValid() { 599 LLDB_INSTRUMENT_VA(this); 600 return this->operator bool(); 601 } 602 SBTypeList::operator bool() const { 603 LLDB_INSTRUMENT_VA(this); 604 605 return (m_opaque_up != nullptr); 606 } 607 608 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { 609 LLDB_INSTRUMENT_VA(this, rhs); 610 611 if (this != &rhs) { 612 m_opaque_up = std::make_unique<TypeListImpl>(); 613 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); 614 i < rhs_size; i++) 615 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); 616 } 617 return *this; 618 } 619 620 void SBTypeList::Append(SBType type) { 621 LLDB_INSTRUMENT_VA(this, type); 622 623 if (type.IsValid()) 624 m_opaque_up->Append(type.m_opaque_sp); 625 } 626 627 SBType SBTypeList::GetTypeAtIndex(uint32_t index) { 628 LLDB_INSTRUMENT_VA(this, index); 629 630 if (m_opaque_up) 631 return SBType(m_opaque_up->GetTypeAtIndex(index)); 632 return SBType(); 633 } 634 635 uint32_t SBTypeList::GetSize() { 636 LLDB_INSTRUMENT_VA(this); 637 638 return m_opaque_up->GetSize(); 639 } 640 641 SBTypeList::~SBTypeList() = default; 642 643 SBTypeMember::SBTypeMember() { LLDB_INSTRUMENT_VA(this); } 644 645 SBTypeMember::~SBTypeMember() = default; 646 647 SBTypeMember::SBTypeMember(const SBTypeMember &rhs) { 648 LLDB_INSTRUMENT_VA(this, rhs); 649 650 if (this != &rhs) { 651 if (rhs.IsValid()) 652 m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref()); 653 } 654 } 655 656 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { 657 LLDB_INSTRUMENT_VA(this, rhs); 658 659 if (this != &rhs) { 660 if (rhs.IsValid()) 661 m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref()); 662 } 663 return *this; 664 } 665 666 bool SBTypeMember::IsValid() const { 667 LLDB_INSTRUMENT_VA(this); 668 return this->operator bool(); 669 } 670 SBTypeMember::operator bool() const { 671 LLDB_INSTRUMENT_VA(this); 672 673 return m_opaque_up.get(); 674 } 675 676 const char *SBTypeMember::GetName() { 677 LLDB_INSTRUMENT_VA(this); 678 679 if (m_opaque_up) 680 return m_opaque_up->GetName().GetCString(); 681 return nullptr; 682 } 683 684 SBType SBTypeMember::GetType() { 685 LLDB_INSTRUMENT_VA(this); 686 687 SBType sb_type; 688 if (m_opaque_up) { 689 sb_type.SetSP(m_opaque_up->GetTypeImpl()); 690 } 691 return sb_type; 692 } 693 694 uint64_t SBTypeMember::GetOffsetInBytes() { 695 LLDB_INSTRUMENT_VA(this); 696 697 if (m_opaque_up) 698 return m_opaque_up->GetBitOffset() / 8u; 699 return 0; 700 } 701 702 uint64_t SBTypeMember::GetOffsetInBits() { 703 LLDB_INSTRUMENT_VA(this); 704 705 if (m_opaque_up) 706 return m_opaque_up->GetBitOffset(); 707 return 0; 708 } 709 710 bool SBTypeMember::IsBitfield() { 711 LLDB_INSTRUMENT_VA(this); 712 713 if (m_opaque_up) 714 return m_opaque_up->GetIsBitfield(); 715 return false; 716 } 717 718 uint32_t SBTypeMember::GetBitfieldSizeInBits() { 719 LLDB_INSTRUMENT_VA(this); 720 721 if (m_opaque_up) 722 return m_opaque_up->GetBitfieldBitSize(); 723 return 0; 724 } 725 726 bool SBTypeMember::GetDescription(lldb::SBStream &description, 727 lldb::DescriptionLevel description_level) { 728 LLDB_INSTRUMENT_VA(this, description, description_level); 729 730 Stream &strm = description.ref(); 731 732 if (m_opaque_up) { 733 const uint32_t bit_offset = m_opaque_up->GetBitOffset(); 734 const uint32_t byte_offset = bit_offset / 8u; 735 const uint32_t byte_bit_offset = bit_offset % 8u; 736 const char *name = m_opaque_up->GetName().GetCString(); 737 if (byte_bit_offset) 738 strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset); 739 else 740 strm.Printf("+%u: (", byte_offset); 741 742 TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl()); 743 if (type_impl_sp) 744 type_impl_sp->GetDescription(strm, description_level); 745 746 strm.Printf(") %s", name); 747 if (m_opaque_up->GetIsBitfield()) { 748 const uint32_t bitfield_bit_size = m_opaque_up->GetBitfieldBitSize(); 749 strm.Printf(" : %u", bitfield_bit_size); 750 } 751 } else { 752 strm.PutCString("No value"); 753 } 754 return true; 755 } 756 757 void SBTypeMember::reset(TypeMemberImpl *type_member_impl) { 758 m_opaque_up.reset(type_member_impl); 759 } 760 761 TypeMemberImpl &SBTypeMember::ref() { 762 if (m_opaque_up == nullptr) 763 m_opaque_up = std::make_unique<TypeMemberImpl>(); 764 return *m_opaque_up; 765 } 766 767 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; } 768 769 SBTypeMemberFunction::SBTypeMemberFunction() { LLDB_INSTRUMENT_VA(this); } 770 771 SBTypeMemberFunction::~SBTypeMemberFunction() = default; 772 773 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs) 774 : m_opaque_sp(rhs.m_opaque_sp) { 775 LLDB_INSTRUMENT_VA(this, rhs); 776 } 777 778 lldb::SBTypeMemberFunction &SBTypeMemberFunction:: 779 operator=(const lldb::SBTypeMemberFunction &rhs) { 780 LLDB_INSTRUMENT_VA(this, rhs); 781 782 if (this != &rhs) 783 m_opaque_sp = rhs.m_opaque_sp; 784 return *this; 785 } 786 787 bool SBTypeMemberFunction::IsValid() const { 788 LLDB_INSTRUMENT_VA(this); 789 return this->operator bool(); 790 } 791 SBTypeMemberFunction::operator bool() const { 792 LLDB_INSTRUMENT_VA(this); 793 794 return m_opaque_sp.get(); 795 } 796 797 const char *SBTypeMemberFunction::GetName() { 798 LLDB_INSTRUMENT_VA(this); 799 800 if (m_opaque_sp) 801 return m_opaque_sp->GetName().GetCString(); 802 return nullptr; 803 } 804 805 const char *SBTypeMemberFunction::GetDemangledName() { 806 LLDB_INSTRUMENT_VA(this); 807 808 if (m_opaque_sp) { 809 ConstString mangled_str = m_opaque_sp->GetMangledName(); 810 if (mangled_str) { 811 Mangled mangled(mangled_str); 812 return mangled.GetDemangledName().GetCString(); 813 } 814 } 815 return nullptr; 816 } 817 818 const char *SBTypeMemberFunction::GetMangledName() { 819 LLDB_INSTRUMENT_VA(this); 820 821 if (m_opaque_sp) 822 return m_opaque_sp->GetMangledName().GetCString(); 823 return nullptr; 824 } 825 826 SBType SBTypeMemberFunction::GetType() { 827 LLDB_INSTRUMENT_VA(this); 828 829 SBType sb_type; 830 if (m_opaque_sp) { 831 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType()))); 832 } 833 return sb_type; 834 } 835 836 lldb::SBType SBTypeMemberFunction::GetReturnType() { 837 LLDB_INSTRUMENT_VA(this); 838 839 SBType sb_type; 840 if (m_opaque_sp) { 841 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType()))); 842 } 843 return sb_type; 844 } 845 846 uint32_t SBTypeMemberFunction::GetNumberOfArguments() { 847 LLDB_INSTRUMENT_VA(this); 848 849 if (m_opaque_sp) 850 return m_opaque_sp->GetNumArguments(); 851 return 0; 852 } 853 854 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) { 855 LLDB_INSTRUMENT_VA(this, i); 856 857 SBType sb_type; 858 if (m_opaque_sp) { 859 sb_type.SetSP( 860 lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i)))); 861 } 862 return sb_type; 863 } 864 865 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { 866 LLDB_INSTRUMENT_VA(this); 867 868 if (m_opaque_sp) 869 return m_opaque_sp->GetKind(); 870 return lldb::eMemberFunctionKindUnknown; 871 } 872 873 bool SBTypeMemberFunction::GetDescription( 874 lldb::SBStream &description, lldb::DescriptionLevel description_level) { 875 LLDB_INSTRUMENT_VA(this, description, description_level); 876 877 Stream &strm = description.ref(); 878 879 if (m_opaque_sp) 880 return m_opaque_sp->GetDescription(strm); 881 882 return false; 883 } 884 885 void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) { 886 m_opaque_sp.reset(type_member_impl); 887 } 888 889 TypeMemberFunctionImpl &SBTypeMemberFunction::ref() { 890 if (!m_opaque_sp) 891 m_opaque_sp = std::make_shared<TypeMemberFunctionImpl>(); 892 return *m_opaque_sp.get(); 893 } 894 895 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const { 896 return *m_opaque_sp.get(); 897 } 898