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