lldb/source/API/SBType.cpp

   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 }