1 //===-- SBType.cpp ----------------------------------------------*- C++ -*-===// 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 "SBReproducerPrivate.h" 11 #include "lldb/API/SBDefines.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/Stream.h" 20 21 #include "llvm/ADT/APSInt.h" 22 23 #include <memory> 24 25 using namespace lldb; 26 using namespace lldb_private; 27 28 SBType::SBType() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); } 29 30 SBType::SBType(const CompilerType &type) 31 : m_opaque_sp(new TypeImpl( 32 CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {} 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) : m_opaque_sp() { 41 LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), 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_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), 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_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), 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_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &), 84 rhs); 85 86 if (this != &rhs) { 87 m_opaque_sp = rhs.m_opaque_sp; 88 } 89 return LLDB_RECORD_RESULT(*this); 90 } 91 92 SBType::~SBType() {} 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_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid); 110 return this->operator bool(); 111 } 112 SBType::operator bool() const { 113 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool); 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_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize); 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_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType); 133 134 if (!IsValid()) 135 return false; 136 return m_opaque_sp->GetCompilerType(true).IsPointerType(); 137 } 138 139 bool SBType::IsArrayType() { 140 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType); 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_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType); 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_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType); 158 159 if (!IsValid()) 160 return false; 161 return m_opaque_sp->GetCompilerType(true).IsReferenceType(); 162 } 163 164 SBType SBType::GetPointerType() { 165 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType); 166 167 if (!IsValid()) 168 return LLDB_RECORD_RESULT(SBType()); 169 170 return LLDB_RECORD_RESULT( 171 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())))); 172 } 173 174 SBType SBType::GetPointeeType() { 175 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType); 176 177 if (!IsValid()) 178 return LLDB_RECORD_RESULT(SBType()); 179 return LLDB_RECORD_RESULT( 180 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())))); 181 } 182 183 SBType SBType::GetReferenceType() { 184 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType); 185 186 if (!IsValid()) 187 return LLDB_RECORD_RESULT(SBType()); 188 return LLDB_RECORD_RESULT( 189 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())))); 190 } 191 192 SBType SBType::GetTypedefedType() { 193 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType); 194 195 if (!IsValid()) 196 return LLDB_RECORD_RESULT(SBType()); 197 return LLDB_RECORD_RESULT( 198 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())))); 199 } 200 201 SBType SBType::GetDereferencedType() { 202 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType); 203 204 if (!IsValid()) 205 return LLDB_RECORD_RESULT(SBType()); 206 return LLDB_RECORD_RESULT( 207 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())))); 208 } 209 210 SBType SBType::GetArrayElementType() { 211 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType); 212 213 if (!IsValid()) 214 return LLDB_RECORD_RESULT(SBType()); 215 return LLDB_RECORD_RESULT(SBType(TypeImplSP( 216 new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType())))); 217 } 218 219 SBType SBType::GetArrayType(uint64_t size) { 220 LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size); 221 222 if (!IsValid()) 223 return LLDB_RECORD_RESULT(SBType()); 224 return LLDB_RECORD_RESULT(SBType(TypeImplSP( 225 new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size))))); 226 } 227 228 SBType SBType::GetVectorElementType() { 229 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType); 230 231 SBType type_sb; 232 if (IsValid()) { 233 CompilerType vector_element_type; 234 if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type, 235 nullptr)) 236 type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type))); 237 } 238 return LLDB_RECORD_RESULT(type_sb); 239 } 240 241 bool SBType::IsFunctionType() { 242 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType); 243 244 if (!IsValid()) 245 return false; 246 return m_opaque_sp->GetCompilerType(true).IsFunctionType(); 247 } 248 249 bool SBType::IsPolymorphicClass() { 250 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass); 251 252 if (!IsValid()) 253 return false; 254 return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass(); 255 } 256 257 bool SBType::IsTypedefType() { 258 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType); 259 260 if (!IsValid()) 261 return false; 262 return m_opaque_sp->GetCompilerType(true).IsTypedefType(); 263 } 264 265 bool SBType::IsAnonymousType() { 266 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType); 267 268 if (!IsValid()) 269 return false; 270 return m_opaque_sp->GetCompilerType(true).IsAnonymousType(); 271 } 272 273 lldb::SBType SBType::GetFunctionReturnType() { 274 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType); 275 276 if (IsValid()) { 277 CompilerType return_type( 278 m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); 279 if (return_type.IsValid()) 280 return LLDB_RECORD_RESULT(SBType(return_type)); 281 } 282 return LLDB_RECORD_RESULT(lldb::SBType()); 283 } 284 285 lldb::SBTypeList SBType::GetFunctionArgumentTypes() { 286 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType, 287 GetFunctionArgumentTypes); 288 289 SBTypeList sb_type_list; 290 if (IsValid()) { 291 CompilerType func_type(m_opaque_sp->GetCompilerType(true)); 292 size_t count = func_type.GetNumberOfFunctionArguments(); 293 for (size_t i = 0; i < count; i++) { 294 sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i))); 295 } 296 } 297 return LLDB_RECORD_RESULT(sb_type_list); 298 } 299 300 uint32_t SBType::GetNumberOfMemberFunctions() { 301 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions); 302 303 if (IsValid()) { 304 return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions(); 305 } 306 return 0; 307 } 308 309 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) { 310 LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType, 311 GetMemberFunctionAtIndex, (uint32_t), idx); 312 313 SBTypeMemberFunction sb_func_type; 314 if (IsValid()) 315 sb_func_type.reset(new TypeMemberFunctionImpl( 316 m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx))); 317 return LLDB_RECORD_RESULT(sb_func_type); 318 } 319 320 lldb::SBType SBType::GetUnqualifiedType() { 321 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType); 322 323 if (!IsValid()) 324 return LLDB_RECORD_RESULT(SBType()); 325 return LLDB_RECORD_RESULT( 326 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())))); 327 } 328 329 lldb::SBType SBType::GetCanonicalType() { 330 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType); 331 332 if (IsValid()) 333 return LLDB_RECORD_RESULT( 334 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())))); 335 return LLDB_RECORD_RESULT(SBType()); 336 } 337 338 lldb::BasicType SBType::GetBasicType() { 339 LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType); 340 341 if (IsValid()) 342 return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration(); 343 return eBasicTypeInvalid; 344 } 345 346 SBType SBType::GetBasicType(lldb::BasicType basic_type) { 347 LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType), 348 basic_type); 349 350 if (IsValid() && m_opaque_sp->IsValid()) 351 return LLDB_RECORD_RESULT(SBType( 352 m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type))); 353 return LLDB_RECORD_RESULT(SBType()); 354 } 355 356 uint32_t SBType::GetNumberOfDirectBaseClasses() { 357 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses); 358 359 if (IsValid()) 360 return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses(); 361 return 0; 362 } 363 364 uint32_t SBType::GetNumberOfVirtualBaseClasses() { 365 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses); 366 367 if (IsValid()) 368 return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses(); 369 return 0; 370 } 371 372 uint32_t SBType::GetNumberOfFields() { 373 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields); 374 375 if (IsValid()) 376 return m_opaque_sp->GetCompilerType(true).GetNumFields(); 377 return 0; 378 } 379 380 bool SBType::GetDescription(SBStream &description, 381 lldb::DescriptionLevel description_level) { 382 LLDB_RECORD_METHOD(bool, SBType, GetDescription, 383 (lldb::SBStream &, lldb::DescriptionLevel), description, 384 description_level); 385 386 Stream &strm = description.ref(); 387 388 if (m_opaque_sp) { 389 m_opaque_sp->GetDescription(strm, description_level); 390 } else 391 strm.PutCString("No value"); 392 393 return true; 394 } 395 396 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { 397 LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, 398 (uint32_t), idx); 399 400 SBTypeMember sb_type_member; 401 if (IsValid()) { 402 uint32_t bit_offset = 0; 403 CompilerType base_class_type = 404 m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex( 405 idx, &bit_offset); 406 if (base_class_type.IsValid()) 407 sb_type_member.reset(new TypeMemberImpl( 408 TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); 409 } 410 return LLDB_RECORD_RESULT(sb_type_member); 411 } 412 413 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { 414 LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, 415 (uint32_t), idx); 416 417 SBTypeMember sb_type_member; 418 if (IsValid()) { 419 uint32_t bit_offset = 0; 420 CompilerType base_class_type = 421 m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex( 422 idx, &bit_offset); 423 if (base_class_type.IsValid()) 424 sb_type_member.reset(new TypeMemberImpl( 425 TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); 426 } 427 return LLDB_RECORD_RESULT(sb_type_member); 428 } 429 430 SBTypeEnumMemberList SBType::GetEnumMembers() { 431 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType, 432 GetEnumMembers); 433 434 SBTypeEnumMemberList sb_enum_member_list; 435 if (IsValid()) { 436 CompilerType this_type(m_opaque_sp->GetCompilerType(true)); 437 if (this_type.IsValid()) { 438 this_type.ForEachEnumerator([&sb_enum_member_list]( 439 const CompilerType &integer_type, 440 ConstString name, 441 const llvm::APSInt &value) -> bool { 442 SBTypeEnumMember enum_member( 443 lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl( 444 lldb::TypeImplSP(new TypeImpl(integer_type)), name, value))); 445 sb_enum_member_list.Append(enum_member); 446 return true; // Keep iterating 447 }); 448 } 449 } 450 return LLDB_RECORD_RESULT(sb_enum_member_list); 451 } 452 453 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { 454 LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t), 455 idx); 456 457 SBTypeMember sb_type_member; 458 if (IsValid()) { 459 CompilerType this_type(m_opaque_sp->GetCompilerType(false)); 460 if (this_type.IsValid()) { 461 uint64_t bit_offset = 0; 462 uint32_t bitfield_bit_size = 0; 463 bool is_bitfield = false; 464 std::string name_sstr; 465 CompilerType field_type(this_type.GetFieldAtIndex( 466 idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield)); 467 if (field_type.IsValid()) { 468 ConstString name; 469 if (!name_sstr.empty()) 470 name.SetCString(name_sstr.c_str()); 471 sb_type_member.reset( 472 new TypeMemberImpl(TypeImplSP(new TypeImpl(field_type)), bit_offset, 473 name, bitfield_bit_size, is_bitfield)); 474 } 475 } 476 } 477 return LLDB_RECORD_RESULT(sb_type_member); 478 } 479 480 bool SBType::IsTypeComplete() { 481 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete); 482 483 if (!IsValid()) 484 return false; 485 return m_opaque_sp->GetCompilerType(false).IsCompleteType(); 486 } 487 488 uint32_t SBType::GetTypeFlags() { 489 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags); 490 491 if (!IsValid()) 492 return 0; 493 return m_opaque_sp->GetCompilerType(true).GetTypeInfo(); 494 } 495 496 const char *SBType::GetName() { 497 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName); 498 499 if (!IsValid()) 500 return ""; 501 return m_opaque_sp->GetName().GetCString(); 502 } 503 504 const char *SBType::GetDisplayTypeName() { 505 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName); 506 507 if (!IsValid()) 508 return ""; 509 return m_opaque_sp->GetDisplayTypeName().GetCString(); 510 } 511 512 lldb::TypeClass SBType::GetTypeClass() { 513 LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass); 514 515 if (IsValid()) 516 return m_opaque_sp->GetCompilerType(true).GetTypeClass(); 517 return lldb::eTypeClassInvalid; 518 } 519 520 uint32_t SBType::GetNumberOfTemplateArguments() { 521 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments); 522 523 if (IsValid()) 524 return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments(); 525 return 0; 526 } 527 528 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { 529 LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t), 530 idx); 531 532 if (!IsValid()) 533 return LLDB_RECORD_RESULT(SBType()); 534 535 CompilerType type; 536 switch(GetTemplateArgumentKind(idx)) { 537 case eTemplateArgumentKindType: 538 type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx); 539 break; 540 case eTemplateArgumentKindIntegral: 541 type = m_opaque_sp->GetCompilerType(false) 542 .GetIntegralTemplateArgument(idx) 543 ->type; 544 break; 545 default: 546 break; 547 } 548 if (type.IsValid()) 549 return LLDB_RECORD_RESULT(SBType(type)); 550 return LLDB_RECORD_RESULT(SBType()); 551 } 552 553 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { 554 LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType, 555 GetTemplateArgumentKind, (uint32_t), idx); 556 557 if (IsValid()) 558 return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx); 559 return eTemplateArgumentKindNull; 560 } 561 562 SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) { 563 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList); 564 } 565 566 SBTypeList::SBTypeList(const SBTypeList &rhs) 567 : m_opaque_up(new TypeListImpl()) { 568 LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs); 569 570 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); 571 i < rhs_size; i++) 572 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); 573 } 574 575 bool SBTypeList::IsValid() { 576 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid); 577 return this->operator bool(); 578 } 579 SBTypeList::operator bool() const { 580 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool); 581 582 return (m_opaque_up != nullptr); 583 } 584 585 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { 586 LLDB_RECORD_METHOD(lldb::SBTypeList &, 587 SBTypeList, operator=,(const lldb::SBTypeList &), rhs); 588 589 if (this != &rhs) { 590 m_opaque_up.reset(new TypeListImpl()); 591 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); 592 i < rhs_size; i++) 593 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); 594 } 595 return LLDB_RECORD_RESULT(*this); 596 } 597 598 void SBTypeList::Append(SBType type) { 599 LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type); 600 601 if (type.IsValid()) 602 m_opaque_up->Append(type.m_opaque_sp); 603 } 604 605 SBType SBTypeList::GetTypeAtIndex(uint32_t index) { 606 LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t), 607 index); 608 609 if (m_opaque_up) 610 return LLDB_RECORD_RESULT(SBType(m_opaque_up->GetTypeAtIndex(index))); 611 return LLDB_RECORD_RESULT(SBType()); 612 } 613 614 uint32_t SBTypeList::GetSize() { 615 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize); 616 617 return m_opaque_up->GetSize(); 618 } 619 620 SBTypeList::~SBTypeList() {} 621 622 SBTypeMember::SBTypeMember() : m_opaque_up() { 623 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember); 624 } 625 626 SBTypeMember::~SBTypeMember() {} 627 628 SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() { 629 LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs); 630 631 if (this != &rhs) { 632 if (rhs.IsValid()) 633 m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); 634 } 635 } 636 637 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { 638 LLDB_RECORD_METHOD(lldb::SBTypeMember &, 639 SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs); 640 641 if (this != &rhs) { 642 if (rhs.IsValid()) 643 m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); 644 } 645 return LLDB_RECORD_RESULT(*this); 646 } 647 648 bool SBTypeMember::IsValid() const { 649 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid); 650 return this->operator bool(); 651 } 652 SBTypeMember::operator bool() const { 653 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool); 654 655 return m_opaque_up.get(); 656 } 657 658 const char *SBTypeMember::GetName() { 659 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName); 660 661 if (m_opaque_up) 662 return m_opaque_up->GetName().GetCString(); 663 return nullptr; 664 } 665 666 SBType SBTypeMember::GetType() { 667 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType); 668 669 SBType sb_type; 670 if (m_opaque_up) { 671 sb_type.SetSP(m_opaque_up->GetTypeImpl()); 672 } 673 return LLDB_RECORD_RESULT(sb_type); 674 } 675 676 uint64_t SBTypeMember::GetOffsetInBytes() { 677 LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes); 678 679 if (m_opaque_up) 680 return m_opaque_up->GetBitOffset() / 8u; 681 return 0; 682 } 683 684 uint64_t SBTypeMember::GetOffsetInBits() { 685 LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits); 686 687 if (m_opaque_up) 688 return m_opaque_up->GetBitOffset(); 689 return 0; 690 } 691 692 bool SBTypeMember::IsBitfield() { 693 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield); 694 695 if (m_opaque_up) 696 return m_opaque_up->GetIsBitfield(); 697 return false; 698 } 699 700 uint32_t SBTypeMember::GetBitfieldSizeInBits() { 701 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits); 702 703 if (m_opaque_up) 704 return m_opaque_up->GetBitfieldBitSize(); 705 return 0; 706 } 707 708 bool SBTypeMember::GetDescription(lldb::SBStream &description, 709 lldb::DescriptionLevel description_level) { 710 LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription, 711 (lldb::SBStream &, lldb::DescriptionLevel), description, 712 description_level); 713 714 Stream &strm = description.ref(); 715 716 if (m_opaque_up) { 717 const uint32_t bit_offset = m_opaque_up->GetBitOffset(); 718 const uint32_t byte_offset = bit_offset / 8u; 719 const uint32_t byte_bit_offset = bit_offset % 8u; 720 const char *name = m_opaque_up->GetName().GetCString(); 721 if (byte_bit_offset) 722 strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset); 723 else 724 strm.Printf("+%u: (", byte_offset); 725 726 TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl()); 727 if (type_impl_sp) 728 type_impl_sp->GetDescription(strm, description_level); 729 730 strm.Printf(") %s", name); 731 if (m_opaque_up->GetIsBitfield()) { 732 const uint32_t bitfield_bit_size = m_opaque_up->GetBitfieldBitSize(); 733 strm.Printf(" : %u", bitfield_bit_size); 734 } 735 } else { 736 strm.PutCString("No value"); 737 } 738 return true; 739 } 740 741 void SBTypeMember::reset(TypeMemberImpl *type_member_impl) { 742 m_opaque_up.reset(type_member_impl); 743 } 744 745 TypeMemberImpl &SBTypeMember::ref() { 746 if (m_opaque_up == nullptr) 747 m_opaque_up.reset(new TypeMemberImpl()); 748 return *m_opaque_up; 749 } 750 751 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; } 752 753 SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() { 754 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction); 755 } 756 757 SBTypeMemberFunction::~SBTypeMemberFunction() {} 758 759 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs) 760 : m_opaque_sp(rhs.m_opaque_sp) { 761 LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction, 762 (const lldb::SBTypeMemberFunction &), rhs); 763 } 764 765 lldb::SBTypeMemberFunction &SBTypeMemberFunction:: 766 operator=(const lldb::SBTypeMemberFunction &rhs) { 767 LLDB_RECORD_METHOD( 768 lldb::SBTypeMemberFunction &, 769 SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &), 770 rhs); 771 772 if (this != &rhs) 773 m_opaque_sp = rhs.m_opaque_sp; 774 return LLDB_RECORD_RESULT(*this); 775 } 776 777 bool SBTypeMemberFunction::IsValid() const { 778 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid); 779 return this->operator bool(); 780 } 781 SBTypeMemberFunction::operator bool() const { 782 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool); 783 784 return m_opaque_sp.get(); 785 } 786 787 const char *SBTypeMemberFunction::GetName() { 788 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName); 789 790 if (m_opaque_sp) 791 return m_opaque_sp->GetName().GetCString(); 792 return nullptr; 793 } 794 795 const char *SBTypeMemberFunction::GetDemangledName() { 796 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, 797 GetDemangledName); 798 799 if (m_opaque_sp) { 800 ConstString mangled_str = m_opaque_sp->GetMangledName(); 801 if (mangled_str) { 802 Mangled mangled(mangled_str, true); 803 return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString(); 804 } 805 } 806 return nullptr; 807 } 808 809 const char *SBTypeMemberFunction::GetMangledName() { 810 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, 811 GetMangledName); 812 813 if (m_opaque_sp) 814 return m_opaque_sp->GetMangledName().GetCString(); 815 return nullptr; 816 } 817 818 SBType SBTypeMemberFunction::GetType() { 819 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType); 820 821 SBType sb_type; 822 if (m_opaque_sp) { 823 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType()))); 824 } 825 return LLDB_RECORD_RESULT(sb_type); 826 } 827 828 lldb::SBType SBTypeMemberFunction::GetReturnType() { 829 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType); 830 831 SBType sb_type; 832 if (m_opaque_sp) { 833 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType()))); 834 } 835 return LLDB_RECORD_RESULT(sb_type); 836 } 837 838 uint32_t SBTypeMemberFunction::GetNumberOfArguments() { 839 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction, 840 GetNumberOfArguments); 841 842 if (m_opaque_sp) 843 return m_opaque_sp->GetNumArguments(); 844 return 0; 845 } 846 847 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) { 848 LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex, 849 (uint32_t), i); 850 851 SBType sb_type; 852 if (m_opaque_sp) { 853 sb_type.SetSP( 854 lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i)))); 855 } 856 return LLDB_RECORD_RESULT(sb_type); 857 } 858 859 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { 860 LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction, 861 GetKind); 862 863 if (m_opaque_sp) 864 return m_opaque_sp->GetKind(); 865 return lldb::eMemberFunctionKindUnknown; 866 } 867 868 bool SBTypeMemberFunction::GetDescription( 869 lldb::SBStream &description, lldb::DescriptionLevel description_level) { 870 LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription, 871 (lldb::SBStream &, lldb::DescriptionLevel), description, 872 description_level); 873 874 Stream &strm = description.ref(); 875 876 if (m_opaque_sp) 877 return m_opaque_sp->GetDescription(strm); 878 879 return false; 880 } 881 882 void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) { 883 m_opaque_sp.reset(type_member_impl); 884 } 885 886 TypeMemberFunctionImpl &SBTypeMemberFunction::ref() { 887 if (!m_opaque_sp) 888 m_opaque_sp = std::make_shared<TypeMemberFunctionImpl>(); 889 return *m_opaque_sp.get(); 890 } 891 892 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const { 893 return *m_opaque_sp.get(); 894 } 895 896 namespace lldb_private { 897 namespace repro { 898 899 template <> 900 void RegisterMethods<SBType>(Registry &R) { 901 LLDB_REGISTER_CONSTRUCTOR(SBType, ()); 902 LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &)); 903 LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &)); 904 LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &)); 905 LLDB_REGISTER_METHOD(lldb::SBType &, 906 SBType, operator=,(const lldb::SBType &)); 907 LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ()); 908 LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ()); 909 LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ()); 910 LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ()); 911 LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ()); 912 LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ()); 913 LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ()); 914 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ()); 915 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ()); 916 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ()); 917 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ()); 918 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ()); 919 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ()); 920 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t)); 921 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ()); 922 LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ()); 923 LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ()); 924 LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ()); 925 LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ()); 926 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ()); 927 LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes, 928 ()); 929 LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ()); 930 LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType, 931 GetMemberFunctionAtIndex, (uint32_t)); 932 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ()); 933 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ()); 934 LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ()); 935 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType)); 936 LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ()); 937 LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ()); 938 LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ()); 939 LLDB_REGISTER_METHOD(bool, SBType, GetDescription, 940 (lldb::SBStream &, lldb::DescriptionLevel)); 941 LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, 942 (uint32_t)); 943 LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, 944 (uint32_t)); 945 LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers, 946 ()); 947 LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, 948 (uint32_t)); 949 LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ()); 950 LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ()); 951 LLDB_REGISTER_METHOD(const char *, SBType, GetName, ()); 952 LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ()); 953 LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ()); 954 LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ()); 955 LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, 956 (uint32_t)); 957 LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType, 958 GetTemplateArgumentKind, (uint32_t)); 959 LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ()); 960 LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &)); 961 LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ()); 962 LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ()); 963 LLDB_REGISTER_METHOD(lldb::SBTypeList &, 964 SBTypeList, operator=,(const lldb::SBTypeList &)); 965 LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType)); 966 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t)); 967 LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ()); 968 LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ()); 969 LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &)); 970 LLDB_REGISTER_METHOD(lldb::SBTypeMember &, 971 SBTypeMember, operator=,(const lldb::SBTypeMember &)); 972 LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ()); 973 LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ()); 974 LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ()); 975 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ()); 976 LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ()); 977 LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ()); 978 LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ()); 979 LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ()); 980 LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription, 981 (lldb::SBStream &, lldb::DescriptionLevel)); 982 LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ()); 983 LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, 984 (const lldb::SBTypeMemberFunction &)); 985 LLDB_REGISTER_METHOD( 986 lldb::SBTypeMemberFunction &, 987 SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &)); 988 LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ()); 989 LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ()); 990 LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ()); 991 LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName, 992 ()); 993 LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName, 994 ()); 995 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ()); 996 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ()); 997 LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments, 998 ()); 999 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, 1000 GetArgumentTypeAtIndex, (uint32_t)); 1001 LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction, 1002 GetKind, ()); 1003 LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription, 1004 (lldb::SBStream &, lldb::DescriptionLevel)); 1005 } 1006 1007 } 1008 } 1009