source/Symbol/CompilerType.cpp

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