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