1 //===-- BlockPointer.cpp ----------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "BlockPointer.h"
11
12 #include "lldb/Core/ValueObject.h"
13 #include "lldb/DataFormatters/FormattersHelpers.h"
14 #include "lldb/Symbol/ClangASTContext.h"
15 #include "lldb/Symbol/ClangASTImporter.h"
16 #include "lldb/Symbol/CompilerType.h"
17 #include "lldb/Symbol/TypeSystem.h"
18 #include "lldb/Target/Target.h"
19
20 #include "lldb/Utility/LLDBAssert.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:
BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)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 Status err;
44 TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage(
45 &err, lldb::eLanguageTypeC_plus_plus);
46
47 if (!err.Success() || !type_system) {
48 return;
49 }
50
51 ClangASTContext *clang_ast_context =
52 llvm::dyn_cast<ClangASTContext>(type_system);
53
54 if (!clang_ast_context) {
55 return;
56 }
57
58 ClangASTImporterSP clang_ast_importer = target_sp->GetClangASTImporter();
59
60 if (!clang_ast_importer) {
61 return;
62 }
63
64 const char *const isa_name("__isa");
65 const CompilerType isa_type =
66 clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass);
67 const char *const flags_name("__flags");
68 const CompilerType flags_type =
69 clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
70 const char *const reserved_name("__reserved");
71 const CompilerType reserved_type =
72 clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
73 const char *const FuncPtr_name("__FuncPtr");
74 const CompilerType FuncPtr_type =
75 clang_ast_importer->CopyType(*clang_ast_context, function_pointer_type);
76
77 m_block_struct_type = clang_ast_context->CreateStructForIdentifier(
78 ConstString(), {{isa_name, isa_type},
79 {flags_name, flags_type},
80 {reserved_name, reserved_type},
81 {FuncPtr_name, FuncPtr_type}});
82 }
83
84 ~BlockPointerSyntheticFrontEnd() override = default;
85
CalculateNumChildren()86 size_t CalculateNumChildren() override {
87 const bool omit_empty_base_classes = false;
88 return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr);
89 }
90
GetChildAtIndex(size_t idx)91 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
92 if (!m_block_struct_type.IsValid()) {
93 return lldb::ValueObjectSP();
94 }
95
96 if (idx >= CalculateNumChildren()) {
97 return lldb::ValueObjectSP();
98 }
99
100 const bool thread_and_frame_only_if_stopped = true;
101 ExecutionContext exe_ctx = m_backend.GetExecutionContextRef().Lock(
102 thread_and_frame_only_if_stopped);
103 const bool transparent_pointers = false;
104 const bool omit_empty_base_classes = false;
105 const bool ignore_array_bounds = false;
106 ValueObject *value_object = nullptr;
107
108 std::string child_name;
109 uint32_t child_byte_size = 0;
110 int32_t child_byte_offset = 0;
111 uint32_t child_bitfield_bit_size = 0;
112 uint32_t child_bitfield_bit_offset = 0;
113 bool child_is_base_class = false;
114 bool child_is_deref_of_parent = false;
115 uint64_t language_flags = 0;
116
117 const CompilerType child_type =
118 m_block_struct_type.GetChildCompilerTypeAtIndex(
119 &exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
120 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
121 child_bitfield_bit_size, child_bitfield_bit_offset,
122 child_is_base_class, child_is_deref_of_parent, value_object,
123 language_flags);
124
125 ValueObjectSP struct_pointer_sp =
126 m_backend.Cast(m_block_struct_type.GetPointerType());
127
128 if (!struct_pointer_sp) {
129 return lldb::ValueObjectSP();
130 }
131
132 Status err;
133 ValueObjectSP struct_sp = struct_pointer_sp->Dereference(err);
134
135 if (!struct_sp || !err.Success()) {
136 return lldb::ValueObjectSP();
137 }
138
139 ValueObjectSP child_sp(struct_sp->GetSyntheticChildAtOffset(
140 child_byte_offset, child_type, true,
141 ConstString(child_name.c_str(), child_name.size())));
142
143 return child_sp;
144 }
145
146 // return true if this object is now safe to use forever without ever
147 // updating again; the typical (and tested) answer here is 'false'
Update()148 bool Update() override { return false; }
149
150 // maybe return false if the block pointer is, say, null
MightHaveChildren()151 bool MightHaveChildren() override { return true; }
152
GetIndexOfChildWithName(const ConstString & name)153 size_t GetIndexOfChildWithName(const ConstString &name) override {
154 if (!m_block_struct_type.IsValid())
155 return UINT32_MAX;
156
157 const bool omit_empty_base_classes = false;
158 return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(),
159 omit_empty_base_classes);
160 }
161
162 private:
163 CompilerType m_block_struct_type;
164 };
165
166 } // namespace formatters
167 } // namespace lldb_private
168
BlockPointerSummaryProvider(ValueObject & valobj,Stream & s,const TypeSummaryOptions &)169 bool lldb_private::formatters::BlockPointerSummaryProvider(
170 ValueObject &valobj, Stream &s, const TypeSummaryOptions &) {
171 lldb_private::SyntheticChildrenFrontEnd *synthetic_children =
172 BlockPointerSyntheticFrontEndCreator(nullptr, valobj.GetSP());
173 if (!synthetic_children) {
174 return false;
175 }
176
177 synthetic_children->Update();
178
179 static const ConstString s_FuncPtr_name("__FuncPtr");
180
181 lldb::ValueObjectSP child_sp = synthetic_children->GetChildAtIndex(
182 synthetic_children->GetIndexOfChildWithName(s_FuncPtr_name));
183
184 if (!child_sp) {
185 return false;
186 }
187
188 lldb::ValueObjectSP qualified_child_representation_sp =
189 child_sp->GetQualifiedRepresentationIfAvailable(
190 lldb::eDynamicDontRunTarget, true);
191
192 const char *child_value =
193 qualified_child_representation_sp->GetValueAsCString();
194
195 s.Printf("%s", child_value);
196
197 return true;
198 }
199
200 lldb_private::SyntheticChildrenFrontEnd *
BlockPointerSyntheticFrontEndCreator(CXXSyntheticChildren *,lldb::ValueObjectSP valobj_sp)201 lldb_private::formatters::BlockPointerSyntheticFrontEndCreator(
202 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
203 if (!valobj_sp)
204 return nullptr;
205 return new BlockPointerSyntheticFrontEnd(valobj_sp);
206 }
207