1 //===-- BlockPointer.cpp --------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "BlockPointer.h" 10 11 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h" 12 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" 13 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 14 #include "lldb/Core/ValueObject.h" 15 #include "lldb/DataFormatters/FormattersHelpers.h" 16 #include "lldb/Symbol/CompilerType.h" 17 #include "lldb/Symbol/TypeSystem.h" 18 #include "lldb/Target/Target.h" 19 #include "lldb/Utility/LLDBAssert.h" 20 #include "lldb/Utility/Log.h" 21 22 using namespace lldb; 23 using namespace lldb_private; 24 using namespace lldb_private::formatters; 25 26 namespace lldb_private { 27 namespace formatters { 28 29 class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd { 30 public: 31 BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 32 : SyntheticChildrenFrontEnd(*valobj_sp), m_block_struct_type() { 33 CompilerType block_pointer_type(m_backend.GetCompilerType()); 34 CompilerType function_pointer_type; 35 block_pointer_type.IsBlockPointerType(&function_pointer_type); 36 37 TargetSP target_sp(m_backend.GetTargetSP()); 38 39 if (!target_sp) { 40 return; 41 } 42 43 auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage( 44 lldb::eLanguageTypeC_plus_plus); 45 if (auto err = type_system_or_err.takeError()) { 46 LLDB_LOG_ERROR( 47 lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS), 48 std::move(err), "Failed to get scratch TypeSystemClang"); 49 return; 50 } 51 52 TypeSystemClang *clang_ast_context = 53 llvm::dyn_cast<TypeSystemClang>(&type_system_or_err.get()); 54 55 if (!clang_ast_context) { 56 return; 57 } 58 59 std::shared_ptr<ClangASTImporter> clang_ast_importer; 60 auto *state = target_sp->GetPersistentExpressionStateForLanguage( 61 lldb::eLanguageTypeC_plus_plus); 62 if (state) { 63 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state); 64 clang_ast_importer = persistent_vars->GetClangASTImporter(); 65 } 66 67 if (!clang_ast_importer) { 68 return; 69 } 70 71 const char *const isa_name("__isa"); 72 const CompilerType isa_type = 73 clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass); 74 const char *const flags_name("__flags"); 75 const CompilerType flags_type = 76 clang_ast_context->GetBasicType(lldb::eBasicTypeInt); 77 const char *const reserved_name("__reserved"); 78 const CompilerType reserved_type = 79 clang_ast_context->GetBasicType(lldb::eBasicTypeInt); 80 const char *const FuncPtr_name("__FuncPtr"); 81 const CompilerType FuncPtr_type = 82 clang_ast_importer->CopyType(*clang_ast_context, function_pointer_type); 83 84 m_block_struct_type = clang_ast_context->CreateStructForIdentifier( 85 ConstString(), {{isa_name, isa_type}, 86 {flags_name, flags_type}, 87 {reserved_name, reserved_type}, 88 {FuncPtr_name, FuncPtr_type}}); 89 } 90 91 ~BlockPointerSyntheticFrontEnd() override = default; 92 93 size_t CalculateNumChildren() override { 94 const bool omit_empty_base_classes = false; 95 return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr); 96 } 97 98 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { 99 if (!m_block_struct_type.IsValid()) { 100 return lldb::ValueObjectSP(); 101 } 102 103 if (idx >= CalculateNumChildren()) { 104 return lldb::ValueObjectSP(); 105 } 106 107 const bool thread_and_frame_only_if_stopped = true; 108 ExecutionContext exe_ctx = m_backend.GetExecutionContextRef().Lock( 109 thread_and_frame_only_if_stopped); 110 const bool transparent_pointers = false; 111 const bool omit_empty_base_classes = false; 112 const bool ignore_array_bounds = false; 113 ValueObject *value_object = nullptr; 114 115 std::string child_name; 116 uint32_t child_byte_size = 0; 117 int32_t child_byte_offset = 0; 118 uint32_t child_bitfield_bit_size = 0; 119 uint32_t child_bitfield_bit_offset = 0; 120 bool child_is_base_class = false; 121 bool child_is_deref_of_parent = false; 122 uint64_t language_flags = 0; 123 124 const CompilerType child_type = 125 m_block_struct_type.GetChildCompilerTypeAtIndex( 126 &exe_ctx, idx, transparent_pointers, omit_empty_base_classes, 127 ignore_array_bounds, child_name, child_byte_size, child_byte_offset, 128 child_bitfield_bit_size, child_bitfield_bit_offset, 129 child_is_base_class, child_is_deref_of_parent, value_object, 130 language_flags); 131 132 ValueObjectSP struct_pointer_sp = 133 m_backend.Cast(m_block_struct_type.GetPointerType()); 134 135 if (!struct_pointer_sp) { 136 return lldb::ValueObjectSP(); 137 } 138 139 Status err; 140 ValueObjectSP struct_sp = struct_pointer_sp->Dereference(err); 141 142 if (!struct_sp || !err.Success()) { 143 return lldb::ValueObjectSP(); 144 } 145 146 ValueObjectSP child_sp(struct_sp->GetSyntheticChildAtOffset( 147 child_byte_offset, child_type, true, 148 ConstString(child_name.c_str(), child_name.size()))); 149 150 return child_sp; 151 } 152 153 // return true if this object is now safe to use forever without ever 154 // updating again; the typical (and tested) answer here is 'false' 155 bool Update() override { return false; } 156 157 // maybe return false if the block pointer is, say, null 158 bool MightHaveChildren() override { return true; } 159 160 size_t GetIndexOfChildWithName(ConstString name) override { 161 if (!m_block_struct_type.IsValid()) 162 return UINT32_MAX; 163 164 const bool omit_empty_base_classes = false; 165 return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(), 166 omit_empty_base_classes); 167 } 168 169 private: 170 CompilerType m_block_struct_type; 171 }; 172 173 } // namespace formatters 174 } // namespace lldb_private 175 176 bool lldb_private::formatters::BlockPointerSummaryProvider( 177 ValueObject &valobj, Stream &s, const TypeSummaryOptions &) { 178 lldb_private::SyntheticChildrenFrontEnd *synthetic_children = 179 BlockPointerSyntheticFrontEndCreator(nullptr, valobj.GetSP()); 180 if (!synthetic_children) { 181 return false; 182 } 183 184 synthetic_children->Update(); 185 186 static const ConstString s_FuncPtr_name("__FuncPtr"); 187 188 lldb::ValueObjectSP child_sp = synthetic_children->GetChildAtIndex( 189 synthetic_children->GetIndexOfChildWithName(s_FuncPtr_name)); 190 191 if (!child_sp) { 192 return false; 193 } 194 195 lldb::ValueObjectSP qualified_child_representation_sp = 196 child_sp->GetQualifiedRepresentationIfAvailable( 197 lldb::eDynamicDontRunTarget, true); 198 199 const char *child_value = 200 qualified_child_representation_sp->GetValueAsCString(); 201 202 s.Printf("%s", child_value); 203 204 return true; 205 } 206 207 lldb_private::SyntheticChildrenFrontEnd * 208 lldb_private::formatters::BlockPointerSyntheticFrontEndCreator( 209 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 210 if (!valobj_sp) 211 return nullptr; 212 return new BlockPointerSyntheticFrontEnd(valobj_sp); 213 } 214