File: | build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp |
Warning: | line 182, column 34 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 | TypeSystemClang *clang_ast_context = | |||
53 | llvm::cast<TypeSystemClang>(block_pointer_type.GetTypeSystem()); | |||
54 | ||||
55 | std::shared_ptr<ClangASTImporter> clang_ast_importer; | |||
56 | auto *state = target_sp->GetPersistentExpressionStateForLanguage( | |||
57 | lldb::eLanguageTypeC_plus_plus); | |||
58 | if (state) { | |||
59 | auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state); | |||
60 | clang_ast_importer = persistent_vars->GetClangASTImporter(); | |||
61 | } | |||
62 | ||||
63 | if (!clang_ast_importer) { | |||
64 | return; | |||
65 | } | |||
66 | ||||
67 | const char *const isa_name("__isa"); | |||
68 | const CompilerType isa_type = | |||
69 | clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass); | |||
70 | const char *const flags_name("__flags"); | |||
71 | const CompilerType flags_type = | |||
72 | clang_ast_context->GetBasicType(lldb::eBasicTypeInt); | |||
73 | const char *const reserved_name("__reserved"); | |||
74 | const CompilerType reserved_type = | |||
75 | clang_ast_context->GetBasicType(lldb::eBasicTypeInt); | |||
76 | const char *const FuncPtr_name("__FuncPtr"); | |||
77 | ||||
78 | m_block_struct_type = clang_ast_context->CreateStructForIdentifier( | |||
79 | ConstString(), {{isa_name, isa_type}, | |||
80 | {flags_name, flags_type}, | |||
81 | {reserved_name, reserved_type}, | |||
82 | {FuncPtr_name, function_pointer_type}}); | |||
83 | } | |||
84 | ||||
85 | ~BlockPointerSyntheticFrontEnd() override = default; | |||
86 | ||||
87 | size_t CalculateNumChildren() override { | |||
88 | const bool omit_empty_base_classes = false; | |||
89 | return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr); | |||
90 | } | |||
91 | ||||
92 | lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { | |||
93 | if (!m_block_struct_type.IsValid()) { | |||
94 | return lldb::ValueObjectSP(); | |||
95 | } | |||
96 | ||||
97 | if (idx >= CalculateNumChildren()) { | |||
98 | return lldb::ValueObjectSP(); | |||
99 | } | |||
100 | ||||
101 | const bool thread_and_frame_only_if_stopped = true; | |||
102 | ExecutionContext exe_ctx = m_backend.GetExecutionContextRef().Lock( | |||
103 | thread_and_frame_only_if_stopped); | |||
104 | const bool transparent_pointers = false; | |||
105 | const bool omit_empty_base_classes = false; | |||
106 | const bool ignore_array_bounds = false; | |||
107 | ValueObject *value_object = nullptr; | |||
108 | ||||
109 | std::string child_name; | |||
110 | uint32_t child_byte_size = 0; | |||
111 | int32_t child_byte_offset = 0; | |||
112 | uint32_t child_bitfield_bit_size = 0; | |||
113 | uint32_t child_bitfield_bit_offset = 0; | |||
114 | bool child_is_base_class = false; | |||
115 | bool child_is_deref_of_parent = false; | |||
116 | uint64_t language_flags = 0; | |||
117 | ||||
118 | const CompilerType child_type = | |||
119 | m_block_struct_type.GetChildCompilerTypeAtIndex( | |||
120 | &exe_ctx, idx, transparent_pointers, omit_empty_base_classes, | |||
121 | ignore_array_bounds, child_name, child_byte_size, child_byte_offset, | |||
122 | child_bitfield_bit_size, child_bitfield_bit_offset, | |||
123 | child_is_base_class, child_is_deref_of_parent, value_object, | |||
124 | language_flags); | |||
125 | ||||
126 | ValueObjectSP struct_pointer_sp = | |||
127 | m_backend.Cast(m_block_struct_type.GetPointerType()); | |||
128 | ||||
129 | if (!struct_pointer_sp) { | |||
130 | return lldb::ValueObjectSP(); | |||
131 | } | |||
132 | ||||
133 | Status err; | |||
134 | ValueObjectSP struct_sp = struct_pointer_sp->Dereference(err); | |||
135 | ||||
136 | if (!struct_sp || !err.Success()) { | |||
137 | return lldb::ValueObjectSP(); | |||
138 | } | |||
139 | ||||
140 | ValueObjectSP child_sp(struct_sp->GetSyntheticChildAtOffset( | |||
141 | child_byte_offset, child_type, true, | |||
142 | ConstString(child_name.c_str(), child_name.size()))); | |||
143 | ||||
144 | return child_sp; | |||
145 | } | |||
146 | ||||
147 | // return true if this object is now safe to use forever without ever | |||
148 | // updating again; the typical (and tested) answer here is 'false' | |||
149 | bool Update() override { return false; } | |||
150 | ||||
151 | // maybe return false if the block pointer is, say, null | |||
152 | bool MightHaveChildren() override { return true; } | |||
153 | ||||
154 | size_t GetIndexOfChildWithName(ConstString name) override { | |||
155 | if (!m_block_struct_type.IsValid()) | |||
156 | return UINT32_MAX(4294967295U); | |||
157 | ||||
158 | const bool omit_empty_base_classes = false; | |||
159 | return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(), | |||
160 | omit_empty_base_classes); | |||
161 | } | |||
162 | ||||
163 | private: | |||
164 | CompilerType m_block_struct_type; | |||
165 | }; | |||
166 | ||||
167 | } // namespace formatters | |||
168 | } // namespace lldb_private | |||
169 | ||||
170 | bool lldb_private::formatters::BlockPointerSummaryProvider( | |||
171 | ValueObject &valobj, Stream &s, const TypeSummaryOptions &) { | |||
172 | lldb_private::SyntheticChildrenFrontEnd *synthetic_children = | |||
173 | BlockPointerSyntheticFrontEndCreator(nullptr, valobj.GetSP()); | |||
| ||||
174 | if (!synthetic_children
| |||
175 | return false; | |||
176 | } | |||
177 | ||||
178 | synthetic_children->Update(); | |||
179 | ||||
180 | static const ConstString s_FuncPtr_name("__FuncPtr"); | |||
181 | ||||
182 | lldb::ValueObjectSP child_sp = synthetic_children->GetChildAtIndex( | |||
| ||||
183 | synthetic_children->GetIndexOfChildWithName(s_FuncPtr_name)); | |||
184 | ||||
185 | if (!child_sp) { | |||
186 | return false; | |||
187 | } | |||
188 | ||||
189 | lldb::ValueObjectSP qualified_child_representation_sp = | |||
190 | child_sp->GetQualifiedRepresentationIfAvailable( | |||
191 | lldb::eDynamicDontRunTarget, true); | |||
192 | ||||
193 | const char *child_value = | |||
194 | qualified_child_representation_sp->GetValueAsCString(); | |||
195 | ||||
196 | s.Printf("%s", child_value); | |||
197 | ||||
198 | return true; | |||
199 | } | |||
200 | ||||
201 | lldb_private::SyntheticChildrenFrontEnd * | |||
202 | lldb_private::formatters::BlockPointerSyntheticFrontEndCreator( | |||
203 | CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { | |||
204 | if (!valobj_sp) | |||
205 | return nullptr; | |||
206 | return new BlockPointerSyntheticFrontEnd(valobj_sp); | |||
207 | } |