blob: 3d917a6f75876cc1428785953a21d40862b8629f [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001//===-- Process.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/Process.h"
11
12#include "lldb/lldb-private-log.h"
13
14#include "lldb/Breakpoint/StoppointCallbackContext.h"
15#include "lldb/Breakpoint/BreakpointLocation.h"
16#include "lldb/Core/Event.h"
Caroline Ticeef5c6d02010-11-16 05:07:41 +000017#include "lldb/Core/ConnectionFileDescriptor.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000018#include "lldb/Core/Debugger.h"
Caroline Ticeef5c6d02010-11-16 05:07:41 +000019#include "lldb/Core/InputReader.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000020#include "lldb/Core/Log.h"
21#include "lldb/Core/PluginManager.h"
22#include "lldb/Core/State.h"
Greg Claytoneb0103f2011-04-07 22:46:35 +000023#include "lldb/Expression/ClangUserExpression.h"
Caroline Tice3df9a8d2010-09-04 00:03:46 +000024#include "lldb/Interpreter/CommandInterpreter.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000025#include "lldb/Host/Host.h"
26#include "lldb/Target/ABI.h"
Greg Clayton8f343b02010-11-04 01:54:29 +000027#include "lldb/Target/DynamicLoader.h"
Greg Clayton56d9a1b2011-08-22 02:49:39 +000028#include "lldb/Target/OperatingSystem.h"
Jim Ingham22777012010-09-23 02:01:19 +000029#include "lldb/Target/LanguageRuntime.h"
30#include "lldb/Target/CPPLanguageRuntime.h"
31#include "lldb/Target/ObjCLanguageRuntime.h"
Greg Claytone996fd32011-03-08 22:40:15 +000032#include "lldb/Target/Platform.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000033#include "lldb/Target/RegisterContext.h"
Greg Claytonf4b47e12010-08-04 01:40:35 +000034#include "lldb/Target/StopInfo.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000035#include "lldb/Target/Target.h"
36#include "lldb/Target/TargetList.h"
37#include "lldb/Target/Thread.h"
38#include "lldb/Target/ThreadPlan.h"
39
40using namespace lldb;
41using namespace lldb_private;
42
Greg Clayton32e0a752011-03-30 18:16:51 +000043void
Greg Clayton8b82f082011-04-12 05:54:46 +000044ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const
Greg Clayton32e0a752011-03-30 18:16:51 +000045{
46 const char *cstr;
Greg Clayton95bf0fd2011-04-01 00:29:43 +000047 if (m_pid != LLDB_INVALID_PROCESS_ID)
48 s.Printf (" pid = %i\n", m_pid);
49
50 if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
51 s.Printf (" parent = %i\n", m_parent_pid);
52
53 if (m_executable)
54 {
55 s.Printf (" name = %s\n", m_executable.GetFilename().GetCString());
56 s.PutCString (" file = ");
57 m_executable.Dump(&s);
58 s.EOL();
59 }
Greg Clayton8b82f082011-04-12 05:54:46 +000060 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +000061 if (argc > 0)
62 {
63 for (uint32_t i=0; i<argc; i++)
64 {
Greg Clayton8b82f082011-04-12 05:54:46 +000065 const char *arg = m_arguments.GetArgumentAtIndex(i);
Greg Clayton95bf0fd2011-04-01 00:29:43 +000066 if (i < 10)
Greg Clayton8b82f082011-04-12 05:54:46 +000067 s.Printf (" arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +000068 else
Greg Clayton8b82f082011-04-12 05:54:46 +000069 s.Printf ("arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +000070 }
71 }
Greg Clayton8b82f082011-04-12 05:54:46 +000072
73 const uint32_t envc = m_environment.GetArgumentCount();
74 if (envc > 0)
75 {
76 for (uint32_t i=0; i<envc; i++)
77 {
78 const char *env = m_environment.GetArgumentAtIndex(i);
79 if (i < 10)
80 s.Printf (" env[%u] = %s\n", i, env);
81 else
82 s.Printf ("env[%u] = %s\n", i, env);
83 }
84 }
85
Greg Clayton95bf0fd2011-04-01 00:29:43 +000086 if (m_arch.IsValid())
87 s.Printf (" arch = %s\n", m_arch.GetTriple().str().c_str());
88
Greg Clayton8b82f082011-04-12 05:54:46 +000089 if (m_uid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +000090 {
Greg Clayton8b82f082011-04-12 05:54:46 +000091 cstr = platform->GetUserName (m_uid);
92 s.Printf (" uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +000093 }
Greg Clayton8b82f082011-04-12 05:54:46 +000094 if (m_gid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +000095 {
Greg Clayton8b82f082011-04-12 05:54:46 +000096 cstr = platform->GetGroupName (m_gid);
97 s.Printf (" gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +000098 }
Greg Clayton8b82f082011-04-12 05:54:46 +000099 if (m_euid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000100 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000101 cstr = platform->GetUserName (m_euid);
102 s.Printf (" euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000103 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000104 if (m_egid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000105 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000106 cstr = platform->GetGroupName (m_egid);
107 s.Printf (" egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000108 }
109}
110
111void
Greg Clayton8b82f082011-04-12 05:54:46 +0000112ProcessInstanceInfo::DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose)
Greg Clayton32e0a752011-03-30 18:16:51 +0000113{
Greg Clayton8b82f082011-04-12 05:54:46 +0000114 const char *label;
115 if (show_args || verbose)
116 label = "ARGUMENTS";
117 else
118 label = "NAME";
119
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000120 if (verbose)
121 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000122 s.Printf ("PID PARENT USER GROUP EFF USER EFF GROUP TRIPLE %s\n", label);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000123 s.PutCString ("====== ====== ========== ========== ========== ========== ======================== ============================\n");
124 }
125 else
126 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000127 s.Printf ("PID PARENT USER ARCH %s\n", label);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000128 s.PutCString ("====== ====== ========== ======= ============================\n");
129 }
Greg Clayton32e0a752011-03-30 18:16:51 +0000130}
131
132void
Greg Clayton8b82f082011-04-12 05:54:46 +0000133ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000134{
135 if (m_pid != LLDB_INVALID_PROCESS_ID)
136 {
137 const char *cstr;
138 s.Printf ("%-6u %-6u ", m_pid, m_parent_pid);
139
Greg Clayton32e0a752011-03-30 18:16:51 +0000140
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000141 if (verbose)
142 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000143 cstr = platform->GetUserName (m_uid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000144 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
145 s.Printf ("%-10s ", cstr);
146 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000147 s.Printf ("%-10u ", m_uid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000148
Greg Clayton8b82f082011-04-12 05:54:46 +0000149 cstr = platform->GetGroupName (m_gid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000150 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
151 s.Printf ("%-10s ", cstr);
152 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000153 s.Printf ("%-10u ", m_gid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000154
Greg Clayton8b82f082011-04-12 05:54:46 +0000155 cstr = platform->GetUserName (m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000156 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
157 s.Printf ("%-10s ", cstr);
158 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000159 s.Printf ("%-10u ", m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000160
Greg Clayton8b82f082011-04-12 05:54:46 +0000161 cstr = platform->GetGroupName (m_egid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000162 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
163 s.Printf ("%-10s ", cstr);
164 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000165 s.Printf ("%-10u ", m_egid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000166 s.Printf ("%-24s ", m_arch.IsValid() ? m_arch.GetTriple().str().c_str() : "");
167 }
168 else
169 {
Jason Molendafd54b362011-09-20 21:44:10 +0000170 s.Printf ("%-10s %-7d %s ",
Greg Clayton8b82f082011-04-12 05:54:46 +0000171 platform->GetUserName (m_euid),
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000172 (int)m_arch.GetTriple().getArchName().size(),
173 m_arch.GetTriple().getArchName().data());
174 }
175
Greg Clayton8b82f082011-04-12 05:54:46 +0000176 if (verbose || show_args)
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000177 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000178 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000179 if (argc > 0)
180 {
181 for (uint32_t i=0; i<argc; i++)
182 {
183 if (i > 0)
184 s.PutChar (' ');
Greg Clayton8b82f082011-04-12 05:54:46 +0000185 s.PutCString (m_arguments.GetArgumentAtIndex(i));
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000186 }
187 }
188 }
189 else
190 {
191 s.PutCString (GetName());
192 }
193
194 s.EOL();
Greg Clayton32e0a752011-03-30 18:16:51 +0000195 }
196}
197
Greg Clayton8b82f082011-04-12 05:54:46 +0000198
199void
Greg Clayton982c9762011-11-03 21:22:33 +0000200ProcessInfo::SetArguments (char const **argv,
201 bool first_arg_is_executable,
202 bool first_arg_is_executable_and_argument)
203{
204 m_arguments.SetArguments (argv);
205
206 // Is the first argument the executable?
207 if (first_arg_is_executable)
208 {
209 const char *first_arg = m_arguments.GetArgumentAtIndex (0);
210 if (first_arg)
211 {
212 // Yes the first argument is an executable, set it as the executable
213 // in the launch options. Don't resolve the file path as the path
214 // could be a remote platform path
215 const bool resolve = false;
216 m_executable.SetFile(first_arg, resolve);
217
218 // If argument zero is an executable and shouldn't be included
219 // in the arguments, remove it from the front of the arguments
220 if (first_arg_is_executable_and_argument == false)
221 m_arguments.DeleteArgumentAtIndex (0);
222 }
223 }
224}
225void
226ProcessInfo::SetArguments (const Args& args,
227 bool first_arg_is_executable,
228 bool first_arg_is_executable_and_argument)
Greg Clayton8b82f082011-04-12 05:54:46 +0000229{
230 // Copy all arguments
231 m_arguments = args;
232
233 // Is the first argument the executable?
234 if (first_arg_is_executable)
235 {
Greg Clayton982c9762011-11-03 21:22:33 +0000236 const char *first_arg = m_arguments.GetArgumentAtIndex (0);
Greg Clayton8b82f082011-04-12 05:54:46 +0000237 if (first_arg)
238 {
239 // Yes the first argument is an executable, set it as the executable
240 // in the launch options. Don't resolve the file path as the path
241 // could be a remote platform path
242 const bool resolve = false;
243 m_executable.SetFile(first_arg, resolve);
244
245 // If argument zero is an executable and shouldn't be included
246 // in the arguments, remove it from the front of the arguments
247 if (first_arg_is_executable_and_argument == false)
248 m_arguments.DeleteArgumentAtIndex (0);
249 }
250 }
251}
252
Greg Clayton1d885962011-11-08 02:43:13 +0000253void
Greg Clayton144f3a92011-11-15 03:53:30 +0000254ProcessLaunchInfo::FinalizeFileActions (Target *target)
Greg Clayton1d885962011-11-08 02:43:13 +0000255{
256 // If notthing was specified, then check the process for any default
257 // settings that were set with "settings set"
258 if (m_file_actions.empty())
259 {
260 const char *path;
261 if (m_flags.Test(eLaunchFlagDisableSTDIO))
262 {
263 AppendSuppressFileAction (STDERR_FILENO, true , true );
264 AppendSuppressFileAction (STDIN_FILENO , true , false);
265 AppendSuppressFileAction (STDOUT_FILENO, false, true );
266 }
267 else
268 {
269 // Check for any values that might have gotten set with any of:
270 // (lldb) settings set target.input-path
271 // (lldb) settings set target.output-path
272 // (lldb) settings set target.error-path
273 if (target)
274 {
275 path = target->GetStandardErrorPath();
276 if (path)
277 {
278 const bool read = true;
279 const bool write = true;
280 AppendOpenFileAction(STDERR_FILENO, path, read, write);
281 }
282 path = target->GetStandardInputPath();
283 if (path)
284 {
285 const bool read = true;
286 const bool write = false;
287 AppendOpenFileAction(STDIN_FILENO, path, read, write);
288 }
289
290 path = target->GetStandardOutputPath();
291 if (path)
292 {
293 const bool read = false;
294 const bool write = true;
295 AppendOpenFileAction(STDOUT_FILENO, path, read, write);
296 }
297 }
298
299 // If we still don't have any actions...
300 if (m_file_actions.empty())
301 {
302 }
303 }
304 }
305}
306
Greg Clayton144f3a92011-11-15 03:53:30 +0000307
308bool
309ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell (Error &error, bool localhost)
310{
311 error.Clear();
312
313 if (GetFlags().Test (eLaunchFlagLaunchInShell))
314 {
315 const char *shell_executable = GetShell();
316 if (shell_executable)
317 {
318 char shell_resolved_path[PATH_MAX];
319
320 if (localhost)
321 {
322 FileSpec shell_filespec (shell_executable, true);
323
324 if (!shell_filespec.Exists())
325 {
326 // Resolve the path in case we just got "bash", "sh" or "tcsh"
327 if (!shell_filespec.ResolveExecutableLocation ())
328 {
329 error.SetErrorStringWithFormat("invalid shell path '%s'", shell_executable);
330 return false;
331 }
332 }
333 shell_filespec.GetPath (shell_resolved_path, sizeof(shell_resolved_path));
334 shell_executable = shell_resolved_path;
335 }
336
337 Args shell_arguments;
338 std::string safe_arg;
339 shell_arguments.AppendArgument (shell_executable);
340 StreamString shell_command;
341 shell_arguments.AppendArgument ("-c");
342 shell_command.PutCString ("exec");
343 if (GetArchitecture().IsValid())
344 {
345 shell_command.Printf(" /usr/bin/arch -arch %s", GetArchitecture().GetArchitectureName());
346 // Set the resume count to 2:
347 // 1 - stop in shell
348 // 2 - stop in /usr/bin/arch
349 // 3 - then we will stop in our program
350 SetResumeCount(2);
351 }
352 else
353 {
354 // Set the resume count to 1:
355 // 1 - stop in shell
356 // 2 - then we will stop in our program
357 SetResumeCount(1);
358 }
359
360 const char **argv = GetArguments().GetConstArgumentVector ();
361 if (argv)
362 {
363 for (size_t i=0; argv[i] != NULL; ++i)
364 {
365 const char *arg = Args::GetShellSafeArgument (argv[i], safe_arg);
366 shell_command.Printf(" %s", arg);
367 }
368 }
369 shell_arguments.AppendArgument (shell_command.GetString().c_str());
370
371 m_executable.SetFile(shell_executable, false);
372 m_arguments = shell_arguments;
373 return true;
374 }
375 else
376 {
377 error.SetErrorString ("invalid shell path");
378 }
379 }
380 else
381 {
382 error.SetErrorString ("not launching in shell");
383 }
384 return false;
385}
386
387
Greg Clayton32e0a752011-03-30 18:16:51 +0000388bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000389ProcessLaunchInfo::FileAction::Open (int fd, const char *path, bool read, bool write)
390{
391 if ((read || write) && fd >= 0 && path && path[0])
392 {
393 m_action = eFileActionOpen;
394 m_fd = fd;
395 if (read && write)
Greg Clayton144f3a92011-11-15 03:53:30 +0000396 m_arg = O_NOCTTY | O_CREAT | O_RDWR;
Greg Clayton8b82f082011-04-12 05:54:46 +0000397 else if (read)
Greg Clayton144f3a92011-11-15 03:53:30 +0000398 m_arg = O_NOCTTY | O_RDONLY;
Greg Clayton8b82f082011-04-12 05:54:46 +0000399 else
Greg Clayton144f3a92011-11-15 03:53:30 +0000400 m_arg = O_NOCTTY | O_CREAT | O_WRONLY;
Greg Clayton8b82f082011-04-12 05:54:46 +0000401 m_path.assign (path);
402 return true;
403 }
404 else
405 {
406 Clear();
407 }
408 return false;
409}
410
411bool
412ProcessLaunchInfo::FileAction::Close (int fd)
413{
414 Clear();
415 if (fd >= 0)
416 {
417 m_action = eFileActionClose;
418 m_fd = fd;
419 }
420 return m_fd >= 0;
421}
422
423
424bool
425ProcessLaunchInfo::FileAction::Duplicate (int fd, int dup_fd)
426{
427 Clear();
428 if (fd >= 0 && dup_fd >= 0)
429 {
430 m_action = eFileActionDuplicate;
431 m_fd = fd;
432 m_arg = dup_fd;
433 }
434 return m_fd >= 0;
435}
436
437
438
439bool
440ProcessLaunchInfo::FileAction::AddPosixSpawnFileAction (posix_spawn_file_actions_t *file_actions,
441 const FileAction *info,
442 Log *log,
443 Error& error)
444{
445 if (info == NULL)
446 return false;
447
448 switch (info->m_action)
449 {
450 case eFileActionNone:
451 error.Clear();
452 break;
453
454 case eFileActionClose:
455 if (info->m_fd == -1)
456 error.SetErrorString ("invalid fd for posix_spawn_file_actions_addclose(...)");
457 else
458 {
459 error.SetError (::posix_spawn_file_actions_addclose (file_actions, info->m_fd),
460 eErrorTypePOSIX);
461 if (log && (error.Fail() || log))
462 error.PutToLog(log, "posix_spawn_file_actions_addclose (action=%p, fd=%i)",
463 file_actions, info->m_fd);
464 }
465 break;
466
467 case eFileActionDuplicate:
468 if (info->m_fd == -1)
469 error.SetErrorString ("invalid fd for posix_spawn_file_actions_adddup2(...)");
470 else if (info->m_arg == -1)
471 error.SetErrorString ("invalid duplicate fd for posix_spawn_file_actions_adddup2(...)");
472 else
473 {
474 error.SetError (::posix_spawn_file_actions_adddup2 (file_actions, info->m_fd, info->m_arg),
475 eErrorTypePOSIX);
476 if (log && (error.Fail() || log))
477 error.PutToLog(log, "posix_spawn_file_actions_adddup2 (action=%p, fd=%i, dup_fd=%i)",
478 file_actions, info->m_fd, info->m_arg);
479 }
480 break;
481
482 case eFileActionOpen:
483 if (info->m_fd == -1)
484 error.SetErrorString ("invalid fd in posix_spawn_file_actions_addopen(...)");
485 else
486 {
487 int oflag = info->m_arg;
Greg Clayton144f3a92011-11-15 03:53:30 +0000488
Greg Clayton8b82f082011-04-12 05:54:46 +0000489 mode_t mode = 0;
490
Greg Clayton144f3a92011-11-15 03:53:30 +0000491 if (oflag & O_CREAT)
492 mode = 0640;
493
Greg Clayton8b82f082011-04-12 05:54:46 +0000494 error.SetError (::posix_spawn_file_actions_addopen (file_actions,
495 info->m_fd,
496 info->m_path.c_str(),
497 oflag,
498 mode),
499 eErrorTypePOSIX);
500 if (error.Fail() || log)
501 error.PutToLog(log,
502 "posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)",
503 file_actions, info->m_fd, info->m_path.c_str(), oflag, mode);
504 }
505 break;
506
507 default:
508 error.SetErrorStringWithFormat ("invalid file action: %i", info->m_action);
509 break;
510 }
511 return error.Success();
512}
513
514Error
Greg Claytonf6b8b582011-04-13 00:18:08 +0000515ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
Greg Clayton8b82f082011-04-12 05:54:46 +0000516{
517 Error error;
518 char short_option = (char) m_getopt_table[option_idx].val;
519
520 switch (short_option)
521 {
522 case 's': // Stop at program entry point
523 launch_info.GetFlags().Set (eLaunchFlagStopAtEntry);
524 break;
525
526 case 'e': // STDERR for read + write
527 {
528 ProcessLaunchInfo::FileAction action;
529 if (action.Open(STDERR_FILENO, option_arg, true, true))
530 launch_info.AppendFileAction (action);
531 }
532 break;
533
534 case 'i': // STDIN for read only
535 {
536 ProcessLaunchInfo::FileAction action;
537 if (action.Open(STDIN_FILENO, option_arg, true, false))
538 launch_info.AppendFileAction (action);
539 }
540 break;
541
542 case 'o': // Open STDOUT for write only
543 {
544 ProcessLaunchInfo::FileAction action;
545 if (action.Open(STDOUT_FILENO, option_arg, false, true))
546 launch_info.AppendFileAction (action);
547 }
548 break;
549
550 case 'p': // Process plug-in name
551 launch_info.SetProcessPluginName (option_arg);
552 break;
553
554 case 'n': // Disable STDIO
555 {
556 ProcessLaunchInfo::FileAction action;
557 if (action.Open(STDERR_FILENO, "/dev/null", true, true))
558 launch_info.AppendFileAction (action);
559 if (action.Open(STDOUT_FILENO, "/dev/null", false, true))
560 launch_info.AppendFileAction (action);
561 if (action.Open(STDIN_FILENO, "/dev/null", true, false))
562 launch_info.AppendFileAction (action);
563 }
564 break;
565
566 case 'w':
567 launch_info.SetWorkingDirectory (option_arg);
568 break;
569
570 case 't': // Open process in new terminal window
571 launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
572 break;
573
574 case 'a':
575 launch_info.GetArchitecture().SetTriple (option_arg,
576 m_interpreter.GetPlatform(true).get());
577 break;
578
579 case 'A':
580 launch_info.GetFlags().Set (eLaunchFlagDisableASLR);
581 break;
582
Greg Clayton982c9762011-11-03 21:22:33 +0000583 case 'c':
Greg Clayton144f3a92011-11-15 03:53:30 +0000584 if (option_arg && option_arg[0])
585 launch_info.SetShell (option_arg);
586 else
587 launch_info.SetShell ("/bin/bash");
Greg Clayton982c9762011-11-03 21:22:33 +0000588 break;
589
Greg Clayton8b82f082011-04-12 05:54:46 +0000590 case 'v':
591 launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
592 break;
593
594 default:
Greg Clayton86edbf42011-10-26 00:56:27 +0000595 error.SetErrorStringWithFormat("unrecognized short option character '%c'", short_option);
Greg Clayton8b82f082011-04-12 05:54:46 +0000596 break;
597
598 }
599 return error;
600}
601
602OptionDefinition
603ProcessLaunchCommandOptions::g_option_table[] =
604{
605{ LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', no_argument, NULL, 0, eArgTypeNone, "Stop at the entry point of the program when launching a process."},
606{ LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', no_argument, NULL, 0, eArgTypeNone, "Disable address space layout randomization when launching a process."},
607{ LLDB_OPT_SET_ALL, false, "plugin", 'p', required_argument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
608{ LLDB_OPT_SET_ALL, false, "working-dir", 'w', required_argument, NULL, 0, eArgTypePath, "Set the current working directory to <path> when running the inferior."},
609{ LLDB_OPT_SET_ALL, false, "arch", 'a', required_argument, NULL, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous."},
610{ LLDB_OPT_SET_ALL, false, "environment", 'v', required_argument, NULL, 0, eArgTypeNone, "Specify an environment variable name/value stirng (--environement NAME=VALUE). Can be specified multiple times for subsequent environment entries."},
Greg Clayton144f3a92011-11-15 03:53:30 +0000611{ LLDB_OPT_SET_ALL, false, "shell", 'c', optional_argument, NULL, 0, eArgTypePath, "Run the process in a shell (not supported on all platforms)."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000612
613{ LLDB_OPT_SET_1 , false, "stdin", 'i', required_argument, NULL, 0, eArgTypePath, "Redirect stdin for the process to <path>."},
614{ LLDB_OPT_SET_1 , false, "stdout", 'o', required_argument, NULL, 0, eArgTypePath, "Redirect stdout for the process to <path>."},
615{ LLDB_OPT_SET_1 , false, "stderr", 'e', required_argument, NULL, 0, eArgTypePath, "Redirect stderr for the process to <path>."},
616
617{ LLDB_OPT_SET_2 , false, "tty", 't', no_argument, NULL, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)."},
618
619{ LLDB_OPT_SET_3 , false, "no-stdio", 'n', no_argument, NULL, 0, eArgTypeNone, "Do not set up for terminal I/O to go to running process."},
620
621{ 0 , false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
622};
623
624
625
626bool
627ProcessInstanceInfoMatch::NameMatches (const char *process_name) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000628{
629 if (m_name_match_type == eNameMatchIgnore || process_name == NULL)
630 return true;
631 const char *match_name = m_match_info.GetName();
632 if (!match_name)
633 return true;
634
635 return lldb_private::NameMatches (process_name, m_name_match_type, match_name);
636}
637
638bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000639ProcessInstanceInfoMatch::Matches (const ProcessInstanceInfo &proc_info) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000640{
641 if (!NameMatches (proc_info.GetName()))
642 return false;
643
644 if (m_match_info.ProcessIDIsValid() &&
645 m_match_info.GetProcessID() != proc_info.GetProcessID())
646 return false;
647
648 if (m_match_info.ParentProcessIDIsValid() &&
649 m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
650 return false;
651
Greg Clayton8b82f082011-04-12 05:54:46 +0000652 if (m_match_info.UserIDIsValid () &&
653 m_match_info.GetUserID() != proc_info.GetUserID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000654 return false;
655
Greg Clayton8b82f082011-04-12 05:54:46 +0000656 if (m_match_info.GroupIDIsValid () &&
657 m_match_info.GetGroupID() != proc_info.GetGroupID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000658 return false;
659
660 if (m_match_info.EffectiveUserIDIsValid () &&
661 m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
662 return false;
663
664 if (m_match_info.EffectiveGroupIDIsValid () &&
665 m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
666 return false;
667
668 if (m_match_info.GetArchitecture().IsValid() &&
669 m_match_info.GetArchitecture() != proc_info.GetArchitecture())
670 return false;
671 return true;
672}
673
674bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000675ProcessInstanceInfoMatch::MatchAllProcesses () const
Greg Clayton32e0a752011-03-30 18:16:51 +0000676{
677 if (m_name_match_type != eNameMatchIgnore)
678 return false;
679
680 if (m_match_info.ProcessIDIsValid())
681 return false;
682
683 if (m_match_info.ParentProcessIDIsValid())
684 return false;
685
Greg Clayton8b82f082011-04-12 05:54:46 +0000686 if (m_match_info.UserIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000687 return false;
688
Greg Clayton8b82f082011-04-12 05:54:46 +0000689 if (m_match_info.GroupIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000690 return false;
691
692 if (m_match_info.EffectiveUserIDIsValid ())
693 return false;
694
695 if (m_match_info.EffectiveGroupIDIsValid ())
696 return false;
697
698 if (m_match_info.GetArchitecture().IsValid())
699 return false;
700
701 if (m_match_all_users)
702 return false;
703
704 return true;
705
706}
707
708void
Greg Clayton8b82f082011-04-12 05:54:46 +0000709ProcessInstanceInfoMatch::Clear()
Greg Clayton32e0a752011-03-30 18:16:51 +0000710{
711 m_match_info.Clear();
712 m_name_match_type = eNameMatchIgnore;
713 m_match_all_users = false;
714}
Greg Clayton58be07b2011-01-07 06:08:19 +0000715
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000716Process*
717Process::FindPlugin (Target &target, const char *plugin_name, Listener &listener)
718{
719 ProcessCreateInstance create_callback = NULL;
720 if (plugin_name)
721 {
722 create_callback = PluginManager::GetProcessCreateCallbackForPluginName (plugin_name);
723 if (create_callback)
724 {
725 std::auto_ptr<Process> debugger_ap(create_callback(target, listener));
Greg Clayton3a29bdb2011-07-17 20:36:25 +0000726 if (debugger_ap->CanDebug(target, true))
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000727 return debugger_ap.release();
728 }
729 }
730 else
731 {
Greg Claytonc982c762010-07-09 20:39:50 +0000732 for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000733 {
Greg Claytonc982c762010-07-09 20:39:50 +0000734 std::auto_ptr<Process> debugger_ap(create_callback(target, listener));
Greg Clayton3a29bdb2011-07-17 20:36:25 +0000735 if (debugger_ap->CanDebug(target, false))
Greg Claytonc982c762010-07-09 20:39:50 +0000736 return debugger_ap.release();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000737 }
738 }
739 return NULL;
740}
741
742
743//----------------------------------------------------------------------
744// Process constructor
745//----------------------------------------------------------------------
746Process::Process(Target &target, Listener &listener) :
747 UserID (LLDB_INVALID_PROCESS_ID),
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000748 Broadcaster ("lldb.process"),
Greg Claytondbe54502010-11-19 03:46:01 +0000749 ProcessInstanceSettings (*GetSettingsController()),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000750 m_target (target),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000751 m_public_state (eStateUnloaded),
752 m_private_state (eStateUnloaded),
753 m_private_state_broadcaster ("lldb.process.internal_state_broadcaster"),
754 m_private_state_control_broadcaster ("lldb.process.internal_state_control_broadcaster"),
755 m_private_state_listener ("lldb.process.internal_state_listener"),
756 m_private_state_control_wait(),
757 m_private_state_thread (LLDB_INVALID_HOST_THREAD),
Jim Ingham4b536182011-08-09 02:12:22 +0000758 m_mod_id (),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000759 m_thread_index_id (0),
760 m_exit_status (-1),
761 m_exit_string (),
762 m_thread_list (this),
763 m_notifications (),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000764 m_image_tokens (),
765 m_listener (listener),
766 m_breakpoint_site_list (),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000767 m_dynamic_checkers_ap (),
Caroline Ticeef5c6d02010-11-16 05:07:41 +0000768 m_unix_signals (),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000769 m_abi_sp (),
Caroline Ticeef5c6d02010-11-16 05:07:41 +0000770 m_process_input_reader (),
Greg Clayton3e06bd92011-01-09 21:07:35 +0000771 m_stdio_communication ("process.stdio"),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000772 m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
Greg Clayton58be07b2011-01-07 06:08:19 +0000773 m_stdout_data (),
Greg Clayton93e86192011-11-13 04:45:22 +0000774 m_stderr_data (),
Greg Claytond495c532011-05-17 03:37:42 +0000775 m_memory_cache (*this),
776 m_allocated_memory_cache (*this),
Jim Ingham8314c522011-09-15 21:36:42 +0000777 m_attached_to_process (false),
Sean Callanan90539452011-09-20 23:01:51 +0000778 m_next_event_action_ap(),
779 m_can_jit(eCanJITYes)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000780{
Caroline Tice1559a462010-09-27 00:30:10 +0000781 UpdateInstanceName();
782
Greg Clayton2d4edfb2010-11-06 01:53:30 +0000783 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000784 if (log)
785 log->Printf ("%p Process::Process()", this);
786
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000787 SetEventName (eBroadcastBitStateChanged, "state-changed");
788 SetEventName (eBroadcastBitInterrupt, "interrupt");
789 SetEventName (eBroadcastBitSTDOUT, "stdout-available");
790 SetEventName (eBroadcastBitSTDERR, "stderr-available");
791
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000792 listener.StartListeningForEvents (this,
793 eBroadcastBitStateChanged |
794 eBroadcastBitInterrupt |
795 eBroadcastBitSTDOUT |
796 eBroadcastBitSTDERR);
797
798 m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster,
799 eBroadcastBitStateChanged);
800
801 m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster,
802 eBroadcastInternalStateControlStop |
803 eBroadcastInternalStateControlPause |
804 eBroadcastInternalStateControlResume);
805}
806
807//----------------------------------------------------------------------
808// Destructor
809//----------------------------------------------------------------------
810Process::~Process()
811{
Greg Clayton2d4edfb2010-11-06 01:53:30 +0000812 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000813 if (log)
814 log->Printf ("%p Process::~Process()", this);
815 StopPrivateStateThread();
816}
817
818void
819Process::Finalize()
820{
Greg Clayton1ed54f52011-10-01 00:45:15 +0000821 // Clear our broadcaster before we proceed with destroying
822 Broadcaster::Clear();
823
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000824 // Do any cleanup needed prior to being destructed... Subclasses
825 // that override this method should call this superclass method as well.
Jim Inghamd0a3e122011-02-16 17:54:55 +0000826
827 // We need to destroy the loader before the derived Process class gets destroyed
828 // since it is very likely that undoing the loader will require access to the real process.
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000829 m_dyld_ap.reset();
830 m_os_ap.reset();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000831}
832
833void
834Process::RegisterNotificationCallbacks (const Notifications& callbacks)
835{
836 m_notifications.push_back(callbacks);
837 if (callbacks.initialize != NULL)
838 callbacks.initialize (callbacks.baton, this);
839}
840
841bool
842Process::UnregisterNotificationCallbacks(const Notifications& callbacks)
843{
844 std::vector<Notifications>::iterator pos, end = m_notifications.end();
845 for (pos = m_notifications.begin(); pos != end; ++pos)
846 {
847 if (pos->baton == callbacks.baton &&
848 pos->initialize == callbacks.initialize &&
849 pos->process_state_changed == callbacks.process_state_changed)
850 {
851 m_notifications.erase(pos);
852 return true;
853 }
854 }
855 return false;
856}
857
858void
859Process::SynchronouslyNotifyStateChanged (StateType state)
860{
861 std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end();
862 for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos)
863 {
864 if (notification_pos->process_state_changed)
865 notification_pos->process_state_changed (notification_pos->baton, this, state);
866 }
867}
868
869// FIXME: We need to do some work on events before the general Listener sees them.
870// For instance if we are continuing from a breakpoint, we need to ensure that we do
871// the little "insert real insn, step & stop" trick. But we can't do that when the
872// event is delivered by the broadcaster - since that is done on the thread that is
873// waiting for new events, so if we needed more than one event for our handling, we would
874// stall. So instead we do it when we fetch the event off of the queue.
875//
876
877StateType
878Process::GetNextEvent (EventSP &event_sp)
879{
880 StateType state = eStateInvalid;
881
882 if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp)
883 state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
884
885 return state;
886}
887
888
889StateType
890Process::WaitForProcessToStop (const TimeValue *timeout)
891{
Jim Ingham4b536182011-08-09 02:12:22 +0000892 // We can't just wait for a "stopped" event, because the stopped event may have restarted the target.
893 // We have to actually check each event, and in the case of a stopped event check the restarted flag
894 // on the event.
895 EventSP event_sp;
896 StateType state = GetState();
897 // If we are exited or detached, we won't ever get back to any
898 // other valid state...
899 if (state == eStateDetached || state == eStateExited)
900 return state;
901
902 while (state != eStateInvalid)
903 {
904 state = WaitForStateChangedEvents (timeout, event_sp);
905 switch (state)
906 {
907 case eStateCrashed:
908 case eStateDetached:
909 case eStateExited:
910 case eStateUnloaded:
911 return state;
912 case eStateStopped:
913 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
914 continue;
915 else
916 return state;
917 default:
918 continue;
919 }
920 }
921 return state;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000922}
923
924
925StateType
926Process::WaitForState
927(
928 const TimeValue *timeout,
929 const StateType *match_states, const uint32_t num_match_states
930)
931{
932 EventSP event_sp;
933 uint32_t i;
Greg Clayton05faeb72010-10-07 04:19:01 +0000934 StateType state = GetState();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000935 while (state != eStateInvalid)
936 {
Greg Clayton05faeb72010-10-07 04:19:01 +0000937 // If we are exited or detached, we won't ever get back to any
938 // other valid state...
939 if (state == eStateDetached || state == eStateExited)
940 return state;
941
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000942 state = WaitForStateChangedEvents (timeout, event_sp);
943
944 for (i=0; i<num_match_states; ++i)
945 {
946 if (match_states[i] == state)
947 return state;
948 }
949 }
950 return state;
951}
952
Jim Ingham30f9b212010-10-11 23:53:14 +0000953bool
954Process::HijackProcessEvents (Listener *listener)
955{
956 if (listener != NULL)
957 {
958 return HijackBroadcaster(listener, eBroadcastBitStateChanged);
959 }
960 else
961 return false;
962}
963
964void
965Process::RestoreProcessEvents ()
966{
967 RestoreBroadcaster();
968}
969
Jim Ingham0f16e732011-02-08 05:20:59 +0000970bool
971Process::HijackPrivateProcessEvents (Listener *listener)
972{
973 if (listener != NULL)
974 {
975 return m_private_state_broadcaster.HijackBroadcaster(listener, eBroadcastBitStateChanged);
976 }
977 else
978 return false;
979}
980
981void
982Process::RestorePrivateProcessEvents ()
983{
984 m_private_state_broadcaster.RestoreBroadcaster();
985}
986
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000987StateType
988Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp)
989{
Greg Clayton2d4edfb2010-11-06 01:53:30 +0000990 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000991
992 if (log)
993 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout);
994
995 StateType state = eStateInvalid;
Greg Clayton3fcbed62010-10-19 03:25:40 +0000996 if (m_listener.WaitForEventForBroadcasterWithType (timeout,
997 this,
998 eBroadcastBitStateChanged,
999 event_sp))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001000 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1001
1002 if (log)
1003 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
1004 __FUNCTION__,
1005 timeout,
1006 StateAsCString(state));
1007 return state;
1008}
1009
1010Event *
1011Process::PeekAtStateChangedEvents ()
1012{
Greg Clayton2d4edfb2010-11-06 01:53:30 +00001013 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001014
1015 if (log)
1016 log->Printf ("Process::%s...", __FUNCTION__);
1017
1018 Event *event_ptr;
Greg Clayton3fcbed62010-10-19 03:25:40 +00001019 event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this,
1020 eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001021 if (log)
1022 {
1023 if (event_ptr)
1024 {
1025 log->Printf ("Process::%s (event_ptr) => %s",
1026 __FUNCTION__,
1027 StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr)));
1028 }
1029 else
1030 {
1031 log->Printf ("Process::%s no events found",
1032 __FUNCTION__);
1033 }
1034 }
1035 return event_ptr;
1036}
1037
1038StateType
1039Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp)
1040{
Greg Clayton2d4edfb2010-11-06 01:53:30 +00001041 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001042
1043 if (log)
1044 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout);
1045
1046 StateType state = eStateInvalid;
Greg Clayton6779606a2011-01-22 23:43:18 +00001047 if (m_private_state_listener.WaitForEventForBroadcasterWithType (timeout,
1048 &m_private_state_broadcaster,
1049 eBroadcastBitStateChanged,
1050 event_sp))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001051 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1052
1053 // This is a bit of a hack, but when we wait here we could very well return
1054 // to the command-line, and that could disable the log, which would render the
1055 // log we got above invalid.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001056 if (log)
Greg Clayton6779606a2011-01-22 23:43:18 +00001057 {
1058 if (state == eStateInvalid)
1059 log->Printf ("Process::%s (timeout = %p, event_sp) => TIMEOUT", __FUNCTION__, timeout);
1060 else
1061 log->Printf ("Process::%s (timeout = %p, event_sp) => %s", __FUNCTION__, timeout, StateAsCString(state));
1062 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001063 return state;
1064}
1065
1066bool
1067Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only)
1068{
Greg Clayton2d4edfb2010-11-06 01:53:30 +00001069 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001070
1071 if (log)
1072 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout);
1073
1074 if (control_only)
1075 return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp);
1076 else
1077 return m_private_state_listener.WaitForEvent(timeout, event_sp);
1078}
1079
1080bool
1081Process::IsRunning () const
1082{
1083 return StateIsRunningState (m_public_state.GetValue());
1084}
1085
1086int
1087Process::GetExitStatus ()
1088{
1089 if (m_public_state.GetValue() == eStateExited)
1090 return m_exit_status;
1091 return -1;
1092}
1093
Greg Clayton85851dd2010-12-04 00:10:17 +00001094
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001095const char *
1096Process::GetExitDescription ()
1097{
1098 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
1099 return m_exit_string.c_str();
1100 return NULL;
1101}
1102
Greg Clayton6779606a2011-01-22 23:43:18 +00001103bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001104Process::SetExitStatus (int status, const char *cstr)
1105{
Greg Clayton414f5d32011-01-25 02:58:48 +00001106 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
1107 if (log)
1108 log->Printf("Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1109 status, status,
1110 cstr ? "\"" : "",
1111 cstr ? cstr : "NULL",
1112 cstr ? "\"" : "");
1113
Greg Clayton6779606a2011-01-22 23:43:18 +00001114 // We were already in the exited state
1115 if (m_private_state.GetValue() == eStateExited)
Greg Clayton414f5d32011-01-25 02:58:48 +00001116 {
Greg Clayton385d6032011-01-26 23:47:29 +00001117 if (log)
1118 log->Printf("Process::SetExitStatus () ignoring exit status because state was already set to eStateExited");
Greg Clayton6779606a2011-01-22 23:43:18 +00001119 return false;
Greg Clayton414f5d32011-01-25 02:58:48 +00001120 }
Greg Clayton6779606a2011-01-22 23:43:18 +00001121
1122 m_exit_status = status;
1123 if (cstr)
1124 m_exit_string = cstr;
1125 else
1126 m_exit_string.clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001127
Greg Clayton6779606a2011-01-22 23:43:18 +00001128 DidExit ();
Greg Clayton10177aa2010-12-08 05:08:21 +00001129
Greg Clayton6779606a2011-01-22 23:43:18 +00001130 SetPrivateState (eStateExited);
1131 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001132}
1133
1134// This static callback can be used to watch for local child processes on
1135// the current host. The the child process exits, the process will be
1136// found in the global target list (we want to be completely sure that the
1137// lldb_private::Process doesn't go away before we can deliver the signal.
1138bool
Greg Claytone4e45922011-11-16 05:37:56 +00001139Process::SetProcessExitStatus (void *callback_baton,
1140 lldb::pid_t pid,
1141 bool exited,
1142 int signo, // Zero for no signal
1143 int exit_status // Exit value of process if signal is zero
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001144)
1145{
Greg Claytone4e45922011-11-16 05:37:56 +00001146 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
1147 if (log)
1148 log->Printf ("Process::SetProcessExitStatus (baton=%p, pid=%i, exited=%i, signal=%i, exit_status=%i)\n",
1149 callback_baton,
1150 pid,
1151 exited,
1152 signo,
1153 exit_status);
1154
1155 if (exited)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001156 {
Greg Clayton66111032010-06-23 01:19:29 +00001157 TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001158 if (target_sp)
1159 {
1160 ProcessSP process_sp (target_sp->GetProcessSP());
1161 if (process_sp)
1162 {
1163 const char *signal_cstr = NULL;
1164 if (signo)
1165 signal_cstr = process_sp->GetUnixSignals().GetSignalAsCString (signo);
1166
1167 process_sp->SetExitStatus (exit_status, signal_cstr);
1168 }
1169 }
1170 return true;
1171 }
1172 return false;
1173}
1174
1175
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001176void
1177Process::UpdateThreadListIfNeeded ()
1178{
1179 const uint32_t stop_id = GetStopID();
1180 if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID())
1181 {
Greg Clayton2637f822011-11-17 01:23:07 +00001182 const StateType state = GetPrivateState();
1183 if (StateIsStoppedState (state, true))
1184 {
1185 Mutex::Locker locker (m_thread_list.GetMutex ());
1186 ThreadList new_thread_list(this);
1187 // Always update the thread list with the protocol specific
1188 // thread list
1189 UpdateThreadList (m_thread_list, new_thread_list);
1190 OperatingSystem *os = GetOperatingSystem ();
1191 if (os)
1192 os->UpdateThreadList (m_thread_list, new_thread_list);
1193 m_thread_list.Update (new_thread_list);
1194 m_thread_list.SetStopID (stop_id);
1195 }
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001196 }
1197}
1198
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001199uint32_t
1200Process::GetNextThreadIndexID ()
1201{
1202 return ++m_thread_index_id;
1203}
1204
1205StateType
1206Process::GetState()
1207{
1208 // If any other threads access this we will need a mutex for it
1209 return m_public_state.GetValue ();
1210}
1211
1212void
1213Process::SetPublicState (StateType new_state)
1214{
Greg Clayton414f5d32011-01-25 02:58:48 +00001215 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001216 if (log)
1217 log->Printf("Process::SetPublicState (%s)", StateAsCString(new_state));
1218 m_public_state.SetValue (new_state);
1219}
1220
1221StateType
1222Process::GetPrivateState ()
1223{
1224 return m_private_state.GetValue();
1225}
1226
1227void
1228Process::SetPrivateState (StateType new_state)
1229{
Greg Clayton414f5d32011-01-25 02:58:48 +00001230 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001231 bool state_changed = false;
1232
1233 if (log)
1234 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
1235
1236 Mutex::Locker locker(m_private_state.GetMutex());
1237
1238 const StateType old_state = m_private_state.GetValueNoLock ();
1239 state_changed = old_state != new_state;
1240 if (state_changed)
1241 {
1242 m_private_state.SetValueNoLock (new_state);
Greg Clayton2637f822011-11-17 01:23:07 +00001243 if (StateIsStoppedState(new_state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001244 {
Jim Ingham4b536182011-08-09 02:12:22 +00001245 m_mod_id.BumpStopID();
Greg Clayton58be07b2011-01-07 06:08:19 +00001246 m_memory_cache.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001247 if (log)
Jim Ingham4b536182011-08-09 02:12:22 +00001248 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_mod_id.GetStopID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001249 }
1250 // Use our target to get a shared pointer to ourselves...
1251 m_private_state_broadcaster.BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (GetTarget().GetProcessSP(), new_state));
1252 }
1253 else
1254 {
1255 if (log)
Jason Molendafd54b362011-09-20 21:44:10 +00001256 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001257 }
1258}
1259
Jim Ingham0faa43f2011-11-08 03:00:11 +00001260void
1261Process::SetRunningUserExpression (bool on)
1262{
1263 m_mod_id.SetRunningUserExpression (on);
1264}
1265
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001266addr_t
1267Process::GetImageInfoAddress()
1268{
1269 return LLDB_INVALID_ADDRESS;
1270}
1271
Greg Clayton8f343b02010-11-04 01:54:29 +00001272//----------------------------------------------------------------------
1273// LoadImage
1274//
1275// This function provides a default implementation that works for most
1276// unix variants. Any Process subclasses that need to do shared library
1277// loading differently should override LoadImage and UnloadImage and
1278// do what is needed.
1279//----------------------------------------------------------------------
1280uint32_t
1281Process::LoadImage (const FileSpec &image_spec, Error &error)
1282{
1283 DynamicLoader *loader = GetDynamicLoader();
1284 if (loader)
1285 {
1286 error = loader->CanLoadImage();
1287 if (error.Fail())
1288 return LLDB_INVALID_IMAGE_TOKEN;
1289 }
1290
1291 if (error.Success())
1292 {
1293 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001294
1295 if (thread_sp)
1296 {
1297 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
1298
1299 if (frame_sp)
1300 {
1301 ExecutionContext exe_ctx;
1302 frame_sp->CalculateExecutionContext (exe_ctx);
Jim Ingham399f1ca2010-11-05 19:25:48 +00001303 bool unwind_on_error = true;
Greg Clayton8f343b02010-11-04 01:54:29 +00001304 StreamString expr;
1305 char path[PATH_MAX];
1306 image_spec.GetPath(path, sizeof(path));
1307 expr.Printf("dlopen (\"%s\", 2)", path);
1308 const char *prefix = "extern \"C\" void* dlopen (const char *path, int mode);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001309 lldb::ValueObjectSP result_valobj_sp;
Sean Callananc7b65062011-11-07 23:35:40 +00001310 ClangUserExpression::Evaluate (exe_ctx, eExecutionPolicyAlways, lldb::eLanguageTypeUnknown, unwind_on_error, expr.GetData(), prefix, result_valobj_sp);
Johnny Chene92aa432011-09-09 00:01:43 +00001311 error = result_valobj_sp->GetError();
1312 if (error.Success())
Greg Clayton8f343b02010-11-04 01:54:29 +00001313 {
1314 Scalar scalar;
Jim Ingham6035b672011-03-31 00:19:25 +00001315 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001316 {
1317 addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1318 if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
1319 {
1320 uint32_t image_token = m_image_tokens.size();
1321 m_image_tokens.push_back (image_ptr);
1322 return image_token;
1323 }
1324 }
1325 }
1326 }
1327 }
1328 }
1329 return LLDB_INVALID_IMAGE_TOKEN;
1330}
1331
1332//----------------------------------------------------------------------
1333// UnloadImage
1334//
1335// This function provides a default implementation that works for most
1336// unix variants. Any Process subclasses that need to do shared library
1337// loading differently should override LoadImage and UnloadImage and
1338// do what is needed.
1339//----------------------------------------------------------------------
1340Error
1341Process::UnloadImage (uint32_t image_token)
1342{
1343 Error error;
1344 if (image_token < m_image_tokens.size())
1345 {
1346 const addr_t image_addr = m_image_tokens[image_token];
1347 if (image_addr == LLDB_INVALID_ADDRESS)
1348 {
1349 error.SetErrorString("image already unloaded");
1350 }
1351 else
1352 {
1353 DynamicLoader *loader = GetDynamicLoader();
1354 if (loader)
1355 error = loader->CanLoadImage();
1356
1357 if (error.Success())
1358 {
1359 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001360
1361 if (thread_sp)
1362 {
1363 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
1364
1365 if (frame_sp)
1366 {
1367 ExecutionContext exe_ctx;
1368 frame_sp->CalculateExecutionContext (exe_ctx);
Jim Ingham399f1ca2010-11-05 19:25:48 +00001369 bool unwind_on_error = true;
Greg Clayton8f343b02010-11-04 01:54:29 +00001370 StreamString expr;
1371 expr.Printf("dlclose ((void *)0x%llx)", image_addr);
1372 const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001373 lldb::ValueObjectSP result_valobj_sp;
Sean Callananc7b65062011-11-07 23:35:40 +00001374 ClangUserExpression::Evaluate (exe_ctx, eExecutionPolicyAlways, lldb::eLanguageTypeUnknown, unwind_on_error, expr.GetData(), prefix, result_valobj_sp);
Greg Clayton8f343b02010-11-04 01:54:29 +00001375 if (result_valobj_sp->GetError().Success())
1376 {
1377 Scalar scalar;
Jim Ingham6035b672011-03-31 00:19:25 +00001378 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001379 {
1380 if (scalar.UInt(1))
1381 {
1382 error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData());
1383 }
1384 else
1385 {
1386 m_image_tokens[image_token] = LLDB_INVALID_ADDRESS;
1387 }
1388 }
1389 }
1390 else
1391 {
1392 error = result_valobj_sp->GetError();
1393 }
1394 }
1395 }
1396 }
1397 }
1398 }
1399 else
1400 {
1401 error.SetErrorString("invalid image token");
1402 }
1403 return error;
1404}
1405
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001406const lldb::ABISP &
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001407Process::GetABI()
1408{
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001409 if (!m_abi_sp)
1410 m_abi_sp = ABI::FindPlugin(m_target.GetArchitecture());
1411 return m_abi_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001412}
1413
Jim Ingham22777012010-09-23 02:01:19 +00001414LanguageRuntime *
1415Process::GetLanguageRuntime(lldb::LanguageType language)
1416{
1417 LanguageRuntimeCollection::iterator pos;
1418 pos = m_language_runtimes.find (language);
1419 if (pos == m_language_runtimes.end())
1420 {
1421 lldb::LanguageRuntimeSP runtime(LanguageRuntime::FindPlugin(this, language));
1422
1423 m_language_runtimes[language]
1424 = runtime;
1425 return runtime.get();
1426 }
1427 else
1428 return (*pos).second.get();
1429}
1430
1431CPPLanguageRuntime *
1432Process::GetCPPLanguageRuntime ()
1433{
1434 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus);
1435 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
1436 return static_cast<CPPLanguageRuntime *> (runtime);
1437 return NULL;
1438}
1439
1440ObjCLanguageRuntime *
1441Process::GetObjCLanguageRuntime ()
1442{
1443 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC);
1444 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC)
1445 return static_cast<ObjCLanguageRuntime *> (runtime);
1446 return NULL;
1447}
1448
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001449BreakpointSiteList &
1450Process::GetBreakpointSiteList()
1451{
1452 return m_breakpoint_site_list;
1453}
1454
1455const BreakpointSiteList &
1456Process::GetBreakpointSiteList() const
1457{
1458 return m_breakpoint_site_list;
1459}
1460
1461
1462void
1463Process::DisableAllBreakpointSites ()
1464{
1465 m_breakpoint_site_list.SetEnabledForAll (false);
1466}
1467
1468Error
1469Process::ClearBreakpointSiteByID (lldb::user_id_t break_id)
1470{
1471 Error error (DisableBreakpointSiteByID (break_id));
1472
1473 if (error.Success())
1474 m_breakpoint_site_list.Remove(break_id);
1475
1476 return error;
1477}
1478
1479Error
1480Process::DisableBreakpointSiteByID (lldb::user_id_t break_id)
1481{
1482 Error error;
1483 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1484 if (bp_site_sp)
1485 {
1486 if (bp_site_sp->IsEnabled())
1487 error = DisableBreakpoint (bp_site_sp.get());
1488 }
1489 else
1490 {
Greg Clayton81c22f62011-10-19 18:09:39 +00001491 error.SetErrorStringWithFormat("invalid breakpoint site ID: %llu", break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001492 }
1493
1494 return error;
1495}
1496
1497Error
1498Process::EnableBreakpointSiteByID (lldb::user_id_t break_id)
1499{
1500 Error error;
1501 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1502 if (bp_site_sp)
1503 {
1504 if (!bp_site_sp->IsEnabled())
1505 error = EnableBreakpoint (bp_site_sp.get());
1506 }
1507 else
1508 {
Greg Clayton81c22f62011-10-19 18:09:39 +00001509 error.SetErrorStringWithFormat("invalid breakpoint site ID: %llu", break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001510 }
1511 return error;
1512}
1513
Stephen Wilson50bd94f2010-07-17 00:56:13 +00001514lldb::break_id_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001515Process::CreateBreakpointSite (BreakpointLocationSP &owner, bool use_hardware)
1516{
Greg Clayton92bb12c2011-05-19 18:17:41 +00001517 const addr_t load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001518 if (load_addr != LLDB_INVALID_ADDRESS)
1519 {
1520 BreakpointSiteSP bp_site_sp;
1521
1522 // Look up this breakpoint site. If it exists, then add this new owner, otherwise
1523 // create a new breakpoint site and add it.
1524
1525 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr);
1526
1527 if (bp_site_sp)
1528 {
1529 bp_site_sp->AddOwner (owner);
1530 owner->SetBreakpointSite (bp_site_sp);
1531 return bp_site_sp->GetID();
1532 }
1533 else
1534 {
1535 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, LLDB_INVALID_THREAD_ID, use_hardware));
1536 if (bp_site_sp)
1537 {
1538 if (EnableBreakpoint (bp_site_sp.get()).Success())
1539 {
1540 owner->SetBreakpointSite (bp_site_sp);
1541 return m_breakpoint_site_list.Add (bp_site_sp);
1542 }
1543 }
1544 }
1545 }
1546 // We failed to enable the breakpoint
1547 return LLDB_INVALID_BREAK_ID;
1548
1549}
1550
1551void
1552Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp)
1553{
1554 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id);
1555 if (num_owners == 0)
1556 {
1557 DisableBreakpoint(bp_site_sp.get());
1558 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
1559 }
1560}
1561
1562
1563size_t
1564Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
1565{
1566 size_t bytes_removed = 0;
1567 addr_t intersect_addr;
1568 size_t intersect_size;
1569 size_t opcode_offset;
1570 size_t idx;
Greg Clayton4d122c42011-09-17 08:33:22 +00001571 BreakpointSiteSP bp_sp;
Jim Ingham20c77192011-06-29 19:42:28 +00001572 BreakpointSiteList bp_sites_in_range;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001573
Jim Ingham20c77192011-06-29 19:42:28 +00001574 if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001575 {
Greg Clayton4d122c42011-09-17 08:33:22 +00001576 for (idx = 0; (bp_sp = bp_sites_in_range.GetByIndex(idx)); ++idx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001577 {
Greg Clayton4d122c42011-09-17 08:33:22 +00001578 if (bp_sp->GetType() == BreakpointSite::eSoftware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001579 {
Greg Clayton4d122c42011-09-17 08:33:22 +00001580 if (bp_sp->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset))
Jim Ingham20c77192011-06-29 19:42:28 +00001581 {
1582 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
1583 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size);
Greg Clayton4d122c42011-09-17 08:33:22 +00001584 assert(opcode_offset + intersect_size <= bp_sp->GetByteSize());
Jim Ingham20c77192011-06-29 19:42:28 +00001585 size_t buf_offset = intersect_addr - bp_addr;
Greg Clayton4d122c42011-09-17 08:33:22 +00001586 ::memcpy(buf + buf_offset, bp_sp->GetSavedOpcodeBytes() + opcode_offset, intersect_size);
Jim Ingham20c77192011-06-29 19:42:28 +00001587 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001588 }
1589 }
1590 }
1591 return bytes_removed;
1592}
1593
1594
Greg Claytonded470d2011-03-19 01:12:21 +00001595
1596size_t
1597Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
1598{
1599 PlatformSP platform_sp (m_target.GetPlatform());
1600 if (platform_sp)
1601 return platform_sp->GetSoftwareBreakpointTrapOpcode (m_target, bp_site);
1602 return 0;
1603}
1604
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001605Error
1606Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site)
1607{
1608 Error error;
1609 assert (bp_site != NULL);
Greg Clayton2d4edfb2010-11-06 01:53:30 +00001610 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001611 const addr_t bp_addr = bp_site->GetLoadAddress();
1612 if (log)
1613 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx", bp_site->GetID(), (uint64_t)bp_addr);
1614 if (bp_site->IsEnabled())
1615 {
1616 if (log)
1617 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already enabled", bp_site->GetID(), (uint64_t)bp_addr);
1618 return error;
1619 }
1620
1621 if (bp_addr == LLDB_INVALID_ADDRESS)
1622 {
1623 error.SetErrorString("BreakpointSite contains an invalid load address.");
1624 return error;
1625 }
1626 // Ask the lldb::Process subclass to fill in the correct software breakpoint
1627 // trap for the breakpoint site
1628 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
1629
1630 if (bp_opcode_size == 0)
1631 {
Greg Clayton86edbf42011-10-26 00:56:27 +00001632 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%llx", bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001633 }
1634 else
1635 {
1636 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
1637
1638 if (bp_opcode_bytes == NULL)
1639 {
1640 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode.");
1641 return error;
1642 }
1643
1644 // Save the original opcode by reading it
1645 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size)
1646 {
1647 // Write a software breakpoint in place of the original opcode
1648 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
1649 {
1650 uint8_t verify_bp_opcode_bytes[64];
1651 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
1652 {
1653 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0)
1654 {
1655 bp_site->SetEnabled(true);
1656 bp_site->SetType (BreakpointSite::eSoftware);
1657 if (log)
1658 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS",
1659 bp_site->GetID(),
1660 (uint64_t)bp_addr);
1661 }
1662 else
Greg Clayton86edbf42011-10-26 00:56:27 +00001663 error.SetErrorString("failed to verify the breakpoint trap in memory.");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001664 }
1665 else
1666 error.SetErrorString("Unable to read memory to verify breakpoint trap.");
1667 }
1668 else
1669 error.SetErrorString("Unable to write breakpoint trap to memory.");
1670 }
1671 else
1672 error.SetErrorString("Unable to read memory at breakpoint address.");
1673 }
Stephen Wilson78a4feb2011-01-12 04:20:03 +00001674 if (log && error.Fail())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001675 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s",
1676 bp_site->GetID(),
1677 (uint64_t)bp_addr,
1678 error.AsCString());
1679 return error;
1680}
1681
1682Error
1683Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
1684{
1685 Error error;
1686 assert (bp_site != NULL);
Greg Clayton2d4edfb2010-11-06 01:53:30 +00001687 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001688 addr_t bp_addr = bp_site->GetLoadAddress();
1689 lldb::user_id_t breakID = bp_site->GetID();
1690 if (log)
Greg Clayton81c22f62011-10-19 18:09:39 +00001691 log->Printf ("Process::DisableBreakpoint (breakID = %llu) addr = 0x%llx", breakID, (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001692
1693 if (bp_site->IsHardware())
1694 {
1695 error.SetErrorString("Breakpoint site is a hardware breakpoint.");
1696 }
1697 else if (bp_site->IsEnabled())
1698 {
1699 const size_t break_op_size = bp_site->GetByteSize();
1700 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
1701 if (break_op_size > 0)
1702 {
1703 // Clear a software breakoint instruction
Greg Claytonc982c762010-07-09 20:39:50 +00001704 uint8_t curr_break_op[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00001705 assert (break_op_size <= sizeof(curr_break_op));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001706 bool break_op_found = false;
1707
1708 // Read the breakpoint opcode
1709 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
1710 {
1711 bool verify = false;
1712 // Make sure we have the a breakpoint opcode exists at this address
1713 if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
1714 {
1715 break_op_found = true;
1716 // We found a valid breakpoint opcode at this address, now restore
1717 // the saved opcode.
1718 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size)
1719 {
1720 verify = true;
1721 }
1722 else
1723 error.SetErrorString("Memory write failed when restoring original opcode.");
1724 }
1725 else
1726 {
1727 error.SetErrorString("Original breakpoint trap is no longer in memory.");
1728 // Set verify to true and so we can check if the original opcode has already been restored
1729 verify = true;
1730 }
1731
1732 if (verify)
1733 {
Greg Claytonc982c762010-07-09 20:39:50 +00001734 uint8_t verify_opcode[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00001735 assert (break_op_size < sizeof(verify_opcode));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001736 // Verify that our original opcode made it back to the inferior
1737 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size)
1738 {
1739 // compare the memory we just read with the original opcode
1740 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
1741 {
1742 // SUCCESS
1743 bp_site->SetEnabled(false);
1744 if (log)
1745 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS", bp_site->GetID(), (uint64_t)bp_addr);
1746 return error;
1747 }
1748 else
1749 {
1750 if (break_op_found)
1751 error.SetErrorString("Failed to restore original opcode.");
1752 }
1753 }
1754 else
1755 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored.");
1756 }
1757 }
1758 else
1759 error.SetErrorString("Unable to read memory that should contain the breakpoint trap.");
1760 }
1761 }
1762 else
1763 {
1764 if (log)
1765 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already disabled", bp_site->GetID(), (uint64_t)bp_addr);
1766 return error;
1767 }
1768
1769 if (log)
1770 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s",
1771 bp_site->GetID(),
1772 (uint64_t)bp_addr,
1773 error.AsCString());
1774 return error;
1775
1776}
1777
Greg Clayton58be07b2011-01-07 06:08:19 +00001778// Comment out line below to disable memory caching
1779#define ENABLE_MEMORY_CACHING
1780// Uncomment to verify memory caching works after making changes to caching code
1781//#define VERIFY_MEMORY_READS
1782
1783#if defined (ENABLE_MEMORY_CACHING)
1784
1785#if defined (VERIFY_MEMORY_READS)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001786
1787size_t
1788Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1789{
Greg Clayton58be07b2011-01-07 06:08:19 +00001790 // Memory caching is enabled, with debug verification
1791 if (buf && size)
1792 {
1793 // Uncomment the line below to make sure memory caching is working.
1794 // I ran this through the test suite and got no assertions, so I am
1795 // pretty confident this is working well. If any changes are made to
1796 // memory caching, uncomment the line below and test your changes!
1797
1798 // Verify all memory reads by using the cache first, then redundantly
1799 // reading the same memory from the inferior and comparing to make sure
1800 // everything is exactly the same.
1801 std::string verify_buf (size, '\0');
1802 assert (verify_buf.size() == size);
1803 const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error);
1804 Error verify_error;
1805 const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error);
1806 assert (cache_bytes_read == verify_bytes_read);
1807 assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
1808 assert (verify_error.Success() == error.Success());
1809 return cache_bytes_read;
1810 }
1811 return 0;
1812}
1813
1814#else // #if defined (VERIFY_MEMORY_READS)
1815
1816size_t
1817Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1818{
1819 // Memory caching enabled, no verification
Greg Claytond495c532011-05-17 03:37:42 +00001820 return m_memory_cache.Read (addr, buf, size, error);
Greg Clayton58be07b2011-01-07 06:08:19 +00001821}
1822
1823#endif // #else for #if defined (VERIFY_MEMORY_READS)
1824
1825#else // #if defined (ENABLE_MEMORY_CACHING)
1826
1827size_t
1828Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1829{
1830 // Memory caching is disabled
1831 return ReadMemoryFromInferior (addr, buf, size, error);
1832}
1833
1834#endif // #else for #if defined (ENABLE_MEMORY_CACHING)
1835
1836
1837size_t
Greg Clayton8b82f082011-04-12 05:54:46 +00001838Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len)
1839{
1840 size_t total_cstr_len = 0;
1841 if (dst && dst_max_len)
1842 {
1843 // NULL out everything just to be safe
1844 memset (dst, 0, dst_max_len);
1845 Error error;
1846 addr_t curr_addr = addr;
1847 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
1848 size_t bytes_left = dst_max_len - 1;
1849 char *curr_dst = dst;
1850
1851 while (bytes_left > 0)
1852 {
1853 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
1854 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
1855 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
1856
1857 if (bytes_read == 0)
1858 {
1859 dst[total_cstr_len] = '\0';
1860 break;
1861 }
1862 const size_t len = strlen(curr_dst);
1863
1864 total_cstr_len += len;
1865
1866 if (len < bytes_to_read)
1867 break;
1868
1869 curr_dst += bytes_read;
1870 curr_addr += bytes_read;
1871 bytes_left -= bytes_read;
1872 }
1873 }
1874 return total_cstr_len;
1875}
1876
1877size_t
Greg Clayton58be07b2011-01-07 06:08:19 +00001878Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error)
1879{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001880 if (buf == NULL || size == 0)
1881 return 0;
1882
1883 size_t bytes_read = 0;
1884 uint8_t *bytes = (uint8_t *)buf;
1885
1886 while (bytes_read < size)
1887 {
1888 const size_t curr_size = size - bytes_read;
1889 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read,
1890 bytes + bytes_read,
1891 curr_size,
1892 error);
1893 bytes_read += curr_bytes_read;
1894 if (curr_bytes_read == curr_size || curr_bytes_read == 0)
1895 break;
1896 }
1897
1898 // Replace any software breakpoint opcodes that fall into this range back
1899 // into "buf" before we return
1900 if (bytes_read > 0)
1901 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf);
1902 return bytes_read;
1903}
1904
Greg Clayton58a4c462010-12-16 20:01:20 +00001905uint64_t
Greg Claytonf3ef3d22011-05-22 22:46:53 +00001906Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error)
Greg Clayton58a4c462010-12-16 20:01:20 +00001907{
Greg Claytonf3ef3d22011-05-22 22:46:53 +00001908 Scalar scalar;
1909 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error))
1910 return scalar.ULongLong(fail_value);
1911 return fail_value;
1912}
1913
1914addr_t
1915Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
1916{
1917 Scalar scalar;
1918 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error))
1919 return scalar.ULongLong(LLDB_INVALID_ADDRESS);
1920 return LLDB_INVALID_ADDRESS;
1921}
1922
1923
1924bool
1925Process::WritePointerToMemory (lldb::addr_t vm_addr,
1926 lldb::addr_t ptr_value,
1927 Error &error)
1928{
1929 Scalar scalar;
1930 const uint32_t addr_byte_size = GetAddressByteSize();
1931 if (addr_byte_size <= 4)
1932 scalar = (uint32_t)ptr_value;
Greg Clayton58a4c462010-12-16 20:01:20 +00001933 else
Greg Claytonf3ef3d22011-05-22 22:46:53 +00001934 scalar = ptr_value;
1935 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size;
Greg Clayton58a4c462010-12-16 20:01:20 +00001936}
1937
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001938size_t
1939Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error)
1940{
1941 size_t bytes_written = 0;
1942 const uint8_t *bytes = (const uint8_t *)buf;
1943
1944 while (bytes_written < size)
1945 {
1946 const size_t curr_size = size - bytes_written;
1947 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written,
1948 bytes + bytes_written,
1949 curr_size,
1950 error);
1951 bytes_written += curr_bytes_written;
1952 if (curr_bytes_written == curr_size || curr_bytes_written == 0)
1953 break;
1954 }
1955 return bytes_written;
1956}
1957
1958size_t
1959Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
1960{
Greg Clayton58be07b2011-01-07 06:08:19 +00001961#if defined (ENABLE_MEMORY_CACHING)
1962 m_memory_cache.Flush (addr, size);
1963#endif
1964
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001965 if (buf == NULL || size == 0)
1966 return 0;
Jim Ingham78a685a2011-04-16 00:01:13 +00001967
Jim Ingham4b536182011-08-09 02:12:22 +00001968 m_mod_id.BumpMemoryID();
Jim Ingham78a685a2011-04-16 00:01:13 +00001969
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001970 // We need to write any data that would go where any current software traps
1971 // (enabled software breakpoints) any software traps (breakpoints) that we
1972 // may have placed in our tasks memory.
1973
1974 BreakpointSiteList::collection::const_iterator iter = m_breakpoint_site_list.GetMap()->lower_bound (addr);
1975 BreakpointSiteList::collection::const_iterator end = m_breakpoint_site_list.GetMap()->end();
1976
1977 if (iter == end || iter->second->GetLoadAddress() > addr + size)
Greg Claytonb4aaf2e2011-05-16 02:35:02 +00001978 return WriteMemoryPrivate (addr, buf, size, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001979
1980 BreakpointSiteList::collection::const_iterator pos;
1981 size_t bytes_written = 0;
Greg Claytonc982c762010-07-09 20:39:50 +00001982 addr_t intersect_addr = 0;
1983 size_t intersect_size = 0;
1984 size_t opcode_offset = 0;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001985 const uint8_t *ubuf = (const uint8_t *)buf;
1986
1987 for (pos = iter; pos != end; ++pos)
1988 {
1989 BreakpointSiteSP bp;
1990 bp = pos->second;
1991
1992 assert(bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset));
1993 assert(addr <= intersect_addr && intersect_addr < addr + size);
1994 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
1995 assert(opcode_offset + intersect_size <= bp->GetByteSize());
1996
1997 // Check for bytes before this breakpoint
1998 const addr_t curr_addr = addr + bytes_written;
1999 if (intersect_addr > curr_addr)
2000 {
2001 // There are some bytes before this breakpoint that we need to
2002 // just write to memory
2003 size_t curr_size = intersect_addr - curr_addr;
2004 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr,
2005 ubuf + bytes_written,
2006 curr_size,
2007 error);
2008 bytes_written += curr_bytes_written;
2009 if (curr_bytes_written != curr_size)
2010 {
2011 // We weren't able to write all of the requested bytes, we
2012 // are done looping and will return the number of bytes that
2013 // we have written so far.
2014 break;
2015 }
2016 }
2017
2018 // Now write any bytes that would cover up any software breakpoints
2019 // directly into the breakpoint opcode buffer
2020 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
2021 bytes_written += intersect_size;
2022 }
2023
2024 // Write any remaining bytes after the last breakpoint if we have any left
2025 if (bytes_written < size)
2026 bytes_written += WriteMemoryPrivate (addr + bytes_written,
2027 ubuf + bytes_written,
2028 size - bytes_written,
2029 error);
Jim Ingham78a685a2011-04-16 00:01:13 +00002030
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002031 return bytes_written;
2032}
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002033
2034size_t
2035Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, uint32_t byte_size, Error &error)
2036{
2037 if (byte_size == UINT32_MAX)
2038 byte_size = scalar.GetByteSize();
2039 if (byte_size > 0)
2040 {
2041 uint8_t buf[32];
2042 const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error);
2043 if (mem_size > 0)
2044 return WriteMemory(addr, buf, mem_size, error);
2045 else
2046 error.SetErrorString ("failed to get scalar as memory data");
2047 }
2048 else
2049 {
2050 error.SetErrorString ("invalid scalar value");
2051 }
2052 return 0;
2053}
2054
2055size_t
2056Process::ReadScalarIntegerFromMemory (addr_t addr,
2057 uint32_t byte_size,
2058 bool is_signed,
2059 Scalar &scalar,
2060 Error &error)
2061{
2062 uint64_t uval;
2063
2064 if (byte_size <= sizeof(uval))
2065 {
2066 size_t bytes_read = ReadMemory (addr, &uval, byte_size, error);
2067 if (bytes_read == byte_size)
2068 {
2069 DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize());
2070 uint32_t offset = 0;
2071 if (byte_size <= 4)
2072 scalar = data.GetMaxU32 (&offset, byte_size);
2073 else
2074 scalar = data.GetMaxU64 (&offset, byte_size);
2075
2076 if (is_signed)
2077 scalar.SignExtend(byte_size * 8);
2078 return bytes_read;
2079 }
2080 }
2081 else
2082 {
2083 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
2084 }
2085 return 0;
2086}
2087
Greg Claytond495c532011-05-17 03:37:42 +00002088#define USE_ALLOCATE_MEMORY_CACHE 1
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002089addr_t
2090Process::AllocateMemory(size_t size, uint32_t permissions, Error &error)
2091{
Jim Inghamf72ce3a2011-06-20 17:32:44 +00002092 if (GetPrivateState() != eStateStopped)
2093 return LLDB_INVALID_ADDRESS;
2094
Greg Claytond495c532011-05-17 03:37:42 +00002095#if defined (USE_ALLOCATE_MEMORY_CACHE)
2096 return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2097#else
Greg Claytonb2daec92011-01-23 19:58:49 +00002098 addr_t allocated_addr = DoAllocateMemory (size, permissions, error);
2099 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
2100 if (log)
Jim Ingham4b536182011-08-09 02:12:22 +00002101 log->Printf("Process::AllocateMemory(size=%4zu, permissions=%s) => 0x%16.16llx (m_stop_id = %u m_memory_id = %u)",
Greg Claytonb2daec92011-01-23 19:58:49 +00002102 size,
Greg Claytond495c532011-05-17 03:37:42 +00002103 GetPermissionsAsCString (permissions),
Greg Claytonb2daec92011-01-23 19:58:49 +00002104 (uint64_t)allocated_addr,
Jim Ingham4b536182011-08-09 02:12:22 +00002105 m_mod_id.GetStopID(),
2106 m_mod_id.GetMemoryID());
Greg Claytonb2daec92011-01-23 19:58:49 +00002107 return allocated_addr;
Greg Claytond495c532011-05-17 03:37:42 +00002108#endif
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002109}
2110
Sean Callanan90539452011-09-20 23:01:51 +00002111bool
2112Process::CanJIT ()
2113{
2114 return m_can_jit == eCanJITYes;
2115}
2116
2117void
2118Process::SetCanJIT (bool can_jit)
2119{
2120 m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
2121}
2122
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002123Error
2124Process::DeallocateMemory (addr_t ptr)
2125{
Greg Claytond495c532011-05-17 03:37:42 +00002126 Error error;
2127#if defined (USE_ALLOCATE_MEMORY_CACHE)
2128 if (!m_allocated_memory_cache.DeallocateMemory(ptr))
2129 {
2130 error.SetErrorStringWithFormat ("deallocation of memory at 0x%llx failed.", (uint64_t)ptr);
2131 }
2132#else
2133 error = DoDeallocateMemory (ptr);
Greg Claytonb2daec92011-01-23 19:58:49 +00002134
2135 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
2136 if (log)
Jim Ingham4b536182011-08-09 02:12:22 +00002137 log->Printf("Process::DeallocateMemory(addr=0x%16.16llx) => err = %s (m_stop_id = %u, m_memory_id = %u)",
Greg Claytonb2daec92011-01-23 19:58:49 +00002138 ptr,
2139 error.AsCString("SUCCESS"),
Jim Ingham4b536182011-08-09 02:12:22 +00002140 m_mod_id.GetStopID(),
2141 m_mod_id.GetMemoryID());
Greg Claytond495c532011-05-17 03:37:42 +00002142#endif
Greg Claytonb2daec92011-01-23 19:58:49 +00002143 return error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002144}
2145
2146
2147Error
Johnny Chen01a67862011-10-14 00:42:25 +00002148Process::EnableWatchpoint (Watchpoint *watchpoint)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002149{
2150 Error error;
2151 error.SetErrorString("watchpoints are not supported");
2152 return error;
2153}
2154
2155Error
Johnny Chen01a67862011-10-14 00:42:25 +00002156Process::DisableWatchpoint (Watchpoint *watchpoint)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002157{
2158 Error error;
2159 error.SetErrorString("watchpoints are not supported");
2160 return error;
2161}
2162
2163StateType
2164Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp)
2165{
2166 StateType state;
2167 // Now wait for the process to launch and return control to us, and then
2168 // call DidLaunch:
2169 while (1)
2170 {
Greg Clayton6779606a2011-01-22 23:43:18 +00002171 event_sp.reset();
2172 state = WaitForStateChangedEventsPrivate (timeout, event_sp);
2173
Greg Clayton2637f822011-11-17 01:23:07 +00002174 if (StateIsStoppedState(state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002175 break;
Greg Clayton6779606a2011-01-22 23:43:18 +00002176
2177 // If state is invalid, then we timed out
2178 if (state == eStateInvalid)
2179 break;
2180
2181 if (event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002182 HandlePrivateEvent (event_sp);
2183 }
2184 return state;
2185}
2186
2187Error
Greg Clayton982c9762011-11-03 21:22:33 +00002188Process::Launch (const ProcessLaunchInfo &launch_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002189{
2190 Error error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002191 m_abi_sp.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002192 m_dyld_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002193 m_os_ap.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002194 m_process_input_reader.reset();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002195
Greg Claytonaa149cb2011-08-11 02:48:45 +00002196 Module *exe_module = m_target.GetExecutableModulePointer();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002197 if (exe_module)
2198 {
Greg Clayton2289fa42011-04-30 01:09:13 +00002199 char local_exec_file_path[PATH_MAX];
2200 char platform_exec_file_path[PATH_MAX];
2201 exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path));
2202 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002203 if (exe_module->GetFileSpec().Exists())
2204 {
Greg Clayton71337622011-02-24 22:24:29 +00002205 if (PrivateStateThreadIsValid ())
2206 PausePrivateStateThread ();
2207
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002208 error = WillLaunch (exe_module);
2209 if (error.Success())
2210 {
Greg Clayton05faeb72010-10-07 04:19:01 +00002211 SetPublicState (eStateLaunching);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002212
2213 // Now launch using these arguments.
Greg Clayton982c9762011-11-03 21:22:33 +00002214 error = DoLaunch (exe_module, launch_info);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002215
2216 if (error.Fail())
2217 {
2218 if (GetID() != LLDB_INVALID_PROCESS_ID)
2219 {
2220 SetID (LLDB_INVALID_PROCESS_ID);
2221 const char *error_string = error.AsCString();
2222 if (error_string == NULL)
2223 error_string = "launch failed";
2224 SetExitStatus (-1, error_string);
2225 }
2226 }
2227 else
2228 {
2229 EventSP event_sp;
Greg Clayton1a38ea72011-06-22 01:42:17 +00002230 TimeValue timeout_time;
2231 timeout_time = TimeValue::Now();
2232 timeout_time.OffsetWithSeconds(10);
2233 StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002234
Greg Clayton1a38ea72011-06-22 01:42:17 +00002235 if (state == eStateInvalid || event_sp.get() == NULL)
2236 {
2237 // We were able to launch the process, but we failed to
2238 // catch the initial stop.
2239 SetExitStatus (0, "failed to catch stop after launch");
2240 Destroy();
2241 }
2242 else if (state == eStateStopped || state == eStateCrashed)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002243 {
Greg Clayton93d3c8332011-02-16 04:46:07 +00002244
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002245 DidLaunch ();
2246
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002247 m_dyld_ap.reset (DynamicLoader::FindPlugin (this, NULL));
Greg Clayton93d3c8332011-02-16 04:46:07 +00002248 if (m_dyld_ap.get())
2249 m_dyld_ap->DidLaunch();
2250
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002251 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002252 // This delays passing the stopped event to listeners till DidLaunch gets
2253 // a chance to complete...
2254 HandlePrivateEvent (event_sp);
Greg Clayton71337622011-02-24 22:24:29 +00002255
2256 if (PrivateStateThreadIsValid ())
2257 ResumePrivateStateThread ();
2258 else
2259 StartPrivateStateThread ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002260 }
2261 else if (state == eStateExited)
2262 {
2263 // We exited while trying to launch somehow. Don't call DidLaunch as that's
2264 // not likely to work, and return an invalid pid.
2265 HandlePrivateEvent (event_sp);
2266 }
2267 }
2268 }
2269 }
2270 else
2271 {
Greg Clayton86edbf42011-10-26 00:56:27 +00002272 error.SetErrorStringWithFormat("file doesn't exist: '%s'", local_exec_file_path);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002273 }
2274 }
2275 return error;
2276}
2277
Jim Inghambb3a2832011-01-29 01:49:25 +00002278Process::NextEventAction::EventActionResult
2279Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002280{
Jim Inghambb3a2832011-01-29 01:49:25 +00002281 StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
2282 switch (state)
Greg Clayton19388cf2010-10-18 01:45:30 +00002283 {
Greg Clayton513c26c2011-01-29 07:10:55 +00002284 case eStateRunning:
Greg Clayton71337622011-02-24 22:24:29 +00002285 case eStateConnected:
Greg Clayton513c26c2011-01-29 07:10:55 +00002286 return eEventActionRetry;
2287
2288 case eStateStopped:
2289 case eStateCrashed:
Greg Claytonc9ed4782011-11-12 02:10:56 +00002290 {
2291 // During attach, prior to sending the eStateStopped event,
2292 // lldb_private::Process subclasses must set the process must set
2293 // the new process ID.
2294 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
2295 if (m_exec_count > 0)
2296 {
2297 --m_exec_count;
2298 m_process->Resume();
2299 return eEventActionRetry;
2300 }
2301 else
2302 {
2303 m_process->CompleteAttach ();
2304 return eEventActionSuccess;
2305 }
2306 }
Greg Clayton513c26c2011-01-29 07:10:55 +00002307 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00002308
Greg Clayton513c26c2011-01-29 07:10:55 +00002309 default:
2310 case eStateExited:
2311 case eStateInvalid:
Greg Clayton513c26c2011-01-29 07:10:55 +00002312 break;
Jim Inghambb3a2832011-01-29 01:49:25 +00002313 }
Greg Claytonc9ed4782011-11-12 02:10:56 +00002314
2315 m_exit_string.assign ("No valid Process");
2316 return eEventActionExit;
Jim Inghambb3a2832011-01-29 01:49:25 +00002317}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002318
Jim Inghambb3a2832011-01-29 01:49:25 +00002319Process::NextEventAction::EventActionResult
2320Process::AttachCompletionHandler::HandleBeingInterrupted()
2321{
2322 return eEventActionSuccess;
2323}
2324
2325const char *
2326Process::AttachCompletionHandler::GetExitString ()
2327{
2328 return m_exit_string.c_str();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002329}
2330
2331Error
Greg Clayton144f3a92011-11-15 03:53:30 +00002332Process::Attach (ProcessAttachInfo &attach_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002333{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002334 m_abi_sp.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002335 m_process_input_reader.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002336 m_dyld_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002337 m_os_ap.reset();
Jim Ingham5aee1622010-08-09 23:31:02 +00002338
Greg Clayton144f3a92011-11-15 03:53:30 +00002339 lldb::pid_t attach_pid = attach_info.GetProcessID();
Greg Claytone996fd32011-03-08 22:40:15 +00002340 Error error;
Greg Clayton144f3a92011-11-15 03:53:30 +00002341 if (attach_pid == LLDB_INVALID_PROCESS_ID)
Jim Ingham5aee1622010-08-09 23:31:02 +00002342 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002343 char process_name[PATH_MAX];
Jim Ingham4299fdb2011-09-15 01:10:17 +00002344
Greg Clayton144f3a92011-11-15 03:53:30 +00002345 if (attach_info.GetExecutableFile().GetPath (process_name, sizeof(process_name)))
Jim Ingham2ecb7422010-08-17 21:54:19 +00002346 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002347 const bool wait_for_launch = attach_info.GetWaitForLaunch();
2348
2349 if (wait_for_launch)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002350 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002351 error = WillAttachToProcessWithName(process_name, wait_for_launch);
2352 if (error.Success())
2353 {
2354 SetPublicState (eStateAttaching);
2355 error = DoAttachToProcessWithName (process_name, wait_for_launch);
2356 if (error.Fail())
2357 {
2358 if (GetID() != LLDB_INVALID_PROCESS_ID)
2359 {
2360 SetID (LLDB_INVALID_PROCESS_ID);
2361 if (error.AsCString() == NULL)
2362 error.SetErrorString("attach failed");
2363
2364 SetExitStatus(-1, error.AsCString());
2365 }
2366 }
2367 else
2368 {
2369 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
2370 StartPrivateStateThread();
2371 }
2372 return error;
2373 }
Greg Claytone996fd32011-03-08 22:40:15 +00002374 }
Greg Clayton144f3a92011-11-15 03:53:30 +00002375 else
Greg Claytone996fd32011-03-08 22:40:15 +00002376 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002377 ProcessInstanceInfoList process_infos;
2378 PlatformSP platform_sp (m_target.GetPlatform ());
2379
2380 if (platform_sp)
2381 {
2382 ProcessInstanceInfoMatch match_info;
2383 match_info.GetProcessInfo() = attach_info;
2384 match_info.SetNameMatchType (eNameMatchEquals);
2385 platform_sp->FindProcesses (match_info, process_infos);
2386 const uint32_t num_matches = process_infos.GetSize();
2387 if (num_matches == 1)
2388 {
2389 attach_pid = process_infos.GetProcessIDAtIndex(0);
2390 // Fall through and attach using the above process ID
2391 }
2392 else
2393 {
2394 match_info.GetProcessInfo().GetExecutableFile().GetPath (process_name, sizeof(process_name));
2395 if (num_matches > 1)
2396 error.SetErrorStringWithFormat ("more than one process named %s", process_name);
2397 else
2398 error.SetErrorStringWithFormat ("could not find a process named %s", process_name);
2399 }
2400 }
2401 else
2402 {
2403 error.SetErrorString ("invalid platform, can't find processes by name");
2404 return error;
2405 }
Greg Claytone996fd32011-03-08 22:40:15 +00002406 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002407 }
2408 else
Greg Clayton144f3a92011-11-15 03:53:30 +00002409 {
2410 error.SetErrorString ("invalid process name");
Greg Claytone996fd32011-03-08 22:40:15 +00002411 }
2412 }
Greg Clayton144f3a92011-11-15 03:53:30 +00002413
2414 if (attach_pid != LLDB_INVALID_PROCESS_ID)
Greg Claytone996fd32011-03-08 22:40:15 +00002415 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002416 error = WillAttachToProcessWithID(attach_pid);
Greg Claytone996fd32011-03-08 22:40:15 +00002417 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002418 {
Greg Claytone996fd32011-03-08 22:40:15 +00002419 SetPublicState (eStateAttaching);
Greg Clayton144f3a92011-11-15 03:53:30 +00002420
2421 error = DoAttachToProcessWithID (attach_pid);
2422 if (error.Success())
2423 {
2424
2425 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
2426 StartPrivateStateThread();
2427 }
2428 else
Greg Claytone996fd32011-03-08 22:40:15 +00002429 {
2430 if (GetID() != LLDB_INVALID_PROCESS_ID)
2431 {
2432 SetID (LLDB_INVALID_PROCESS_ID);
2433 const char *error_string = error.AsCString();
2434 if (error_string == NULL)
2435 error_string = "attach failed";
2436
2437 SetExitStatus(-1, error_string);
2438 }
2439 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002440 }
2441 }
2442 return error;
2443}
2444
Greg Clayton144f3a92011-11-15 03:53:30 +00002445//Error
2446//Process::Attach (const char *process_name, bool wait_for_launch)
2447//{
2448// m_abi_sp.reset();
2449// m_process_input_reader.reset();
2450//
2451// // Find the process and its architecture. Make sure it matches the architecture
2452// // of the current Target, and if not adjust it.
2453// Error error;
2454//
2455// if (!wait_for_launch)
2456// {
2457// ProcessInstanceInfoList process_infos;
2458// PlatformSP platform_sp (m_target.GetPlatform ());
2459// assert (platform_sp.get());
2460//
2461// if (platform_sp)
2462// {
2463// ProcessInstanceInfoMatch match_info;
2464// match_info.GetProcessInfo().SetName(process_name);
2465// match_info.SetNameMatchType (eNameMatchEquals);
2466// platform_sp->FindProcesses (match_info, process_infos);
2467// if (process_infos.GetSize() > 1)
2468// {
2469// error.SetErrorStringWithFormat ("more than one process named %s", process_name);
2470// }
2471// else if (process_infos.GetSize() == 0)
2472// {
2473// error.SetErrorStringWithFormat ("could not find a process named %s", process_name);
2474// }
2475// }
2476// else
2477// {
2478// error.SetErrorString ("invalid platform");
2479// }
2480// }
2481//
2482// if (error.Success())
2483// {
2484// m_dyld_ap.reset();
2485// m_os_ap.reset();
2486//
2487// error = WillAttachToProcessWithName(process_name, wait_for_launch);
2488// if (error.Success())
2489// {
2490// SetPublicState (eStateAttaching);
2491// error = DoAttachToProcessWithName (process_name, wait_for_launch);
2492// if (error.Fail())
2493// {
2494// if (GetID() != LLDB_INVALID_PROCESS_ID)
2495// {
2496// SetID (LLDB_INVALID_PROCESS_ID);
2497// const char *error_string = error.AsCString();
2498// if (error_string == NULL)
2499// error_string = "attach failed";
2500//
2501// SetExitStatus(-1, error_string);
2502// }
2503// }
2504// else
2505// {
2506// SetNextEventAction(new Process::AttachCompletionHandler(this, 0));
2507// StartPrivateStateThread();
2508// }
2509// }
2510// }
2511// return error;
2512//}
2513
Greg Clayton93d3c8332011-02-16 04:46:07 +00002514void
2515Process::CompleteAttach ()
2516{
2517 // Let the process subclass figure out at much as it can about the process
2518 // before we go looking for a dynamic loader plug-in.
Jim Ingham8314c522011-09-15 21:36:42 +00002519 m_attached_to_process = true;
Greg Clayton93d3c8332011-02-16 04:46:07 +00002520 DidAttach();
2521
Jim Ingham4299fdb2011-09-15 01:10:17 +00002522 // We just attached. If we have a platform, ask it for the process architecture, and if it isn't
2523 // the same as the one we've already set, switch architectures.
2524 PlatformSP platform_sp (m_target.GetPlatform ());
2525 assert (platform_sp.get());
2526 if (platform_sp)
2527 {
2528 ProcessInstanceInfo process_info;
2529 platform_sp->GetProcessInfo (GetID(), process_info);
2530 const ArchSpec &process_arch = process_info.GetArchitecture();
2531 if (process_arch.IsValid() && m_target.GetArchitecture() != process_arch)
2532 m_target.SetArchitecture (process_arch);
2533 }
2534
2535 // We have completed the attach, now it is time to find the dynamic loader
Greg Clayton93d3c8332011-02-16 04:46:07 +00002536 // plug-in
Greg Clayton7a5388b2011-03-20 04:57:14 +00002537 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
Greg Clayton93d3c8332011-02-16 04:46:07 +00002538 if (m_dyld_ap.get())
2539 m_dyld_ap->DidAttach();
2540
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002541 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Greg Clayton93d3c8332011-02-16 04:46:07 +00002542 // Figure out which one is the executable, and set that in our target:
2543 ModuleList &modules = m_target.GetImages();
2544
2545 size_t num_modules = modules.GetSize();
2546 for (int i = 0; i < num_modules; i++)
2547 {
2548 ModuleSP module_sp (modules.GetModuleAtIndex(i));
Greg Clayton8b82f082011-04-12 05:54:46 +00002549 if (module_sp && module_sp->IsExecutable())
Greg Clayton93d3c8332011-02-16 04:46:07 +00002550 {
Greg Claytonaa149cb2011-08-11 02:48:45 +00002551 if (m_target.GetExecutableModulePointer() != module_sp.get())
Greg Clayton93d3c8332011-02-16 04:46:07 +00002552 m_target.SetExecutableModule (module_sp, false);
2553 break;
2554 }
2555 }
2556}
2557
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002558Error
Greg Claytonb766a732011-02-04 01:58:07 +00002559Process::ConnectRemote (const char *remote_url)
2560{
Greg Claytonb766a732011-02-04 01:58:07 +00002561 m_abi_sp.reset();
2562 m_process_input_reader.reset();
2563
2564 // Find the process and its architecture. Make sure it matches the architecture
2565 // of the current Target, and if not adjust it.
2566
2567 Error error (DoConnectRemote (remote_url));
2568 if (error.Success())
2569 {
Greg Clayton71337622011-02-24 22:24:29 +00002570 if (GetID() != LLDB_INVALID_PROCESS_ID)
2571 {
Greg Clayton32e0a752011-03-30 18:16:51 +00002572 EventSP event_sp;
2573 StateType state = WaitForProcessStopPrivate(NULL, event_sp);
2574
2575 if (state == eStateStopped || state == eStateCrashed)
2576 {
2577 // If we attached and actually have a process on the other end, then
2578 // this ended up being the equivalent of an attach.
2579 CompleteAttach ();
2580
2581 // This delays passing the stopped event to listeners till
2582 // CompleteAttach gets a chance to complete...
2583 HandlePrivateEvent (event_sp);
2584
2585 }
Greg Clayton71337622011-02-24 22:24:29 +00002586 }
Greg Clayton32e0a752011-03-30 18:16:51 +00002587
2588 if (PrivateStateThreadIsValid ())
2589 ResumePrivateStateThread ();
2590 else
2591 StartPrivateStateThread ();
Greg Claytonb766a732011-02-04 01:58:07 +00002592 }
2593 return error;
2594}
2595
2596
2597Error
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002598Process::Resume ()
2599{
Greg Clayton2d4edfb2010-11-06 01:53:30 +00002600 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002601 if (log)
Jim Ingham444586b2011-01-24 06:34:17 +00002602 log->Printf("Process::Resume() m_stop_id = %u, public state: %s private state: %s",
Jim Ingham4b536182011-08-09 02:12:22 +00002603 m_mod_id.GetStopID(),
Jim Ingham444586b2011-01-24 06:34:17 +00002604 StateAsCString(m_public_state.GetValue()),
2605 StateAsCString(m_private_state.GetValue()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002606
2607 Error error (WillResume());
2608 // Tell the process it is about to resume before the thread list
2609 if (error.Success())
2610 {
Johnny Chenc4221e42010-12-02 20:53:05 +00002611 // Now let the thread list know we are about to resume so it
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002612 // can let all of our threads know that they are about to be
2613 // resumed. Threads will each be called with
2614 // Thread::WillResume(StateType) where StateType contains the state
2615 // that they are supposed to have when the process is resumed
2616 // (suspended/running/stepping). Threads should also check
2617 // their resume signal in lldb::Thread::GetResumeSignal()
2618 // to see if they are suppoed to start back up with a signal.
2619 if (m_thread_list.WillResume())
2620 {
Jim Ingham0faa43f2011-11-08 03:00:11 +00002621 m_mod_id.BumpResumeID();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002622 error = DoResume();
2623 if (error.Success())
2624 {
2625 DidResume();
2626 m_thread_list.DidResume();
Jim Ingham444586b2011-01-24 06:34:17 +00002627 if (log)
2628 log->Printf ("Process thinks the process has resumed.");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002629 }
2630 }
2631 else
2632 {
Jim Ingham444586b2011-01-24 06:34:17 +00002633 error.SetErrorStringWithFormat("Process::WillResume() thread list returned false after WillResume");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002634 }
2635 }
Jim Ingham444586b2011-01-24 06:34:17 +00002636 else if (log)
2637 log->Printf ("Process::WillResume() got an error \"%s\".", error.AsCString("<unknown error>"));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002638 return error;
2639}
2640
2641Error
2642Process::Halt ()
2643{
Jim Inghambb3a2832011-01-29 01:49:25 +00002644 // Pause our private state thread so we can ensure no one else eats
2645 // the stop event out from under us.
Jim Ingham0f16e732011-02-08 05:20:59 +00002646 Listener halt_listener ("lldb.process.halt_listener");
2647 HijackPrivateProcessEvents(&halt_listener);
Greg Clayton3af9ea52010-11-18 05:57:03 +00002648
Jim Inghambb3a2832011-01-29 01:49:25 +00002649 EventSP event_sp;
Greg Clayton513c26c2011-01-29 07:10:55 +00002650 Error error (WillHalt());
Jim Inghambb3a2832011-01-29 01:49:25 +00002651
Greg Clayton513c26c2011-01-29 07:10:55 +00002652 if (error.Success())
Jim Inghambb3a2832011-01-29 01:49:25 +00002653 {
Jim Inghambb3a2832011-01-29 01:49:25 +00002654
Greg Clayton513c26c2011-01-29 07:10:55 +00002655 bool caused_stop = false;
2656
2657 // Ask the process subclass to actually halt our process
2658 error = DoHalt(caused_stop);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002659 if (error.Success())
Jim Ingham0d8bcc72010-11-17 02:32:00 +00002660 {
Greg Clayton513c26c2011-01-29 07:10:55 +00002661 if (m_public_state.GetValue() == eStateAttaching)
2662 {
2663 SetExitStatus(SIGKILL, "Cancelled async attach.");
2664 Destroy ();
2665 }
2666 else
Jim Ingham0d8bcc72010-11-17 02:32:00 +00002667 {
Jim Inghambb3a2832011-01-29 01:49:25 +00002668 // If "caused_stop" is true, then DoHalt stopped the process. If
2669 // "caused_stop" is false, the process was already stopped.
2670 // If the DoHalt caused the process to stop, then we want to catch
2671 // this event and set the interrupted bool to true before we pass
2672 // this along so clients know that the process was interrupted by
2673 // a halt command.
2674 if (caused_stop)
Greg Clayton3af9ea52010-11-18 05:57:03 +00002675 {
Jim Ingham0f16e732011-02-08 05:20:59 +00002676 // Wait for 1 second for the process to stop.
Jim Inghambb3a2832011-01-29 01:49:25 +00002677 TimeValue timeout_time;
2678 timeout_time = TimeValue::Now();
2679 timeout_time.OffsetWithSeconds(1);
Jim Ingham0f16e732011-02-08 05:20:59 +00002680 bool got_event = halt_listener.WaitForEvent (&timeout_time, event_sp);
2681 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00002682
Jim Ingham0f16e732011-02-08 05:20:59 +00002683 if (!got_event || state == eStateInvalid)
Greg Clayton3af9ea52010-11-18 05:57:03 +00002684 {
Jim Inghambb3a2832011-01-29 01:49:25 +00002685 // We timeout out and didn't get a stop event...
Jim Ingham0f16e732011-02-08 05:20:59 +00002686 error.SetErrorStringWithFormat ("Halt timed out. State = %s", StateAsCString(GetState()));
Greg Clayton3af9ea52010-11-18 05:57:03 +00002687 }
2688 else
2689 {
Greg Clayton2637f822011-11-17 01:23:07 +00002690 if (StateIsStoppedState (state, false))
Jim Inghambb3a2832011-01-29 01:49:25 +00002691 {
2692 // We caused the process to interrupt itself, so mark this
2693 // as such in the stop event so clients can tell an interrupted
2694 // process from a natural stop
2695 ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);
2696 }
2697 else
2698 {
2699 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
2700 if (log)
2701 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
2702 error.SetErrorString ("Did not get stopped event after halt.");
2703 }
Greg Clayton3af9ea52010-11-18 05:57:03 +00002704 }
2705 }
Jim Inghambb3a2832011-01-29 01:49:25 +00002706 DidHalt();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00002707 }
2708 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002709 }
Jim Inghambb3a2832011-01-29 01:49:25 +00002710 // Resume our private state thread before we post the event (if any)
Jim Ingham0f16e732011-02-08 05:20:59 +00002711 RestorePrivateProcessEvents();
Jim Inghambb3a2832011-01-29 01:49:25 +00002712
2713 // Post any event we might have consumed. If all goes well, we will have
2714 // stopped the process, intercepted the event and set the interrupted
2715 // bool in the event. Post it to the private event queue and that will end up
2716 // correctly setting the state.
2717 if (event_sp)
2718 m_private_state_broadcaster.BroadcastEvent(event_sp);
2719
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002720 return error;
2721}
2722
2723Error
2724Process::Detach ()
2725{
2726 Error error (WillDetach());
2727
2728 if (error.Success())
2729 {
2730 DisableAllBreakpointSites();
2731 error = DoDetach();
2732 if (error.Success())
2733 {
2734 DidDetach();
2735 StopPrivateStateThread();
2736 }
2737 }
2738 return error;
2739}
2740
2741Error
2742Process::Destroy ()
2743{
2744 Error error (WillDestroy());
2745 if (error.Success())
2746 {
2747 DisableAllBreakpointSites();
2748 error = DoDestroy();
2749 if (error.Success())
2750 {
2751 DidDestroy();
2752 StopPrivateStateThread();
2753 }
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002754 m_stdio_communication.StopReadThread();
2755 m_stdio_communication.Disconnect();
2756 if (m_process_input_reader && m_process_input_reader->IsActive())
2757 m_target.GetDebugger().PopInputReader (m_process_input_reader);
2758 if (m_process_input_reader)
2759 m_process_input_reader.reset();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002760 }
2761 return error;
2762}
2763
2764Error
2765Process::Signal (int signal)
2766{
2767 Error error (WillSignal());
2768 if (error.Success())
2769 {
2770 error = DoSignal(signal);
2771 if (error.Success())
2772 DidSignal();
2773 }
2774 return error;
2775}
2776
Greg Clayton514487e2011-02-15 21:59:32 +00002777lldb::ByteOrder
2778Process::GetByteOrder () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002779{
Greg Clayton514487e2011-02-15 21:59:32 +00002780 return m_target.GetArchitecture().GetByteOrder();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002781}
2782
2783uint32_t
Greg Clayton514487e2011-02-15 21:59:32 +00002784Process::GetAddressByteSize () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002785{
Greg Clayton514487e2011-02-15 21:59:32 +00002786 return m_target.GetArchitecture().GetAddressByteSize();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002787}
2788
Greg Clayton514487e2011-02-15 21:59:32 +00002789
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002790bool
2791Process::ShouldBroadcastEvent (Event *event_ptr)
2792{
2793 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr);
2794 bool return_value = true;
Greg Clayton2d4edfb2010-11-06 01:53:30 +00002795 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002796
2797 switch (state)
2798 {
Greg Claytonb766a732011-02-04 01:58:07 +00002799 case eStateConnected:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002800 case eStateAttaching:
2801 case eStateLaunching:
2802 case eStateDetached:
2803 case eStateExited:
2804 case eStateUnloaded:
2805 // These events indicate changes in the state of the debugging session, always report them.
2806 return_value = true;
2807 break;
2808 case eStateInvalid:
2809 // We stopped for no apparent reason, don't report it.
2810 return_value = false;
2811 break;
2812 case eStateRunning:
2813 case eStateStepping:
2814 // If we've started the target running, we handle the cases where we
2815 // are already running and where there is a transition from stopped to
2816 // running differently.
2817 // running -> running: Automatically suppress extra running events
2818 // stopped -> running: Report except when there is one or more no votes
2819 // and no yes votes.
2820 SynchronouslyNotifyStateChanged (state);
2821 switch (m_public_state.GetValue())
2822 {
2823 case eStateRunning:
2824 case eStateStepping:
2825 // We always suppress multiple runnings with no PUBLIC stop in between.
2826 return_value = false;
2827 break;
2828 default:
2829 // TODO: make this work correctly. For now always report
2830 // run if we aren't running so we don't miss any runnning
2831 // events. If I run the lldb/test/thread/a.out file and
2832 // break at main.cpp:58, run and hit the breakpoints on
2833 // multiple threads, then somehow during the stepping over
2834 // of all breakpoints no run gets reported.
2835 return_value = true;
2836
2837 // This is a transition from stop to run.
2838 switch (m_thread_list.ShouldReportRun (event_ptr))
2839 {
2840 case eVoteYes:
2841 case eVoteNoOpinion:
2842 return_value = true;
2843 break;
2844 case eVoteNo:
2845 return_value = false;
2846 break;
2847 }
2848 break;
2849 }
2850 break;
2851 case eStateStopped:
2852 case eStateCrashed:
2853 case eStateSuspended:
2854 {
2855 // We've stopped. First see if we're going to restart the target.
2856 // If we are going to stop, then we always broadcast the event.
2857 // If we aren't going to stop, let the thread plans decide if we're going to report this event.
Jim Inghamb01e7422010-06-19 04:45:32 +00002858 // If no thread has an opinion, we don't report it.
Jim Ingham0d8bcc72010-11-17 02:32:00 +00002859 if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002860 {
Greg Clayton3af9ea52010-11-18 05:57:03 +00002861 if (log)
2862 log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s", event_ptr, StateAsCString(state));
Jim Ingham0d8bcc72010-11-17 02:32:00 +00002863 return true;
2864 }
2865 else
2866 {
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002867 RefreshStateAfterStop ();
2868
2869 if (m_thread_list.ShouldStop (event_ptr) == false)
2870 {
2871 switch (m_thread_list.ShouldReportStop (event_ptr))
2872 {
2873 case eVoteYes:
2874 Process::ProcessEventData::SetRestartedInEvent (event_ptr, true);
Johnny Chen3c230652010-10-14 00:54:32 +00002875 // Intentional fall-through here.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002876 case eVoteNoOpinion:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002877 case eVoteNo:
2878 return_value = false;
2879 break;
2880 }
2881
2882 if (log)
Jim Ingham0d8bcc72010-11-17 02:32:00 +00002883 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s", event_ptr, StateAsCString(state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002884 Resume ();
2885 }
2886 else
2887 {
2888 return_value = true;
2889 SynchronouslyNotifyStateChanged (state);
2890 }
2891 }
2892 }
2893 }
2894
2895 if (log)
Jason Molendafd54b362011-09-20 21:44:10 +00002896 log->Printf ("Process::ShouldBroadcastEvent (%p) => %s - %s", event_ptr, StateAsCString(state), return_value ? "YES" : "NO");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002897 return return_value;
2898}
2899
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002900
2901bool
2902Process::StartPrivateStateThread ()
2903{
Greg Clayton2d4edfb2010-11-06 01:53:30 +00002904 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002905
Greg Clayton8b82f082011-04-12 05:54:46 +00002906 bool already_running = PrivateStateThreadIsValid ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002907 if (log)
Greg Clayton8b82f082011-04-12 05:54:46 +00002908 log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread");
2909
2910 if (already_running)
2911 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002912
2913 // Create a thread that watches our internal state and controls which
2914 // events make it to clients (into the DCProcess event queue).
Greg Clayton3e06bd92011-01-09 21:07:35 +00002915 char thread_name[1024];
Greg Clayton81c22f62011-10-19 18:09:39 +00002916 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%llu)>", GetID());
Greg Clayton3e06bd92011-01-09 21:07:35 +00002917 m_private_state_thread = Host::ThreadCreate (thread_name, Process::PrivateStateThread, this, NULL);
Greg Clayton2da6d492011-02-08 01:34:25 +00002918 return IS_VALID_LLDB_HOST_THREAD(m_private_state_thread);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002919}
2920
2921void
2922Process::PausePrivateStateThread ()
2923{
2924 ControlPrivateStateThread (eBroadcastInternalStateControlPause);
2925}
2926
2927void
2928Process::ResumePrivateStateThread ()
2929{
2930 ControlPrivateStateThread (eBroadcastInternalStateControlResume);
2931}
2932
2933void
2934Process::StopPrivateStateThread ()
2935{
Greg Clayton8b82f082011-04-12 05:54:46 +00002936 if (PrivateStateThreadIsValid ())
2937 ControlPrivateStateThread (eBroadcastInternalStateControlStop);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002938}
2939
2940void
2941Process::ControlPrivateStateThread (uint32_t signal)
2942{
Greg Clayton2d4edfb2010-11-06 01:53:30 +00002943 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002944
2945 assert (signal == eBroadcastInternalStateControlStop ||
2946 signal == eBroadcastInternalStateControlPause ||
2947 signal == eBroadcastInternalStateControlResume);
2948
2949 if (log)
Greg Clayton7ecb3a02011-01-22 17:43:17 +00002950 log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002951
Greg Clayton7ecb3a02011-01-22 17:43:17 +00002952 // Signal the private state thread. First we should copy this is case the
2953 // thread starts exiting since the private state thread will NULL this out
2954 // when it exits
2955 const lldb::thread_t private_state_thread = m_private_state_thread;
Greg Clayton2da6d492011-02-08 01:34:25 +00002956 if (IS_VALID_LLDB_HOST_THREAD(private_state_thread))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002957 {
2958 TimeValue timeout_time;
2959 bool timed_out;
2960
2961 m_private_state_control_broadcaster.BroadcastEvent (signal, NULL);
2962
2963 timeout_time = TimeValue::Now();
2964 timeout_time.OffsetWithSeconds(2);
2965 m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out);
2966 m_private_state_control_wait.SetValue (false, eBroadcastNever);
2967
2968 if (signal == eBroadcastInternalStateControlStop)
2969 {
2970 if (timed_out)
Greg Clayton7ecb3a02011-01-22 17:43:17 +00002971 Host::ThreadCancel (private_state_thread, NULL);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002972
2973 thread_result_t result = NULL;
Greg Clayton7ecb3a02011-01-22 17:43:17 +00002974 Host::ThreadJoin (private_state_thread, &result, NULL);
Greg Clayton49182ed2010-07-22 18:34:21 +00002975 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002976 }
2977 }
2978}
2979
2980void
2981Process::HandlePrivateEvent (EventSP &event_sp)
2982{
Greg Clayton2d4edfb2010-11-06 01:53:30 +00002983 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Inghambb3a2832011-01-29 01:49:25 +00002984
Greg Clayton414f5d32011-01-25 02:58:48 +00002985 const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00002986
2987 // First check to see if anybody wants a shot at this event:
Jim Ingham754ab982011-01-29 04:05:41 +00002988 if (m_next_event_action_ap.get() != NULL)
Jim Inghambb3a2832011-01-29 01:49:25 +00002989 {
Jim Ingham754ab982011-01-29 04:05:41 +00002990 NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp);
Jim Inghambb3a2832011-01-29 01:49:25 +00002991 switch (action_result)
2992 {
2993 case NextEventAction::eEventActionSuccess:
2994 SetNextEventAction(NULL);
2995 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00002996
Jim Inghambb3a2832011-01-29 01:49:25 +00002997 case NextEventAction::eEventActionRetry:
2998 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00002999
Jim Inghambb3a2832011-01-29 01:49:25 +00003000 case NextEventAction::eEventActionExit:
Jim Ingham2a5fdd42011-01-29 01:57:31 +00003001 // Handle Exiting Here. If we already got an exited event,
3002 // we should just propagate it. Otherwise, swallow this event,
3003 // and set our state to exit so the next event will kill us.
3004 if (new_state != eStateExited)
3005 {
3006 // FIXME: should cons up an exited event, and discard this one.
Jim Ingham754ab982011-01-29 04:05:41 +00003007 SetExitStatus(0, m_next_event_action_ap->GetExitString());
Jim Ingham2a5fdd42011-01-29 01:57:31 +00003008 SetNextEventAction(NULL);
3009 return;
3010 }
3011 SetNextEventAction(NULL);
Jim Inghambb3a2832011-01-29 01:49:25 +00003012 break;
3013 }
3014 }
3015
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003016 // See if we should broadcast this state to external clients?
3017 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003018
3019 if (should_broadcast)
3020 {
3021 if (log)
3022 {
Greg Clayton81c22f62011-10-19 18:09:39 +00003023 log->Printf ("Process::%s (pid = %llu) broadcasting new state %s (old state %s) to %s",
Greg Clayton414f5d32011-01-25 02:58:48 +00003024 __FUNCTION__,
3025 GetID(),
3026 StateAsCString(new_state),
3027 StateAsCString (GetState ()),
3028 IsHijackedForEvent(eBroadcastBitStateChanged) ? "hijacked" : "public");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003029 }
Jim Ingham9575d842011-03-11 03:53:59 +00003030 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
Greg Clayton414f5d32011-01-25 02:58:48 +00003031 if (StateIsRunningState (new_state))
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003032 PushProcessInputReader ();
3033 else
3034 PopProcessInputReader ();
Jim Ingham9575d842011-03-11 03:53:59 +00003035
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003036 BroadcastEvent (event_sp);
3037 }
3038 else
3039 {
3040 if (log)
3041 {
Greg Clayton81c22f62011-10-19 18:09:39 +00003042 log->Printf ("Process::%s (pid = %llu) suppressing state %s (old state %s): should_broadcast == false",
Greg Clayton414f5d32011-01-25 02:58:48 +00003043 __FUNCTION__,
3044 GetID(),
3045 StateAsCString(new_state),
Jason Molendafd54b362011-09-20 21:44:10 +00003046 StateAsCString (GetState ()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003047 }
3048 }
3049}
3050
3051void *
3052Process::PrivateStateThread (void *arg)
3053{
3054 Process *proc = static_cast<Process*> (arg);
3055 void *result = proc->RunPrivateStateThread ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003056 return result;
3057}
3058
3059void *
3060Process::RunPrivateStateThread ()
3061{
3062 bool control_only = false;
3063 m_private_state_control_wait.SetValue (false, eBroadcastNever);
3064
Greg Clayton2d4edfb2010-11-06 01:53:30 +00003065 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003066 if (log)
Greg Clayton81c22f62011-10-19 18:09:39 +00003067 log->Printf ("Process::%s (arg = %p, pid = %llu) thread starting...", __FUNCTION__, this, GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003068
3069 bool exit_now = false;
3070 while (!exit_now)
3071 {
3072 EventSP event_sp;
3073 WaitForEventsPrivate (NULL, event_sp, control_only);
3074 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
3075 {
3076 switch (event_sp->GetType())
3077 {
3078 case eBroadcastInternalStateControlStop:
3079 exit_now = true;
3080 continue; // Go to next loop iteration so we exit without
3081 break; // doing any internal state managment below
3082
3083 case eBroadcastInternalStateControlPause:
3084 control_only = true;
3085 break;
3086
3087 case eBroadcastInternalStateControlResume:
3088 control_only = false;
3089 break;
3090 }
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003091
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003092 if (log)
Greg Clayton81c22f62011-10-19 18:09:39 +00003093 log->Printf ("Process::%s (arg = %p, pid = %llu) got a control event: %d", __FUNCTION__, this, GetID(), event_sp->GetType());
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003094
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003095 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003096 continue;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003097 }
3098
3099
3100 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3101
3102 if (internal_state != eStateInvalid)
3103 {
3104 HandlePrivateEvent (event_sp);
3105 }
3106
Greg Clayton58d1c9a2010-10-18 04:14:23 +00003107 if (internal_state == eStateInvalid ||
3108 internal_state == eStateExited ||
3109 internal_state == eStateDetached )
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003110 {
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003111 if (log)
Greg Clayton81c22f62011-10-19 18:09:39 +00003112 log->Printf ("Process::%s (arg = %p, pid = %llu) about to exit with internal state %s...", __FUNCTION__, this, GetID(), StateAsCString(internal_state));
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003113
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003114 break;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003115 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003116 }
3117
Caroline Tice20ad3c42010-10-29 21:48:37 +00003118 // Verify log is still enabled before attempting to write to it...
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003119 if (log)
Greg Clayton81c22f62011-10-19 18:09:39 +00003120 log->Printf ("Process::%s (arg = %p, pid = %llu) thread exiting...", __FUNCTION__, this, GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003121
Greg Clayton6ed95942011-01-22 07:12:45 +00003122 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
3123 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003124 return NULL;
3125}
3126
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003127//------------------------------------------------------------------
3128// Process Event Data
3129//------------------------------------------------------------------
3130
3131Process::ProcessEventData::ProcessEventData () :
3132 EventData (),
3133 m_process_sp (),
3134 m_state (eStateInvalid),
Greg Claytonc982c762010-07-09 20:39:50 +00003135 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00003136 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003137 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003138{
3139}
3140
3141Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) :
3142 EventData (),
3143 m_process_sp (process_sp),
3144 m_state (state),
Greg Claytonc982c762010-07-09 20:39:50 +00003145 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00003146 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003147 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003148{
3149}
3150
3151Process::ProcessEventData::~ProcessEventData()
3152{
3153}
3154
3155const ConstString &
3156Process::ProcessEventData::GetFlavorString ()
3157{
3158 static ConstString g_flavor ("Process::ProcessEventData");
3159 return g_flavor;
3160}
3161
3162const ConstString &
3163Process::ProcessEventData::GetFlavor () const
3164{
3165 return ProcessEventData::GetFlavorString ();
3166}
3167
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003168void
3169Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
3170{
3171 // This function gets called twice for each event, once when the event gets pulled
Jim Inghama8604692011-05-22 21:45:01 +00003172 // off of the private process event queue, and then any number of times, first when it gets pulled off of
3173 // the public event queue, then other times when we're pretending that this is where we stopped at the
3174 // end of expression evaluation. m_update_state is used to distinguish these
3175 // three cases; it is 0 when we're just pulling it off for private handling,
3176 // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003177
Jim Inghama8604692011-05-22 21:45:01 +00003178 if (m_update_state != 1)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003179 return;
3180
3181 m_process_sp->SetPublicState (m_state);
3182
3183 // If we're stopped and haven't restarted, then do the breakpoint commands here:
3184 if (m_state == eStateStopped && ! m_restarted)
Jim Ingham0faa43f2011-11-08 03:00:11 +00003185 {
3186 ThreadList &curr_thread_list = m_process_sp->GetThreadList();
3187 int num_threads = curr_thread_list.GetSize();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003188 int idx;
Greg Claytonf4b47e12010-08-04 01:40:35 +00003189
Jim Ingham4b536182011-08-09 02:12:22 +00003190 // The actions might change one of the thread's stop_info's opinions about whether we should
3191 // stop the process, so we need to query that as we go.
Jim Ingham0faa43f2011-11-08 03:00:11 +00003192
3193 // One other complication here, is that we try to catch any case where the target has run (except for expressions)
3194 // and immediately exit, but if we get that wrong (which is possible) then the thread list might have changed, and
3195 // that would cause our iteration here to crash. We could make a copy of the thread list, but we'd really like
3196 // to also know if it has changed at all, so we make up a vector of the thread ID's and check what we get back
3197 // against this list & bag out if anything differs.
3198 std::vector<lldb::tid_t> thread_index_array(num_threads);
3199 for (idx = 0; idx < num_threads; ++idx)
3200 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
3201
Jim Ingham4b536182011-08-09 02:12:22 +00003202 bool still_should_stop = true;
3203
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003204 for (idx = 0; idx < num_threads; ++idx)
3205 {
Jim Ingham0faa43f2011-11-08 03:00:11 +00003206 curr_thread_list = m_process_sp->GetThreadList();
3207 if (curr_thread_list.GetSize() != num_threads)
3208 {
3209 lldb::LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
3210 log->Printf("Number of threads changed from %d to %d while processing event.", num_threads, curr_thread_list.GetSize());
3211 break;
3212 }
3213
3214 lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
3215
3216 if (thread_sp->GetIndexID() != thread_index_array[idx])
3217 {
3218 lldb::LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
3219 log->Printf("The thread at position %d changed from %d to %d while processing event.",
3220 idx,
3221 thread_index_array[idx],
3222 thread_sp->GetIndexID());
3223 break;
3224 }
3225
Jim Inghamb15bfc72010-10-20 00:39:53 +00003226 StopInfoSP stop_info_sp = thread_sp->GetStopInfo ();
3227 if (stop_info_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003228 {
Jim Inghamb15bfc72010-10-20 00:39:53 +00003229 stop_info_sp->PerformAction(event_ptr);
Jim Ingham4b536182011-08-09 02:12:22 +00003230 // The stop action might restart the target. If it does, then we want to mark that in the
3231 // event so that whoever is receiving it will know to wait for the running event and reflect
3232 // that state appropriately.
3233 // We also need to stop processing actions, since they aren't expecting the target to be running.
Jim Ingham0faa43f2011-11-08 03:00:11 +00003234
3235 // FIXME: we might have run.
3236 if (stop_info_sp->HasTargetRunSinceMe())
Jim Ingham4b536182011-08-09 02:12:22 +00003237 {
3238 SetRestarted (true);
3239 break;
3240 }
3241 else if (!stop_info_sp->ShouldStop(event_ptr))
3242 {
3243 still_should_stop = false;
3244 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003245 }
3246 }
Jim Ingham3ebcf7f2010-08-10 00:59:59 +00003247
Jim Ingham4b536182011-08-09 02:12:22 +00003248
3249 if (m_process_sp->GetPrivateState() != eStateRunning)
Jim Ingham9575d842011-03-11 03:53:59 +00003250 {
Jim Ingham4b536182011-08-09 02:12:22 +00003251 if (!still_should_stop)
3252 {
3253 // We've been asked to continue, so do that here.
Jim Ingham9575d842011-03-11 03:53:59 +00003254 SetRestarted(true);
Jim Ingham4b536182011-08-09 02:12:22 +00003255 m_process_sp->Resume();
3256 }
3257 else
3258 {
3259 // If we didn't restart, run the Stop Hooks here:
3260 // They might also restart the target, so watch for that.
3261 m_process_sp->GetTarget().RunStopHooks();
3262 if (m_process_sp->GetPrivateState() == eStateRunning)
3263 SetRestarted(true);
3264 }
Jim Ingham9575d842011-03-11 03:53:59 +00003265 }
3266
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003267 }
3268}
3269
3270void
3271Process::ProcessEventData::Dump (Stream *s) const
3272{
3273 if (m_process_sp)
Greg Clayton81c22f62011-10-19 18:09:39 +00003274 s->Printf(" process = %p (pid = %llu), ", m_process_sp.get(), m_process_sp->GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003275
Greg Clayton8b82f082011-04-12 05:54:46 +00003276 s->Printf("state = %s", StateAsCString(GetState()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003277}
3278
3279const Process::ProcessEventData *
3280Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr)
3281{
3282 if (event_ptr)
3283 {
3284 const EventData *event_data = event_ptr->GetData();
3285 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString())
3286 return static_cast <const ProcessEventData *> (event_ptr->GetData());
3287 }
3288 return NULL;
3289}
3290
3291ProcessSP
3292Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr)
3293{
3294 ProcessSP process_sp;
3295 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3296 if (data)
3297 process_sp = data->GetProcessSP();
3298 return process_sp;
3299}
3300
3301StateType
3302Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr)
3303{
3304 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3305 if (data == NULL)
3306 return eStateInvalid;
3307 else
3308 return data->GetState();
3309}
3310
3311bool
3312Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr)
3313{
3314 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3315 if (data == NULL)
3316 return false;
3317 else
3318 return data->GetRestarted();
3319}
3320
3321void
3322Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value)
3323{
3324 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
3325 if (data != NULL)
3326 data->SetRestarted(new_value);
3327}
3328
3329bool
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003330Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr)
3331{
3332 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3333 if (data == NULL)
3334 return false;
3335 else
3336 return data->GetInterrupted ();
3337}
3338
3339void
3340Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value)
3341{
3342 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
3343 if (data != NULL)
3344 data->SetInterrupted(new_value);
3345}
3346
3347bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003348Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr)
3349{
3350 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
3351 if (data)
3352 {
3353 data->SetUpdateStateOnRemoval();
3354 return true;
3355 }
3356 return false;
3357}
3358
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003359void
Greg Clayton0603aa92010-10-04 01:05:56 +00003360Process::CalculateExecutionContext (ExecutionContext &exe_ctx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003361{
Greg Claytonc14ee322011-09-22 04:58:26 +00003362 exe_ctx.SetTargetPtr (&m_target);
3363 exe_ctx.SetProcessPtr (this);
3364 exe_ctx.SetThreadPtr(NULL);
3365 exe_ctx.SetFramePtr (NULL);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003366}
3367
3368lldb::ProcessSP
3369Process::GetSP ()
3370{
3371 return GetTarget().GetProcessSP();
3372}
3373
Greg Claytone996fd32011-03-08 22:40:15 +00003374//uint32_t
3375//Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
3376//{
3377// return 0;
3378//}
3379//
3380//ArchSpec
3381//Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
3382//{
3383// return Host::GetArchSpecForExistingProcess (pid);
3384//}
3385//
3386//ArchSpec
3387//Process::GetArchSpecForExistingProcess (const char *process_name)
3388//{
3389// return Host::GetArchSpecForExistingProcess (process_name);
3390//}
3391//
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003392void
3393Process::AppendSTDOUT (const char * s, size_t len)
3394{
Greg Clayton3af9ea52010-11-18 05:57:03 +00003395 Mutex::Locker locker (m_stdio_communication_mutex);
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003396 m_stdout_data.append (s, len);
Greg Claytona9ff3062010-12-05 19:16:56 +00003397 BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (GetTarget().GetProcessSP(), GetState()));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003398}
3399
3400void
Greg Clayton93e86192011-11-13 04:45:22 +00003401Process::AppendSTDERR (const char * s, size_t len)
3402{
3403 Mutex::Locker locker (m_stdio_communication_mutex);
3404 m_stderr_data.append (s, len);
3405 BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (GetTarget().GetProcessSP(), GetState()));
3406}
3407
3408//------------------------------------------------------------------
3409// Process STDIO
3410//------------------------------------------------------------------
3411
3412size_t
3413Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
3414{
3415 Mutex::Locker locker(m_stdio_communication_mutex);
3416 size_t bytes_available = m_stdout_data.size();
3417 if (bytes_available > 0)
3418 {
3419 LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3420 if (log)
3421 log->Printf ("Process::GetSTDOUT (buf = %p, size = %zu)", buf, buf_size);
3422 if (bytes_available > buf_size)
3423 {
3424 memcpy(buf, m_stdout_data.c_str(), buf_size);
3425 m_stdout_data.erase(0, buf_size);
3426 bytes_available = buf_size;
3427 }
3428 else
3429 {
3430 memcpy(buf, m_stdout_data.c_str(), bytes_available);
3431 m_stdout_data.clear();
3432 }
3433 }
3434 return bytes_available;
3435}
3436
3437
3438size_t
3439Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
3440{
3441 Mutex::Locker locker(m_stdio_communication_mutex);
3442 size_t bytes_available = m_stderr_data.size();
3443 if (bytes_available > 0)
3444 {
3445 LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3446 if (log)
3447 log->Printf ("Process::GetSTDERR (buf = %p, size = %zu)", buf, buf_size);
3448 if (bytes_available > buf_size)
3449 {
3450 memcpy(buf, m_stderr_data.c_str(), buf_size);
3451 m_stderr_data.erase(0, buf_size);
3452 bytes_available = buf_size;
3453 }
3454 else
3455 {
3456 memcpy(buf, m_stderr_data.c_str(), bytes_available);
3457 m_stderr_data.clear();
3458 }
3459 }
3460 return bytes_available;
3461}
3462
3463void
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003464Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
3465{
3466 Process *process = (Process *) baton;
3467 process->AppendSTDOUT (static_cast<const char *>(src), src_len);
3468}
3469
3470size_t
3471Process::ProcessInputReaderCallback (void *baton,
3472 InputReader &reader,
3473 lldb::InputReaderAction notification,
3474 const char *bytes,
3475 size_t bytes_len)
3476{
3477 Process *process = (Process *) baton;
3478
3479 switch (notification)
3480 {
3481 case eInputReaderActivate:
3482 break;
3483
3484 case eInputReaderDeactivate:
3485 break;
3486
3487 case eInputReaderReactivate:
3488 break;
3489
Caroline Tice969ed3d2011-05-02 20:41:46 +00003490 case eInputReaderAsynchronousOutputWritten:
3491 break;
3492
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003493 case eInputReaderGotToken:
3494 {
3495 Error error;
3496 process->PutSTDIN (bytes, bytes_len, error);
3497 }
3498 break;
3499
Caroline Ticeefed6132010-11-19 20:47:54 +00003500 case eInputReaderInterrupt:
3501 process->Halt ();
3502 break;
3503
3504 case eInputReaderEndOfFile:
3505 process->AppendSTDOUT ("^D", 2);
3506 break;
3507
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003508 case eInputReaderDone:
3509 break;
3510
3511 }
3512
3513 return bytes_len;
3514}
3515
3516void
3517Process::ResetProcessInputReader ()
3518{
3519 m_process_input_reader.reset();
3520}
3521
3522void
3523Process::SetUpProcessInputReader (int file_descriptor)
3524{
3525 // First set up the Read Thread for reading/handling process I/O
3526
3527 std::auto_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (file_descriptor, true));
3528
3529 if (conn_ap.get())
3530 {
3531 m_stdio_communication.SetConnection (conn_ap.release());
3532 if (m_stdio_communication.IsConnected())
3533 {
3534 m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
3535 m_stdio_communication.StartReadThread();
3536
3537 // Now read thread is set up, set up input reader.
3538
3539 if (!m_process_input_reader.get())
3540 {
3541 m_process_input_reader.reset (new InputReader(m_target.GetDebugger()));
3542 Error err (m_process_input_reader->Initialize (Process::ProcessInputReaderCallback,
3543 this,
3544 eInputReaderGranularityByte,
3545 NULL,
3546 NULL,
3547 false));
3548
3549 if (err.Fail())
3550 m_process_input_reader.reset();
3551 }
3552 }
3553 }
3554}
3555
3556void
3557Process::PushProcessInputReader ()
3558{
3559 if (m_process_input_reader && !m_process_input_reader->IsActive())
3560 m_target.GetDebugger().PushInputReader (m_process_input_reader);
3561}
3562
3563void
3564Process::PopProcessInputReader ()
3565{
3566 if (m_process_input_reader && m_process_input_reader->IsActive())
3567 m_target.GetDebugger().PopInputReader (m_process_input_reader);
3568}
3569
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00003570// The process needs to know about installed plug-ins
Greg Clayton99d0faf2010-11-18 23:32:35 +00003571void
Caroline Tice20bd37f2011-03-10 22:14:10 +00003572Process::SettingsInitialize ()
Caroline Tice3df9a8d2010-09-04 00:03:46 +00003573{
Greg Claytone0d378b2011-03-24 21:19:54 +00003574 static std::vector<OptionEnumValueElement> g_plugins;
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00003575
3576 int i=0;
3577 const char *name;
3578 OptionEnumValueElement option_enum;
3579 while ((name = PluginManager::GetProcessPluginNameAtIndex (i)) != NULL)
3580 {
3581 if (name)
3582 {
3583 option_enum.value = i;
3584 option_enum.string_value = name;
3585 option_enum.usage = PluginManager::GetProcessPluginDescriptionAtIndex (i);
3586 g_plugins.push_back (option_enum);
3587 }
3588 ++i;
3589 }
3590 option_enum.value = 0;
3591 option_enum.string_value = NULL;
3592 option_enum.usage = NULL;
3593 g_plugins.push_back (option_enum);
3594
3595 for (i=0; (name = SettingsController::instance_settings_table[i].var_name); ++i)
3596 {
3597 if (::strcmp (name, "plugin") == 0)
3598 {
3599 SettingsController::instance_settings_table[i].enum_values = &g_plugins[0];
3600 break;
3601 }
3602 }
Greg Clayton99d0faf2010-11-18 23:32:35 +00003603 UserSettingsControllerSP &usc = GetSettingsController();
3604 usc.reset (new SettingsController);
3605 UserSettingsController::InitializeSettingsController (usc,
3606 SettingsController::global_settings_table,
3607 SettingsController::instance_settings_table);
Caroline Tice20bd37f2011-03-10 22:14:10 +00003608
3609 // Now call SettingsInitialize() for each 'child' of Process settings
3610 Thread::SettingsInitialize ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00003611}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00003612
Greg Clayton99d0faf2010-11-18 23:32:35 +00003613void
Caroline Tice20bd37f2011-03-10 22:14:10 +00003614Process::SettingsTerminate ()
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00003615{
Caroline Tice20bd37f2011-03-10 22:14:10 +00003616 // Must call SettingsTerminate() on each 'child' of Process settings before terminating Process settings.
3617
3618 Thread::SettingsTerminate ();
3619
3620 // Now terminate Process Settings.
3621
Greg Clayton99d0faf2010-11-18 23:32:35 +00003622 UserSettingsControllerSP &usc = GetSettingsController();
3623 UserSettingsController::FinalizeSettingsController (usc);
3624 usc.reset();
3625}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00003626
Greg Clayton99d0faf2010-11-18 23:32:35 +00003627UserSettingsControllerSP &
3628Process::GetSettingsController ()
3629{
3630 static UserSettingsControllerSP g_settings_controller;
Caroline Tice3df9a8d2010-09-04 00:03:46 +00003631 return g_settings_controller;
3632}
3633
Caroline Tice1559a462010-09-27 00:30:10 +00003634void
3635Process::UpdateInstanceName ()
3636{
Greg Claytonaa149cb2011-08-11 02:48:45 +00003637 Module *module = GetTarget().GetExecutableModulePointer();
3638 if (module)
Caroline Tice1559a462010-09-27 00:30:10 +00003639 {
3640 StreamString sstr;
Greg Claytonaa149cb2011-08-11 02:48:45 +00003641 sstr.Printf ("%s", module->GetFileSpec().GetFilename().AsCString());
Caroline Tice1559a462010-09-27 00:30:10 +00003642
Greg Claytondbe54502010-11-19 03:46:01 +00003643 GetSettingsController()->RenameInstanceSettings (GetInstanceName().AsCString(),
Greg Clayton8b82f082011-04-12 05:54:46 +00003644 sstr.GetData());
Caroline Tice1559a462010-09-27 00:30:10 +00003645 }
3646}
3647
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00003648ExecutionResults
Jim Inghamf48169b2010-11-30 02:22:11 +00003649Process::RunThreadPlan (ExecutionContext &exe_ctx,
3650 lldb::ThreadPlanSP &thread_plan_sp,
3651 bool stop_others,
3652 bool try_all_threads,
3653 bool discard_on_error,
3654 uint32_t single_thread_timeout_usec,
3655 Stream &errors)
3656{
3657 ExecutionResults return_value = eExecutionSetupError;
3658
Jim Ingham77787032011-01-20 02:03:18 +00003659 if (thread_plan_sp.get() == NULL)
3660 {
3661 errors.Printf("RunThreadPlan called with empty thread plan.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003662 return eExecutionSetupError;
Jim Ingham77787032011-01-20 02:03:18 +00003663 }
Greg Claytonc14ee322011-09-22 04:58:26 +00003664
3665 if (exe_ctx.GetProcessPtr() != this)
3666 {
3667 errors.Printf("RunThreadPlan called on wrong process.");
3668 return eExecutionSetupError;
3669 }
3670
3671 Thread *thread = exe_ctx.GetThreadPtr();
3672 if (thread == NULL)
3673 {
3674 errors.Printf("RunThreadPlan called with invalid thread.");
3675 return eExecutionSetupError;
3676 }
Jim Ingham77787032011-01-20 02:03:18 +00003677
Jim Ingham17e5c4e2011-05-17 22:24:54 +00003678 // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes.
3679 // For that to be true the plan can't be private - since private plans suppress themselves in the
3680 // GetCompletedPlan call.
3681
3682 bool orig_plan_private = thread_plan_sp->GetPrivate();
3683 thread_plan_sp->SetPrivate(false);
3684
Jim Ingham444586b2011-01-24 06:34:17 +00003685 if (m_private_state.GetValue() != eStateStopped)
3686 {
3687 errors.Printf ("RunThreadPlan called while the private state was not stopped.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003688 return eExecutionSetupError;
Jim Ingham444586b2011-01-24 06:34:17 +00003689 }
3690
Jim Ingham66243842011-08-13 00:56:10 +00003691 // Save the thread & frame from the exe_ctx for restoration after we run
Greg Claytonc14ee322011-09-22 04:58:26 +00003692 const uint32_t thread_idx_id = thread->GetIndexID();
3693 StackID ctx_frame_id = thread->GetSelectedFrame()->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00003694
3695 // N.B. Running the target may unset the currently selected thread and frame. We don't want to do that either,
3696 // so we should arrange to reset them as well.
3697
Greg Claytonc14ee322011-09-22 04:58:26 +00003698 lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
Jim Inghamf48169b2010-11-30 02:22:11 +00003699
Jim Ingham66243842011-08-13 00:56:10 +00003700 uint32_t selected_tid;
3701 StackID selected_stack_id;
Greg Clayton762f7132011-09-18 18:59:15 +00003702 if (selected_thread_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00003703 {
3704 selected_tid = selected_thread_sp->GetIndexID();
Jim Ingham66243842011-08-13 00:56:10 +00003705 selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00003706 }
3707 else
3708 {
3709 selected_tid = LLDB_INVALID_THREAD_ID;
3710 }
3711
Greg Claytonc14ee322011-09-22 04:58:26 +00003712 thread->QueueThreadPlan(thread_plan_sp, true);
Jim Inghamf48169b2010-11-30 02:22:11 +00003713
Jim Ingham1e7a9ee2011-01-23 21:14:08 +00003714 Listener listener("lldb.process.listener.run-thread-plan");
Jim Ingham0f16e732011-02-08 05:20:59 +00003715
3716 // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get
3717 // restored on exit to the function.
3718
3719 ProcessEventHijacker run_thread_plan_hijacker (*this, &listener);
Jim Ingham444586b2011-01-24 06:34:17 +00003720
Jim Ingham1e7a9ee2011-01-23 21:14:08 +00003721 lldb::LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham77787032011-01-20 02:03:18 +00003722 if (log)
3723 {
3724 StreamString s;
3725 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
Greg Clayton81c22f62011-10-19 18:09:39 +00003726 log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4llx to run thread plan \"%s\".",
Greg Claytonc14ee322011-09-22 04:58:26 +00003727 thread->GetIndexID(),
3728 thread->GetID(),
Jim Ingham0f16e732011-02-08 05:20:59 +00003729 s.GetData());
Jim Ingham77787032011-01-20 02:03:18 +00003730 }
3731
Jim Ingham0f16e732011-02-08 05:20:59 +00003732 bool got_event;
3733 lldb::EventSP event_sp;
3734 lldb::StateType stop_state = lldb::eStateInvalid;
Jim Inghamf48169b2010-11-30 02:22:11 +00003735
3736 TimeValue* timeout_ptr = NULL;
3737 TimeValue real_timeout;
3738
Jim Ingham0f16e732011-02-08 05:20:59 +00003739 bool first_timeout = true;
3740 bool do_resume = true;
Jim Inghamf48169b2010-11-30 02:22:11 +00003741
Jim Inghamf48169b2010-11-30 02:22:11 +00003742 while (1)
3743 {
Jim Ingham0f16e732011-02-08 05:20:59 +00003744 // We usually want to resume the process if we get to the top of the loop.
3745 // The only exception is if we get two running events with no intervening
3746 // stop, which can happen, we will just wait for then next stop event.
Jim Inghamf48169b2010-11-30 02:22:11 +00003747
Jim Ingham0f16e732011-02-08 05:20:59 +00003748 if (do_resume)
Jim Inghamf48169b2010-11-30 02:22:11 +00003749 {
Jim Ingham0f16e732011-02-08 05:20:59 +00003750 // Do the initial resume and wait for the running event before going further.
3751
Greg Claytonc14ee322011-09-22 04:58:26 +00003752 Error resume_error = Resume ();
Jim Ingham0f16e732011-02-08 05:20:59 +00003753 if (!resume_error.Success())
3754 {
3755 errors.Printf("Error resuming inferior: \"%s\".\n", resume_error.AsCString());
Greg Claytone0d378b2011-03-24 21:19:54 +00003756 return_value = eExecutionSetupError;
Jim Ingham0f16e732011-02-08 05:20:59 +00003757 break;
3758 }
3759
3760 real_timeout = TimeValue::Now();
3761 real_timeout.OffsetWithMicroSeconds(500000);
3762 timeout_ptr = &real_timeout;
3763
3764 got_event = listener.WaitForEvent(NULL, event_sp);
3765 if (!got_event)
3766 {
3767 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003768 log->PutCString("Didn't get any event after initial resume, exiting.");
Jim Ingham0f16e732011-02-08 05:20:59 +00003769
3770 errors.Printf("Didn't get any event after initial resume, exiting.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003771 return_value = eExecutionSetupError;
Jim Ingham0f16e732011-02-08 05:20:59 +00003772 break;
3773 }
3774
3775 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3776 if (stop_state != eStateRunning)
3777 {
3778 if (log)
3779 log->Printf("Didn't get running event after initial resume, got %s instead.", StateAsCString(stop_state));
3780
3781 errors.Printf("Didn't get running event after initial resume, got %s instead.", StateAsCString(stop_state));
Greg Claytone0d378b2011-03-24 21:19:54 +00003782 return_value = eExecutionSetupError;
Jim Ingham0f16e732011-02-08 05:20:59 +00003783 break;
3784 }
3785
3786 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003787 log->PutCString ("Resuming succeeded.");
Jim Ingham0f16e732011-02-08 05:20:59 +00003788 // We need to call the function synchronously, so spin waiting for it to return.
3789 // If we get interrupted while executing, we're going to lose our context, and
3790 // won't be able to gather the result at this point.
3791 // We set the timeout AFTER the resume, since the resume takes some time and we
3792 // don't want to charge that to the timeout.
3793
3794 if (single_thread_timeout_usec != 0)
3795 {
3796 real_timeout = TimeValue::Now();
3797 if (first_timeout)
3798 real_timeout.OffsetWithMicroSeconds(single_thread_timeout_usec);
3799 else
3800 real_timeout.OffsetWithSeconds(10);
3801
3802 timeout_ptr = &real_timeout;
3803 }
3804 }
3805 else
3806 {
3807 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003808 log->PutCString ("Handled an extra running event.");
Jim Ingham0f16e732011-02-08 05:20:59 +00003809 do_resume = true;
3810 }
3811
3812 // Now wait for the process to stop again:
3813 stop_state = lldb::eStateInvalid;
3814 event_sp.reset();
3815 got_event = listener.WaitForEvent (timeout_ptr, event_sp);
3816
3817 if (got_event)
3818 {
3819 if (event_sp.get())
3820 {
3821 bool keep_going = false;
3822 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3823 if (log)
3824 log->Printf("In while loop, got event: %s.", StateAsCString(stop_state));
3825
3826 switch (stop_state)
3827 {
3828 case lldb::eStateStopped:
Jim Ingham160f78c2011-05-17 01:10:11 +00003829 {
Greg Clayton54e8ac52011-06-03 22:12:42 +00003830 // Yay, we're done. Now make sure that our thread plan actually completed.
Greg Claytonc14ee322011-09-22 04:58:26 +00003831 ThreadSP thread_sp = GetThreadList().FindThreadByIndexID (thread_idx_id);
Greg Clayton54e8ac52011-06-03 22:12:42 +00003832 if (!thread_sp)
Jim Ingham160f78c2011-05-17 01:10:11 +00003833 {
Greg Clayton54e8ac52011-06-03 22:12:42 +00003834 // Ooh, our thread has vanished. Unlikely that this was successful execution...
Jim Ingham160f78c2011-05-17 01:10:11 +00003835 if (log)
Greg Clayton54e8ac52011-06-03 22:12:42 +00003836 log->Printf ("Execution completed but our thread (index-id=%u) has vanished.", thread_idx_id);
3837 return_value = eExecutionInterrupted;
Jim Ingham160f78c2011-05-17 01:10:11 +00003838 }
3839 else
3840 {
Greg Clayton54e8ac52011-06-03 22:12:42 +00003841 StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
3842 StopReason stop_reason = eStopReasonInvalid;
3843 if (stop_info_sp)
3844 stop_reason = stop_info_sp->GetStopReason();
3845 if (stop_reason == eStopReasonPlanComplete)
3846 {
3847 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003848 log->PutCString ("Execution completed successfully.");
Greg Clayton54e8ac52011-06-03 22:12:42 +00003849 // Now mark this plan as private so it doesn't get reported as the stop reason
3850 // after this point.
3851 if (thread_plan_sp)
3852 thread_plan_sp->SetPrivate (orig_plan_private);
3853 return_value = eExecutionCompleted;
3854 }
3855 else
3856 {
3857 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003858 log->PutCString ("Thread plan didn't successfully complete.");
Greg Clayton54e8ac52011-06-03 22:12:42 +00003859
3860 return_value = eExecutionInterrupted;
3861 }
Jim Ingham160f78c2011-05-17 01:10:11 +00003862 }
Greg Clayton54e8ac52011-06-03 22:12:42 +00003863 }
3864 break;
3865
Jim Ingham0f16e732011-02-08 05:20:59 +00003866 case lldb::eStateCrashed:
3867 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003868 log->PutCString ("Execution crashed.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003869 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00003870 break;
Greg Clayton54e8ac52011-06-03 22:12:42 +00003871
Jim Ingham0f16e732011-02-08 05:20:59 +00003872 case lldb::eStateRunning:
3873 do_resume = false;
3874 keep_going = true;
3875 break;
Greg Clayton54e8ac52011-06-03 22:12:42 +00003876
Jim Ingham0f16e732011-02-08 05:20:59 +00003877 default:
3878 if (log)
3879 log->Printf("Execution stopped with unexpected state: %s.", StateAsCString(stop_state));
Jim Ingham160f78c2011-05-17 01:10:11 +00003880
3881 errors.Printf ("Execution stopped with unexpected state.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003882 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00003883 break;
3884 }
3885 if (keep_going)
3886 continue;
3887 else
3888 break;
3889 }
3890 else
3891 {
3892 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003893 log->PutCString ("got_event was true, but the event pointer was null. How odd...");
Greg Claytone0d378b2011-03-24 21:19:54 +00003894 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00003895 break;
3896 }
3897 }
3898 else
3899 {
3900 // If we didn't get an event that means we've timed out...
3901 // We will interrupt the process here. Depending on what we were asked to do we will
3902 // either exit, or try with all threads running for the same timeout.
Jim Inghamf48169b2010-11-30 02:22:11 +00003903 // Not really sure what to do if Halt fails here...
Jim Ingham0f16e732011-02-08 05:20:59 +00003904
Stephen Wilson78a4feb2011-01-12 04:20:03 +00003905 if (log) {
Jim Inghamf48169b2010-11-30 02:22:11 +00003906 if (try_all_threads)
Jim Ingham0f16e732011-02-08 05:20:59 +00003907 {
3908 if (first_timeout)
3909 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %d timed out, "
3910 "trying with all threads enabled.",
3911 single_thread_timeout_usec);
3912 else
3913 log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled "
3914 "and timeout: %d timed out.",
3915 single_thread_timeout_usec);
3916 }
Jim Inghamf48169b2010-11-30 02:22:11 +00003917 else
Jim Ingham0f16e732011-02-08 05:20:59 +00003918 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %d timed out, "
3919 "halt and abandoning execution.",
Jim Inghamf48169b2010-11-30 02:22:11 +00003920 single_thread_timeout_usec);
Stephen Wilson78a4feb2011-01-12 04:20:03 +00003921 }
Jim Inghamf48169b2010-11-30 02:22:11 +00003922
Greg Claytonc14ee322011-09-22 04:58:26 +00003923 Error halt_error = Halt();
Jim Inghame22e88b2011-01-22 01:30:53 +00003924 if (halt_error.Success())
Jim Inghamf48169b2010-11-30 02:22:11 +00003925 {
Jim Inghamf48169b2010-11-30 02:22:11 +00003926 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003927 log->PutCString ("Process::RunThreadPlan(): Halt succeeded.");
Jim Inghamf48169b2010-11-30 02:22:11 +00003928
Jim Ingham0f16e732011-02-08 05:20:59 +00003929 // If halt succeeds, it always produces a stopped event. Wait for that:
3930
3931 real_timeout = TimeValue::Now();
3932 real_timeout.OffsetWithMicroSeconds(500000);
3933
3934 got_event = listener.WaitForEvent(&real_timeout, event_sp);
Jim Inghamf48169b2010-11-30 02:22:11 +00003935
3936 if (got_event)
3937 {
3938 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3939 if (log)
3940 {
Greg Clayton414f5d32011-01-25 02:58:48 +00003941 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state));
Jim Ingham0f16e732011-02-08 05:20:59 +00003942 if (stop_state == lldb::eStateStopped
3943 && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
Jim Ingham20829ac2011-08-09 22:24:33 +00003944 log->PutCString (" Event was the Halt interruption event.");
Jim Inghamf48169b2010-11-30 02:22:11 +00003945 }
3946
Jim Ingham0f16e732011-02-08 05:20:59 +00003947 if (stop_state == lldb::eStateStopped)
Jim Inghamf48169b2010-11-30 02:22:11 +00003948 {
Jim Ingham0f16e732011-02-08 05:20:59 +00003949 // Between the time we initiated the Halt and the time we delivered it, the process could have
3950 // already finished its job. Check that here:
Jim Inghamf48169b2010-11-30 02:22:11 +00003951
Greg Claytonc14ee322011-09-22 04:58:26 +00003952 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
Jim Ingham0f16e732011-02-08 05:20:59 +00003953 {
3954 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003955 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
Jim Ingham0f16e732011-02-08 05:20:59 +00003956 "Exiting wait loop.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003957 return_value = eExecutionCompleted;
Jim Ingham0f16e732011-02-08 05:20:59 +00003958 break;
3959 }
Jim Inghamf48169b2010-11-30 02:22:11 +00003960
Jim Ingham0f16e732011-02-08 05:20:59 +00003961 if (!try_all_threads)
3962 {
3963 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003964 log->PutCString ("try_all_threads was false, we stopped so now we're quitting.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003965 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00003966 break;
3967 }
3968
3969 if (first_timeout)
3970 {
3971 // Set all the other threads to run, and return to the top of the loop, which will continue;
3972 first_timeout = false;
3973 thread_plan_sp->SetStopOthers (false);
3974 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003975 log->PutCString ("Process::RunThreadPlan(): About to resume.");
Jim Ingham0f16e732011-02-08 05:20:59 +00003976
3977 continue;
3978 }
3979 else
3980 {
3981 // Running all threads failed, so return Interrupted.
3982 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003983 log->PutCString("Process::RunThreadPlan(): running all threads timed out.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003984 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00003985 break;
3986 }
Jim Inghamf48169b2010-11-30 02:22:11 +00003987 }
Jim Ingham0f16e732011-02-08 05:20:59 +00003988 }
3989 else
3990 { if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00003991 log->PutCString("Process::RunThreadPlan(): halt said it succeeded, but I got no event. "
Jim Ingham0f16e732011-02-08 05:20:59 +00003992 "I'm getting out of here passing Interrupted.");
Greg Claytone0d378b2011-03-24 21:19:54 +00003993 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00003994 break;
Jim Inghamf48169b2010-11-30 02:22:11 +00003995 }
3996 }
Jim Inghame22e88b2011-01-22 01:30:53 +00003997 else
3998 {
Jim Ingham0f16e732011-02-08 05:20:59 +00003999 // This branch is to work around some problems with gdb-remote's Halt. It is a little racy, and can return
4000 // an error from halt, but if you wait a bit you'll get a stopped event anyway.
Jim Inghame22e88b2011-01-22 01:30:53 +00004001 if (log)
Jim Ingham0f16e732011-02-08 05:20:59 +00004002 log->Printf ("Process::RunThreadPlan(): halt failed: error = \"%s\", I'm just going to wait a little longer and see if I get a stopped event.",
4003 halt_error.AsCString());
4004 real_timeout = TimeValue::Now();
4005 real_timeout.OffsetWithMicroSeconds(500000);
4006 timeout_ptr = &real_timeout;
4007 got_event = listener.WaitForEvent(&real_timeout, event_sp);
4008 if (!got_event || event_sp.get() == NULL)
Jim Ingham1e7a9ee2011-01-23 21:14:08 +00004009 {
Jim Ingham0f16e732011-02-08 05:20:59 +00004010 // This is not going anywhere, bag out.
4011 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004012 log->PutCString ("Process::RunThreadPlan(): halt failed: and waiting for the stopped event failed.");
Greg Claytone0d378b2011-03-24 21:19:54 +00004013 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00004014 break;
Jim Ingham1e7a9ee2011-01-23 21:14:08 +00004015 }
Jim Ingham0f16e732011-02-08 05:20:59 +00004016 else
4017 {
4018 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4019 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004020 log->PutCString ("Process::RunThreadPlan(): halt failed: but then I got a stopped event. Whatever...");
Jim Ingham0f16e732011-02-08 05:20:59 +00004021 if (stop_state == lldb::eStateStopped)
4022 {
4023 // Between the time we initiated the Halt and the time we delivered it, the process could have
4024 // already finished its job. Check that here:
4025
Greg Claytonc14ee322011-09-22 04:58:26 +00004026 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
Jim Ingham0f16e732011-02-08 05:20:59 +00004027 {
4028 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004029 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
Jim Ingham0f16e732011-02-08 05:20:59 +00004030 "Exiting wait loop.");
Greg Claytone0d378b2011-03-24 21:19:54 +00004031 return_value = eExecutionCompleted;
Jim Ingham0f16e732011-02-08 05:20:59 +00004032 break;
4033 }
4034
4035 if (first_timeout)
4036 {
4037 // Set all the other threads to run, and return to the top of the loop, which will continue;
4038 first_timeout = false;
4039 thread_plan_sp->SetStopOthers (false);
4040 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004041 log->PutCString ("Process::RunThreadPlan(): About to resume.");
Jim Ingham0f16e732011-02-08 05:20:59 +00004042
4043 continue;
4044 }
4045 else
4046 {
4047 // Running all threads failed, so return Interrupted.
4048 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004049 log->PutCString ("Process::RunThreadPlan(): running all threads timed out.");
Greg Claytone0d378b2011-03-24 21:19:54 +00004050 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00004051 break;
4052 }
4053 }
4054 else
4055 {
Sean Callanan39821ac2011-08-09 22:07:08 +00004056 if (log)
4057 log->Printf ("Process::RunThreadPlan(): halt failed, I waited and didn't get"
4058 " a stopped event, instead got %s.", StateAsCString(stop_state));
Greg Claytone0d378b2011-03-24 21:19:54 +00004059 return_value = eExecutionInterrupted;
Jim Ingham0f16e732011-02-08 05:20:59 +00004060 break;
4061 }
4062 }
Jim Inghame22e88b2011-01-22 01:30:53 +00004063 }
4064
Jim Inghamf48169b2010-11-30 02:22:11 +00004065 }
4066
Jim Ingham0f16e732011-02-08 05:20:59 +00004067 } // END WAIT LOOP
4068
4069 // Now do some processing on the results of the run:
4070 if (return_value == eExecutionInterrupted)
4071 {
Jim Inghamf48169b2010-11-30 02:22:11 +00004072 if (log)
Jim Ingham0f16e732011-02-08 05:20:59 +00004073 {
4074 StreamString s;
4075 if (event_sp)
4076 event_sp->Dump (&s);
4077 else
4078 {
Jim Ingham20829ac2011-08-09 22:24:33 +00004079 log->PutCString ("Process::RunThreadPlan(): Stop event that interrupted us is NULL.");
Jim Ingham0f16e732011-02-08 05:20:59 +00004080 }
4081
4082 StreamString ts;
4083
Jim Ingham20829ac2011-08-09 22:24:33 +00004084 const char *event_explanation = NULL;
Jim Ingham0f16e732011-02-08 05:20:59 +00004085
4086 do
4087 {
4088 const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get());
4089
4090 if (!event_data)
4091 {
4092 event_explanation = "<no event data>";
4093 break;
4094 }
4095
4096 Process *process = event_data->GetProcessSP().get();
4097
4098 if (!process)
4099 {
4100 event_explanation = "<no process>";
4101 break;
4102 }
4103
4104 ThreadList &thread_list = process->GetThreadList();
4105
4106 uint32_t num_threads = thread_list.GetSize();
4107 uint32_t thread_index;
4108
4109 ts.Printf("<%u threads> ", num_threads);
4110
4111 for (thread_index = 0;
4112 thread_index < num_threads;
4113 ++thread_index)
4114 {
4115 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
4116
4117 if (!thread)
4118 {
4119 ts.Printf("<?> ");
4120 continue;
4121 }
4122
Greg Clayton81c22f62011-10-19 18:09:39 +00004123 ts.Printf("<0x%4.4llx ", thread->GetID());
Jim Ingham0f16e732011-02-08 05:20:59 +00004124 RegisterContext *register_context = thread->GetRegisterContext().get();
4125
4126 if (register_context)
4127 ts.Printf("[ip 0x%llx] ", register_context->GetPC());
4128 else
4129 ts.Printf("[ip unknown] ");
4130
4131 lldb::StopInfoSP stop_info_sp = thread->GetStopInfo();
4132 if (stop_info_sp)
4133 {
4134 const char *stop_desc = stop_info_sp->GetDescription();
4135 if (stop_desc)
4136 ts.PutCString (stop_desc);
4137 }
4138 ts.Printf(">");
4139 }
4140
4141 event_explanation = ts.GetData();
4142 } while (0);
4143
4144 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004145 {
4146 if (event_explanation)
4147 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation);
4148 else
4149 log->Printf("Process::RunThreadPlan(): execution interrupted: %s", s.GetData());
4150 }
Jim Ingham0f16e732011-02-08 05:20:59 +00004151
4152 if (discard_on_error && thread_plan_sp)
4153 {
Greg Claytonc14ee322011-09-22 04:58:26 +00004154 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Ingham4b536182011-08-09 02:12:22 +00004155 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Ingham0f16e732011-02-08 05:20:59 +00004156 }
4157 }
4158 }
4159 else if (return_value == eExecutionSetupError)
4160 {
4161 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004162 log->PutCString("Process::RunThreadPlan(): execution set up error.");
Jim Ingham0f16e732011-02-08 05:20:59 +00004163
4164 if (discard_on_error && thread_plan_sp)
4165 {
Greg Claytonc14ee322011-09-22 04:58:26 +00004166 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Ingham4b536182011-08-09 02:12:22 +00004167 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Ingham0f16e732011-02-08 05:20:59 +00004168 }
4169 }
4170 else
4171 {
Greg Claytonc14ee322011-09-22 04:58:26 +00004172 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
Jim Inghamf48169b2010-11-30 02:22:11 +00004173 {
Greg Clayton414f5d32011-01-25 02:58:48 +00004174 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004175 log->PutCString("Process::RunThreadPlan(): thread plan is done");
Greg Claytone0d378b2011-03-24 21:19:54 +00004176 return_value = eExecutionCompleted;
Jim Inghamf48169b2010-11-30 02:22:11 +00004177 }
Greg Claytonc14ee322011-09-22 04:58:26 +00004178 else if (thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
Jim Inghamf48169b2010-11-30 02:22:11 +00004179 {
Greg Clayton414f5d32011-01-25 02:58:48 +00004180 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004181 log->PutCString("Process::RunThreadPlan(): thread plan was discarded");
Greg Claytone0d378b2011-03-24 21:19:54 +00004182 return_value = eExecutionDiscarded;
Jim Inghamf48169b2010-11-30 02:22:11 +00004183 }
4184 else
4185 {
4186 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004187 log->PutCString("Process::RunThreadPlan(): thread plan stopped in mid course");
Jim Inghamf48169b2010-11-30 02:22:11 +00004188 if (discard_on_error && thread_plan_sp)
4189 {
Jim Ingham0f16e732011-02-08 05:20:59 +00004190 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00004191 log->PutCString("Process::RunThreadPlan(): discarding thread plan 'cause discard_on_error is set.");
Greg Claytonc14ee322011-09-22 04:58:26 +00004192 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Ingham4b536182011-08-09 02:12:22 +00004193 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Inghamf48169b2010-11-30 02:22:11 +00004194 }
Jim Inghamf48169b2010-11-30 02:22:11 +00004195 }
4196 }
Jim Ingham0f16e732011-02-08 05:20:59 +00004197
Jim Inghamf48169b2010-11-30 02:22:11 +00004198 // Thread we ran the function in may have gone away because we ran the target
Jim Ingham66243842011-08-13 00:56:10 +00004199 // Check that it's still there, and if it is put it back in the context. Also restore the
4200 // frame in the context if it is still present.
Greg Claytonc14ee322011-09-22 04:58:26 +00004201 thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
4202 if (thread)
Jim Ingham66243842011-08-13 00:56:10 +00004203 {
Greg Claytonc14ee322011-09-22 04:58:26 +00004204 exe_ctx.SetFrameSP (thread->GetFrameWithStackID (ctx_frame_id));
Jim Ingham66243842011-08-13 00:56:10 +00004205 }
Jim Inghamf48169b2010-11-30 02:22:11 +00004206
4207 // Also restore the current process'es selected frame & thread, since this function calling may
4208 // be done behind the user's back.
4209
4210 if (selected_tid != LLDB_INVALID_THREAD_ID)
4211 {
Greg Claytonc14ee322011-09-22 04:58:26 +00004212 if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid())
Jim Inghamf48169b2010-11-30 02:22:11 +00004213 {
4214 // We were able to restore the selected thread, now restore the frame:
Greg Claytonc14ee322011-09-22 04:58:26 +00004215 StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
Jim Ingham66243842011-08-13 00:56:10 +00004216 if (old_frame_sp)
Greg Claytonc14ee322011-09-22 04:58:26 +00004217 GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
Jim Inghamf48169b2010-11-30 02:22:11 +00004218 }
4219 }
4220
4221 return return_value;
4222}
4223
4224const char *
4225Process::ExecutionResultAsCString (ExecutionResults result)
4226{
4227 const char *result_name;
4228
4229 switch (result)
4230 {
Greg Claytone0d378b2011-03-24 21:19:54 +00004231 case eExecutionCompleted:
Jim Inghamf48169b2010-11-30 02:22:11 +00004232 result_name = "eExecutionCompleted";
4233 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00004234 case eExecutionDiscarded:
Jim Inghamf48169b2010-11-30 02:22:11 +00004235 result_name = "eExecutionDiscarded";
4236 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00004237 case eExecutionInterrupted:
Jim Inghamf48169b2010-11-30 02:22:11 +00004238 result_name = "eExecutionInterrupted";
4239 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00004240 case eExecutionSetupError:
Jim Inghamf48169b2010-11-30 02:22:11 +00004241 result_name = "eExecutionSetupError";
4242 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00004243 case eExecutionTimedOut:
Jim Inghamf48169b2010-11-30 02:22:11 +00004244 result_name = "eExecutionTimedOut";
4245 break;
4246 }
4247 return result_name;
4248}
4249
Greg Clayton7260f622011-04-18 08:33:37 +00004250void
4251Process::GetStatus (Stream &strm)
4252{
4253 const StateType state = GetState();
Greg Clayton2637f822011-11-17 01:23:07 +00004254 if (StateIsStoppedState(state, false))
Greg Clayton7260f622011-04-18 08:33:37 +00004255 {
4256 if (state == eStateExited)
4257 {
4258 int exit_status = GetExitStatus();
4259 const char *exit_description = GetExitDescription();
Greg Clayton81c22f62011-10-19 18:09:39 +00004260 strm.Printf ("Process %llu exited with status = %i (0x%8.8x) %s\n",
Greg Clayton7260f622011-04-18 08:33:37 +00004261 GetID(),
4262 exit_status,
4263 exit_status,
4264 exit_description ? exit_description : "");
4265 }
4266 else
4267 {
4268 if (state == eStateConnected)
4269 strm.Printf ("Connected to remote target.\n");
4270 else
Greg Clayton81c22f62011-10-19 18:09:39 +00004271 strm.Printf ("Process %llu %s\n", GetID(), StateAsCString (state));
Greg Clayton7260f622011-04-18 08:33:37 +00004272 }
4273 }
4274 else
4275 {
Greg Clayton81c22f62011-10-19 18:09:39 +00004276 strm.Printf ("Process %llu is running.\n", GetID());
Greg Clayton7260f622011-04-18 08:33:37 +00004277 }
4278}
4279
4280size_t
4281Process::GetThreadStatus (Stream &strm,
4282 bool only_threads_with_stop_reason,
4283 uint32_t start_frame,
4284 uint32_t num_frames,
4285 uint32_t num_frames_with_source)
4286{
4287 size_t num_thread_infos_dumped = 0;
4288
4289 const size_t num_threads = GetThreadList().GetSize();
4290 for (uint32_t i = 0; i < num_threads; i++)
4291 {
4292 Thread *thread = GetThreadList().GetThreadAtIndex(i).get();
4293 if (thread)
4294 {
4295 if (only_threads_with_stop_reason)
4296 {
4297 if (thread->GetStopInfo().get() == NULL)
4298 continue;
4299 }
4300 thread->GetStatus (strm,
4301 start_frame,
4302 num_frames,
4303 num_frames_with_source);
4304 ++num_thread_infos_dumped;
4305 }
4306 }
4307 return num_thread_infos_dumped;
4308}
4309
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004310//--------------------------------------------------------------
Greg Clayton1b654882010-09-19 02:33:57 +00004311// class Process::SettingsController
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004312//--------------------------------------------------------------
4313
Greg Clayton1b654882010-09-19 02:33:57 +00004314Process::SettingsController::SettingsController () :
Caroline Ticedaccaa92010-09-20 20:44:43 +00004315 UserSettingsController ("process", Target::GetSettingsController())
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004316{
Greg Clayton85851dd2010-12-04 00:10:17 +00004317 m_default_settings.reset (new ProcessInstanceSettings (*this,
4318 false,
Caroline Tice91123da2010-09-08 17:48:55 +00004319 InstanceSettings::GetDefaultName().AsCString()));
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004320}
4321
Greg Clayton1b654882010-09-19 02:33:57 +00004322Process::SettingsController::~SettingsController ()
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004323{
4324}
4325
4326lldb::InstanceSettingsSP
Greg Clayton1b654882010-09-19 02:33:57 +00004327Process::SettingsController::CreateInstanceSettings (const char *instance_name)
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004328{
Greg Claytondbe54502010-11-19 03:46:01 +00004329 ProcessInstanceSettings *new_settings = new ProcessInstanceSettings (*GetSettingsController(),
4330 false,
4331 instance_name);
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004332 lldb::InstanceSettingsSP new_settings_sp (new_settings);
4333 return new_settings_sp;
4334}
4335
4336//--------------------------------------------------------------
4337// class ProcessInstanceSettings
4338//--------------------------------------------------------------
4339
Greg Clayton85851dd2010-12-04 00:10:17 +00004340ProcessInstanceSettings::ProcessInstanceSettings
4341(
4342 UserSettingsController &owner,
4343 bool live_instance,
4344 const char *name
4345) :
Greg Clayton1d885962011-11-08 02:43:13 +00004346 InstanceSettings (owner, name ? name : InstanceSettings::InvalidName().AsCString(), live_instance)
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004347{
Caroline Ticef20e8232010-09-09 18:26:37 +00004348 // CopyInstanceSettings is a pure virtual function in InstanceSettings; it therefore cannot be called
4349 // until the vtables for ProcessInstanceSettings are properly set up, i.e. AFTER all the initializers.
4350 // For this reason it has to be called here, rather than in the initializer or in the parent constructor.
Caroline Tice9e41c152010-09-16 19:05:55 +00004351 // This is true for CreateInstanceName() too.
Greg Clayton1d885962011-11-08 02:43:13 +00004352
Caroline Tice9e41c152010-09-16 19:05:55 +00004353 if (GetInstanceName () == InstanceSettings::InvalidName())
4354 {
4355 ChangeInstanceName (std::string (CreateInstanceName().AsCString()));
4356 m_owner.RegisterInstanceSettings (this);
4357 }
Greg Clayton1d885962011-11-08 02:43:13 +00004358
Caroline Ticef20e8232010-09-09 18:26:37 +00004359 if (live_instance)
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004360 {
4361 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name);
4362 CopyInstanceSettings (pending_settings,false);
Caroline Ticef20e8232010-09-09 18:26:37 +00004363 //m_owner.RemovePendingSettings (m_instance_name);
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004364 }
4365}
4366
4367ProcessInstanceSettings::ProcessInstanceSettings (const ProcessInstanceSettings &rhs) :
Greg Clayton1d885962011-11-08 02:43:13 +00004368 InstanceSettings (*Process::GetSettingsController(), CreateInstanceName().AsCString())
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004369{
4370 if (m_instance_name != InstanceSettings::GetDefaultName())
4371 {
4372 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name);
4373 CopyInstanceSettings (pending_settings,false);
4374 m_owner.RemovePendingSettings (m_instance_name);
4375 }
4376}
4377
4378ProcessInstanceSettings::~ProcessInstanceSettings ()
4379{
4380}
4381
4382ProcessInstanceSettings&
4383ProcessInstanceSettings::operator= (const ProcessInstanceSettings &rhs)
4384{
4385 if (this != &rhs)
4386 {
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004387 }
4388
4389 return *this;
4390}
4391
4392
4393void
4394ProcessInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var_name,
4395 const char *index_value,
4396 const char *value,
4397 const ConstString &instance_name,
4398 const SettingEntry &entry,
Greg Claytone0d378b2011-03-24 21:19:54 +00004399 VarSetOperationType op,
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004400 Error &err,
4401 bool pending)
4402{
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004403}
4404
4405void
4406ProcessInstanceSettings::CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings,
4407 bool pending)
4408{
Greg Clayton1d885962011-11-08 02:43:13 +00004409// if (new_settings.get() == NULL)
4410// return;
4411//
4412// ProcessInstanceSettings *new_process_settings = (ProcessInstanceSettings *) new_settings.get();
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004413}
4414
Caroline Tice12cecd72010-09-20 21:37:42 +00004415bool
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004416ProcessInstanceSettings::GetInstanceSettingsValue (const SettingEntry &entry,
4417 const ConstString &var_name,
Caroline Ticedaccaa92010-09-20 20:44:43 +00004418 StringList &value,
Caroline Tice12cecd72010-09-20 21:37:42 +00004419 Error *err)
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004420{
Greg Clayton1d885962011-11-08 02:43:13 +00004421 if (err)
4422 err->SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString());
4423 return false;
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004424}
4425
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004426const ConstString
4427ProcessInstanceSettings::CreateInstanceName ()
4428{
4429 static int instance_count = 1;
4430 StreamString sstr;
4431
4432 sstr.Printf ("process_%d", instance_count);
4433 ++instance_count;
4434
4435 const ConstString ret_val (sstr.GetData());
4436 return ret_val;
4437}
4438
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004439//--------------------------------------------------
Greg Clayton1b654882010-09-19 02:33:57 +00004440// SettingsController Variable Tables
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004441//--------------------------------------------------
4442
4443SettingEntry
Greg Clayton1b654882010-09-19 02:33:57 +00004444Process::SettingsController::global_settings_table[] =
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004445{
4446 //{ "var-name", var-type , "default", enum-table, init'd, hidden, "help-text"},
4447 { NULL, eSetVarTypeNone, NULL, NULL, 0, 0, NULL }
4448};
4449
4450
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004451SettingEntry
Greg Clayton1b654882010-09-19 02:33:57 +00004452Process::SettingsController::instance_settings_table[] =
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004453{
Greg Clayton85851dd2010-12-04 00:10:17 +00004454 //{ "var-name", var-type, "default", enum-table, init'd, hidden, "help-text"},
Greg Clayton85851dd2010-12-04 00:10:17 +00004455 { NULL, eSetVarTypeNone, NULL, NULL, false, false, NULL }
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004456};
4457
4458
Jim Ingham5aee1622010-08-09 23:31:02 +00004459
Greg Clayton1d885962011-11-08 02:43:13 +00004460