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"
18 #include "lldb/Symbol/Variable.h"
19 #include "lldb/Symbol/VariableList.h"
20 
21 #include "lldb/Core/PluginManager.h"
22 #include "lldb/Core/UniqueCStringMap.h"
23 #include "lldb/Symbol/CompileUnit.h"
24 #include "lldb/Target/ABI.h"
25 #include "lldb/Target/ExecutionContext.h"
26 #include "lldb/Target/RegisterContext.h"
27 #include "lldb/Target/SectionLoadList.h"
28 #include "lldb/Target/StackFrame.h"
29 #include "lldb/Target/ThreadPlanRunToAddress.h"
30 #include "lldb/Target/ThreadPlanStepInRange.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 CPPLanguageRuntime::CPPLanguageRuntime(Process *process)
41     : LanguageRuntime(process) {}
42 
43 bool CPPLanguageRuntime::IsAllowedRuntimeValue(ConstString name) {
44   return name == g_this;
45 }
46 
47 bool CPPLanguageRuntime::GetObjectDescription(Stream &str,
48                                               ValueObject &object) {
49   // C++ has no generic way to do this.
50   return false;
51 }
52 
53 bool CPPLanguageRuntime::GetObjectDescription(
54     Stream &str, Value &value, ExecutionContextScope *exe_scope) {
55   // C++ has no generic way to do this.
56   return false;
57 }
58 
59 bool contains_lambda_identifier(llvm::StringRef &str_ref) {
60   return str_ref.contains("$_") || str_ref.contains("'lambda'");
61 }
62 
63 CPPLanguageRuntime::LibCppStdFunctionCallableInfo
64 line_entry_helper(Target &target, const SymbolContext &sc, Symbol *symbol,
65                   llvm::StringRef first_template_param_sref,
66                   bool has_invoke) {
67 
68   CPPLanguageRuntime::LibCppStdFunctionCallableInfo optional_info;
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
83       optional_info.callable_case = lldb_private::CPPLanguageRuntime::
84           LibCppStdFunctionCallableCase::Lambda;
85     } else {
86       // Case 3
87       optional_info.callable_case = lldb_private::CPPLanguageRuntime::
88           LibCppStdFunctionCallableCase::CallableObject;
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 
99 CPPLanguageRuntime::LibCppStdFunctionCallableInfo
100 CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
101     lldb::ValueObjectSP &valobj_sp) {
102   LLDB_SCOPED_TIMER();
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 
199   if (!target.GetSectionLoadList().ResolveLoadAddress(
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 
211   target.GetImages().ResolveSymbolContextForAddress(
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.
250   if (target.GetSectionLoadList().ResolveLoadAddress(
251           possible_function_address, function_address_resolved)) {
252     target.GetImages().ResolveSymbolContextForAddress(
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) {
269     SymbolContextList scl;
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 =
280         LibCppStdFunctionCallableCase::FreeOrMemberFunction;
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 
293   SymbolContextList scl;
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 
337 lldb::ThreadPlanSP
338 CPPLanguageRuntime::GetStepThroughTrampolinePlan(Thread &thread,
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 
386     CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info =
387         FindLibCppStdFunctionCallableInfo(value_sp);
388 
389     if (callable_info.callable_case != LibCppStdFunctionCallableCase::Invalid &&
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,
402           eLazyBoolYes, eLazyBoolYes);
403       return ret_plan_sp;
404     }
405   }
406 
407   return ret_plan_sp;
408 }
409