LLDB mainline
BlockPointer.cpp
Go to the documentation of this file.
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
18#include "lldb/Target/Target.h"
21#include "lldb/Utility/Log.h"
22
23using namespace lldb;
24using namespace lldb_private;
25using namespace lldb_private::formatters;
26
27namespace lldb_private {
28namespace formatters {
29
31public:
32 BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
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(
46 if (auto err = type_system_or_err.takeError()) {
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(
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 {
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;
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 =
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 =
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 {
158 return UINT32_MAX;
159
160 const bool omit_empty_base_classes = false;
162 omit_empty_base_classes);
163 }
164
165private:
167};
168
169} // namespace formatters
170} // namespace lldb_private
171
173 ValueObject &valobj, Stream &s, const TypeSummaryOptions &) {
174 lldb_private::SyntheticChildrenFrontEnd *synthetic_children =
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(
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
205 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
206 if (!valobj_sp)
207 return nullptr;
208 return new BlockPointerSyntheticFrontEnd(valobj_sp);
209}
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:360
std::shared_ptr< TypeSystemType > dyn_cast_or_null()
Return a shared_ptr<TypeSystemType> if dyn_cast succeeds.
Definition: CompilerType.h:68
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
TypeSystemSPWrapper GetTypeSystem() const
Accessors.
CompilerType GetChildCompilerTypeAtIndex(ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, bool omit_empty_base_classes, bool ignore_array_bounds, std::string &child_name, uint32_t &child_byte_size, int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, bool &child_is_base_class, bool &child_is_deref_of_parent, ValueObject *valobj, uint64_t &language_flags) const
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
uint32_t GetNumChildren(bool omit_empty_base_classes, const ExecutionContext *exe_ctx) const
bool IsBlockPointerType(CompilerType *function_pointer_type_ptr=nullptr) const
uint32_t GetIndexOfChildWithName(const char *name, bool omit_empty_base_classes) const
Lookup a child given a name.
A uniqued constant string class.
Definition: ConstString.h:39
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:192
ExecutionContext Lock(bool thread_and_frame_only_if_stopped) const
Create an ExecutionContext object from this object.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
An error handling class.
Definition: Status.h:44
bool Success() const
Test for success condition.
Definition: Status.cpp:287
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
virtual size_t GetIndexOfChildWithName(ConstString name)=0
virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx)=0
A TypeSystem implementation based on Clang.
virtual lldb::ValueObjectSP Cast(const CompilerType &compiler_type)
CompilerType GetCompilerType()
Definition: ValueObject.h:352
lldb::ValueObjectSP GetSP()
Definition: ValueObject.h:555
lldb::TargetSP GetTargetSP() const
Definition: ValueObject.h:334
const ExecutionContextRef & GetExecutionContextRef() const
Definition: ValueObject.h:330
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override
size_t GetIndexOfChildWithName(ConstString name) override
BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
#define UINT32_MAX
Definition: lldb-defines.h:19
SyntheticChildrenFrontEnd * BlockPointerSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP)
bool BlockPointerSummaryProvider(ValueObject &, Stream &, const TypeSummaryOptions &)
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
Definition: SBAddress.h:15
@ eBasicTypeObjCClass
@ eLanguageTypeC_plus_plus
ISO C++:1998.
@ eDynamicDontRunTarget