CompilerType ClangUtil::RemoveFastQualifiers(const CompilerType &ct) { if (!IsClangType(ct)) return ct; QualType qual_type(GetQualType(ct)); qual_type.removeLocalFastQualifiers(); return CompilerType(ct.GetTypeSystem(), qual_type.getAsOpaquePtr()); }
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 lldb_private::formatters::swift::SwiftOptionSetSummaryProvider:: WouldEvenConsiderFormatting(CompilerType clang_type) { SwiftASTContext *swift_ast_ctx = llvm::dyn_cast_or_null<SwiftASTContext>(clang_type.GetTypeSystem()); if (!swift_ast_ctx) return false; return clang_type.IsValid() && swift_ast_ctx->IsTrivialOptionSetType(clang_type) && swift_ast_ctx->IsImportedType(clang_type, nullptr); }
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(); }
bool ClangASTImporter::Import(const CompilerType &type) { if (!ClangUtil::IsClangType(type)) return false; // TODO: remove external completion BOOL // CompleteAndFetchChildren should get the Decl out and check for the clang::QualType qual_type( ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type))); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: { const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { if (ResolveDeclOrigin(cxx_record_decl, NULL, NULL)) return CompleteAndFetchChildren(qual_type); } } break; case clang::Type::Enum: { clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl(); if (enum_decl) { if (ResolveDeclOrigin(enum_decl, NULL, NULL)) return CompleteAndFetchChildren(qual_type); } } break; case clang::Type::ObjCObject: case clang::Type::ObjCInterface: { const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); if (objc_class_type) { clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); // We currently can't complete objective C types through the newly added // ASTContext because it only supports TagDecl objects right now... if (class_interface_decl) { if (ResolveDeclOrigin(class_interface_decl, NULL, NULL)) return CompleteAndFetchChildren(qual_type); } } } break; case clang::Type::Typedef: return Import(CompilerType(type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type) ->getDecl() ->getUnderlyingType() .getAsOpaquePtr())); case clang::Type::Auto: return Import(CompilerType(type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type) ->getDeducedType() .getAsOpaquePtr())); case clang::Type::Elaborated: return Import(CompilerType(type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type) ->getNamedType() .getAsOpaquePtr())); case clang::Type::Paren: return Import(CompilerType( type.GetTypeSystem(), llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); default: break; } return false; }
size_t DWARFASTParserGo::ParseChildMembers(const SymbolContext &sc, const DWARFDIE &parent_die, CompilerType &class_compiler_type) { size_t count = 0; uint32_t member_idx = 0; ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); GoASTContext *ast = llvm::dyn_cast_or_null<GoASTContext>(class_compiler_type.GetTypeSystem()); if (ast == nullptr) return 0; for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling()) { dw_tag_t tag = die.Tag(); switch (tag) { case DW_TAG_member: { DWARFAttributes attributes; const size_t num_attributes = die.GetAttributes(attributes); if (num_attributes > 0) { Declaration decl; const char *name = NULL; lldb::user_id_t encoding_uid = LLDB_INVALID_UID; uint32_t member_byte_offset = UINT32_MAX; uint32_t i; for (i = 0; i < num_attributes; ++i) { const dw_attr_t attr = attributes.AttributeAtIndex(i); DWARFFormValue form_value; if (attributes.ExtractFormValueAtIndex(i, form_value)) { switch (attr) { case DW_AT_name: name = form_value.AsCString(); break; case DW_AT_type: encoding_uid = form_value.Reference(); break; case DW_AT_data_member_location: if (form_value.BlockData()) { Value initialValue(0); Value memberOffset(0); const DWARFDataExtractor &debug_info_data = die.GetDWARF()->get_debug_info_data(); uint32_t block_length = form_value.Unsigned(); uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart(); if (DWARFExpression::Evaluate(NULL, // ExecutionContext * NULL, // ClangExpressionVariableList * NULL, // ClangExpressionDeclMap * NULL, // RegisterContext * module_sp, debug_info_data, die.GetCU(), block_offset, block_length, eRegisterKindDWARF, &initialValue, NULL, memberOffset, NULL)) { member_byte_offset = memberOffset.ResolveValue(NULL).UInt(); } } else { // With DWARF 3 and later, if the value is an integer constant, // this form value is the offset in bytes from the beginning // of the containing entity. member_byte_offset = form_value.Unsigned(); } break; default: break; } } } Type *member_type = die.ResolveTypeUID(encoding_uid); if (member_type) { CompilerType member_go_type = member_type->GetFullCompilerType(); ConstString name_const_str(name); m_ast.AddFieldToStruct(class_compiler_type, name_const_str, member_go_type, member_byte_offset); } } ++member_idx; } break; default: break; } } return count; }
SwiftHashedContainerNativeBufferHandler::SwiftHashedContainerNativeBufferHandler (lldb::ValueObjectSP nativeStorage_sp, CompilerType key_type, CompilerType value_type) : m_nativeStorage(nativeStorage_sp.get()), m_process(nullptr), m_ptr_size(0), m_count(0), m_capacity(0), m_bitmask_ptr(LLDB_INVALID_ADDRESS), m_keys_ptr(LLDB_INVALID_ADDRESS), m_values_ptr(LLDB_INVALID_ADDRESS), m_element_type(), m_key_stride(key_type.GetByteStride()), m_value_stride(0), m_bitmask_cache() { static ConstString g_initializedEntries("initializedEntries"); static ConstString g_values("values"); static ConstString g__rawValue("_rawValue"); static ConstString g_keys("keys"); static ConstString g_buffer("buffer"); static ConstString g_key("key"); static ConstString g_value("value"); if (!m_nativeStorage) return; if (!key_type) return; if (value_type) { m_value_stride = value_type.GetByteStride(); if (SwiftASTContext *swift_ast = llvm::dyn_cast_or_null<SwiftASTContext>(key_type.GetTypeSystem())) { std::vector<SwiftASTContext::TupleElement> tuple_elements{ {g_key,key_type}, {g_value,value_type} }; m_element_type = swift_ast->CreateTupleType(tuple_elements); } } else m_element_type = key_type; if (!m_element_type) return; auto buffer_ptr = m_nativeStorage->GetChildAtNamePath( {g_buffer} )->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); if (!buffer_ptr) return; m_process = m_nativeStorage->GetProcessSP().get(); if (!m_process) return; m_ptr_size = m_process->GetAddressByteSize(); Error error; m_capacity = m_process->ReadPointerFromMemory(buffer_ptr + 2 * m_ptr_size, error); if (error.Fail()) return; m_count = m_process->ReadPointerFromMemory(buffer_ptr + 3 * m_ptr_size, error); if (error.Fail()) return; m_nativeStorage = nativeStorage_sp.get(); m_bitmask_ptr = m_nativeStorage->GetChildAtNamePath( {g_initializedEntries,g_values,g__rawValue} )->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); if (ValueObjectSP value_child_sp = m_nativeStorage->GetChildAtNamePath( {g_values,g__rawValue} )) { // it is fine not to pass a value_type, but if the value child exists, then you have to pass one if (!value_type) return; m_values_ptr = value_child_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); } m_keys_ptr = m_nativeStorage->GetChildAtNamePath( {g_keys,g__rawValue} )->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); }