1 //===-- SBType.cpp ----------------------------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
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"
21 #include "llvm/ADT/APSInt.h"
26 using namespace lldb_private;
28 SBType::SBType() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); }
30 SBType::SBType(const CompilerType &type)
31 : m_opaque_sp(new TypeImpl(
32 CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {}
34 SBType::SBType(const lldb::TypeSP &type_sp)
35 : m_opaque_sp(new TypeImpl(type_sp)) {}
37 SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
38 : m_opaque_sp(type_impl_sp) {}
40 SBType::SBType(const SBType &rhs) : m_opaque_sp() {
41 LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs);
44 m_opaque_sp = rhs.m_opaque_sp;
48 // SBType::SBType (TypeImpl* impl) :
52 bool SBType::operator==(SBType &rhs) {
53 LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
56 return !rhs.IsValid();
61 return *m_opaque_sp.get() == *rhs.m_opaque_sp.get();
64 bool SBType::operator!=(SBType &rhs) {
65 LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
73 return *m_opaque_sp.get() != *rhs.m_opaque_sp.get();
76 lldb::TypeImplSP SBType::GetSP() { return m_opaque_sp; }
78 void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
79 m_opaque_sp = type_impl_sp;
82 SBType &SBType::operator=(const SBType &rhs) {
83 LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
87 m_opaque_sp = rhs.m_opaque_sp;
89 return LLDB_RECORD_RESULT(*this);
94 TypeImpl &SBType::ref() {
95 if (m_opaque_sp.get() == nullptr)
96 m_opaque_sp = std::make_shared<TypeImpl>();
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
104 assert(m_opaque_sp.get());
108 bool SBType::IsValid() const {
109 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
110 return this->operator bool();
112 SBType::operator bool() const {
113 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool);
115 if (m_opaque_sp.get() == nullptr)
118 return m_opaque_sp->IsValid();
121 uint64_t SBType::GetByteSize() {
122 LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize);
125 if (llvm::Optional<uint64_t> size =
126 m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr))
131 bool SBType::IsPointerType() {
132 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType);
136 return m_opaque_sp->GetCompilerType(true).IsPointerType();
139 bool SBType::IsArrayType() {
140 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType);
144 return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr,
148 bool SBType::IsVectorType() {
149 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType);
153 return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr);
156 bool SBType::IsReferenceType() {
157 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType);
161 return m_opaque_sp->GetCompilerType(true).IsReferenceType();
164 SBType SBType::GetPointerType() {
165 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
168 return LLDB_RECORD_RESULT(SBType());
170 return LLDB_RECORD_RESULT(
171 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))));
174 SBType SBType::GetPointeeType() {
175 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType);
178 return LLDB_RECORD_RESULT(SBType());
179 return LLDB_RECORD_RESULT(
180 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))));
183 SBType SBType::GetReferenceType() {
184 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType);
187 return LLDB_RECORD_RESULT(SBType());
188 return LLDB_RECORD_RESULT(
189 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))));
192 SBType SBType::GetTypedefedType() {
193 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType);
196 return LLDB_RECORD_RESULT(SBType());
197 return LLDB_RECORD_RESULT(
198 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))));
201 SBType SBType::GetDereferencedType() {
202 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType);
205 return LLDB_RECORD_RESULT(SBType());
206 return LLDB_RECORD_RESULT(
207 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))));
210 SBType SBType::GetArrayElementType() {
211 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType);
214 return LLDB_RECORD_RESULT(SBType());
215 return LLDB_RECORD_RESULT(SBType(TypeImplSP(
216 new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType()))));
219 SBType SBType::GetArrayType(uint64_t size) {
220 LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
223 return LLDB_RECORD_RESULT(SBType());
224 return LLDB_RECORD_RESULT(SBType(TypeImplSP(
225 new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size)))));
228 SBType SBType::GetVectorElementType() {
229 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
233 CompilerType vector_element_type;
234 if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type,
236 type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
238 return LLDB_RECORD_RESULT(type_sb);
241 bool SBType::IsFunctionType() {
242 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType);
246 return m_opaque_sp->GetCompilerType(true).IsFunctionType();
249 bool SBType::IsPolymorphicClass() {
250 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass);
254 return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass();
257 bool SBType::IsTypedefType() {
258 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType);
262 return m_opaque_sp->GetCompilerType(true).IsTypedefType();
265 bool SBType::IsAnonymousType() {
266 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
270 return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
273 lldb::SBType SBType::GetFunctionReturnType() {
274 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
277 CompilerType return_type(
278 m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
279 if (return_type.IsValid())
280 return LLDB_RECORD_RESULT(SBType(return_type));
282 return LLDB_RECORD_RESULT(lldb::SBType());
285 lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
286 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType,
287 GetFunctionArgumentTypes);
289 SBTypeList sb_type_list;
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)));
297 return LLDB_RECORD_RESULT(sb_type_list);
300 uint32_t SBType::GetNumberOfMemberFunctions() {
301 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions);
304 return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
309 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
310 LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
311 GetMemberFunctionAtIndex, (uint32_t), idx);
313 SBTypeMemberFunction sb_func_type;
315 sb_func_type.reset(new TypeMemberFunctionImpl(
316 m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
317 return LLDB_RECORD_RESULT(sb_func_type);
320 lldb::SBType SBType::GetUnqualifiedType() {
321 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType);
324 return LLDB_RECORD_RESULT(SBType());
325 return LLDB_RECORD_RESULT(
326 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))));
329 lldb::SBType SBType::GetCanonicalType() {
330 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
333 return LLDB_RECORD_RESULT(
334 SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))));
335 return LLDB_RECORD_RESULT(SBType());
338 lldb::BasicType SBType::GetBasicType() {
339 LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
342 return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
343 return eBasicTypeInvalid;
346 SBType SBType::GetBasicType(lldb::BasicType basic_type) {
347 LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
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());
356 uint32_t SBType::GetNumberOfDirectBaseClasses() {
357 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses);
360 return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
364 uint32_t SBType::GetNumberOfVirtualBaseClasses() {
365 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses);
368 return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
372 uint32_t SBType::GetNumberOfFields() {
373 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields);
376 return m_opaque_sp->GetCompilerType(true).GetNumFields();
380 bool SBType::GetDescription(SBStream &description,
381 lldb::DescriptionLevel description_level) {
382 LLDB_RECORD_METHOD(bool, SBType, GetDescription,
383 (lldb::SBStream &, lldb::DescriptionLevel), description,
386 Stream &strm = description.ref();
389 m_opaque_sp->GetDescription(strm, description_level);
391 strm.PutCString("No value");
396 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
397 LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
400 SBTypeMember sb_type_member;
402 uint32_t bit_offset = 0;
403 CompilerType base_class_type =
404 m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex(
406 if (base_class_type.IsValid())
407 sb_type_member.reset(new TypeMemberImpl(
408 TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
410 return LLDB_RECORD_RESULT(sb_type_member);
413 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
414 LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
417 SBTypeMember sb_type_member;
419 uint32_t bit_offset = 0;
420 CompilerType base_class_type =
421 m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex(
423 if (base_class_type.IsValid())
424 sb_type_member.reset(new TypeMemberImpl(
425 TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
427 return LLDB_RECORD_RESULT(sb_type_member);
430 SBTypeEnumMemberList SBType::GetEnumMembers() {
431 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
434 SBTypeEnumMemberList sb_enum_member_list;
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,
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
450 return LLDB_RECORD_RESULT(sb_enum_member_list);
453 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
454 LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
457 SBTypeMember sb_type_member;
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()) {
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));
477 return LLDB_RECORD_RESULT(sb_type_member);
480 bool SBType::IsTypeComplete() {
481 LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete);
485 return m_opaque_sp->GetCompilerType(false).IsCompleteType();
488 uint32_t SBType::GetTypeFlags() {
489 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags);
493 return m_opaque_sp->GetCompilerType(true).GetTypeInfo();
496 const char *SBType::GetName() {
497 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName);
501 return m_opaque_sp->GetName().GetCString();
504 const char *SBType::GetDisplayTypeName() {
505 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName);
509 return m_opaque_sp->GetDisplayTypeName().GetCString();
512 lldb::TypeClass SBType::GetTypeClass() {
513 LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass);
516 return m_opaque_sp->GetCompilerType(true).GetTypeClass();
517 return lldb::eTypeClassInvalid;
520 uint32_t SBType::GetNumberOfTemplateArguments() {
521 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments);
524 return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
528 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
529 LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
533 return LLDB_RECORD_RESULT(SBType());
536 switch(GetTemplateArgumentKind(idx)) {
537 case eTemplateArgumentKindType:
538 type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx);
540 case eTemplateArgumentKindIntegral:
541 type = m_opaque_sp->GetCompilerType(false)
542 .GetIntegralTemplateArgument(idx)
549 return LLDB_RECORD_RESULT(SBType(type));
550 return LLDB_RECORD_RESULT(SBType());
553 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
554 LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
555 GetTemplateArgumentKind, (uint32_t), idx);
558 return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
559 return eTemplateArgumentKindNull;
562 SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
563 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList);
566 SBTypeList::SBTypeList(const SBTypeList &rhs)
567 : m_opaque_up(new TypeListImpl()) {
568 LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs);
570 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
572 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
575 bool SBTypeList::IsValid() {
576 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid);
577 return this->operator bool();
579 SBTypeList::operator bool() const {
580 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool);
582 return (m_opaque_up != nullptr);
585 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
586 LLDB_RECORD_METHOD(lldb::SBTypeList &,
587 SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
590 m_opaque_up.reset(new TypeListImpl());
591 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
593 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
595 return LLDB_RECORD_RESULT(*this);
598 void SBTypeList::Append(SBType type) {
599 LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
602 m_opaque_up->Append(type.m_opaque_sp);
605 SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
606 LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t),
610 return LLDB_RECORD_RESULT(SBType(m_opaque_up->GetTypeAtIndex(index)));
611 return LLDB_RECORD_RESULT(SBType());
614 uint32_t SBTypeList::GetSize() {
615 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize);
617 return m_opaque_up->GetSize();
620 SBTypeList::~SBTypeList() {}
622 SBTypeMember::SBTypeMember() : m_opaque_up() {
623 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember);
626 SBTypeMember::~SBTypeMember() {}
628 SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() {
629 LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs);
633 m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));
637 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
638 LLDB_RECORD_METHOD(lldb::SBTypeMember &,
639 SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs);
643 m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));
645 return LLDB_RECORD_RESULT(*this);
648 bool SBTypeMember::IsValid() const {
649 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
650 return this->operator bool();
652 SBTypeMember::operator bool() const {
653 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool);
655 return m_opaque_up.get();
658 const char *SBTypeMember::GetName() {
659 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName);
662 return m_opaque_up->GetName().GetCString();
666 SBType SBTypeMember::GetType() {
667 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType);
671 sb_type.SetSP(m_opaque_up->GetTypeImpl());
673 return LLDB_RECORD_RESULT(sb_type);
676 uint64_t SBTypeMember::GetOffsetInBytes() {
677 LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes);
680 return m_opaque_up->GetBitOffset() / 8u;
684 uint64_t SBTypeMember::GetOffsetInBits() {
685 LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits);
688 return m_opaque_up->GetBitOffset();
692 bool SBTypeMember::IsBitfield() {
693 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield);
696 return m_opaque_up->GetIsBitfield();
700 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
701 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits);
704 return m_opaque_up->GetBitfieldBitSize();
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,
714 Stream &strm = description.ref();
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();
722 strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset);
724 strm.Printf("+%u: (", byte_offset);
726 TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl());
728 type_impl_sp->GetDescription(strm, description_level);
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);
736 strm.PutCString("No value");
741 void SBTypeMember::reset(TypeMemberImpl *type_member_impl) {
742 m_opaque_up.reset(type_member_impl);
745 TypeMemberImpl &SBTypeMember::ref() {
746 if (m_opaque_up == nullptr)
747 m_opaque_up.reset(new TypeMemberImpl());
751 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
753 SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {
754 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction);
757 SBTypeMemberFunction::~SBTypeMemberFunction() {}
759 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
760 : m_opaque_sp(rhs.m_opaque_sp) {
761 LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction,
762 (const lldb::SBTypeMemberFunction &), rhs);
765 lldb::SBTypeMemberFunction &SBTypeMemberFunction::
766 operator=(const lldb::SBTypeMemberFunction &rhs) {
768 lldb::SBTypeMemberFunction &,
769 SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &),
773 m_opaque_sp = rhs.m_opaque_sp;
774 return LLDB_RECORD_RESULT(*this);
777 bool SBTypeMemberFunction::IsValid() const {
778 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
779 return this->operator bool();
781 SBTypeMemberFunction::operator bool() const {
782 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool);
784 return m_opaque_sp.get();
787 const char *SBTypeMemberFunction::GetName() {
788 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName);
791 return m_opaque_sp->GetName().GetCString();
795 const char *SBTypeMemberFunction::GetDemangledName() {
796 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
800 ConstString mangled_str = m_opaque_sp->GetMangledName();
802 Mangled mangled(mangled_str, true);
803 return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString();
809 const char *SBTypeMemberFunction::GetMangledName() {
810 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
814 return m_opaque_sp->GetMangledName().GetCString();
818 SBType SBTypeMemberFunction::GetType() {
819 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType);
823 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
825 return LLDB_RECORD_RESULT(sb_type);
828 lldb::SBType SBTypeMemberFunction::GetReturnType() {
829 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType);
833 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
835 return LLDB_RECORD_RESULT(sb_type);
838 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
839 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction,
840 GetNumberOfArguments);
843 return m_opaque_sp->GetNumArguments();
847 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
848 LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
854 lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
856 return LLDB_RECORD_RESULT(sb_type);
859 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
860 LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction,
864 return m_opaque_sp->GetKind();
865 return lldb::eMemberFunctionKindUnknown;
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,
874 Stream &strm = description.ref();
877 return m_opaque_sp->GetDescription(strm);
882 void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) {
883 m_opaque_sp.reset(type_member_impl);
886 TypeMemberFunctionImpl &SBTypeMemberFunction::ref() {
888 m_opaque_sp = std::make_shared<TypeMemberFunctionImpl>();
889 return *m_opaque_sp.get();
892 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const {
893 return *m_opaque_sp.get();
896 namespace lldb_private {
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,
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,
943 LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
945 LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers,
947 LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex,
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,
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,
993 LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
995 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
996 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
997 LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
999 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
1000 GetArgumentTypeAtIndex, (uint32_t));
1001 LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
1003 LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,
1004 (lldb::SBStream &, lldb::DescriptionLevel));