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