llvm-project/lldb/source/Symbol/JavaASTContext.cpp

1334 lines
43 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();
}