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" |
Greg Clayton | 49ce896 | 2012-08-29 21:13:06 +0000 | [diff] [blame] | 22 | #include "lldb/Core/Module.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 23 | #include "lldb/Core/Stream.h" |
Greg Clayton | 49ce896 | 2012-08-29 21:13:06 +0000 | [diff] [blame] | 24 | #include "lldb/Symbol/ObjectFile.h" |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 25 | #include "lldb/Target/LanguageRuntime.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 26 | #include "lldb/Target/Process.h" |
| 27 | #include "lldb/Target/RegisterContext.h" |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 28 | #include "lldb/Target/StopInfo.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 29 | #include "lldb/Target/Target.h" |
| 30 | #include "lldb/Target/Thread.h" |
| 31 | #include "lldb/Target/ThreadPlanRunToAddress.h" |
| 32 | |
| 33 | using namespace lldb; |
| 34 | using namespace lldb_private; |
| 35 | |
| 36 | //---------------------------------------------------------------------- |
| 37 | // ThreadPlanCallFunction: Plan to call a single function |
| 38 | //---------------------------------------------------------------------- |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 39 | bool |
| 40 | ThreadPlanCallFunction::ConstructorSetup (Thread &thread, |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 41 | ABI *& abi, |
| 42 | lldb::addr_t &start_load_addr, |
| 43 | lldb::addr_t &function_load_addr) |
| 44 | { |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 45 | SetIsMasterPlan (true); |
Jim Ingham | 110b55f | 2012-05-11 18:43:38 +0000 | [diff] [blame] | 46 | SetOkayToDiscard (false); |
Andrew Kaylor | ae0f59c | 2012-12-07 17:56:31 +0000 | [diff] [blame] | 47 | SetPrivate (true); |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 48 | |
| 49 | ProcessSP process_sp (thread.GetProcess()); |
| 50 | if (!process_sp) |
| 51 | return false; |
| 52 | |
| 53 | abi = process_sp->GetABI().get(); |
| 54 | |
| 55 | if (!abi) |
| 56 | return false; |
| 57 | |
| 58 | TargetSP target_sp (thread.CalculateTarget()); |
| 59 | |
Jim Ingham | a8d26eb | 2012-04-13 23:11:52 +0000 | [diff] [blame] | 60 | LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP)); |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 61 | |
| 62 | SetBreakpoints(); |
| 63 | |
| 64 | m_function_sp = thread.GetRegisterContext()->GetSP() - abi->GetRedZoneSize(); |
| 65 | // If we can't read memory at the point of the process where we are planning to put our function, we're |
| 66 | // not going to get any further... |
| 67 | Error error; |
| 68 | process_sp->ReadUnsignedIntegerFromMemory(m_function_sp, 4, 0, error); |
| 69 | if (!error.Success()) |
| 70 | { |
| 71 | if (log) |
Daniel Malea | 5f35a4b | 2012-11-29 21:49:15 +0000 | [diff] [blame] | 72 | log->Printf ("ThreadPlanCallFunction(%p): Trying to put the stack in unreadable memory at: 0x%" PRIx64 ".", this, m_function_sp); |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 73 | return false; |
| 74 | } |
| 75 | |
| 76 | Module *exe_module = target_sp->GetExecutableModulePointer(); |
| 77 | |
| 78 | if (exe_module == NULL) |
| 79 | { |
| 80 | if (log) |
Jim Ingham | a8d26eb | 2012-04-13 23:11:52 +0000 | [diff] [blame] | 81 | log->Printf ("ThreadPlanCallFunction(%p): Can't execute code without an executable module.", this); |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 82 | return false; |
| 83 | } |
| 84 | else |
| 85 | { |
| 86 | ObjectFile *objectFile = exe_module->GetObjectFile(); |
| 87 | if (!objectFile) |
| 88 | { |
| 89 | if (log) |
Jim Ingham | a8d26eb | 2012-04-13 23:11:52 +0000 | [diff] [blame] | 90 | log->Printf ("ThreadPlanCallFunction(%p): Could not find object file for module \"%s\".", |
| 91 | this, exe_module->GetFileSpec().GetFilename().AsCString()); |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 92 | return false; |
| 93 | } |
| 94 | m_start_addr = objectFile->GetEntryPointAddress(); |
| 95 | if (!m_start_addr.IsValid()) |
| 96 | { |
| 97 | if (log) |
Jim Ingham | a8d26eb | 2012-04-13 23:11:52 +0000 | [diff] [blame] | 98 | log->Printf ("ThreadPlanCallFunction(%p): Could not find entry point address for executable module \"%s\".", |
| 99 | this, exe_module->GetFileSpec().GetFilename().AsCString()); |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 100 | return false; |
| 101 | } |
| 102 | } |
| 103 | |
| 104 | start_load_addr = m_start_addr.GetLoadAddress (target_sp.get()); |
| 105 | |
| 106 | // Checkpoint the thread state so we can restore it later. |
| 107 | if (log && log->GetVerbose()) |
| 108 | ReportRegisterState ("About to checkpoint thread before function call. Original register state was:"); |
| 109 | |
| 110 | if (!thread.CheckpointThreadState (m_stored_thread_state)) |
| 111 | { |
| 112 | if (log) |
Jim Ingham | a8d26eb | 2012-04-13 23:11:52 +0000 | [diff] [blame] | 113 | log->Printf ("ThreadPlanCallFunction(%p): Setting up ThreadPlanCallFunction, failed to checkpoint thread state.", this); |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 114 | return false; |
| 115 | } |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 116 | function_load_addr = m_function_addr.GetLoadAddress (target_sp.get()); |
| 117 | |
| 118 | return true; |
| 119 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 120 | |
| 121 | ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread, |
| 122 | Address &function, |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 123 | const ClangASTType &return_type, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 124 | addr_t arg, |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 125 | bool stop_other_threads, |
Sean Callanan | 3c9c5eb | 2010-09-21 00:44:12 +0000 | [diff] [blame] | 126 | bool discard_on_error, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 127 | addr_t *this_arg, |
| 128 | addr_t *cmd_arg) : |
Jim Ingham | 5a47e8b | 2010-06-19 04:45:32 +0000 | [diff] [blame] | 129 | ThreadPlan (ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion), |
Benjamin Kramer | 36a0810 | 2010-07-16 12:32:33 +0000 | [diff] [blame] | 130 | m_valid (false), |
| 131 | m_stop_other_threads (stop_other_threads), |
Jim Ingham | 574c3d6 | 2011-08-12 23:34:31 +0000 | [diff] [blame] | 132 | m_function_addr (function), |
Filipe Cabecinhas | 5ebd51f | 2012-09-11 18:11:07 +0000 | [diff] [blame] | 133 | m_function_sp (0), |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 134 | m_return_type (return_type), |
Jim Ingham | ba560cc | 2011-11-01 02:46:54 +0000 | [diff] [blame] | 135 | m_takedown_done (false), |
Jim Ingham | 110b55f | 2012-05-11 18:43:38 +0000 | [diff] [blame] | 136 | m_stop_address (LLDB_INVALID_ADDRESS), |
| 137 | m_discard_on_error (discard_on_error) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 138 | { |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 139 | lldb::addr_t start_load_addr; |
| 140 | ABI *abi; |
| 141 | lldb::addr_t function_load_addr; |
Jim Ingham | 110b55f | 2012-05-11 18:43:38 +0000 | [diff] [blame] | 142 | if (!ConstructorSetup (thread, abi, start_load_addr, function_load_addr)) |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 143 | return; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 144 | |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 145 | if (this_arg && cmd_arg) |
| 146 | { |
| 147 | if (!abi->PrepareTrivialCall (thread, |
| 148 | m_function_sp, |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 149 | function_load_addr, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 150 | start_load_addr, |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 151 | this_arg, |
| 152 | cmd_arg, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 153 | &arg)) |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 154 | return; |
| 155 | } |
| 156 | else if (this_arg) |
| 157 | { |
| 158 | if (!abi->PrepareTrivialCall (thread, |
| 159 | m_function_sp, |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 160 | function_load_addr, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 161 | start_load_addr, |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 162 | this_arg, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 163 | &arg)) |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 164 | return; |
| 165 | } |
| 166 | else |
| 167 | { |
| 168 | if (!abi->PrepareTrivialCall (thread, |
| 169 | m_function_sp, |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 170 | function_load_addr, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 171 | start_load_addr, |
| 172 | &arg)) |
| 173 | return; |
| 174 | } |
| 175 | |
| 176 | ReportRegisterState ("Function call was set up. Register state was:"); |
| 177 | |
| 178 | m_valid = true; |
| 179 | } |
| 180 | |
| 181 | |
| 182 | ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread, |
| 183 | Address &function, |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 184 | const ClangASTType &return_type, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 185 | bool stop_other_threads, |
| 186 | bool discard_on_error, |
| 187 | addr_t *arg1_ptr, |
| 188 | addr_t *arg2_ptr, |
| 189 | addr_t *arg3_ptr, |
| 190 | addr_t *arg4_ptr, |
| 191 | addr_t *arg5_ptr, |
| 192 | addr_t *arg6_ptr) : |
| 193 | ThreadPlan (ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion), |
| 194 | m_valid (false), |
| 195 | m_stop_other_threads (stop_other_threads), |
Jim Ingham | 574c3d6 | 2011-08-12 23:34:31 +0000 | [diff] [blame] | 196 | m_function_addr (function), |
Jim Ingham | 76b258d | 2012-11-26 23:52:18 +0000 | [diff] [blame] | 197 | m_function_sp (0), |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 198 | m_return_type (return_type), |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 199 | m_takedown_done (false), |
Jim Ingham | 76b258d | 2012-11-26 23:52:18 +0000 | [diff] [blame] | 200 | m_stop_address (LLDB_INVALID_ADDRESS), |
| 201 | m_discard_on_error (discard_on_error) |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 202 | { |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 203 | lldb::addr_t start_load_addr; |
| 204 | ABI *abi; |
| 205 | lldb::addr_t function_load_addr; |
Jim Ingham | 110b55f | 2012-05-11 18:43:38 +0000 | [diff] [blame] | 206 | if (!ConstructorSetup (thread, abi, start_load_addr, function_load_addr)) |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 207 | return; |
| 208 | |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 209 | if (!abi->PrepareTrivialCall (thread, |
Jim Ingham | 1e58cef | 2012-04-13 20:38:13 +0000 | [diff] [blame] | 210 | m_function_sp, |
| 211 | function_load_addr, |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 212 | start_load_addr, |
| 213 | arg1_ptr, |
| 214 | arg2_ptr, |
| 215 | arg3_ptr, |
| 216 | arg4_ptr, |
| 217 | arg5_ptr, |
| 218 | arg6_ptr)) |
| 219 | { |
Greg Clayton | 61d4f7a | 2011-05-12 02:14:56 +0000 | [diff] [blame] | 220 | return; |
| 221 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 222 | |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 223 | ReportRegisterState ("Function call was set up. Register state was:"); |
| 224 | |
| 225 | m_valid = true; |
| 226 | } |
| 227 | |
| 228 | ThreadPlanCallFunction::~ThreadPlanCallFunction () |
| 229 | { |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 230 | DoTakedown(true); |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 231 | } |
| 232 | |
| 233 | void |
| 234 | ThreadPlanCallFunction::ReportRegisterState (const char *message) |
| 235 | { |
Greg Clayton | 628cead | 2011-05-19 03:54:16 +0000 | [diff] [blame] | 236 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_VERBOSE)); |
Sean Callanan | 6dff827 | 2010-11-08 03:49:50 +0000 | [diff] [blame] | 237 | if (log) |
| 238 | { |
Greg Clayton | 628cead | 2011-05-19 03:54:16 +0000 | [diff] [blame] | 239 | StreamString strm; |
Greg Clayton | 08d7d3a | 2011-01-06 22:15:06 +0000 | [diff] [blame] | 240 | RegisterContext *reg_ctx = m_thread.GetRegisterContext().get(); |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 241 | |
| 242 | log->PutCString(message); |
| 243 | |
Greg Clayton | 628cead | 2011-05-19 03:54:16 +0000 | [diff] [blame] | 244 | RegisterValue reg_value; |
| 245 | |
| 246 | for (uint32_t reg_idx = 0, num_registers = reg_ctx->GetRegisterCount(); |
| 247 | reg_idx < num_registers; |
| 248 | ++reg_idx) |
Sean Callanan | 6dff827 | 2010-11-08 03:49:50 +0000 | [diff] [blame] | 249 | { |
Greg Clayton | 628cead | 2011-05-19 03:54:16 +0000 | [diff] [blame] | 250 | const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx); |
| 251 | if (reg_ctx->ReadRegister(reg_info, reg_value)) |
| 252 | { |
| 253 | reg_value.Dump(&strm, reg_info, true, false, eFormatDefault); |
| 254 | strm.EOL(); |
| 255 | } |
Sean Callanan | 6dff827 | 2010-11-08 03:49:50 +0000 | [diff] [blame] | 256 | } |
Greg Clayton | 628cead | 2011-05-19 03:54:16 +0000 | [diff] [blame] | 257 | log->PutCString(strm.GetData()); |
Sean Callanan | 6dff827 | 2010-11-08 03:49:50 +0000 | [diff] [blame] | 258 | } |
Sean Callanan | 14a97ff | 2010-11-04 01:51:38 +0000 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | void |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 262 | ThreadPlanCallFunction::DoTakedown (bool success) |
Sean Callanan | 14a97ff | 2010-11-04 01:51:38 +0000 | [diff] [blame] | 263 | { |
Jim Ingham | a8d26eb | 2012-04-13 23:11:52 +0000 | [diff] [blame] | 264 | LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP)); |
| 265 | |
| 266 | if (!m_valid) |
| 267 | { |
| 268 | //Don't call DoTakedown if we were never valid to begin with. |
| 269 | if (log) |
| 270 | log->Printf ("ThreadPlanCallFunction(%p): Log called on ThreadPlanCallFunction that was never valid.", this); |
| 271 | return; |
| 272 | } |
| 273 | |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 274 | if (!m_takedown_done) |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 275 | { |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 276 | if (success) |
Greg Clayton | 2f085c6 | 2011-05-15 01:25:55 +0000 | [diff] [blame] | 277 | { |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 278 | ProcessSP process_sp (m_thread.GetProcess()); |
| 279 | const ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; |
| 280 | if (abi && m_return_type.IsValid()) |
| 281 | { |
| 282 | const bool persistent = false; |
| 283 | m_return_valobj_sp = abi->GetReturnValueObject (m_thread, m_return_type, persistent); |
| 284 | } |
Greg Clayton | 2f085c6 | 2011-05-15 01:25:55 +0000 | [diff] [blame] | 285 | } |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 286 | if (log) |
Daniel Malea | 5f35a4b | 2012-11-29 21:49:15 +0000 | [diff] [blame] | 287 | log->Printf ("ThreadPlanCallFunction(%p): DoTakedown called for thread 0x%4.4" PRIx64 ", m_valid: %d complete: %d.\n", this, m_thread.GetID(), m_valid, IsPlanComplete()); |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 288 | m_takedown_done = true; |
Jim Ingham | ba560cc | 2011-11-01 02:46:54 +0000 | [diff] [blame] | 289 | m_stop_address = m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC(); |
Jim Ingham | 2370a97 | 2011-05-17 01:10:11 +0000 | [diff] [blame] | 290 | m_real_stop_info_sp = GetPrivateStopReason(); |
Jim Ingham | 76b258d | 2012-11-26 23:52:18 +0000 | [diff] [blame] | 291 | m_thread.RestoreRegisterStateFromCheckpoint(m_stored_thread_state); |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 292 | SetPlanComplete(success); |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 293 | ClearBreakpoints(); |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 294 | if (log && log->GetVerbose()) |
| 295 | ReportRegisterState ("Restoring thread state after function call. Restored register state:"); |
Jim Ingham | 78108e6 | 2011-01-26 19:13:09 +0000 | [diff] [blame] | 296 | |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 297 | } |
| 298 | else |
| 299 | { |
| 300 | if (log) |
Daniel Malea | 5f35a4b | 2012-11-29 21:49:15 +0000 | [diff] [blame] | 301 | log->Printf ("ThreadPlanCallFunction(%p): DoTakedown called as no-op for thread 0x%4.4" PRIx64 ", m_valid: %d complete: %d.\n", this, m_thread.GetID(), m_valid, IsPlanComplete()); |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 302 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | void |
Jim Ingham | 6c9662e | 2011-01-18 01:58:06 +0000 | [diff] [blame] | 306 | ThreadPlanCallFunction::WillPop () |
| 307 | { |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 308 | DoTakedown(true); |
Jim Ingham | 6c9662e | 2011-01-18 01:58:06 +0000 | [diff] [blame] | 309 | } |
| 310 | |
| 311 | void |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 312 | ThreadPlanCallFunction::GetDescription (Stream *s, DescriptionLevel level) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 313 | { |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 314 | if (level == eDescriptionLevelBrief) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 315 | { |
| 316 | s->Printf("Function call thread plan"); |
| 317 | } |
| 318 | else |
| 319 | { |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 320 | TargetSP target_sp (m_thread.CalculateTarget()); |
Daniel Malea | 5f35a4b | 2012-11-29 21:49:15 +0000 | [diff] [blame] | 321 | s->Printf("Thread plan to call 0x%" PRIx64, m_function_addr.GetLoadAddress(target_sp.get())); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 322 | } |
| 323 | } |
| 324 | |
| 325 | bool |
| 326 | ThreadPlanCallFunction::ValidatePlan (Stream *error) |
| 327 | { |
| 328 | if (!m_valid) |
| 329 | return false; |
| 330 | |
| 331 | return true; |
| 332 | } |
| 333 | |
| 334 | bool |
| 335 | ThreadPlanCallFunction::PlanExplainsStop () |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 336 | { |
Jim Ingham | 2370a97 | 2011-05-17 01:10:11 +0000 | [diff] [blame] | 337 | m_real_stop_info_sp = GetPrivateStopReason(); |
| 338 | |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 339 | // If our subplan knows why we stopped, even if it's done (which would forward the question to us) |
| 340 | // we answer yes. |
Enrico Granata | 4c3fb4b | 2011-07-19 18:03:25 +0000 | [diff] [blame] | 341 | if (m_subplan_sp.get() != NULL && m_subplan_sp->PlanExplainsStop()) |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 342 | return true; |
Sean Callanan | ba8547d | 2010-10-19 22:24:06 +0000 | [diff] [blame] | 343 | |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 344 | // Check if the breakpoint is one of ours. |
| 345 | |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 346 | StopReason stop_reason; |
| 347 | if (!m_real_stop_info_sp) |
| 348 | stop_reason = eStopReasonNone; |
| 349 | else |
| 350 | stop_reason = m_real_stop_info_sp->GetStopReason(); |
| 351 | |
| 352 | if (stop_reason == eStopReasonBreakpoint && BreakpointsExplainStop()) |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 353 | return true; |
| 354 | |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 355 | // If we don't want to discard this plan, than any stop we don't understand should be propagated up the stack. |
Jim Ingham | 110b55f | 2012-05-11 18:43:38 +0000 | [diff] [blame] | 356 | if (!m_discard_on_error) |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 357 | return false; |
| 358 | |
| 359 | // Otherwise, check the case where we stopped for an internal breakpoint, in that case, continue on. |
| 360 | // If it is not an internal breakpoint, consult OkayToDiscard. |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 361 | |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 362 | |
| 363 | if (stop_reason == eStopReasonBreakpoint) |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 364 | { |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 365 | ProcessSP process_sp (m_thread.CalculateProcess()); |
Jim Ingham | 2370a97 | 2011-05-17 01:10:11 +0000 | [diff] [blame] | 366 | uint64_t break_site_id = m_real_stop_info_sp->GetValue(); |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 367 | BreakpointSiteSP bp_site_sp; |
| 368 | if (process_sp) |
| 369 | bp_site_sp = process_sp->GetBreakpointSiteList().FindByID(break_site_id); |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 370 | if (bp_site_sp) |
| 371 | { |
| 372 | uint32_t num_owners = bp_site_sp->GetNumberOfOwners(); |
| 373 | bool is_internal = true; |
| 374 | for (uint32_t i = 0; i < num_owners; i++) |
| 375 | { |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 376 | Breakpoint &bp = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 377 | |
| 378 | if (!bp.IsInternal()) |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 379 | { |
| 380 | is_internal = false; |
| 381 | break; |
| 382 | } |
| 383 | } |
| 384 | if (is_internal) |
| 385 | return false; |
| 386 | } |
| 387 | |
Jim Ingham | 110b55f | 2012-05-11 18:43:38 +0000 | [diff] [blame] | 388 | if (m_discard_on_error) |
| 389 | { |
| 390 | DoTakedown(false); |
| 391 | return true; |
| 392 | } |
| 393 | else |
| 394 | return false; |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 395 | } |
| 396 | else |
| 397 | { |
| 398 | // If the subplan is running, any crashes are attributable to us. |
Jim Ingham | 78108e6 | 2011-01-26 19:13:09 +0000 | [diff] [blame] | 399 | // If we want to discard the plan, then we say we explain the stop |
| 400 | // but if we are going to be discarded, let whoever is above us |
| 401 | // explain the stop. |
Sean Callanan | b386d82 | 2012-08-09 00:50:26 +0000 | [diff] [blame] | 402 | if (m_subplan_sp) |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 403 | { |
Jim Ingham | 110b55f | 2012-05-11 18:43:38 +0000 | [diff] [blame] | 404 | if (m_discard_on_error) |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 405 | { |
| 406 | DoTakedown(false); |
| 407 | return true; |
| 408 | } |
| 409 | else |
| 410 | return false; |
| 411 | } |
| 412 | else |
| 413 | return false; |
Jim Ingham | 988ddbc | 2010-10-26 00:27:45 +0000 | [diff] [blame] | 414 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 415 | } |
| 416 | |
| 417 | bool |
| 418 | ThreadPlanCallFunction::ShouldStop (Event *event_ptr) |
| 419 | { |
Jim Ingham | d82bc6d | 2012-05-11 23:47:32 +0000 | [diff] [blame] | 420 | if (IsPlanComplete() || PlanExplainsStop()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 421 | { |
Jim Ingham | 2f6267f | 2011-01-22 01:27:23 +0000 | [diff] [blame] | 422 | ReportRegisterState ("Function completed. Register state was:"); |
Sean Callanan | f5857a0 | 2010-07-31 01:32:05 +0000 | [diff] [blame] | 423 | |
Jim Ingham | 038fa8e | 2012-05-10 01:35:39 +0000 | [diff] [blame] | 424 | DoTakedown(true); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 425 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 426 | return true; |
| 427 | } |
| 428 | else |
| 429 | { |
| 430 | return false; |
| 431 | } |
| 432 | } |
| 433 | |
| 434 | bool |
| 435 | ThreadPlanCallFunction::StopOthers () |
| 436 | { |
| 437 | return m_stop_other_threads; |
| 438 | } |
| 439 | |
| 440 | void |
| 441 | ThreadPlanCallFunction::SetStopOthers (bool new_value) |
| 442 | { |
| 443 | if (m_subplan_sp) |
| 444 | { |
| 445 | ThreadPlanRunToAddress *address_plan = static_cast<ThreadPlanRunToAddress *>(m_subplan_sp.get()); |
| 446 | address_plan->SetStopOthers(new_value); |
| 447 | } |
| 448 | m_stop_other_threads = new_value; |
| 449 | } |
| 450 | |
| 451 | StateType |
Jim Ingham | 745ac7a | 2010-11-11 19:26:09 +0000 | [diff] [blame] | 452 | ThreadPlanCallFunction::GetPlanRunState () |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 453 | { |
| 454 | return eStateRunning; |
| 455 | } |
| 456 | |
| 457 | void |
| 458 | ThreadPlanCallFunction::DidPush () |
| 459 | { |
Sean Callanan | c2c6f77 | 2010-10-26 00:31:56 +0000 | [diff] [blame] | 460 | //#define SINGLE_STEP_EXPRESSIONS |
| 461 | |
Jim Ingham | 76b258d | 2012-11-26 23:52:18 +0000 | [diff] [blame] | 462 | // Now set the thread state to "no reason" so we don't run with whatever signal was outstanding... |
| 463 | // Wait till the plan is pushed so we aren't changing the stop info till we're about to run. |
| 464 | |
| 465 | GetThread().SetStopInfoToNothing(); |
| 466 | |
Sean Callanan | c2c6f77 | 2010-10-26 00:31:56 +0000 | [diff] [blame] | 467 | #ifndef SINGLE_STEP_EXPRESSIONS |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 468 | m_subplan_sp.reset(new ThreadPlanRunToAddress(m_thread, m_start_addr, m_stop_other_threads)); |
| 469 | |
| 470 | m_thread.QueueThreadPlan(m_subplan_sp, false); |
Jim Ingham | 15dcb7c | 2011-01-20 02:03:18 +0000 | [diff] [blame] | 471 | m_subplan_sp->SetPrivate (true); |
Sean Callanan | c2c6f77 | 2010-10-26 00:31:56 +0000 | [diff] [blame] | 472 | #endif |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 473 | } |
| 474 | |
| 475 | bool |
| 476 | ThreadPlanCallFunction::WillStop () |
| 477 | { |
| 478 | return true; |
| 479 | } |
| 480 | |
| 481 | bool |
| 482 | ThreadPlanCallFunction::MischiefManaged () |
| 483 | { |
| 484 | if (IsPlanComplete()) |
| 485 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 486 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 487 | |
| 488 | if (log) |
Jim Ingham | a8d26eb | 2012-04-13 23:11:52 +0000 | [diff] [blame] | 489 | log->Printf("ThreadPlanCallFunction(%p): Completed call function plan.", this); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 490 | |
| 491 | ThreadPlan::MischiefManaged (); |
| 492 | return true; |
| 493 | } |
| 494 | else |
| 495 | { |
| 496 | return false; |
| 497 | } |
| 498 | } |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 499 | |
| 500 | void |
| 501 | ThreadPlanCallFunction::SetBreakpoints () |
| 502 | { |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 503 | ProcessSP process_sp (m_thread.CalculateProcess()); |
| 504 | if (process_sp) |
| 505 | { |
| 506 | m_cxx_language_runtime = process_sp->GetLanguageRuntime(eLanguageTypeC_plus_plus); |
| 507 | m_objc_language_runtime = process_sp->GetLanguageRuntime(eLanguageTypeObjC); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 508 | |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 509 | if (m_cxx_language_runtime) |
| 510 | m_cxx_language_runtime->SetExceptionBreakpoints(); |
| 511 | if (m_objc_language_runtime) |
| 512 | m_objc_language_runtime->SetExceptionBreakpoints(); |
| 513 | } |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 514 | } |
| 515 | |
| 516 | void |
| 517 | ThreadPlanCallFunction::ClearBreakpoints () |
| 518 | { |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 519 | if (m_cxx_language_runtime) |
| 520 | m_cxx_language_runtime->ClearExceptionBreakpoints(); |
| 521 | if (m_objc_language_runtime) |
| 522 | m_objc_language_runtime->ClearExceptionBreakpoints(); |
Sean Callanan | 07f3d8d | 2010-11-03 01:37:52 +0000 | [diff] [blame] | 523 | } |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 524 | |
| 525 | bool |
| 526 | ThreadPlanCallFunction::BreakpointsExplainStop() |
| 527 | { |
Greg Clayton | 989816b | 2011-05-14 01:50:35 +0000 | [diff] [blame] | 528 | StopInfoSP stop_info_sp = GetPrivateStopReason(); |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 529 | |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 530 | if (m_cxx_language_runtime && |
| 531 | m_cxx_language_runtime->ExceptionBreakpointsExplainStop(stop_info_sp)) |
| 532 | return true; |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 533 | |
Sean Callanan | 29756d4 | 2010-11-03 22:19:38 +0000 | [diff] [blame] | 534 | if (m_objc_language_runtime && |
| 535 | m_objc_language_runtime->ExceptionBreakpointsExplainStop(stop_info_sp)) |
| 536 | return true; |
Sean Callanan | 94fb543 | 2010-11-03 19:36:28 +0000 | [diff] [blame] | 537 | |
| 538 | return false; |
| 539 | } |
Jim Ingham | 76b258d | 2012-11-26 23:52:18 +0000 | [diff] [blame] | 540 | |
| 541 | bool |
| 542 | ThreadPlanCallFunction::RestoreThreadState() |
| 543 | { |
| 544 | return GetThread().RestoreThreadStateFromCheckpoint(m_stored_thread_state); |
| 545 | } |
| 546 | |