contrib/llvm/tools/lldb/source/Symbol/JavaASTContext.cpp

   1 //===-- JavaASTContext.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 <sstream>
  11
  12 #include "lldb/Core/ArchSpec.h"
  13 #include "lldb/Core/DataExtractor.h"
  14 #include "lldb/Core/Module.h"
  15 #include "lldb/Core/PluginManager.h"
  16 #include "lldb/Core/Stream.h"
  17 #include "lldb/Core/StreamFile.h"
  18 #include "lldb/Core/ValueObject.h"
  19 #include "lldb/Expression/DWARFExpression.h"
  20 #include "lldb/Symbol/CompilerType.h"
  21 #include "lldb/Symbol/JavaASTContext.h"
  22 #include "lldb/Symbol/SymbolFile.h"
  23 #include "lldb/Symbol/Type.h"
  24 #include "lldb/Target/Target.h"
  25
  26 #include "Plugins/SymbolFile/DWARF/DWARFASTParserJava.h"
  27
  28 using namespace lldb;
  29 using namespace lldb_private;
  30
  31 namespace lldb_private
  32 {
  33
  34 class JavaASTContext::JavaType
  35 {
  36 public:
  37     enum LLVMCastKind
  38     {
  39         eKindPrimitive,
  40         eKindObject,
  41         eKindReference,
  42         eKindArray,
  43         kNumKinds
  44     };
  45
  46     JavaType(LLVMCastKind kind) : m_kind(kind) {}
  47
  48     virtual ~JavaType() = default;
  49
  50     virtual ConstString
  51     GetName() = 0;
  52
  53     virtual void
  54     Dump(Stream *s) = 0;
  55
  56     virtual bool
  57     IsCompleteType() = 0;
  58
  59     LLVMCastKind
  60     getKind() const
  61     {
  62         return m_kind;
  63     }
  64
  65 private:
  66     LLVMCastKind m_kind;
  67 };
  68
  69 } // end of namespace lldb_private
  70
  71 namespace
  72 {
  73
  74 class JavaPrimitiveType : public JavaASTContext::JavaType
  75 {
  76 public:
  77     enum TypeKind
  78     {
  79         eTypeByte,
  80         eTypeShort,
  81         eTypeInt,
  82         eTypeLong,
  83         eTypeFloat,
  84         eTypeDouble,
  85         eTypeBoolean,
  86         eTypeChar,
  87     };
  88
  89     JavaPrimitiveType(TypeKind type_kind) : JavaType(JavaType::eKindPrimitive), m_type_kind(type_kind) {}
  90
  91     ConstString
  92     GetName() override
  93     {
  94         switch (m_type_kind)
  95         {
  96             case eTypeByte:
  97                 return ConstString("byte");
  98             case eTypeShort:
  99                 return ConstString("short");
 100             case eTypeInt:
 101                 return ConstString("int");
 102             case eTypeLong:
 103                 return ConstString("long");
 104             case eTypeFloat:
 105                 return ConstString("float");
 106             case eTypeDouble:
 107                 return ConstString("double");
 108             case eTypeBoolean:
 109                 return ConstString("boolean");
 110             case eTypeChar:
 111                 return ConstString("char");
 112         }
 113         return ConstString();
 114     }
 115
 116     TypeKind
 117     GetTypeKind()
 118     {
 119         return m_type_kind;
 120     }
 121
 122     void
 123     Dump(Stream *s) override
 124     {
 125         s->Printf("%s\n", GetName().GetCString());
 126     }
 127
 128     bool
 129     IsCompleteType() override
 130     {
 131         return true;
 132     }
 133
 134     static bool
 135     classof(const JavaType *jt)
 136     {
 137         return jt->getKind() == JavaType::eKindPrimitive;
 138     }
 139
 140 private:
 141     const TypeKind m_type_kind;
 142 };
 143
 144 class JavaDynamicType : public JavaASTContext::JavaType
 145 {
 146 public:
 147     JavaDynamicType(LLVMCastKind kind, const ConstString &linkage_name) :
 148         JavaType(kind),
 149         m_linkage_name(linkage_name),
 150         m_dynamic_type_id(nullptr)
 151     {
 152     }
 153
 154     ConstString
 155     GetLinkageName() const
 156     {
 157         return m_linkage_name;
 158     }
 159
 160     void
 161     SetDynamicTypeId(const DWARFExpression &type_id)
 162     {
 163         m_dynamic_type_id = type_id;
 164     }
 165
 166     uint64_t
 167     CalculateDynamicTypeId(ExecutionContext *exe_ctx, ValueObject &value_obj)
 168     {
 169         if (!m_dynamic_type_id.IsValid())
 170             return UINT64_MAX;
 171
 172         Value obj_load_address = value_obj.GetValue();
 173         obj_load_address.ResolveValue(exe_ctx);
 174         obj_load_address.SetValueType(Value::eValueTypeLoadAddress);
 175
 176         Value result;
 177         if (m_dynamic_type_id.Evaluate(exe_ctx->GetBestExecutionContextScope(), nullptr, nullptr, 0, &obj_load_address,
 178                                        nullptr, result, nullptr))
 179         {
 180             Error error;
 181
 182             lldb::addr_t type_id_addr = result.GetScalar().UInt();
 183             lldb::ProcessSP process_sp = exe_ctx->GetProcessSP();
 184             if (process_sp)
 185                 return process_sp->ReadUnsignedIntegerFromMemory(type_id_addr, process_sp->GetAddressByteSize(),
 186                                                                  UINT64_MAX, error);
 187         }
 188
 189         return UINT64_MAX;
 190     }
 191
 192 public:
 193     ConstString m_linkage_name;
 194     DWARFExpression m_dynamic_type_id;
 195 };
 196
 197 class JavaObjectType : public JavaDynamicType
 198 {
 199 public:
 200     struct Field
 201     {
 202         ConstString m_name;
 203         CompilerType m_type;
 204         uint32_t m_offset;
 205     };
 206
 207     JavaObjectType(const ConstString &name, const ConstString &linkage_name, uint32_t byte_size)
 208         : JavaDynamicType(JavaType::eKindObject, linkage_name),
 209           m_name(name),
 210           m_byte_size(byte_size),
 211           m_base_class_offset(0),
 212           m_is_complete(false)
 213     {
 214     }
 215
 216     ConstString
 217     GetName() override
 218     {
 219         return m_name;
 220     }
 221
 222     uint32_t
 223     GetByteSize() const
 224     {
 225         return m_byte_size;
 226     }
 227
 228     uint32_t
 229     GetNumFields()
 230     {
 231         return m_fields.size();
 232     }
 233
 234     void
 235     Dump(Stream *s) override
 236     {
 237         if (m_base_class.IsValid())
 238             s->Printf("%s : %s\n", GetName().GetCString(), m_base_class.GetTypeName().GetCString());
 239         else
 240             s->Printf("%s\n", GetName().GetCString());
 241
 242         s->IndentMore();
 243         for (const Field &f : m_fields)
 244             s->Printf("%s %s\n", f.m_type.GetTypeName().GetCString(), f.m_name.GetCString());
 245         s->IndentLess();
 246     }
 247
 248     Field *
 249     GetFieldAtIndex(size_t idx)
 250     {
 251         if (idx < m_fields.size())
 252             return &m_fields[idx];
 253         return nullptr;
 254     }
 255
 256     CompilerType
 257     GetBaseClass()
 258     {
 259         return m_base_class;
 260     }
 261
 262     uint32_t
 263     GetBaseClassOffset()
 264     {
 265         return m_base_class_offset;
 266     }
 267
 268     uint32_t
 269     GetNumInterfaces()
 270     {
 271         return m_interfaces.size();
 272     }
 273
 274     CompilerType
 275     GetInterfaceAtIndex(uint32_t idx)
 276     {
 277         if (m_interfaces.size() < idx)
 278             return m_interfaces[idx];
 279         return CompilerType();
 280     }
 281
 282     bool
 283     IsCompleteType() override
 284     {
 285         return m_is_complete;
 286     }
 287
 288     void
 289     SetCompleteType(bool is_complete)
 290     {
 291         m_is_complete = is_complete;
 292         if (m_byte_size == 0)
 293         {
 294             // Try to calcualte the size of the object based on it's values
 295             for (const Field &field : m_fields)
 296             {
 297                 uint32_t field_end = field.m_offset + field.m_type.GetByteSize(nullptr);
 298                 if (field_end > m_byte_size)
 299                     m_byte_size = field_end;
 300             }
 301         }
 302     }
 303
 304     void
 305     AddBaseClass(const CompilerType &type, uint32_t offset)
 306     {
 307         // TODO: Check if type is an interface and add it to the interface list in that case
 308         m_base_class = type;
 309         m_base_class_offset = offset;
 310     }
 311
 312     void
 313     AddField(const ConstString &name, const CompilerType &type, uint32_t offset)
 314     {
 315         m_fields.push_back({name, type, offset});
 316     }
 317
 318     static bool
 319     classof(const JavaType *jt)
 320     {
 321         return jt->getKind() == JavaType::eKindObject;
 322     }
 323
 324 private:
 325     ConstString m_name;
 326     uint32_t m_byte_size;
 327     CompilerType m_base_class;
 328     uint32_t m_base_class_offset;
 329     std::vector<CompilerType> m_interfaces;
 330     std::vector<Field> m_fields;
 331     bool m_is_complete;
 332 };
 333
 334 class JavaReferenceType : public JavaASTContext::JavaType
 335 {
 336 public:
 337     JavaReferenceType(CompilerType pointee_type) : JavaType(JavaType::eKindReference), m_pointee_type(pointee_type) {}
 338
 339     static bool
 340     classof(const JavaType *jt)
 341     {
 342         return jt->getKind() == JavaType::eKindReference;
 343     }
 344
 345     CompilerType
 346     GetPointeeType()
 347     {
 348         return m_pointee_type;
 349     }
 350
 351     ConstString
 352     GetName() override
 353     {
 354         ConstString pointee_type_name = static_cast<JavaType *>(GetPointeeType().GetOpaqueQualType())->GetName();
 355         return ConstString(std::string(pointee_type_name.AsCString()) + "&");
 356     }
 357
 358     void
 359     Dump(Stream *s) override
 360     {
 361         static_cast<JavaType *>(m_pointee_type.GetOpaqueQualType())->Dump(s);
 362     }
 363
 364     bool
 365     IsCompleteType() override
 366     {
 367         return m_pointee_type.IsCompleteType();
 368     }
 369
 370 private:
 371     CompilerType m_pointee_type;
 372 };
 373
 374 class JavaArrayType : public JavaDynamicType
 375 {
 376 public:
 377     JavaArrayType(const ConstString& linkage_name, CompilerType element_type, const DWARFExpression &length_expression,
 378                   lldb::addr_t data_offset)
 379         : JavaDynamicType(JavaType::eKindArray, linkage_name),
 380           m_element_type(element_type),
 381           m_length_expression(length_expression),
 382           m_data_offset(data_offset)
 383     {
 384     }
 385
 386     static bool
 387     classof(const JavaType *jt)
 388     {
 389         return jt->getKind() == JavaType::eKindArray;
 390     }
 391
 392     CompilerType
 393     GetElementType()
 394     {
 395         return m_element_type;
 396     }
 397
 398     ConstString
 399     GetName() override
 400     {
 401         ConstString element_type_name = static_cast<JavaType *>(GetElementType().GetOpaqueQualType())->GetName();
 402         return ConstString(std::string(element_type_name.AsCString()) + "[]");
 403     }
 404
 405     void
 406     Dump(Stream *s) override
 407     {
 408         s->Printf("%s\n", GetName().GetCString());
 409     }
 410
 411     bool
 412     IsCompleteType() override
 413     {
 414         return m_length_expression.IsValid();
 415     }
 416
 417     uint32_t
 418     GetNumElements(ValueObject *value_obj)
 419     {
 420         if (!m_length_expression.IsValid())
 421             return UINT32_MAX;
 422
 423         Error error;
 424         ValueObjectSP address_obj = value_obj->AddressOf(error);
 425         if (error.Fail())
 426             return UINT32_MAX;
 427
 428         Value obj_load_address = address_obj->GetValue();
 429         obj_load_address.SetValueType(Value::eValueTypeLoadAddress);
 430
 431         Value result;
 432         ExecutionContextScope* exec_ctx_scope = value_obj->GetExecutionContextRef().Lock(true).GetBestExecutionContextScope();
 433         if (m_length_expression.Evaluate(exec_ctx_scope, nullptr, nullptr, 0, nullptr, &obj_load_address, result, nullptr))
 434             return result.GetScalar().UInt();
 435
 436         return UINT32_MAX;
 437     }
 438
 439     uint64_t
 440     GetElementOffset(size_t idx)
 441     {
 442         return m_data_offset + idx * m_element_type.GetByteSize(nullptr);
 443     }
 444
 445 private:
 446     CompilerType m_element_type;
 447     DWARFExpression m_length_expression;
 448     lldb::addr_t m_data_offset;
 449 };
 450
 451 } // end of anonymous namespace
 452
 453 ConstString
 454 JavaASTContext::GetPluginNameStatic()
 455 {
 456     return ConstString("java");
 457 }
 458
 459 ConstString
 460 JavaASTContext::GetPluginName()
 461 {
 462     return JavaASTContext::GetPluginNameStatic();
 463 }
 464
 465 uint32_t
 466 JavaASTContext::GetPluginVersion()
 467 {
 468     return 1;
 469 }
 470
 471 lldb::TypeSystemSP
 472 JavaASTContext::CreateInstance(lldb::LanguageType language, Module *module, Target *target)
 473 {
 474     if (language == eLanguageTypeJava)
 475     {
 476         if (module)
 477             return std::make_shared<JavaASTContext>(module->GetArchitecture());
 478         if (target)
 479             return std::make_shared<JavaASTContext>(target->GetArchitecture());
 480         assert(false && "Either a module or a target has to be specifed to create a JavaASTContext");
 481     }
 482     return lldb::TypeSystemSP();
 483 }
 484
 485 void
 486 JavaASTContext::EnumerateSupportedLanguages(std::set<lldb::LanguageType> &languages_for_types,
 487                                             std::set<lldb::LanguageType> &languages_for_expressions)
 488 {
 489     static std::vector<lldb::LanguageType> s_languages_for_types({lldb::eLanguageTypeJava});
 490     static std::vector<lldb::LanguageType> s_languages_for_expressions({});
 491
 492     languages_for_types.insert(s_languages_for_types.begin(), s_languages_for_types.end());
 493     languages_for_expressions.insert(s_languages_for_expressions.begin(), s_languages_for_expressions.end());
 494 }
 495
 496 void
 497 JavaASTContext::Initialize()
 498 {
 499     PluginManager::RegisterPlugin(GetPluginNameStatic(), "AST context plug-in", CreateInstance,
 500                                   EnumerateSupportedLanguages);
 501 }
 502
 503 void
 504 JavaASTContext::Terminate()
 505 {
 506     PluginManager::UnregisterPlugin(CreateInstance);
 507 }
 508
 509 JavaASTContext::JavaASTContext(const ArchSpec &arch)
 510     : TypeSystem(eKindJava), m_pointer_byte_size(arch.GetAddressByteSize())
 511 {
 512 }
 513
 514 JavaASTContext::~JavaASTContext()
 515 {
 516 }
 517
 518 uint32_t
 519 JavaASTContext::GetPointerByteSize()
 520 {
 521     return m_pointer_byte_size;
 522 }
 523
 524 DWARFASTParser *
 525 JavaASTContext::GetDWARFParser()
 526 {
 527     if (!m_dwarf_ast_parser_ap)
 528         m_dwarf_ast_parser_ap.reset(new DWARFASTParserJava(*this));
 529     return m_dwarf_ast_parser_ap.get();
 530 }
 531
 532 ConstString
 533 JavaASTContext::DeclGetName(void *opaque_decl)
 534 {
 535     return ConstString();
 536 }
 537
 538 std::vector<CompilerDecl>
 539 JavaASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name, const bool ignore_imported_decls)
 540 {
 541     return std::vector<CompilerDecl>();
 542 }
 543
 544 bool
 545 JavaASTContext::DeclContextIsStructUnionOrClass(void *opaque_decl_ctx)
 546 {
 547     return false;
 548 }
 549
 550 ConstString
 551 JavaASTContext::DeclContextGetName(void *opaque_decl_ctx)
 552 {
 553     return ConstString();
 554 }
 555
 556 bool
 557 JavaASTContext::DeclContextIsClassMethod(void *opaque_decl_ctx, lldb::LanguageType *language_ptr,
 558                                          bool *is_instance_method_ptr, ConstString *language_object_name_ptr)
 559 {
 560     return false;
 561 }
 562
 563 bool
 564 JavaASTContext::IsArrayType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size,
 565                             bool *is_incomplete)
 566 {
 567     if (element_type)
 568         element_type->Clear();
 569     if (size)
 570         *size = 0;
 571     if (is_incomplete)
 572         *is_incomplete = false;
 573
 574     if (JavaArrayType *array = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type)))
 575     {
 576         if (element_type)
 577             *element_type = array->GetElementType();
 578         return true;
 579     }
 580     return false;
 581 }
 582
 583 bool
 584 JavaASTContext::IsAggregateType(lldb::opaque_compiler_type_t type)
 585 {
 586     return llvm::isa<JavaObjectType>(static_cast<JavaType *>(type));
 587 }
 588
 589 bool
 590 JavaASTContext::IsCharType(lldb::opaque_compiler_type_t type)
 591 {
 592     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
 593         return ptype->GetTypeKind() == JavaPrimitiveType::eTypeChar;
 594     return false;
 595 }
 596
 597 bool
 598 JavaASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex)
 599 {
 600     is_complex = true;
 601
 602     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
 603     {
 604         switch (ptype->GetTypeKind())
 605         {
 606             case JavaPrimitiveType::eTypeFloat:
 607             case JavaPrimitiveType::eTypeDouble:
 608                 count = 1;
 609                 return true;
 610             default:
 611                 break;
 612         }
 613     }
 614
 615     count = 0;
 616     return false;
 617 }
 618
 619 bool
 620 JavaASTContext::IsFunctionType(lldb::opaque_compiler_type_t type, bool *is_variadic_ptr)
 621 {
 622     if (is_variadic_ptr)
 623         *is_variadic_ptr = false;
 624     return false;
 625 }
 626
 627 size_t
 628 JavaASTContext::GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type)
 629 {
 630     return 0;
 631 }
 632
 633 CompilerType
 634 JavaASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index)
 635 {
 636     return CompilerType();
 637 }
 638
 639 bool
 640 JavaASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type)
 641 {
 642     return false;
 643 }
 644
 645 bool
 646 JavaASTContext::IsBlockPointerType (lldb::opaque_compiler_type_t type, CompilerType *function_pointer_type_ptr)
 647 {
 648     return false;
 649 }
 650
 651 bool
 652 JavaASTContext::IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed)
 653 {
 654     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
 655     {
 656         switch (ptype->GetTypeKind())
 657         {
 658             case JavaPrimitiveType::eTypeByte:
 659             case JavaPrimitiveType::eTypeShort:
 660             case JavaPrimitiveType::eTypeInt:
 661             case JavaPrimitiveType::eTypeLong:
 662                 is_signed = true;
 663                 return true;
 664             default:
 665                 break;
 666         }
 667     }
 668
 669     is_signed = false;
 670     return false;
 671 }
 672
 673 bool
 674 JavaASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type, CompilerType *target_type,
 675                                       bool check_cplusplus, bool check_objc)
 676 {
 677     return llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type));
 678 }
 679
 680 bool
 681 JavaASTContext::IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
 682 {
 683     if (pointee_type)
 684         pointee_type->Clear();
 685     return false;
 686 }
 687
 688 bool
 689 JavaASTContext::IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool *is_rvalue)
 690 {
 691     if (is_rvalue)
 692         *is_rvalue = false;
 693
 694     if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type)))
 695     {
 696         if (pointee_type)
 697             *pointee_type = ref->GetPointeeType();
 698         return true;
 699     }
 700
 701     if (pointee_type)
 702         pointee_type->Clear();
 703     return false;
 704 }
 705
 706 bool
 707 JavaASTContext::IsScalarType(lldb::opaque_compiler_type_t type)
 708 {
 709     return llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type)) ||
 710            llvm::isa<JavaPrimitiveType>(static_cast<JavaType *>(type));
 711 }
 712
 713 bool
 714 JavaASTContext::IsVoidType(lldb::opaque_compiler_type_t type)
 715 {
 716     return false; // TODO: Implement if we introduce the void type
 717 }
 718
 719 bool
 720 JavaASTContext::SupportsLanguage(lldb::LanguageType language)
 721 {
 722     return language == lldb::eLanguageTypeJava;
 723 }
 724
 725 bool
 726 JavaASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type)
 727 {
 728     return true;
 729 }
 730
 731 bool
 732 JavaASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
 733 {
 734     return IsPointerType(type, pointee_type) || IsReferenceType(type, pointee_type);
 735 }
 736
 737 bool
 738 JavaASTContext::IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length)
 739 {
 740     return false; // TODO: Implement it if we need it for string literals
 741 }
 742
 743 bool
 744 JavaASTContext::IsTypedefType(lldb::opaque_compiler_type_t type)
 745 {
 746     return false;
 747 }
 748
 749 bool
 750 JavaASTContext::IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size)
 751 {
 752     if (element_type)
 753         element_type->Clear();
 754     if (size)
 755         *size = 0;
 756     return false;
 757 }
 758
 759 bool
 760 JavaASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type)
 761 {
 762     return llvm::isa<JavaObjectType>(static_cast<JavaType *>(type));
 763 }
 764
 765 uint32_t
 766 JavaASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr)
 767 {
 768     return false;
 769 }
 770
 771 bool
 772 JavaASTContext::IsCompleteType(lldb::opaque_compiler_type_t type)
 773 {
 774     return static_cast<JavaType *>(type)->IsCompleteType();
 775 }
 776
 777 bool
 778 JavaASTContext::IsConst(lldb::opaque_compiler_type_t type)
 779 {
 780     return false;
 781 }
 782
 783 bool
 784 JavaASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type)
 785 {
 786     return false;
 787 }
 788
 789 bool
 790 JavaASTContext::IsDefined(lldb::opaque_compiler_type_t type)
 791 {
 792     return type != nullptr;
 793 }
 794
 795 bool
 796 JavaASTContext::GetCompleteType(lldb::opaque_compiler_type_t type)
 797 {
 798     if (IsCompleteType(type))
 799         return true;
 800
 801     if (JavaArrayType *array = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type)))
 802         return GetCompleteType(array->GetElementType().GetOpaqueQualType());
 803
 804     if (JavaReferenceType *reference = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type)))
 805         return GetCompleteType(reference->GetPointeeType().GetOpaqueQualType());
 806
 807     if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)))
 808     {
 809         SymbolFile *symbol_file = GetSymbolFile();
 810         if (!symbol_file)
 811             return false;
 812
 813         CompilerType object_type(this, type);
 814         return symbol_file->CompleteType(object_type);
 815     }
 816     return false;
 817 }
 818
 819 ConstString
 820 JavaASTContext::GetTypeName(lldb::opaque_compiler_type_t type)
 821 {
 822     if (type)
 823         return static_cast<JavaType *>(type)->GetName();
 824     return ConstString();
 825 }
 826
 827 uint32_t
 828 JavaASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type)
 829 {
 830     if (pointee_or_element_compiler_type)
 831         pointee_or_element_compiler_type->Clear();
 832     if (!type)
 833         return 0;
 834
 835     if (IsReferenceType(type, pointee_or_element_compiler_type))
 836         return eTypeHasChildren | eTypeHasValue | eTypeIsReference;
 837     if (IsArrayType(type, pointee_or_element_compiler_type, nullptr, nullptr))
 838         return eTypeHasChildren | eTypeIsArray;
 839     if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)))
 840         return eTypeHasChildren | eTypeIsClass;
 841
 842     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
 843     {
 844         switch (ptype->GetTypeKind())
 845         {
 846             case JavaPrimitiveType::eTypeByte:
 847             case JavaPrimitiveType::eTypeShort:
 848             case JavaPrimitiveType::eTypeInt:
 849             case JavaPrimitiveType::eTypeLong:
 850                 return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar | eTypeIsInteger | eTypeIsSigned;
 851             case JavaPrimitiveType::eTypeFloat:
 852             case JavaPrimitiveType::eTypeDouble:
 853                 return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar | eTypeIsFloat | eTypeIsSigned;
 854             case JavaPrimitiveType::eTypeBoolean:
 855                 return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar;
 856             case JavaPrimitiveType::eTypeChar:
 857                 return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar;
 858         }
 859     }
 860     return 0;
 861 }
 862
 863 lldb::TypeClass
 864 JavaASTContext::GetTypeClass(lldb::opaque_compiler_type_t type)
 865 {
 866     if (!type)
 867         return eTypeClassInvalid;
 868     if (llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type)))
 869         return eTypeClassReference;
 870     if (llvm::isa<JavaArrayType>(static_cast<JavaType *>(type)))
 871         return eTypeClassArray;
 872     if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)))
 873         return eTypeClassClass;
 874     if (llvm::isa<JavaPrimitiveType>(static_cast<JavaType *>(type)))
 875         return eTypeClassBuiltin;
 876     assert(false && "Java type with unhandled type class");
 877     return eTypeClassInvalid;
 878 }
 879
 880 lldb::LanguageType
 881 JavaASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type)
 882 {
 883     return lldb::eLanguageTypeJava;
 884 }
 885
 886 CompilerType
 887 JavaASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride)
 888 {
 889     if (stride)
 890         *stride = 0;
 891
 892     CompilerType element_type;
 893     if (IsArrayType(type, &element_type, nullptr, nullptr))
 894         return element_type;
 895     return CompilerType();
 896 }
 897
 898 CompilerType
 899 JavaASTContext::GetPointeeType(lldb::opaque_compiler_type_t type)
 900 {
 901     CompilerType pointee_type;
 902     if (IsPointerType(type, &pointee_type))
 903         return pointee_type;
 904     return CompilerType();
 905 }
 906
 907 CompilerType
 908 JavaASTContext::GetPointerType(lldb::opaque_compiler_type_t type)
 909 {
 910     return CompilerType(); // No pointer types in java
 911 }
 912
 913 CompilerType
 914 JavaASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type)
 915 {
 916     return CompilerType(this, type);
 917 }
 918
 919 CompilerType
 920 JavaASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type)
 921 {
 922     return CompilerType(this, type);
 923 }
 924
 925 CompilerType
 926 JavaASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type)
 927 {
 928     CompilerType pointee_type;
 929     if (IsReferenceType(type, &pointee_type))
 930         return pointee_type;
 931     return CompilerType(this, type);
 932 }
 933
 934 CompilerType
 935 JavaASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type)
 936 {
 937     return CompilerType();
 938 }
 939
 940 CompilerType
 941 JavaASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type)
 942 {
 943     return CompilerType();
 944 }
 945
 946 CompilerType
 947 JavaASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size)
 948 {
 949     return CompilerType();
 950 }
 951
 952 size_t
 953 JavaASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type)
 954 {
 955     return 0;
 956 }
 957
 958 lldb::BasicType
 959 JavaASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type)
 960 {
 961     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
 962     {
 963         switch (ptype->GetTypeKind())
 964         {
 965             case JavaPrimitiveType::eTypeByte:
 966                 return eBasicTypeOther;
 967             case JavaPrimitiveType::eTypeShort:
 968                 return eBasicTypeShort;
 969             case JavaPrimitiveType::eTypeInt:
 970                 return eBasicTypeInt;
 971             case JavaPrimitiveType::eTypeLong:
 972                 return eBasicTypeLong;
 973             case JavaPrimitiveType::eTypeFloat:
 974                 return eBasicTypeFloat;
 975             case JavaPrimitiveType::eTypeDouble:
 976                 return eBasicTypeDouble;
 977             case JavaPrimitiveType::eTypeBoolean:
 978                 return eBasicTypeBool;
 979             case JavaPrimitiveType::eTypeChar:
 980                 return eBasicTypeChar;
 981         }
 982     }
 983     return eBasicTypeInvalid;
 984 }
 985
 986 uint64_t
 987 JavaASTContext::GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
 988 {
 989     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
 990     {
 991         switch (ptype->GetTypeKind())
 992         {
 993             case JavaPrimitiveType::eTypeByte:
 994                 return 8;
 995             case JavaPrimitiveType::eTypeShort:
 996                 return 16;
 997             case JavaPrimitiveType::eTypeInt:
 998                 return 32;
 999             case JavaPrimitiveType::eTypeLong:
1000                 return 64;
1001             case JavaPrimitiveType::eTypeFloat:
1002                 return 32;
1003             case JavaPrimitiveType::eTypeDouble:
1004                 return 64;
1005             case JavaPrimitiveType::eTypeBoolean:
1006                 return 1;
1007             case JavaPrimitiveType::eTypeChar:
1008                 return 16;
1009         }
1010     }
1011     else if (llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type)))
1012     {
1013         return 32; // References are always 4 byte long in java
1014     }
1015     else if (llvm::isa<JavaArrayType>(static_cast<JavaType *>(type)))
1016     {
1017         return 64;
1018     }
1019     else if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1020     {
1021         return obj->GetByteSize() * 8;
1022     }
1023     return 0;
1024 }
1025
1026 lldb::Encoding
1027 JavaASTContext::GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count)
1028 {
1029     count = 1;
1030
1031     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
1032     {
1033         switch (ptype->GetTypeKind())
1034         {
1035             case JavaPrimitiveType::eTypeByte:
1036             case JavaPrimitiveType::eTypeShort:
1037             case JavaPrimitiveType::eTypeInt:
1038             case JavaPrimitiveType::eTypeLong:
1039                 return eEncodingSint;
1040             case JavaPrimitiveType::eTypeFloat:
1041             case JavaPrimitiveType::eTypeDouble:
1042                 return eEncodingIEEE754;
1043             case JavaPrimitiveType::eTypeBoolean:
1044             case JavaPrimitiveType::eTypeChar:
1045                 return eEncodingUint;
1046         }
1047     }
1048     if (IsReferenceType(type))
1049         return eEncodingUint;
1050     return eEncodingInvalid;
1051 }
1052
1053 lldb::Format
1054 JavaASTContext::GetFormat(lldb::opaque_compiler_type_t type)
1055 {
1056     if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
1057     {
1058         switch (ptype->GetTypeKind())
1059         {
1060             case JavaPrimitiveType::eTypeByte:
1061             case JavaPrimitiveType::eTypeShort:
1062             case JavaPrimitiveType::eTypeInt:
1063             case JavaPrimitiveType::eTypeLong:
1064                 return eFormatDecimal;
1065             case JavaPrimitiveType::eTypeFloat:
1066             case JavaPrimitiveType::eTypeDouble:
1067                 return eFormatFloat;
1068             case JavaPrimitiveType::eTypeBoolean:
1069                 return eFormatBoolean;
1070             case JavaPrimitiveType::eTypeChar:
1071                 return eFormatUnicode16;
1072         }
1073     }
1074     if (IsReferenceType(type))
1075         return eFormatHex;
1076     return eFormatDefault;
1077 }
1078
1079 unsigned
1080 JavaASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type)
1081 {
1082     return 0;
1083 }
1084
1085 size_t
1086 JavaASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst,
1087                                           size_t dst_size)
1088 {
1089     assert(false && "Not implemented");
1090     return 0;
1091 }
1092
1093 size_t
1094 JavaASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type)
1095 {
1096     return 0;
1097 }
1098
1099 CompilerType
1100 JavaASTContext::GetTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, lldb::TemplateArgumentKind &kind)
1101 {
1102     return CompilerType();
1103 }
1104
1105 uint32_t
1106 JavaASTContext::GetNumFields(lldb::opaque_compiler_type_t type)
1107 {
1108     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1109     {
1110         GetCompleteType(type);
1111         return obj->GetNumFields();
1112     }
1113     return 0;
1114 }
1115
1116 CompilerType
1117 JavaASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name,
1118                                 uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr)
1119 {
1120     if (bit_offset_ptr)
1121         *bit_offset_ptr = 0;
1122     if (bitfield_bit_size_ptr)
1123         *bitfield_bit_size_ptr = 0;
1124     if (is_bitfield_ptr)
1125         *is_bitfield_ptr = false;
1126
1127     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1128     {
1129         GetCompleteType(type);
1130
1131         JavaObjectType::Field *field = obj->GetFieldAtIndex(idx);
1132         if (!field)
1133             return CompilerType();
1134         name = field->m_name.AsCString();
1135         if (bit_offset_ptr)
1136             *bit_offset_ptr = field->m_offset * 8;
1137         return field->m_type;
1138     }
1139     return CompilerType();
1140 }
1141
1142 uint32_t
1143 JavaASTContext::GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes)
1144 {
1145     GetCompleteType(type);
1146
1147     if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type)))
1148         return ref->GetPointeeType().GetNumChildren(omit_empty_base_classes);
1149
1150     if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)))
1151         return GetNumFields(type) + GetNumDirectBaseClasses(type);
1152
1153     return 0;
1154 }
1155
1156 uint32_t
1157 JavaASTContext::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type)
1158 {
1159     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1160     {
1161         GetCompleteType(type);
1162         return obj->GetNumInterfaces() + (obj->GetBaseClass() ? 1 : 0);
1163     }
1164     return 0;
1165 }
1166
1167 uint32_t
1168 JavaASTContext::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type)
1169 {
1170     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1171     {
1172         GetCompleteType(type);
1173         return obj->GetNumInterfaces();
1174     }
1175     return 0;
1176 }
1177
1178 CompilerType
1179 JavaASTContext::GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr)
1180 {
1181     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1182     {
1183         GetCompleteType(type);
1184
1185         if (CompilerType base_class = obj->GetBaseClass())
1186         {
1187             if (idx == 0)
1188                 return base_class;
1189             else
1190                 --idx;
1191         }
1192         return obj->GetInterfaceAtIndex(idx);
1193     }
1194     return CompilerType();
1195 }
1196
1197 CompilerType
1198 JavaASTContext::GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr)
1199 {
1200     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1201     {
1202         GetCompleteType(type);
1203         return obj->GetInterfaceAtIndex(idx);
1204     }
1205     return CompilerType();
1206 }
1207
1208 void
1209 JavaASTContext::DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
1210                           const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size,
1211                           uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary,
1212                           bool verbose, uint32_t depth)
1213 {
1214     assert(false && "Not implemented");
1215 }
1216
1217 bool
1218 JavaASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
1219                               const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size,
1220                               uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
1221                               ExecutionContextScope *exe_scope)
1222 {
1223     if (IsScalarType(type))
1224     {
1225         return data.Dump(s, data_offset, format, data_byte_size,
1226                          1, // count
1227                          UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size, bitfield_bit_offset, exe_scope);
1228     }
1229     return false;
1230 }
1231
1232 void
1233 JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type)
1234 {
1235     StreamFile s(stdout, false);
1236     DumpTypeDescription(type, &s);
1237 }
1238
1239 void
1240 JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s)
1241 {
1242     static_cast<JavaType *>(type)->Dump(s);
1243 }
1244
1245 void
1246 JavaASTContext::DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
1247                             const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size)
1248 {
1249     assert(false && "Not implemented");
1250 }
1251
1252 int
1253 JavaASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type)
1254 {
1255     return 0;
1256 }
1257
1258 CompilerType
1259 JavaASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx)
1260 {
1261     return CompilerType();
1262 }
1263
1264 CompilerType
1265 JavaASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type)
1266 {
1267     return CompilerType();
1268 }
1269
1270 size_t
1271 JavaASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type)
1272 {
1273     return 0;
1274 }
1275
1276 TypeMemberFunctionImpl
1277 JavaASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx)
1278 {
1279     return TypeMemberFunctionImpl();
1280 }
1281
1282 CompilerType
1283 JavaASTContext::GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
1284                                             bool transparent_pointers, bool omit_empty_base_classes,
1285                                             bool ignore_array_bounds, std::string &child_name,
1286                                             uint32_t &child_byte_size, int32_t &child_byte_offset,
1287                                             uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
1288                                             bool &child_is_base_class, bool &child_is_deref_of_parent,
1289                                             ValueObject *valobj, uint64_t &language_flags)
1290 {
1291     child_name.clear();
1292     child_byte_size = 0;
1293     child_byte_offset = 0;
1294     child_bitfield_bit_size = 0;
1295     child_bitfield_bit_offset = 0;
1296     child_is_base_class = false;
1297     child_is_deref_of_parent = false;
1298     language_flags = 0;
1299
1300     ExecutionContextScope *exec_ctx_scope = exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
1301
1302     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1303     {
1304         GetCompleteType(type);
1305
1306         if (CompilerType base_class = obj->GetBaseClass())
1307         {
1308             if (idx == 0)
1309             {
1310                 JavaType *base_class_type = static_cast<JavaType *>(base_class.GetOpaqueQualType());
1311                 child_name = base_class_type->GetName().GetCString();
1312                 child_byte_size = base_class.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
1313                 child_byte_offset = obj->GetBaseClassOffset();
1314                 child_is_base_class = true;
1315                 return base_class;
1316             }
1317             idx -= 1;
1318         }
1319
1320         JavaObjectType::Field *field = obj->GetFieldAtIndex(idx);
1321         if (!field)
1322             return CompilerType();
1323
1324         child_name = field->m_name.AsCString();
1325         child_byte_size = field->m_type.GetByteSize(exec_ctx_scope);
1326         child_byte_offset = field->m_offset;
1327         return field->m_type;
1328     }
1329     else if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type)))
1330     {
1331         CompilerType pointee_type = ref->GetPointeeType();
1332
1333         if (transparent_pointers)
1334             return pointee_type.GetChildCompilerTypeAtIndex(
1335                 exe_ctx, idx, transparent_pointers, omit_empty_base_classes, ignore_array_bounds, child_name,
1336                 child_byte_size, child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
1337                 child_is_base_class, child_is_deref_of_parent, valobj, language_flags);
1338
1339         if (idx != 0)
1340             return CompilerType();
1341
1342         if (valobj && valobj->GetName())
1343             child_name = valobj->GetName().GetCString();
1344         child_is_deref_of_parent = true;
1345         child_byte_offset = 0;
1346         child_byte_size = pointee_type.GetByteSize(exec_ctx_scope);
1347         return pointee_type;
1348     }
1349     return CompilerType();
1350 }
1351
1352 uint32_t
1353 JavaASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name,
1354                                         bool omit_empty_base_classes)
1355 {
1356     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1357     {
1358         GetCompleteType(type);
1359
1360         uint32_t index_offset = 0;
1361         if (CompilerType base_class = obj->GetBaseClass())
1362         {
1363             if (base_class.GetTypeName() == ConstString(name))
1364                 return 0;
1365             index_offset = 1;
1366         }
1367         for (uint32_t i = 0; i < obj->GetNumFields(); ++i)
1368         {
1369             if (obj->GetFieldAtIndex(i)->m_name == ConstString(name))
1370                 return i + index_offset;
1371         }
1372     }
1373     else if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type)))
1374     {
1375         return GetIndexOfChildWithName(ref->GetPointeeType().GetOpaqueQualType(), name, omit_empty_base_classes);
1376     }
1377     return UINT_MAX;
1378 }
1379
1380 size_t
1381 JavaASTContext::GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name,
1382                                               bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes)
1383 {
1384     child_indexes.clear();
1385
1386     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
1387     {
1388         GetCompleteType(type);
1389
1390         uint32_t index_offset = 0;
1391         if (CompilerType base_class = obj->GetBaseClass())
1392         {
1393             if (GetIndexOfChildMemberWithName(base_class.GetOpaqueQualType(), name, omit_empty_base_classes,
1394                                               child_indexes) != 0)
1395             {
1396                 child_indexes.insert(child_indexes.begin(), 0);
1397                 return child_indexes.size();
1398             }
1399             index_offset = 1;
1400         }
1401
1402         for (uint32_t i = 0; i < obj->GetNumFields(); ++i)
1403         {
1404             if (obj->GetFieldAtIndex(i)->m_name == ConstString(name))
1405             {
1406                 child_indexes.push_back(i + index_offset);
1407                 return child_indexes.size();
1408             }
1409         }
1410     }
1411     else if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type)))
1412     {
1413         return GetIndexOfChildMemberWithName(ref->GetPointeeType().GetOpaqueQualType(), name, omit_empty_base_classes,
1414                                              child_indexes);
1415     }
1416     return 0;
1417 }
1418
1419 CompilerType
1420 JavaASTContext::GetLValueReferenceType(lldb::opaque_compiler_type_t type)
1421 {
1422     return CreateReferenceType(CompilerType(this, type));
1423 }
1424
1425 ConstString
1426 JavaASTContext::DeclContextGetScopeQualifiedName(lldb::opaque_compiler_type_t opaque_decl_ctx)
1427 {
1428     return GetTypeName(opaque_decl_ctx);
1429 }
1430
1431 static void
1432 AddPrimitiveType(JavaASTContext::JavaTypeMap &type_map, JavaPrimitiveType::TypeKind type_kind)
1433 {
1434     JavaPrimitiveType *type = new JavaPrimitiveType(type_kind);
1435     type_map.emplace(type->GetName(), std::unique_ptr<JavaASTContext::JavaType>(type));
1436 }
1437
1438 CompilerType
1439 JavaASTContext::CreateBaseType(const ConstString &name)
1440 {
1441     if (m_base_type_map.empty())
1442     {
1443         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeByte);
1444         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeShort);
1445         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeInt);
1446         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeLong);
1447         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeFloat);
1448         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeDouble);
1449         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeBoolean);
1450         AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeChar);
1451     }
1452     auto it = m_base_type_map.find(name);
1453     if (it != m_base_type_map.end())
1454         return CompilerType(this, it->second.get());
1455     return CompilerType();
1456 }
1457
1458 CompilerType
1459 JavaASTContext::CreateObjectType(const ConstString &name, const ConstString &linkage_name, uint32_t byte_size)
1460 {
1461     auto it = m_object_type_map.find(name);
1462     if (it == m_object_type_map.end())
1463     {
1464         std::unique_ptr<JavaType> object_type(new JavaObjectType(name, linkage_name, byte_size));
1465         it = m_object_type_map.emplace(name, std::move(object_type)).first;
1466     }
1467     return CompilerType(this, it->second.get());
1468 }
1469
1470 CompilerType
1471 JavaASTContext::CreateArrayType(const ConstString &linkage_name, const CompilerType &element_type,
1472                                 const DWARFExpression &length_expression, const lldb::addr_t data_offset)
1473 {
1474     ConstString name = element_type.GetTypeName();
1475     auto it = m_array_type_map.find(name);
1476     if (it == m_array_type_map.end())
1477     {
1478         std::unique_ptr<JavaType> array_type(new JavaArrayType(linkage_name, element_type, length_expression,
1479                                                                data_offset));
1480         it = m_array_type_map.emplace(name, std::move(array_type)).first;
1481     }
1482     return CompilerType(this, it->second.get());
1483 }
1484
1485 CompilerType
1486 JavaASTContext::CreateReferenceType(const CompilerType &pointee_type)
1487 {
1488     ConstString name = pointee_type.GetTypeName();
1489     auto it = m_reference_type_map.find(name);
1490     if (it == m_reference_type_map.end())
1491         it = m_reference_type_map.emplace(name, std::unique_ptr<JavaType>(new JavaReferenceType(pointee_type))).first;
1492     return CompilerType(this, it->second.get());
1493 }
1494
1495 void
1496 JavaASTContext::CompleteObjectType(const CompilerType &object_type)
1497 {
1498     JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(object_type.GetOpaqueQualType()));
1499     assert(obj && "JavaASTContext::CompleteObjectType called with not a JavaObjectType");
1500     obj->SetCompleteType(true);
1501 }
1502
1503 void
1504 JavaASTContext::AddBaseClassToObject(const CompilerType &object_type, const CompilerType &member_type,
1505                                      uint32_t member_offset)
1506 {
1507     JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(object_type.GetOpaqueQualType()));
1508     assert(obj && "JavaASTContext::AddMemberToObject called with not a JavaObjectType");
1509     obj->AddBaseClass(member_type, member_offset);
1510 }
1511
1512 void
1513 JavaASTContext::AddMemberToObject(const CompilerType &object_type, const ConstString &name,
1514                                   const CompilerType &member_type, uint32_t member_offset)
1515 {
1516     JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(object_type.GetOpaqueQualType()));
1517     assert(obj && "JavaASTContext::AddMemberToObject called with not a JavaObjectType");
1518     obj->AddField(name, member_type, member_offset);
1519 }
1520
1521 void
1522 JavaASTContext::SetDynamicTypeId(const CompilerType &type, const DWARFExpression &type_id)
1523 {
1524     JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type.GetOpaqueQualType()));
1525     assert(obj && "JavaASTContext::SetDynamicTypeId called with not a JavaObjectType");
1526     obj->SetDynamicTypeId(type_id);
1527 }
1528
1529 uint64_t
1530 JavaASTContext::CalculateDynamicTypeId(ExecutionContext *exe_ctx, const CompilerType &type, ValueObject &in_value)
1531 {
1532     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
1533         return obj->CalculateDynamicTypeId(exe_ctx, in_value);
1534     if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
1535         return arr->CalculateDynamicTypeId(exe_ctx, in_value);
1536     return UINT64_MAX;
1537 }
1538
1539 uint32_t
1540 JavaASTContext::CalculateArraySize(const CompilerType &type, ValueObject &in_value)
1541 {
1542     if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
1543         return arr->GetNumElements(&in_value);
1544     return UINT32_MAX;
1545 }
1546
1547 uint64_t
1548 JavaASTContext::CalculateArrayElementOffset(const CompilerType &type, size_t index)
1549 {
1550     if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
1551         return arr->GetElementOffset(index);
1552     return UINT64_MAX;
1553 }
1554
1555 ConstString
1556 JavaASTContext::GetLinkageName(const CompilerType &type)
1557 {
1558     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
1559         return obj->GetLinkageName();
1560     return ConstString();
1561 }