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
SBTypeList()589 SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
590 LLDB_INSTRUMENT_VA(this);
591 }
592
SBTypeList(const SBTypeList & rhs)593 SBTypeList::SBTypeList(const SBTypeList &rhs)
594 : m_opaque_up(new TypeListImpl()) {
595 LLDB_INSTRUMENT_VA(this, rhs);
596
597 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
598 i < rhs_size; i++)
599 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
600 }
601
IsValid()602 bool SBTypeList::IsValid() {
603 LLDB_INSTRUMENT_VA(this);
604 return this->operator bool();
605 }
operator bool() const606 SBTypeList::operator bool() const {
607 LLDB_INSTRUMENT_VA(this);
608
609 return (m_opaque_up != nullptr);
610 }
611
operator =(const SBTypeList & rhs)612 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
613 LLDB_INSTRUMENT_VA(this, rhs);
614
615 if (this != &rhs) {
616 m_opaque_up = std::make_unique<TypeListImpl>();
617 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
618 i < rhs_size; i++)
619 Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
620 }
621 return *this;
622 }
623
Append(SBType type)624 void SBTypeList::Append(SBType type) {
625 LLDB_INSTRUMENT_VA(this, type);
626
627 if (type.IsValid())
628 m_opaque_up->Append(type.m_opaque_sp);
629 }
630
GetTypeAtIndex(uint32_t index)631 SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
632 LLDB_INSTRUMENT_VA(this, index);
633
634 if (m_opaque_up)
635 return SBType(m_opaque_up->GetTypeAtIndex(index));
636 return SBType();
637 }
638
GetSize()639 uint32_t SBTypeList::GetSize() {
640 LLDB_INSTRUMENT_VA(this);
641
642 return m_opaque_up->GetSize();
643 }
644
645 SBTypeList::~SBTypeList() = default;
646
SBTypeMember()647 SBTypeMember::SBTypeMember() { LLDB_INSTRUMENT_VA(this); }
648
649 SBTypeMember::~SBTypeMember() = default;
650
SBTypeMember(const SBTypeMember & rhs)651 SBTypeMember::SBTypeMember(const SBTypeMember &rhs) {
652 LLDB_INSTRUMENT_VA(this, rhs);
653
654 if (this != &rhs) {
655 if (rhs.IsValid())
656 m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref());
657 }
658 }
659
operator =(const lldb::SBTypeMember & rhs)660 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
661 LLDB_INSTRUMENT_VA(this, rhs);
662
663 if (this != &rhs) {
664 if (rhs.IsValid())
665 m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref());
666 }
667 return *this;
668 }
669
IsValid() const670 bool SBTypeMember::IsValid() const {
671 LLDB_INSTRUMENT_VA(this);
672 return this->operator bool();
673 }
operator bool() const674 SBTypeMember::operator bool() const {
675 LLDB_INSTRUMENT_VA(this);
676
677 return m_opaque_up.get();
678 }
679
GetName()680 const char *SBTypeMember::GetName() {
681 LLDB_INSTRUMENT_VA(this);
682
683 if (m_opaque_up)
684 return m_opaque_up->GetName().GetCString();
685 return nullptr;
686 }
687
GetType()688 SBType SBTypeMember::GetType() {
689 LLDB_INSTRUMENT_VA(this);
690
691 SBType sb_type;
692 if (m_opaque_up) {
693 sb_type.SetSP(m_opaque_up->GetTypeImpl());
694 }
695 return sb_type;
696 }
697
GetOffsetInBytes()698 uint64_t SBTypeMember::GetOffsetInBytes() {
699 LLDB_INSTRUMENT_VA(this);
700
701 if (m_opaque_up)
702 return m_opaque_up->GetBitOffset() / 8u;
703 return 0;
704 }
705
GetOffsetInBits()706 uint64_t SBTypeMember::GetOffsetInBits() {
707 LLDB_INSTRUMENT_VA(this);
708
709 if (m_opaque_up)
710 return m_opaque_up->GetBitOffset();
711 return 0;
712 }
713
IsBitfield()714 bool SBTypeMember::IsBitfield() {
715 LLDB_INSTRUMENT_VA(this);
716
717 if (m_opaque_up)
718 return m_opaque_up->GetIsBitfield();
719 return false;
720 }
721
GetBitfieldSizeInBits()722 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
723 LLDB_INSTRUMENT_VA(this);
724
725 if (m_opaque_up)
726 return m_opaque_up->GetBitfieldBitSize();
727 return 0;
728 }
729
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)730 bool SBTypeMember::GetDescription(lldb::SBStream &description,
731 lldb::DescriptionLevel description_level) {
732 LLDB_INSTRUMENT_VA(this, description, description_level);
733
734 Stream &strm = description.ref();
735
736 if (m_opaque_up) {
737 const uint32_t bit_offset = m_opaque_up->GetBitOffset();
738 const uint32_t byte_offset = bit_offset / 8u;
739 const uint32_t byte_bit_offset = bit_offset % 8u;
740 const char *name = m_opaque_up->GetName().GetCString();
741 if (byte_bit_offset)
742 strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset);
743 else
744 strm.Printf("+%u: (", byte_offset);
745
746 TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl());
747 if (type_impl_sp)
748 type_impl_sp->GetDescription(strm, description_level);
749
750 strm.Printf(") %s", name);
751 if (m_opaque_up->GetIsBitfield()) {
752 const uint32_t bitfield_bit_size = m_opaque_up->GetBitfieldBitSize();
753 strm.Printf(" : %u", bitfield_bit_size);
754 }
755 } else {
756 strm.PutCString("No value");
757 }
758 return true;
759 }
760
reset(TypeMemberImpl * type_member_impl)761 void SBTypeMember::reset(TypeMemberImpl *type_member_impl) {
762 m_opaque_up.reset(type_member_impl);
763 }
764
ref()765 TypeMemberImpl &SBTypeMember::ref() {
766 if (m_opaque_up == nullptr)
767 m_opaque_up = std::make_unique<TypeMemberImpl>();
768 return *m_opaque_up;
769 }
770
ref() const771 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
772
SBTypeMemberFunction()773 SBTypeMemberFunction::SBTypeMemberFunction() { LLDB_INSTRUMENT_VA(this); }
774
775 SBTypeMemberFunction::~SBTypeMemberFunction() = default;
776
SBTypeMemberFunction(const SBTypeMemberFunction & rhs)777 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
778 : m_opaque_sp(rhs.m_opaque_sp) {
779 LLDB_INSTRUMENT_VA(this, rhs);
780 }
781
782 lldb::SBTypeMemberFunction &SBTypeMemberFunction::
operator =(const lldb::SBTypeMemberFunction & rhs)783 operator=(const lldb::SBTypeMemberFunction &rhs) {
784 LLDB_INSTRUMENT_VA(this, rhs);
785
786 if (this != &rhs)
787 m_opaque_sp = rhs.m_opaque_sp;
788 return *this;
789 }
790
IsValid() const791 bool SBTypeMemberFunction::IsValid() const {
792 LLDB_INSTRUMENT_VA(this);
793 return this->operator bool();
794 }
operator bool() const795 SBTypeMemberFunction::operator bool() const {
796 LLDB_INSTRUMENT_VA(this);
797
798 return m_opaque_sp.get();
799 }
800
GetName()801 const char *SBTypeMemberFunction::GetName() {
802 LLDB_INSTRUMENT_VA(this);
803
804 if (m_opaque_sp)
805 return m_opaque_sp->GetName().GetCString();
806 return nullptr;
807 }
808
GetDemangledName()809 const char *SBTypeMemberFunction::GetDemangledName() {
810 LLDB_INSTRUMENT_VA(this);
811
812 if (m_opaque_sp) {
813 ConstString mangled_str = m_opaque_sp->GetMangledName();
814 if (mangled_str) {
815 Mangled mangled(mangled_str);
816 return mangled.GetDemangledName().GetCString();
817 }
818 }
819 return nullptr;
820 }
821
GetMangledName()822 const char *SBTypeMemberFunction::GetMangledName() {
823 LLDB_INSTRUMENT_VA(this);
824
825 if (m_opaque_sp)
826 return m_opaque_sp->GetMangledName().GetCString();
827 return nullptr;
828 }
829
GetType()830 SBType SBTypeMemberFunction::GetType() {
831 LLDB_INSTRUMENT_VA(this);
832
833 SBType sb_type;
834 if (m_opaque_sp) {
835 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
836 }
837 return sb_type;
838 }
839
GetReturnType()840 lldb::SBType SBTypeMemberFunction::GetReturnType() {
841 LLDB_INSTRUMENT_VA(this);
842
843 SBType sb_type;
844 if (m_opaque_sp) {
845 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
846 }
847 return sb_type;
848 }
849
GetNumberOfArguments()850 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
851 LLDB_INSTRUMENT_VA(this);
852
853 if (m_opaque_sp)
854 return m_opaque_sp->GetNumArguments();
855 return 0;
856 }
857
GetArgumentTypeAtIndex(uint32_t i)858 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
859 LLDB_INSTRUMENT_VA(this, i);
860
861 SBType sb_type;
862 if (m_opaque_sp) {
863 sb_type.SetSP(
864 lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
865 }
866 return sb_type;
867 }
868
GetKind()869 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
870 LLDB_INSTRUMENT_VA(this);
871
872 if (m_opaque_sp)
873 return m_opaque_sp->GetKind();
874 return lldb::eMemberFunctionKindUnknown;
875 }
876
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)877 bool SBTypeMemberFunction::GetDescription(
878 lldb::SBStream &description, lldb::DescriptionLevel description_level) {
879 LLDB_INSTRUMENT_VA(this, description, description_level);
880
881 Stream &strm = description.ref();
882
883 if (m_opaque_sp)
884 return m_opaque_sp->GetDescription(strm);
885
886 return false;
887 }
888
reset(TypeMemberFunctionImpl * type_member_impl)889 void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) {
890 m_opaque_sp.reset(type_member_impl);
891 }
892
ref()893 TypeMemberFunctionImpl &SBTypeMemberFunction::ref() {
894 if (!m_opaque_sp)
895 m_opaque_sp = std::make_shared<TypeMemberFunctionImpl>();
896 return *m_opaque_sp.get();
897 }
898
ref() const899 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const {
900 return *m_opaque_sp.get();
901 }
902