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); } } }