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