LLDB mainline
CPPLanguageRuntime.cpp
Go to the documentation of this file.
1//===-- CPPLanguageRuntime.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 <cstring>
10
11#include <memory>
12
13#include "CPPLanguageRuntime.h"
14
15#include "llvm/ADT/StringRef.h"
16
17#include "lldb/Symbol/Block.h"
20
24#include "lldb/Target/ABI.h"
31#include "lldb/Utility/Timer.h"
32
33using namespace lldb;
34using namespace lldb_private;
35
37
39
41 : LanguageRuntime(process) {}
42
44 return name == g_this;
45}
46
48 ValueObject &object) {
49 // C++ has no generic way to do this.
50 return false;
51}
52
54 Stream &str, Value &value, ExecutionContextScope *exe_scope) {
55 // C++ has no generic way to do this.
56 return false;
57}
58
59bool contains_lambda_identifier(llvm::StringRef &str_ref) {
60 return str_ref.contains("$_") || str_ref.contains("'lambda'");
61}
62
64line_entry_helper(Target &target, const SymbolContext &sc, Symbol *symbol,
65 llvm::StringRef first_template_param_sref,
66 bool has_invoke) {
67
69
70 AddressRange range;
71 sc.GetAddressRange(eSymbolContextEverything, 0, false, range);
72
73 Address address = range.GetBaseAddress();
74
75 Address addr;
76 if (target.ResolveLoadAddress(address.GetCallableLoadAddress(&target),
77 addr)) {
78 LineEntry line_entry;
79 addr.CalculateSymbolContextLineEntry(line_entry);
80
81 if (contains_lambda_identifier(first_template_param_sref) || has_invoke) {
82 // Case 1 and 2
85 } else {
86 // Case 3
89 }
90
91 optional_info.callable_symbol = *symbol;
92 optional_info.callable_line_entry = line_entry;
93 optional_info.callable_address = addr;
94 }
95
96 return optional_info;
97}
98
101 lldb::ValueObjectSP &valobj_sp) {
103
104 LibCppStdFunctionCallableInfo optional_info;
105
106 if (!valobj_sp)
107 return optional_info;
108
109 // Member __f_ has type __base*, the contents of which will hold:
110 // 1) a vtable entry which may hold type information needed to discover the
111 // lambda being called
112 // 2) possibly hold a pointer to the callable object
113 // e.g.
114 //
115 // (lldb) frame var -R f_display
116 // (std::__1::function<void (int)>) f_display = {
117 // __buf_ = {
118 // …
119 // }
120 // __f_ = 0x00007ffeefbffa00
121 // }
122 // (lldb) memory read -fA 0x00007ffeefbffa00
123 // 0x7ffeefbffa00: ... `vtable for std::__1::__function::__func<void (*) ...
124 // 0x7ffeefbffa08: ... `print_num(int) at std_function_cppreference_exam ...
125 //
126 // We will be handling five cases below, std::function is wrapping:
127 //
128 // 1) a lambda we know at compile time. We will obtain the name of the lambda
129 // from the first template pameter from __func's vtable. We will look up
130 // the lambda's operator()() and obtain the line table entry.
131 // 2) a lambda we know at runtime. A pointer to the lambdas __invoke method
132 // will be stored after the vtable. We will obtain the lambdas name from
133 // this entry and lookup operator()() and obtain the line table entry.
134 // 3) a callable object via operator()(). We will obtain the name of the
135 // object from the first template parameter from __func's vtable. We will
136 // look up the objects operator()() and obtain the line table entry.
137 // 4) a member function. A pointer to the function will stored after the
138 // we will obtain the name from this pointer.
139 // 5) a free function. A pointer to the function will stored after the vtable
140 // we will obtain the name from this pointer.
141 ValueObjectSP member_f_(valobj_sp->GetChildMemberWithName("__f_"));
142
143 if (member_f_) {
144 ValueObjectSP sub_member_f_(member_f_->GetChildMemberWithName("__f_"));
145
146 if (sub_member_f_)
147 member_f_ = sub_member_f_;
148 }
149
150 if (!member_f_)
151 return optional_info;
152
153 lldb::addr_t member_f_pointer_value = member_f_->GetValueAsUnsigned(0);
154
155 optional_info.member_f_pointer_value = member_f_pointer_value;
156
157 if (!member_f_pointer_value)
158 return optional_info;
159
160 ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef());
161 Process *process = exe_ctx.GetProcessPtr();
162
163 if (process == nullptr)
164 return optional_info;
165
166 uint32_t address_size = process->GetAddressByteSize();
167 Status status;
168
169 // First item pointed to by __f_ should be the pointer to the vtable for
170 // a __base object.
171 lldb::addr_t vtable_address =
172 process->ReadPointerFromMemory(member_f_pointer_value, status);
173
174 if (status.Fail())
175 return optional_info;
176
177 lldb::addr_t vtable_address_first_entry =
178 process->ReadPointerFromMemory(vtable_address + address_size, status);
179
180 if (status.Fail())
181 return optional_info;
182
183 lldb::addr_t address_after_vtable = member_f_pointer_value + address_size;
184 // As commented above we may not have a function pointer but if we do we will
185 // need it.
186 lldb::addr_t possible_function_address =
187 process->ReadPointerFromMemory(address_after_vtable, status);
188
189 if (status.Fail())
190 return optional_info;
191
192 Target &target = process->GetTarget();
193
194 if (target.GetSectionLoadList().IsEmpty())
195 return optional_info;
196
197 Address vtable_first_entry_resolved;
198
200 vtable_address_first_entry, vtable_first_entry_resolved))
201 return optional_info;
202
203 Address vtable_addr_resolved;
204 SymbolContext sc;
205 Symbol *symbol = nullptr;
206
207 if (!target.GetSectionLoadList().ResolveLoadAddress(vtable_address,
208 vtable_addr_resolved))
209 return optional_info;
210
212 vtable_addr_resolved, eSymbolContextEverything, sc);
213 symbol = sc.symbol;
214
215 if (symbol == nullptr)
216 return optional_info;
217
218 llvm::StringRef vtable_name(symbol->GetName().GetStringRef());
219 bool found_expected_start_string =
220 vtable_name.startswith("vtable for std::__1::__function::__func<");
221
222 if (!found_expected_start_string)
223 return optional_info;
224
225 // Given case 1 or 3 we have a vtable name, we are want to extract the first
226 // template parameter
227 //
228 // ... __func<main::$_0, std::__1::allocator<main::$_0> ...
229 // ^^^^^^^^^
230 //
231 // We could see names such as:
232 // main::$_0
233 // Bar::add_num2(int)::'lambda'(int)
234 // Bar
235 //
236 // We do this by find the first < and , and extracting in between.
237 //
238 // This covers the case of the lambda known at compile time.
239 size_t first_open_angle_bracket = vtable_name.find('<') + 1;
240 size_t first_comma = vtable_name.find(',');
241
242 llvm::StringRef first_template_parameter =
243 vtable_name.slice(first_open_angle_bracket, first_comma);
244
245 Address function_address_resolved;
246
247 // Setup for cases 2, 4 and 5 we have a pointer to a function after the
248 // vtable. We will use a process of elimination to drop through each case
249 // and obtain the data we need.
251 possible_function_address, function_address_resolved)) {
253 function_address_resolved, eSymbolContextEverything, sc);
254 symbol = sc.symbol;
255 }
256
257 // These conditions are used several times to simplify statements later on.
258 bool has_invoke =
259 (symbol ? symbol->GetName().GetStringRef().contains("__invoke") : false);
260 auto calculate_symbol_context_helper = [](auto &t,
261 SymbolContextList &sc_list) {
262 SymbolContext sc;
263 t->CalculateSymbolContext(&sc);
264 sc_list.Append(sc);
265 };
266
267 // Case 2
268 if (has_invoke) {
270 calculate_symbol_context_helper(symbol, scl);
271
272 return line_entry_helper(target, scl[0], symbol, first_template_parameter,
273 has_invoke);
274 }
275
276 // Case 4 or 5
277 if (symbol && !symbol->GetName().GetStringRef().startswith("vtable for") &&
278 !contains_lambda_identifier(first_template_parameter) && !has_invoke) {
279 optional_info.callable_case =
281 optional_info.callable_address = function_address_resolved;
282 optional_info.callable_symbol = *symbol;
283
284 return optional_info;
285 }
286
287 std::string func_to_match = first_template_parameter.str();
288
289 auto it = CallableLookupCache.find(func_to_match);
290 if (it != CallableLookupCache.end())
291 return it->second;
292
294
295 CompileUnit *vtable_cu =
296 vtable_first_entry_resolved.CalculateSymbolContextCompileUnit();
297 llvm::StringRef name_to_use = func_to_match;
298
299 // Case 3, we have a callable object instead of a lambda
300 //
301 // TODO
302 // We currently don't support this case a callable object may have multiple
303 // operator()() varying on const/non-const and number of arguments and we
304 // don't have a way to currently distinguish them so we will bail out now.
305 if (!contains_lambda_identifier(name_to_use))
306 return optional_info;
307
308 if (vtable_cu && !has_invoke) {
309 lldb::FunctionSP func_sp =
310 vtable_cu->FindFunction([name_to_use](const FunctionSP &f) {
311 auto name = f->GetName().GetStringRef();
312 if (name.startswith(name_to_use) && name.contains("operator"))
313 return true;
314
315 return false;
316 });
317
318 if (func_sp) {
319 calculate_symbol_context_helper(func_sp, scl);
320 }
321 }
322
323 if (symbol == nullptr)
324 return optional_info;
325
326 // Case 1 or 3
327 if (scl.GetSize() >= 1) {
328 optional_info = line_entry_helper(target, scl[0], symbol,
329 first_template_parameter, has_invoke);
330 }
331
332 CallableLookupCache[func_to_match] = optional_info;
333
334 return optional_info;
335}
336
339 bool stop_others) {
340 ThreadPlanSP ret_plan_sp;
341
342 lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
343
344 TargetSP target_sp(thread.CalculateTarget());
345
346 if (target_sp->GetSectionLoadList().IsEmpty())
347 return ret_plan_sp;
348
349 Address pc_addr_resolved;
350 SymbolContext sc;
351 Symbol *symbol;
352
353 if (!target_sp->GetSectionLoadList().ResolveLoadAddress(curr_pc,
354 pc_addr_resolved))
355 return ret_plan_sp;
356
357 target_sp->GetImages().ResolveSymbolContextForAddress(
358 pc_addr_resolved, eSymbolContextEverything, sc);
359 symbol = sc.symbol;
360
361 if (symbol == nullptr)
362 return ret_plan_sp;
363
364 llvm::StringRef function_name(symbol->GetName().GetCString());
365
366 // Handling the case where we are attempting to step into std::function.
367 // The behavior will be that we will attempt to obtain the wrapped
368 // callable via FindLibCppStdFunctionCallableInfo() and if we find it we
369 // will return a ThreadPlanRunToAddress to the callable. Therefore we will
370 // step into the wrapped callable.
371 //
372 bool found_expected_start_string =
373 function_name.startswith("std::__1::function<");
374
375 if (!found_expected_start_string)
376 return ret_plan_sp;
377
378 AddressRange range_of_curr_func;
379 sc.GetAddressRange(eSymbolContextEverything, 0, false, range_of_curr_func);
380
381 StackFrameSP frame = thread.GetStackFrameAtIndex(0);
382
383 if (frame) {
384 ValueObjectSP value_sp = frame->FindVariable(g_this);
385
388
390 value_sp->GetValueIsValid()) {
391 // We found the std::function wrapped callable and we have its address.
392 // We now create a ThreadPlan to run to the callable.
393 ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(
394 thread, callable_info.callable_address, stop_others);
395 return ret_plan_sp;
396 } else {
397 // We are in std::function but we could not obtain the callable.
398 // We create a ThreadPlan to keep stepping through using the address range
399 // of the current function.
400 ret_plan_sp = std::make_shared<ThreadPlanStepInRange>(
401 thread, range_of_curr_func, sc, nullptr, eOnlyThisThread,
403 return ret_plan_sp;
404 }
405 }
406
407 return ret_plan_sp;
408}
bool contains_lambda_identifier(llvm::StringRef &str_ref)
static ConstString g_this
CPPLanguageRuntime::LibCppStdFunctionCallableInfo line_entry_helper(Target &target, const SymbolContext &sc, Symbol *symbol, llvm::StringRef first_template_param_sref, bool has_invoke)
#define LLDB_SCOPED_TIMER()
Definition: Timer.h:83
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
A section + offset based address class.
Definition: Address.h:59
lldb::addr_t GetCallableLoadAddress(Target *target, bool is_indirect=false) const
Get the load address as a callable code load address.
Definition: Address.cpp:336
bool CalculateSymbolContextLineEntry(LineEntry &line_entry) const
Definition: Address.cpp:907
CompileUnit * CalculateSymbolContextCompileUnit() const
Definition: Address.cpp:851
bool IsAllowedRuntimeValue(ConstString name) override
Identify whether a name is a runtime value that should not be hidden by from the user interface.
LibCppStdFunctionCallableInfo FindLibCppStdFunctionCallableInfo(lldb::ValueObjectSP &valobj_sp)
lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, bool stop_others) override
Obtain a ThreadPlan to get us into C++ constructs such as std::function.
OperatorStringToCallableInfoMap CallableLookupCache
bool GetObjectDescription(Stream &str, ValueObject &object) override
A class that describes a compilation unit.
Definition: CompileUnit.h:41
lldb::FunctionSP FindFunction(llvm::function_ref< bool(const lldb::FunctionSP &)> matching_lambda)
Find a function in the compile unit based on the predicate matching_lambda.
Definition: CompileUnit.cpp:77
A uniqued constant string class.
Definition: ConstString.h:40
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:191
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:205
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Process * GetProcessPtr() const
Returns a pointer to the process object.
uint32_t ResolveSymbolContextForAddress(const Address &so_addr, lldb::SymbolContextItem resolve_scope, SymbolContext &sc) const
Resolve the symbol context for the given address. (const Address&,uint32_t,SymbolContext&)
Definition: ModuleList.cpp:670
A plug-in interface definition class for debugging a process.
Definition: Process.h:336
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
Definition: Process.cpp:2089
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3403
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1242
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
An error handling class.
Definition: Status.h:44
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
Defines a list of symbol context objects.
uint32_t GetSize() const
Get accessor for a symbol context list size.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
bool GetAddressRange(uint32_t scope, uint32_t range_idx, bool use_inline_block_range, AddressRange &range) const
Get the address range contained within a symbol context.
Symbol * symbol
The Symbol for a given query.
ConstString GetName() const
Definition: Symbol.cpp:544
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1122
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
Definition: Target.cpp:3067
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:967
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:397
virtual lldb::RegisterContextSP GetRegisterContext()=0
lldb::TargetSP CalculateTarget() override
Definition: Thread.cpp:1381
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Function > FunctionSP
Definition: lldb-forward.h:336
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:428
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:399
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:458
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:423
A line table entry class.
Definition: LineEntry.h:20