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;
}
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;
}
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;
}
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);
}
bool ObjCLanguageRuntime::GetTypeBitSize(const CompilerType &compiler_type,
uint64_t &size) {
void *opaque_ptr = compiler_type.GetOpaqueQualType();
size = m_type_size_cache.Lookup(opaque_ptr);
// an ObjC object will at least have an ISA, so 0 is definitely not OK
if (size > 0)
return true;
ClassDescriptorSP class_descriptor_sp =
GetClassDescriptorFromClassName(compiler_type.GetTypeName());
if (!class_descriptor_sp)
return false;
int32_t max_offset = INT32_MIN;
uint64_t sizeof_max = 0;
bool found = false;
for (size_t idx = 0; idx < class_descriptor_sp->GetNumIVars(); idx++) {
const auto &ivar = class_descriptor_sp->GetIVarAtIndex(idx);
int32_t cur_offset = ivar.m_offset;
if (cur_offset > max_offset) {
max_offset = cur_offset;
sizeof_max = ivar.m_size;
found = true;
}
}
size = 8 * (max_offset + sizeof_max);
if (found)
m_type_size_cache.Insert(opaque_ptr, size);
return found;
}
QualType ClangUtil::GetQualType(const CompilerType &ct) {
// Make sure we have a clang type before making a clang::QualType
if (!IsClangType(ct))
return QualType();
return QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
}
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);
}
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);
}
bool ClangUtil::IsClangType(const CompilerType &ct) {
if (llvm::dyn_cast_or_null<ClangASTContext>(ct.GetTypeSystem()) == nullptr)
return false;
if (!ct.GetOpaqueQualType())
return false;
return true;
}
bool ClangASTImporter::CompleteType(const CompilerType &compiler_type) {
if (!CanImport(compiler_type))
return false;
if (Import(compiler_type)) {
ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
return true;
}
ClangASTContext::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
false);
return false;
}
CompilerType ClangASTImporter::CopyType(ClangASTContext &dst_ast,
const CompilerType &src_type) {
clang::ASTContext *dst_clang_ast = dst_ast.getASTContext();
if (dst_clang_ast) {
ClangASTContext *src_ast =
llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
if (src_ast) {
clang::ASTContext *src_clang_ast = src_ast->getASTContext();
if (src_clang_ast) {
lldb::opaque_compiler_type_t dst_clang_type = CopyType(
dst_clang_ast, src_clang_ast, src_type.GetOpaqueQualType());
if (dst_clang_type)
return CompilerType(&dst_ast, dst_clang_type);
}
}
}
return CompilerType();
}
ConstString JavaASTContext::GetLinkageName(const CompilerType &type) {
if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(
static_cast<JavaType *>(type.GetOpaqueQualType())))
return obj->GetLinkageName();
return ConstString();
}
void FormatManager::GetPossibleMatches(
ValueObject &valobj, CompilerType compiler_type, uint32_t reason,
lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
bool did_strip_ptr, bool did_strip_ref, bool did_strip_typedef,
bool root_level) {
compiler_type = compiler_type.GetTypeForFormatters();
ConstString type_name(compiler_type.GetConstTypeName());
if (valobj.GetBitfieldBitSize() > 0) {
StreamString sstring;
sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
ConstString bitfieldname(sstring.GetString());
entries.push_back(
{bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef});
reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
}
if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
entries.push_back(
{type_name, reason, did_strip_ptr, did_strip_ref, did_strip_typedef});
ConstString display_type_name(compiler_type.GetDisplayTypeName());
if (display_type_name != type_name)
entries.push_back({display_type_name, reason, did_strip_ptr,
did_strip_ref, did_strip_typedef});
}
for (bool is_rvalue_ref = true, j = true;
j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
CompilerType non_ref_type = compiler_type.GetNonReferenceType();
GetPossibleMatches(
valobj, non_ref_type,
reason |
lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
use_dynamic, entries, did_strip_ptr, true, did_strip_typedef);
if (non_ref_type.IsTypedefType()) {
CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
deffed_referenced_type =
is_rvalue_ref ? deffed_referenced_type.GetRValueReferenceType()
: deffed_referenced_type.GetLValueReferenceType();
GetPossibleMatches(
valobj, deffed_referenced_type,
reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
use_dynamic, entries, did_strip_ptr, did_strip_ref,
true); // this is not exactly the usual meaning of stripping typedefs
}
}
if (compiler_type.IsPointerType()) {
CompilerType non_ptr_type = compiler_type.GetPointeeType();
GetPossibleMatches(
valobj, non_ptr_type,
reason |
lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
use_dynamic, entries, true, did_strip_ref, did_strip_typedef);
if (non_ptr_type.IsTypedefType()) {
CompilerType deffed_pointed_type =
non_ptr_type.GetTypedefedType().GetPointerType();
GetPossibleMatches(
valobj, deffed_pointed_type,
reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
use_dynamic, entries, did_strip_ptr, did_strip_ref,
true); // this is not exactly the usual meaning of stripping typedefs
}
}
for (lldb::LanguageType language_type : GetCandidateLanguages(valobj)) {
if (Language *language = Language::FindPlugin(language_type)) {
for (ConstString candidate :
language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
entries.push_back(
{candidate,
reason | lldb_private::eFormatterChoiceCriterionLanguagePlugin,
did_strip_ptr, did_strip_ref, did_strip_typedef});
}
}
}
// try to strip typedef chains
if (compiler_type.IsTypedefType()) {
CompilerType deffed_type = compiler_type.GetTypedefedType();
GetPossibleMatches(
valobj, deffed_type,
reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
use_dynamic, entries, did_strip_ptr, did_strip_ref, true);
}
if (root_level) {
do {
if (!compiler_type.IsValid())
break;
CompilerType unqual_compiler_ast_type =
compiler_type.GetFullyUnqualifiedType();
if (!unqual_compiler_ast_type.IsValid())
break;
if (unqual_compiler_ast_type.GetOpaqueQualType() !=
compiler_type.GetOpaqueQualType())
GetPossibleMatches(valobj, unqual_compiler_ast_type, reason,
use_dynamic, entries, did_strip_ptr, did_strip_ref,
did_strip_typedef);
} while (false);
// if all else fails, go to static type
if (valobj.IsDynamic()) {
lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
if (static_value_sp)
GetPossibleMatches(
*static_value_sp.get(), static_value_sp->GetCompilerType(),
reason | lldb_private::eFormatterChoiceCriterionWentToStaticValue,
use_dynamic, entries, did_strip_ptr, did_strip_ref,
did_strip_typedef, true);
}
}
}
