1 //===-- Type.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 // Other libraries and framework includes
11 
12 #include "lldb/Core/DataExtractor.h"
13 #include "lldb/Core/DataBufferHeap.h"
14 #include "lldb/Core/Module.h"
15 #include "lldb/Core/Scalar.h"
16 #include "lldb/Core/StreamString.h"
17 
18 #include "lldb/Symbol/ClangASTType.h"
19 #include "lldb/Symbol/ClangASTContext.h"
20 #include "lldb/Symbol/ObjectFile.h"
21 #include "lldb/Symbol/SymbolContextScope.h"
22 #include "lldb/Symbol/SymbolFile.h"
23 #include "lldb/Symbol/SymbolVendor.h"
24 #include "lldb/Symbol/Type.h"
25 #include "lldb/Symbol/TypeList.h"
26 
27 #include "lldb/Target/ExecutionContext.h"
28 #include "lldb/Target/Process.h"
29 #include "lldb/Target/Target.h"
30 
31 #include "llvm/ADT/StringRef.h"
32 
33 #include "clang/AST/Decl.h"
34 #include "clang/AST/DeclObjC.h"
35 
36 using namespace lldb;
37 using namespace lldb_private;
38 
39 class TypeAppendVisitor
40 {
41 public:
42     TypeAppendVisitor(TypeListImpl &type_list) :
43         m_type_list(type_list)
44     {
45     }
46 
47     bool
48     operator() (const lldb::TypeSP& type)
49     {
50         m_type_list.Append(TypeImplSP(new TypeImpl(type)));
51         return true;
52     }
53 
54 private:
55     TypeListImpl &m_type_list;
56 };
57 
58 void
59 TypeListImpl::Append (const lldb_private::TypeList &type_list)
60 {
61     TypeAppendVisitor cb(*this);
62     type_list.ForEach(cb);
63 }
64 
65 
66 Type *
67 SymbolFileType::GetType ()
68 {
69     if (!m_type_sp)
70     {
71         Type *resolved_type = m_symbol_file.ResolveTypeUID (GetID());
72         if (resolved_type)
73             m_type_sp = resolved_type->shared_from_this();
74     }
75     return m_type_sp.get();
76 }
77 
78 
79 Type::Type
80 (
81     lldb::user_id_t uid,
82     SymbolFile* symbol_file,
83     const ConstString &name,
84     uint64_t byte_size,
85     SymbolContextScope *context,
86     user_id_t encoding_uid,
87     EncodingDataType encoding_uid_type,
88     const Declaration& decl,
89     const ClangASTType &clang_type,
90     ResolveState clang_type_resolve_state
91 ) :
92     std::enable_shared_from_this<Type> (),
93     UserID (uid),
94     m_name (name),
95     m_symbol_file (symbol_file),
96     m_context (context),
97     m_encoding_type (nullptr),
98     m_encoding_uid (encoding_uid),
99     m_encoding_uid_type (encoding_uid_type),
100     m_byte_size (byte_size),
101     m_decl (decl),
102     m_clang_type (clang_type)
103 {
104     m_flags.clang_type_resolve_state = (clang_type ? clang_type_resolve_state : eResolveStateUnresolved);
105     m_flags.is_complete_objc_class = false;
106 }
107 
108 Type::Type () :
109     std::enable_shared_from_this<Type> (),
110     UserID (0),
111     m_name ("<INVALID TYPE>"),
112     m_symbol_file (nullptr),
113     m_context (nullptr),
114     m_encoding_type (nullptr),
115     m_encoding_uid (LLDB_INVALID_UID),
116     m_encoding_uid_type (eEncodingInvalid),
117     m_byte_size (0),
118     m_decl (),
119     m_clang_type ()
120 {
121     m_flags.clang_type_resolve_state = eResolveStateUnresolved;
122     m_flags.is_complete_objc_class = false;
123 }
124 
125 
126 Type::Type (const Type &rhs) :
127     std::enable_shared_from_this<Type> (rhs),
128     UserID (rhs),
129     m_name (rhs.m_name),
130     m_symbol_file (rhs.m_symbol_file),
131     m_context (rhs.m_context),
132     m_encoding_type (rhs.m_encoding_type),
133     m_encoding_uid (rhs.m_encoding_uid),
134     m_encoding_uid_type (rhs.m_encoding_uid_type),
135     m_byte_size (rhs.m_byte_size),
136     m_decl (rhs.m_decl),
137     m_clang_type (rhs.m_clang_type),
138     m_flags (rhs.m_flags)
139 {
140 }
141 
142 const Type&
143 Type::operator= (const Type& rhs)
144 {
145     if (this != &rhs)
146     {
147     }
148     return *this;
149 }
150 
151 
152 void
153 Type::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name)
154 {
155     *s << "id = " << (const UserID&)*this;
156 
157     // Call the name accessor to make sure we resolve the type name
158     if (show_name)
159     {
160         const ConstString &type_name = GetName();
161         if (type_name)
162         {
163             *s << ", name = \"" << type_name << '"';
164             ConstString qualified_type_name (GetQualifiedName());
165             if (qualified_type_name != type_name)
166             {
167                 *s << ", qualified = \"" << qualified_type_name << '"';
168             }
169         }
170     }
171 
172     // Call the get byte size accesor so we resolve our byte size
173     if (GetByteSize())
174         s->Printf(", byte-size = %" PRIu64, m_byte_size);
175     bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose);
176     m_decl.Dump(s, show_fullpaths);
177 
178     if (m_clang_type.IsValid())
179     {
180         *s << ", clang_type = \"";
181         GetClangForwardType().DumpTypeDescription(s);
182         *s << '"';
183     }
184     else if (m_encoding_uid != LLDB_INVALID_UID)
185     {
186         s->Printf(", type_uid = 0x%8.8" PRIx64, m_encoding_uid);
187         switch (m_encoding_uid_type)
188         {
189         case eEncodingInvalid: break;
190         case eEncodingIsUID: s->PutCString(" (unresolved type)"); break;
191         case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break;
192         case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break;
193         case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break;
194         case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break;
195         case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break;
196         case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break;
197         case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break;
198         case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break;
199         }
200     }
201 }
202 
203 
204 void
205 Type::Dump (Stream *s, bool show_context)
206 {
207     s->Printf("%p: ", static_cast<void*>(this));
208     s->Indent();
209     *s << "Type" << static_cast<const UserID&>(*this) << ' ';
210     if (m_name)
211         *s << ", name = \"" << m_name << "\"";
212 
213     if (m_byte_size != 0)
214         s->Printf(", size = %" PRIu64, m_byte_size);
215 
216     if (show_context && m_context != nullptr)
217     {
218         s->PutCString(", context = ( ");
219         m_context->DumpSymbolContext(s);
220         s->PutCString(" )");
221     }
222 
223     bool show_fullpaths = false;
224     m_decl.Dump (s,show_fullpaths);
225 
226     if (m_clang_type.IsValid())
227     {
228         *s << ", clang_type = " << m_clang_type.GetOpaqueQualType() << ' ';
229         GetClangForwardType().DumpTypeDescription (s);
230     }
231     else if (m_encoding_uid != LLDB_INVALID_UID)
232     {
233         *s << ", type_data = " << (uint64_t)m_encoding_uid;
234         switch (m_encoding_uid_type)
235         {
236         case eEncodingInvalid: break;
237         case eEncodingIsUID: s->PutCString(" (unresolved type)"); break;
238         case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break;
239         case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break;
240         case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break;
241         case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break;
242         case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break;
243         case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break;
244         case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break;
245         case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break;
246         }
247     }
248 
249 //
250 //  if (m_access)
251 //      s->Printf(", access = %u", m_access);
252     s->EOL();
253 }
254 
255 const ConstString &
256 Type::GetName()
257 {
258     if (!m_name)
259         m_name = GetClangForwardType().GetConstTypeName();
260     return m_name;
261 }
262 
263 void
264 Type::DumpTypeName(Stream *s)
265 {
266     GetName().Dump(s, "<invalid-type-name>");
267 }
268 
269 
270 void
271 Type::DumpValue
272 (
273     ExecutionContext *exe_ctx,
274     Stream *s,
275     const DataExtractor &data,
276     uint32_t data_byte_offset,
277     bool show_types,
278     bool show_summary,
279     bool verbose,
280     lldb::Format format
281 )
282 {
283     if (ResolveClangType(eResolveStateForward))
284     {
285         if (show_types)
286         {
287             s->PutChar('(');
288             if (verbose)
289                 s->Printf("Type{0x%8.8" PRIx64 "} ", GetID());
290             DumpTypeName (s);
291             s->PutCString(") ");
292         }
293 
294         GetClangForwardType().DumpValue (exe_ctx,
295                                          s,
296                                          format == lldb::eFormatDefault ? GetFormat() : format,
297                                          data,
298                                          data_byte_offset,
299                                          GetByteSize(),
300                                          0, // Bitfield bit size
301                                          0, // Bitfield bit offset
302                                          show_types,
303                                          show_summary,
304                                          verbose,
305                                          0);
306     }
307 }
308 
309 Type *
310 Type::GetEncodingType ()
311 {
312     if (m_encoding_type == nullptr && m_encoding_uid != LLDB_INVALID_UID)
313         m_encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_uid);
314     return m_encoding_type;
315 }
316 
317 
318 
319 uint64_t
320 Type::GetByteSize()
321 {
322     if (m_byte_size == 0)
323     {
324         switch (m_encoding_uid_type)
325         {
326         case eEncodingInvalid:
327         case eEncodingIsSyntheticUID:
328             break;
329         case eEncodingIsUID:
330         case eEncodingIsConstUID:
331         case eEncodingIsRestrictUID:
332         case eEncodingIsVolatileUID:
333         case eEncodingIsTypedefUID:
334             {
335                 Type *encoding_type = GetEncodingType ();
336                 if (encoding_type)
337                     m_byte_size = encoding_type->GetByteSize();
338                 if (m_byte_size == 0)
339                     m_byte_size = GetClangLayoutType().GetByteSize(nullptr);
340             }
341             break;
342 
343         // If we are a pointer or reference, then this is just a pointer size;
344         case eEncodingIsPointerUID:
345         case eEncodingIsLValueReferenceUID:
346         case eEncodingIsRValueReferenceUID:
347             m_byte_size = m_symbol_file->GetClangASTContext().GetPointerByteSize();
348             break;
349         }
350     }
351     return m_byte_size;
352 }
353 
354 
355 uint32_t
356 Type::GetNumChildren (bool omit_empty_base_classes)
357 {
358     return GetClangForwardType().GetNumChildren(omit_empty_base_classes);
359 }
360 
361 bool
362 Type::IsAggregateType ()
363 {
364     return GetClangForwardType().IsAggregateType();
365 }
366 
367 lldb::TypeSP
368 Type::GetTypedefType()
369 {
370     lldb::TypeSP type_sp;
371     if (IsTypedef())
372     {
373         Type *typedef_type = m_symbol_file->ResolveTypeUID(m_encoding_uid);
374         if (typedef_type)
375             type_sp = typedef_type->shared_from_this();
376     }
377     return type_sp;
378 }
379 
380 
381 
382 lldb::Format
383 Type::GetFormat ()
384 {
385     return GetClangForwardType().GetFormat();
386 }
387 
388 
389 
390 lldb::Encoding
391 Type::GetEncoding (uint64_t &count)
392 {
393     // Make sure we resolve our type if it already hasn't been.
394     return GetClangForwardType().GetEncoding(count);
395 }
396 
397 bool
398 Type::DumpValueInMemory
399 (
400     ExecutionContext *exe_ctx,
401     Stream *s,
402     lldb::addr_t address,
403     AddressType address_type,
404     bool show_types,
405     bool show_summary,
406     bool verbose
407 )
408 {
409     if (address != LLDB_INVALID_ADDRESS)
410     {
411         DataExtractor data;
412         Target *target = nullptr;
413         if (exe_ctx)
414             target = exe_ctx->GetTargetPtr();
415         if (target)
416             data.SetByteOrder (target->GetArchitecture().GetByteOrder());
417         if (ReadFromMemory (exe_ctx, address, address_type, data))
418         {
419             DumpValue(exe_ctx, s, data, 0, show_types, show_summary, verbose);
420             return true;
421         }
422     }
423     return false;
424 }
425 
426 
427 bool
428 Type::ReadFromMemory (ExecutionContext *exe_ctx, lldb::addr_t addr, AddressType address_type, DataExtractor &data)
429 {
430     if (address_type == eAddressTypeFile)
431     {
432         // Can't convert a file address to anything valid without more
433         // context (which Module it came from)
434         return false;
435     }
436 
437     const uint64_t byte_size = GetByteSize();
438     if (data.GetByteSize() < byte_size)
439     {
440         lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0'));
441         data.SetData(data_sp);
442     }
443 
444     uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size);
445     if (dst != nullptr)
446     {
447         if (address_type == eAddressTypeHost)
448         {
449             // The address is an address in this process, so just copy it
450             if (addr == 0)
451                 return false;
452             memcpy (dst, (uint8_t*)nullptr + addr, byte_size);
453             return true;
454         }
455         else
456         {
457             if (exe_ctx)
458             {
459                 Process *process = exe_ctx->GetProcessPtr();
460                 if (process)
461                 {
462                     Error error;
463                     return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size, error) == byte_size;
464                 }
465             }
466         }
467     }
468     return false;
469 }
470 
471 
472 bool
473 Type::WriteToMemory (ExecutionContext *exe_ctx, lldb::addr_t addr, AddressType address_type, DataExtractor &data)
474 {
475     return false;
476 }
477 
478 
479 TypeList*
480 Type::GetTypeList()
481 {
482     return GetSymbolFile()->GetTypeList();
483 }
484 
485 const Declaration &
486 Type::GetDeclaration () const
487 {
488     return m_decl;
489 }
490 
491 bool
492 Type::ResolveClangType (ResolveState clang_type_resolve_state)
493 {
494     Type *encoding_type = nullptr;
495     if (!m_clang_type.IsValid())
496     {
497         encoding_type = GetEncodingType();
498         if (encoding_type)
499         {
500             switch (m_encoding_uid_type)
501             {
502             case eEncodingIsUID:
503                 {
504                     ClangASTType encoding_clang_type = encoding_type->GetClangForwardType();
505                     if (encoding_clang_type.IsValid())
506                     {
507                         m_clang_type = encoding_clang_type;
508                         m_flags.clang_type_resolve_state = encoding_type->m_flags.clang_type_resolve_state;
509                     }
510                 }
511                 break;
512 
513             case eEncodingIsConstUID:
514                 m_clang_type = encoding_type->GetClangForwardType().AddConstModifier();
515                 break;
516 
517             case eEncodingIsRestrictUID:
518                 m_clang_type = encoding_type->GetClangForwardType().AddRestrictModifier();
519                 break;
520 
521             case eEncodingIsVolatileUID:
522                 m_clang_type = encoding_type->GetClangForwardType().AddVolatileModifier();
523                 break;
524 
525             case eEncodingIsTypedefUID:
526                 m_clang_type = encoding_type->GetClangForwardType().CreateTypedefType (GetName().AsCString(),
527                                                                                        GetSymbolFile()->GetClangDeclContextContainingTypeUID(GetID()));
528                 m_name.Clear();
529                 break;
530 
531             case eEncodingIsPointerUID:
532                 m_clang_type = encoding_type->GetClangForwardType().GetPointerType();
533                 break;
534 
535             case eEncodingIsLValueReferenceUID:
536                 m_clang_type = encoding_type->GetClangForwardType().GetLValueReferenceType();
537                 break;
538 
539             case eEncodingIsRValueReferenceUID:
540                 m_clang_type = encoding_type->GetClangForwardType().GetRValueReferenceType();
541                 break;
542 
543             default:
544                 assert(!"Unhandled encoding_data_type.");
545                 break;
546             }
547         }
548         else
549         {
550             // We have no encoding type, return void?
551             ClangASTType void_clang_type (ClangASTContext::GetBasicType(GetClangASTContext().getASTContext(), eBasicTypeVoid));
552             switch (m_encoding_uid_type)
553             {
554             case eEncodingIsUID:
555                 m_clang_type = void_clang_type;
556                 break;
557 
558             case eEncodingIsConstUID:
559                 m_clang_type = void_clang_type.AddConstModifier ();
560                 break;
561 
562             case eEncodingIsRestrictUID:
563                 m_clang_type = void_clang_type.AddRestrictModifier ();
564                 break;
565 
566             case eEncodingIsVolatileUID:
567                 m_clang_type = void_clang_type.AddVolatileModifier ();
568                 break;
569 
570             case eEncodingIsTypedefUID:
571                 m_clang_type = void_clang_type.CreateTypedefType (GetName().AsCString(),
572                                                                   GetSymbolFile()->GetClangDeclContextContainingTypeUID(GetID()));
573                 break;
574 
575             case eEncodingIsPointerUID:
576                 m_clang_type = void_clang_type.GetPointerType ();
577                 break;
578 
579             case eEncodingIsLValueReferenceUID:
580                 m_clang_type = void_clang_type.GetLValueReferenceType ();
581                 break;
582 
583             case eEncodingIsRValueReferenceUID:
584                 m_clang_type = void_clang_type.GetRValueReferenceType ();
585                 break;
586 
587             default:
588                 assert(!"Unhandled encoding_data_type.");
589                 break;
590             }
591         }
592 
593         // When we have a EncodingUID, our "m_flags.clang_type_resolve_state" is set to eResolveStateUnresolved
594         // so we need to update it to say that we now have a forward declaration since that is what we created
595         // above.
596         if (m_clang_type.IsValid())
597             m_flags.clang_type_resolve_state = eResolveStateForward;
598 
599     }
600 
601     // Check if we have a forward reference to a class/struct/union/enum?
602     if (clang_type_resolve_state == eResolveStateLayout || clang_type_resolve_state == eResolveStateFull)
603     {
604         // Check if we have a forward reference to a class/struct/union/enum?
605         if (m_clang_type.IsValid() && m_flags.clang_type_resolve_state < clang_type_resolve_state)
606         {
607             m_flags.clang_type_resolve_state = eResolveStateFull;
608             if (!m_clang_type.IsDefined ())
609             {
610                 // We have a forward declaration, we need to resolve it to a complete definition.
611                 m_symbol_file->ResolveClangOpaqueTypeDefinition (m_clang_type);
612             }
613         }
614     }
615 
616     // If we have an encoding type, then we need to make sure it is
617     // resolved appropriately.
618     if (m_encoding_uid != LLDB_INVALID_UID)
619     {
620         if (encoding_type == nullptr)
621             encoding_type = GetEncodingType();
622         if (encoding_type)
623         {
624             ResolveState encoding_clang_type_resolve_state = clang_type_resolve_state;
625 
626             if (clang_type_resolve_state == eResolveStateLayout)
627             {
628                 switch (m_encoding_uid_type)
629                 {
630                 case eEncodingIsPointerUID:
631                 case eEncodingIsLValueReferenceUID:
632                 case eEncodingIsRValueReferenceUID:
633                     encoding_clang_type_resolve_state = eResolveStateForward;
634                     break;
635                 default:
636                     break;
637                 }
638             }
639             encoding_type->ResolveClangType (encoding_clang_type_resolve_state);
640         }
641     }
642     return m_clang_type.IsValid();
643 }
644 uint32_t
645 Type::GetEncodingMask ()
646 {
647     uint32_t encoding_mask = 1u << m_encoding_uid_type;
648     Type *encoding_type = GetEncodingType();
649     assert (encoding_type != this);
650     if (encoding_type)
651         encoding_mask |= encoding_type->GetEncodingMask ();
652     return encoding_mask;
653 }
654 
655 ClangASTType
656 Type::GetClangFullType ()
657 {
658     ResolveClangType(eResolveStateFull);
659     return m_clang_type;
660 }
661 
662 ClangASTType
663 Type::GetClangLayoutType ()
664 {
665     ResolveClangType(eResolveStateLayout);
666     return m_clang_type;
667 }
668 
669 ClangASTType
670 Type::GetClangForwardType ()
671 {
672     ResolveClangType (eResolveStateForward);
673     return m_clang_type;
674 }
675 
676 ClangASTContext &
677 Type::GetClangASTContext ()
678 {
679     return m_symbol_file->GetClangASTContext();
680 }
681 
682 int
683 Type::Compare(const Type &a, const Type &b)
684 {
685     // Just compare the UID values for now...
686     lldb::user_id_t a_uid = a.GetID();
687     lldb::user_id_t b_uid = b.GetID();
688     if (a_uid < b_uid)
689         return -1;
690     if (a_uid > b_uid)
691         return 1;
692     return 0;
693 //  if (a.getQualType() == b.getQualType())
694 //      return 0;
695 }
696 
697 
698 #if 0  // START REMOVE
699 // Move this into ClangASTType
700 void *
701 Type::CreateClangPointerType (Type *type)
702 {
703     assert(type);
704     return GetClangASTContext().CreatePointerType(type->GetClangForwardType());
705 }
706 
707 void *
708 Type::CreateClangTypedefType (Type *typedef_type, Type *base_type)
709 {
710     assert(typedef_type && base_type);
711     return GetClangASTContext().CreateTypedefType (typedef_type->GetName().AsCString(),
712                                                    base_type->GetClangForwardType(),
713                                                    typedef_type->GetSymbolFile()->GetClangDeclContextContainingTypeUID(typedef_type->GetID()));
714 }
715 
716 void *
717 Type::CreateClangLValueReferenceType (Type *type)
718 {
719     assert(type);
720     return GetClangASTContext().CreateLValueReferenceType(type->GetClangForwardType());
721 }
722 
723 void *
724 Type::CreateClangRValueReferenceType (Type *type)
725 {
726     assert(type);
727     return GetClangASTContext().CreateRValueReferenceType (type->GetClangForwardType());
728 }
729 #endif // END REMOVE
730 
731 bool
732 Type::IsRealObjCClass()
733 {
734     // For now we are just skipping ObjC classes that get made by hand from the runtime, because
735     // those don't have any information.  We could extend this to only return true for "full
736     // definitions" if we can figure that out.
737 
738     if (m_clang_type.IsObjCObjectOrInterfaceType() && GetByteSize() != 0)
739         return true;
740     else
741         return false;
742 }
743 
744 ConstString
745 Type::GetQualifiedName ()
746 {
747     return GetClangForwardType().GetConstTypeName();
748 }
749 
750 
751 bool
752 Type::GetTypeScopeAndBasename (const char* &name_cstr,
753                                std::string &scope,
754                                std::string &basename,
755                                TypeClass &type_class)
756 {
757     // Protect against null c string.
758 
759     type_class = eTypeClassAny;
760 
761     if (name_cstr && name_cstr[0])
762     {
763         llvm::StringRef name_strref(name_cstr);
764         if (name_strref.startswith("struct "))
765         {
766             name_cstr += 7;
767             type_class = eTypeClassStruct;
768         }
769         else if (name_strref.startswith("class "))
770         {
771             name_cstr += 6;
772             type_class = eTypeClassClass;
773         }
774         else if (name_strref.startswith("union "))
775         {
776             name_cstr += 6;
777             type_class = eTypeClassUnion;
778         }
779         else if (name_strref.startswith("enum "))
780         {
781             name_cstr += 5;
782             type_class = eTypeClassEnumeration;
783         }
784         else if (name_strref.startswith("typedef "))
785         {
786             name_cstr += 8;
787             type_class = eTypeClassTypedef;
788         }
789         const char *basename_cstr = name_cstr;
790         const char* namespace_separator = ::strstr (basename_cstr, "::");
791         if (namespace_separator)
792         {
793             const char* template_arg_char = ::strchr (basename_cstr, '<');
794             while (namespace_separator != nullptr)
795             {
796                 if (template_arg_char && namespace_separator > template_arg_char) // but namespace'd template arguments are still good to go
797                     break;
798                 basename_cstr = namespace_separator + 2;
799                 namespace_separator = strstr(basename_cstr, "::");
800             }
801             if (basename_cstr > name_cstr)
802             {
803                 scope.assign (name_cstr, basename_cstr - name_cstr);
804                 basename.assign (basename_cstr);
805                 return true;
806             }
807         }
808     }
809     return false;
810 }
811 
812 
813 ModuleSP
814 Type::GetModule()
815 {
816     if (m_symbol_file)
817         return m_symbol_file->GetObjectFile()->GetModule();
818     return ModuleSP();
819 }
820 
821 
822 TypeAndOrName::TypeAndOrName () : m_type_pair(), m_type_name()
823 {
824 
825 }
826 
827 TypeAndOrName::TypeAndOrName (TypeSP &in_type_sp) : m_type_pair(in_type_sp)
828 {
829     if (in_type_sp)
830         m_type_name = in_type_sp->GetName();
831 }
832 
833 TypeAndOrName::TypeAndOrName (const char *in_type_str) : m_type_name(in_type_str)
834 {
835 }
836 
837 TypeAndOrName::TypeAndOrName (const TypeAndOrName &rhs) : m_type_pair (rhs.m_type_pair), m_type_name (rhs.m_type_name)
838 {
839 
840 }
841 
842 TypeAndOrName::TypeAndOrName (ConstString &in_type_const_string) : m_type_name (in_type_const_string)
843 {
844 }
845 
846 TypeAndOrName &
847 TypeAndOrName::operator= (const TypeAndOrName &rhs)
848 {
849     if (this != &rhs)
850     {
851         m_type_name = rhs.m_type_name;
852         m_type_pair = rhs.m_type_pair;
853     }
854     return *this;
855 }
856 
857 bool
858 TypeAndOrName::operator==(const TypeAndOrName &other) const
859 {
860     if (m_type_pair != other.m_type_pair)
861         return false;
862     if (m_type_name != other.m_type_name)
863         return false;
864     return true;
865 }
866 
867 bool
868 TypeAndOrName::operator!=(const TypeAndOrName &other) const
869 {
870     if (m_type_pair != other.m_type_pair)
871         return true;
872     if (m_type_name != other.m_type_name)
873         return true;
874     return false;
875 }
876 
877 ConstString
878 TypeAndOrName::GetName () const
879 {
880     if (m_type_name)
881         return m_type_name;
882     if (m_type_pair)
883         return m_type_pair.GetName();
884     return ConstString("<invalid>");
885 }
886 
887 void
888 TypeAndOrName::SetName (const ConstString &type_name)
889 {
890     m_type_name = type_name;
891 }
892 
893 void
894 TypeAndOrName::SetName (const char *type_name_cstr)
895 {
896     m_type_name.SetCString (type_name_cstr);
897 }
898 
899 void
900 TypeAndOrName::SetTypeSP (lldb::TypeSP type_sp)
901 {
902     m_type_pair.SetType(type_sp);
903     if (m_type_pair)
904         m_type_name = m_type_pair.GetName();
905 }
906 
907 void
908 TypeAndOrName::SetClangASTType (ClangASTType clang_type)
909 {
910     m_type_pair.SetType(clang_type);
911     if (m_type_pair)
912         m_type_name = m_type_pair.GetName();
913 }
914 
915 bool
916 TypeAndOrName::IsEmpty()  const
917 {
918     if ((bool)m_type_name || (bool)m_type_pair)
919         return false;
920     else
921         return true;
922 }
923 
924 void
925 TypeAndOrName::Clear ()
926 {
927     m_type_name.Clear();
928     m_type_pair.Clear();
929 }
930 
931 bool
932 TypeAndOrName::HasName () const
933 {
934     return (bool)m_type_name;
935 }
936 
937 bool
938 TypeAndOrName::HasTypeSP () const
939 {
940     return m_type_pair.GetTypeSP().get() != nullptr;
941 }
942 
943 bool
944 TypeAndOrName::HasClangASTType () const
945 {
946     return m_type_pair.GetClangASTType().IsValid();
947 }
948 
949 
950 TypeImpl::TypeImpl() :
951     m_module_wp(),
952     m_static_type(),
953     m_dynamic_type()
954 {
955 }
956 
957 TypeImpl::TypeImpl(const TypeImpl& rhs) :
958     m_module_wp (rhs.m_module_wp),
959     m_static_type(rhs.m_static_type),
960     m_dynamic_type(rhs.m_dynamic_type)
961 {
962 }
963 
964 TypeImpl::TypeImpl (const lldb::TypeSP &type_sp) :
965     m_module_wp (),
966     m_static_type(),
967     m_dynamic_type()
968 {
969     SetType (type_sp);
970 }
971 
972 TypeImpl::TypeImpl (const ClangASTType &clang_type) :
973     m_module_wp (),
974     m_static_type(),
975     m_dynamic_type()
976 {
977     SetType (clang_type);
978 }
979 
980 TypeImpl::TypeImpl (const lldb::TypeSP &type_sp, const ClangASTType &dynamic) :
981     m_module_wp (),
982     m_static_type (type_sp),
983     m_dynamic_type(dynamic)
984 {
985     SetType (type_sp, dynamic);
986 }
987 
988 TypeImpl::TypeImpl (const ClangASTType &static_type, const ClangASTType &dynamic_type) :
989     m_module_wp (),
990     m_static_type (),
991     m_dynamic_type()
992 {
993     SetType (static_type, dynamic_type);
994 }
995 
996 TypeImpl::TypeImpl (const TypePair &pair, const ClangASTType &dynamic) :
997     m_module_wp (),
998     m_static_type (),
999     m_dynamic_type()
1000 {
1001     SetType (pair, dynamic);
1002 }
1003 
1004 void
1005 TypeImpl::SetType (const lldb::TypeSP &type_sp)
1006 {
1007     m_static_type.SetType(type_sp);
1008     if (type_sp)
1009         m_module_wp = type_sp->GetModule();
1010     else
1011         m_module_wp = lldb::ModuleWP();
1012 }
1013 
1014 void
1015 TypeImpl::SetType (const ClangASTType &clang_type)
1016 {
1017     m_module_wp = lldb::ModuleWP();
1018     m_static_type.SetType (clang_type);
1019 }
1020 
1021 void
1022 TypeImpl::SetType (const lldb::TypeSP &type_sp, const ClangASTType &dynamic)
1023 {
1024     SetType (type_sp);
1025     m_dynamic_type = dynamic;
1026 }
1027 
1028 void
1029 TypeImpl::SetType (const ClangASTType &clang_type, const ClangASTType &dynamic)
1030 {
1031     m_module_wp = lldb::ModuleWP();
1032     m_static_type.SetType (clang_type);
1033     m_dynamic_type = dynamic;
1034 }
1035 
1036 void
1037 TypeImpl::SetType (const TypePair &pair, const ClangASTType &dynamic)
1038 {
1039     m_module_wp = pair.GetModule();
1040     m_static_type = pair;
1041     m_dynamic_type = dynamic;
1042 }
1043 
1044 TypeImpl&
1045 TypeImpl::operator = (const TypeImpl& rhs)
1046 {
1047     if (rhs != *this)
1048     {
1049         m_module_wp = rhs.m_module_wp;
1050         m_static_type = rhs.m_static_type;
1051         m_dynamic_type = rhs.m_dynamic_type;
1052     }
1053     return *this;
1054 }
1055 
1056 bool
1057 TypeImpl::CheckModule (lldb::ModuleSP &module_sp) const
1058 {
1059     // Check if we have a module for this type. If we do and the shared pointer is
1060     // can be successfully initialized with m_module_wp, return true. Else return false
1061     // if we didn't have a module, or if we had a module and it has been deleted. Any
1062     // functions doing anything with a TypeSP in this TypeImpl class should call this
1063     // function and only do anything with the ivars if this function returns true. If
1064     // we have a module, the "module_sp" will be filled in with a strong reference to the
1065     // module so that the module will at least stay around long enough for the type
1066     // query to succeed.
1067     module_sp = m_module_wp.lock();
1068     if (!module_sp)
1069     {
1070         lldb::ModuleWP empty_module_wp;
1071         // If either call to "std::weak_ptr::owner_before(...) value returns true, this
1072         // indicates that m_module_wp once contained (possibly still does) a reference
1073         // to a valid shared pointer. This helps us know if we had a valid reference to
1074         // a section which is now invalid because the module it was in was deleted
1075         if (empty_module_wp.owner_before(m_module_wp) || m_module_wp.owner_before(empty_module_wp))
1076         {
1077             // m_module_wp had a valid reference to a module, but all strong references
1078             // have been released and the module has been deleted
1079             return false;
1080         }
1081     }
1082     // We either successfully locked the module, or didn't have one to begin with
1083     return true;
1084 }
1085 
1086 bool
1087 TypeImpl::operator == (const TypeImpl& rhs) const
1088 {
1089     return m_static_type == rhs.m_static_type && m_dynamic_type == rhs.m_dynamic_type;
1090 }
1091 
1092 bool
1093 TypeImpl::operator != (const TypeImpl& rhs) const
1094 {
1095     return m_static_type != rhs.m_static_type || m_dynamic_type != rhs.m_dynamic_type;
1096 }
1097 
1098 bool
1099 TypeImpl::IsValid() const
1100 {
1101     // just a name is not valid
1102     ModuleSP module_sp;
1103     if (CheckModule (module_sp))
1104         return m_static_type.IsValid() || m_dynamic_type.IsValid();
1105     return false;
1106 }
1107 
1108 TypeImpl::operator bool () const
1109 {
1110     return IsValid();
1111 }
1112 
1113 void
1114 TypeImpl::Clear()
1115 {
1116     m_module_wp = lldb::ModuleWP();
1117     m_static_type.Clear();
1118     m_dynamic_type.Clear();
1119 }
1120 
1121 ConstString
1122 TypeImpl::GetName ()  const
1123 {
1124     ModuleSP module_sp;
1125     if (CheckModule (module_sp))
1126     {
1127         if (m_dynamic_type)
1128             return m_dynamic_type.GetTypeName();
1129         return m_static_type.GetName ();
1130     }
1131     return ConstString();
1132 }
1133 
1134 ConstString
1135 TypeImpl::GetDisplayTypeName ()  const
1136 {
1137     ModuleSP module_sp;
1138     if (CheckModule (module_sp))
1139     {
1140         if (m_dynamic_type)
1141             return m_dynamic_type.GetDisplayTypeName();
1142         return m_static_type.GetDisplayTypeName();
1143     }
1144     return ConstString();
1145 }
1146 
1147 TypeImpl
1148 TypeImpl::GetPointerType () const
1149 {
1150     ModuleSP module_sp;
1151     if (CheckModule (module_sp))
1152     {
1153         if (m_dynamic_type.IsValid())
1154         {
1155             return TypeImpl(m_static_type.GetPointerType(), m_dynamic_type.GetPointerType());
1156         }
1157         return TypeImpl(m_static_type.GetPointerType());
1158     }
1159     return TypeImpl();
1160 }
1161 
1162 TypeImpl
1163 TypeImpl::GetPointeeType () const
1164 {
1165     ModuleSP module_sp;
1166     if (CheckModule (module_sp))
1167     {
1168         if (m_dynamic_type.IsValid())
1169         {
1170             return TypeImpl(m_static_type.GetPointeeType(), m_dynamic_type.GetPointeeType());
1171         }
1172         return TypeImpl(m_static_type.GetPointeeType());
1173     }
1174     return TypeImpl();
1175 }
1176 
1177 TypeImpl
1178 TypeImpl::GetReferenceType () const
1179 {
1180     ModuleSP module_sp;
1181     if (CheckModule (module_sp))
1182     {
1183         if (m_dynamic_type.IsValid())
1184         {
1185             return TypeImpl(m_static_type.GetReferenceType(), m_dynamic_type.GetLValueReferenceType());
1186         }
1187         return TypeImpl(m_static_type.GetReferenceType());
1188     }
1189     return TypeImpl();
1190 }
1191 
1192 TypeImpl
1193 TypeImpl::GetTypedefedType () const
1194 {
1195     ModuleSP module_sp;
1196     if (CheckModule (module_sp))
1197     {
1198         if (m_dynamic_type.IsValid())
1199         {
1200             return TypeImpl(m_static_type.GetTypedefedType(), m_dynamic_type.GetTypedefedType());
1201         }
1202         return TypeImpl(m_static_type.GetTypedefedType());
1203     }
1204     return TypeImpl();
1205 }
1206 
1207 TypeImpl
1208 TypeImpl::GetDereferencedType () const
1209 {
1210     ModuleSP module_sp;
1211     if (CheckModule (module_sp))
1212     {
1213         if (m_dynamic_type.IsValid())
1214         {
1215             return TypeImpl(m_static_type.GetDereferencedType(), m_dynamic_type.GetNonReferenceType());
1216         }
1217         return TypeImpl(m_static_type.GetDereferencedType());
1218     }
1219     return TypeImpl();
1220 }
1221 
1222 TypeImpl
1223 TypeImpl::GetUnqualifiedType() const
1224 {
1225     ModuleSP module_sp;
1226     if (CheckModule (module_sp))
1227     {
1228         if (m_dynamic_type.IsValid())
1229         {
1230             return TypeImpl(m_static_type.GetUnqualifiedType(), m_dynamic_type.GetFullyUnqualifiedType());
1231         }
1232         return TypeImpl(m_static_type.GetUnqualifiedType());
1233     }
1234     return TypeImpl();
1235 }
1236 
1237 TypeImpl
1238 TypeImpl::GetCanonicalType() const
1239 {
1240     ModuleSP module_sp;
1241     if (CheckModule (module_sp))
1242     {
1243         if (m_dynamic_type.IsValid())
1244         {
1245             return TypeImpl(m_static_type.GetCanonicalType(), m_dynamic_type.GetCanonicalType());
1246         }
1247         return TypeImpl(m_static_type.GetCanonicalType());
1248     }
1249     return TypeImpl();
1250 }
1251 
1252 ClangASTType
1253 TypeImpl::GetClangASTType (bool prefer_dynamic)
1254 {
1255     ModuleSP module_sp;
1256     if (CheckModule (module_sp))
1257     {
1258         if (prefer_dynamic)
1259         {
1260             if (m_dynamic_type.IsValid())
1261                 return m_dynamic_type;
1262         }
1263         return m_static_type.GetClangASTType();
1264     }
1265     return ClangASTType();
1266 }
1267 
1268 clang::ASTContext *
1269 TypeImpl::GetClangASTContext (bool prefer_dynamic)
1270 {
1271     ModuleSP module_sp;
1272     if (CheckModule (module_sp))
1273     {
1274         if (prefer_dynamic)
1275         {
1276             if (m_dynamic_type.IsValid())
1277                 return m_dynamic_type.GetASTContext();
1278         }
1279         return m_static_type.GetClangASTContext();
1280     }
1281     return NULL;
1282 }
1283 
1284 bool
1285 TypeImpl::GetDescription (lldb_private::Stream &strm,
1286                           lldb::DescriptionLevel description_level)
1287 {
1288     ModuleSP module_sp;
1289     if (CheckModule (module_sp))
1290     {
1291         if (m_dynamic_type.IsValid())
1292         {
1293             strm.Printf("Dynamic:\n");
1294             m_dynamic_type.DumpTypeDescription(&strm);
1295             strm.Printf("\nStatic:\n");
1296         }
1297         m_static_type.GetClangASTType().DumpTypeDescription(&strm);
1298     }
1299     else
1300     {
1301         strm.PutCString("Invalid TypeImpl module for type has been deleted\n");
1302     }
1303     return true;
1304 }
1305 
1306 TypeMemberFunctionImpl&
1307 TypeMemberFunctionImpl::operator = (const TypeMemberFunctionImpl& rhs)
1308 {
1309     if (this != &rhs)
1310     {
1311         m_type = rhs.m_type;
1312         m_objc_method_decl = rhs.m_objc_method_decl;
1313         m_name = rhs.m_name;
1314         m_kind = rhs.m_kind;
1315     }
1316     return *this;
1317 }
1318 
1319 bool
1320 TypeMemberFunctionImpl::IsValid ()
1321 {
1322     return m_type.IsValid() && m_kind != lldb::eMemberFunctionKindUnknown;
1323 }
1324 
1325 ConstString
1326 TypeMemberFunctionImpl::GetName () const
1327 {
1328     return m_name;
1329 }
1330 
1331 ClangASTType
1332 TypeMemberFunctionImpl::GetType () const
1333 {
1334     return m_type;
1335 }
1336 
1337 lldb::MemberFunctionKind
1338 TypeMemberFunctionImpl::GetKind () const
1339 {
1340     return m_kind;
1341 }
1342 
1343 std::string
1344 TypeMemberFunctionImpl::GetPrintableTypeName ()
1345 {
1346     if (m_type)
1347         return m_type.GetTypeName().AsCString("<unknown>");
1348     if (m_objc_method_decl)
1349     {
1350         if (m_objc_method_decl->getClassInterface())
1351         {
1352             return m_objc_method_decl->getClassInterface()->getName();
1353         }
1354     }
1355     return "<unknown>";
1356 }
1357 
1358 bool
1359 TypeMemberFunctionImpl::GetDescription (Stream& stream)
1360 {
1361     switch (m_kind) {
1362         case lldb::eMemberFunctionKindUnknown:
1363             return false;
1364         case lldb::eMemberFunctionKindConstructor:
1365             stream.Printf("constructor for %s", GetPrintableTypeName().c_str());
1366             break;
1367         case lldb::eMemberFunctionKindDestructor:
1368             stream.Printf("destructor for %s",  GetPrintableTypeName().c_str());
1369             break;
1370         case lldb::eMemberFunctionKindInstanceMethod:
1371             stream.Printf("instance method %s of type %s",
1372                           m_name.AsCString(),
1373                           GetPrintableTypeName().c_str());
1374             break;
1375         case lldb::eMemberFunctionKindStaticMethod:
1376             stream.Printf("static method %s of type %s",
1377                           m_name.AsCString(),
1378                           GetPrintableTypeName().c_str());
1379             break;
1380     }
1381     return true;
1382 }
1383 
1384 ClangASTType
1385 TypeMemberFunctionImpl::GetReturnType () const
1386 {
1387     if (m_type)
1388         return m_type.GetFunctionReturnType();
1389     if (m_objc_method_decl)
1390         return ClangASTType(&m_objc_method_decl->getASTContext(),m_objc_method_decl->getReturnType().getAsOpaquePtr());
1391     return ClangASTType();
1392 }
1393 
1394 size_t
1395 TypeMemberFunctionImpl::GetNumArguments () const
1396 {
1397     if (m_type)
1398         return m_type.GetNumberOfFunctionArguments();
1399     if (m_objc_method_decl)
1400         return m_objc_method_decl->param_size();
1401     return 0;
1402 }
1403 
1404 ClangASTType
1405 TypeMemberFunctionImpl::GetArgumentAtIndex (size_t idx) const
1406 {
1407     if (m_type)
1408         return m_type.GetFunctionArgumentAtIndex (idx);
1409     if (m_objc_method_decl)
1410     {
1411         if (idx < m_objc_method_decl->param_size())
1412             return ClangASTType(&m_objc_method_decl->getASTContext(), m_objc_method_decl->parameters()[idx]->getOriginalType().getAsOpaquePtr());
1413     }
1414     return ClangASTType();
1415 }
1416 
1417 TypeEnumMemberImpl::TypeEnumMemberImpl (const clang::EnumConstantDecl* enum_member_decl,
1418                                         const lldb_private::ClangASTType& integer_type) :
1419     m_integer_type_sp(),
1420     m_name(),
1421     m_value(),
1422     m_valid(false)
1423 
1424 {
1425     if (enum_member_decl)
1426     {
1427         m_integer_type_sp.reset(new TypeImpl(integer_type));
1428         m_name = ConstString(enum_member_decl->getNameAsString().c_str());
1429         m_value = enum_member_decl->getInitVal();
1430         m_valid = true;
1431     }
1432 }
1433