| //===-- JavaASTContext.cpp --------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/Symbol/JavaASTContext.h" |
| #include "lldb/Core/DumpDataExtractor.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/PluginManager.h" |
| #include "lldb/Core/StreamFile.h" |
| #include "lldb/Core/ValueObject.h" |
| #include "lldb/Expression/DWARFExpression.h" |
| #include "lldb/Symbol/CompilerType.h" |
| #include "lldb/Symbol/SymbolFile.h" |
| #include "lldb/Symbol/Type.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Utility/ArchSpec.h" |
| #include "lldb/Utility/Stream.h" |
| #include <sstream> |
| |
| #include "Plugins/SymbolFile/DWARF/DWARFASTParserJava.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| namespace lldb_private { |
| |
| class JavaASTContext::JavaType { |
| public: |
| enum LLVMCastKind { |
| eKindPrimitive, |
| eKindObject, |
| eKindReference, |
| eKindArray, |
| kNumKinds |
| }; |
| |
| JavaType(LLVMCastKind kind) : m_kind(kind) {} |
| |
| virtual ~JavaType() = default; |
| |
| virtual ConstString GetName() = 0; |
| |
| virtual void Dump(Stream *s) = 0; |
| |
| virtual bool IsCompleteType() = 0; |
| |
| LLVMCastKind getKind() const { return m_kind; } |
| |
| private: |
| LLVMCastKind m_kind; |
| }; |
| |
| } // end of namespace lldb_private |
| |
| namespace { |
| |
| class JavaPrimitiveType : public JavaASTContext::JavaType { |
| public: |
| enum TypeKind { |
| eTypeByte, |
| eTypeShort, |
| eTypeInt, |
| eTypeLong, |
| eTypeFloat, |
| eTypeDouble, |
| eTypeBoolean, |
| eTypeChar, |
| }; |
| |
| JavaPrimitiveType(TypeKind type_kind) |
| : JavaType(JavaType::eKindPrimitive), m_type_kind(type_kind) {} |
| |
| ConstString GetName() override { |
| switch (m_type_kind) { |
| case eTypeByte: |
| return ConstString("byte"); |
| case eTypeShort: |
| return ConstString("short"); |
| case eTypeInt: |
| return ConstString("int"); |
| case eTypeLong: |
| return ConstString("long"); |
| case eTypeFloat: |
| return ConstString("float"); |
| case eTypeDouble: |
| return ConstString("double"); |
| case eTypeBoolean: |
| return ConstString("boolean"); |
| case eTypeChar: |
| return ConstString("char"); |
| } |
| return ConstString(); |
| } |
| |
| TypeKind GetTypeKind() { return m_type_kind; } |
| |
| void Dump(Stream *s) override { s->Printf("%s\n", GetName().GetCString()); } |
| |
| bool IsCompleteType() override { return true; } |
| |
| static bool classof(const JavaType *jt) { |
| return jt->getKind() == JavaType::eKindPrimitive; |
| } |
| |
| private: |
| const TypeKind m_type_kind; |
| }; |
| |
| class JavaDynamicType : public JavaASTContext::JavaType { |
| public: |
| JavaDynamicType(LLVMCastKind kind, const ConstString &linkage_name) |
| : JavaType(kind), m_linkage_name(linkage_name), |
| m_dynamic_type_id(nullptr) {} |
| |
| ConstString GetLinkageName() const { return m_linkage_name; } |
| |
| void SetDynamicTypeId(const DWARFExpression &type_id) { |
| m_dynamic_type_id = type_id; |
| } |
| |
| uint64_t CalculateDynamicTypeId(ExecutionContext *exe_ctx, |
| ValueObject &value_obj) { |
| if (!m_dynamic_type_id.IsValid()) |
| return UINT64_MAX; |
| |
| Value obj_load_address = value_obj.GetValue(); |
| obj_load_address.ResolveValue(exe_ctx); |
| obj_load_address.SetValueType(Value::eValueTypeLoadAddress); |
| |
| Value result; |
| if (m_dynamic_type_id.Evaluate(exe_ctx->GetBestExecutionContextScope(), 0, |
| &obj_load_address, nullptr, result, |
| nullptr)) { |
| Status error; |
| |
| lldb::addr_t type_id_addr = result.GetScalar().UInt(); |
| lldb::ProcessSP process_sp = exe_ctx->GetProcessSP(); |
| if (process_sp) |
| return process_sp->ReadUnsignedIntegerFromMemory( |
| type_id_addr, process_sp->GetAddressByteSize(), UINT64_MAX, error); |
| } |
| |
| return UINT64_MAX; |
| } |
| |
| public: |
| ConstString m_linkage_name; |
| DWARFExpression m_dynamic_type_id; |
| }; |
| |
| class JavaObjectType : public JavaDynamicType { |
| public: |
| struct Field { |
| ConstString m_name; |
| CompilerType m_type; |
| uint32_t m_offset; |
| }; |
| |
| JavaObjectType(const ConstString &name, const ConstString &linkage_name, |
| uint32_t byte_size) |
| : JavaDynamicType(JavaType::eKindObject, linkage_name), m_name(name), |
| m_byte_size(byte_size), m_base_class_offset(0), m_is_complete(false) {} |
| |
| ConstString GetName() override { return m_name; } |
| |
| uint32_t GetByteSize() const { return m_byte_size; } |
| |
| uint32_t GetNumFields() { return m_fields.size(); } |
| |
| void Dump(Stream *s) override { |
| if (m_base_class.IsValid()) |
| s->Printf("%s : %s\n", GetName().GetCString(), |
| m_base_class.GetTypeName().GetCString()); |
| else |
| s->Printf("%s\n", GetName().GetCString()); |
| |
| s->IndentMore(); |
| for (const Field &f : m_fields) |
| s->Printf("%s %s\n", f.m_type.GetTypeName().GetCString(), |
| f.m_name.GetCString()); |
| s->IndentLess(); |
| } |
| |
| Field *GetFieldAtIndex(size_t idx) { |
| if (idx < m_fields.size()) |
| return &m_fields[idx]; |
| return nullptr; |
| } |
| |
| CompilerType GetBaseClass() { return m_base_class; } |
| |
| uint32_t GetBaseClassOffset() { return m_base_class_offset; } |
| |
| uint32_t GetNumInterfaces() { return m_interfaces.size(); } |
| |
| CompilerType GetInterfaceAtIndex(uint32_t idx) { |
| if (m_interfaces.size() < idx) |
| return m_interfaces[idx]; |
| return CompilerType(); |
| } |
| |
| bool IsCompleteType() override { return m_is_complete; } |
| |
| void SetCompleteType(bool is_complete) { |
| m_is_complete = is_complete; |
| if (m_byte_size == 0) { |
| // Try to calcualte the size of the object based on it's values |
| for (const Field &field : m_fields) { |
| uint32_t field_end = field.m_offset + field.m_type.GetByteSize(nullptr); |
| if (field_end > m_byte_size) |
| m_byte_size = field_end; |
| } |
| } |
| } |
| |
| void AddBaseClass(const CompilerType &type, uint32_t offset) { |
| // TODO: Check if type is an interface and add it to the interface list in |
| // that case |
| m_base_class = type; |
| m_base_class_offset = offset; |
| } |
| |
| void AddField(const ConstString &name, const CompilerType &type, |
| uint32_t offset) { |
| m_fields.push_back({name, type, offset}); |
| } |
| |
| static bool classof(const JavaType *jt) { |
| return jt->getKind() == JavaType::eKindObject; |
| } |
| |
| private: |
| ConstString m_name; |
| uint32_t m_byte_size; |
| CompilerType m_base_class; |
| uint32_t m_base_class_offset; |
| std::vector<CompilerType> m_interfaces; |
| std::vector<Field> m_fields; |
| bool m_is_complete; |
| }; |
| |
| class JavaReferenceType : public JavaASTContext::JavaType { |
| public: |
| JavaReferenceType(CompilerType pointee_type) |
| : JavaType(JavaType::eKindReference), m_pointee_type(pointee_type) {} |
| |
| static bool classof(const JavaType *jt) { |
| return jt->getKind() == JavaType::eKindReference; |
| } |
| |
| CompilerType GetPointeeType() { return m_pointee_type; } |
| |
| ConstString GetName() override { |
| ConstString pointee_type_name = |
| static_cast<JavaType *>(GetPointeeType().GetOpaqueQualType()) |
| ->GetName(); |
| return ConstString(std::string(pointee_type_name.AsCString()) + "&"); |
| } |
| |
| void Dump(Stream *s) override { |
| static_cast<JavaType *>(m_pointee_type.GetOpaqueQualType())->Dump(s); |
| } |
| |
| bool IsCompleteType() override { return m_pointee_type.IsCompleteType(); } |
| |
| private: |
| CompilerType m_pointee_type; |
| }; |
| |
| class JavaArrayType : public JavaDynamicType { |
| public: |
| JavaArrayType(const ConstString &linkage_name, CompilerType element_type, |
| const DWARFExpression &length_expression, |
| lldb::addr_t data_offset) |
| : JavaDynamicType(JavaType::eKindArray, linkage_name), |
| m_element_type(element_type), m_length_expression(length_expression), |
| m_data_offset(data_offset) {} |
| |
| static bool classof(const JavaType *jt) { |
| return jt->getKind() == JavaType::eKindArray; |
| } |
| |
| CompilerType GetElementType() { return m_element_type; } |
| |
| ConstString GetName() override { |
| ConstString element_type_name = |
| static_cast<JavaType *>(GetElementType().GetOpaqueQualType()) |
| ->GetName(); |
| return ConstString(std::string(element_type_name.AsCString()) + "[]"); |
| } |
| |
| void Dump(Stream *s) override { s->Printf("%s\n", GetName().GetCString()); } |
| |
| bool IsCompleteType() override { return m_length_expression.IsValid(); } |
| |
| uint32_t GetNumElements(ValueObject *value_obj) { |
| if (!m_length_expression.IsValid()) |
| return UINT32_MAX; |
| |
| Status error; |
| ValueObjectSP address_obj = value_obj->AddressOf(error); |
| if (error.Fail()) |
| return UINT32_MAX; |
| |
| Value obj_load_address = address_obj->GetValue(); |
| obj_load_address.SetValueType(Value::eValueTypeLoadAddress); |
| |
| Value result; |
| ExecutionContextScope *exec_ctx_scope = value_obj->GetExecutionContextRef() |
| .Lock(true) |
| .GetBestExecutionContextScope(); |
| if (m_length_expression.Evaluate(exec_ctx_scope, 0, nullptr, |
| &obj_load_address, result, nullptr)) |
| return result.GetScalar().UInt(); |
| |
| return UINT32_MAX; |
| } |
| |
| uint64_t GetElementOffset(size_t idx) { |
| return m_data_offset + idx * m_element_type.GetByteSize(nullptr); |
| } |
| |
| private: |
| CompilerType m_element_type; |
| DWARFExpression m_length_expression; |
| lldb::addr_t m_data_offset; |
| }; |
| |
| } // end of anonymous namespace |
| |
| ConstString JavaASTContext::GetPluginNameStatic() { |
| return ConstString("java"); |
| } |
| |
| ConstString JavaASTContext::GetPluginName() { |
| return JavaASTContext::GetPluginNameStatic(); |
| } |
| |
| uint32_t JavaASTContext::GetPluginVersion() { return 1; } |
| |
| lldb::TypeSystemSP JavaASTContext::CreateInstance(lldb::LanguageType language, |
| Module *module, |
| Target *target) { |
| if (language == eLanguageTypeJava) { |
| if (module) |
| return std::make_shared<JavaASTContext>(module->GetArchitecture()); |
| if (target) |
| return std::make_shared<JavaASTContext>(target->GetArchitecture()); |
| assert(false && "Either a module or a target has to be specifed to create " |
| "a JavaASTContext"); |
| } |
| return lldb::TypeSystemSP(); |
| } |
| |
| void JavaASTContext::EnumerateSupportedLanguages( |
| std::set<lldb::LanguageType> &languages_for_types, |
| std::set<lldb::LanguageType> &languages_for_expressions) { |
| static std::vector<lldb::LanguageType> s_languages_for_types( |
| {lldb::eLanguageTypeJava}); |
| static std::vector<lldb::LanguageType> s_languages_for_expressions({}); |
| |
| languages_for_types.insert(s_languages_for_types.begin(), |
| s_languages_for_types.end()); |
| languages_for_expressions.insert(s_languages_for_expressions.begin(), |
| s_languages_for_expressions.end()); |
| } |
| |
| void JavaASTContext::Initialize() { |
| PluginManager::RegisterPlugin(GetPluginNameStatic(), "AST context plug-in", |
| CreateInstance, EnumerateSupportedLanguages); |
| } |
| |
| void JavaASTContext::Terminate() { |
| PluginManager::UnregisterPlugin(CreateInstance); |
| } |
| |
| JavaASTContext::JavaASTContext(const ArchSpec &arch) |
| : TypeSystem(eKindJava), m_pointer_byte_size(arch.GetAddressByteSize()) {} |
| |
| JavaASTContext::~JavaASTContext() {} |
| |
| uint32_t JavaASTContext::GetPointerByteSize() { return m_pointer_byte_size; } |
| |
| DWARFASTParser *JavaASTContext::GetDWARFParser() { |
| if (!m_dwarf_ast_parser_ap) |
| m_dwarf_ast_parser_ap.reset(new DWARFASTParserJava(*this)); |
| return m_dwarf_ast_parser_ap.get(); |
| } |
| |
| ConstString JavaASTContext::DeclGetName(void *opaque_decl) { |
| return ConstString(); |
| } |
| |
| std::vector<CompilerDecl> JavaASTContext::DeclContextFindDeclByName( |
| void *opaque_decl_ctx, ConstString name, const bool ignore_imported_decls) { |
| return std::vector<CompilerDecl>(); |
| } |
| |
| bool JavaASTContext::DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) { |
| return false; |
| } |
| |
| ConstString JavaASTContext::DeclContextGetName(void *opaque_decl_ctx) { |
| return ConstString(); |
| } |
| |
| bool JavaASTContext::DeclContextIsClassMethod( |
| void *opaque_decl_ctx, lldb::LanguageType *language_ptr, |
| bool *is_instance_method_ptr, ConstString *language_object_name_ptr) { |
| return false; |
| } |
| |
| bool JavaASTContext::IsArrayType(lldb::opaque_compiler_type_t type, |
| CompilerType *element_type, uint64_t *size, |
| bool *is_incomplete) { |
| if (element_type) |
| element_type->Clear(); |
| if (size) |
| *size = 0; |
| if (is_incomplete) |
| *is_incomplete = false; |
| |
| if (JavaArrayType *array = |
| llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type))) { |
| if (element_type) |
| *element_type = array->GetElementType(); |
| return true; |
| } |
| return false; |
| } |
| |
| bool JavaASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) { |
| return llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)); |
| } |
| |
| bool JavaASTContext::IsCharType(lldb::opaque_compiler_type_t type) { |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) |
| return ptype->GetTypeKind() == JavaPrimitiveType::eTypeChar; |
| return false; |
| } |
| |
| bool JavaASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type, |
| uint32_t &count, bool &is_complex) { |
| is_complex = true; |
| |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) { |
| switch (ptype->GetTypeKind()) { |
| case JavaPrimitiveType::eTypeFloat: |
| case JavaPrimitiveType::eTypeDouble: |
| count = 1; |
| return true; |
| default: |
| break; |
| } |
| } |
| |
| count = 0; |
| return false; |
| } |
| |
| bool JavaASTContext::IsFunctionType(lldb::opaque_compiler_type_t type, |
| bool *is_variadic_ptr) { |
| if (is_variadic_ptr) |
| *is_variadic_ptr = false; |
| return false; |
| } |
| |
| size_t JavaASTContext::GetNumberOfFunctionArguments( |
| lldb::opaque_compiler_type_t type) { |
| return 0; |
| } |
| |
| CompilerType |
| JavaASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, |
| const size_t index) { |
| return CompilerType(); |
| } |
| |
| bool JavaASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) { |
| return false; |
| } |
| |
| bool JavaASTContext::IsBlockPointerType( |
| lldb::opaque_compiler_type_t type, |
| CompilerType *function_pointer_type_ptr) { |
| return false; |
| } |
| |
| bool JavaASTContext::IsIntegerType(lldb::opaque_compiler_type_t type, |
| bool &is_signed) { |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) { |
| switch (ptype->GetTypeKind()) { |
| case JavaPrimitiveType::eTypeByte: |
| case JavaPrimitiveType::eTypeShort: |
| case JavaPrimitiveType::eTypeInt: |
| case JavaPrimitiveType::eTypeLong: |
| is_signed = true; |
| return true; |
| default: |
| break; |
| } |
| } |
| |
| is_signed = false; |
| return false; |
| } |
| |
| bool JavaASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type, |
| CompilerType *target_type, |
| bool check_cplusplus, |
| bool check_objc) { |
| return llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type)); |
| } |
| |
| bool JavaASTContext::IsPointerType(lldb::opaque_compiler_type_t type, |
| CompilerType *pointee_type) { |
| if (pointee_type) |
| pointee_type->Clear(); |
| return false; |
| } |
| |
| bool JavaASTContext::IsReferenceType(lldb::opaque_compiler_type_t type, |
| CompilerType *pointee_type, |
| bool *is_rvalue) { |
| if (is_rvalue) |
| *is_rvalue = false; |
| |
| if (JavaReferenceType *ref = |
| llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type))) { |
| if (pointee_type) |
| *pointee_type = ref->GetPointeeType(); |
| return true; |
| } |
| |
| if (pointee_type) |
| pointee_type->Clear(); |
| return false; |
| } |
| |
| bool JavaASTContext::IsScalarType(lldb::opaque_compiler_type_t type) { |
| return llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type)) || |
| llvm::isa<JavaPrimitiveType>(static_cast<JavaType *>(type)); |
| } |
| |
| bool JavaASTContext::IsVoidType(lldb::opaque_compiler_type_t type) { |
| return false; // TODO: Implement if we introduce the void type |
| } |
| |
| bool JavaASTContext::SupportsLanguage(lldb::LanguageType language) { |
| return language == lldb::eLanguageTypeJava; |
| } |
| |
| bool JavaASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) { |
| return true; |
| } |
| |
| bool JavaASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, |
| CompilerType *pointee_type) { |
| return IsPointerType(type, pointee_type) || |
| IsReferenceType(type, pointee_type); |
| } |
| |
| bool JavaASTContext::IsCStringType(lldb::opaque_compiler_type_t type, |
| uint32_t &length) { |
| return false; // TODO: Implement it if we need it for string literals |
| } |
| |
| bool JavaASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) { |
| return false; |
| } |
| |
| bool JavaASTContext::IsVectorType(lldb::opaque_compiler_type_t type, |
| CompilerType *element_type, uint64_t *size) { |
| if (element_type) |
| element_type->Clear(); |
| if (size) |
| *size = 0; |
| return false; |
| } |
| |
| bool JavaASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) { |
| return llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)); |
| } |
| |
| uint32_t |
| JavaASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, |
| CompilerType *base_type_ptr) { |
| return false; |
| } |
| |
| bool JavaASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) { |
| return static_cast<JavaType *>(type)->IsCompleteType(); |
| } |
| |
| bool JavaASTContext::IsConst(lldb::opaque_compiler_type_t type) { |
| return false; |
| } |
| |
| bool JavaASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) { |
| return false; |
| } |
| |
| bool JavaASTContext::IsDefined(lldb::opaque_compiler_type_t type) { |
| return type != nullptr; |
| } |
| |
| bool JavaASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) { |
| if (IsCompleteType(type)) |
| return true; |
| |
| if (JavaArrayType *array = |
| llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type))) |
| return GetCompleteType(array->GetElementType().GetOpaqueQualType()); |
| |
| if (JavaReferenceType *reference = |
| llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type))) |
| return GetCompleteType(reference->GetPointeeType().GetOpaqueQualType()); |
| |
| if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type))) { |
| SymbolFile *symbol_file = GetSymbolFile(); |
| if (!symbol_file) |
| return false; |
| |
| CompilerType object_type(this, type); |
| return symbol_file->CompleteType(object_type); |
| } |
| return false; |
| } |
| |
| ConstString JavaASTContext::GetTypeName(lldb::opaque_compiler_type_t type) { |
| if (type) |
| return static_cast<JavaType *>(type)->GetName(); |
| return ConstString(); |
| } |
| |
| uint32_t |
| JavaASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, |
| CompilerType *pointee_or_element_compiler_type) { |
| if (pointee_or_element_compiler_type) |
| pointee_or_element_compiler_type->Clear(); |
| if (!type) |
| return 0; |
| |
| if (IsReferenceType(type, pointee_or_element_compiler_type)) |
| return eTypeHasChildren | eTypeHasValue | eTypeIsReference; |
| if (IsArrayType(type, pointee_or_element_compiler_type, nullptr, nullptr)) |
| return eTypeHasChildren | eTypeIsArray; |
| if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type))) |
| return eTypeHasChildren | eTypeIsClass; |
| |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) { |
| switch (ptype->GetTypeKind()) { |
| case JavaPrimitiveType::eTypeByte: |
| case JavaPrimitiveType::eTypeShort: |
| case JavaPrimitiveType::eTypeInt: |
| case JavaPrimitiveType::eTypeLong: |
| return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar | eTypeIsInteger | |
| eTypeIsSigned; |
| case JavaPrimitiveType::eTypeFloat: |
| case JavaPrimitiveType::eTypeDouble: |
| return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar | eTypeIsFloat | |
| eTypeIsSigned; |
| case JavaPrimitiveType::eTypeBoolean: |
| return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar; |
| case JavaPrimitiveType::eTypeChar: |
| return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar; |
| } |
| } |
| return 0; |
| } |
| |
| lldb::TypeClass |
| JavaASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) { |
| if (!type) |
| return eTypeClassInvalid; |
| if (llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type))) |
| return eTypeClassReference; |
| if (llvm::isa<JavaArrayType>(static_cast<JavaType *>(type))) |
| return eTypeClassArray; |
| if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type))) |
| return eTypeClassClass; |
| if (llvm::isa<JavaPrimitiveType>(static_cast<JavaType *>(type))) |
| return eTypeClassBuiltin; |
| assert(false && "Java type with unhandled type class"); |
| return eTypeClassInvalid; |
| } |
| |
| lldb::LanguageType |
| JavaASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) { |
| return lldb::eLanguageTypeJava; |
| } |
| |
| CompilerType |
| JavaASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type, |
| uint64_t *stride) { |
| if (stride) |
| *stride = 0; |
| |
| CompilerType element_type; |
| if (IsArrayType(type, &element_type, nullptr, nullptr)) |
| return element_type; |
| return CompilerType(); |
| } |
| |
| CompilerType JavaASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) { |
| CompilerType pointee_type; |
| if (IsPointerType(type, &pointee_type)) |
| return pointee_type; |
| return CompilerType(); |
| } |
| |
| CompilerType JavaASTContext::GetPointerType(lldb::opaque_compiler_type_t type) { |
| return CompilerType(); // No pointer types in java |
| } |
| |
| CompilerType |
| JavaASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) { |
| return CompilerType(this, type); |
| } |
| |
| CompilerType |
| JavaASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) { |
| return CompilerType(this, type); |
| } |
| |
| CompilerType |
| JavaASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) { |
| CompilerType pointee_type; |
| if (IsReferenceType(type, &pointee_type)) |
| return pointee_type; |
| return CompilerType(this, type); |
| } |
| |
| CompilerType |
| JavaASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) { |
| return CompilerType(); |
| } |
| |
| CompilerType JavaASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) { |
| return CompilerType(); |
| } |
| |
| CompilerType |
| JavaASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, |
| size_t bit_size) { |
| return CompilerType(); |
| } |
| |
| size_t JavaASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) { |
| return 0; |
| } |
| |
| lldb::BasicType |
| JavaASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) { |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) { |
| switch (ptype->GetTypeKind()) { |
| case JavaPrimitiveType::eTypeByte: |
| return eBasicTypeOther; |
| case JavaPrimitiveType::eTypeShort: |
| return eBasicTypeShort; |
| case JavaPrimitiveType::eTypeInt: |
| return eBasicTypeInt; |
| case JavaPrimitiveType::eTypeLong: |
| return eBasicTypeLong; |
| case JavaPrimitiveType::eTypeFloat: |
| return eBasicTypeFloat; |
| case JavaPrimitiveType::eTypeDouble: |
| return eBasicTypeDouble; |
| case JavaPrimitiveType::eTypeBoolean: |
| return eBasicTypeBool; |
| case JavaPrimitiveType::eTypeChar: |
| return eBasicTypeChar; |
| } |
| } |
| return eBasicTypeInvalid; |
| } |
| |
| uint64_t JavaASTContext::GetBitSize(lldb::opaque_compiler_type_t type, |
| ExecutionContextScope *exe_scope) { |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) { |
| switch (ptype->GetTypeKind()) { |
| case JavaPrimitiveType::eTypeByte: |
| return 8; |
| case JavaPrimitiveType::eTypeShort: |
| return 16; |
| case JavaPrimitiveType::eTypeInt: |
| return 32; |
| case JavaPrimitiveType::eTypeLong: |
| return 64; |
| case JavaPrimitiveType::eTypeFloat: |
| return 32; |
| case JavaPrimitiveType::eTypeDouble: |
| return 64; |
| case JavaPrimitiveType::eTypeBoolean: |
| return 1; |
| case JavaPrimitiveType::eTypeChar: |
| return 16; |
| } |
| } else if (llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type))) { |
| return 32; // References are always 4 byte long in java |
| } else if (llvm::isa<JavaArrayType>(static_cast<JavaType *>(type))) { |
| return 64; |
| } else if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>( |
| static_cast<JavaType *>(type))) { |
| return obj->GetByteSize() * 8; |
| } |
| return 0; |
| } |
| |
| lldb::Encoding JavaASTContext::GetEncoding(lldb::opaque_compiler_type_t type, |
| uint64_t &count) { |
| count = 1; |
| |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) { |
| switch (ptype->GetTypeKind()) { |
| case JavaPrimitiveType::eTypeByte: |
| case JavaPrimitiveType::eTypeShort: |
| case JavaPrimitiveType::eTypeInt: |
| case JavaPrimitiveType::eTypeLong: |
| return eEncodingSint; |
| case JavaPrimitiveType::eTypeFloat: |
| case JavaPrimitiveType::eTypeDouble: |
| return eEncodingIEEE754; |
| case JavaPrimitiveType::eTypeBoolean: |
| case JavaPrimitiveType::eTypeChar: |
| return eEncodingUint; |
| } |
| } |
| if (IsReferenceType(type)) |
| return eEncodingUint; |
| return eEncodingInvalid; |
| } |
| |
| lldb::Format JavaASTContext::GetFormat(lldb::opaque_compiler_type_t type) { |
| if (JavaPrimitiveType *ptype = |
| llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type))) { |
| switch (ptype->GetTypeKind()) { |
| case JavaPrimitiveType::eTypeByte: |
| case JavaPrimitiveType::eTypeShort: |
| case JavaPrimitiveType::eTypeInt: |
| case JavaPrimitiveType::eTypeLong: |
| return eFormatDecimal; |
| case JavaPrimitiveType::eTypeFloat: |
| case JavaPrimitiveType::eTypeDouble: |
| return eFormatFloat; |
| case JavaPrimitiveType::eTypeBoolean: |
| return eFormatBoolean; |
| case JavaPrimitiveType::eTypeChar: |
| return eFormatUnicode16; |
| } |
| } |
| if (IsReferenceType(type)) |
| return eFormatHex; |
| return eFormatDefault; |
| } |
| |
| unsigned JavaASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) { |
| return 0; |
| } |
| |
| size_t |
| JavaASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, |
| const char *s, uint8_t *dst, |
| size_t dst_size) { |
| assert(false && "Not implemented"); |
| return 0; |
| } |
| |
| size_t |
| JavaASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) { |
| return 0; |
| } |
| |
| uint32_t JavaASTContext::GetNumFields(lldb::opaque_compiler_type_t type) { |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| return obj->GetNumFields(); |
| } |
| return 0; |
| } |
| |
| CompilerType JavaASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type, |
| size_t idx, std::string &name, |
| uint64_t *bit_offset_ptr, |
| uint32_t *bitfield_bit_size_ptr, |
| bool *is_bitfield_ptr) { |
| if (bit_offset_ptr) |
| *bit_offset_ptr = 0; |
| if (bitfield_bit_size_ptr) |
| *bitfield_bit_size_ptr = 0; |
| if (is_bitfield_ptr) |
| *is_bitfield_ptr = false; |
| |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| |
| JavaObjectType::Field *field = obj->GetFieldAtIndex(idx); |
| if (!field) |
| return CompilerType(); |
| name = field->m_name.AsCString(); |
| if (bit_offset_ptr) |
| *bit_offset_ptr = field->m_offset * 8; |
| return field->m_type; |
| } |
| return CompilerType(); |
| } |
| |
| uint32_t JavaASTContext::GetNumChildren(lldb::opaque_compiler_type_t type, |
| bool omit_empty_base_classes) { |
| GetCompleteType(type); |
| |
| if (JavaReferenceType *ref = |
| llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type))) |
| return ref->GetPointeeType().GetNumChildren(omit_empty_base_classes); |
| |
| if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type))) |
| return GetNumFields(type) + GetNumDirectBaseClasses(type); |
| |
| return 0; |
| } |
| |
| uint32_t |
| JavaASTContext::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) { |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| return obj->GetNumInterfaces() + (obj->GetBaseClass() ? 1 : 0); |
| } |
| return 0; |
| } |
| |
| uint32_t |
| JavaASTContext::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) { |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| return obj->GetNumInterfaces(); |
| } |
| return 0; |
| } |
| |
| CompilerType JavaASTContext::GetDirectBaseClassAtIndex( |
| lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) { |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| |
| if (CompilerType base_class = obj->GetBaseClass()) { |
| if (idx == 0) |
| return base_class; |
| else |
| --idx; |
| } |
| return obj->GetInterfaceAtIndex(idx); |
| } |
| return CompilerType(); |
| } |
| |
| CompilerType JavaASTContext::GetVirtualBaseClassAtIndex( |
| lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) { |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| return obj->GetInterfaceAtIndex(idx); |
| } |
| return CompilerType(); |
| } |
| |
| void JavaASTContext::DumpValue( |
| lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, |
| lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, |
| size_t data_byte_size, uint32_t bitfield_bit_size, |
| uint32_t bitfield_bit_offset, bool show_types, bool show_summary, |
| bool verbose, uint32_t depth) { |
| assert(false && "Not implemented"); |
| } |
| |
| bool JavaASTContext::DumpTypeValue( |
| lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, |
| const DataExtractor &data, lldb::offset_t data_offset, |
| size_t data_byte_size, uint32_t bitfield_bit_size, |
| uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope) { |
| if (IsScalarType(type)) { |
| return DumpDataExtractor(data, s, data_offset, format, data_byte_size, |
| 1, // count |
| UINT32_MAX, LLDB_INVALID_ADDRESS, |
| bitfield_bit_size, bitfield_bit_offset, exe_scope); |
| } |
| return false; |
| } |
| |
| void JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) { |
| StreamFile s(stdout, false); |
| DumpTypeDescription(type, &s); |
| } |
| |
| void JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, |
| Stream *s) { |
| static_cast<JavaType *>(type)->Dump(s); |
| } |
| |
| void JavaASTContext::DumpSummary(lldb::opaque_compiler_type_t type, |
| ExecutionContext *exe_ctx, Stream *s, |
| const DataExtractor &data, |
| lldb::offset_t data_offset, |
| size_t data_byte_size) { |
| assert(false && "Not implemented"); |
| } |
| |
| int JavaASTContext::GetFunctionArgumentCount( |
| lldb::opaque_compiler_type_t type) { |
| return 0; |
| } |
| |
| CompilerType JavaASTContext::GetFunctionArgumentTypeAtIndex( |
| lldb::opaque_compiler_type_t type, size_t idx) { |
| return CompilerType(); |
| } |
| |
| CompilerType |
| JavaASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) { |
| return CompilerType(); |
| } |
| |
| size_t |
| JavaASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) { |
| return 0; |
| } |
| |
| TypeMemberFunctionImpl |
| JavaASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, |
| size_t idx) { |
| return TypeMemberFunctionImpl(); |
| } |
| |
| CompilerType JavaASTContext::GetChildCompilerTypeAtIndex( |
| lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, |
| bool transparent_pointers, bool omit_empty_base_classes, |
| bool ignore_array_bounds, std::string &child_name, |
| uint32_t &child_byte_size, int32_t &child_byte_offset, |
| uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, |
| bool &child_is_base_class, bool &child_is_deref_of_parent, |
| ValueObject *valobj, uint64_t &language_flags) { |
| child_name.clear(); |
| child_byte_size = 0; |
| child_byte_offset = 0; |
| child_bitfield_bit_size = 0; |
| child_bitfield_bit_offset = 0; |
| child_is_base_class = false; |
| child_is_deref_of_parent = false; |
| language_flags = 0; |
| |
| ExecutionContextScope *exec_ctx_scope = |
| exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr; |
| |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| |
| if (CompilerType base_class = obj->GetBaseClass()) { |
| if (idx == 0) { |
| JavaType *base_class_type = |
| static_cast<JavaType *>(base_class.GetOpaqueQualType()); |
| child_name = base_class_type->GetName().GetCString(); |
| child_byte_size = base_class.GetByteSize( |
| exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr); |
| child_byte_offset = obj->GetBaseClassOffset(); |
| child_is_base_class = true; |
| return base_class; |
| } |
| idx -= 1; |
| } |
| |
| JavaObjectType::Field *field = obj->GetFieldAtIndex(idx); |
| if (!field) |
| return CompilerType(); |
| |
| child_name = field->m_name.AsCString(); |
| child_byte_size = field->m_type.GetByteSize(exec_ctx_scope); |
| child_byte_offset = field->m_offset; |
| return field->m_type; |
| } else if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>( |
| static_cast<JavaType *>(type))) { |
| CompilerType pointee_type = ref->GetPointeeType(); |
| |
| if (transparent_pointers) |
| return pointee_type.GetChildCompilerTypeAtIndex( |
| exe_ctx, idx, transparent_pointers, omit_empty_base_classes, |
| ignore_array_bounds, child_name, child_byte_size, child_byte_offset, |
| child_bitfield_bit_size, child_bitfield_bit_offset, |
| child_is_base_class, child_is_deref_of_parent, valobj, |
| language_flags); |
| |
| if (idx != 0) |
| return CompilerType(); |
| |
| if (valobj && valobj->GetName()) |
| child_name = valobj->GetName().GetCString(); |
| child_is_deref_of_parent = true; |
| child_byte_offset = 0; |
| child_byte_size = pointee_type.GetByteSize(exec_ctx_scope); |
| return pointee_type; |
| } |
| return CompilerType(); |
| } |
| |
| uint32_t |
| JavaASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, |
| const char *name, |
| bool omit_empty_base_classes) { |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| |
| uint32_t index_offset = 0; |
| if (CompilerType base_class = obj->GetBaseClass()) { |
| if (base_class.GetTypeName() == ConstString(name)) |
| return 0; |
| index_offset = 1; |
| } |
| for (uint32_t i = 0; i < obj->GetNumFields(); ++i) { |
| if (obj->GetFieldAtIndex(i)->m_name == ConstString(name)) |
| return i + index_offset; |
| } |
| } else if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>( |
| static_cast<JavaType *>(type))) { |
| return GetIndexOfChildWithName(ref->GetPointeeType().GetOpaqueQualType(), |
| name, omit_empty_base_classes); |
| } |
| return UINT_MAX; |
| } |
| |
| size_t JavaASTContext::GetIndexOfChildMemberWithName( |
| lldb::opaque_compiler_type_t type, const char *name, |
| bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) { |
| child_indexes.clear(); |
| |
| if (JavaObjectType *obj = |
| llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { |
| GetCompleteType(type); |
| |
| uint32_t index_offset = 0; |
| if (CompilerType base_class = obj->GetBaseClass()) { |
| if (GetIndexOfChildMemberWithName(base_class.GetOpaqueQualType(), name, |
| omit_empty_base_classes, |
| child_indexes) != 0) { |
| child_indexes.insert(child_indexes.begin(), 0); |
| return child_indexes.size(); |
| } |
| index_offset = 1; |
| } |
| |
| for (uint32_t i = 0; i < obj->GetNumFields(); ++i) { |
| if (obj->GetFieldAtIndex(i)->m_name == ConstString(name)) { |
| child_indexes.push_back(i + index_offset); |
| return child_indexes.size(); |
| } |
| } |
| } else if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>( |
| static_cast<JavaType *>(type))) { |
| return GetIndexOfChildMemberWithName( |
| ref->GetPointeeType().GetOpaqueQualType(), name, |
| omit_empty_base_classes, child_indexes); |
| } |
| return 0; |
| } |
| |
| CompilerType |
| JavaASTContext::GetLValueReferenceType(lldb::opaque_compiler_type_t type) { |
| return CreateReferenceType(CompilerType(this, type)); |
| } |
| |
| ConstString JavaASTContext::DeclContextGetScopeQualifiedName( |
| lldb::opaque_compiler_type_t opaque_decl_ctx) { |
| return GetTypeName(opaque_decl_ctx); |
| } |
| |
| static void AddPrimitiveType(JavaASTContext::JavaTypeMap &type_map, |
| JavaPrimitiveType::TypeKind type_kind) { |
| JavaPrimitiveType *type = new JavaPrimitiveType(type_kind); |
| type_map.emplace(type->GetName(), |
| std::unique_ptr<JavaASTContext::JavaType>(type)); |
| } |
| |
| CompilerType JavaASTContext::CreateBaseType(const ConstString &name) { |
| if (m_base_type_map.empty()) { |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeByte); |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeShort); |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeInt); |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeLong); |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeFloat); |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeDouble); |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeBoolean); |
| AddPrimitiveType(m_base_type_map, JavaPrimitiveType::eTypeChar); |
| } |
| auto it = m_base_type_map.find(name); |
| if (it != m_base_type_map.end()) |
| return CompilerType(this, it->second.get()); |
| return CompilerType(); |
| } |
| |
| CompilerType JavaASTContext::CreateObjectType(const ConstString &name, |
| const ConstString &linkage_name, |
| uint32_t byte_size) { |
| auto it = m_object_type_map.find(name); |
| if (it == m_object_type_map.end()) { |
| std::unique_ptr<JavaType> object_type( |
| new JavaObjectType(name, linkage_name, byte_size)); |
| it = m_object_type_map.emplace(name, std::move(object_type)).first; |
| } |
| return CompilerType(this, it->second.get()); |
| } |
| |
| CompilerType JavaASTContext::CreateArrayType( |
| const ConstString &linkage_name, const CompilerType &element_type, |
| const DWARFExpression &length_expression, const lldb::addr_t data_offset) { |
| ConstString name = element_type.GetTypeName(); |
| auto it = m_array_type_map.find(name); |
| if (it == m_array_type_map.end()) { |
| std::unique_ptr<JavaType> array_type(new JavaArrayType( |
| linkage_name, element_type, length_expression, data_offset)); |
| it = m_array_type_map.emplace(name, std::move(array_type)).first; |
| } |
| return CompilerType(this, it->second.get()); |
| } |
| |
| CompilerType |
| JavaASTContext::CreateReferenceType(const CompilerType &pointee_type) { |
| ConstString name = pointee_type.GetTypeName(); |
| auto it = m_reference_type_map.find(name); |
| if (it == m_reference_type_map.end()) |
| it = m_reference_type_map |
| .emplace(name, std::unique_ptr<JavaType>( |
| new JavaReferenceType(pointee_type))) |
| .first; |
| return CompilerType(this, it->second.get()); |
| } |
| |
| void JavaASTContext::CompleteObjectType(const CompilerType &object_type) { |
| JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>( |
| static_cast<JavaType *>(object_type.GetOpaqueQualType())); |
| assert(obj && |
| "JavaASTContext::CompleteObjectType called with not a JavaObjectType"); |
| obj->SetCompleteType(true); |
| } |
| |
| void JavaASTContext::AddBaseClassToObject(const CompilerType &object_type, |
| const CompilerType &member_type, |
| uint32_t member_offset) { |
| JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>( |
| static_cast<JavaType *>(object_type.GetOpaqueQualType())); |
| assert(obj && |
| "JavaASTContext::AddMemberToObject called with not a JavaObjectType"); |
| obj->AddBaseClass(member_type, member_offset); |
| } |
| |
| void JavaASTContext::AddMemberToObject(const CompilerType &object_type, |
| const ConstString &name, |
| const CompilerType &member_type, |
| uint32_t member_offset) { |
| JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>( |
| static_cast<JavaType *>(object_type.GetOpaqueQualType())); |
| assert(obj && |
| "JavaASTContext::AddMemberToObject called with not a JavaObjectType"); |
| obj->AddField(name, member_type, member_offset); |
| } |
| |
| void JavaASTContext::SetDynamicTypeId(const CompilerType &type, |
| const DWARFExpression &type_id) { |
| JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>( |
| static_cast<JavaType *>(type.GetOpaqueQualType())); |
| assert(obj && |
| "JavaASTContext::SetDynamicTypeId called with not a JavaObjectType"); |
| obj->SetDynamicTypeId(type_id); |
| } |
| |
| uint64_t JavaASTContext::CalculateDynamicTypeId(ExecutionContext *exe_ctx, |
| const CompilerType &type, |
| ValueObject &in_value) { |
| if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>( |
| static_cast<JavaType *>(type.GetOpaqueQualType()))) |
| return obj->CalculateDynamicTypeId(exe_ctx, in_value); |
| if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>( |
| static_cast<JavaType *>(type.GetOpaqueQualType()))) |
| return arr->CalculateDynamicTypeId(exe_ctx, in_value); |
| return UINT64_MAX; |
| } |
| |
| uint32_t JavaASTContext::CalculateArraySize(const CompilerType &type, |
| ValueObject &in_value) { |
| if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>( |
| static_cast<JavaType *>(type.GetOpaqueQualType()))) |
| return arr->GetNumElements(&in_value); |
| return UINT32_MAX; |
| } |
| |
| uint64_t JavaASTContext::CalculateArrayElementOffset(const CompilerType &type, |
| size_t index) { |
| if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>( |
| static_cast<JavaType *>(type.GetOpaqueQualType()))) |
| return arr->GetElementOffset(index); |
| return UINT64_MAX; |
| } |
| |
| ConstString JavaASTContext::GetLinkageName(const CompilerType &type) { |
| if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>( |
| static_cast<JavaType *>(type.GetOpaqueQualType()))) |
| return obj->GetLinkageName(); |
| return ConstString(); |
| } |
