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