Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- ThreadPlanCallFunction.cpp ------------------------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
| 10 | #include "lldb/Target/ThreadPlanCallFunction.h" |
| 11 | |
| 12 | // C Includes |
| 13 | // C++ Includes |
| 14 | // Other libraries and framework includes |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 15 | #include "llvm/Support/MachO.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 16 | // Project includes |
| 17 | #include "lldb/lldb-private-log.h" |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 18 | #include "lldb/Breakpoint/Breakpoint.h" |
| 19 | #include "lldb/Breakpoint/BreakpointLocation.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 20 | #include "lldb/Core/Address.h" |
| 21 | #include "lldb/Core/Log.h" |
| 22 | #include "lldb/Core/Stream.h" |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 23 | #include "lldb/Target/LanguageRuntime.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 24 | #include "lldb/Target/Process.h" |
| 25 | #include "lldb/Target/RegisterContext.h" |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 26 | #include "lldb/Target/StopInfo.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 27 | #include "lldb/Target/Target.h" |
| 28 | #include "lldb/Target/Thread.h" |
| 29 | #include "lldb/Target/ThreadPlanRunToAddress.h" |
| 30 | |
| 31 | using namespace lldb; |
| 32 | using namespace lldb_private; |
| 33 | |
| 34 | //---------------------------------------------------------------------- |
| 35 | // ThreadPlanCallFunction: Plan to call a single function |
| 36 | //---------------------------------------------------------------------- |
| 37 | |
| 38 | ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread, |
| 39 | Address &function, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 40 | addr_t arg, |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 41 | bool stop_other_threads, |
Sean Callanan | 3c9c5eb | 2010-09-21 00:44:12 +0000 | [diff] [blame] | 42 | bool discard_on_error, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 43 | addr_t *this_arg, |
| 44 | addr_t *cmd_arg) : |
Jim Ingham | 5a47e8b | 2010-06-19 04:45:32 +0000 | [diff] [blame] | 45 | ThreadPlan (ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion), |
Benjamin Kramer | 36a0810 | 2010-07-16 12:32:33 +0000 | [diff] [blame] | 46 | m_valid (false), |
| 47 | m_stop_other_threads (stop_other_threads), |
Benjamin Kramer | 36a0810 | 2010-07-16 12:32:33 +0000 | [diff] [blame] | 48 | m_process (thread.GetProcess()), |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 49 | m_thread (thread), |
Sean Callanan | 0ddf806 | 2011-05-09 22:04:36 +0000 | [diff] [blame] | 50 | m_takedown_done (false), |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 51 | m_function_sp (NULL) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 52 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 53 | SetOkayToDiscard (discard_on_error); |
| 54 | |
| 55 | Process& process = thread.GetProcess(); |
| 56 | Target& target = process.GetTarget(); |
Greg Clayton | 75906e4 | 2011-05-11 18:39:18 +0000 | [diff] [blame] | 57 | const ABI *abi = process.GetABI().get(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 58 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 59 | if (!abi) |
| 60 | return; |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 61 | |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 62 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
| 63 | |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 64 | SetBreakpoints(); |
| 65 | |
Sean Callanan | 0ddf806 | 2011-05-09 22:04:36 +0000 | [diff] [blame] | 66 | m_function_sp = thread.GetRegisterContext()->GetSP() - abi->GetRedZoneSize(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 67 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 68 | ModuleSP executableModuleSP (target.GetExecutableModule()); |
| 69 | |
Jim Ingham | 2877594 | 2011-03-07 23:44:08 +0000 | [diff] [blame] | 70 | if (!executableModuleSP) |
| 71 | { |
| 72 | log->Printf ("Can't execute code without an executable module."); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 73 | return; |
Jim Ingham | 2877594 | 2011-03-07 23:44:08 +0000 | [diff] [blame] | 74 | } |
| 75 | else |
| 76 | { |
| 77 | ObjectFile *objectFile = executableModuleSP->GetObjectFile(); |
| 78 | if (!objectFile) |
| 79 | { |
| 80 | log->Printf ("Could not find object file for module \"%s\".", |
| 81 | executableModuleSP->GetFileSpec().GetFilename().AsCString()); |
| 82 | return; |
| 83 | } |
| 84 | m_start_addr = objectFile->GetEntryPointAddress(); |
| 85 | if (!m_start_addr.IsValid()) |
| 86 | { |
| 87 | log->Printf ("Could not find entry point address for executable module \"%s\".", |
| 88 | executableModuleSP->GetFileSpec().GetFilename().AsCString()); |
| 89 | return; |
| 90 | } |
| 91 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 92 | |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 93 | addr_t start_load_addr = m_start_addr.GetLoadAddress(&target); |
Jim Ingham | 2877594 | 2011-03-07 23:44:08 +0000 | [diff] [blame] | 94 | |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 95 | // Checkpoint the thread state so we can restore it later. |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 96 | if (log && log->GetVerbose()) |
| 97 | ReportRegisterState ("About to checkpoint thread before function call. Original register state was:"); |
| 98 | |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 99 | if (!thread.CheckpointThreadState (m_stored_thread_state)) |
| 100 | { |
| 101 | if (log) |
| 102 | log->Printf ("Setting up ThreadPlanCallFunction, failed to checkpoint thread state."); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 103 | return; |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 104 | } |
| 105 | // Now set the thread state to "no reason" so we don't run with whatever signal was outstanding... |
| 106 | thread.SetStopInfoToNothing(); |
| 107 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 108 | m_function_addr = function; |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 109 | addr_t FunctionLoadAddr = m_function_addr.GetLoadAddress(&target); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 110 | |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 111 | if (this_arg && cmd_arg) |
| 112 | { |
| 113 | if (!abi->PrepareTrivialCall (thread, |
| 114 | m_function_sp, |
| 115 | FunctionLoadAddr, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 116 | start_load_addr, |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 117 | this_arg, |
| 118 | cmd_arg, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 119 | &arg)) |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 120 | return; |
| 121 | } |
| 122 | else if (this_arg) |
| 123 | { |
| 124 | if (!abi->PrepareTrivialCall (thread, |
| 125 | m_function_sp, |
| 126 | FunctionLoadAddr, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 127 | start_load_addr, |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 128 | this_arg, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 129 | &arg)) |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 130 | return; |
| 131 | } |
| 132 | else |
| 133 | { |
| 134 | if (!abi->PrepareTrivialCall (thread, |
| 135 | m_function_sp, |
| 136 | FunctionLoadAddr, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 137 | start_load_addr, |
| 138 | &arg)) |
| 139 | return; |
| 140 | } |
| 141 | |
| 142 | ReportRegisterState ("Function call was set up. Register state was:"); |
| 143 | |
| 144 | m_valid = true; |
| 145 | } |
| 146 | |
| 147 | |
| 148 | ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread, |
| 149 | Address &function, |
| 150 | bool stop_other_threads, |
| 151 | bool discard_on_error, |
| 152 | addr_t *arg1_ptr, |
| 153 | addr_t *arg2_ptr, |
| 154 | addr_t *arg3_ptr, |
| 155 | addr_t *arg4_ptr, |
| 156 | addr_t *arg5_ptr, |
| 157 | addr_t *arg6_ptr) : |
| 158 | ThreadPlan (ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion), |
| 159 | m_valid (false), |
| 160 | m_stop_other_threads (stop_other_threads), |
| 161 | m_process (thread.GetProcess()), |
| 162 | m_thread (thread), |
| 163 | m_takedown_done (false), |
| 164 | m_function_sp(NULL) |
| 165 | { |
| 166 | SetOkayToDiscard (discard_on_error); |
| 167 | |
| 168 | Process& process = thread.GetProcess(); |
| 169 | Target& target = process.GetTarget(); |
| 170 | const ABI *abi = process.GetABI().get(); |
| 171 | |
| 172 | if (!abi) |
| 173 | return; |
| 174 | |
| 175 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
| 176 | |
| 177 | SetBreakpoints(); |
| 178 | |
| 179 | m_function_sp = thread.GetRegisterContext()->GetSP() - abi->GetRedZoneSize(); |
| 180 | |
| 181 | ModuleSP executableModuleSP (target.GetExecutableModule()); |
| 182 | |
| 183 | if (!executableModuleSP) |
| 184 | { |
| 185 | log->Printf ("Can't execute code without an executable module."); |
| 186 | return; |
| 187 | } |
| 188 | else |
| 189 | { |
| 190 | ObjectFile *objectFile = executableModuleSP->GetObjectFile(); |
| 191 | if (!objectFile) |
| 192 | { |
| 193 | log->Printf ("Could not find object file for module \"%s\".", |
| 194 | executableModuleSP->GetFileSpec().GetFilename().AsCString()); |
| 195 | return; |
| 196 | } |
| 197 | m_start_addr = objectFile->GetEntryPointAddress(); |
| 198 | if (!m_start_addr.IsValid()) |
| 199 | { |
| 200 | log->Printf ("Could not find entry point address for executable module \"%s\".", |
| 201 | executableModuleSP->GetFileSpec().GetFilename().AsCString()); |
| 202 | return; |
| 203 | } |
| 204 | } |
| 205 | |
| 206 | addr_t start_load_addr = m_start_addr.GetLoadAddress(&target); |
| 207 | |
| 208 | // Checkpoint the thread state so we can restore it later. |
| 209 | if (log && log->GetVerbose()) |
| 210 | ReportRegisterState ("About to checkpoint thread before function call. Original register state was:"); |
| 211 | |
| 212 | if (!thread.CheckpointThreadState (m_stored_thread_state)) |
| 213 | { |
| 214 | if (log) |
| 215 | log->Printf ("Setting up ThreadPlanCallFunction, failed to checkpoint thread state."); |
| 216 | return; |
| 217 | } |
| 218 | // Now set the thread state to "no reason" so we don't run with whatever signal was outstanding... |
| 219 | thread.SetStopInfoToNothing(); |
| 220 | |
| 221 | m_function_addr = function; |
| 222 | addr_t FunctionLoadAddr = m_function_addr.GetLoadAddress(&target); |
| 223 | |
| 224 | if (!abi->PrepareTrivialCall (thread, |
| 225 | m_function_sp, |
| 226 | FunctionLoadAddr, |
| 227 | start_load_addr, |
| 228 | arg1_ptr, |
| 229 | arg2_ptr, |
| 230 | arg3_ptr, |
| 231 | arg4_ptr, |
| 232 | arg5_ptr, |
| 233 | arg6_ptr)) |
| 234 | { |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 235 | return; |
| 236 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 237 | |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 238 | ReportRegisterState ("Function call was set up. Register state was:"); |
| 239 | |
| 240 | m_valid = true; |
| 241 | } |
| 242 | |
| 243 | ThreadPlanCallFunction::~ThreadPlanCallFunction () |
| 244 | { |
| 245 | } |
| 246 | |
| 247 | void |
| 248 | ThreadPlanCallFunction::ReportRegisterState (const char *message) |
| 249 | { |
| 250 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
Sean Callanan | 6dff827 | 2010-11-08 03:49:50 +0000 | [diff] [blame] | 251 | if (log) |
| 252 | { |
Greg Clayton | 08d7d3a | 2011-01-06 22:15:06 +0000 | [diff] [blame] | 253 | RegisterContext *reg_ctx = m_thread.GetRegisterContext().get(); |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 254 | |
| 255 | log->PutCString(message); |
| 256 | |
Sean Callanan | 6dff827 | 2010-11-08 03:49:50 +0000 | [diff] [blame] | 257 | for (uint32_t register_index = 0, num_registers = reg_ctx->GetRegisterCount(); |
| 258 | register_index < num_registers; |
| 259 | ++register_index) |
| 260 | { |
| 261 | const char *register_name = reg_ctx->GetRegisterName(register_index); |
| 262 | uint64_t register_value = reg_ctx->ReadRegisterAsUnsigned(register_index, LLDB_INVALID_ADDRESS); |
| 263 | |
| 264 | log->Printf(" %s = 0x%llx", register_name, register_value); |
| 265 | } |
| 266 | } |
Sean Callanan | 14a97ff | 2010-11-04 01:51:38 +0000 | [diff] [blame] | 267 | } |
| 268 | |
| 269 | void |
| 270 | ThreadPlanCallFunction::DoTakedown () |
| 271 | { |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 272 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
| 273 | if (!m_takedown_done) |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 274 | { |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 275 | if (log) |
| 276 | log->Printf ("DoTakedown called for thread 0x%4.4x, m_valid: %d complete: %d.\n", m_thread.GetID(), m_valid, IsPlanComplete()); |
| 277 | m_takedown_done = true; |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 278 | m_thread.RestoreThreadStateFromCheckpoint(m_stored_thread_state); |
| 279 | SetPlanComplete(); |
| 280 | ClearBreakpoints(); |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 281 | if (log && log->GetVerbose()) |
| 282 | ReportRegisterState ("Restoring thread state after function call. Restored register state:"); |
Jim Ingham | 78108e6 | 2011-01-26 19:13:09 +0000 | [diff] [blame] | 283 | |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 284 | } |
| 285 | else |
| 286 | { |
| 287 | if (log) |
| 288 | log->Printf ("DoTakedown called as no-op for thread 0x%4.4x, m_valid: %d complete: %d.\n", m_thread.GetID(), m_valid, IsPlanComplete()); |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 289 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 290 | } |
| 291 | |
| 292 | void |
Jim Ingham | 6c9662e | 2011-01-18 01:58:06 +0000 | [diff] [blame] | 293 | ThreadPlanCallFunction::WillPop () |
| 294 | { |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 295 | DoTakedown(); |
Jim Ingham | 6c9662e | 2011-01-18 01:58:06 +0000 | [diff] [blame] | 296 | } |
| 297 | |
| 298 | void |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 299 | ThreadPlanCallFunction::GetDescription (Stream *s, DescriptionLevel level) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 300 | { |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 301 | if (level == eDescriptionLevelBrief) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 302 | { |
| 303 | s->Printf("Function call thread plan"); |
| 304 | } |
| 305 | else |
| 306 | { |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 307 | s->Printf("Thread plan to call 0x%llx", m_function_addr.GetLoadAddress(&m_process.GetTarget())); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 308 | } |
| 309 | } |
| 310 | |
| 311 | bool |
| 312 | ThreadPlanCallFunction::ValidatePlan (Stream *error) |
| 313 | { |
| 314 | if (!m_valid) |
| 315 | return false; |
| 316 | |
| 317 | return true; |
| 318 | } |
| 319 | |
| 320 | bool |
| 321 | ThreadPlanCallFunction::PlanExplainsStop () |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 322 | { |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 323 | // If our subplan knows why we stopped, even if it's done (which would forward the question to us) |
| 324 | // we answer yes. |
| 325 | if(m_subplan_sp.get() != NULL && m_subplan_sp->PlanExplainsStop()) |
| 326 | return true; |
Sean Callanan | ba8547d | 2010-10-19 22:24:06 +0000 | [diff] [blame] | 327 | |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 328 | // Check if the breakpoint is one of ours. |
| 329 | |
| 330 | if (BreakpointsExplainStop()) |
| 331 | return true; |
| 332 | |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 333 | // If we don't want to discard this plan, than any stop we don't understand should be propagated up the stack. |
| 334 | if (!OkayToDiscard()) |
| 335 | return false; |
| 336 | |
| 337 | // Otherwise, check the case where we stopped for an internal breakpoint, in that case, continue on. |
| 338 | // If it is not an internal breakpoint, consult OkayToDiscard. |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 339 | StopInfoSP stop_info_sp = GetPrivateStopReason(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 340 | |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 341 | if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint) |
| 342 | { |
| 343 | uint64_t break_site_id = stop_info_sp->GetValue(); |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 344 | BreakpointSiteSP bp_site_sp = m_thread.GetProcess().GetBreakpointSiteList().FindByID(break_site_id); |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 345 | if (bp_site_sp) |
| 346 | { |
| 347 | uint32_t num_owners = bp_site_sp->GetNumberOfOwners(); |
| 348 | bool is_internal = true; |
| 349 | for (uint32_t i = 0; i < num_owners; i++) |
| 350 | { |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 351 | Breakpoint &bp = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 352 | |
| 353 | if (!bp.IsInternal()) |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 354 | { |
| 355 | is_internal = false; |
| 356 | break; |
| 357 | } |
| 358 | } |
| 359 | if (is_internal) |
| 360 | return false; |
| 361 | } |
| 362 | |
| 363 | return OkayToDiscard(); |
| 364 | } |
| 365 | else |
| 366 | { |
| 367 | // If the subplan is running, any crashes are attributable to us. |
Jim Ingham | 78108e6 | 2011-01-26 19:13:09 +0000 | [diff] [blame] | 368 | // If we want to discard the plan, then we say we explain the stop |
| 369 | // but if we are going to be discarded, let whoever is above us |
| 370 | // explain the stop. |
| 371 | return ((m_subplan_sp.get() != NULL) && !OkayToDiscard()); |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 372 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | bool |
| 376 | ThreadPlanCallFunction::ShouldStop (Event *event_ptr) |
| 377 | { |
| 378 | if (PlanExplainsStop()) |
| 379 | { |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 380 | ReportRegisterState ("Function completed. Register state was:"); |
Sean Callanan | f5857a0 | 2010-07-31 01:32:05 +0000 | [diff] [blame] | 381 | |
Sean Callanan | 14a97ff | 2010-11-04 01:51:38 +0000 | [diff] [blame] | 382 | DoTakedown(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 383 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 384 | return true; |
| 385 | } |
| 386 | else |
| 387 | { |
| 388 | return false; |
| 389 | } |
| 390 | } |
| 391 | |
| 392 | bool |
| 393 | ThreadPlanCallFunction::StopOthers () |
| 394 | { |
| 395 | return m_stop_other_threads; |
| 396 | } |
| 397 | |
| 398 | void |
| 399 | ThreadPlanCallFunction::SetStopOthers (bool new_value) |
| 400 | { |
| 401 | if (m_subplan_sp) |
| 402 | { |
| 403 | ThreadPlanRunToAddress *address_plan = static_cast<ThreadPlanRunToAddress *>(m_subplan_sp.get()); |
| 404 | address_plan->SetStopOthers(new_value); |
| 405 | } |
| 406 | m_stop_other_threads = new_value; |
| 407 | } |
| 408 | |
| 409 | StateType |
Jim Ingham | 745ac7a | 2010-11-11 19:26:09 +0000 | [diff] [blame] | 410 | ThreadPlanCallFunction::GetPlanRunState () |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 411 | { |
| 412 | return eStateRunning; |
| 413 | } |
| 414 | |
| 415 | void |
| 416 | ThreadPlanCallFunction::DidPush () |
| 417 | { |
Sean Callanan | c2c6f77 | 2010-10-26 00:31:56 +0000 | [diff] [blame] | 418 | //#define SINGLE_STEP_EXPRESSIONS |
| 419 | |
| 420 | #ifndef SINGLE_STEP_EXPRESSIONS |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 421 | m_subplan_sp.reset(new ThreadPlanRunToAddress(m_thread, m_start_addr, m_stop_other_threads)); |
| 422 | |
| 423 | m_thread.QueueThreadPlan(m_subplan_sp, false); |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 424 | m_subplan_sp->SetPrivate (true); |
Sean Callanan | c2c6f77 | 2010-10-26 00:31:56 +0000 | [diff] [blame] | 425 | #endif |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 426 | } |
| 427 | |
| 428 | bool |
| 429 | ThreadPlanCallFunction::WillStop () |
| 430 | { |
| 431 | return true; |
| 432 | } |
| 433 | |
| 434 | bool |
| 435 | ThreadPlanCallFunction::MischiefManaged () |
| 436 | { |
| 437 | if (IsPlanComplete()) |
| 438 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 439 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 440 | |
| 441 | if (log) |
| 442 | log->Printf("Completed call function plan."); |
| 443 | |
| 444 | ThreadPlan::MischiefManaged (); |
| 445 | return true; |
| 446 | } |
| 447 | else |
| 448 | { |
| 449 | return false; |
| 450 | } |
| 451 | } |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 452 | |
| 453 | void |
| 454 | ThreadPlanCallFunction::SetBreakpoints () |
| 455 | { |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 456 | m_cxx_language_runtime = m_process.GetLanguageRuntime(eLanguageTypeC_plus_plus); |
| 457 | m_objc_language_runtime = m_process.GetLanguageRuntime(eLanguageTypeObjC); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 458 | |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 459 | if (m_cxx_language_runtime) |
| 460 | m_cxx_language_runtime->SetExceptionBreakpoints(); |
| 461 | if (m_objc_language_runtime) |
| 462 | m_objc_language_runtime->SetExceptionBreakpoints(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 463 | } |
| 464 | |
| 465 | void |
| 466 | ThreadPlanCallFunction::ClearBreakpoints () |
| 467 | { |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 468 | if (m_cxx_language_runtime) |
| 469 | m_cxx_language_runtime->ClearExceptionBreakpoints(); |
| 470 | if (m_objc_language_runtime) |
| 471 | m_objc_language_runtime->ClearExceptionBreakpoints(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 472 | } |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 473 | |
| 474 | bool |
| 475 | ThreadPlanCallFunction::BreakpointsExplainStop() |
| 476 | { |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame^] | 477 | StopInfoSP stop_info_sp = GetPrivateStopReason(); |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 478 | |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 479 | if (m_cxx_language_runtime && |
| 480 | m_cxx_language_runtime->ExceptionBreakpointsExplainStop(stop_info_sp)) |
| 481 | return true; |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 482 | |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 483 | if (m_objc_language_runtime && |
| 484 | m_objc_language_runtime->ExceptionBreakpointsExplainStop(stop_info_sp)) |
| 485 | return true; |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 486 | |
| 487 | return false; |
| 488 | } |