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