1 //===-- AppleThreadPlanStepThroughObjCTrampoline.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 "AppleThreadPlanStepThroughObjCTrampoline.h" 10 11 #include "AppleObjCTrampolineHandler.h" 12 #include "lldb/Expression/DiagnosticManager.h" 13 #include "lldb/Expression/FunctionCaller.h" 14 #include "lldb/Expression/UtilityFunction.h" 15 #include "lldb/Target/ABI.h" 16 #include "lldb/Target/ExecutionContext.h" 17 #include "lldb/Target/Process.h" 18 #include "lldb/Target/Thread.h" 19 #include "lldb/Target/ThreadPlanRunToAddress.h" 20 #include "lldb/Target/ThreadPlanStepOut.h" 21 #include "lldb/Utility/LLDBLog.h" 22 #include "lldb/Utility/Log.h" 23 24 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" 25 26 #include <memory> 27 28 using namespace lldb; 29 using namespace lldb_private; 30 31 // ThreadPlanStepThroughObjCTrampoline constructor 32 AppleThreadPlanStepThroughObjCTrampoline:: 33 AppleThreadPlanStepThroughObjCTrampoline( 34 Thread &thread, AppleObjCTrampolineHandler &trampoline_handler, 35 ValueList &input_values, lldb::addr_t isa_addr, lldb::addr_t sel_addr, 36 lldb::addr_t sel_str_addr, llvm::StringRef sel_str) 37 : ThreadPlan(ThreadPlan::eKindGeneric, 38 "MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion, 39 eVoteNoOpinion), 40 m_trampoline_handler(trampoline_handler), 41 m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values), 42 m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr), 43 m_sel_str_addr(sel_str_addr), m_sel_str(sel_str) {} 44 45 // Destructor 46 AppleThreadPlanStepThroughObjCTrampoline:: 47 ~AppleThreadPlanStepThroughObjCTrampoline() = default; 48 49 void AppleThreadPlanStepThroughObjCTrampoline::DidPush() { 50 // Setting up the memory space for the called function text might require 51 // allocations, i.e. a nested function call. This needs to be done as a 52 // PreResumeAction. 53 m_process.AddPreResumeAction(PreResumeInitializeFunctionCaller, (void *)this); 54 } 55 56 bool AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller() { 57 if (!m_func_sp) { 58 DiagnosticManager diagnostics; 59 m_args_addr = 60 m_trampoline_handler.SetupDispatchFunction(GetThread(), m_input_values); 61 62 if (m_args_addr == LLDB_INVALID_ADDRESS) { 63 return false; 64 } 65 m_impl_function = 66 m_trampoline_handler.GetLookupImplementationFunctionCaller(); 67 ExecutionContext exc_ctx; 68 EvaluateExpressionOptions options; 69 options.SetUnwindOnError(true); 70 options.SetIgnoreBreakpoints(true); 71 options.SetStopOthers(false); 72 GetThread().CalculateExecutionContext(exc_ctx); 73 m_func_sp = m_impl_function->GetThreadPlanToCallFunction( 74 exc_ctx, m_args_addr, options, diagnostics); 75 m_func_sp->SetOkayToDiscard(true); 76 PushPlan(m_func_sp); 77 } 78 return true; 79 } 80 81 bool AppleThreadPlanStepThroughObjCTrampoline:: 82 PreResumeInitializeFunctionCaller(void *void_myself) { 83 AppleThreadPlanStepThroughObjCTrampoline *myself = 84 static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself); 85 return myself->InitializeFunctionCaller(); 86 } 87 88 void AppleThreadPlanStepThroughObjCTrampoline::GetDescription( 89 Stream *s, lldb::DescriptionLevel level) { 90 if (level == lldb::eDescriptionLevelBrief) 91 s->Printf("Step through ObjC trampoline"); 92 else { 93 s->Printf("Stepping to implementation of ObjC method - obj: 0x%llx, isa: " 94 "0x%" PRIx64 ", sel: 0x%" PRIx64, 95 m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(), 96 m_isa_addr, m_sel_addr); 97 } 98 } 99 100 bool AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan(Stream *error) { 101 return true; 102 } 103 104 bool AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop( 105 Event *event_ptr) { 106 // If we get asked to explain the stop it will be because something went 107 // wrong (like the implementation for selector function crashed... We're 108 // going to figure out what to do about that, so we do explain the stop. 109 return true; 110 } 111 112 lldb::StateType AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState() { 113 return eStateRunning; 114 } 115 116 bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) { 117 // First stage: we are still handling the "call a function to get the target 118 // of the dispatch" 119 if (m_func_sp) { 120 if (!m_func_sp->IsPlanComplete()) { 121 return false; 122 } else { 123 if (!m_func_sp->PlanSucceeded()) { 124 SetPlanComplete(false); 125 return true; 126 } 127 m_func_sp.reset(); 128 } 129 } 130 131 // Second stage, if all went well with the function calling, get the 132 // implementation function address, and queue up a "run to that address" plan. 133 Log *log = GetLog(LLDBLog::Step); 134 135 if (!m_run_to_sp) { 136 Value target_addr_value; 137 ExecutionContext exc_ctx; 138 GetThread().CalculateExecutionContext(exc_ctx); 139 m_impl_function->FetchFunctionResults(exc_ctx, m_args_addr, 140 target_addr_value); 141 m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr); 142 lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong(); 143 144 if (ABISP abi_sp = GetThread().GetProcess()->GetABI()) { 145 target_addr = abi_sp->FixCodeAddress(target_addr); 146 } 147 Address target_so_addr; 148 target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr()); 149 if (target_addr == 0) { 150 LLDB_LOGF(log, "Got target implementation of 0x0, stopping."); 151 SetPlanComplete(); 152 return true; 153 } 154 if (m_trampoline_handler.AddrIsMsgForward(target_addr)) { 155 LLDB_LOGF(log, 156 "Implementation lookup returned msgForward function: 0x%" PRIx64 157 ", stopping.", 158 target_addr); 159 160 SymbolContext sc = GetThread().GetStackFrameAtIndex(0)->GetSymbolContext( 161 eSymbolContextEverything); 162 Status status; 163 const bool abort_other_plans = false; 164 const bool first_insn = true; 165 const uint32_t frame_idx = 0; 166 m_run_to_sp = GetThread().QueueThreadPlanForStepOutNoShouldStop( 167 abort_other_plans, &sc, first_insn, false, eVoteNoOpinion, 168 eVoteNoOpinion, frame_idx, status); 169 if (m_run_to_sp && status.Success()) 170 m_run_to_sp->SetPrivate(true); 171 return false; 172 } 173 174 LLDB_LOGF(log, "Running to ObjC method implementation: 0x%" PRIx64, 175 target_addr); 176 177 ObjCLanguageRuntime *objc_runtime = 178 ObjCLanguageRuntime::Get(*GetThread().GetProcess()); 179 assert(objc_runtime != nullptr); 180 if (m_sel_str_addr != LLDB_INVALID_ADDRESS) { 181 // Cache the string -> implementation and free the string in the target. 182 Status dealloc_error = 183 GetThread().GetProcess()->DeallocateMemory(m_sel_str_addr); 184 // For now just log this: 185 if (dealloc_error.Fail()) 186 LLDB_LOG(log, "Failed to deallocate the sel str at {0} - error: {1}", 187 m_sel_str_addr, dealloc_error); 188 objc_runtime->AddToMethodCache(m_isa_addr, m_sel_str, target_addr); 189 LLDB_LOG(log, 190 "Adding \\{isa-addr={0}, sel-addr={1}\\} = addr={2} to cache.", 191 m_isa_addr, m_sel_str, target_addr); 192 } else { 193 objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr); 194 LLDB_LOGF(log, 195 "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64 196 "} = addr=0x%" PRIx64 " to cache.", 197 m_isa_addr, m_sel_addr, target_addr); 198 } 199 200 m_run_to_sp = std::make_shared<ThreadPlanRunToAddress>( 201 GetThread(), target_so_addr, false); 202 PushPlan(m_run_to_sp); 203 return false; 204 } else if (GetThread().IsThreadPlanDone(m_run_to_sp.get())) { 205 // Third stage, work the run to target plan. 206 SetPlanComplete(); 207 return true; 208 } 209 return false; 210 } 211 212 // The base class MischiefManaged does some cleanup - so you have to call it in 213 // your MischiefManaged derived class. 214 bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() { 215 return IsPlanComplete(); 216 } 217 218 bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; } 219 220 // Objective-C uses optimized dispatch functions for some common and seldom 221 // overridden methods. For instance 222 // [object respondsToSelector:]; 223 // will get compiled to: 224 // objc_opt_respondsToSelector(object); 225 // This checks whether the selector has been overridden, directly calling the 226 // implementation if it hasn't and calling objc_msgSend if it has. 227 // 228 // We need to get into the overridden implementation. We'll do that by 229 // setting a breakpoint on objc_msgSend, and doing a "step out". If we stop 230 // at objc_msgSend, we can step through to the target of the send, and see if 231 // that's a place we want to stop. 232 // 233 // A couple of complexities. The checking code might call some other method, 234 // so we might see objc_msgSend more than once. Also, these optimized dispatch 235 // functions might dispatch more than one message at a time (e.g. alloc followed 236 // by init.) So we can't give up at the first objc_msgSend. 237 // That means among other things that we have to handle the "ShouldStopHere" - 238 // since we can't just return control to the plan that's controlling us on the 239 // first step. 240 241 AppleThreadPlanStepThroughDirectDispatch :: 242 AppleThreadPlanStepThroughDirectDispatch( 243 Thread &thread, AppleObjCTrampolineHandler &handler, 244 llvm::StringRef dispatch_func_name) 245 : ThreadPlanStepOut(thread, nullptr, true /* first instruction */, false, 246 eVoteNoOpinion, eVoteNoOpinion, 247 0 /* Step out of zeroth frame */, 248 eLazyBoolNo /* Our parent plan will decide this 249 when we are done */ 250 , 251 true /* Run to branch for inline step out */, 252 false /* Don't gather the return value */), 253 m_trampoline_handler(handler), 254 m_dispatch_func_name(std::string(dispatch_func_name)), 255 m_at_msg_send(false) { 256 // Set breakpoints on the dispatch functions: 257 auto bkpt_callback = [&] (lldb::addr_t addr, 258 const AppleObjCTrampolineHandler 259 ::DispatchFunction &dispatch) { 260 m_msgSend_bkpts.push_back(GetTarget().CreateBreakpoint(addr, 261 true /* internal */, 262 false /* hard */)); 263 m_msgSend_bkpts.back()->SetThreadID(GetThread().GetID()); 264 }; 265 handler.ForEachDispatchFunction(bkpt_callback); 266 267 // We'll set the step-out plan in the DidPush so it gets queued in the right 268 // order. 269 270 if (GetThread().GetStepInAvoidsNoDebug()) 271 GetFlags().Set(ThreadPlanShouldStopHere::eStepInAvoidNoDebug); 272 else 273 GetFlags().Clear(ThreadPlanShouldStopHere::eStepInAvoidNoDebug); 274 // We only care about step in. Our parent plan will figure out what to 275 // do when we've stepped out again. 276 GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug); 277 } 278 279 AppleThreadPlanStepThroughDirectDispatch:: 280 ~AppleThreadPlanStepThroughDirectDispatch() { 281 for (BreakpointSP bkpt_sp : m_msgSend_bkpts) { 282 GetTarget().RemoveBreakpointByID(bkpt_sp->GetID()); 283 } 284 } 285 286 void AppleThreadPlanStepThroughDirectDispatch::GetDescription( 287 Stream *s, lldb::DescriptionLevel level) { 288 switch (level) { 289 case lldb::eDescriptionLevelBrief: 290 s->PutCString("Step through ObjC direct dispatch function."); 291 break; 292 default: 293 s->Printf("Step through ObjC direct dispatch '%s' using breakpoints: ", 294 m_dispatch_func_name.c_str()); 295 bool first = true; 296 for (auto bkpt_sp : m_msgSend_bkpts) { 297 if (!first) { 298 s->PutCString(", "); 299 } 300 first = false; 301 s->Printf("%d", bkpt_sp->GetID()); 302 } 303 (*s) << "."; 304 break; 305 } 306 } 307 308 bool 309 AppleThreadPlanStepThroughDirectDispatch::DoPlanExplainsStop(Event *event_ptr) { 310 if (ThreadPlanStepOut::DoPlanExplainsStop(event_ptr)) 311 return true; 312 313 StopInfoSP stop_info_sp = GetPrivateStopInfo(); 314 315 // Check if the breakpoint is one of ours msgSend dispatch breakpoints. 316 317 StopReason stop_reason = eStopReasonNone; 318 if (stop_info_sp) 319 stop_reason = stop_info_sp->GetStopReason(); 320 321 // See if this is one of our msgSend breakpoints: 322 if (stop_reason == eStopReasonBreakpoint) { 323 ProcessSP process_sp = GetThread().GetProcess(); 324 uint64_t break_site_id = stop_info_sp->GetValue(); 325 BreakpointSiteSP site_sp 326 = process_sp->GetBreakpointSiteList().FindByID(break_site_id); 327 // Some other plan might have deleted the site's last owner before this 328 // got to us. In which case, it wasn't our breakpoint... 329 if (!site_sp) 330 return false; 331 332 for (BreakpointSP break_sp : m_msgSend_bkpts) { 333 if (site_sp->IsBreakpointAtThisSite(break_sp->GetID())) { 334 // If we aren't the only one with a breakpoint on this site, then we 335 // should just stop and return control to the user. 336 if (site_sp->GetNumberOfOwners() > 1) { 337 SetPlanComplete(true); 338 return false; 339 } 340 m_at_msg_send = true; 341 return true; 342 } 343 } 344 } 345 346 // We're done here. If one of our sub-plans explained the stop, they 347 // would have already answered true to PlanExplainsStop, and if they were 348 // done, we'll get called to figure out what to do in ShouldStop... 349 return false; 350 } 351 352 bool AppleThreadPlanStepThroughDirectDispatch 353 ::DoWillResume(lldb::StateType resume_state, bool current_plan) { 354 ThreadPlanStepOut::DoWillResume(resume_state, current_plan); 355 m_at_msg_send = false; 356 return true; 357 } 358 359 bool AppleThreadPlanStepThroughDirectDispatch::ShouldStop(Event *event_ptr) { 360 // If step out plan finished, that means we didn't find our way into a method 361 // implementation. Either we went directly to the default implementation, 362 // of the overridden implementation didn't have debug info. 363 // So we should mark ourselves as done. 364 const bool step_out_should_stop = ThreadPlanStepOut::ShouldStop(event_ptr); 365 if (step_out_should_stop) { 366 SetPlanComplete(true); 367 return true; 368 } 369 370 // If we have a step through plan, then w're in the process of getting 371 // through an ObjC msgSend. If we arrived at the target function, then 372 // check whether we have debug info, and if we do, stop. 373 Log *log = GetLog(LLDBLog::Step); 374 375 if (m_objc_step_through_sp && m_objc_step_through_sp->IsPlanComplete()) { 376 // If the plan failed for some reason, we should probably just let the 377 // step over plan get us out of here... We don't need to do anything about 378 // the step through plan, it is done and will get popped when we continue. 379 if (!m_objc_step_through_sp->PlanSucceeded()) { 380 LLDB_LOGF(log, "ObjC Step through plan failed. Stepping out."); 381 } 382 Status error; 383 if (InvokeShouldStopHereCallback(eFrameCompareYounger, error)) { 384 SetPlanComplete(true); 385 return true; 386 } 387 // If we didn't want to stop at this msgSend, there might be another so 388 // we should just continue on with the step out and see if our breakpoint 389 // triggers again. 390 m_objc_step_through_sp.reset(); 391 for (BreakpointSP bkpt_sp : m_msgSend_bkpts) { 392 bkpt_sp->SetEnabled(true); 393 } 394 return false; 395 } 396 397 // If we hit an msgSend breakpoint, then we should queue the step through 398 // plan: 399 400 if (m_at_msg_send) { 401 LanguageRuntime *objc_runtime 402 = GetThread().GetProcess()->GetLanguageRuntime(eLanguageTypeObjC); 403 // There's no way we could have gotten here without an ObjC language 404 // runtime. 405 assert(objc_runtime); 406 m_objc_step_through_sp = 407 objc_runtime->GetStepThroughTrampolinePlan(GetThread(), false); 408 // If we failed to find the target for this dispatch, just keep going and 409 // let the step out complete. 410 if (!m_objc_step_through_sp) { 411 LLDB_LOG(log, "Couldn't find target for message dispatch, continuing."); 412 return false; 413 } 414 // Otherwise push the step through plan and continue. 415 GetThread().QueueThreadPlan(m_objc_step_through_sp, false); 416 for (BreakpointSP bkpt_sp : m_msgSend_bkpts) { 417 bkpt_sp->SetEnabled(false); 418 } 419 return false; 420 } 421 return true; 422 } 423 424 bool AppleThreadPlanStepThroughDirectDispatch::MischiefManaged() { 425 if (IsPlanComplete()) 426 return true; 427 return ThreadPlanStepOut::MischiefManaged(); 428 } 429