1 //===-- CompilerType.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/Symbol/CompilerType.h"
11 
12 #include "lldb/Core/ConstString.h"
13 #include "lldb/Core/DataBufferHeap.h"
14 #include "lldb/Core/DataExtractor.h"
15 #include "lldb/Core/Debugger.h"
16 #include "lldb/Core/Scalar.h"
17 #include "lldb/Core/Stream.h"
18 #include "lldb/Core/StreamFile.h"
19 #include "lldb/Core/StreamString.h"
20 #include "lldb/Symbol/ClangASTContext.h"
21 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
22 #include "lldb/Symbol/Type.h"
23 #include "lldb/Target/ExecutionContext.h"
24 #include "lldb/Target/Process.h"
25 
26 #include <iterator>
27 #include <mutex>
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 CompilerType::CompilerType (TypeSystem *type_system,
33                             lldb::opaque_compiler_type_t type) :
34     m_type (type),
35     m_type_system (type_system)
36 {
37 }
38 
39 CompilerType::CompilerType (clang::ASTContext *ast,
40                             clang::QualType qual_type) :
41     m_type (qual_type.getAsOpaquePtr()),
42     m_type_system (ClangASTContext::GetASTContext(ast))
43 {
44 #ifdef LLDB_CONFIGURATION_DEBUG
45     if (m_type)
46         assert(m_type_system != nullptr);
47 #endif
48 }
49 
50 CompilerType::~CompilerType()
51 {
52 }
53 
54 //----------------------------------------------------------------------
55 // Tests
56 //----------------------------------------------------------------------
57 
58 bool
59 CompilerType::IsAggregateType () const
60 {
61     if (IsValid())
62         return m_type_system->IsAggregateType(m_type);
63     return false;
64 }
65 
66 bool
67 CompilerType::IsAnonymousType () const
68 {
69     if (IsValid())
70         return m_type_system->IsAnonymousType(m_type);
71     return false;
72 }
73 
74 bool
75 CompilerType::IsArrayType (CompilerType *element_type_ptr,
76                            uint64_t *size,
77                            bool *is_incomplete) const
78 {
79     if (IsValid())
80         return m_type_system->IsArrayType(m_type, element_type_ptr, size, is_incomplete);
81 
82     if (element_type_ptr)
83         element_type_ptr->Clear();
84     if (size)
85         *size = 0;
86     if (is_incomplete)
87         *is_incomplete = false;
88     return false;
89 }
90 
91 bool
92 CompilerType::IsVectorType (CompilerType *element_type,
93                             uint64_t *size) const
94 {
95     if (IsValid())
96         return m_type_system->IsVectorType(m_type, element_type, size);
97     return false;
98 }
99 
100 bool
101 CompilerType::IsRuntimeGeneratedType () const
102 {
103     if (IsValid())
104         return m_type_system->IsRuntimeGeneratedType(m_type);
105     return false;
106 }
107 
108 bool
109 CompilerType::IsCharType () const
110 {
111     if (IsValid())
112         return m_type_system->IsCharType(m_type);
113     return false;
114 }
115 
116 
117 bool
118 CompilerType::IsCompleteType () const
119 {
120     if (IsValid())
121         return m_type_system->IsCompleteType(m_type);
122     return false;
123 }
124 
125 bool
126 CompilerType::IsConst() const
127 {
128     if (IsValid())
129         return m_type_system->IsConst(m_type);
130     return false;
131 }
132 
133 bool
134 CompilerType::IsCStringType (uint32_t &length) const
135 {
136     if (IsValid())
137         return m_type_system->IsCStringType(m_type, length);
138     return false;
139 }
140 
141 bool
142 CompilerType::IsFunctionType (bool *is_variadic_ptr) const
143 {
144     if (IsValid())
145         return m_type_system->IsFunctionType(m_type, is_variadic_ptr);
146     return false;
147 }
148 
149 // Used to detect "Homogeneous Floating-point Aggregates"
150 uint32_t
151 CompilerType::IsHomogeneousAggregate (CompilerType* base_type_ptr) const
152 {
153     if (IsValid())
154         return m_type_system->IsHomogeneousAggregate(m_type, base_type_ptr);
155     return 0;
156 }
157 
158 size_t
159 CompilerType::GetNumberOfFunctionArguments () const
160 {
161     if (IsValid())
162         return m_type_system->GetNumberOfFunctionArguments(m_type);
163     return 0;
164 }
165 
166 CompilerType
167 CompilerType::GetFunctionArgumentAtIndex (const size_t index) const
168 {
169     if (IsValid())
170         return m_type_system->GetFunctionArgumentAtIndex(m_type, index);
171     return CompilerType();
172 }
173 
174 bool
175 CompilerType::IsFunctionPointerType () const
176 {
177     if (IsValid())
178         return m_type_system->IsFunctionPointerType(m_type);
179     return false;
180 
181 }
182 
183 bool
184 CompilerType::IsIntegerType (bool &is_signed) const
185 {
186     if (IsValid())
187         return m_type_system->IsIntegerType(m_type, is_signed);
188     return false;
189 }
190 
191 bool
192 CompilerType::IsPointerType (CompilerType *pointee_type) const
193 {
194     if (IsValid())
195     {
196         return m_type_system->IsPointerType(m_type, pointee_type);
197     }
198     if (pointee_type)
199         pointee_type->Clear();
200     return false;
201 }
202 
203 
204 bool
205 CompilerType::IsPointerOrReferenceType (CompilerType *pointee_type) const
206 {
207     if (IsValid())
208     {
209         return m_type_system->IsPointerOrReferenceType(m_type, pointee_type);
210     }
211     if (pointee_type)
212         pointee_type->Clear();
213     return false;
214 }
215 
216 
217 bool
218 CompilerType::IsReferenceType (CompilerType *pointee_type, bool* is_rvalue) const
219 {
220     if (IsValid())
221     {
222         return m_type_system->IsReferenceType(m_type, pointee_type, is_rvalue);
223     }
224     if (pointee_type)
225         pointee_type->Clear();
226     return false;
227 }
228 
229 bool
230 CompilerType::ShouldTreatScalarValueAsAddress () const
231 {
232     if (IsValid())
233         return m_type_system->ShouldTreatScalarValueAsAddress(m_type);
234     return false;
235 }
236 
237 bool
238 CompilerType::IsFloatingPointType (uint32_t &count, bool &is_complex) const
239 {
240     if (IsValid())
241     {
242         return m_type_system->IsFloatingPointType(m_type, count, is_complex);
243     }
244     count = 0;
245     is_complex = false;
246     return false;
247 }
248 
249 
250 bool
251 CompilerType::IsDefined() const
252 {
253     if (IsValid())
254         return m_type_system->IsDefined(m_type);
255     return true;
256 }
257 
258 bool
259 CompilerType::IsPolymorphicClass () const
260 {
261     if (IsValid())
262     {
263         return m_type_system->IsPolymorphicClass(m_type);
264     }
265     return false;
266 }
267 
268 bool
269 CompilerType::IsPossibleDynamicType (CompilerType *dynamic_pointee_type,
270                                      bool check_cplusplus,
271                                      bool check_objc) const
272 {
273     if (IsValid())
274         return m_type_system->IsPossibleDynamicType(m_type, dynamic_pointee_type, check_cplusplus, check_objc);
275     return false;
276 }
277 
278 
279 bool
280 CompilerType::IsScalarType () const
281 {
282     if (!IsValid())
283         return false;
284 
285     return m_type_system->IsScalarType(m_type);
286 }
287 
288 bool
289 CompilerType::IsTypedefType () const
290 {
291     if (!IsValid())
292         return false;
293     return m_type_system->IsTypedefType(m_type);
294 }
295 
296 bool
297 CompilerType::IsVoidType () const
298 {
299     if (!IsValid())
300         return false;
301     return m_type_system->IsVoidType(m_type);
302 }
303 
304 bool
305 CompilerType::IsPointerToScalarType () const
306 {
307     if (!IsValid())
308         return false;
309 
310     return IsPointerType() && GetPointeeType().IsScalarType();
311 }
312 
313 bool
314 CompilerType::IsArrayOfScalarType () const
315 {
316     CompilerType element_type;
317     if (IsArrayType(&element_type, nullptr, nullptr))
318         return element_type.IsScalarType();
319     return false;
320 }
321 
322 bool
323 CompilerType::IsBeingDefined () const
324 {
325     if (!IsValid())
326         return false;
327     return m_type_system->IsBeingDefined(m_type);
328 }
329 
330 //----------------------------------------------------------------------
331 // Type Completion
332 //----------------------------------------------------------------------
333 
334 bool
335 CompilerType::GetCompleteType () const
336 {
337     if (!IsValid())
338         return false;
339     return m_type_system->GetCompleteType(m_type);
340 }
341 
342 //----------------------------------------------------------------------
343 // AST related queries
344 //----------------------------------------------------------------------
345 size_t
346 CompilerType::GetPointerByteSize () const
347 {
348     if (m_type_system)
349         return m_type_system->GetPointerByteSize();
350     return 0;
351 }
352 
353 ConstString
354 CompilerType::GetConstQualifiedTypeName () const
355 {
356     return GetConstTypeName ();
357 }
358 
359 ConstString
360 CompilerType::GetConstTypeName () const
361 {
362     if (IsValid())
363     {
364         ConstString type_name (GetTypeName());
365         if (type_name)
366             return type_name;
367     }
368     return ConstString("<invalid>");
369 }
370 
371 ConstString
372 CompilerType::GetTypeName () const
373 {
374     if (IsValid())
375     {
376         return m_type_system->GetTypeName(m_type);
377     }
378     return ConstString("<invalid>");
379 }
380 
381 ConstString
382 CompilerType::GetDisplayTypeName () const
383 {
384     return GetTypeName();
385 }
386 
387 uint32_t
388 CompilerType::GetTypeInfo (CompilerType *pointee_or_element_compiler_type) const
389 {
390     if (!IsValid())
391         return 0;
392 
393     return m_type_system->GetTypeInfo(m_type, pointee_or_element_compiler_type);
394 }
395 
396 
397 
398 lldb::LanguageType
399 CompilerType::GetMinimumLanguage ()
400 {
401     if (!IsValid())
402         return lldb::eLanguageTypeC;
403 
404     return m_type_system->GetMinimumLanguage(m_type);
405 }
406 
407 lldb::TypeClass
408 CompilerType::GetTypeClass () const
409 {
410     if (!IsValid())
411         return lldb::eTypeClassInvalid;
412 
413     return m_type_system->GetTypeClass(m_type);
414 
415 }
416 
417 void
418 CompilerType::SetCompilerType (TypeSystem* type_system, lldb::opaque_compiler_type_t type)
419 {
420     m_type_system = type_system;
421     m_type = type;
422 }
423 
424 void
425 CompilerType::SetCompilerType (clang::ASTContext *ast, clang::QualType qual_type)
426 {
427     m_type_system = ClangASTContext::GetASTContext(ast);
428     m_type = qual_type.getAsOpaquePtr();
429 }
430 
431 unsigned
432 CompilerType::GetTypeQualifiers() const
433 {
434     if (IsValid())
435         return m_type_system->GetTypeQualifiers(m_type);
436     return 0;
437 }
438 
439 //----------------------------------------------------------------------
440 // Creating related types
441 //----------------------------------------------------------------------
442 
443 CompilerType
444 CompilerType::GetArrayElementType (uint64_t *stride) const
445 {
446     if (IsValid())
447     {
448         return m_type_system->GetArrayElementType(m_type, stride);
449 
450     }
451     return CompilerType();
452 }
453 
454 CompilerType
455 CompilerType::GetCanonicalType () const
456 {
457     if (IsValid())
458         return m_type_system->GetCanonicalType(m_type);
459     return CompilerType();
460 }
461 
462 CompilerType
463 CompilerType::GetFullyUnqualifiedType () const
464 {
465     if (IsValid())
466         return m_type_system->GetFullyUnqualifiedType(m_type);
467     return CompilerType();
468 }
469 
470 
471 int
472 CompilerType::GetFunctionArgumentCount () const
473 {
474     if (IsValid())
475     {
476         return m_type_system->GetFunctionArgumentCount(m_type);
477     }
478     return -1;
479 }
480 
481 CompilerType
482 CompilerType::GetFunctionArgumentTypeAtIndex (size_t idx) const
483 {
484     if (IsValid())
485     {
486         return m_type_system->GetFunctionArgumentTypeAtIndex(m_type, idx);
487     }
488     return CompilerType();
489 }
490 
491 CompilerType
492 CompilerType::GetFunctionReturnType () const
493 {
494     if (IsValid())
495     {
496         return m_type_system->GetFunctionReturnType(m_type);
497     }
498     return CompilerType();
499 }
500 
501 size_t
502 CompilerType::GetNumMemberFunctions () const
503 {
504     if (IsValid())
505     {
506         return m_type_system->GetNumMemberFunctions(m_type);
507     }
508     return 0;
509 }
510 
511 TypeMemberFunctionImpl
512 CompilerType::GetMemberFunctionAtIndex (size_t idx)
513 {
514     if (IsValid())
515     {
516         return m_type_system->GetMemberFunctionAtIndex(m_type, idx);
517     }
518     return TypeMemberFunctionImpl();
519 }
520 
521 CompilerType
522 CompilerType::GetNonReferenceType () const
523 {
524     if (IsValid())
525         return m_type_system->GetNonReferenceType(m_type);
526     return CompilerType();
527 }
528 
529 CompilerType
530 CompilerType::GetPointeeType () const
531 {
532     if (IsValid())
533     {
534         return m_type_system->GetPointeeType(m_type);
535     }
536     return CompilerType();
537 }
538 
539 CompilerType
540 CompilerType::GetPointerType () const
541 {
542     if (IsValid())
543     {
544         return m_type_system->GetPointerType(m_type);
545     }
546     return CompilerType();
547 }
548 
549 CompilerType
550 CompilerType::GetLValueReferenceType () const
551 {
552     if (IsValid())
553         return m_type_system->GetLValueReferenceType(m_type);
554     else
555         return CompilerType();
556 }
557 
558 CompilerType
559 CompilerType::GetRValueReferenceType () const
560 {
561     if (IsValid())
562         return m_type_system->GetRValueReferenceType(m_type);
563     else
564         return CompilerType();
565 }
566 
567 CompilerType
568 CompilerType::AddConstModifier () const
569 {
570     if (IsValid())
571         return m_type_system->AddConstModifier(m_type);
572     else
573         return CompilerType();
574 }
575 
576 CompilerType
577 CompilerType::AddVolatileModifier () const
578 {
579     if (IsValid())
580         return m_type_system->AddVolatileModifier(m_type);
581     else
582         return CompilerType();
583 }
584 
585 CompilerType
586 CompilerType::AddRestrictModifier () const
587 {
588     if (IsValid())
589         return m_type_system->AddRestrictModifier(m_type);
590     else
591         return CompilerType();
592 }
593 
594 CompilerType
595 CompilerType::CreateTypedef (const char *name, const CompilerDeclContext &decl_ctx) const
596 {
597     if (IsValid())
598         return m_type_system->CreateTypedef(m_type, name, decl_ctx);
599     else
600         return CompilerType();
601 }
602 
603 CompilerType
604 CompilerType::GetTypedefedType () const
605 {
606     if (IsValid())
607         return m_type_system->GetTypedefedType(m_type);
608     else
609         return CompilerType();
610 }
611 
612 //----------------------------------------------------------------------
613 // Create related types using the current type's AST
614 //----------------------------------------------------------------------
615 
616 CompilerType
617 CompilerType::GetBasicTypeFromAST (lldb::BasicType basic_type) const
618 {
619     if (IsValid())
620         return m_type_system->GetBasicTypeFromAST(basic_type);
621     return CompilerType();
622 }
623 //----------------------------------------------------------------------
624 // Exploring the type
625 //----------------------------------------------------------------------
626 
627 uint64_t
628 CompilerType::GetBitSize (ExecutionContextScope *exe_scope) const
629 {
630     if (IsValid())
631     {
632         return m_type_system->GetBitSize(m_type, exe_scope);
633     }
634     return 0;
635 }
636 
637 uint64_t
638 CompilerType::GetByteSize (ExecutionContextScope *exe_scope) const
639 {
640     return (GetBitSize (exe_scope) + 7) / 8;
641 }
642 
643 
644 size_t
645 CompilerType::GetTypeBitAlign () const
646 {
647     if (IsValid())
648         return m_type_system->GetTypeBitAlign(m_type);
649     return 0;
650 }
651 
652 
653 lldb::Encoding
654 CompilerType::GetEncoding (uint64_t &count) const
655 {
656     if (!IsValid())
657         return lldb::eEncodingInvalid;
658 
659     return m_type_system->GetEncoding(m_type, count);
660 }
661 
662 lldb::Format
663 CompilerType::GetFormat () const
664 {
665     if (!IsValid())
666         return lldb::eFormatDefault;
667 
668     return m_type_system->GetFormat(m_type);
669 }
670 
671 uint32_t
672 CompilerType::GetNumChildren (bool omit_empty_base_classes) const
673 {
674     if (!IsValid())
675         return 0;
676     return m_type_system->GetNumChildren(m_type, omit_empty_base_classes);
677 }
678 
679 lldb::BasicType
680 CompilerType::GetBasicTypeEnumeration () const
681 {
682     if (IsValid())
683         return m_type_system->GetBasicTypeEnumeration(m_type);
684     return eBasicTypeInvalid;
685 }
686 
687 void
688 CompilerType::ForEachEnumerator (std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback) const
689 {
690     if (IsValid())
691         return m_type_system->ForEachEnumerator (m_type, callback);
692 }
693 
694 
695 uint32_t
696 CompilerType::GetNumFields () const
697 {
698     if (!IsValid())
699         return 0;
700     return m_type_system->GetNumFields(m_type);
701 }
702 
703 CompilerType
704 CompilerType::GetFieldAtIndex (size_t idx,
705                                std::string& name,
706                                uint64_t *bit_offset_ptr,
707                                uint32_t *bitfield_bit_size_ptr,
708                                bool *is_bitfield_ptr) const
709 {
710     if (!IsValid())
711         return CompilerType();
712     return m_type_system->GetFieldAtIndex(m_type, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr);
713 }
714 
715 uint32_t
716 CompilerType::GetNumDirectBaseClasses () const
717 {
718     if (IsValid())
719         return m_type_system->GetNumDirectBaseClasses (m_type);
720     return 0;
721 }
722 
723 uint32_t
724 CompilerType::GetNumVirtualBaseClasses () const
725 {
726     if (IsValid())
727         return m_type_system->GetNumVirtualBaseClasses (m_type);
728     return 0;
729 }
730 
731 CompilerType
732 CompilerType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
733 {
734     if (IsValid())
735         return m_type_system->GetDirectBaseClassAtIndex (m_type, idx, bit_offset_ptr);
736     return CompilerType();
737 }
738 
739 CompilerType
740 CompilerType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
741 {
742     if (IsValid())
743         return m_type_system->GetVirtualBaseClassAtIndex (m_type, idx, bit_offset_ptr);
744     return CompilerType();
745 }
746 
747 uint32_t
748 CompilerType::GetIndexOfFieldWithName (const char* name,
749                                        CompilerType* field_compiler_type_ptr,
750                                        uint64_t *bit_offset_ptr,
751                                        uint32_t *bitfield_bit_size_ptr,
752                                        bool *is_bitfield_ptr) const
753 {
754     unsigned count = GetNumFields();
755     std::string field_name;
756     for (unsigned index = 0; index < count; index++)
757     {
758         CompilerType field_compiler_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
759         if (strcmp(field_name.c_str(), name) == 0)
760         {
761             if (field_compiler_type_ptr)
762                 *field_compiler_type_ptr = field_compiler_type;
763             return index;
764         }
765     }
766     return UINT32_MAX;
767 }
768 
769 
770 CompilerType
771 CompilerType::GetChildCompilerTypeAtIndex (ExecutionContext *exe_ctx,
772                                            size_t idx,
773                                            bool transparent_pointers,
774                                            bool omit_empty_base_classes,
775                                            bool ignore_array_bounds,
776                                            std::string& child_name,
777                                            uint32_t &child_byte_size,
778                                            int32_t &child_byte_offset,
779                                            uint32_t &child_bitfield_bit_size,
780                                            uint32_t &child_bitfield_bit_offset,
781                                            bool &child_is_base_class,
782                                            bool &child_is_deref_of_parent,
783                                            ValueObject *valobj,
784                                            uint64_t &language_flags) const
785 {
786     if (!IsValid())
787         return CompilerType();
788     return m_type_system->GetChildCompilerTypeAtIndex(m_type,
789                                                       exe_ctx,
790                                                       idx,
791                                                       transparent_pointers,
792                                                       omit_empty_base_classes,
793                                                       ignore_array_bounds,
794                                                       child_name,
795                                                       child_byte_size,
796                                                       child_byte_offset,
797                                                       child_bitfield_bit_size,
798                                                       child_bitfield_bit_offset,
799                                                       child_is_base_class,
800                                                       child_is_deref_of_parent,
801                                                       valobj,
802                                                       language_flags);
803 }
804 
805 // Look for a child member (doesn't include base classes, but it does include
806 // their members) in the type hierarchy. Returns an index path into "clang_type"
807 // on how to reach the appropriate member.
808 //
809 //    class A
810 //    {
811 //    public:
812 //        int m_a;
813 //        int m_b;
814 //    };
815 //
816 //    class B
817 //    {
818 //    };
819 //
820 //    class C :
821 //        public B,
822 //        public A
823 //    {
824 //    };
825 //
826 // If we have a clang type that describes "class C", and we wanted to looked
827 // "m_b" in it:
828 //
829 // With omit_empty_base_classes == false we would get an integer array back with:
830 // { 1,  1 }
831 // The first index 1 is the child index for "class A" within class C
832 // The second index 1 is the child index for "m_b" within class A
833 //
834 // With omit_empty_base_classes == true we would get an integer array back with:
835 // { 0,  1 }
836 // The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count)
837 // The second index 1 is the child index for "m_b" within class A
838 
839 size_t
840 CompilerType::GetIndexOfChildMemberWithName (const char *name,
841                                              bool omit_empty_base_classes,
842                                              std::vector<uint32_t>& child_indexes) const
843 {
844     if (IsValid() && name && name[0])
845     {
846         return m_type_system->GetIndexOfChildMemberWithName(m_type, name, omit_empty_base_classes, child_indexes);
847     }
848     return 0;
849 }
850 
851 size_t
852 CompilerType::GetNumTemplateArguments () const
853 {
854     if (IsValid())
855     {
856         return m_type_system->GetNumTemplateArguments(m_type);
857     }
858     return 0;
859 }
860 
861 CompilerType
862 CompilerType::GetTemplateArgument (size_t idx,
863                                    lldb::TemplateArgumentKind &kind) const
864 {
865     if (IsValid())
866     {
867         return m_type_system->GetTemplateArgument(m_type, idx, kind);
868     }
869     return CompilerType();
870 }
871 
872 CompilerType
873 CompilerType::GetTypeForFormatters () const
874 {
875     if (IsValid())
876         return m_type_system->GetTypeForFormatters(m_type);
877     return CompilerType();
878 }
879 
880 LazyBool
881 CompilerType::ShouldPrintAsOneLiner (ValueObject* valobj) const
882 {
883     if (IsValid())
884         return m_type_system->ShouldPrintAsOneLiner(m_type, valobj);
885     return eLazyBoolCalculate;
886 }
887 
888 bool
889 CompilerType::IsMeaninglessWithoutDynamicResolution () const
890 {
891     if (IsValid())
892         return m_type_system->IsMeaninglessWithoutDynamicResolution(m_type);
893     return false;
894 }
895 
896 // Get the index of the child of "clang_type" whose name matches. This function
897 // doesn't descend into the children, but only looks one level deep and name
898 // matches can include base class names.
899 
900 uint32_t
901 CompilerType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_classes) const
902 {
903     if (IsValid() && name && name[0])
904     {
905         return m_type_system->GetIndexOfChildWithName(m_type, name, omit_empty_base_classes);
906     }
907     return UINT32_MAX;
908 }
909 
910 size_t
911 CompilerType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst_size) const
912 {
913     if (IsValid())
914         return m_type_system->ConvertStringToFloatValue(m_type, s, dst, dst_size);
915     return 0;
916 }
917 
918 
919 
920 //----------------------------------------------------------------------
921 // Dumping types
922 //----------------------------------------------------------------------
923 #define DEPTH_INCREMENT 2
924 
925 void
926 CompilerType::DumpValue (ExecutionContext *exe_ctx,
927                          Stream *s,
928                          lldb::Format format,
929                          const lldb_private::DataExtractor &data,
930                          lldb::offset_t data_byte_offset,
931                          size_t data_byte_size,
932                          uint32_t bitfield_bit_size,
933                          uint32_t bitfield_bit_offset,
934                          bool show_types,
935                          bool show_summary,
936                          bool verbose,
937                          uint32_t depth)
938 {
939     if (!IsValid())
940         return;
941     m_type_system->DumpValue(m_type, exe_ctx, s, format, data, data_byte_offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset, show_types, show_summary, verbose, depth);
942 }
943 
944 
945 
946 
947 bool
948 CompilerType::DumpTypeValue (Stream *s,
949                              lldb::Format format,
950                              const lldb_private::DataExtractor &data,
951                              lldb::offset_t byte_offset,
952                              size_t byte_size,
953                              uint32_t bitfield_bit_size,
954                              uint32_t bitfield_bit_offset,
955                              ExecutionContextScope *exe_scope)
956 {
957     if (!IsValid())
958         return false;
959     return m_type_system->DumpTypeValue(m_type, s, format, data, byte_offset, byte_size, bitfield_bit_size, bitfield_bit_offset, exe_scope);
960 }
961 
962 
963 
964 void
965 CompilerType::DumpSummary (ExecutionContext *exe_ctx,
966                            Stream *s,
967                            const lldb_private::DataExtractor &data,
968                            lldb::offset_t data_byte_offset,
969                            size_t data_byte_size)
970 {
971     if (IsValid())
972         m_type_system->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset, data_byte_size);
973 }
974 
975 void
976 CompilerType::DumpTypeDescription () const
977 {
978     if (IsValid())
979         m_type_system->DumpTypeDescription(m_type);
980 }
981 
982 void
983 CompilerType::DumpTypeDescription (Stream *s) const
984 {
985     if (IsValid())
986     {
987         m_type_system->DumpTypeDescription(m_type, s);
988     }
989 }
990 
991 bool
992 CompilerType::GetValueAsScalar (const lldb_private::DataExtractor &data,
993                                 lldb::offset_t data_byte_offset,
994                                 size_t data_byte_size,
995                                 Scalar &value) const
996 {
997     if (!IsValid())
998         return false;
999 
1000     if (IsAggregateType ())
1001     {
1002         return false;   // Aggregate types don't have scalar values
1003     }
1004     else
1005     {
1006         uint64_t count = 0;
1007         lldb::Encoding encoding = GetEncoding (count);
1008 
1009         if (encoding == lldb::eEncodingInvalid || count != 1)
1010             return false;
1011 
1012         const uint64_t byte_size = GetByteSize(nullptr);
1013         lldb::offset_t offset = data_byte_offset;
1014         switch (encoding)
1015         {
1016             case lldb::eEncodingInvalid:
1017                 break;
1018             case lldb::eEncodingVector:
1019                 break;
1020             case lldb::eEncodingUint:
1021                 if (byte_size <= sizeof(unsigned long long))
1022                 {
1023                     uint64_t uval64 = data.GetMaxU64 (&offset, byte_size);
1024                     if (byte_size <= sizeof(unsigned int))
1025                     {
1026                         value = (unsigned int)uval64;
1027                         return true;
1028                     }
1029                     else if (byte_size <= sizeof(unsigned long))
1030                     {
1031                         value = (unsigned long)uval64;
1032                         return true;
1033                     }
1034                     else if (byte_size <= sizeof(unsigned long long))
1035                     {
1036                         value = (unsigned long long )uval64;
1037                         return true;
1038                     }
1039                     else
1040                         value.Clear();
1041                 }
1042                 break;
1043 
1044             case lldb::eEncodingSint:
1045                 if (byte_size <= sizeof(long long))
1046                 {
1047                     int64_t sval64 = data.GetMaxS64 (&offset, byte_size);
1048                     if (byte_size <= sizeof(int))
1049                     {
1050                         value = (int)sval64;
1051                         return true;
1052                     }
1053                     else if (byte_size <= sizeof(long))
1054                     {
1055                         value = (long)sval64;
1056                         return true;
1057                     }
1058                     else if (byte_size <= sizeof(long long))
1059                     {
1060                         value = (long long )sval64;
1061                         return true;
1062                     }
1063                     else
1064                         value.Clear();
1065                 }
1066                 break;
1067 
1068             case lldb::eEncodingIEEE754:
1069                 if (byte_size <= sizeof(long double))
1070                 {
1071                     uint32_t u32;
1072                     uint64_t u64;
1073                     if (byte_size == sizeof(float))
1074                     {
1075                         if (sizeof(float) == sizeof(uint32_t))
1076                         {
1077                             u32 = data.GetU32(&offset);
1078                             value = *((float *)&u32);
1079                             return true;
1080                         }
1081                         else if (sizeof(float) == sizeof(uint64_t))
1082                         {
1083                             u64 = data.GetU64(&offset);
1084                             value = *((float *)&u64);
1085                             return true;
1086                         }
1087                     }
1088                     else
1089                         if (byte_size == sizeof(double))
1090                         {
1091                             if (sizeof(double) == sizeof(uint32_t))
1092                             {
1093                                 u32 = data.GetU32(&offset);
1094                                 value = *((double *)&u32);
1095                                 return true;
1096                             }
1097                             else if (sizeof(double) == sizeof(uint64_t))
1098                             {
1099                                 u64 = data.GetU64(&offset);
1100                                 value = *((double *)&u64);
1101                                 return true;
1102                             }
1103                         }
1104                         else
1105                             if (byte_size == sizeof(long double))
1106                             {
1107                                 if (sizeof(long double) == sizeof(uint32_t))
1108                                 {
1109                                     u32 = data.GetU32(&offset);
1110                                     value = *((long double *)&u32);
1111                                     return true;
1112                                 }
1113                                 else if (sizeof(long double) == sizeof(uint64_t))
1114                                 {
1115                                     u64 = data.GetU64(&offset);
1116                                     value = *((long double *)&u64);
1117                                     return true;
1118                                 }
1119                             }
1120                 }
1121                 break;
1122         }
1123     }
1124     return false;
1125 }
1126 
1127 bool
1128 CompilerType::SetValueFromScalar (const Scalar &value, Stream &strm)
1129 {
1130     if (!IsValid())
1131         return false;
1132 
1133     // Aggregate types don't have scalar values
1134     if (!IsAggregateType ())
1135     {
1136         strm.GetFlags().Set(Stream::eBinary);
1137         uint64_t count = 0;
1138         lldb::Encoding encoding = GetEncoding (count);
1139 
1140         if (encoding == lldb::eEncodingInvalid || count != 1)
1141             return false;
1142 
1143         const uint64_t bit_width = GetBitSize(nullptr);
1144         // This function doesn't currently handle non-byte aligned assignments
1145         if ((bit_width % 8) != 0)
1146             return false;
1147 
1148         const uint64_t byte_size = (bit_width + 7 ) / 8;
1149         switch (encoding)
1150         {
1151             case lldb::eEncodingInvalid:
1152                 break;
1153             case lldb::eEncodingVector:
1154                 break;
1155             case lldb::eEncodingUint:
1156                 switch (byte_size)
1157             {
1158                 case 1: strm.PutHex8(value.UInt()); return true;
1159                 case 2: strm.PutHex16(value.UInt()); return true;
1160                 case 4: strm.PutHex32(value.UInt()); return true;
1161                 case 8: strm.PutHex64(value.ULongLong()); return true;
1162                 default:
1163                     break;
1164             }
1165                 break;
1166 
1167             case lldb::eEncodingSint:
1168                 switch (byte_size)
1169             {
1170                 case 1: strm.PutHex8(value.SInt()); return true;
1171                 case 2: strm.PutHex16(value.SInt()); return true;
1172                 case 4: strm.PutHex32(value.SInt()); return true;
1173                 case 8: strm.PutHex64(value.SLongLong()); return true;
1174                 default:
1175                     break;
1176             }
1177                 break;
1178 
1179             case lldb::eEncodingIEEE754:
1180                 if (byte_size <= sizeof(long double))
1181                 {
1182                     if (byte_size == sizeof(float))
1183                     {
1184                         strm.PutFloat(value.Float());
1185                         return true;
1186                     }
1187                     else
1188                         if (byte_size == sizeof(double))
1189                         {
1190                             strm.PutDouble(value.Double());
1191                             return true;
1192                         }
1193                         else
1194                             if (byte_size == sizeof(long double))
1195                             {
1196                                 strm.PutDouble(value.LongDouble());
1197                                 return true;
1198                             }
1199                 }
1200                 break;
1201         }
1202     }
1203     return false;
1204 }
1205 
1206 bool
1207 CompilerType::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx,
1208                               lldb::addr_t addr,
1209                               AddressType address_type,
1210                               lldb_private::DataExtractor &data)
1211 {
1212     if (!IsValid())
1213         return false;
1214 
1215     // Can't convert a file address to anything valid without more
1216     // context (which Module it came from)
1217     if (address_type == eAddressTypeFile)
1218         return false;
1219 
1220     if (!GetCompleteType())
1221         return false;
1222 
1223     const uint64_t byte_size = GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
1224     if (data.GetByteSize() < byte_size)
1225     {
1226         lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0'));
1227         data.SetData(data_sp);
1228     }
1229 
1230     uint8_t* dst = const_cast<uint8_t*>(data.PeekData(0, byte_size));
1231     if (dst != nullptr)
1232     {
1233         if (address_type == eAddressTypeHost)
1234         {
1235             if (addr == 0)
1236                 return false;
1237             // The address is an address in this process, so just copy it
1238             memcpy (dst, (uint8_t*)nullptr + addr, byte_size);
1239             return true;
1240         }
1241         else
1242         {
1243             Process *process = nullptr;
1244             if (exe_ctx)
1245                 process = exe_ctx->GetProcessPtr();
1246             if (process)
1247             {
1248                 Error error;
1249                 return process->ReadMemory(addr, dst, byte_size, error) == byte_size;
1250             }
1251         }
1252     }
1253     return false;
1254 }
1255 
1256 bool
1257 CompilerType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx,
1258                              lldb::addr_t addr,
1259                              AddressType address_type,
1260                              StreamString &new_value)
1261 {
1262     if (!IsValid())
1263         return false;
1264 
1265     // Can't convert a file address to anything valid without more
1266     // context (which Module it came from)
1267     if (address_type == eAddressTypeFile)
1268         return false;
1269 
1270     if (!GetCompleteType())
1271         return false;
1272 
1273     const uint64_t byte_size = GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
1274 
1275     if (byte_size > 0)
1276     {
1277         if (address_type == eAddressTypeHost)
1278         {
1279             // The address is an address in this process, so just copy it
1280             memcpy ((void *)addr, new_value.GetData(), byte_size);
1281             return true;
1282         }
1283         else
1284         {
1285             Process *process = nullptr;
1286             if (exe_ctx)
1287                 process = exe_ctx->GetProcessPtr();
1288             if (process)
1289             {
1290                 Error error;
1291                 return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size;
1292             }
1293         }
1294     }
1295     return false;
1296 }
1297 
1298 //clang::CXXRecordDecl *
1299 //CompilerType::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t opaque_compiler_qual_type)
1300 //{
1301 //    if (opaque_compiler_qual_type)
1302 //        return clang::QualType::getFromOpaquePtr(opaque_compiler_qual_type)->getAsCXXRecordDecl();
1303 //    return NULL;
1304 //}
1305 
1306 bool
1307 lldb_private::operator == (const lldb_private::CompilerType &lhs, const lldb_private::CompilerType &rhs)
1308 {
1309     return lhs.GetTypeSystem() == rhs.GetTypeSystem() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
1310 }
1311 
1312 
1313 bool
1314 lldb_private::operator != (const lldb_private::CompilerType &lhs, const lldb_private::CompilerType &rhs)
1315 {
1316     return lhs.GetTypeSystem() != rhs.GetTypeSystem() || lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType();
1317 }
1318 
1319 
1320 
1321