diff options
Diffstat (limited to 'source/Symbol/JavaASTContext.cpp')
| -rw-r--r-- | source/Symbol/JavaASTContext.cpp | 2290 |
1 files changed, 1031 insertions, 1259 deletions
diff --git a/source/Symbol/JavaASTContext.cpp b/source/Symbol/JavaASTContext.cpp index 45cda8d5112b..79073a653676 100644 --- a/source/Symbol/JavaASTContext.cpp +++ b/source/Symbol/JavaASTContext.cpp @@ -28,1534 +28,1306 @@ using namespace lldb; using namespace lldb_private; -namespace lldb_private -{ +namespace lldb_private { -class JavaASTContext::JavaType -{ +class JavaASTContext::JavaType { public: - enum LLVMCastKind - { - eKindPrimitive, - eKindObject, - eKindReference, - eKindArray, - kNumKinds - }; + enum LLVMCastKind { + eKindPrimitive, + eKindObject, + eKindReference, + eKindArray, + kNumKinds + }; - JavaType(LLVMCastKind kind) : m_kind(kind) {} + JavaType(LLVMCastKind kind) : m_kind(kind) {} - virtual ~JavaType() = default; + virtual ~JavaType() = default; - virtual ConstString - GetName() = 0; + virtual ConstString GetName() = 0; - virtual void - Dump(Stream *s) = 0; + virtual void Dump(Stream *s) = 0; - virtual bool - IsCompleteType() = 0; + virtual bool IsCompleteType() = 0; - LLVMCastKind - getKind() const - { - return m_kind; - } + LLVMCastKind getKind() const { return m_kind; } private: - LLVMCastKind m_kind; + LLVMCastKind m_kind; }; } // end of namespace lldb_private -namespace -{ +namespace { -class JavaPrimitiveType : public JavaASTContext::JavaType -{ +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(); + 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; - } + TypeKind GetTypeKind() { return m_type_kind; } - void - Dump(Stream *s) override - { - s->Printf("%s\n", GetName().GetCString()); - } + void Dump(Stream *s) override { s->Printf("%s\n", GetName().GetCString()); } - bool - IsCompleteType() override - { - return true; - } + bool IsCompleteType() override { return true; } - static bool - classof(const JavaType *jt) - { - return jt->getKind() == JavaType::eKindPrimitive; - } + static bool classof(const JavaType *jt) { + return jt->getKind() == JavaType::eKindPrimitive; + } private: - const TypeKind m_type_kind; + const TypeKind m_type_kind; }; -class JavaDynamicType : public JavaASTContext::JavaType -{ +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) - { - } + 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; - } + ConstString GetLinkageName() const { return m_linkage_name; } - void - SetDynamicTypeId(const DWARFExpression &type_id) - { - m_dynamic_type_id = type_id; - } + 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(), nullptr, nullptr, 0, &obj_load_address, - nullptr, result, nullptr)) - { - Error 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; - } + uint64_t CalculateDynamicTypeId(ExecutionContext *exe_ctx, + ValueObject &value_obj) { + if (!m_dynamic_type_id.IsValid()) + return UINT64_MAX; -public: - ConstString m_linkage_name; - DWARFExpression m_dynamic_type_id; -}; + Value obj_load_address = value_obj.GetValue(); + obj_load_address.ResolveValue(exe_ctx); + obj_load_address.SetValueType(Value::eValueTypeLoadAddress); -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) - { - } + Value result; + if (m_dynamic_type_id.Evaluate(exe_ctx->GetBestExecutionContextScope(), + nullptr, nullptr, 0, &obj_load_address, + nullptr, result, nullptr)) { + Error error; - ConstString - GetName() override - { - return m_name; + 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); } - uint32_t - GetByteSize() const - { - return m_byte_size; - } + return UINT64_MAX; + } - uint32_t - GetNumFields() - { - return m_fields.size(); - } +public: + ConstString m_linkage_name; + DWARFExpression m_dynamic_type_id; +}; - 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(); - } +class JavaObjectType : public JavaDynamicType { +public: + struct Field { + ConstString m_name; + CompilerType m_type; + uint32_t m_offset; + }; - Field * - GetFieldAtIndex(size_t idx) - { - if (idx < m_fields.size()) - return &m_fields[idx]; - return nullptr; - } + 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) {} - CompilerType - GetBaseClass() - { - return m_base_class; - } + ConstString GetName() override { return m_name; } - uint32_t - GetBaseClassOffset() - { - return m_base_class_offset; - } + uint32_t GetByteSize() const { return m_byte_size; } - uint32_t - GetNumInterfaces() - { - return m_interfaces.size(); - } + uint32_t GetNumFields() { return m_fields.size(); } - CompilerType - GetInterfaceAtIndex(uint32_t idx) - { - if (m_interfaces.size() < idx) - return m_interfaces[idx]; - return CompilerType(); - } + 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()); - bool - IsCompleteType() override - { - return m_is_complete; - } + s->IndentMore(); + for (const Field &f : m_fields) + s->Printf("%s %s\n", f.m_type.GetTypeName().GetCString(), + f.m_name.GetCString()); + s->IndentLess(); + } - 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; - } - } - } + Field *GetFieldAtIndex(size_t idx) { + if (idx < m_fields.size()) + return &m_fields[idx]; + return nullptr; + } - 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; - } + CompilerType GetBaseClass() { return m_base_class; } - void - AddField(const ConstString &name, const CompilerType &type, uint32_t offset) - { - m_fields.push_back({name, type, offset}); - } + uint32_t GetBaseClassOffset() { return m_base_class_offset; } - static bool - classof(const JavaType *jt) - { - return jt->getKind() == JavaType::eKindObject; - } + 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; + 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 -{ +class JavaReferenceType : public JavaASTContext::JavaType { public: - JavaReferenceType(CompilerType pointee_type) : JavaType(JavaType::eKindReference), m_pointee_type(pointee_type) {} + JavaReferenceType(CompilerType pointee_type) + : JavaType(JavaType::eKindReference), m_pointee_type(pointee_type) {} - static bool - classof(const JavaType *jt) - { - return jt->getKind() == JavaType::eKindReference; - } + static bool classof(const JavaType *jt) { + return jt->getKind() == JavaType::eKindReference; + } - CompilerType - GetPointeeType() - { - return m_pointee_type; - } + 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()) + "&"); - } + 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); - } + void Dump(Stream *s) override { + static_cast<JavaType *>(m_pointee_type.GetOpaqueQualType())->Dump(s); + } - bool - IsCompleteType() override - { - return m_pointee_type.IsCompleteType(); - } + bool IsCompleteType() override { return m_pointee_type.IsCompleteType(); } private: - CompilerType m_pointee_type; + CompilerType m_pointee_type; }; -class JavaArrayType : public JavaDynamicType -{ +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(); - } + 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; + + Error 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, nullptr, nullptr, 0, + nullptr, &obj_load_address, result, + nullptr)) + return result.GetScalar().UInt(); - uint32_t - GetNumElements(ValueObject *value_obj) - { - if (!m_length_expression.IsValid()) - return UINT32_MAX; - - Error 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, nullptr, nullptr, 0, nullptr, &obj_load_address, result, nullptr)) - return result.GetScalar().UInt(); - - return UINT32_MAX; - } + return UINT32_MAX; + } - uint64_t - GetElementOffset(size_t idx) - { - return m_data_offset + idx * m_element_type.GetByteSize(nullptr); - } + 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; + 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::GetPluginNameStatic() { + return ConstString("java"); } -ConstString -JavaASTContext::GetPluginName() -{ - return JavaASTContext::GetPluginNameStatic(); +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(); +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({}); +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()); + 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::Initialize() { + PluginManager::RegisterPlugin(GetPluginNameStatic(), "AST context plug-in", + CreateInstance, EnumerateSupportedLanguages); } -void -JavaASTContext::Terminate() -{ - PluginManager::UnregisterPlugin(CreateInstance); +void JavaASTContext::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); } JavaASTContext::JavaASTContext(const ArchSpec &arch) - : TypeSystem(eKindJava), m_pointer_byte_size(arch.GetAddressByteSize()) -{ + : 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(); } -JavaASTContext::~JavaASTContext() -{ +ConstString JavaASTContext::DeclGetName(void *opaque_decl) { + return ConstString(); } -uint32_t -JavaASTContext::GetPointerByteSize() -{ - return m_pointer_byte_size; +std::vector<CompilerDecl> JavaASTContext::DeclContextFindDeclByName( + void *opaque_decl_ctx, ConstString name, const bool ignore_imported_decls) { + return std::vector<CompilerDecl>(); } -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(); +bool JavaASTContext::DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) { + return false; } -ConstString -JavaASTContext::DeclGetName(void *opaque_decl) -{ - return ConstString(); +ConstString JavaASTContext::DeclContextGetName(void *opaque_decl_ctx) { + return ConstString(); } -std::vector<CompilerDecl> -JavaASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name, const bool ignore_imported_decls) -{ - return std::vector<CompilerDecl>(); +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::DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) -{ - 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; } -ConstString -JavaASTContext::DeclContextGetName(void *opaque_decl_ctx) -{ - return ConstString(); +bool JavaASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) { + return llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)); } -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::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::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; - } +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; + 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; +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; +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(); +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; - } - } +bool JavaASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) { + return false; +} - is_signed = false; - return false; +bool JavaASTContext::IsBlockPointerType( + lldb::opaque_compiler_type_t type, + CompilerType *function_pointer_type_ptr) { + 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::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::IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type) -{ - if (pointee_type) - pointee_type->Clear(); - 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::IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool *is_rvalue) -{ - if (is_rvalue) - *is_rvalue = false; +bool JavaASTContext::IsPointerType(lldb::opaque_compiler_type_t type, + CompilerType *pointee_type) { + if (pointee_type) + pointee_type->Clear(); + return false; +} - if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type))) - { - if (pointee_type) - *pointee_type = ref->GetPointeeType(); - return true; - } +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->Clear(); - return false; + *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::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::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::SupportsLanguage(lldb::LanguageType language) { + return language == lldb::eLanguageTypeJava; } -bool -JavaASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) -{ - return true; +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::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::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::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::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)); +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; +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::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::IsConst(lldb::opaque_compiler_type_t type) { + return false; } -bool -JavaASTContext::IsBeingDefined(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::IsDefined(lldb::opaque_compiler_type_t type) { + return type != nullptr; } -bool -JavaASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) -{ - if (IsCompleteType(type)) - return true; +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 (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 (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; + 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; + 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(); +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; - } - } +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"); +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; +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(); +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::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::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); +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); +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); +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(); +JavaASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) { + return CompilerType(); } -CompilerType -JavaASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) -{ - return CompilerType(); +CompilerType JavaASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) { + return CompilerType(); } CompilerType -JavaASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size) -{ - return CompilerType(); +JavaASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, + size_t bit_size) { + return CompilerType(); } -size_t -JavaASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) -{ - return 0; +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; +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; +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; +JavaASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) { + return 0; } CompilerType -JavaASTContext::GetTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, lldb::TemplateArgumentKind &kind) -{ - return CompilerType(); +JavaASTContext::GetTemplateArgument(lldb::opaque_compiler_type_t type, + size_t idx, + lldb::TemplateArgumentKind &kind) { + return CompilerType(); } -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; -} +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); -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) -{ + JavaObjectType::Field *field = obj->GetFieldAtIndex(idx); + if (!field) + return CompilerType(); + name = field->m_name.AsCString(); 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(); + *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); +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 (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); + if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type))) + return GetNumFields(type) + GetNumDirectBaseClasses(type); - return 0; + 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; +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; +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); +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 CompilerType(); + 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(); +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 data.Dump(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::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"); } -void -JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) -{ - StreamFile s(stdout, false); - DumpTypeDescription(type, &s); +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 data.Dump(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, Stream *s) -{ - static_cast<JavaType *>(type)->Dump(s); +void JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) { + StreamFile s(stdout, false); + DumpTypeDescription(type, &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"); +void JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, + Stream *s) { + static_cast<JavaType *>(type)->Dump(s); } -int -JavaASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) -{ - return 0; +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"); } -CompilerType -JavaASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx) -{ - return CompilerType(); +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(); +JavaASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) { + return CompilerType(); } size_t -JavaASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) -{ - return 0; +JavaASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) { + return 0; } TypeMemberFunctionImpl -JavaASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) -{ - return 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); -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; + 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_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(); + 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; -} +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); -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(); - } - } + uint32_t index_offset = 0; + if (CompilerType base_class = obj->GetBaseClass()) { + if (base_class.GetTypeName() == ConstString(name)) + return 0; + index_offset = 1; } - else if (JavaReferenceType *ref = llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type))) - { - return GetIndexOfChildMemberWithName(ref->GetPointeeType().GetOpaqueQualType(), name, omit_empty_base_classes, - child_indexes); + for (uint32_t i = 0; i < obj->GetNumFields(); ++i) { + if (obj->GetFieldAtIndex(i)->m_name == ConstString(name)) + return i + index_offset; } - return 0; -} - -CompilerType -JavaASTContext::GetLValueReferenceType(lldb::opaque_compiler_type_t type) -{ - return CreateReferenceType(CompilerType(this, type)); + } 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; } -ConstString -JavaASTContext::DeclContextGetScopeQualifiedName(lldb::opaque_compiler_type_t opaque_decl_ctx) -{ - return GetTypeName(opaque_decl_ctx); -} +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(); -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)); -} + if (JavaObjectType *obj = + llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) { + GetCompleteType(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); + 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; } - 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; + 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(); + } } - return CompilerType(this, it->second.get()); + } 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::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; - } +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(); +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(); } |