lldb/source/Symbol/CompilerType.cpp

   1 //===-- CompilerType.cpp --------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Symbol/CompilerType.h"
  10
  11 #include "lldb/Core/Debugger.h"
  12 #include "lldb/Core/StreamFile.h"
  13 #include "lldb/Symbol/Type.h"
  14 #include "lldb/Target/ExecutionContext.h"
  15 #include "lldb/Target/Process.h"
  16 #include "lldb/Utility/ConstString.h"
  17 #include "lldb/Utility/DataBufferHeap.h"
  18 #include "lldb/Utility/DataExtractor.h"
  19 #include "lldb/Utility/Scalar.h"
  20 #include "lldb/Utility/Stream.h"
  21 #include "lldb/Utility/StreamString.h"
  22
  23 #include <iterator>
  24 #include <mutex>
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29 // Tests
  30
  31 bool CompilerType::IsAggregateType() const {
  32   if (IsValid())
  33     return m_type_system->IsAggregateType(m_type);
  34   return false;
  35 }
  36
  37 bool CompilerType::IsAnonymousType() const {
  38   if (IsValid())
  39     return m_type_system->IsAnonymousType(m_type);
  40   return false;
  41 }
  42
  43 bool CompilerType::IsScopedEnumerationType() const {
  44   if (IsValid())
  45     return m_type_system->IsScopedEnumerationType(m_type);
  46   return false;
  47 }
  48
  49 bool CompilerType::IsArrayType(CompilerType *element_type_ptr, uint64_t *size,
  50                                bool *is_incomplete) const {
  51   if (IsValid())
  52     return m_type_system->IsArrayType(m_type, element_type_ptr, size,
  53                                       is_incomplete);
  54
  55   if (element_type_ptr)
  56     element_type_ptr->Clear();
  57   if (size)
  58     *size = 0;
  59   if (is_incomplete)
  60     *is_incomplete = false;
  61   return false;
  62 }
  63
  64 bool CompilerType::IsVectorType(CompilerType *element_type,
  65                                 uint64_t *size) const {
  66   if (IsValid())
  67     return m_type_system->IsVectorType(m_type, element_type, size);
  68   return false;
  69 }
  70
  71 bool CompilerType::IsRuntimeGeneratedType() const {
  72   if (IsValid())
  73     return m_type_system->IsRuntimeGeneratedType(m_type);
  74   return false;
  75 }
  76
  77 bool CompilerType::IsCharType() const {
  78   if (IsValid())
  79     return m_type_system->IsCharType(m_type);
  80   return false;
  81 }
  82
  83 bool CompilerType::IsCompleteType() const {
  84   if (IsValid())
  85     return m_type_system->IsCompleteType(m_type);
  86   return false;
  87 }
  88
  89 bool CompilerType::IsConst() const {
  90   if (IsValid())
  91     return m_type_system->IsConst(m_type);
  92   return false;
  93 }
  94
  95 bool CompilerType::IsCStringType(uint32_t &length) const {
  96   if (IsValid())
  97     return m_type_system->IsCStringType(m_type, length);
  98   return false;
  99 }
 100
 101 bool CompilerType::IsFunctionType() const {
 102   if (IsValid())
 103     return m_type_system->IsFunctionType(m_type);
 104   return false;
 105 }
 106
 107 // Used to detect "Homogeneous Floating-point Aggregates"
 108 uint32_t
 109 CompilerType::IsHomogeneousAggregate(CompilerType *base_type_ptr) const {
 110   if (IsValid())
 111     return m_type_system->IsHomogeneousAggregate(m_type, base_type_ptr);
 112   return 0;
 113 }
 114
 115 size_t CompilerType::GetNumberOfFunctionArguments() const {
 116   if (IsValid())
 117     return m_type_system->GetNumberOfFunctionArguments(m_type);
 118   return 0;
 119 }
 120
 121 CompilerType
 122 CompilerType::GetFunctionArgumentAtIndex(const size_t index) const {
 123   if (IsValid())
 124     return m_type_system->GetFunctionArgumentAtIndex(m_type, index);
 125   return CompilerType();
 126 }
 127
 128 bool CompilerType::IsFunctionPointerType() const {
 129   if (IsValid())
 130     return m_type_system->IsFunctionPointerType(m_type);
 131   return false;
 132 }
 133
 134 bool CompilerType::IsBlockPointerType(
 135     CompilerType *function_pointer_type_ptr) const {
 136   if (IsValid())
 137     return m_type_system->IsBlockPointerType(m_type, function_pointer_type_ptr);
 138   return false;
 139 }
 140
 141 bool CompilerType::IsIntegerType(bool &is_signed) const {
 142   if (IsValid())
 143     return m_type_system->IsIntegerType(m_type, is_signed);
 144   return false;
 145 }
 146
 147 bool CompilerType::IsEnumerationType(bool &is_signed) const {
 148   if (IsValid())
 149     return m_type_system->IsEnumerationType(m_type, is_signed);
 150   return false;
 151 }
 152
 153 bool CompilerType::IsIntegerOrEnumerationType(bool &is_signed) const {
 154   return IsIntegerType(is_signed) || IsEnumerationType(is_signed);
 155 }
 156
 157 bool CompilerType::IsPointerType(CompilerType *pointee_type) const {
 158   if (IsValid()) {
 159     return m_type_system->IsPointerType(m_type, pointee_type);
 160   }
 161   if (pointee_type)
 162     pointee_type->Clear();
 163   return false;
 164 }
 165
 166 bool CompilerType::IsPointerOrReferenceType(CompilerType *pointee_type) const {
 167   if (IsValid()) {
 168     return m_type_system->IsPointerOrReferenceType(m_type, pointee_type);
 169   }
 170   if (pointee_type)
 171     pointee_type->Clear();
 172   return false;
 173 }
 174
 175 bool CompilerType::IsReferenceType(CompilerType *pointee_type,
 176                                    bool *is_rvalue) const {
 177   if (IsValid()) {
 178     return m_type_system->IsReferenceType(m_type, pointee_type, is_rvalue);
 179   }
 180   if (pointee_type)
 181     pointee_type->Clear();
 182   return false;
 183 }
 184
 185 bool CompilerType::ShouldTreatScalarValueAsAddress() const {
 186   if (IsValid())
 187     return m_type_system->ShouldTreatScalarValueAsAddress(m_type);
 188   return false;
 189 }
 190
 191 bool CompilerType::IsFloatingPointType(uint32_t &count,
 192                                        bool &is_complex) const {
 193   if (IsValid()) {
 194     return m_type_system->IsFloatingPointType(m_type, count, is_complex);
 195   }
 196   count = 0;
 197   is_complex = false;
 198   return false;
 199 }
 200
 201 bool CompilerType::IsDefined() const {
 202   if (IsValid())
 203     return m_type_system->IsDefined(m_type);
 204   return true;
 205 }
 206
 207 bool CompilerType::IsPolymorphicClass() const {
 208   if (IsValid()) {
 209     return m_type_system->IsPolymorphicClass(m_type);
 210   }
 211   return false;
 212 }
 213
 214 bool CompilerType::IsPossibleDynamicType(CompilerType *dynamic_pointee_type,
 215                                          bool check_cplusplus,
 216                                          bool check_objc) const {
 217   if (IsValid())
 218     return m_type_system->IsPossibleDynamicType(m_type, dynamic_pointee_type,
 219                                                 check_cplusplus, check_objc);
 220   return false;
 221 }
 222
 223 bool CompilerType::IsScalarType() const {
 224   if (!IsValid())
 225     return false;
 226
 227   return m_type_system->IsScalarType(m_type);
 228 }
 229
 230 bool CompilerType::IsTypedefType() const {
 231   if (!IsValid())
 232     return false;
 233   return m_type_system->IsTypedefType(m_type);
 234 }
 235
 236 bool CompilerType::IsVoidType() const {
 237   if (!IsValid())
 238     return false;
 239   return m_type_system->IsVoidType(m_type);
 240 }
 241
 242 bool CompilerType::IsPointerToScalarType() const {
 243   if (!IsValid())
 244     return false;
 245
 246   return IsPointerType() && GetPointeeType().IsScalarType();
 247 }
 248
 249 bool CompilerType::IsArrayOfScalarType() const {
 250   CompilerType element_type;
 251   if (IsArrayType(&element_type))
 252     return element_type.IsScalarType();
 253   return false;
 254 }
 255
 256 bool CompilerType::IsBeingDefined() const {
 257   if (!IsValid())
 258     return false;
 259   return m_type_system->IsBeingDefined(m_type);
 260 }
 261
 262 // Type Completion
 263
 264 bool CompilerType::GetCompleteType() const {
 265   if (!IsValid())
 266     return false;
 267   return m_type_system->GetCompleteType(m_type);
 268 }
 269
 270 // AST related queries
 271 size_t CompilerType::GetPointerByteSize() const {
 272   if (m_type_system)
 273     return m_type_system->GetPointerByteSize();
 274   return 0;
 275 }
 276
 277 ConstString CompilerType::GetTypeName() const {
 278   if (IsValid()) {
 279     return m_type_system->GetTypeName(m_type);
 280   }
 281   return ConstString("<invalid>");
 282 }
 283
 284 ConstString CompilerType::GetDisplayTypeName() const {
 285   if (IsValid())
 286     return m_type_system->GetDisplayTypeName(m_type);
 287   return ConstString("<invalid>");
 288 }
 289
 290 uint32_t CompilerType::GetTypeInfo(
 291     CompilerType *pointee_or_element_compiler_type) const {
 292   if (!IsValid())
 293     return 0;
 294
 295   return m_type_system->GetTypeInfo(m_type, pointee_or_element_compiler_type);
 296 }
 297
 298 lldb::LanguageType CompilerType::GetMinimumLanguage() {
 299   if (!IsValid())
 300     return lldb::eLanguageTypeC;
 301
 302   return m_type_system->GetMinimumLanguage(m_type);
 303 }
 304
 305 lldb::TypeClass CompilerType::GetTypeClass() const {
 306   if (!IsValid())
 307     return lldb::eTypeClassInvalid;
 308
 309   return m_type_system->GetTypeClass(m_type);
 310 }
 311
 312 void CompilerType::SetCompilerType(TypeSystem *type_system,
 313                                    lldb::opaque_compiler_type_t type) {
 314   m_type_system = type_system;
 315   m_type = type;
 316 }
 317
 318 unsigned CompilerType::GetTypeQualifiers() const {
 319   if (IsValid())
 320     return m_type_system->GetTypeQualifiers(m_type);
 321   return 0;
 322 }
 323
 324 // Creating related types
 325
 326 CompilerType
 327 CompilerType::GetArrayElementType(ExecutionContextScope *exe_scope) const {
 328   if (IsValid()) {
 329     return m_type_system->GetArrayElementType(m_type, exe_scope);
 330   }
 331   return CompilerType();
 332 }
 333
 334 CompilerType CompilerType::GetArrayType(uint64_t size) const {
 335   if (IsValid()) {
 336     return m_type_system->GetArrayType(m_type, size);
 337   }
 338   return CompilerType();
 339 }
 340
 341 CompilerType CompilerType::GetCanonicalType() const {
 342   if (IsValid())
 343     return m_type_system->GetCanonicalType(m_type);
 344   return CompilerType();
 345 }
 346
 347 CompilerType CompilerType::GetFullyUnqualifiedType() const {
 348   if (IsValid())
 349     return m_type_system->GetFullyUnqualifiedType(m_type);
 350   return CompilerType();
 351 }
 352
 353 CompilerType CompilerType::GetEnumerationIntegerType() const {
 354   if (IsValid())
 355     return m_type_system->GetEnumerationIntegerType(m_type);
 356   return CompilerType();
 357 }
 358
 359 int CompilerType::GetFunctionArgumentCount() const {
 360   if (IsValid()) {
 361     return m_type_system->GetFunctionArgumentCount(m_type);
 362   }
 363   return -1;
 364 }
 365
 366 CompilerType CompilerType::GetFunctionArgumentTypeAtIndex(size_t idx) const {
 367   if (IsValid()) {
 368     return m_type_system->GetFunctionArgumentTypeAtIndex(m_type, idx);
 369   }
 370   return CompilerType();
 371 }
 372
 373 CompilerType CompilerType::GetFunctionReturnType() const {
 374   if (IsValid()) {
 375     return m_type_system->GetFunctionReturnType(m_type);
 376   }
 377   return CompilerType();
 378 }
 379
 380 size_t CompilerType::GetNumMemberFunctions() const {
 381   if (IsValid()) {
 382     return m_type_system->GetNumMemberFunctions(m_type);
 383   }
 384   return 0;
 385 }
 386
 387 TypeMemberFunctionImpl CompilerType::GetMemberFunctionAtIndex(size_t idx) {
 388   if (IsValid()) {
 389     return m_type_system->GetMemberFunctionAtIndex(m_type, idx);
 390   }
 391   return TypeMemberFunctionImpl();
 392 }
 393
 394 CompilerType CompilerType::GetNonReferenceType() const {
 395   if (IsValid())
 396     return m_type_system->GetNonReferenceType(m_type);
 397   return CompilerType();
 398 }
 399
 400 CompilerType CompilerType::GetPointeeType() const {
 401   if (IsValid()) {
 402     return m_type_system->GetPointeeType(m_type);
 403   }
 404   return CompilerType();
 405 }
 406
 407 CompilerType CompilerType::GetPointerType() const {
 408   if (IsValid()) {
 409     return m_type_system->GetPointerType(m_type);
 410   }
 411   return CompilerType();
 412 }
 413
 414 CompilerType CompilerType::GetLValueReferenceType() const {
 415   if (IsValid())
 416     return m_type_system->GetLValueReferenceType(m_type);
 417   else
 418     return CompilerType();
 419 }
 420
 421 CompilerType CompilerType::GetRValueReferenceType() const {
 422   if (IsValid())
 423     return m_type_system->GetRValueReferenceType(m_type);
 424   else
 425     return CompilerType();
 426 }
 427
 428 CompilerType CompilerType::GetAtomicType() const {
 429   if (IsValid())
 430     return m_type_system->GetAtomicType(m_type);
 431   return CompilerType();
 432 }
 433
 434 CompilerType CompilerType::AddConstModifier() const {
 435   if (IsValid())
 436     return m_type_system->AddConstModifier(m_type);
 437   else
 438     return CompilerType();
 439 }
 440
 441 CompilerType CompilerType::AddVolatileModifier() const {
 442   if (IsValid())
 443     return m_type_system->AddVolatileModifier(m_type);
 444   else
 445     return CompilerType();
 446 }
 447
 448 CompilerType CompilerType::AddRestrictModifier() const {
 449   if (IsValid())
 450     return m_type_system->AddRestrictModifier(m_type);
 451   else
 452     return CompilerType();
 453 }
 454
 455 CompilerType CompilerType::CreateTypedef(const char *name,
 456                                          const CompilerDeclContext &decl_ctx,
 457                                          uint32_t payload) const {
 458   if (IsValid())
 459     return m_type_system->CreateTypedef(m_type, name, decl_ctx, payload);
 460   else
 461     return CompilerType();
 462 }
 463
 464 CompilerType CompilerType::GetTypedefedType() const {
 465   if (IsValid())
 466     return m_type_system->GetTypedefedType(m_type);
 467   else
 468     return CompilerType();
 469 }
 470
 471 // Create related types using the current type's AST
 472
 473 CompilerType
 474 CompilerType::GetBasicTypeFromAST(lldb::BasicType basic_type) const {
 475   if (IsValid())
 476     return m_type_system->GetBasicTypeFromAST(basic_type);
 477   return CompilerType();
 478 }
 479 // Exploring the type
 480
 481 llvm::Optional<uint64_t>
 482 CompilerType::GetBitSize(ExecutionContextScope *exe_scope) const {
 483   if (IsValid())
 484     return m_type_system->GetBitSize(m_type, exe_scope);
 485   return {};
 486 }
 487
 488 llvm::Optional<uint64_t>
 489 CompilerType::GetByteSize(ExecutionContextScope *exe_scope) const {
 490   if (llvm::Optional<uint64_t> bit_size = GetBitSize(exe_scope))
 491     return (*bit_size + 7) / 8;
 492   return {};
 493 }
 494
 495 llvm::Optional<size_t> CompilerType::GetTypeBitAlign(ExecutionContextScope *exe_scope) const {
 496   if (IsValid())
 497     return m_type_system->GetTypeBitAlign(m_type, exe_scope);
 498   return {};
 499 }
 500
 501 lldb::Encoding CompilerType::GetEncoding(uint64_t &count) const {
 502   if (!IsValid())
 503     return lldb::eEncodingInvalid;
 504
 505   return m_type_system->GetEncoding(m_type, count);
 506 }
 507
 508 lldb::Format CompilerType::GetFormat() const {
 509   if (!IsValid())
 510     return lldb::eFormatDefault;
 511
 512   return m_type_system->GetFormat(m_type);
 513 }
 514
 515 uint32_t CompilerType::GetNumChildren(bool omit_empty_base_classes,
 516                                       const ExecutionContext *exe_ctx) const {
 517   if (!IsValid())
 518     return 0;
 519   return m_type_system->GetNumChildren(m_type, omit_empty_base_classes,
 520                                        exe_ctx);
 521 }
 522
 523 lldb::BasicType CompilerType::GetBasicTypeEnumeration() const {
 524   if (IsValid())
 525     return m_type_system->GetBasicTypeEnumeration(m_type);
 526   return eBasicTypeInvalid;
 527 }
 528
 529 void CompilerType::ForEachEnumerator(
 530     std::function<bool(const CompilerType &integer_type,
 531                        ConstString name,
 532                        const llvm::APSInt &value)> const &callback) const {
 533   if (IsValid())
 534     return m_type_system->ForEachEnumerator(m_type, callback);
 535 }
 536
 537 uint32_t CompilerType::GetNumFields() const {
 538   if (!IsValid())
 539     return 0;
 540   return m_type_system->GetNumFields(m_type);
 541 }
 542
 543 CompilerType CompilerType::GetFieldAtIndex(size_t idx, std::string &name,
 544                                            uint64_t *bit_offset_ptr,
 545                                            uint32_t *bitfield_bit_size_ptr,
 546                                            bool *is_bitfield_ptr) const {
 547   if (!IsValid())
 548     return CompilerType();
 549   return m_type_system->GetFieldAtIndex(m_type, idx, name, bit_offset_ptr,
 550                                         bitfield_bit_size_ptr, is_bitfield_ptr);
 551 }
 552
 553 uint32_t CompilerType::GetNumDirectBaseClasses() const {
 554   if (IsValid())
 555     return m_type_system->GetNumDirectBaseClasses(m_type);
 556   return 0;
 557 }
 558
 559 uint32_t CompilerType::GetNumVirtualBaseClasses() const {
 560   if (IsValid())
 561     return m_type_system->GetNumVirtualBaseClasses(m_type);
 562   return 0;
 563 }
 564
 565 CompilerType
 566 CompilerType::GetDirectBaseClassAtIndex(size_t idx,
 567                                         uint32_t *bit_offset_ptr) const {
 568   if (IsValid())
 569     return m_type_system->GetDirectBaseClassAtIndex(m_type, idx,
 570                                                     bit_offset_ptr);
 571   return CompilerType();
 572 }
 573
 574 CompilerType
 575 CompilerType::GetVirtualBaseClassAtIndex(size_t idx,
 576                                          uint32_t *bit_offset_ptr) const {
 577   if (IsValid())
 578     return m_type_system->GetVirtualBaseClassAtIndex(m_type, idx,
 579                                                      bit_offset_ptr);
 580   return CompilerType();
 581 }
 582
 583 uint32_t CompilerType::GetIndexOfFieldWithName(
 584     const char *name, CompilerType *field_compiler_type_ptr,
 585     uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr,
 586     bool *is_bitfield_ptr) const {
 587   unsigned count = GetNumFields();
 588   std::string field_name;
 589   for (unsigned index = 0; index < count; index++) {
 590     CompilerType field_compiler_type(
 591         GetFieldAtIndex(index, field_name, bit_offset_ptr,
 592                         bitfield_bit_size_ptr, is_bitfield_ptr));
 593     if (strcmp(field_name.c_str(), name) == 0) {
 594       if (field_compiler_type_ptr)
 595         *field_compiler_type_ptr = field_compiler_type;
 596       return index;
 597     }
 598   }
 599   return UINT32_MAX;
 600 }
 601
 602 CompilerType CompilerType::GetChildCompilerTypeAtIndex(
 603     ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
 604     bool omit_empty_base_classes, bool ignore_array_bounds,
 605     std::string &child_name, uint32_t &child_byte_size,
 606     int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
 607     uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
 608     bool &child_is_deref_of_parent, ValueObject *valobj,
 609     uint64_t &language_flags) const {
 610   if (!IsValid())
 611     return CompilerType();
 612   return m_type_system->GetChildCompilerTypeAtIndex(
 613       m_type, exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
 614       ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
 615       child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
 616       child_is_deref_of_parent, valobj, language_flags);
 617 }
 618
 619 // Look for a child member (doesn't include base classes, but it does include
 620 // their members) in the type hierarchy. Returns an index path into
 621 // "clang_type" on how to reach the appropriate member.
 622 //
 623 //    class A
 624 //    {
 625 //    public:
 626 //        int m_a;
 627 //        int m_b;
 628 //    };
 629 //
 630 //    class B
 631 //    {
 632 //    };
 633 //
 634 //    class C :
 635 //        public B,
 636 //        public A
 637 //    {
 638 //    };
 639 //
 640 // If we have a clang type that describes "class C", and we wanted to looked
 641 // "m_b" in it:
 642 //
 643 // With omit_empty_base_classes == false we would get an integer array back
 644 // with: { 1,  1 } The first index 1 is the child index for "class A" within
 645 // class C The second index 1 is the child index for "m_b" within class A
 646 //
 647 // With omit_empty_base_classes == true we would get an integer array back
 648 // with: { 0,  1 } The first index 0 is the child index for "class A" within
 649 // class C (since class B doesn't have any members it doesn't count) The second
 650 // index 1 is the child index for "m_b" within class A
 651
 652 size_t CompilerType::GetIndexOfChildMemberWithName(
 653     const char *name, bool omit_empty_base_classes,
 654     std::vector<uint32_t> &child_indexes) const {
 655   if (IsValid() && name && name[0]) {
 656     return m_type_system->GetIndexOfChildMemberWithName(
 657         m_type, name, omit_empty_base_classes, child_indexes);
 658   }
 659   return 0;
 660 }
 661
 662 size_t CompilerType::GetNumTemplateArguments() const {
 663   if (IsValid()) {
 664     return m_type_system->GetNumTemplateArguments(m_type);
 665   }
 666   return 0;
 667 }
 668
 669 TemplateArgumentKind CompilerType::GetTemplateArgumentKind(size_t idx) const {
 670   if (IsValid())
 671     return m_type_system->GetTemplateArgumentKind(m_type, idx);
 672   return eTemplateArgumentKindNull;
 673 }
 674
 675 CompilerType CompilerType::GetTypeTemplateArgument(size_t idx) const {
 676   if (IsValid()) {
 677     return m_type_system->GetTypeTemplateArgument(m_type, idx);
 678   }
 679   return CompilerType();
 680 }
 681
 682 llvm::Optional<CompilerType::IntegralTemplateArgument>
 683 CompilerType::GetIntegralTemplateArgument(size_t idx) const {
 684   if (IsValid())
 685     return m_type_system->GetIntegralTemplateArgument(m_type, idx);
 686   return llvm::None;
 687 }
 688
 689 CompilerType CompilerType::GetTypeForFormatters() const {
 690   if (IsValid())
 691     return m_type_system->GetTypeForFormatters(m_type);
 692   return CompilerType();
 693 }
 694
 695 LazyBool CompilerType::ShouldPrintAsOneLiner(ValueObject *valobj) const {
 696   if (IsValid())
 697     return m_type_system->ShouldPrintAsOneLiner(m_type, valobj);
 698   return eLazyBoolCalculate;
 699 }
 700
 701 bool CompilerType::IsMeaninglessWithoutDynamicResolution() const {
 702   if (IsValid())
 703     return m_type_system->IsMeaninglessWithoutDynamicResolution(m_type);
 704   return false;
 705 }
 706
 707 // Get the index of the child of "clang_type" whose name matches. This function
 708 // doesn't descend into the children, but only looks one level deep and name
 709 // matches can include base class names.
 710
 711 uint32_t
 712 CompilerType::GetIndexOfChildWithName(const char *name,
 713                                       bool omit_empty_base_classes) const {
 714   if (IsValid() && name && name[0]) {
 715     return m_type_system->GetIndexOfChildWithName(m_type, name,
 716                                                   omit_empty_base_classes);
 717   }
 718   return UINT32_MAX;
 719 }
 720
 721 // Dumping types
 722
 723 void CompilerType::DumpValue(ExecutionContext *exe_ctx, Stream *s,
 724                              lldb::Format format, const DataExtractor &data,
 725                              lldb::offset_t data_byte_offset,
 726                              size_t data_byte_size, uint32_t bitfield_bit_size,
 727                              uint32_t bitfield_bit_offset, bool show_types,
 728                              bool show_summary, bool verbose, uint32_t depth) {
 729   if (!IsValid())
 730     return;
 731   m_type_system->DumpValue(m_type, exe_ctx, s, format, data, data_byte_offset,
 732                            data_byte_size, bitfield_bit_size,
 733                            bitfield_bit_offset, show_types, show_summary,
 734                            verbose, depth);
 735 }
 736
 737 bool CompilerType::DumpTypeValue(Stream *s, lldb::Format format,
 738                                  const DataExtractor &data,
 739                                  lldb::offset_t byte_offset, size_t byte_size,
 740                                  uint32_t bitfield_bit_size,
 741                                  uint32_t bitfield_bit_offset,
 742                                  ExecutionContextScope *exe_scope) {
 743   if (!IsValid())
 744     return false;
 745   return m_type_system->DumpTypeValue(m_type, s, format, data, byte_offset,
 746                                       byte_size, bitfield_bit_size,
 747                                       bitfield_bit_offset, exe_scope);
 748 }
 749
 750 void CompilerType::DumpSummary(ExecutionContext *exe_ctx, Stream *s,
 751                                const DataExtractor &data,
 752                                lldb::offset_t data_byte_offset,
 753                                size_t data_byte_size) {
 754   if (IsValid())
 755     m_type_system->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset,
 756                                data_byte_size);
 757 }
 758
 759 void CompilerType::DumpTypeDescription(lldb::DescriptionLevel level) const {
 760   if (IsValid())
 761     m_type_system->DumpTypeDescription(m_type, level);
 762 }
 763
 764 void CompilerType::DumpTypeDescription(Stream *s,
 765                                        lldb::DescriptionLevel level) const {
 766   if (IsValid()) {
 767     m_type_system->DumpTypeDescription(m_type, s, level);
 768   }
 769 }
 770
 771 #ifndef NDEBUG
 772 LLVM_DUMP_METHOD void CompilerType::dump() const {
 773   if (IsValid())
 774     m_type_system->dump(m_type);
 775   else
 776     llvm::errs() << "<invalid>\n";
 777 }
 778 #endif
 779
 780 bool CompilerType::GetValueAsScalar(const lldb_private::DataExtractor &data,
 781                                     lldb::offset_t data_byte_offset,
 782                                     size_t data_byte_size, Scalar &value,
 783                                     ExecutionContextScope *exe_scope) const {
 784   if (!IsValid())
 785     return false;
 786
 787   if (IsAggregateType()) {
 788     return false; // Aggregate types don't have scalar values
 789   } else {
 790     uint64_t count = 0;
 791     lldb::Encoding encoding = GetEncoding(count);
 792
 793     if (encoding == lldb::eEncodingInvalid || count != 1)
 794       return false;
 795
 796     llvm::Optional<uint64_t> byte_size = GetByteSize(exe_scope);
 797     if (!byte_size)
 798       return false;
 799     lldb::offset_t offset = data_byte_offset;
 800     switch (encoding) {
 801     case lldb::eEncodingInvalid:
 802       break;
 803     case lldb::eEncodingVector:
 804       break;
 805     case lldb::eEncodingUint:
 806       if (*byte_size <= sizeof(unsigned long long)) {
 807         uint64_t uval64 = data.GetMaxU64(&offset, *byte_size);
 808         if (*byte_size <= sizeof(unsigned int)) {
 809           value = (unsigned int)uval64;
 810           return true;
 811         } else if (*byte_size <= sizeof(unsigned long)) {
 812           value = (unsigned long)uval64;
 813           return true;
 814         } else if (*byte_size <= sizeof(unsigned long long)) {
 815           value = (unsigned long long)uval64;
 816           return true;
 817         } else
 818           value.Clear();
 819       }
 820       break;
 821
 822     case lldb::eEncodingSint:
 823       if (*byte_size <= sizeof(long long)) {
 824         int64_t sval64 = data.GetMaxS64(&offset, *byte_size);
 825         if (*byte_size <= sizeof(int)) {
 826           value = (int)sval64;
 827           return true;
 828         } else if (*byte_size <= sizeof(long)) {
 829           value = (long)sval64;
 830           return true;
 831         } else if (*byte_size <= sizeof(long long)) {
 832           value = (long long)sval64;
 833           return true;
 834         } else
 835           value.Clear();
 836       }
 837       break;
 838
 839     case lldb::eEncodingIEEE754:
 840       if (*byte_size <= sizeof(long double)) {
 841         uint32_t u32;
 842         uint64_t u64;
 843         if (*byte_size == sizeof(float)) {
 844           if (sizeof(float) == sizeof(uint32_t)) {
 845             u32 = data.GetU32(&offset);
 846             value = *((float *)&u32);
 847             return true;
 848           } else if (sizeof(float) == sizeof(uint64_t)) {
 849             u64 = data.GetU64(&offset);
 850             value = *((float *)&u64);
 851             return true;
 852           }
 853         } else if (*byte_size == sizeof(double)) {
 854           if (sizeof(double) == sizeof(uint32_t)) {
 855             u32 = data.GetU32(&offset);
 856             value = *((double *)&u32);
 857             return true;
 858           } else if (sizeof(double) == sizeof(uint64_t)) {
 859             u64 = data.GetU64(&offset);
 860             value = *((double *)&u64);
 861             return true;
 862           }
 863         } else if (*byte_size == sizeof(long double)) {
 864           if (sizeof(long double) == sizeof(uint32_t)) {
 865             u32 = data.GetU32(&offset);
 866             value = *((long double *)&u32);
 867             return true;
 868           } else if (sizeof(long double) == sizeof(uint64_t)) {
 869             u64 = data.GetU64(&offset);
 870             value = *((long double *)&u64);
 871             return true;
 872           }
 873         }
 874       }
 875       break;
 876     }
 877   }
 878   return false;
 879 }
 880
 881 #ifndef NDEBUG
 882 bool CompilerType::Verify() const {
 883   return !IsValid() || m_type_system->Verify(m_type);
 884 }
 885 #endif
 886
 887 bool lldb_private::operator==(const lldb_private::CompilerType &lhs,
 888                               const lldb_private::CompilerType &rhs) {
 889   return lhs.GetTypeSystem() == rhs.GetTypeSystem() &&
 890          lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
 891 }
 892
 893 bool lldb_private::operator!=(const lldb_private::CompilerType &lhs,
 894                               const lldb_private::CompilerType &rhs) {
 895   return !(lhs == rhs);
 896 }