diff options
Diffstat (limited to 'source/Symbol/JavaASTContext.cpp')
| -rw-r--r-- | source/Symbol/JavaASTContext.cpp | 1561 |
1 files changed, 1561 insertions, 0 deletions
diff --git a/source/Symbol/JavaASTContext.cpp b/source/Symbol/JavaASTContext.cpp new file mode 100644 index 000000000000..45cda8d5112b --- /dev/null +++ b/source/Symbol/JavaASTContext.cpp @@ -0,0 +1,1561 @@ +//===-- 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 <sstream> + +#include "lldb/Core/ArchSpec.h" +#include "lldb/Core/DataExtractor.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Expression/DWARFExpression.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/Symbol/JavaASTContext.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Target/Target.h" + +#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(), 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; + } + +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; + + 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; + } + + 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; +} + +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; +} + +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 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) +{ + 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(); +} |