1 //===-- SBType.cpp ----------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/API/SBType.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/Log.h"
20 #include "lldb/Utility/Stream.h"
21 
22 #include "llvm/ADT/APSInt.h"
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
SBType()27 SBType::SBType() : m_opaque_sp() {}
28 
SBType(const CompilerType & type)29 SBType::SBType(const CompilerType &type)
30     : m_opaque_sp(new TypeImpl(
31           CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {}
32 
SBType(const lldb::TypeSP & type_sp)33 SBType::SBType(const lldb::TypeSP &type_sp)
34     : m_opaque_sp(new TypeImpl(type_sp)) {}
35 
SBType(const lldb::TypeImplSP & type_impl_sp)36 SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
37     : m_opaque_sp(type_impl_sp) {}
38 
SBType(const SBType & rhs)39 SBType::SBType(const SBType &rhs) : m_opaque_sp() {
40   if (this != &rhs) {
41     m_opaque_sp = rhs.m_opaque_sp;
42   }
43 }
44 
45 // SBType::SBType (TypeImpl* impl) :
46 //    m_opaque_ap(impl)
47 //{}
48 //
operator ==(SBType & rhs)49 bool SBType::operator==(SBType &rhs) {
50   if (!IsValid())
51     return !rhs.IsValid();
52 
53   if (!rhs.IsValid())
54     return false;
55 
56   return *m_opaque_sp.get() == *rhs.m_opaque_sp.get();
57 }
58 
operator !=(SBType & rhs)59 bool SBType::operator!=(SBType &rhs) {
60   if (!IsValid())
61     return rhs.IsValid();
62 
63   if (!rhs.IsValid())
64     return true;
65 
66   return *m_opaque_sp.get() != *rhs.m_opaque_sp.get();
67 }
68 
GetSP()69 lldb::TypeImplSP SBType::GetSP() { return m_opaque_sp; }
70 
SetSP(const lldb::TypeImplSP & type_impl_sp)71 void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
72   m_opaque_sp = type_impl_sp;
73 }
74 
operator =(const SBType & rhs)75 SBType &SBType::operator=(const SBType &rhs) {
76   if (this != &rhs) {
77     m_opaque_sp = rhs.m_opaque_sp;
78   }
79   return *this;
80 }
81 
~SBType()82 SBType::~SBType() {}
83 
ref()84 TypeImpl &SBType::ref() {
85   if (m_opaque_sp.get() == NULL)
86     m_opaque_sp.reset(new TypeImpl());
87   return *m_opaque_sp;
88 }
89 
ref() const90 const TypeImpl &SBType::ref() const {
91   // "const SBAddress &addr" should already have checked "addr.IsValid()" prior
92   // to calling this function. In case you didn't we will assert and die to let
93   // you know.
94   assert(m_opaque_sp.get());
95   return *m_opaque_sp;
96 }
97 
IsValid() const98 bool SBType::IsValid() const {
99   if (m_opaque_sp.get() == NULL)
100     return false;
101 
102   return m_opaque_sp->IsValid();
103 }
104 
GetByteSize()105 uint64_t SBType::GetByteSize() {
106   if (IsValid())
107     if (llvm::Optional<uint64_t> size =
108             m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr))
109       return *size;
110   return 0;
111 }
112 
IsPointerType()113 bool SBType::IsPointerType() {
114   if (!IsValid())
115     return false;
116   return m_opaque_sp->GetCompilerType(true).IsPointerType();
117 }
118 
IsArrayType()119 bool SBType::IsArrayType() {
120   if (!IsValid())
121     return false;
122   return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr,
123                                                         nullptr);
124 }
125 
IsVectorType()126 bool SBType::IsVectorType() {
127   if (!IsValid())
128     return false;
129   return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr);
130 }
131 
IsReferenceType()132 bool SBType::IsReferenceType() {
133   if (!IsValid())
134     return false;
135   return m_opaque_sp->GetCompilerType(true).IsReferenceType();
136 }
137 
GetPointerType()138 SBType SBType::GetPointerType() {
139   if (!IsValid())
140     return SBType();
141 
142   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
143 }
144 
GetPointeeType()145 SBType SBType::GetPointeeType() {
146   if (!IsValid())
147     return SBType();
148   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())));
149 }
150 
GetReferenceType()151 SBType SBType::GetReferenceType() {
152   if (!IsValid())
153     return SBType();
154   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())));
155 }
156 
GetTypedefedType()157 SBType SBType::GetTypedefedType() {
158   if (!IsValid())
159     return SBType();
160   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())));
161 }
162 
GetDereferencedType()163 SBType SBType::GetDereferencedType() {
164   if (!IsValid())
165     return SBType();
166   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
167 }
168 
GetArrayElementType()169 SBType SBType::GetArrayElementType() {
170   if (!IsValid())
171     return SBType();
172   return SBType(TypeImplSP(
173       new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType())));
174 }
175 
GetArrayType(uint64_t size)176 SBType SBType::GetArrayType(uint64_t size) {
177   if (!IsValid())
178     return SBType();
179   return SBType(TypeImplSP(
180       new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size))));
181 }
182 
GetVectorElementType()183 SBType SBType::GetVectorElementType() {
184   SBType type_sb;
185   if (IsValid()) {
186     CompilerType vector_element_type;
187     if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type,
188                                                         nullptr))
189       type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
190   }
191   return type_sb;
192 }
193 
IsFunctionType()194 bool SBType::IsFunctionType() {
195   if (!IsValid())
196     return false;
197   return m_opaque_sp->GetCompilerType(true).IsFunctionType();
198 }
199 
IsPolymorphicClass()200 bool SBType::IsPolymorphicClass() {
201   if (!IsValid())
202     return false;
203   return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass();
204 }
205 
IsTypedefType()206 bool SBType::IsTypedefType() {
207   if (!IsValid())
208     return false;
209   return m_opaque_sp->GetCompilerType(true).IsTypedefType();
210 }
211 
IsAnonymousType()212 bool SBType::IsAnonymousType() {
213   if (!IsValid())
214     return false;
215   return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
216 }
217 
GetFunctionReturnType()218 lldb::SBType SBType::GetFunctionReturnType() {
219   if (IsValid()) {
220     CompilerType return_type(
221         m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
222     if (return_type.IsValid())
223       return SBType(return_type);
224   }
225   return lldb::SBType();
226 }
227 
GetFunctionArgumentTypes()228 lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
229   SBTypeList sb_type_list;
230   if (IsValid()) {
231     CompilerType func_type(m_opaque_sp->GetCompilerType(true));
232     size_t count = func_type.GetNumberOfFunctionArguments();
233     for (size_t i = 0; i < count; i++) {
234       sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
235     }
236   }
237   return sb_type_list;
238 }
239 
GetNumberOfMemberFunctions()240 uint32_t SBType::GetNumberOfMemberFunctions() {
241   if (IsValid()) {
242     return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
243   }
244   return 0;
245 }
246 
GetMemberFunctionAtIndex(uint32_t idx)247 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
248   SBTypeMemberFunction sb_func_type;
249   if (IsValid())
250     sb_func_type.reset(new TypeMemberFunctionImpl(
251         m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
252   return sb_func_type;
253 }
254 
GetUnqualifiedType()255 lldb::SBType SBType::GetUnqualifiedType() {
256   if (!IsValid())
257     return SBType();
258   return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())));
259 }
260 
GetCanonicalType()261 lldb::SBType SBType::GetCanonicalType() {
262   if (IsValid())
263     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
264   return SBType();
265 }
266 
GetBasicType()267 lldb::BasicType SBType::GetBasicType() {
268   if (IsValid())
269     return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
270   return eBasicTypeInvalid;
271 }
272 
GetBasicType(lldb::BasicType basic_type)273 SBType SBType::GetBasicType(lldb::BasicType basic_type) {
274   if (IsValid() && m_opaque_sp->IsValid())
275     return SBType(
276         m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type));
277   return SBType();
278 }
279 
GetNumberOfDirectBaseClasses()280 uint32_t SBType::GetNumberOfDirectBaseClasses() {
281   if (IsValid())
282     return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
283   return 0;
284 }
285 
GetNumberOfVirtualBaseClasses()286 uint32_t SBType::GetNumberOfVirtualBaseClasses() {
287   if (IsValid())
288     return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
289   return 0;
290 }
291 
GetNumberOfFields()292 uint32_t SBType::GetNumberOfFields() {
293   if (IsValid())
294     return m_opaque_sp->GetCompilerType(true).GetNumFields();
295   return 0;
296 }
297 
GetDescription(SBStream & description,lldb::DescriptionLevel description_level)298 bool SBType::GetDescription(SBStream &description,
299                             lldb::DescriptionLevel description_level) {
300   Stream &strm = description.ref();
301 
302   if (m_opaque_sp) {
303     m_opaque_sp->GetDescription(strm, description_level);
304   } else
305     strm.PutCString("No value");
306 
307   return true;
308 }
309 
GetDirectBaseClassAtIndex(uint32_t idx)310 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
311   SBTypeMember sb_type_member;
312   if (IsValid()) {
313     uint32_t bit_offset = 0;
314     CompilerType base_class_type =
315         m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex(
316             idx, &bit_offset);
317     if (base_class_type.IsValid())
318       sb_type_member.reset(new TypeMemberImpl(
319           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
320   }
321   return sb_type_member;
322 }
323 
GetVirtualBaseClassAtIndex(uint32_t idx)324 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
325   SBTypeMember sb_type_member;
326   if (IsValid()) {
327     uint32_t bit_offset = 0;
328     CompilerType base_class_type =
329         m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex(
330             idx, &bit_offset);
331     if (base_class_type.IsValid())
332       sb_type_member.reset(new TypeMemberImpl(
333           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
334   }
335   return sb_type_member;
336 }
337 
GetEnumMembers()338 SBTypeEnumMemberList SBType::GetEnumMembers() {
339   SBTypeEnumMemberList sb_enum_member_list;
340   if (IsValid()) {
341     CompilerType this_type(m_opaque_sp->GetCompilerType(true));
342     if (this_type.IsValid()) {
343       this_type.ForEachEnumerator([&sb_enum_member_list](
344                                       const CompilerType &integer_type,
345                                       const ConstString &name,
346                                       const llvm::APSInt &value) -> bool {
347         SBTypeEnumMember enum_member(
348             lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl(
349                 lldb::TypeImplSP(new TypeImpl(integer_type)), name, value)));
350         sb_enum_member_list.Append(enum_member);
351         return true; // Keep iterating
352       });
353     }
354   }
355   return sb_enum_member_list;
356 }
357 
GetFieldAtIndex(uint32_t idx)358 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
359   SBTypeMember sb_type_member;
360   if (IsValid()) {
361     CompilerType this_type(m_opaque_sp->GetCompilerType(false));
362     if (this_type.IsValid()) {
363       uint64_t bit_offset = 0;
364       uint32_t bitfield_bit_size = 0;
365       bool is_bitfield = false;
366       std::string name_sstr;
367       CompilerType field_type(this_type.GetFieldAtIndex(
368           idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield));
369       if (field_type.IsValid()) {
370         ConstString name;
371         if (!name_sstr.empty())
372           name.SetCString(name_sstr.c_str());
373         sb_type_member.reset(
374             new TypeMemberImpl(TypeImplSP(new TypeImpl(field_type)), bit_offset,
375                                name, bitfield_bit_size, is_bitfield));
376       }
377     }
378   }
379   return sb_type_member;
380 }
381 
IsTypeComplete()382 bool SBType::IsTypeComplete() {
383   if (!IsValid())
384     return false;
385   return m_opaque_sp->GetCompilerType(false).IsCompleteType();
386 }
387 
GetTypeFlags()388 uint32_t SBType::GetTypeFlags() {
389   if (!IsValid())
390     return 0;
391   return m_opaque_sp->GetCompilerType(true).GetTypeInfo();
392 }
393 
GetName()394 const char *SBType::GetName() {
395   if (!IsValid())
396     return "";
397   return m_opaque_sp->GetName().GetCString();
398 }
399 
GetDisplayTypeName()400 const char *SBType::GetDisplayTypeName() {
401   if (!IsValid())
402     return "";
403   return m_opaque_sp->GetDisplayTypeName().GetCString();
404 }
405 
GetTypeClass()406 lldb::TypeClass SBType::GetTypeClass() {
407   if (IsValid())
408     return m_opaque_sp->GetCompilerType(true).GetTypeClass();
409   return lldb::eTypeClassInvalid;
410 }
411 
GetNumberOfTemplateArguments()412 uint32_t SBType::GetNumberOfTemplateArguments() {
413   if (IsValid())
414     return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
415   return 0;
416 }
417 
GetTemplateArgumentType(uint32_t idx)418 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
419   if (!IsValid())
420     return SBType();
421 
422   CompilerType type;
423   switch(GetTemplateArgumentKind(idx)) {
424     case eTemplateArgumentKindType:
425       type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx);
426       break;
427     case eTemplateArgumentKindIntegral:
428       type = m_opaque_sp->GetCompilerType(false)
429                  .GetIntegralTemplateArgument(idx)
430                  ->type;
431       break;
432     default:
433       break;
434   }
435   if (type.IsValid())
436     return SBType(type);
437   return SBType();
438 }
439 
GetTemplateArgumentKind(uint32_t idx)440 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
441   if (IsValid())
442     return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
443   return eTemplateArgumentKindNull;
444 }
445 
SBTypeList()446 SBTypeList::SBTypeList() : m_opaque_ap(new TypeListImpl()) {}
447 
SBTypeList(const SBTypeList & rhs)448 SBTypeList::SBTypeList(const SBTypeList &rhs)
449     : m_opaque_ap(new TypeListImpl()) {
450   for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
451        i < rhs_size; i++)
452     Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
453 }
454 
IsValid()455 bool SBTypeList::IsValid() { return (m_opaque_ap != NULL); }
456 
operator =(const SBTypeList & rhs)457 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
458   if (this != &rhs) {
459     m_opaque_ap.reset(new TypeListImpl());
460     for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
461          i < rhs_size; i++)
462       Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
463   }
464   return *this;
465 }
466 
Append(SBType type)467 void SBTypeList::Append(SBType type) {
468   if (type.IsValid())
469     m_opaque_ap->Append(type.m_opaque_sp);
470 }
471 
GetTypeAtIndex(uint32_t index)472 SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
473   if (m_opaque_ap)
474     return SBType(m_opaque_ap->GetTypeAtIndex(index));
475   return SBType();
476 }
477 
GetSize()478 uint32_t SBTypeList::GetSize() { return m_opaque_ap->GetSize(); }
479 
~SBTypeList()480 SBTypeList::~SBTypeList() {}
481 
SBTypeMember()482 SBTypeMember::SBTypeMember() : m_opaque_ap() {}
483 
~SBTypeMember()484 SBTypeMember::~SBTypeMember() {}
485 
SBTypeMember(const SBTypeMember & rhs)486 SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_ap() {
487   if (this != &rhs) {
488     if (rhs.IsValid())
489       m_opaque_ap.reset(new TypeMemberImpl(rhs.ref()));
490   }
491 }
492 
operator =(const lldb::SBTypeMember & rhs)493 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
494   if (this != &rhs) {
495     if (rhs.IsValid())
496       m_opaque_ap.reset(new TypeMemberImpl(rhs.ref()));
497   }
498   return *this;
499 }
500 
IsValid() const501 bool SBTypeMember::IsValid() const { return m_opaque_ap.get(); }
502 
GetName()503 const char *SBTypeMember::GetName() {
504   if (m_opaque_ap)
505     return m_opaque_ap->GetName().GetCString();
506   return NULL;
507 }
508 
GetType()509 SBType SBTypeMember::GetType() {
510   SBType sb_type;
511   if (m_opaque_ap) {
512     sb_type.SetSP(m_opaque_ap->GetTypeImpl());
513   }
514   return sb_type;
515 }
516 
GetOffsetInBytes()517 uint64_t SBTypeMember::GetOffsetInBytes() {
518   if (m_opaque_ap)
519     return m_opaque_ap->GetBitOffset() / 8u;
520   return 0;
521 }
522 
GetOffsetInBits()523 uint64_t SBTypeMember::GetOffsetInBits() {
524   if (m_opaque_ap)
525     return m_opaque_ap->GetBitOffset();
526   return 0;
527 }
528 
IsBitfield()529 bool SBTypeMember::IsBitfield() {
530   if (m_opaque_ap)
531     return m_opaque_ap->GetIsBitfield();
532   return false;
533 }
534 
GetBitfieldSizeInBits()535 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
536   if (m_opaque_ap)
537     return m_opaque_ap->GetBitfieldBitSize();
538   return 0;
539 }
540 
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)541 bool SBTypeMember::GetDescription(lldb::SBStream &description,
542                                   lldb::DescriptionLevel description_level) {
543   Stream &strm = description.ref();
544 
545   if (m_opaque_ap) {
546     const uint32_t bit_offset = m_opaque_ap->GetBitOffset();
547     const uint32_t byte_offset = bit_offset / 8u;
548     const uint32_t byte_bit_offset = bit_offset % 8u;
549     const char *name = m_opaque_ap->GetName().GetCString();
550     if (byte_bit_offset)
551       strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset);
552     else
553       strm.Printf("+%u: (", byte_offset);
554 
555     TypeImplSP type_impl_sp(m_opaque_ap->GetTypeImpl());
556     if (type_impl_sp)
557       type_impl_sp->GetDescription(strm, description_level);
558 
559     strm.Printf(") %s", name);
560     if (m_opaque_ap->GetIsBitfield()) {
561       const uint32_t bitfield_bit_size = m_opaque_ap->GetBitfieldBitSize();
562       strm.Printf(" : %u", bitfield_bit_size);
563     }
564   } else {
565     strm.PutCString("No value");
566   }
567   return true;
568 }
569 
reset(TypeMemberImpl * type_member_impl)570 void SBTypeMember::reset(TypeMemberImpl *type_member_impl) {
571   m_opaque_ap.reset(type_member_impl);
572 }
573 
ref()574 TypeMemberImpl &SBTypeMember::ref() {
575   if (m_opaque_ap == NULL)
576     m_opaque_ap.reset(new TypeMemberImpl());
577   return *m_opaque_ap;
578 }
579 
ref() const580 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_ap; }
581 
SBTypeMemberFunction()582 SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {}
583 
~SBTypeMemberFunction()584 SBTypeMemberFunction::~SBTypeMemberFunction() {}
585 
SBTypeMemberFunction(const SBTypeMemberFunction & rhs)586 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
587     : m_opaque_sp(rhs.m_opaque_sp) {}
588 
589 lldb::SBTypeMemberFunction &SBTypeMemberFunction::
operator =(const lldb::SBTypeMemberFunction & rhs)590 operator=(const lldb::SBTypeMemberFunction &rhs) {
591   if (this != &rhs)
592     m_opaque_sp = rhs.m_opaque_sp;
593   return *this;
594 }
595 
IsValid() const596 bool SBTypeMemberFunction::IsValid() const { return m_opaque_sp.get(); }
597 
GetName()598 const char *SBTypeMemberFunction::GetName() {
599   if (m_opaque_sp)
600     return m_opaque_sp->GetName().GetCString();
601   return NULL;
602 }
603 
GetDemangledName()604 const char *SBTypeMemberFunction::GetDemangledName() {
605   if (m_opaque_sp) {
606     ConstString mangled_str = m_opaque_sp->GetMangledName();
607     if (mangled_str) {
608       Mangled mangled(mangled_str, true);
609       return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString();
610     }
611   }
612   return NULL;
613 }
614 
GetMangledName()615 const char *SBTypeMemberFunction::GetMangledName() {
616   if (m_opaque_sp)
617     return m_opaque_sp->GetMangledName().GetCString();
618   return NULL;
619 }
620 
GetType()621 SBType SBTypeMemberFunction::GetType() {
622   SBType sb_type;
623   if (m_opaque_sp) {
624     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
625   }
626   return sb_type;
627 }
628 
GetReturnType()629 lldb::SBType SBTypeMemberFunction::GetReturnType() {
630   SBType sb_type;
631   if (m_opaque_sp) {
632     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
633   }
634   return sb_type;
635 }
636 
GetNumberOfArguments()637 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
638   if (m_opaque_sp)
639     return m_opaque_sp->GetNumArguments();
640   return 0;
641 }
642 
GetArgumentTypeAtIndex(uint32_t i)643 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
644   SBType sb_type;
645   if (m_opaque_sp) {
646     sb_type.SetSP(
647         lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
648   }
649   return sb_type;
650 }
651 
GetKind()652 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
653   if (m_opaque_sp)
654     return m_opaque_sp->GetKind();
655   return lldb::eMemberFunctionKindUnknown;
656 }
657 
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)658 bool SBTypeMemberFunction::GetDescription(
659     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
660   Stream &strm = description.ref();
661 
662   if (m_opaque_sp)
663     return m_opaque_sp->GetDescription(strm);
664 
665   return false;
666 }
667 
reset(TypeMemberFunctionImpl * type_member_impl)668 void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) {
669   m_opaque_sp.reset(type_member_impl);
670 }
671 
ref()672 TypeMemberFunctionImpl &SBTypeMemberFunction::ref() {
673   if (!m_opaque_sp)
674     m_opaque_sp.reset(new TypeMemberFunctionImpl());
675   return *m_opaque_sp.get();
676 }
677 
ref() const678 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const {
679   return *m_opaque_sp.get();
680 }
681