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