1562 lines
44 KiB
C++
1562 lines
44 KiB
C++
//===-- 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();
|
|
}
|