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),
48                      "Failed to get scratch TypeSystemClang");
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;
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 }
210