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