File: | build/source/lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp |
Warning: | line 184, column 3 Potential leak of memory pointed to by 'synthetic_children' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
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/LLDBLog.h" | |||
21 | #include "lldb/Utility/Log.h" | |||
22 | ||||
23 | using namespace lldb; | |||
24 | using namespace lldb_private; | |||
25 | using namespace lldb_private::formatters; | |||
26 | ||||
27 | namespace lldb_private { | |||
28 | namespace formatters { | |||
29 | ||||
30 | class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd { | |||
31 | public: | |||
32 | BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) | |||
33 | : SyntheticChildrenFrontEnd(*valobj_sp), m_block_struct_type() { | |||
34 | CompilerType block_pointer_type(m_backend.GetCompilerType()); | |||
35 | CompilerType function_pointer_type; | |||
36 | block_pointer_type.IsBlockPointerType(&function_pointer_type); | |||
37 | ||||
38 | TargetSP target_sp(m_backend.GetTargetSP()); | |||
39 | ||||
40 | if (!target_sp) { | |||
41 | return; | |||
42 | } | |||
43 | ||||
44 | auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage( | |||
45 | lldb::eLanguageTypeC_plus_plus); | |||
46 | if (auto err = type_system_or_err.takeError()) { | |||
47 | LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters), std::move(err),do { ::lldb_private::Log *log_private = (GetLog(LLDBLog::DataFormatters )); ::llvm::Error error_private = (std::move(err)); if (log_private && error_private) { log_private->FormatError(::std ::move(error_private), "lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp" , __func__, "Failed to get scratch TypeSystemClang"); } else :: llvm::consumeError(::std::move(error_private)); } while (0) | |||
48 | "Failed to get scratch TypeSystemClang")do { ::lldb_private::Log *log_private = (GetLog(LLDBLog::DataFormatters )); ::llvm::Error error_private = (std::move(err)); if (log_private && error_private) { log_private->FormatError(::std ::move(error_private), "lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp" , __func__, "Failed to get scratch TypeSystemClang"); } else :: llvm::consumeError(::std::move(error_private)); } while (0); | |||
49 | return; | |||
50 | } | |||
51 | ||||
52 | auto ts = block_pointer_type.GetTypeSystem(); | |||
53 | auto clang_ast_context = ts.dyn_cast_or_null<TypeSystemClang>(); | |||
54 | if (!clang_ast_context) | |||
55 | return; | |||
56 | ||||
57 | std::shared_ptr<ClangASTImporter> clang_ast_importer; | |||
58 | auto *state = target_sp->GetPersistentExpressionStateForLanguage( | |||
59 | lldb::eLanguageTypeC_plus_plus); | |||
60 | if (state) { | |||
61 | auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state); | |||
62 | clang_ast_importer = persistent_vars->GetClangASTImporter(); | |||
63 | } | |||
64 | ||||
65 | if (!clang_ast_importer) { | |||
66 | return; | |||
67 | } | |||
68 | ||||
69 | const char *const isa_name("__isa"); | |||
70 | const CompilerType isa_type = | |||
71 | clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass); | |||
72 | const char *const flags_name("__flags"); | |||
73 | const CompilerType flags_type = | |||
74 | clang_ast_context->GetBasicType(lldb::eBasicTypeInt); | |||
75 | const char *const reserved_name("__reserved"); | |||
76 | const CompilerType reserved_type = | |||
77 | clang_ast_context->GetBasicType(lldb::eBasicTypeInt); | |||
78 | const char *const FuncPtr_name("__FuncPtr"); | |||
79 | ||||
80 | m_block_struct_type = clang_ast_context->CreateStructForIdentifier( | |||
81 | ConstString(), {{isa_name, isa_type}, | |||
82 | {flags_name, flags_type}, | |||
83 | {reserved_name, reserved_type}, | |||
84 | {FuncPtr_name, function_pointer_type}}); | |||
85 | } | |||
86 | ||||
87 | ~BlockPointerSyntheticFrontEnd() override = default; | |||
88 | ||||
89 | size_t CalculateNumChildren() override { | |||
90 | const bool omit_empty_base_classes = false; | |||
91 | return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr); | |||
92 | } | |||
93 | ||||
94 | lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { | |||
95 | if (!m_block_struct_type.IsValid()) { | |||
96 | return lldb::ValueObjectSP(); | |||
97 | } | |||
98 | ||||
99 | if (idx >= CalculateNumChildren()) { | |||
100 | return lldb::ValueObjectSP(); | |||
101 | } | |||
102 | ||||
103 | const bool thread_and_frame_only_if_stopped = true; | |||
104 | ExecutionContext exe_ctx = m_backend.GetExecutionContextRef().Lock( | |||
105 | thread_and_frame_only_if_stopped); | |||
106 | const bool transparent_pointers = false; | |||
107 | const bool omit_empty_base_classes = false; | |||
108 | const bool ignore_array_bounds = false; | |||
109 | ValueObject *value_object = nullptr; | |||
110 | ||||
111 | std::string child_name; | |||
112 | uint32_t child_byte_size = 0; | |||
113 | int32_t child_byte_offset = 0; | |||
114 | uint32_t child_bitfield_bit_size = 0; | |||
115 | uint32_t child_bitfield_bit_offset = 0; | |||
116 | bool child_is_base_class = false; | |||
117 | bool child_is_deref_of_parent = false; | |||
118 | uint64_t language_flags = 0; | |||
119 | ||||
120 | const CompilerType child_type = | |||
121 | m_block_struct_type.GetChildCompilerTypeAtIndex( | |||
122 | &exe_ctx, idx, transparent_pointers, omit_empty_base_classes, | |||
123 | ignore_array_bounds, child_name, child_byte_size, child_byte_offset, | |||
124 | child_bitfield_bit_size, child_bitfield_bit_offset, | |||
125 | child_is_base_class, child_is_deref_of_parent, value_object, | |||
126 | language_flags); | |||
127 | ||||
128 | ValueObjectSP struct_pointer_sp = | |||
129 | m_backend.Cast(m_block_struct_type.GetPointerType()); | |||
130 | ||||
131 | if (!struct_pointer_sp) { | |||
132 | return lldb::ValueObjectSP(); | |||
133 | } | |||
134 | ||||
135 | Status err; | |||
136 | ValueObjectSP struct_sp = struct_pointer_sp->Dereference(err); | |||
137 | ||||
138 | if (!struct_sp || !err.Success()) { | |||
139 | return lldb::ValueObjectSP(); | |||
140 | } | |||
141 | ||||
142 | ValueObjectSP child_sp(struct_sp->GetSyntheticChildAtOffset( | |||
143 | child_byte_offset, child_type, true, | |||
144 | ConstString(child_name.c_str(), child_name.size()))); | |||
145 | ||||
146 | return child_sp; | |||
147 | } | |||
148 | ||||
149 | // return true if this object is now safe to use forever without ever | |||
150 | // updating again; the typical (and tested) answer here is 'false' | |||
151 | bool Update() override { return false; } | |||
152 | ||||
153 | // maybe return false if the block pointer is, say, null | |||
154 | bool MightHaveChildren() override { return true; } | |||
155 | ||||
156 | size_t GetIndexOfChildWithName(ConstString name) override { | |||
157 | if (!m_block_struct_type.IsValid()) | |||
158 | return UINT32_MAX(4294967295U); | |||
159 | ||||
160 | const bool omit_empty_base_classes = false; | |||
161 | return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(), | |||
162 | omit_empty_base_classes); | |||
163 | } | |||
164 | ||||
165 | private: | |||
166 | CompilerType m_block_struct_type; | |||
167 | }; | |||
168 | ||||
169 | } // namespace formatters | |||
170 | } // namespace lldb_private | |||
171 | ||||
172 | bool lldb_private::formatters::BlockPointerSummaryProvider( | |||
173 | ValueObject &valobj, Stream &s, const TypeSummaryOptions &) { | |||
174 | lldb_private::SyntheticChildrenFrontEnd *synthetic_children = | |||
175 | BlockPointerSyntheticFrontEndCreator(nullptr, valobj.GetSP()); | |||
| ||||
176 | if (!synthetic_children
| |||
177 | return false; | |||
178 | } | |||
179 | ||||
180 | synthetic_children->Update(); | |||
181 | ||||
182 | static const ConstString s_FuncPtr_name("__FuncPtr"); | |||
183 | ||||
184 | lldb::ValueObjectSP child_sp = synthetic_children->GetChildAtIndex( | |||
| ||||
185 | synthetic_children->GetIndexOfChildWithName(s_FuncPtr_name)); | |||
186 | ||||
187 | if (!child_sp) { | |||
188 | return false; | |||
189 | } | |||
190 | ||||
191 | lldb::ValueObjectSP qualified_child_representation_sp = | |||
192 | child_sp->GetQualifiedRepresentationIfAvailable( | |||
193 | lldb::eDynamicDontRunTarget, true); | |||
194 | ||||
195 | const char *child_value = | |||
196 | qualified_child_representation_sp->GetValueAsCString(); | |||
197 | ||||
198 | s.Printf("%s", child_value); | |||
199 | ||||
200 | return true; | |||
201 | } | |||
202 | ||||
203 | lldb_private::SyntheticChildrenFrontEnd * | |||
204 | lldb_private::formatters::BlockPointerSyntheticFrontEndCreator( | |||
205 | CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { | |||
206 | if (!valobj_sp) | |||
207 | return nullptr; | |||
208 | return new BlockPointerSyntheticFrontEnd(valobj_sp); | |||
209 | } |