blob: 756f99950803a202b1d0bbbbb2c30f6b44efe94c [file] [log] [blame]
Chris Lattner24943d22010-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 Tice861efb32010-11-16 05:07:41 +000017#include "lldb/Core/ConnectionFileDescriptor.h"
Chris Lattner24943d22010-06-08 16:52:24 +000018#include "lldb/Core/Debugger.h"
Caroline Tice861efb32010-11-16 05:07:41 +000019#include "lldb/Core/InputReader.h"
Chris Lattner24943d22010-06-08 16:52:24 +000020#include "lldb/Core/Log.h"
21#include "lldb/Core/PluginManager.h"
22#include "lldb/Core/State.h"
Greg Claytonf15996e2011-04-07 22:46:35 +000023#include "lldb/Expression/ClangUserExpression.h"
Caroline Tice6e4c5ce2010-09-04 00:03:46 +000024#include "lldb/Interpreter/CommandInterpreter.h"
Chris Lattner24943d22010-06-08 16:52:24 +000025#include "lldb/Host/Host.h"
26#include "lldb/Target/ABI.h"
Greg Clayton0baa3942010-11-04 01:54:29 +000027#include "lldb/Target/DynamicLoader.h"
Jim Ingham642036f2010-09-23 02:01:19 +000028#include "lldb/Target/LanguageRuntime.h"
29#include "lldb/Target/CPPLanguageRuntime.h"
30#include "lldb/Target/ObjCLanguageRuntime.h"
Greg Claytone4b9c1f2011-03-08 22:40:15 +000031#include "lldb/Target/Platform.h"
Chris Lattner24943d22010-06-08 16:52:24 +000032#include "lldb/Target/RegisterContext.h"
Greg Clayton643ee732010-08-04 01:40:35 +000033#include "lldb/Target/StopInfo.h"
Chris Lattner24943d22010-06-08 16:52:24 +000034#include "lldb/Target/Target.h"
35#include "lldb/Target/TargetList.h"
36#include "lldb/Target/Thread.h"
37#include "lldb/Target/ThreadPlan.h"
38
39using namespace lldb;
40using namespace lldb_private;
41
Greg Clayton24bc5d92011-03-30 18:16:51 +000042void
Greg Claytonb72d0f02011-04-12 05:54:46 +000043ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const
Greg Clayton24bc5d92011-03-30 18:16:51 +000044{
45 const char *cstr;
Greg Claytonff39f742011-04-01 00:29:43 +000046 if (m_pid != LLDB_INVALID_PROCESS_ID)
47 s.Printf (" pid = %i\n", m_pid);
48
49 if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
50 s.Printf (" parent = %i\n", m_parent_pid);
51
52 if (m_executable)
53 {
54 s.Printf (" name = %s\n", m_executable.GetFilename().GetCString());
55 s.PutCString (" file = ");
56 m_executable.Dump(&s);
57 s.EOL();
58 }
Greg Claytonb72d0f02011-04-12 05:54:46 +000059 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Claytonff39f742011-04-01 00:29:43 +000060 if (argc > 0)
61 {
62 for (uint32_t i=0; i<argc; i++)
63 {
Greg Claytonb72d0f02011-04-12 05:54:46 +000064 const char *arg = m_arguments.GetArgumentAtIndex(i);
Greg Claytonff39f742011-04-01 00:29:43 +000065 if (i < 10)
Greg Claytonb72d0f02011-04-12 05:54:46 +000066 s.Printf (" arg[%u] = %s\n", i, arg);
Greg Claytonff39f742011-04-01 00:29:43 +000067 else
Greg Claytonb72d0f02011-04-12 05:54:46 +000068 s.Printf ("arg[%u] = %s\n", i, arg);
Greg Claytonff39f742011-04-01 00:29:43 +000069 }
70 }
Greg Claytonb72d0f02011-04-12 05:54:46 +000071
72 const uint32_t envc = m_environment.GetArgumentCount();
73 if (envc > 0)
74 {
75 for (uint32_t i=0; i<envc; i++)
76 {
77 const char *env = m_environment.GetArgumentAtIndex(i);
78 if (i < 10)
79 s.Printf (" env[%u] = %s\n", i, env);
80 else
81 s.Printf ("env[%u] = %s\n", i, env);
82 }
83 }
84
Greg Claytonff39f742011-04-01 00:29:43 +000085 if (m_arch.IsValid())
86 s.Printf (" arch = %s\n", m_arch.GetTriple().str().c_str());
87
Greg Claytonb72d0f02011-04-12 05:54:46 +000088 if (m_uid != UINT32_MAX)
Greg Clayton24bc5d92011-03-30 18:16:51 +000089 {
Greg Claytonb72d0f02011-04-12 05:54:46 +000090 cstr = platform->GetUserName (m_uid);
91 s.Printf (" uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
Greg Clayton24bc5d92011-03-30 18:16:51 +000092 }
Greg Claytonb72d0f02011-04-12 05:54:46 +000093 if (m_gid != UINT32_MAX)
Greg Clayton24bc5d92011-03-30 18:16:51 +000094 {
Greg Claytonb72d0f02011-04-12 05:54:46 +000095 cstr = platform->GetGroupName (m_gid);
96 s.Printf (" gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
Greg Clayton24bc5d92011-03-30 18:16:51 +000097 }
Greg Claytonb72d0f02011-04-12 05:54:46 +000098 if (m_euid != UINT32_MAX)
Greg Clayton24bc5d92011-03-30 18:16:51 +000099 {
Greg Claytonb72d0f02011-04-12 05:54:46 +0000100 cstr = platform->GetUserName (m_euid);
101 s.Printf (" euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
Greg Clayton24bc5d92011-03-30 18:16:51 +0000102 }
Greg Claytonb72d0f02011-04-12 05:54:46 +0000103 if (m_egid != UINT32_MAX)
Greg Clayton24bc5d92011-03-30 18:16:51 +0000104 {
Greg Claytonb72d0f02011-04-12 05:54:46 +0000105 cstr = platform->GetGroupName (m_egid);
106 s.Printf (" egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
Greg Clayton24bc5d92011-03-30 18:16:51 +0000107 }
108}
109
110void
Greg Claytonb72d0f02011-04-12 05:54:46 +0000111ProcessInstanceInfo::DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose)
Greg Clayton24bc5d92011-03-30 18:16:51 +0000112{
Greg Claytonb72d0f02011-04-12 05:54:46 +0000113 const char *label;
114 if (show_args || verbose)
115 label = "ARGUMENTS";
116 else
117 label = "NAME";
118
Greg Claytonff39f742011-04-01 00:29:43 +0000119 if (verbose)
120 {
Greg Claytonb72d0f02011-04-12 05:54:46 +0000121 s.Printf ("PID PARENT USER GROUP EFF USER EFF GROUP TRIPLE %s\n", label);
Greg Claytonff39f742011-04-01 00:29:43 +0000122 s.PutCString ("====== ====== ========== ========== ========== ========== ======================== ============================\n");
123 }
124 else
125 {
Greg Claytonb72d0f02011-04-12 05:54:46 +0000126 s.Printf ("PID PARENT USER ARCH %s\n", label);
Greg Claytonff39f742011-04-01 00:29:43 +0000127 s.PutCString ("====== ====== ========== ======= ============================\n");
128 }
Greg Clayton24bc5d92011-03-30 18:16:51 +0000129}
130
131void
Greg Claytonb72d0f02011-04-12 05:54:46 +0000132ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const
Greg Clayton24bc5d92011-03-30 18:16:51 +0000133{
134 if (m_pid != LLDB_INVALID_PROCESS_ID)
135 {
136 const char *cstr;
137 s.Printf ("%-6u %-6u ", m_pid, m_parent_pid);
138
Greg Clayton24bc5d92011-03-30 18:16:51 +0000139
Greg Claytonff39f742011-04-01 00:29:43 +0000140 if (verbose)
141 {
Greg Claytonb72d0f02011-04-12 05:54:46 +0000142 cstr = platform->GetUserName (m_uid);
Greg Claytonff39f742011-04-01 00:29:43 +0000143 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
144 s.Printf ("%-10s ", cstr);
145 else
Greg Claytonb72d0f02011-04-12 05:54:46 +0000146 s.Printf ("%-10u ", m_uid);
Greg Clayton24bc5d92011-03-30 18:16:51 +0000147
Greg Claytonb72d0f02011-04-12 05:54:46 +0000148 cstr = platform->GetGroupName (m_gid);
Greg Claytonff39f742011-04-01 00:29:43 +0000149 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
150 s.Printf ("%-10s ", cstr);
151 else
Greg Claytonb72d0f02011-04-12 05:54:46 +0000152 s.Printf ("%-10u ", m_gid);
Greg Clayton24bc5d92011-03-30 18:16:51 +0000153
Greg Claytonb72d0f02011-04-12 05:54:46 +0000154 cstr = platform->GetUserName (m_euid);
Greg Claytonff39f742011-04-01 00:29:43 +0000155 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
156 s.Printf ("%-10s ", cstr);
157 else
Greg Claytonb72d0f02011-04-12 05:54:46 +0000158 s.Printf ("%-10u ", m_euid);
Greg Claytonff39f742011-04-01 00:29:43 +0000159
Greg Claytonb72d0f02011-04-12 05:54:46 +0000160 cstr = platform->GetGroupName (m_egid);
Greg Claytonff39f742011-04-01 00:29:43 +0000161 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
162 s.Printf ("%-10s ", cstr);
163 else
Greg Claytonb72d0f02011-04-12 05:54:46 +0000164 s.Printf ("%-10u ", m_egid);
Greg Claytonff39f742011-04-01 00:29:43 +0000165 s.Printf ("%-24s ", m_arch.IsValid() ? m_arch.GetTriple().str().c_str() : "");
166 }
167 else
168 {
169 s.Printf ("%-10s %.*-7s ",
Greg Claytonb72d0f02011-04-12 05:54:46 +0000170 platform->GetUserName (m_euid),
Greg Claytonff39f742011-04-01 00:29:43 +0000171 (int)m_arch.GetTriple().getArchName().size(),
172 m_arch.GetTriple().getArchName().data());
173 }
174
Greg Claytonb72d0f02011-04-12 05:54:46 +0000175 if (verbose || show_args)
Greg Claytonff39f742011-04-01 00:29:43 +0000176 {
Greg Claytonb72d0f02011-04-12 05:54:46 +0000177 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Claytonff39f742011-04-01 00:29:43 +0000178 if (argc > 0)
179 {
180 for (uint32_t i=0; i<argc; i++)
181 {
182 if (i > 0)
183 s.PutChar (' ');
Greg Claytonb72d0f02011-04-12 05:54:46 +0000184 s.PutCString (m_arguments.GetArgumentAtIndex(i));
Greg Claytonff39f742011-04-01 00:29:43 +0000185 }
186 }
187 }
188 else
189 {
190 s.PutCString (GetName());
191 }
192
193 s.EOL();
Greg Clayton24bc5d92011-03-30 18:16:51 +0000194 }
195}
196
Greg Claytonb72d0f02011-04-12 05:54:46 +0000197
198void
199ProcessInfo::SetArgumentsFromArgs (const Args& args,
200 bool first_arg_is_executable,
201 bool first_arg_is_executable_and_argument)
202{
203 // Copy all arguments
204 m_arguments = args;
205
206 // Is the first argument the executable?
207 if (first_arg_is_executable)
208 {
209 const char *first_arg = args.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}
225
Greg Clayton24bc5d92011-03-30 18:16:51 +0000226bool
Greg Claytonb72d0f02011-04-12 05:54:46 +0000227ProcessLaunchInfo::FileAction::Open (int fd, const char *path, bool read, bool write)
228{
229 if ((read || write) && fd >= 0 && path && path[0])
230 {
231 m_action = eFileActionOpen;
232 m_fd = fd;
233 if (read && write)
234 m_arg = O_RDWR;
235 else if (read)
236 m_arg = O_RDONLY;
237 else
238 m_arg = O_WRONLY;
239 m_path.assign (path);
240 return true;
241 }
242 else
243 {
244 Clear();
245 }
246 return false;
247}
248
249bool
250ProcessLaunchInfo::FileAction::Close (int fd)
251{
252 Clear();
253 if (fd >= 0)
254 {
255 m_action = eFileActionClose;
256 m_fd = fd;
257 }
258 return m_fd >= 0;
259}
260
261
262bool
263ProcessLaunchInfo::FileAction::Duplicate (int fd, int dup_fd)
264{
265 Clear();
266 if (fd >= 0 && dup_fd >= 0)
267 {
268 m_action = eFileActionDuplicate;
269 m_fd = fd;
270 m_arg = dup_fd;
271 }
272 return m_fd >= 0;
273}
274
275
276
277bool
278ProcessLaunchInfo::FileAction::AddPosixSpawnFileAction (posix_spawn_file_actions_t *file_actions,
279 const FileAction *info,
280 Log *log,
281 Error& error)
282{
283 if (info == NULL)
284 return false;
285
286 switch (info->m_action)
287 {
288 case eFileActionNone:
289 error.Clear();
290 break;
291
292 case eFileActionClose:
293 if (info->m_fd == -1)
294 error.SetErrorString ("invalid fd for posix_spawn_file_actions_addclose(...)");
295 else
296 {
297 error.SetError (::posix_spawn_file_actions_addclose (file_actions, info->m_fd),
298 eErrorTypePOSIX);
299 if (log && (error.Fail() || log))
300 error.PutToLog(log, "posix_spawn_file_actions_addclose (action=%p, fd=%i)",
301 file_actions, info->m_fd);
302 }
303 break;
304
305 case eFileActionDuplicate:
306 if (info->m_fd == -1)
307 error.SetErrorString ("invalid fd for posix_spawn_file_actions_adddup2(...)");
308 else if (info->m_arg == -1)
309 error.SetErrorString ("invalid duplicate fd for posix_spawn_file_actions_adddup2(...)");
310 else
311 {
312 error.SetError (::posix_spawn_file_actions_adddup2 (file_actions, info->m_fd, info->m_arg),
313 eErrorTypePOSIX);
314 if (log && (error.Fail() || log))
315 error.PutToLog(log, "posix_spawn_file_actions_adddup2 (action=%p, fd=%i, dup_fd=%i)",
316 file_actions, info->m_fd, info->m_arg);
317 }
318 break;
319
320 case eFileActionOpen:
321 if (info->m_fd == -1)
322 error.SetErrorString ("invalid fd in posix_spawn_file_actions_addopen(...)");
323 else
324 {
325 int oflag = info->m_arg;
326 mode_t mode = 0;
327
328 error.SetError (::posix_spawn_file_actions_addopen (file_actions,
329 info->m_fd,
330 info->m_path.c_str(),
331 oflag,
332 mode),
333 eErrorTypePOSIX);
334 if (error.Fail() || log)
335 error.PutToLog(log,
336 "posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)",
337 file_actions, info->m_fd, info->m_path.c_str(), oflag, mode);
338 }
339 break;
340
341 default:
342 error.SetErrorStringWithFormat ("invalid file action: %i", info->m_action);
343 break;
344 }
345 return error.Success();
346}
347
348Error
Greg Clayton143fcc32011-04-13 00:18:08 +0000349ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
Greg Claytonb72d0f02011-04-12 05:54:46 +0000350{
351 Error error;
352 char short_option = (char) m_getopt_table[option_idx].val;
353
354 switch (short_option)
355 {
356 case 's': // Stop at program entry point
357 launch_info.GetFlags().Set (eLaunchFlagStopAtEntry);
358 break;
359
360 case 'e': // STDERR for read + write
361 {
362 ProcessLaunchInfo::FileAction action;
363 if (action.Open(STDERR_FILENO, option_arg, true, true))
364 launch_info.AppendFileAction (action);
365 }
366 break;
367
368 case 'i': // STDIN for read only
369 {
370 ProcessLaunchInfo::FileAction action;
371 if (action.Open(STDIN_FILENO, option_arg, true, false))
372 launch_info.AppendFileAction (action);
373 }
374 break;
375
376 case 'o': // Open STDOUT for write only
377 {
378 ProcessLaunchInfo::FileAction action;
379 if (action.Open(STDOUT_FILENO, option_arg, false, true))
380 launch_info.AppendFileAction (action);
381 }
382 break;
383
384 case 'p': // Process plug-in name
385 launch_info.SetProcessPluginName (option_arg);
386 break;
387
388 case 'n': // Disable STDIO
389 {
390 ProcessLaunchInfo::FileAction action;
391 if (action.Open(STDERR_FILENO, "/dev/null", true, true))
392 launch_info.AppendFileAction (action);
393 if (action.Open(STDOUT_FILENO, "/dev/null", false, true))
394 launch_info.AppendFileAction (action);
395 if (action.Open(STDIN_FILENO, "/dev/null", true, false))
396 launch_info.AppendFileAction (action);
397 }
398 break;
399
400 case 'w':
401 launch_info.SetWorkingDirectory (option_arg);
402 break;
403
404 case 't': // Open process in new terminal window
405 launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
406 break;
407
408 case 'a':
409 launch_info.GetArchitecture().SetTriple (option_arg,
410 m_interpreter.GetPlatform(true).get());
411 break;
412
413 case 'A':
414 launch_info.GetFlags().Set (eLaunchFlagDisableASLR);
415 break;
416
417 case 'v':
418 launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
419 break;
420
421 default:
422 error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option);
423 break;
424
425 }
426 return error;
427}
428
429OptionDefinition
430ProcessLaunchCommandOptions::g_option_table[] =
431{
432{ 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."},
433{ LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', no_argument, NULL, 0, eArgTypeNone, "Disable address space layout randomization when launching a process."},
434{ LLDB_OPT_SET_ALL, false, "plugin", 'p', required_argument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
435{ LLDB_OPT_SET_ALL, false, "working-dir", 'w', required_argument, NULL, 0, eArgTypePath, "Set the current working directory to <path> when running the inferior."},
436{ LLDB_OPT_SET_ALL, false, "arch", 'a', required_argument, NULL, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous."},
437{ 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."},
438
439{ LLDB_OPT_SET_1 , false, "stdin", 'i', required_argument, NULL, 0, eArgTypePath, "Redirect stdin for the process to <path>."},
440{ LLDB_OPT_SET_1 , false, "stdout", 'o', required_argument, NULL, 0, eArgTypePath, "Redirect stdout for the process to <path>."},
441{ LLDB_OPT_SET_1 , false, "stderr", 'e', required_argument, NULL, 0, eArgTypePath, "Redirect stderr for the process to <path>."},
442
443{ LLDB_OPT_SET_2 , false, "tty", 't', no_argument, NULL, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)."},
444
445{ 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."},
446
447{ 0 , false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
448};
449
450
451
452bool
453ProcessInstanceInfoMatch::NameMatches (const char *process_name) const
Greg Clayton24bc5d92011-03-30 18:16:51 +0000454{
455 if (m_name_match_type == eNameMatchIgnore || process_name == NULL)
456 return true;
457 const char *match_name = m_match_info.GetName();
458 if (!match_name)
459 return true;
460
461 return lldb_private::NameMatches (process_name, m_name_match_type, match_name);
462}
463
464bool
Greg Claytonb72d0f02011-04-12 05:54:46 +0000465ProcessInstanceInfoMatch::Matches (const ProcessInstanceInfo &proc_info) const
Greg Clayton24bc5d92011-03-30 18:16:51 +0000466{
467 if (!NameMatches (proc_info.GetName()))
468 return false;
469
470 if (m_match_info.ProcessIDIsValid() &&
471 m_match_info.GetProcessID() != proc_info.GetProcessID())
472 return false;
473
474 if (m_match_info.ParentProcessIDIsValid() &&
475 m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
476 return false;
477
Greg Claytonb72d0f02011-04-12 05:54:46 +0000478 if (m_match_info.UserIDIsValid () &&
479 m_match_info.GetUserID() != proc_info.GetUserID())
Greg Clayton24bc5d92011-03-30 18:16:51 +0000480 return false;
481
Greg Claytonb72d0f02011-04-12 05:54:46 +0000482 if (m_match_info.GroupIDIsValid () &&
483 m_match_info.GetGroupID() != proc_info.GetGroupID())
Greg Clayton24bc5d92011-03-30 18:16:51 +0000484 return false;
485
486 if (m_match_info.EffectiveUserIDIsValid () &&
487 m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
488 return false;
489
490 if (m_match_info.EffectiveGroupIDIsValid () &&
491 m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
492 return false;
493
494 if (m_match_info.GetArchitecture().IsValid() &&
495 m_match_info.GetArchitecture() != proc_info.GetArchitecture())
496 return false;
497 return true;
498}
499
500bool
Greg Claytonb72d0f02011-04-12 05:54:46 +0000501ProcessInstanceInfoMatch::MatchAllProcesses () const
Greg Clayton24bc5d92011-03-30 18:16:51 +0000502{
503 if (m_name_match_type != eNameMatchIgnore)
504 return false;
505
506 if (m_match_info.ProcessIDIsValid())
507 return false;
508
509 if (m_match_info.ParentProcessIDIsValid())
510 return false;
511
Greg Claytonb72d0f02011-04-12 05:54:46 +0000512 if (m_match_info.UserIDIsValid ())
Greg Clayton24bc5d92011-03-30 18:16:51 +0000513 return false;
514
Greg Claytonb72d0f02011-04-12 05:54:46 +0000515 if (m_match_info.GroupIDIsValid ())
Greg Clayton24bc5d92011-03-30 18:16:51 +0000516 return false;
517
518 if (m_match_info.EffectiveUserIDIsValid ())
519 return false;
520
521 if (m_match_info.EffectiveGroupIDIsValid ())
522 return false;
523
524 if (m_match_info.GetArchitecture().IsValid())
525 return false;
526
527 if (m_match_all_users)
528 return false;
529
530 return true;
531
532}
533
534void
Greg Claytonb72d0f02011-04-12 05:54:46 +0000535ProcessInstanceInfoMatch::Clear()
Greg Clayton24bc5d92011-03-30 18:16:51 +0000536{
537 m_match_info.Clear();
538 m_name_match_type = eNameMatchIgnore;
539 m_match_all_users = false;
540}
Greg Claytonfd119992011-01-07 06:08:19 +0000541
Chris Lattner24943d22010-06-08 16:52:24 +0000542Process*
543Process::FindPlugin (Target &target, const char *plugin_name, Listener &listener)
544{
545 ProcessCreateInstance create_callback = NULL;
546 if (plugin_name)
547 {
548 create_callback = PluginManager::GetProcessCreateCallbackForPluginName (plugin_name);
549 if (create_callback)
550 {
551 std::auto_ptr<Process> debugger_ap(create_callback(target, listener));
552 if (debugger_ap->CanDebug(target))
553 return debugger_ap.release();
554 }
555 }
556 else
557 {
Greg Clayton54e7afa2010-07-09 20:39:50 +0000558 for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx)
Chris Lattner24943d22010-06-08 16:52:24 +0000559 {
Greg Clayton54e7afa2010-07-09 20:39:50 +0000560 std::auto_ptr<Process> debugger_ap(create_callback(target, listener));
561 if (debugger_ap->CanDebug(target))
562 return debugger_ap.release();
Chris Lattner24943d22010-06-08 16:52:24 +0000563 }
564 }
565 return NULL;
566}
567
568
569//----------------------------------------------------------------------
570// Process constructor
571//----------------------------------------------------------------------
572Process::Process(Target &target, Listener &listener) :
573 UserID (LLDB_INVALID_PROCESS_ID),
Greg Clayton49ce6822010-10-31 03:01:06 +0000574 Broadcaster ("lldb.process"),
Greg Claytonc0c1b0c2010-11-19 03:46:01 +0000575 ProcessInstanceSettings (*GetSettingsController()),
Chris Lattner24943d22010-06-08 16:52:24 +0000576 m_target (target),
Chris Lattner24943d22010-06-08 16:52:24 +0000577 m_public_state (eStateUnloaded),
578 m_private_state (eStateUnloaded),
579 m_private_state_broadcaster ("lldb.process.internal_state_broadcaster"),
580 m_private_state_control_broadcaster ("lldb.process.internal_state_control_broadcaster"),
581 m_private_state_listener ("lldb.process.internal_state_listener"),
582 m_private_state_control_wait(),
583 m_private_state_thread (LLDB_INVALID_HOST_THREAD),
584 m_stop_id (0),
585 m_thread_index_id (0),
586 m_exit_status (-1),
587 m_exit_string (),
588 m_thread_list (this),
589 m_notifications (),
Greg Clayton20d338f2010-11-18 05:57:03 +0000590 m_image_tokens (),
591 m_listener (listener),
592 m_breakpoint_site_list (),
Greg Clayton20d338f2010-11-18 05:57:03 +0000593 m_dynamic_checkers_ap (),
Caroline Tice861efb32010-11-16 05:07:41 +0000594 m_unix_signals (),
Greg Clayton20d338f2010-11-18 05:57:03 +0000595 m_abi_sp (),
Caroline Tice861efb32010-11-16 05:07:41 +0000596 m_process_input_reader (),
Greg Claytona875b642011-01-09 21:07:35 +0000597 m_stdio_communication ("process.stdio"),
Greg Clayton20d338f2010-11-18 05:57:03 +0000598 m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
Greg Claytonfd119992011-01-07 06:08:19 +0000599 m_stdout_data (),
Greg Clayton613b8732011-05-17 03:37:42 +0000600 m_memory_cache (*this),
601 m_allocated_memory_cache (*this),
Greg Clayton7e2f91c2011-01-29 07:10:55 +0000602 m_next_event_action_ap()
Chris Lattner24943d22010-06-08 16:52:24 +0000603{
Caroline Tice1ebef442010-09-27 00:30:10 +0000604 UpdateInstanceName();
605
Greg Claytone005f2c2010-11-06 01:53:30 +0000606 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner24943d22010-06-08 16:52:24 +0000607 if (log)
608 log->Printf ("%p Process::Process()", this);
609
Greg Clayton49ce6822010-10-31 03:01:06 +0000610 SetEventName (eBroadcastBitStateChanged, "state-changed");
611 SetEventName (eBroadcastBitInterrupt, "interrupt");
612 SetEventName (eBroadcastBitSTDOUT, "stdout-available");
613 SetEventName (eBroadcastBitSTDERR, "stderr-available");
614
Chris Lattner24943d22010-06-08 16:52:24 +0000615 listener.StartListeningForEvents (this,
616 eBroadcastBitStateChanged |
617 eBroadcastBitInterrupt |
618 eBroadcastBitSTDOUT |
619 eBroadcastBitSTDERR);
620
621 m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster,
622 eBroadcastBitStateChanged);
623
624 m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster,
625 eBroadcastInternalStateControlStop |
626 eBroadcastInternalStateControlPause |
627 eBroadcastInternalStateControlResume);
628}
629
630//----------------------------------------------------------------------
631// Destructor
632//----------------------------------------------------------------------
633Process::~Process()
634{
Greg Claytone005f2c2010-11-06 01:53:30 +0000635 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner24943d22010-06-08 16:52:24 +0000636 if (log)
637 log->Printf ("%p Process::~Process()", this);
638 StopPrivateStateThread();
639}
640
641void
642Process::Finalize()
643{
644 // Do any cleanup needed prior to being destructed... Subclasses
645 // that override this method should call this superclass method as well.
Jim Ingham88fa7bd2011-02-16 17:54:55 +0000646
647 // We need to destroy the loader before the derived Process class gets destroyed
648 // since it is very likely that undoing the loader will require access to the real process.
649 if (m_dyld_ap.get() != NULL)
650 m_dyld_ap.reset();
Chris Lattner24943d22010-06-08 16:52:24 +0000651}
652
653void
654Process::RegisterNotificationCallbacks (const Notifications& callbacks)
655{
656 m_notifications.push_back(callbacks);
657 if (callbacks.initialize != NULL)
658 callbacks.initialize (callbacks.baton, this);
659}
660
661bool
662Process::UnregisterNotificationCallbacks(const Notifications& callbacks)
663{
664 std::vector<Notifications>::iterator pos, end = m_notifications.end();
665 for (pos = m_notifications.begin(); pos != end; ++pos)
666 {
667 if (pos->baton == callbacks.baton &&
668 pos->initialize == callbacks.initialize &&
669 pos->process_state_changed == callbacks.process_state_changed)
670 {
671 m_notifications.erase(pos);
672 return true;
673 }
674 }
675 return false;
676}
677
678void
679Process::SynchronouslyNotifyStateChanged (StateType state)
680{
681 std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end();
682 for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos)
683 {
684 if (notification_pos->process_state_changed)
685 notification_pos->process_state_changed (notification_pos->baton, this, state);
686 }
687}
688
689// FIXME: We need to do some work on events before the general Listener sees them.
690// For instance if we are continuing from a breakpoint, we need to ensure that we do
691// the little "insert real insn, step & stop" trick. But we can't do that when the
692// event is delivered by the broadcaster - since that is done on the thread that is
693// waiting for new events, so if we needed more than one event for our handling, we would
694// stall. So instead we do it when we fetch the event off of the queue.
695//
696
697StateType
698Process::GetNextEvent (EventSP &event_sp)
699{
700 StateType state = eStateInvalid;
701
702 if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp)
703 state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
704
705 return state;
706}
707
708
709StateType
710Process::WaitForProcessToStop (const TimeValue *timeout)
711{
712 StateType match_states[] = { eStateStopped, eStateCrashed, eStateDetached, eStateExited, eStateUnloaded };
713 return WaitForState (timeout, match_states, sizeof(match_states) / sizeof(StateType));
714}
715
716
717StateType
718Process::WaitForState
719(
720 const TimeValue *timeout,
721 const StateType *match_states, const uint32_t num_match_states
722)
723{
724 EventSP event_sp;
725 uint32_t i;
Greg Claytond8c62532010-10-07 04:19:01 +0000726 StateType state = GetState();
Chris Lattner24943d22010-06-08 16:52:24 +0000727 while (state != eStateInvalid)
728 {
Greg Claytond8c62532010-10-07 04:19:01 +0000729 // If we are exited or detached, we won't ever get back to any
730 // other valid state...
731 if (state == eStateDetached || state == eStateExited)
732 return state;
733
Chris Lattner24943d22010-06-08 16:52:24 +0000734 state = WaitForStateChangedEvents (timeout, event_sp);
735
736 for (i=0; i<num_match_states; ++i)
737 {
738 if (match_states[i] == state)
739 return state;
740 }
741 }
742 return state;
743}
744
Jim Ingham63e24d72010-10-11 23:53:14 +0000745bool
746Process::HijackProcessEvents (Listener *listener)
747{
748 if (listener != NULL)
749 {
750 return HijackBroadcaster(listener, eBroadcastBitStateChanged);
751 }
752 else
753 return false;
754}
755
756void
757Process::RestoreProcessEvents ()
758{
759 RestoreBroadcaster();
760}
761
Jim Inghamf9f40c22011-02-08 05:20:59 +0000762bool
763Process::HijackPrivateProcessEvents (Listener *listener)
764{
765 if (listener != NULL)
766 {
767 return m_private_state_broadcaster.HijackBroadcaster(listener, eBroadcastBitStateChanged);
768 }
769 else
770 return false;
771}
772
773void
774Process::RestorePrivateProcessEvents ()
775{
776 m_private_state_broadcaster.RestoreBroadcaster();
777}
778
Chris Lattner24943d22010-06-08 16:52:24 +0000779StateType
780Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp)
781{
Greg Claytone005f2c2010-11-06 01:53:30 +0000782 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +0000783
784 if (log)
785 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout);
786
787 StateType state = eStateInvalid;
Greg Clayton36f63a92010-10-19 03:25:40 +0000788 if (m_listener.WaitForEventForBroadcasterWithType (timeout,
789 this,
790 eBroadcastBitStateChanged,
791 event_sp))
Chris Lattner24943d22010-06-08 16:52:24 +0000792 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
793
794 if (log)
795 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
796 __FUNCTION__,
797 timeout,
798 StateAsCString(state));
799 return state;
800}
801
802Event *
803Process::PeekAtStateChangedEvents ()
804{
Greg Claytone005f2c2010-11-06 01:53:30 +0000805 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +0000806
807 if (log)
808 log->Printf ("Process::%s...", __FUNCTION__);
809
810 Event *event_ptr;
Greg Clayton36f63a92010-10-19 03:25:40 +0000811 event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this,
812 eBroadcastBitStateChanged);
Chris Lattner24943d22010-06-08 16:52:24 +0000813 if (log)
814 {
815 if (event_ptr)
816 {
817 log->Printf ("Process::%s (event_ptr) => %s",
818 __FUNCTION__,
819 StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr)));
820 }
821 else
822 {
823 log->Printf ("Process::%s no events found",
824 __FUNCTION__);
825 }
826 }
827 return event_ptr;
828}
829
830StateType
831Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp)
832{
Greg Claytone005f2c2010-11-06 01:53:30 +0000833 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +0000834
835 if (log)
836 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout);
837
838 StateType state = eStateInvalid;
Greg Clayton72e1c782011-01-22 23:43:18 +0000839 if (m_private_state_listener.WaitForEventForBroadcasterWithType (timeout,
840 &m_private_state_broadcaster,
841 eBroadcastBitStateChanged,
842 event_sp))
Chris Lattner24943d22010-06-08 16:52:24 +0000843 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
844
845 // This is a bit of a hack, but when we wait here we could very well return
846 // to the command-line, and that could disable the log, which would render the
847 // log we got above invalid.
Chris Lattner24943d22010-06-08 16:52:24 +0000848 if (log)
Greg Clayton72e1c782011-01-22 23:43:18 +0000849 {
850 if (state == eStateInvalid)
851 log->Printf ("Process::%s (timeout = %p, event_sp) => TIMEOUT", __FUNCTION__, timeout);
852 else
853 log->Printf ("Process::%s (timeout = %p, event_sp) => %s", __FUNCTION__, timeout, StateAsCString(state));
854 }
Chris Lattner24943d22010-06-08 16:52:24 +0000855 return state;
856}
857
858bool
859Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only)
860{
Greg Claytone005f2c2010-11-06 01:53:30 +0000861 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +0000862
863 if (log)
864 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout);
865
866 if (control_only)
867 return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp);
868 else
869 return m_private_state_listener.WaitForEvent(timeout, event_sp);
870}
871
872bool
873Process::IsRunning () const
874{
875 return StateIsRunningState (m_public_state.GetValue());
876}
877
878int
879Process::GetExitStatus ()
880{
881 if (m_public_state.GetValue() == eStateExited)
882 return m_exit_status;
883 return -1;
884}
885
Greg Clayton638351a2010-12-04 00:10:17 +0000886
887void
888Process::ProcessInstanceSettings::GetHostEnvironmentIfNeeded ()
889{
890 if (m_inherit_host_env && !m_got_host_env)
891 {
892 m_got_host_env = true;
893 StringList host_env;
894 const size_t host_env_count = Host::GetEnvironment (host_env);
895 for (size_t idx=0; idx<host_env_count; idx++)
896 {
897 const char *env_entry = host_env.GetStringAtIndex (idx);
898 if (env_entry)
899 {
Greg Clayton1f3dd642010-12-15 20:52:40 +0000900 const char *equal_pos = ::strchr(env_entry, '=');
Greg Clayton638351a2010-12-04 00:10:17 +0000901 if (equal_pos)
902 {
903 std::string key (env_entry, equal_pos - env_entry);
904 std::string value (equal_pos + 1);
905 if (m_env_vars.find (key) == m_env_vars.end())
906 m_env_vars[key] = value;
907 }
908 }
909 }
910 }
911}
912
913
914size_t
915Process::ProcessInstanceSettings::GetEnvironmentAsArgs (Args &env)
916{
917 GetHostEnvironmentIfNeeded ();
918
919 dictionary::const_iterator pos, end = m_env_vars.end();
920 for (pos = m_env_vars.begin(); pos != end; ++pos)
921 {
922 std::string env_var_equal_value (pos->first);
923 env_var_equal_value.append(1, '=');
924 env_var_equal_value.append (pos->second);
925 env.AppendArgument (env_var_equal_value.c_str());
926 }
927 return env.GetArgumentCount();
928}
929
930
Chris Lattner24943d22010-06-08 16:52:24 +0000931const char *
932Process::GetExitDescription ()
933{
934 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
935 return m_exit_string.c_str();
936 return NULL;
937}
938
Greg Clayton72e1c782011-01-22 23:43:18 +0000939bool
Chris Lattner24943d22010-06-08 16:52:24 +0000940Process::SetExitStatus (int status, const char *cstr)
941{
Greg Clayton68ca8232011-01-25 02:58:48 +0000942 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
943 if (log)
944 log->Printf("Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
945 status, status,
946 cstr ? "\"" : "",
947 cstr ? cstr : "NULL",
948 cstr ? "\"" : "");
949
Greg Clayton72e1c782011-01-22 23:43:18 +0000950 // We were already in the exited state
951 if (m_private_state.GetValue() == eStateExited)
Greg Clayton68ca8232011-01-25 02:58:48 +0000952 {
Greg Clayton644ddfb2011-01-26 23:47:29 +0000953 if (log)
954 log->Printf("Process::SetExitStatus () ignoring exit status because state was already set to eStateExited");
Greg Clayton72e1c782011-01-22 23:43:18 +0000955 return false;
Greg Clayton68ca8232011-01-25 02:58:48 +0000956 }
Greg Clayton72e1c782011-01-22 23:43:18 +0000957
958 m_exit_status = status;
959 if (cstr)
960 m_exit_string = cstr;
961 else
962 m_exit_string.clear();
Chris Lattner24943d22010-06-08 16:52:24 +0000963
Greg Clayton72e1c782011-01-22 23:43:18 +0000964 DidExit ();
Greg Clayton58e844b2010-12-08 05:08:21 +0000965
Greg Clayton72e1c782011-01-22 23:43:18 +0000966 SetPrivateState (eStateExited);
967 return true;
Chris Lattner24943d22010-06-08 16:52:24 +0000968}
969
970// This static callback can be used to watch for local child processes on
971// the current host. The the child process exits, the process will be
972// found in the global target list (we want to be completely sure that the
973// lldb_private::Process doesn't go away before we can deliver the signal.
974bool
975Process::SetProcessExitStatus
976(
977 void *callback_baton,
978 lldb::pid_t pid,
979 int signo, // Zero for no signal
980 int exit_status // Exit value of process if signal is zero
981)
982{
983 if (signo == 0 || exit_status)
984 {
Greg Clayton63094e02010-06-23 01:19:29 +0000985 TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
Chris Lattner24943d22010-06-08 16:52:24 +0000986 if (target_sp)
987 {
988 ProcessSP process_sp (target_sp->GetProcessSP());
989 if (process_sp)
990 {
991 const char *signal_cstr = NULL;
992 if (signo)
993 signal_cstr = process_sp->GetUnixSignals().GetSignalAsCString (signo);
994
995 process_sp->SetExitStatus (exit_status, signal_cstr);
996 }
997 }
998 return true;
999 }
1000 return false;
1001}
1002
1003
1004uint32_t
1005Process::GetNextThreadIndexID ()
1006{
1007 return ++m_thread_index_id;
1008}
1009
1010StateType
1011Process::GetState()
1012{
1013 // If any other threads access this we will need a mutex for it
1014 return m_public_state.GetValue ();
1015}
1016
1017void
1018Process::SetPublicState (StateType new_state)
1019{
Greg Clayton68ca8232011-01-25 02:58:48 +00001020 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +00001021 if (log)
1022 log->Printf("Process::SetPublicState (%s)", StateAsCString(new_state));
1023 m_public_state.SetValue (new_state);
1024}
1025
1026StateType
1027Process::GetPrivateState ()
1028{
1029 return m_private_state.GetValue();
1030}
1031
1032void
1033Process::SetPrivateState (StateType new_state)
1034{
Greg Clayton68ca8232011-01-25 02:58:48 +00001035 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +00001036 bool state_changed = false;
1037
1038 if (log)
1039 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
1040
1041 Mutex::Locker locker(m_private_state.GetMutex());
1042
1043 const StateType old_state = m_private_state.GetValueNoLock ();
1044 state_changed = old_state != new_state;
1045 if (state_changed)
1046 {
1047 m_private_state.SetValueNoLock (new_state);
1048 if (StateIsStoppedState(new_state))
1049 {
1050 m_stop_id++;
Greg Claytonfd119992011-01-07 06:08:19 +00001051 m_memory_cache.Clear();
Chris Lattner24943d22010-06-08 16:52:24 +00001052 if (log)
1053 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_stop_id);
1054 }
1055 // Use our target to get a shared pointer to ourselves...
1056 m_private_state_broadcaster.BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (GetTarget().GetProcessSP(), new_state));
1057 }
1058 else
1059 {
1060 if (log)
1061 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state), StateAsCString(old_state));
1062 }
1063}
1064
1065
1066uint32_t
1067Process::GetStopID() const
1068{
1069 return m_stop_id;
1070}
1071
1072addr_t
1073Process::GetImageInfoAddress()
1074{
1075 return LLDB_INVALID_ADDRESS;
1076}
1077
Greg Clayton0baa3942010-11-04 01:54:29 +00001078//----------------------------------------------------------------------
1079// LoadImage
1080//
1081// This function provides a default implementation that works for most
1082// unix variants. Any Process subclasses that need to do shared library
1083// loading differently should override LoadImage and UnloadImage and
1084// do what is needed.
1085//----------------------------------------------------------------------
1086uint32_t
1087Process::LoadImage (const FileSpec &image_spec, Error &error)
1088{
1089 DynamicLoader *loader = GetDynamicLoader();
1090 if (loader)
1091 {
1092 error = loader->CanLoadImage();
1093 if (error.Fail())
1094 return LLDB_INVALID_IMAGE_TOKEN;
1095 }
1096
1097 if (error.Success())
1098 {
1099 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
1100 if (thread_sp == NULL)
1101 thread_sp = GetThreadList ().GetThreadAtIndex(0, true);
1102
1103 if (thread_sp)
1104 {
1105 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
1106
1107 if (frame_sp)
1108 {
1109 ExecutionContext exe_ctx;
1110 frame_sp->CalculateExecutionContext (exe_ctx);
Jim Inghamea9d4262010-11-05 19:25:48 +00001111 bool unwind_on_error = true;
Greg Clayton0baa3942010-11-04 01:54:29 +00001112 StreamString expr;
1113 char path[PATH_MAX];
1114 image_spec.GetPath(path, sizeof(path));
1115 expr.Printf("dlopen (\"%s\", 2)", path);
1116 const char *prefix = "extern \"C\" void* dlopen (const char *path, int mode);\n";
Jim Ingham360f53f2010-11-30 02:22:11 +00001117 lldb::ValueObjectSP result_valobj_sp;
Sean Callanan696cf5f2011-05-07 01:06:41 +00001118 ClangUserExpression::Evaluate (exe_ctx, unwind_on_error, expr.GetData(), prefix, result_valobj_sp);
Greg Clayton0baa3942010-11-04 01:54:29 +00001119 if (result_valobj_sp->GetError().Success())
1120 {
1121 Scalar scalar;
Jim Inghamfa3a16a2011-03-31 00:19:25 +00001122 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton0baa3942010-11-04 01:54:29 +00001123 {
1124 addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1125 if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
1126 {
1127 uint32_t image_token = m_image_tokens.size();
1128 m_image_tokens.push_back (image_ptr);
1129 return image_token;
1130 }
1131 }
1132 }
1133 }
1134 }
1135 }
1136 return LLDB_INVALID_IMAGE_TOKEN;
1137}
1138
1139//----------------------------------------------------------------------
1140// UnloadImage
1141//
1142// This function provides a default implementation that works for most
1143// unix variants. Any Process subclasses that need to do shared library
1144// loading differently should override LoadImage and UnloadImage and
1145// do what is needed.
1146//----------------------------------------------------------------------
1147Error
1148Process::UnloadImage (uint32_t image_token)
1149{
1150 Error error;
1151 if (image_token < m_image_tokens.size())
1152 {
1153 const addr_t image_addr = m_image_tokens[image_token];
1154 if (image_addr == LLDB_INVALID_ADDRESS)
1155 {
1156 error.SetErrorString("image already unloaded");
1157 }
1158 else
1159 {
1160 DynamicLoader *loader = GetDynamicLoader();
1161 if (loader)
1162 error = loader->CanLoadImage();
1163
1164 if (error.Success())
1165 {
1166 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
1167 if (thread_sp == NULL)
1168 thread_sp = GetThreadList ().GetThreadAtIndex(0, true);
1169
1170 if (thread_sp)
1171 {
1172 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
1173
1174 if (frame_sp)
1175 {
1176 ExecutionContext exe_ctx;
1177 frame_sp->CalculateExecutionContext (exe_ctx);
Jim Inghamea9d4262010-11-05 19:25:48 +00001178 bool unwind_on_error = true;
Greg Clayton0baa3942010-11-04 01:54:29 +00001179 StreamString expr;
1180 expr.Printf("dlclose ((void *)0x%llx)", image_addr);
1181 const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
Jim Ingham360f53f2010-11-30 02:22:11 +00001182 lldb::ValueObjectSP result_valobj_sp;
Sean Callanan696cf5f2011-05-07 01:06:41 +00001183 ClangUserExpression::Evaluate (exe_ctx, unwind_on_error, expr.GetData(), prefix, result_valobj_sp);
Greg Clayton0baa3942010-11-04 01:54:29 +00001184 if (result_valobj_sp->GetError().Success())
1185 {
1186 Scalar scalar;
Jim Inghamfa3a16a2011-03-31 00:19:25 +00001187 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton0baa3942010-11-04 01:54:29 +00001188 {
1189 if (scalar.UInt(1))
1190 {
1191 error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData());
1192 }
1193 else
1194 {
1195 m_image_tokens[image_token] = LLDB_INVALID_ADDRESS;
1196 }
1197 }
1198 }
1199 else
1200 {
1201 error = result_valobj_sp->GetError();
1202 }
1203 }
1204 }
1205 }
1206 }
1207 }
1208 else
1209 {
1210 error.SetErrorString("invalid image token");
1211 }
1212 return error;
1213}
1214
Greg Clayton75906e42011-05-11 18:39:18 +00001215const lldb::ABISP &
Chris Lattner24943d22010-06-08 16:52:24 +00001216Process::GetABI()
1217{
Greg Clayton75906e42011-05-11 18:39:18 +00001218 if (!m_abi_sp)
1219 m_abi_sp = ABI::FindPlugin(m_target.GetArchitecture());
1220 return m_abi_sp;
Chris Lattner24943d22010-06-08 16:52:24 +00001221}
1222
Jim Ingham642036f2010-09-23 02:01:19 +00001223LanguageRuntime *
1224Process::GetLanguageRuntime(lldb::LanguageType language)
1225{
1226 LanguageRuntimeCollection::iterator pos;
1227 pos = m_language_runtimes.find (language);
1228 if (pos == m_language_runtimes.end())
1229 {
1230 lldb::LanguageRuntimeSP runtime(LanguageRuntime::FindPlugin(this, language));
1231
1232 m_language_runtimes[language]
1233 = runtime;
1234 return runtime.get();
1235 }
1236 else
1237 return (*pos).second.get();
1238}
1239
1240CPPLanguageRuntime *
1241Process::GetCPPLanguageRuntime ()
1242{
1243 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus);
1244 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
1245 return static_cast<CPPLanguageRuntime *> (runtime);
1246 return NULL;
1247}
1248
1249ObjCLanguageRuntime *
1250Process::GetObjCLanguageRuntime ()
1251{
1252 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC);
1253 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC)
1254 return static_cast<ObjCLanguageRuntime *> (runtime);
1255 return NULL;
1256}
1257
Chris Lattner24943d22010-06-08 16:52:24 +00001258BreakpointSiteList &
1259Process::GetBreakpointSiteList()
1260{
1261 return m_breakpoint_site_list;
1262}
1263
1264const BreakpointSiteList &
1265Process::GetBreakpointSiteList() const
1266{
1267 return m_breakpoint_site_list;
1268}
1269
1270
1271void
1272Process::DisableAllBreakpointSites ()
1273{
1274 m_breakpoint_site_list.SetEnabledForAll (false);
1275}
1276
1277Error
1278Process::ClearBreakpointSiteByID (lldb::user_id_t break_id)
1279{
1280 Error error (DisableBreakpointSiteByID (break_id));
1281
1282 if (error.Success())
1283 m_breakpoint_site_list.Remove(break_id);
1284
1285 return error;
1286}
1287
1288Error
1289Process::DisableBreakpointSiteByID (lldb::user_id_t break_id)
1290{
1291 Error error;
1292 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1293 if (bp_site_sp)
1294 {
1295 if (bp_site_sp->IsEnabled())
1296 error = DisableBreakpoint (bp_site_sp.get());
1297 }
1298 else
1299 {
1300 error.SetErrorStringWithFormat("invalid breakpoint site ID: %i", break_id);
1301 }
1302
1303 return error;
1304}
1305
1306Error
1307Process::EnableBreakpointSiteByID (lldb::user_id_t break_id)
1308{
1309 Error error;
1310 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1311 if (bp_site_sp)
1312 {
1313 if (!bp_site_sp->IsEnabled())
1314 error = EnableBreakpoint (bp_site_sp.get());
1315 }
1316 else
1317 {
1318 error.SetErrorStringWithFormat("invalid breakpoint site ID: %i", break_id);
1319 }
1320 return error;
1321}
1322
Stephen Wilson3fd1f362010-07-17 00:56:13 +00001323lldb::break_id_t
Chris Lattner24943d22010-06-08 16:52:24 +00001324Process::CreateBreakpointSite (BreakpointLocationSP &owner, bool use_hardware)
1325{
Greg Clayton265ab332011-05-19 18:17:41 +00001326 const addr_t load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
Chris Lattner24943d22010-06-08 16:52:24 +00001327 if (load_addr != LLDB_INVALID_ADDRESS)
1328 {
1329 BreakpointSiteSP bp_site_sp;
1330
1331 // Look up this breakpoint site. If it exists, then add this new owner, otherwise
1332 // create a new breakpoint site and add it.
1333
1334 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr);
1335
1336 if (bp_site_sp)
1337 {
1338 bp_site_sp->AddOwner (owner);
1339 owner->SetBreakpointSite (bp_site_sp);
1340 return bp_site_sp->GetID();
1341 }
1342 else
1343 {
1344 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, LLDB_INVALID_THREAD_ID, use_hardware));
1345 if (bp_site_sp)
1346 {
1347 if (EnableBreakpoint (bp_site_sp.get()).Success())
1348 {
1349 owner->SetBreakpointSite (bp_site_sp);
1350 return m_breakpoint_site_list.Add (bp_site_sp);
1351 }
1352 }
1353 }
1354 }
1355 // We failed to enable the breakpoint
1356 return LLDB_INVALID_BREAK_ID;
1357
1358}
1359
1360void
1361Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp)
1362{
1363 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id);
1364 if (num_owners == 0)
1365 {
1366 DisableBreakpoint(bp_site_sp.get());
1367 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
1368 }
1369}
1370
1371
1372size_t
1373Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
1374{
1375 size_t bytes_removed = 0;
1376 addr_t intersect_addr;
1377 size_t intersect_size;
1378 size_t opcode_offset;
1379 size_t idx;
1380 BreakpointSiteSP bp;
Jim Ingham82820f92011-06-29 19:42:28 +00001381 BreakpointSiteList bp_sites_in_range;
Chris Lattner24943d22010-06-08 16:52:24 +00001382
Jim Ingham82820f92011-06-29 19:42:28 +00001383 if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range))
Chris Lattner24943d22010-06-08 16:52:24 +00001384 {
Jim Ingham82820f92011-06-29 19:42:28 +00001385 for (idx = 0; (bp = bp_sites_in_range.GetByIndex(idx)) != NULL; ++idx)
Chris Lattner24943d22010-06-08 16:52:24 +00001386 {
Jim Ingham82820f92011-06-29 19:42:28 +00001387 if (bp->GetType() == BreakpointSite::eSoftware)
Chris Lattner24943d22010-06-08 16:52:24 +00001388 {
Jim Ingham82820f92011-06-29 19:42:28 +00001389 if (bp->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset))
1390 {
1391 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
1392 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size);
1393 assert(opcode_offset + intersect_size <= bp->GetByteSize());
1394 size_t buf_offset = intersect_addr - bp_addr;
1395 ::memcpy(buf + buf_offset, bp->GetSavedOpcodeBytes() + opcode_offset, intersect_size);
1396 }
Chris Lattner24943d22010-06-08 16:52:24 +00001397 }
1398 }
1399 }
1400 return bytes_removed;
1401}
1402
1403
Greg Claytonb1888f22011-03-19 01:12:21 +00001404
1405size_t
1406Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
1407{
1408 PlatformSP platform_sp (m_target.GetPlatform());
1409 if (platform_sp)
1410 return platform_sp->GetSoftwareBreakpointTrapOpcode (m_target, bp_site);
1411 return 0;
1412}
1413
Chris Lattner24943d22010-06-08 16:52:24 +00001414Error
1415Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site)
1416{
1417 Error error;
1418 assert (bp_site != NULL);
Greg Claytone005f2c2010-11-06 01:53:30 +00001419 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner24943d22010-06-08 16:52:24 +00001420 const addr_t bp_addr = bp_site->GetLoadAddress();
1421 if (log)
1422 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx", bp_site->GetID(), (uint64_t)bp_addr);
1423 if (bp_site->IsEnabled())
1424 {
1425 if (log)
1426 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already enabled", bp_site->GetID(), (uint64_t)bp_addr);
1427 return error;
1428 }
1429
1430 if (bp_addr == LLDB_INVALID_ADDRESS)
1431 {
1432 error.SetErrorString("BreakpointSite contains an invalid load address.");
1433 return error;
1434 }
1435 // Ask the lldb::Process subclass to fill in the correct software breakpoint
1436 // trap for the breakpoint site
1437 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
1438
1439 if (bp_opcode_size == 0)
1440 {
1441 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%llx.\n", bp_addr);
1442 }
1443 else
1444 {
1445 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
1446
1447 if (bp_opcode_bytes == NULL)
1448 {
1449 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode.");
1450 return error;
1451 }
1452
1453 // Save the original opcode by reading it
1454 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size)
1455 {
1456 // Write a software breakpoint in place of the original opcode
1457 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
1458 {
1459 uint8_t verify_bp_opcode_bytes[64];
1460 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
1461 {
1462 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0)
1463 {
1464 bp_site->SetEnabled(true);
1465 bp_site->SetType (BreakpointSite::eSoftware);
1466 if (log)
1467 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS",
1468 bp_site->GetID(),
1469 (uint64_t)bp_addr);
1470 }
1471 else
1472 error.SetErrorString("Failed to verify the breakpoint trap in memory.");
1473 }
1474 else
1475 error.SetErrorString("Unable to read memory to verify breakpoint trap.");
1476 }
1477 else
1478 error.SetErrorString("Unable to write breakpoint trap to memory.");
1479 }
1480 else
1481 error.SetErrorString("Unable to read memory at breakpoint address.");
1482 }
Stephen Wilsonc2b98252011-01-12 04:20:03 +00001483 if (log && error.Fail())
Chris Lattner24943d22010-06-08 16:52:24 +00001484 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s",
1485 bp_site->GetID(),
1486 (uint64_t)bp_addr,
1487 error.AsCString());
1488 return error;
1489}
1490
1491Error
1492Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
1493{
1494 Error error;
1495 assert (bp_site != NULL);
Greg Claytone005f2c2010-11-06 01:53:30 +00001496 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner24943d22010-06-08 16:52:24 +00001497 addr_t bp_addr = bp_site->GetLoadAddress();
1498 lldb::user_id_t breakID = bp_site->GetID();
1499 if (log)
Stephen Wilson9ff73ed2011-01-14 21:07:07 +00001500 log->Printf ("Process::DisableBreakpoint (breakID = %d) addr = 0x%llx", breakID, (uint64_t)bp_addr);
Chris Lattner24943d22010-06-08 16:52:24 +00001501
1502 if (bp_site->IsHardware())
1503 {
1504 error.SetErrorString("Breakpoint site is a hardware breakpoint.");
1505 }
1506 else if (bp_site->IsEnabled())
1507 {
1508 const size_t break_op_size = bp_site->GetByteSize();
1509 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
1510 if (break_op_size > 0)
1511 {
1512 // Clear a software breakoint instruction
Greg Clayton54e7afa2010-07-09 20:39:50 +00001513 uint8_t curr_break_op[8];
Stephen Wilson141eeac2010-07-20 18:41:11 +00001514 assert (break_op_size <= sizeof(curr_break_op));
Chris Lattner24943d22010-06-08 16:52:24 +00001515 bool break_op_found = false;
1516
1517 // Read the breakpoint opcode
1518 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
1519 {
1520 bool verify = false;
1521 // Make sure we have the a breakpoint opcode exists at this address
1522 if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
1523 {
1524 break_op_found = true;
1525 // We found a valid breakpoint opcode at this address, now restore
1526 // the saved opcode.
1527 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size)
1528 {
1529 verify = true;
1530 }
1531 else
1532 error.SetErrorString("Memory write failed when restoring original opcode.");
1533 }
1534 else
1535 {
1536 error.SetErrorString("Original breakpoint trap is no longer in memory.");
1537 // Set verify to true and so we can check if the original opcode has already been restored
1538 verify = true;
1539 }
1540
1541 if (verify)
1542 {
Greg Clayton54e7afa2010-07-09 20:39:50 +00001543 uint8_t verify_opcode[8];
Stephen Wilson141eeac2010-07-20 18:41:11 +00001544 assert (break_op_size < sizeof(verify_opcode));
Chris Lattner24943d22010-06-08 16:52:24 +00001545 // Verify that our original opcode made it back to the inferior
1546 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size)
1547 {
1548 // compare the memory we just read with the original opcode
1549 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
1550 {
1551 // SUCCESS
1552 bp_site->SetEnabled(false);
1553 if (log)
1554 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS", bp_site->GetID(), (uint64_t)bp_addr);
1555 return error;
1556 }
1557 else
1558 {
1559 if (break_op_found)
1560 error.SetErrorString("Failed to restore original opcode.");
1561 }
1562 }
1563 else
1564 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored.");
1565 }
1566 }
1567 else
1568 error.SetErrorString("Unable to read memory that should contain the breakpoint trap.");
1569 }
1570 }
1571 else
1572 {
1573 if (log)
1574 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already disabled", bp_site->GetID(), (uint64_t)bp_addr);
1575 return error;
1576 }
1577
1578 if (log)
1579 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s",
1580 bp_site->GetID(),
1581 (uint64_t)bp_addr,
1582 error.AsCString());
1583 return error;
1584
1585}
1586
Greg Claytonfd119992011-01-07 06:08:19 +00001587// Comment out line below to disable memory caching
1588#define ENABLE_MEMORY_CACHING
1589// Uncomment to verify memory caching works after making changes to caching code
1590//#define VERIFY_MEMORY_READS
1591
1592#if defined (ENABLE_MEMORY_CACHING)
1593
1594#if defined (VERIFY_MEMORY_READS)
Chris Lattner24943d22010-06-08 16:52:24 +00001595
1596size_t
1597Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1598{
Greg Claytonfd119992011-01-07 06:08:19 +00001599 // Memory caching is enabled, with debug verification
1600 if (buf && size)
1601 {
1602 // Uncomment the line below to make sure memory caching is working.
1603 // I ran this through the test suite and got no assertions, so I am
1604 // pretty confident this is working well. If any changes are made to
1605 // memory caching, uncomment the line below and test your changes!
1606
1607 // Verify all memory reads by using the cache first, then redundantly
1608 // reading the same memory from the inferior and comparing to make sure
1609 // everything is exactly the same.
1610 std::string verify_buf (size, '\0');
1611 assert (verify_buf.size() == size);
1612 const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error);
1613 Error verify_error;
1614 const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error);
1615 assert (cache_bytes_read == verify_bytes_read);
1616 assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
1617 assert (verify_error.Success() == error.Success());
1618 return cache_bytes_read;
1619 }
1620 return 0;
1621}
1622
1623#else // #if defined (VERIFY_MEMORY_READS)
1624
1625size_t
1626Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1627{
1628 // Memory caching enabled, no verification
Greg Clayton613b8732011-05-17 03:37:42 +00001629 return m_memory_cache.Read (addr, buf, size, error);
Greg Claytonfd119992011-01-07 06:08:19 +00001630}
1631
1632#endif // #else for #if defined (VERIFY_MEMORY_READS)
1633
1634#else // #if defined (ENABLE_MEMORY_CACHING)
1635
1636size_t
1637Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1638{
1639 // Memory caching is disabled
1640 return ReadMemoryFromInferior (addr, buf, size, error);
1641}
1642
1643#endif // #else for #if defined (ENABLE_MEMORY_CACHING)
1644
1645
1646size_t
Greg Claytonb72d0f02011-04-12 05:54:46 +00001647Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len)
1648{
1649 size_t total_cstr_len = 0;
1650 if (dst && dst_max_len)
1651 {
1652 // NULL out everything just to be safe
1653 memset (dst, 0, dst_max_len);
1654 Error error;
1655 addr_t curr_addr = addr;
1656 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
1657 size_t bytes_left = dst_max_len - 1;
1658 char *curr_dst = dst;
1659
1660 while (bytes_left > 0)
1661 {
1662 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
1663 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
1664 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
1665
1666 if (bytes_read == 0)
1667 {
1668 dst[total_cstr_len] = '\0';
1669 break;
1670 }
1671 const size_t len = strlen(curr_dst);
1672
1673 total_cstr_len += len;
1674
1675 if (len < bytes_to_read)
1676 break;
1677
1678 curr_dst += bytes_read;
1679 curr_addr += bytes_read;
1680 bytes_left -= bytes_read;
1681 }
1682 }
1683 return total_cstr_len;
1684}
1685
1686size_t
Greg Claytonfd119992011-01-07 06:08:19 +00001687Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error)
1688{
Chris Lattner24943d22010-06-08 16:52:24 +00001689 if (buf == NULL || size == 0)
1690 return 0;
1691
1692 size_t bytes_read = 0;
1693 uint8_t *bytes = (uint8_t *)buf;
1694
1695 while (bytes_read < size)
1696 {
1697 const size_t curr_size = size - bytes_read;
1698 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read,
1699 bytes + bytes_read,
1700 curr_size,
1701 error);
1702 bytes_read += curr_bytes_read;
1703 if (curr_bytes_read == curr_size || curr_bytes_read == 0)
1704 break;
1705 }
1706
1707 // Replace any software breakpoint opcodes that fall into this range back
1708 // into "buf" before we return
1709 if (bytes_read > 0)
1710 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf);
1711 return bytes_read;
1712}
1713
Greg Claytonf72fdee2010-12-16 20:01:20 +00001714uint64_t
Greg Claytonc0fa5332011-05-22 22:46:53 +00001715Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error)
Greg Claytonf72fdee2010-12-16 20:01:20 +00001716{
Greg Claytonc0fa5332011-05-22 22:46:53 +00001717 Scalar scalar;
1718 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error))
1719 return scalar.ULongLong(fail_value);
1720 return fail_value;
1721}
1722
1723addr_t
1724Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
1725{
1726 Scalar scalar;
1727 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error))
1728 return scalar.ULongLong(LLDB_INVALID_ADDRESS);
1729 return LLDB_INVALID_ADDRESS;
1730}
1731
1732
1733bool
1734Process::WritePointerToMemory (lldb::addr_t vm_addr,
1735 lldb::addr_t ptr_value,
1736 Error &error)
1737{
1738 Scalar scalar;
1739 const uint32_t addr_byte_size = GetAddressByteSize();
1740 if (addr_byte_size <= 4)
1741 scalar = (uint32_t)ptr_value;
Greg Claytonf72fdee2010-12-16 20:01:20 +00001742 else
Greg Claytonc0fa5332011-05-22 22:46:53 +00001743 scalar = ptr_value;
1744 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size;
Greg Claytonf72fdee2010-12-16 20:01:20 +00001745}
1746
Chris Lattner24943d22010-06-08 16:52:24 +00001747size_t
1748Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error)
1749{
1750 size_t bytes_written = 0;
1751 const uint8_t *bytes = (const uint8_t *)buf;
1752
1753 while (bytes_written < size)
1754 {
1755 const size_t curr_size = size - bytes_written;
1756 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written,
1757 bytes + bytes_written,
1758 curr_size,
1759 error);
1760 bytes_written += curr_bytes_written;
1761 if (curr_bytes_written == curr_size || curr_bytes_written == 0)
1762 break;
1763 }
1764 return bytes_written;
1765}
1766
1767size_t
1768Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
1769{
Greg Claytonfd119992011-01-07 06:08:19 +00001770#if defined (ENABLE_MEMORY_CACHING)
1771 m_memory_cache.Flush (addr, size);
1772#endif
1773
Chris Lattner24943d22010-06-08 16:52:24 +00001774 if (buf == NULL || size == 0)
1775 return 0;
Jim Inghame41494a2011-04-16 00:01:13 +00001776
1777 // Need to bump the stop ID after writing so that ValueObjects will know to re-read themselves.
1778 // FUTURE: Doing this should be okay, but if anybody else gets upset about the stop_id changing when
1779 // the target hasn't run, then we will need to add a "memory generation" as well as a stop_id...
1780 m_stop_id++;
1781
Chris Lattner24943d22010-06-08 16:52:24 +00001782 // We need to write any data that would go where any current software traps
1783 // (enabled software breakpoints) any software traps (breakpoints) that we
1784 // may have placed in our tasks memory.
1785
1786 BreakpointSiteList::collection::const_iterator iter = m_breakpoint_site_list.GetMap()->lower_bound (addr);
1787 BreakpointSiteList::collection::const_iterator end = m_breakpoint_site_list.GetMap()->end();
1788
1789 if (iter == end || iter->second->GetLoadAddress() > addr + size)
Greg Claytonc8bc1c32011-05-16 02:35:02 +00001790 return WriteMemoryPrivate (addr, buf, size, error);
Chris Lattner24943d22010-06-08 16:52:24 +00001791
1792 BreakpointSiteList::collection::const_iterator pos;
1793 size_t bytes_written = 0;
Greg Clayton54e7afa2010-07-09 20:39:50 +00001794 addr_t intersect_addr = 0;
1795 size_t intersect_size = 0;
1796 size_t opcode_offset = 0;
Chris Lattner24943d22010-06-08 16:52:24 +00001797 const uint8_t *ubuf = (const uint8_t *)buf;
1798
1799 for (pos = iter; pos != end; ++pos)
1800 {
1801 BreakpointSiteSP bp;
1802 bp = pos->second;
1803
1804 assert(bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset));
1805 assert(addr <= intersect_addr && intersect_addr < addr + size);
1806 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
1807 assert(opcode_offset + intersect_size <= bp->GetByteSize());
1808
1809 // Check for bytes before this breakpoint
1810 const addr_t curr_addr = addr + bytes_written;
1811 if (intersect_addr > curr_addr)
1812 {
1813 // There are some bytes before this breakpoint that we need to
1814 // just write to memory
1815 size_t curr_size = intersect_addr - curr_addr;
1816 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr,
1817 ubuf + bytes_written,
1818 curr_size,
1819 error);
1820 bytes_written += curr_bytes_written;
1821 if (curr_bytes_written != curr_size)
1822 {
1823 // We weren't able to write all of the requested bytes, we
1824 // are done looping and will return the number of bytes that
1825 // we have written so far.
1826 break;
1827 }
1828 }
1829
1830 // Now write any bytes that would cover up any software breakpoints
1831 // directly into the breakpoint opcode buffer
1832 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
1833 bytes_written += intersect_size;
1834 }
1835
1836 // Write any remaining bytes after the last breakpoint if we have any left
1837 if (bytes_written < size)
1838 bytes_written += WriteMemoryPrivate (addr + bytes_written,
1839 ubuf + bytes_written,
1840 size - bytes_written,
1841 error);
Jim Inghame41494a2011-04-16 00:01:13 +00001842
Chris Lattner24943d22010-06-08 16:52:24 +00001843 return bytes_written;
1844}
Greg Claytonc0fa5332011-05-22 22:46:53 +00001845
1846size_t
1847Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, uint32_t byte_size, Error &error)
1848{
1849 if (byte_size == UINT32_MAX)
1850 byte_size = scalar.GetByteSize();
1851 if (byte_size > 0)
1852 {
1853 uint8_t buf[32];
1854 const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error);
1855 if (mem_size > 0)
1856 return WriteMemory(addr, buf, mem_size, error);
1857 else
1858 error.SetErrorString ("failed to get scalar as memory data");
1859 }
1860 else
1861 {
1862 error.SetErrorString ("invalid scalar value");
1863 }
1864 return 0;
1865}
1866
1867size_t
1868Process::ReadScalarIntegerFromMemory (addr_t addr,
1869 uint32_t byte_size,
1870 bool is_signed,
1871 Scalar &scalar,
1872 Error &error)
1873{
1874 uint64_t uval;
1875
1876 if (byte_size <= sizeof(uval))
1877 {
1878 size_t bytes_read = ReadMemory (addr, &uval, byte_size, error);
1879 if (bytes_read == byte_size)
1880 {
1881 DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize());
1882 uint32_t offset = 0;
1883 if (byte_size <= 4)
1884 scalar = data.GetMaxU32 (&offset, byte_size);
1885 else
1886 scalar = data.GetMaxU64 (&offset, byte_size);
1887
1888 if (is_signed)
1889 scalar.SignExtend(byte_size * 8);
1890 return bytes_read;
1891 }
1892 }
1893 else
1894 {
1895 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
1896 }
1897 return 0;
1898}
1899
Greg Clayton613b8732011-05-17 03:37:42 +00001900#define USE_ALLOCATE_MEMORY_CACHE 1
Chris Lattner24943d22010-06-08 16:52:24 +00001901addr_t
1902Process::AllocateMemory(size_t size, uint32_t permissions, Error &error)
1903{
Jim Inghame6bd1422011-06-20 17:32:44 +00001904 if (GetPrivateState() != eStateStopped)
1905 return LLDB_INVALID_ADDRESS;
1906
Greg Clayton613b8732011-05-17 03:37:42 +00001907#if defined (USE_ALLOCATE_MEMORY_CACHE)
1908 return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
1909#else
Greg Clayton2860ba92011-01-23 19:58:49 +00001910 addr_t allocated_addr = DoAllocateMemory (size, permissions, error);
1911 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1912 if (log)
Greg Clayton613b8732011-05-17 03:37:42 +00001913 log->Printf("Process::AllocateMemory(size=%4zu, permissions=%s) => 0x%16.16llx (m_stop_id = %u)",
Greg Clayton2860ba92011-01-23 19:58:49 +00001914 size,
Greg Clayton613b8732011-05-17 03:37:42 +00001915 GetPermissionsAsCString (permissions),
Greg Clayton2860ba92011-01-23 19:58:49 +00001916 (uint64_t)allocated_addr,
1917 m_stop_id);
1918 return allocated_addr;
Greg Clayton613b8732011-05-17 03:37:42 +00001919#endif
Chris Lattner24943d22010-06-08 16:52:24 +00001920}
1921
1922Error
1923Process::DeallocateMemory (addr_t ptr)
1924{
Greg Clayton613b8732011-05-17 03:37:42 +00001925 Error error;
1926#if defined (USE_ALLOCATE_MEMORY_CACHE)
1927 if (!m_allocated_memory_cache.DeallocateMemory(ptr))
1928 {
1929 error.SetErrorStringWithFormat ("deallocation of memory at 0x%llx failed.", (uint64_t)ptr);
1930 }
1931#else
1932 error = DoDeallocateMemory (ptr);
Greg Clayton2860ba92011-01-23 19:58:49 +00001933
1934 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1935 if (log)
1936 log->Printf("Process::DeallocateMemory(addr=0x%16.16llx) => err = %s (m_stop_id = %u)",
1937 ptr,
1938 error.AsCString("SUCCESS"),
1939 m_stop_id);
Greg Clayton613b8732011-05-17 03:37:42 +00001940#endif
Greg Clayton2860ba92011-01-23 19:58:49 +00001941 return error;
Chris Lattner24943d22010-06-08 16:52:24 +00001942}
1943
1944
1945Error
1946Process::EnableWatchpoint (WatchpointLocation *watchpoint)
1947{
1948 Error error;
1949 error.SetErrorString("watchpoints are not supported");
1950 return error;
1951}
1952
1953Error
1954Process::DisableWatchpoint (WatchpointLocation *watchpoint)
1955{
1956 Error error;
1957 error.SetErrorString("watchpoints are not supported");
1958 return error;
1959}
1960
1961StateType
1962Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp)
1963{
1964 StateType state;
1965 // Now wait for the process to launch and return control to us, and then
1966 // call DidLaunch:
1967 while (1)
1968 {
Greg Clayton72e1c782011-01-22 23:43:18 +00001969 event_sp.reset();
1970 state = WaitForStateChangedEventsPrivate (timeout, event_sp);
1971
1972 if (StateIsStoppedState(state))
Chris Lattner24943d22010-06-08 16:52:24 +00001973 break;
Greg Clayton72e1c782011-01-22 23:43:18 +00001974
1975 // If state is invalid, then we timed out
1976 if (state == eStateInvalid)
1977 break;
1978
1979 if (event_sp)
Chris Lattner24943d22010-06-08 16:52:24 +00001980 HandlePrivateEvent (event_sp);
1981 }
1982 return state;
1983}
1984
1985Error
1986Process::Launch
1987(
1988 char const *argv[],
1989 char const *envp[],
Greg Clayton452bf612010-08-31 18:35:14 +00001990 uint32_t launch_flags,
Chris Lattner24943d22010-06-08 16:52:24 +00001991 const char *stdin_path,
1992 const char *stdout_path,
Greg Claytonde915be2011-01-23 05:56:20 +00001993 const char *stderr_path,
1994 const char *working_directory
Chris Lattner24943d22010-06-08 16:52:24 +00001995)
1996{
1997 Error error;
Chris Lattner24943d22010-06-08 16:52:24 +00001998 m_abi_sp.reset();
Greg Clayton75c703d2011-02-16 04:46:07 +00001999 m_dyld_ap.reset();
Caroline Tice861efb32010-11-16 05:07:41 +00002000 m_process_input_reader.reset();
Chris Lattner24943d22010-06-08 16:52:24 +00002001
2002 Module *exe_module = m_target.GetExecutableModule().get();
2003 if (exe_module)
2004 {
Greg Clayton180546b2011-04-30 01:09:13 +00002005 char local_exec_file_path[PATH_MAX];
2006 char platform_exec_file_path[PATH_MAX];
2007 exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path));
2008 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path));
Chris Lattner24943d22010-06-08 16:52:24 +00002009 if (exe_module->GetFileSpec().Exists())
2010 {
Greg Claytona2f74232011-02-24 22:24:29 +00002011 if (PrivateStateThreadIsValid ())
2012 PausePrivateStateThread ();
2013
Chris Lattner24943d22010-06-08 16:52:24 +00002014 error = WillLaunch (exe_module);
2015 if (error.Success())
2016 {
Greg Claytond8c62532010-10-07 04:19:01 +00002017 SetPublicState (eStateLaunching);
Chris Lattner24943d22010-06-08 16:52:24 +00002018 // The args coming in should not contain the application name, the
2019 // lldb_private::Process class will add this in case the executable
2020 // gets resolved to a different file than was given on the command
2021 // line (like when an applicaiton bundle is specified and will
2022 // resolve to the contained exectuable file, or the file given was
2023 // a symlink or other file system link that resolves to a different
2024 // file).
2025
2026 // Get the resolved exectuable path
2027
2028 // Make a new argument vector
2029 std::vector<const char *> exec_path_plus_argv;
2030 // Append the resolved executable path
Greg Clayton180546b2011-04-30 01:09:13 +00002031 exec_path_plus_argv.push_back (platform_exec_file_path);
Chris Lattner24943d22010-06-08 16:52:24 +00002032
2033 // Push all args if there are any
2034 if (argv)
2035 {
2036 for (int i = 0; argv[i]; ++i)
2037 exec_path_plus_argv.push_back(argv[i]);
2038 }
2039
2040 // Push a NULL to terminate the args.
2041 exec_path_plus_argv.push_back(NULL);
2042
2043 // Now launch using these arguments.
Greg Clayton53d68e72010-07-20 22:52:08 +00002044 error = DoLaunch (exe_module,
2045 exec_path_plus_argv.empty() ? NULL : &exec_path_plus_argv.front(),
2046 envp,
Greg Clayton452bf612010-08-31 18:35:14 +00002047 launch_flags,
Greg Clayton53d68e72010-07-20 22:52:08 +00002048 stdin_path,
2049 stdout_path,
Greg Claytonde915be2011-01-23 05:56:20 +00002050 stderr_path,
2051 working_directory);
Chris Lattner24943d22010-06-08 16:52:24 +00002052
2053 if (error.Fail())
2054 {
2055 if (GetID() != LLDB_INVALID_PROCESS_ID)
2056 {
2057 SetID (LLDB_INVALID_PROCESS_ID);
2058 const char *error_string = error.AsCString();
2059 if (error_string == NULL)
2060 error_string = "launch failed";
2061 SetExitStatus (-1, error_string);
2062 }
2063 }
2064 else
2065 {
2066 EventSP event_sp;
Greg Clayton49859592011-06-22 01:42:17 +00002067 TimeValue timeout_time;
2068 timeout_time = TimeValue::Now();
2069 timeout_time.OffsetWithSeconds(10);
2070 StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp);
Chris Lattner24943d22010-06-08 16:52:24 +00002071
Greg Clayton49859592011-06-22 01:42:17 +00002072 if (state == eStateInvalid || event_sp.get() == NULL)
2073 {
2074 // We were able to launch the process, but we failed to
2075 // catch the initial stop.
2076 SetExitStatus (0, "failed to catch stop after launch");
2077 Destroy();
2078 }
2079 else if (state == eStateStopped || state == eStateCrashed)
Chris Lattner24943d22010-06-08 16:52:24 +00002080 {
Greg Clayton75c703d2011-02-16 04:46:07 +00002081
Chris Lattner24943d22010-06-08 16:52:24 +00002082 DidLaunch ();
2083
Greg Clayton4fdf7602011-03-20 04:57:14 +00002084 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
Greg Clayton75c703d2011-02-16 04:46:07 +00002085 if (m_dyld_ap.get())
2086 m_dyld_ap->DidLaunch();
2087
Chris Lattner24943d22010-06-08 16:52:24 +00002088 // This delays passing the stopped event to listeners till DidLaunch gets
2089 // a chance to complete...
2090 HandlePrivateEvent (event_sp);
Greg Claytona2f74232011-02-24 22:24:29 +00002091
2092 if (PrivateStateThreadIsValid ())
2093 ResumePrivateStateThread ();
2094 else
2095 StartPrivateStateThread ();
Chris Lattner24943d22010-06-08 16:52:24 +00002096 }
2097 else if (state == eStateExited)
2098 {
2099 // We exited while trying to launch somehow. Don't call DidLaunch as that's
2100 // not likely to work, and return an invalid pid.
2101 HandlePrivateEvent (event_sp);
2102 }
2103 }
2104 }
2105 }
2106 else
2107 {
Greg Clayton180546b2011-04-30 01:09:13 +00002108 error.SetErrorStringWithFormat("File doesn't exist: '%s'.\n", local_exec_file_path);
Chris Lattner24943d22010-06-08 16:52:24 +00002109 }
2110 }
2111 return error;
2112}
2113
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002114Process::NextEventAction::EventActionResult
2115Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
Chris Lattner24943d22010-06-08 16:52:24 +00002116{
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002117 StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
2118 switch (state)
Greg Claytonc1d37752010-10-18 01:45:30 +00002119 {
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002120 case eStateRunning:
Greg Claytona2f74232011-02-24 22:24:29 +00002121 case eStateConnected:
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002122 return eEventActionRetry;
2123
2124 case eStateStopped:
2125 case eStateCrashed:
Jim Ingham7508e732010-08-09 23:31:02 +00002126 {
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002127 // During attach, prior to sending the eStateStopped event,
2128 // lldb_private::Process subclasses must set the process must set
2129 // the new process ID.
2130 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
Greg Clayton75c703d2011-02-16 04:46:07 +00002131 m_process->CompleteAttach ();
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002132 return eEventActionSuccess;
Jim Ingham7508e732010-08-09 23:31:02 +00002133 }
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002134
2135
2136 break;
2137 default:
2138 case eStateExited:
2139 case eStateInvalid:
2140 m_exit_string.assign ("No valid Process");
2141 return eEventActionExit;
2142 break;
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002143 }
2144}
Chris Lattner24943d22010-06-08 16:52:24 +00002145
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002146Process::NextEventAction::EventActionResult
2147Process::AttachCompletionHandler::HandleBeingInterrupted()
2148{
2149 return eEventActionSuccess;
2150}
2151
2152const char *
2153Process::AttachCompletionHandler::GetExitString ()
2154{
2155 return m_exit_string.c_str();
Chris Lattner24943d22010-06-08 16:52:24 +00002156}
2157
2158Error
2159Process::Attach (lldb::pid_t attach_pid)
2160{
2161
Chris Lattner24943d22010-06-08 16:52:24 +00002162 m_abi_sp.reset();
Caroline Tice861efb32010-11-16 05:07:41 +00002163 m_process_input_reader.reset();
Chris Lattner24943d22010-06-08 16:52:24 +00002164
Jim Ingham7508e732010-08-09 23:31:02 +00002165 // Find the process and its architecture. Make sure it matches the architecture
2166 // of the current Target, and if not adjust it.
2167
Greg Claytonb72d0f02011-04-12 05:54:46 +00002168 ProcessInstanceInfo process_info;
Greg Claytonb1888f22011-03-19 01:12:21 +00002169 PlatformSP platform_sp (m_target.GetDebugger().GetPlatformList().GetSelectedPlatform ());
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002170 if (platform_sp)
Jim Ingham7508e732010-08-09 23:31:02 +00002171 {
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002172 if (platform_sp->GetProcessInfo (attach_pid, process_info))
2173 {
2174 const ArchSpec &process_arch = process_info.GetArchitecture();
2175 if (process_arch.IsValid())
2176 GetTarget().SetArchitecture(process_arch);
2177 }
Jim Ingham7508e732010-08-09 23:31:02 +00002178 }
2179
Greg Clayton75c703d2011-02-16 04:46:07 +00002180 m_dyld_ap.reset();
2181
Greg Clayton54e7afa2010-07-09 20:39:50 +00002182 Error error (WillAttachToProcessWithID(attach_pid));
Chris Lattner24943d22010-06-08 16:52:24 +00002183 if (error.Success())
2184 {
Greg Claytond8c62532010-10-07 04:19:01 +00002185 SetPublicState (eStateAttaching);
2186
Greg Clayton54e7afa2010-07-09 20:39:50 +00002187 error = DoAttachToProcessWithID (attach_pid);
Chris Lattner24943d22010-06-08 16:52:24 +00002188 if (error.Success())
2189 {
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002190 SetNextEventAction(new Process::AttachCompletionHandler(this));
2191 StartPrivateStateThread();
Chris Lattner24943d22010-06-08 16:52:24 +00002192 }
2193 else
2194 {
2195 if (GetID() != LLDB_INVALID_PROCESS_ID)
2196 {
2197 SetID (LLDB_INVALID_PROCESS_ID);
2198 const char *error_string = error.AsCString();
2199 if (error_string == NULL)
2200 error_string = "attach failed";
2201
2202 SetExitStatus(-1, error_string);
2203 }
2204 }
2205 }
2206 return error;
2207}
2208
2209Error
2210Process::Attach (const char *process_name, bool wait_for_launch)
2211{
Chris Lattner24943d22010-06-08 16:52:24 +00002212 m_abi_sp.reset();
Caroline Tice861efb32010-11-16 05:07:41 +00002213 m_process_input_reader.reset();
Jim Ingham7508e732010-08-09 23:31:02 +00002214
2215 // Find the process and its architecture. Make sure it matches the architecture
2216 // of the current Target, and if not adjust it.
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002217 Error error;
Jim Ingham7508e732010-08-09 23:31:02 +00002218
Jim Inghamea294182010-08-17 21:54:19 +00002219 if (!wait_for_launch)
Jim Ingham7508e732010-08-09 23:31:02 +00002220 {
Greg Claytonb72d0f02011-04-12 05:54:46 +00002221 ProcessInstanceInfoList process_infos;
Greg Claytonb1888f22011-03-19 01:12:21 +00002222 PlatformSP platform_sp (m_target.GetDebugger().GetPlatformList().GetSelectedPlatform ());
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002223 if (platform_sp)
Jim Inghamea294182010-08-17 21:54:19 +00002224 {
Greg Claytonb72d0f02011-04-12 05:54:46 +00002225 ProcessInstanceInfoMatch match_info;
Greg Clayton24bc5d92011-03-30 18:16:51 +00002226 match_info.GetProcessInfo().SetName(process_name);
2227 match_info.SetNameMatchType (eNameMatchEquals);
2228 platform_sp->FindProcesses (match_info, process_infos);
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002229 if (process_infos.GetSize() > 1)
Chris Lattner24943d22010-06-08 16:52:24 +00002230 {
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002231 error.SetErrorStringWithFormat ("More than one process named %s\n", process_name);
2232 }
2233 else if (process_infos.GetSize() == 0)
2234 {
2235 error.SetErrorStringWithFormat ("Could not find a process named %s\n", process_name);
2236 }
2237 else
2238 {
Greg Claytonb72d0f02011-04-12 05:54:46 +00002239 ProcessInstanceInfo process_info;
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002240 if (process_infos.GetInfoAtIndex (0, process_info))
2241 {
2242 const ArchSpec &process_arch = process_info.GetArchitecture();
2243 if (process_arch.IsValid() && process_arch != GetTarget().GetArchitecture())
2244 {
2245 // Set the architecture on the target.
2246 GetTarget().SetArchitecture (process_arch);
2247 }
2248 }
Chris Lattner24943d22010-06-08 16:52:24 +00002249 }
2250 }
2251 else
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002252 {
2253 error.SetErrorString ("Invalid platform");
2254 }
2255 }
2256
2257 if (error.Success())
2258 {
2259 m_dyld_ap.reset();
2260
2261 error = WillAttachToProcessWithName(process_name, wait_for_launch);
2262 if (error.Success())
Chris Lattner24943d22010-06-08 16:52:24 +00002263 {
Greg Claytone4b9c1f2011-03-08 22:40:15 +00002264 SetPublicState (eStateAttaching);
2265 error = DoAttachToProcessWithName (process_name, wait_for_launch);
2266 if (error.Fail())
2267 {
2268 if (GetID() != LLDB_INVALID_PROCESS_ID)
2269 {
2270 SetID (LLDB_INVALID_PROCESS_ID);
2271 const char *error_string = error.AsCString();
2272 if (error_string == NULL)
2273 error_string = "attach failed";
2274
2275 SetExitStatus(-1, error_string);
2276 }
2277 }
2278 else
2279 {
2280 SetNextEventAction(new Process::AttachCompletionHandler(this));
2281 StartPrivateStateThread();
2282 }
Chris Lattner24943d22010-06-08 16:52:24 +00002283 }
2284 }
2285 return error;
2286}
2287
Greg Clayton75c703d2011-02-16 04:46:07 +00002288void
2289Process::CompleteAttach ()
2290{
2291 // Let the process subclass figure out at much as it can about the process
2292 // before we go looking for a dynamic loader plug-in.
2293 DidAttach();
2294
2295 // We have complete the attach, now it is time to find the dynamic loader
2296 // plug-in
Greg Clayton4fdf7602011-03-20 04:57:14 +00002297 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
Greg Clayton75c703d2011-02-16 04:46:07 +00002298 if (m_dyld_ap.get())
2299 m_dyld_ap->DidAttach();
2300
2301 // Figure out which one is the executable, and set that in our target:
2302 ModuleList &modules = m_target.GetImages();
2303
2304 size_t num_modules = modules.GetSize();
2305 for (int i = 0; i < num_modules; i++)
2306 {
2307 ModuleSP module_sp (modules.GetModuleAtIndex(i));
Greg Claytonb72d0f02011-04-12 05:54:46 +00002308 if (module_sp && module_sp->IsExecutable())
Greg Clayton75c703d2011-02-16 04:46:07 +00002309 {
2310 ModuleSP target_exe_module_sp (m_target.GetExecutableModule());
2311 if (target_exe_module_sp != module_sp)
2312 m_target.SetExecutableModule (module_sp, false);
2313 break;
2314 }
2315 }
2316}
2317
Chris Lattner24943d22010-06-08 16:52:24 +00002318Error
Greg Claytone71e2582011-02-04 01:58:07 +00002319Process::ConnectRemote (const char *remote_url)
2320{
Greg Claytone71e2582011-02-04 01:58:07 +00002321 m_abi_sp.reset();
2322 m_process_input_reader.reset();
2323
2324 // Find the process and its architecture. Make sure it matches the architecture
2325 // of the current Target, and if not adjust it.
2326
2327 Error error (DoConnectRemote (remote_url));
2328 if (error.Success())
2329 {
Greg Claytona2f74232011-02-24 22:24:29 +00002330 if (GetID() != LLDB_INVALID_PROCESS_ID)
2331 {
Greg Clayton24bc5d92011-03-30 18:16:51 +00002332 EventSP event_sp;
2333 StateType state = WaitForProcessStopPrivate(NULL, event_sp);
2334
2335 if (state == eStateStopped || state == eStateCrashed)
2336 {
2337 // If we attached and actually have a process on the other end, then
2338 // this ended up being the equivalent of an attach.
2339 CompleteAttach ();
2340
2341 // This delays passing the stopped event to listeners till
2342 // CompleteAttach gets a chance to complete...
2343 HandlePrivateEvent (event_sp);
2344
2345 }
Greg Claytona2f74232011-02-24 22:24:29 +00002346 }
Greg Clayton24bc5d92011-03-30 18:16:51 +00002347
2348 if (PrivateStateThreadIsValid ())
2349 ResumePrivateStateThread ();
2350 else
2351 StartPrivateStateThread ();
Greg Claytone71e2582011-02-04 01:58:07 +00002352 }
2353 return error;
2354}
2355
2356
2357Error
Chris Lattner24943d22010-06-08 16:52:24 +00002358Process::Resume ()
2359{
Greg Claytone005f2c2010-11-06 01:53:30 +00002360 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +00002361 if (log)
Jim Inghamac959662011-01-24 06:34:17 +00002362 log->Printf("Process::Resume() m_stop_id = %u, public state: %s private state: %s",
2363 m_stop_id,
2364 StateAsCString(m_public_state.GetValue()),
2365 StateAsCString(m_private_state.GetValue()));
Chris Lattner24943d22010-06-08 16:52:24 +00002366
2367 Error error (WillResume());
2368 // Tell the process it is about to resume before the thread list
2369 if (error.Success())
2370 {
Johnny Chen9c11d472010-12-02 20:53:05 +00002371 // Now let the thread list know we are about to resume so it
Chris Lattner24943d22010-06-08 16:52:24 +00002372 // can let all of our threads know that they are about to be
2373 // resumed. Threads will each be called with
2374 // Thread::WillResume(StateType) where StateType contains the state
2375 // that they are supposed to have when the process is resumed
2376 // (suspended/running/stepping). Threads should also check
2377 // their resume signal in lldb::Thread::GetResumeSignal()
2378 // to see if they are suppoed to start back up with a signal.
2379 if (m_thread_list.WillResume())
2380 {
2381 error = DoResume();
2382 if (error.Success())
2383 {
2384 DidResume();
2385 m_thread_list.DidResume();
Jim Inghamac959662011-01-24 06:34:17 +00002386 if (log)
2387 log->Printf ("Process thinks the process has resumed.");
Chris Lattner24943d22010-06-08 16:52:24 +00002388 }
2389 }
2390 else
2391 {
Jim Inghamac959662011-01-24 06:34:17 +00002392 error.SetErrorStringWithFormat("Process::WillResume() thread list returned false after WillResume");
Chris Lattner24943d22010-06-08 16:52:24 +00002393 }
2394 }
Jim Inghamac959662011-01-24 06:34:17 +00002395 else if (log)
2396 log->Printf ("Process::WillResume() got an error \"%s\".", error.AsCString("<unknown error>"));
Chris Lattner24943d22010-06-08 16:52:24 +00002397 return error;
2398}
2399
2400Error
2401Process::Halt ()
2402{
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002403 // Pause our private state thread so we can ensure no one else eats
2404 // the stop event out from under us.
Jim Inghamf9f40c22011-02-08 05:20:59 +00002405 Listener halt_listener ("lldb.process.halt_listener");
2406 HijackPrivateProcessEvents(&halt_listener);
Greg Clayton20d338f2010-11-18 05:57:03 +00002407
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002408 EventSP event_sp;
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002409 Error error (WillHalt());
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002410
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002411 if (error.Success())
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002412 {
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002413
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002414 bool caused_stop = false;
2415
2416 // Ask the process subclass to actually halt our process
2417 error = DoHalt(caused_stop);
Chris Lattner24943d22010-06-08 16:52:24 +00002418 if (error.Success())
Jim Ingham3ae449a2010-11-17 02:32:00 +00002419 {
Greg Clayton7e2f91c2011-01-29 07:10:55 +00002420 if (m_public_state.GetValue() == eStateAttaching)
2421 {
2422 SetExitStatus(SIGKILL, "Cancelled async attach.");
2423 Destroy ();
2424 }
2425 else
Jim Ingham3ae449a2010-11-17 02:32:00 +00002426 {
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002427 // If "caused_stop" is true, then DoHalt stopped the process. If
2428 // "caused_stop" is false, the process was already stopped.
2429 // If the DoHalt caused the process to stop, then we want to catch
2430 // this event and set the interrupted bool to true before we pass
2431 // this along so clients know that the process was interrupted by
2432 // a halt command.
2433 if (caused_stop)
Greg Clayton20d338f2010-11-18 05:57:03 +00002434 {
Jim Inghamf9f40c22011-02-08 05:20:59 +00002435 // Wait for 1 second for the process to stop.
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002436 TimeValue timeout_time;
2437 timeout_time = TimeValue::Now();
2438 timeout_time.OffsetWithSeconds(1);
Jim Inghamf9f40c22011-02-08 05:20:59 +00002439 bool got_event = halt_listener.WaitForEvent (&timeout_time, event_sp);
2440 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002441
Jim Inghamf9f40c22011-02-08 05:20:59 +00002442 if (!got_event || state == eStateInvalid)
Greg Clayton20d338f2010-11-18 05:57:03 +00002443 {
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002444 // We timeout out and didn't get a stop event...
Jim Inghamf9f40c22011-02-08 05:20:59 +00002445 error.SetErrorStringWithFormat ("Halt timed out. State = %s", StateAsCString(GetState()));
Greg Clayton20d338f2010-11-18 05:57:03 +00002446 }
2447 else
2448 {
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002449 if (StateIsStoppedState (state))
2450 {
2451 // We caused the process to interrupt itself, so mark this
2452 // as such in the stop event so clients can tell an interrupted
2453 // process from a natural stop
2454 ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);
2455 }
2456 else
2457 {
2458 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
2459 if (log)
2460 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
2461 error.SetErrorString ("Did not get stopped event after halt.");
2462 }
Greg Clayton20d338f2010-11-18 05:57:03 +00002463 }
2464 }
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002465 DidHalt();
Jim Ingham3ae449a2010-11-17 02:32:00 +00002466 }
2467 }
Chris Lattner24943d22010-06-08 16:52:24 +00002468 }
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002469 // Resume our private state thread before we post the event (if any)
Jim Inghamf9f40c22011-02-08 05:20:59 +00002470 RestorePrivateProcessEvents();
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002471
2472 // Post any event we might have consumed. If all goes well, we will have
2473 // stopped the process, intercepted the event and set the interrupted
2474 // bool in the event. Post it to the private event queue and that will end up
2475 // correctly setting the state.
2476 if (event_sp)
2477 m_private_state_broadcaster.BroadcastEvent(event_sp);
2478
Chris Lattner24943d22010-06-08 16:52:24 +00002479 return error;
2480}
2481
2482Error
2483Process::Detach ()
2484{
2485 Error error (WillDetach());
2486
2487 if (error.Success())
2488 {
2489 DisableAllBreakpointSites();
2490 error = DoDetach();
2491 if (error.Success())
2492 {
2493 DidDetach();
2494 StopPrivateStateThread();
2495 }
2496 }
2497 return error;
2498}
2499
2500Error
2501Process::Destroy ()
2502{
2503 Error error (WillDestroy());
2504 if (error.Success())
2505 {
2506 DisableAllBreakpointSites();
2507 error = DoDestroy();
2508 if (error.Success())
2509 {
2510 DidDestroy();
2511 StopPrivateStateThread();
2512 }
Caroline Tice861efb32010-11-16 05:07:41 +00002513 m_stdio_communication.StopReadThread();
2514 m_stdio_communication.Disconnect();
2515 if (m_process_input_reader && m_process_input_reader->IsActive())
2516 m_target.GetDebugger().PopInputReader (m_process_input_reader);
2517 if (m_process_input_reader)
2518 m_process_input_reader.reset();
Chris Lattner24943d22010-06-08 16:52:24 +00002519 }
2520 return error;
2521}
2522
2523Error
2524Process::Signal (int signal)
2525{
2526 Error error (WillSignal());
2527 if (error.Success())
2528 {
2529 error = DoSignal(signal);
2530 if (error.Success())
2531 DidSignal();
2532 }
2533 return error;
2534}
2535
Greg Clayton395fc332011-02-15 21:59:32 +00002536lldb::ByteOrder
2537Process::GetByteOrder () const
Chris Lattner24943d22010-06-08 16:52:24 +00002538{
Greg Clayton395fc332011-02-15 21:59:32 +00002539 return m_target.GetArchitecture().GetByteOrder();
Chris Lattner24943d22010-06-08 16:52:24 +00002540}
2541
2542uint32_t
Greg Clayton395fc332011-02-15 21:59:32 +00002543Process::GetAddressByteSize () const
Chris Lattner24943d22010-06-08 16:52:24 +00002544{
Greg Clayton395fc332011-02-15 21:59:32 +00002545 return m_target.GetArchitecture().GetAddressByteSize();
Chris Lattner24943d22010-06-08 16:52:24 +00002546}
2547
Greg Clayton395fc332011-02-15 21:59:32 +00002548
Chris Lattner24943d22010-06-08 16:52:24 +00002549bool
2550Process::ShouldBroadcastEvent (Event *event_ptr)
2551{
2552 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr);
2553 bool return_value = true;
Greg Claytone005f2c2010-11-06 01:53:30 +00002554 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner24943d22010-06-08 16:52:24 +00002555
2556 switch (state)
2557 {
Greg Claytone71e2582011-02-04 01:58:07 +00002558 case eStateConnected:
Chris Lattner24943d22010-06-08 16:52:24 +00002559 case eStateAttaching:
2560 case eStateLaunching:
2561 case eStateDetached:
2562 case eStateExited:
2563 case eStateUnloaded:
2564 // These events indicate changes in the state of the debugging session, always report them.
2565 return_value = true;
2566 break;
2567 case eStateInvalid:
2568 // We stopped for no apparent reason, don't report it.
2569 return_value = false;
2570 break;
2571 case eStateRunning:
2572 case eStateStepping:
2573 // If we've started the target running, we handle the cases where we
2574 // are already running and where there is a transition from stopped to
2575 // running differently.
2576 // running -> running: Automatically suppress extra running events
2577 // stopped -> running: Report except when there is one or more no votes
2578 // and no yes votes.
2579 SynchronouslyNotifyStateChanged (state);
2580 switch (m_public_state.GetValue())
2581 {
2582 case eStateRunning:
2583 case eStateStepping:
2584 // We always suppress multiple runnings with no PUBLIC stop in between.
2585 return_value = false;
2586 break;
2587 default:
2588 // TODO: make this work correctly. For now always report
2589 // run if we aren't running so we don't miss any runnning
2590 // events. If I run the lldb/test/thread/a.out file and
2591 // break at main.cpp:58, run and hit the breakpoints on
2592 // multiple threads, then somehow during the stepping over
2593 // of all breakpoints no run gets reported.
2594 return_value = true;
2595
2596 // This is a transition from stop to run.
2597 switch (m_thread_list.ShouldReportRun (event_ptr))
2598 {
2599 case eVoteYes:
2600 case eVoteNoOpinion:
2601 return_value = true;
2602 break;
2603 case eVoteNo:
2604 return_value = false;
2605 break;
2606 }
2607 break;
2608 }
2609 break;
2610 case eStateStopped:
2611 case eStateCrashed:
2612 case eStateSuspended:
2613 {
2614 // We've stopped. First see if we're going to restart the target.
2615 // If we are going to stop, then we always broadcast the event.
2616 // If we aren't going to stop, let the thread plans decide if we're going to report this event.
Jim Ingham5a47e8b2010-06-19 04:45:32 +00002617 // If no thread has an opinion, we don't report it.
Jim Ingham3ae449a2010-11-17 02:32:00 +00002618 if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
Chris Lattner24943d22010-06-08 16:52:24 +00002619 {
Greg Clayton20d338f2010-11-18 05:57:03 +00002620 if (log)
2621 log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s", event_ptr, StateAsCString(state));
Jim Ingham3ae449a2010-11-17 02:32:00 +00002622 return true;
2623 }
2624 else
2625 {
Chris Lattner24943d22010-06-08 16:52:24 +00002626 RefreshStateAfterStop ();
2627
2628 if (m_thread_list.ShouldStop (event_ptr) == false)
2629 {
2630 switch (m_thread_list.ShouldReportStop (event_ptr))
2631 {
2632 case eVoteYes:
2633 Process::ProcessEventData::SetRestartedInEvent (event_ptr, true);
Johnny Chen028784b2010-10-14 00:54:32 +00002634 // Intentional fall-through here.
Chris Lattner24943d22010-06-08 16:52:24 +00002635 case eVoteNoOpinion:
Chris Lattner24943d22010-06-08 16:52:24 +00002636 case eVoteNo:
2637 return_value = false;
2638 break;
2639 }
2640
2641 if (log)
Jim Ingham3ae449a2010-11-17 02:32:00 +00002642 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s", event_ptr, StateAsCString(state));
Chris Lattner24943d22010-06-08 16:52:24 +00002643 Resume ();
2644 }
2645 else
2646 {
2647 return_value = true;
2648 SynchronouslyNotifyStateChanged (state);
2649 }
2650 }
2651 }
2652 }
2653
2654 if (log)
2655 log->Printf ("Process::ShouldBroadcastEvent (%p) => %s", event_ptr, StateAsCString(state), return_value ? "YES" : "NO");
2656 return return_value;
2657}
2658
Chris Lattner24943d22010-06-08 16:52:24 +00002659
2660bool
2661Process::StartPrivateStateThread ()
2662{
Greg Claytone005f2c2010-11-06 01:53:30 +00002663 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner24943d22010-06-08 16:52:24 +00002664
Greg Claytonb72d0f02011-04-12 05:54:46 +00002665 bool already_running = PrivateStateThreadIsValid ();
Chris Lattner24943d22010-06-08 16:52:24 +00002666 if (log)
Greg Claytonb72d0f02011-04-12 05:54:46 +00002667 log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread");
2668
2669 if (already_running)
2670 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00002671
2672 // Create a thread that watches our internal state and controls which
2673 // events make it to clients (into the DCProcess event queue).
Greg Claytona875b642011-01-09 21:07:35 +00002674 char thread_name[1024];
2675 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%i)>", GetID());
2676 m_private_state_thread = Host::ThreadCreate (thread_name, Process::PrivateStateThread, this, NULL);
Greg Clayton09c81ef2011-02-08 01:34:25 +00002677 return IS_VALID_LLDB_HOST_THREAD(m_private_state_thread);
Chris Lattner24943d22010-06-08 16:52:24 +00002678}
2679
2680void
2681Process::PausePrivateStateThread ()
2682{
2683 ControlPrivateStateThread (eBroadcastInternalStateControlPause);
2684}
2685
2686void
2687Process::ResumePrivateStateThread ()
2688{
2689 ControlPrivateStateThread (eBroadcastInternalStateControlResume);
2690}
2691
2692void
2693Process::StopPrivateStateThread ()
2694{
Greg Claytonb72d0f02011-04-12 05:54:46 +00002695 if (PrivateStateThreadIsValid ())
2696 ControlPrivateStateThread (eBroadcastInternalStateControlStop);
Chris Lattner24943d22010-06-08 16:52:24 +00002697}
2698
2699void
2700Process::ControlPrivateStateThread (uint32_t signal)
2701{
Greg Claytone005f2c2010-11-06 01:53:30 +00002702 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner24943d22010-06-08 16:52:24 +00002703
2704 assert (signal == eBroadcastInternalStateControlStop ||
2705 signal == eBroadcastInternalStateControlPause ||
2706 signal == eBroadcastInternalStateControlResume);
2707
2708 if (log)
Greg Claytonf4fbc0b2011-01-22 17:43:17 +00002709 log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
Chris Lattner24943d22010-06-08 16:52:24 +00002710
Greg Claytonf4fbc0b2011-01-22 17:43:17 +00002711 // Signal the private state thread. First we should copy this is case the
2712 // thread starts exiting since the private state thread will NULL this out
2713 // when it exits
2714 const lldb::thread_t private_state_thread = m_private_state_thread;
Greg Clayton09c81ef2011-02-08 01:34:25 +00002715 if (IS_VALID_LLDB_HOST_THREAD(private_state_thread))
Chris Lattner24943d22010-06-08 16:52:24 +00002716 {
2717 TimeValue timeout_time;
2718 bool timed_out;
2719
2720 m_private_state_control_broadcaster.BroadcastEvent (signal, NULL);
2721
2722 timeout_time = TimeValue::Now();
2723 timeout_time.OffsetWithSeconds(2);
2724 m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out);
2725 m_private_state_control_wait.SetValue (false, eBroadcastNever);
2726
2727 if (signal == eBroadcastInternalStateControlStop)
2728 {
2729 if (timed_out)
Greg Claytonf4fbc0b2011-01-22 17:43:17 +00002730 Host::ThreadCancel (private_state_thread, NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00002731
2732 thread_result_t result = NULL;
Greg Claytonf4fbc0b2011-01-22 17:43:17 +00002733 Host::ThreadJoin (private_state_thread, &result, NULL);
Greg Claytonc607d862010-07-22 18:34:21 +00002734 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner24943d22010-06-08 16:52:24 +00002735 }
2736 }
2737}
2738
2739void
2740Process::HandlePrivateEvent (EventSP &event_sp)
2741{
Greg Claytone005f2c2010-11-06 01:53:30 +00002742 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002743
Greg Clayton68ca8232011-01-25 02:58:48 +00002744 const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002745
2746 // First check to see if anybody wants a shot at this event:
Jim Ingham68bffc52011-01-29 04:05:41 +00002747 if (m_next_event_action_ap.get() != NULL)
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002748 {
Jim Ingham68bffc52011-01-29 04:05:41 +00002749 NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp);
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002750 switch (action_result)
2751 {
2752 case NextEventAction::eEventActionSuccess:
2753 SetNextEventAction(NULL);
2754 break;
2755 case NextEventAction::eEventActionRetry:
2756 break;
2757 case NextEventAction::eEventActionExit:
Jim Ingham84c86382011-01-29 01:57:31 +00002758 // Handle Exiting Here. If we already got an exited event,
2759 // we should just propagate it. Otherwise, swallow this event,
2760 // and set our state to exit so the next event will kill us.
2761 if (new_state != eStateExited)
2762 {
2763 // FIXME: should cons up an exited event, and discard this one.
Jim Ingham68bffc52011-01-29 04:05:41 +00002764 SetExitStatus(0, m_next_event_action_ap->GetExitString());
Jim Ingham84c86382011-01-29 01:57:31 +00002765 SetNextEventAction(NULL);
2766 return;
2767 }
2768 SetNextEventAction(NULL);
Jim Inghamc2dc7c82011-01-29 01:49:25 +00002769 break;
2770 }
2771 }
2772
Chris Lattner24943d22010-06-08 16:52:24 +00002773 // See if we should broadcast this state to external clients?
2774 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get());
Chris Lattner24943d22010-06-08 16:52:24 +00002775
2776 if (should_broadcast)
2777 {
2778 if (log)
2779 {
Greg Clayton68ca8232011-01-25 02:58:48 +00002780 log->Printf ("Process::%s (pid = %i) broadcasting new state %s (old state %s) to %s",
2781 __FUNCTION__,
2782 GetID(),
2783 StateAsCString(new_state),
2784 StateAsCString (GetState ()),
2785 IsHijackedForEvent(eBroadcastBitStateChanged) ? "hijacked" : "public");
Chris Lattner24943d22010-06-08 16:52:24 +00002786 }
Jim Inghamd60d94a2011-03-11 03:53:59 +00002787 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
Greg Clayton68ca8232011-01-25 02:58:48 +00002788 if (StateIsRunningState (new_state))
Caroline Tice861efb32010-11-16 05:07:41 +00002789 PushProcessInputReader ();
2790 else
2791 PopProcessInputReader ();
Jim Inghamd60d94a2011-03-11 03:53:59 +00002792
Chris Lattner24943d22010-06-08 16:52:24 +00002793 BroadcastEvent (event_sp);
2794 }
2795 else
2796 {
2797 if (log)
2798 {
Greg Clayton68ca8232011-01-25 02:58:48 +00002799 log->Printf ("Process::%s (pid = %i) suppressing state %s (old state %s): should_broadcast == false",
2800 __FUNCTION__,
2801 GetID(),
2802 StateAsCString(new_state),
2803 StateAsCString (GetState ()),
2804 IsHijackedForEvent(eBroadcastBitStateChanged) ? "hijacked" : "public");
Chris Lattner24943d22010-06-08 16:52:24 +00002805 }
2806 }
2807}
2808
2809void *
2810Process::PrivateStateThread (void *arg)
2811{
2812 Process *proc = static_cast<Process*> (arg);
2813 void *result = proc->RunPrivateStateThread ();
Chris Lattner24943d22010-06-08 16:52:24 +00002814 return result;
2815}
2816
2817void *
2818Process::RunPrivateStateThread ()
2819{
2820 bool control_only = false;
2821 m_private_state_control_wait.SetValue (false, eBroadcastNever);
2822
Greg Claytone005f2c2010-11-06 01:53:30 +00002823 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner24943d22010-06-08 16:52:24 +00002824 if (log)
2825 log->Printf ("Process::%s (arg = %p, pid = %i) thread starting...", __FUNCTION__, this, GetID());
2826
2827 bool exit_now = false;
2828 while (!exit_now)
2829 {
2830 EventSP event_sp;
2831 WaitForEventsPrivate (NULL, event_sp, control_only);
2832 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
2833 {
2834 switch (event_sp->GetType())
2835 {
2836 case eBroadcastInternalStateControlStop:
2837 exit_now = true;
2838 continue; // Go to next loop iteration so we exit without
2839 break; // doing any internal state managment below
2840
2841 case eBroadcastInternalStateControlPause:
2842 control_only = true;
2843 break;
2844
2845 case eBroadcastInternalStateControlResume:
2846 control_only = false;
2847 break;
2848 }
Jim Ingham3ae449a2010-11-17 02:32:00 +00002849
Jim Ingham3ae449a2010-11-17 02:32:00 +00002850 if (log)
2851 log->Printf ("Process::%s (arg = %p, pid = %i) got a control event: %d", __FUNCTION__, this, GetID(), event_sp->GetType());
2852
Chris Lattner24943d22010-06-08 16:52:24 +00002853 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
Jim Ingham3ae449a2010-11-17 02:32:00 +00002854 continue;
Chris Lattner24943d22010-06-08 16:52:24 +00002855 }
2856
2857
2858 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
2859
2860 if (internal_state != eStateInvalid)
2861 {
2862 HandlePrivateEvent (event_sp);
2863 }
2864
Greg Clayton3b2c41c2010-10-18 04:14:23 +00002865 if (internal_state == eStateInvalid ||
2866 internal_state == eStateExited ||
2867 internal_state == eStateDetached )
Jim Ingham3ae449a2010-11-17 02:32:00 +00002868 {
Jim Ingham3ae449a2010-11-17 02:32:00 +00002869 if (log)
2870 log->Printf ("Process::%s (arg = %p, pid = %i) about to exit with internal state %s...", __FUNCTION__, this, GetID(), StateAsCString(internal_state));
2871
Chris Lattner24943d22010-06-08 16:52:24 +00002872 break;
Jim Ingham3ae449a2010-11-17 02:32:00 +00002873 }
Chris Lattner24943d22010-06-08 16:52:24 +00002874 }
2875
Caroline Tice926060e2010-10-29 21:48:37 +00002876 // Verify log is still enabled before attempting to write to it...
Chris Lattner24943d22010-06-08 16:52:24 +00002877 if (log)
2878 log->Printf ("Process::%s (arg = %p, pid = %i) thread exiting...", __FUNCTION__, this, GetID());
2879
Greg Claytona4881d02011-01-22 07:12:45 +00002880 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
2881 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner24943d22010-06-08 16:52:24 +00002882 return NULL;
2883}
2884
Chris Lattner24943d22010-06-08 16:52:24 +00002885//------------------------------------------------------------------
2886// Process Event Data
2887//------------------------------------------------------------------
2888
2889Process::ProcessEventData::ProcessEventData () :
2890 EventData (),
2891 m_process_sp (),
2892 m_state (eStateInvalid),
Greg Clayton54e7afa2010-07-09 20:39:50 +00002893 m_restarted (false),
Jim Ingham6cf4d2b2011-05-22 21:45:01 +00002894 m_update_state (0),
Jim Ingham3ae449a2010-11-17 02:32:00 +00002895 m_interrupted (false)
Chris Lattner24943d22010-06-08 16:52:24 +00002896{
2897}
2898
2899Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) :
2900 EventData (),
2901 m_process_sp (process_sp),
2902 m_state (state),
Greg Clayton54e7afa2010-07-09 20:39:50 +00002903 m_restarted (false),
Jim Ingham6cf4d2b2011-05-22 21:45:01 +00002904 m_update_state (0),
Jim Ingham3ae449a2010-11-17 02:32:00 +00002905 m_interrupted (false)
Chris Lattner24943d22010-06-08 16:52:24 +00002906{
2907}
2908
2909Process::ProcessEventData::~ProcessEventData()
2910{
2911}
2912
2913const ConstString &
2914Process::ProcessEventData::GetFlavorString ()
2915{
2916 static ConstString g_flavor ("Process::ProcessEventData");
2917 return g_flavor;
2918}
2919
2920const ConstString &
2921Process::ProcessEventData::GetFlavor () const
2922{
2923 return ProcessEventData::GetFlavorString ();
2924}
2925
Chris Lattner24943d22010-06-08 16:52:24 +00002926void
2927Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
2928{
2929 // This function gets called twice for each event, once when the event gets pulled
Jim Ingham6cf4d2b2011-05-22 21:45:01 +00002930 // off of the private process event queue, and then any number of times, first when it gets pulled off of
2931 // the public event queue, then other times when we're pretending that this is where we stopped at the
2932 // end of expression evaluation. m_update_state is used to distinguish these
2933 // three cases; it is 0 when we're just pulling it off for private handling,
2934 // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
Chris Lattner24943d22010-06-08 16:52:24 +00002935
Jim Ingham6cf4d2b2011-05-22 21:45:01 +00002936 if (m_update_state != 1)
Chris Lattner24943d22010-06-08 16:52:24 +00002937 return;
2938
2939 m_process_sp->SetPublicState (m_state);
2940
2941 // If we're stopped and haven't restarted, then do the breakpoint commands here:
2942 if (m_state == eStateStopped && ! m_restarted)
2943 {
2944 int num_threads = m_process_sp->GetThreadList().GetSize();
2945 int idx;
Greg Clayton643ee732010-08-04 01:40:35 +00002946
Chris Lattner24943d22010-06-08 16:52:24 +00002947 for (idx = 0; idx < num_threads; ++idx)
2948 {
2949 lldb::ThreadSP thread_sp = m_process_sp->GetThreadList().GetThreadAtIndex(idx);
2950
Jim Ingham6297a3a2010-10-20 00:39:53 +00002951 StopInfoSP stop_info_sp = thread_sp->GetStopInfo ();
2952 if (stop_info_sp)
Chris Lattner24943d22010-06-08 16:52:24 +00002953 {
Jim Ingham6297a3a2010-10-20 00:39:53 +00002954 stop_info_sp->PerformAction(event_ptr);
Chris Lattner24943d22010-06-08 16:52:24 +00002955 }
2956 }
Greg Clayton643ee732010-08-04 01:40:35 +00002957
Jim Ingham6fb8baa2010-08-10 00:59:59 +00002958 // The stop action might restart the target. If it does, then we want to mark that in the
2959 // event so that whoever is receiving it will know to wait for the running event and reflect
2960 // that state appropriately.
2961
Chris Lattner24943d22010-06-08 16:52:24 +00002962 if (m_process_sp->GetPrivateState() == eStateRunning)
2963 SetRestarted(true);
Jim Inghamd60d94a2011-03-11 03:53:59 +00002964 else
2965 {
2966 // Finally, if we didn't restart, run the Stop Hooks here:
2967 // They might also restart the target, so watch for that.
2968 m_process_sp->GetTarget().RunStopHooks();
2969 if (m_process_sp->GetPrivateState() == eStateRunning)
2970 SetRestarted(true);
2971 }
2972
Chris Lattner24943d22010-06-08 16:52:24 +00002973 }
2974}
2975
2976void
2977Process::ProcessEventData::Dump (Stream *s) const
2978{
2979 if (m_process_sp)
2980 s->Printf(" process = %p (pid = %u), ", m_process_sp.get(), m_process_sp->GetID());
2981
Greg Claytonb72d0f02011-04-12 05:54:46 +00002982 s->Printf("state = %s", StateAsCString(GetState()));
Chris Lattner24943d22010-06-08 16:52:24 +00002983}
2984
2985const Process::ProcessEventData *
2986Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr)
2987{
2988 if (event_ptr)
2989 {
2990 const EventData *event_data = event_ptr->GetData();
2991 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString())
2992 return static_cast <const ProcessEventData *> (event_ptr->GetData());
2993 }
2994 return NULL;
2995}
2996
2997ProcessSP
2998Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr)
2999{
3000 ProcessSP process_sp;
3001 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3002 if (data)
3003 process_sp = data->GetProcessSP();
3004 return process_sp;
3005}
3006
3007StateType
3008Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr)
3009{
3010 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3011 if (data == NULL)
3012 return eStateInvalid;
3013 else
3014 return data->GetState();
3015}
3016
3017bool
3018Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr)
3019{
3020 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3021 if (data == NULL)
3022 return false;
3023 else
3024 return data->GetRestarted();
3025}
3026
3027void
3028Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value)
3029{
3030 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
3031 if (data != NULL)
3032 data->SetRestarted(new_value);
3033}
3034
3035bool
Jim Ingham3ae449a2010-11-17 02:32:00 +00003036Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr)
3037{
3038 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
3039 if (data == NULL)
3040 return false;
3041 else
3042 return data->GetInterrupted ();
3043}
3044
3045void
3046Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value)
3047{
3048 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
3049 if (data != NULL)
3050 data->SetInterrupted(new_value);
3051}
3052
3053bool
Chris Lattner24943d22010-06-08 16:52:24 +00003054Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr)
3055{
3056 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
3057 if (data)
3058 {
3059 data->SetUpdateStateOnRemoval();
3060 return true;
3061 }
3062 return false;
3063}
3064
Chris Lattner24943d22010-06-08 16:52:24 +00003065void
Greg Claytona830adb2010-10-04 01:05:56 +00003066Process::CalculateExecutionContext (ExecutionContext &exe_ctx)
Chris Lattner24943d22010-06-08 16:52:24 +00003067{
3068 exe_ctx.target = &m_target;
3069 exe_ctx.process = this;
3070 exe_ctx.thread = NULL;
3071 exe_ctx.frame = NULL;
3072}
3073
3074lldb::ProcessSP
3075Process::GetSP ()
3076{
3077 return GetTarget().GetProcessSP();
3078}
3079
Greg Claytone4b9c1f2011-03-08 22:40:15 +00003080//uint32_t
3081//Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
3082//{
3083// return 0;
3084//}
3085//
3086//ArchSpec
3087//Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
3088//{
3089// return Host::GetArchSpecForExistingProcess (pid);
3090//}
3091//
3092//ArchSpec
3093//Process::GetArchSpecForExistingProcess (const char *process_name)
3094//{
3095// return Host::GetArchSpecForExistingProcess (process_name);
3096//}
3097//
Caroline Tice861efb32010-11-16 05:07:41 +00003098void
3099Process::AppendSTDOUT (const char * s, size_t len)
3100{
Greg Clayton20d338f2010-11-18 05:57:03 +00003101 Mutex::Locker locker (m_stdio_communication_mutex);
Caroline Tice861efb32010-11-16 05:07:41 +00003102 m_stdout_data.append (s, len);
3103
Greg Claytonb3781332010-12-05 19:16:56 +00003104 BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (GetTarget().GetProcessSP(), GetState()));
Caroline Tice861efb32010-11-16 05:07:41 +00003105}
3106
3107void
3108Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
3109{
3110 Process *process = (Process *) baton;
3111 process->AppendSTDOUT (static_cast<const char *>(src), src_len);
3112}
3113
3114size_t
3115Process::ProcessInputReaderCallback (void *baton,
3116 InputReader &reader,
3117 lldb::InputReaderAction notification,
3118 const char *bytes,
3119 size_t bytes_len)
3120{
3121 Process *process = (Process *) baton;
3122
3123 switch (notification)
3124 {
3125 case eInputReaderActivate:
3126 break;
3127
3128 case eInputReaderDeactivate:
3129 break;
3130
3131 case eInputReaderReactivate:
3132 break;
3133
Caroline Tice4a348082011-05-02 20:41:46 +00003134 case eInputReaderAsynchronousOutputWritten:
3135 break;
3136
Caroline Tice861efb32010-11-16 05:07:41 +00003137 case eInputReaderGotToken:
3138 {
3139 Error error;
3140 process->PutSTDIN (bytes, bytes_len, error);
3141 }
3142 break;
3143
Caroline Ticec4f55fe2010-11-19 20:47:54 +00003144 case eInputReaderInterrupt:
3145 process->Halt ();
3146 break;
3147
3148 case eInputReaderEndOfFile:
3149 process->AppendSTDOUT ("^D", 2);
3150 break;
3151
Caroline Tice861efb32010-11-16 05:07:41 +00003152 case eInputReaderDone:
3153 break;
3154
3155 }
3156
3157 return bytes_len;
3158}
3159
3160void
3161Process::ResetProcessInputReader ()
3162{
3163 m_process_input_reader.reset();
3164}
3165
3166void
3167Process::SetUpProcessInputReader (int file_descriptor)
3168{
3169 // First set up the Read Thread for reading/handling process I/O
3170
3171 std::auto_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (file_descriptor, true));
3172
3173 if (conn_ap.get())
3174 {
3175 m_stdio_communication.SetConnection (conn_ap.release());
3176 if (m_stdio_communication.IsConnected())
3177 {
3178 m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
3179 m_stdio_communication.StartReadThread();
3180
3181 // Now read thread is set up, set up input reader.
3182
3183 if (!m_process_input_reader.get())
3184 {
3185 m_process_input_reader.reset (new InputReader(m_target.GetDebugger()));
3186 Error err (m_process_input_reader->Initialize (Process::ProcessInputReaderCallback,
3187 this,
3188 eInputReaderGranularityByte,
3189 NULL,
3190 NULL,
3191 false));
3192
3193 if (err.Fail())
3194 m_process_input_reader.reset();
3195 }
3196 }
3197 }
3198}
3199
3200void
3201Process::PushProcessInputReader ()
3202{
3203 if (m_process_input_reader && !m_process_input_reader->IsActive())
3204 m_target.GetDebugger().PushInputReader (m_process_input_reader);
3205}
3206
3207void
3208Process::PopProcessInputReader ()
3209{
3210 if (m_process_input_reader && m_process_input_reader->IsActive())
3211 m_target.GetDebugger().PopInputReader (m_process_input_reader);
3212}
3213
Greg Claytond284b662011-02-18 01:44:25 +00003214// The process needs to know about installed plug-ins
Greg Clayton990de7b2010-11-18 23:32:35 +00003215void
Caroline Tice2a456812011-03-10 22:14:10 +00003216Process::SettingsInitialize ()
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003217{
Greg Claytonb3448432011-03-24 21:19:54 +00003218 static std::vector<OptionEnumValueElement> g_plugins;
Greg Claytond284b662011-02-18 01:44:25 +00003219
3220 int i=0;
3221 const char *name;
3222 OptionEnumValueElement option_enum;
3223 while ((name = PluginManager::GetProcessPluginNameAtIndex (i)) != NULL)
3224 {
3225 if (name)
3226 {
3227 option_enum.value = i;
3228 option_enum.string_value = name;
3229 option_enum.usage = PluginManager::GetProcessPluginDescriptionAtIndex (i);
3230 g_plugins.push_back (option_enum);
3231 }
3232 ++i;
3233 }
3234 option_enum.value = 0;
3235 option_enum.string_value = NULL;
3236 option_enum.usage = NULL;
3237 g_plugins.push_back (option_enum);
3238
3239 for (i=0; (name = SettingsController::instance_settings_table[i].var_name); ++i)
3240 {
3241 if (::strcmp (name, "plugin") == 0)
3242 {
3243 SettingsController::instance_settings_table[i].enum_values = &g_plugins[0];
3244 break;
3245 }
3246 }
Greg Clayton990de7b2010-11-18 23:32:35 +00003247 UserSettingsControllerSP &usc = GetSettingsController();
3248 usc.reset (new SettingsController);
3249 UserSettingsController::InitializeSettingsController (usc,
3250 SettingsController::global_settings_table,
3251 SettingsController::instance_settings_table);
Caroline Tice2a456812011-03-10 22:14:10 +00003252
3253 // Now call SettingsInitialize() for each 'child' of Process settings
3254 Thread::SettingsInitialize ();
Greg Clayton990de7b2010-11-18 23:32:35 +00003255}
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003256
Greg Clayton990de7b2010-11-18 23:32:35 +00003257void
Caroline Tice2a456812011-03-10 22:14:10 +00003258Process::SettingsTerminate ()
Greg Claytond284b662011-02-18 01:44:25 +00003259{
Caroline Tice2a456812011-03-10 22:14:10 +00003260 // Must call SettingsTerminate() on each 'child' of Process settings before terminating Process settings.
3261
3262 Thread::SettingsTerminate ();
3263
3264 // Now terminate Process Settings.
3265
Greg Clayton990de7b2010-11-18 23:32:35 +00003266 UserSettingsControllerSP &usc = GetSettingsController();
3267 UserSettingsController::FinalizeSettingsController (usc);
3268 usc.reset();
3269}
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003270
Greg Clayton990de7b2010-11-18 23:32:35 +00003271UserSettingsControllerSP &
3272Process::GetSettingsController ()
3273{
3274 static UserSettingsControllerSP g_settings_controller;
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003275 return g_settings_controller;
3276}
3277
Caroline Tice1ebef442010-09-27 00:30:10 +00003278void
3279Process::UpdateInstanceName ()
3280{
3281 ModuleSP module_sp = GetTarget().GetExecutableModule();
3282 if (module_sp)
3283 {
3284 StreamString sstr;
3285 sstr.Printf ("%s", module_sp->GetFileSpec().GetFilename().AsCString());
3286
Greg Claytonc0c1b0c2010-11-19 03:46:01 +00003287 GetSettingsController()->RenameInstanceSettings (GetInstanceName().AsCString(),
Greg Claytonb72d0f02011-04-12 05:54:46 +00003288 sstr.GetData());
Caroline Tice1ebef442010-09-27 00:30:10 +00003289 }
3290}
3291
Greg Clayton427f2902010-12-14 02:59:59 +00003292ExecutionResults
Jim Ingham360f53f2010-11-30 02:22:11 +00003293Process::RunThreadPlan (ExecutionContext &exe_ctx,
3294 lldb::ThreadPlanSP &thread_plan_sp,
3295 bool stop_others,
3296 bool try_all_threads,
3297 bool discard_on_error,
3298 uint32_t single_thread_timeout_usec,
3299 Stream &errors)
3300{
3301 ExecutionResults return_value = eExecutionSetupError;
3302
Jim Ingham15dcb7c2011-01-20 02:03:18 +00003303 if (thread_plan_sp.get() == NULL)
3304 {
3305 errors.Printf("RunThreadPlan called with empty thread plan.");
Greg Claytonb3448432011-03-24 21:19:54 +00003306 return eExecutionSetupError;
Jim Ingham15dcb7c2011-01-20 02:03:18 +00003307 }
3308
Jim Ingham5ab7fba2011-05-17 22:24:54 +00003309 // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes.
3310 // For that to be true the plan can't be private - since private plans suppress themselves in the
3311 // GetCompletedPlan call.
3312
3313 bool orig_plan_private = thread_plan_sp->GetPrivate();
3314 thread_plan_sp->SetPrivate(false);
3315
Jim Inghamac959662011-01-24 06:34:17 +00003316 if (m_private_state.GetValue() != eStateStopped)
3317 {
3318 errors.Printf ("RunThreadPlan called while the private state was not stopped.");
Greg Claytonb3448432011-03-24 21:19:54 +00003319 return eExecutionSetupError;
Jim Inghamac959662011-01-24 06:34:17 +00003320 }
3321
Jim Ingham360f53f2010-11-30 02:22:11 +00003322 // Save this value for restoration of the execution context after we run
Greg Clayton265ab332011-05-19 18:17:41 +00003323 const uint32_t thread_idx_id = exe_ctx.thread->GetIndexID();
Jim Ingham360f53f2010-11-30 02:22:11 +00003324
3325 // N.B. Running the target may unset the currently selected thread and frame. We don't want to do that either,
3326 // so we should arrange to reset them as well.
3327
3328 lldb::ThreadSP selected_thread_sp = exe_ctx.process->GetThreadList().GetSelectedThread();
3329 lldb::StackFrameSP selected_frame_sp;
3330
3331 uint32_t selected_tid;
3332 if (selected_thread_sp != NULL)
3333 {
3334 selected_tid = selected_thread_sp->GetIndexID();
3335 selected_frame_sp = selected_thread_sp->GetSelectedFrame();
3336 }
3337 else
3338 {
3339 selected_tid = LLDB_INVALID_THREAD_ID;
3340 }
3341
3342 exe_ctx.thread->QueueThreadPlan(thread_plan_sp, true);
3343
Jim Ingham6ae318c2011-01-23 21:14:08 +00003344 Listener listener("lldb.process.listener.run-thread-plan");
Jim Inghamf9f40c22011-02-08 05:20:59 +00003345
3346 // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get
3347 // restored on exit to the function.
3348
3349 ProcessEventHijacker run_thread_plan_hijacker (*this, &listener);
Jim Inghamac959662011-01-24 06:34:17 +00003350
Jim Ingham6ae318c2011-01-23 21:14:08 +00003351 lldb::LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham15dcb7c2011-01-20 02:03:18 +00003352 if (log)
3353 {
3354 StreamString s;
3355 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
Jim Inghamf9f40c22011-02-08 05:20:59 +00003356 log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4x to run thread plan \"%s\".",
3357 exe_ctx.thread->GetIndexID(),
3358 exe_ctx.thread->GetID(),
3359 s.GetData());
Jim Ingham15dcb7c2011-01-20 02:03:18 +00003360 }
3361
Jim Inghamf9f40c22011-02-08 05:20:59 +00003362 bool got_event;
3363 lldb::EventSP event_sp;
3364 lldb::StateType stop_state = lldb::eStateInvalid;
Jim Ingham360f53f2010-11-30 02:22:11 +00003365
3366 TimeValue* timeout_ptr = NULL;
3367 TimeValue real_timeout;
3368
Jim Inghamf9f40c22011-02-08 05:20:59 +00003369 bool first_timeout = true;
3370 bool do_resume = true;
Jim Ingham360f53f2010-11-30 02:22:11 +00003371
Jim Ingham360f53f2010-11-30 02:22:11 +00003372 while (1)
3373 {
Jim Inghamf9f40c22011-02-08 05:20:59 +00003374 // We usually want to resume the process if we get to the top of the loop.
3375 // The only exception is if we get two running events with no intervening
3376 // stop, which can happen, we will just wait for then next stop event.
Jim Ingham360f53f2010-11-30 02:22:11 +00003377
Jim Inghamf9f40c22011-02-08 05:20:59 +00003378 if (do_resume)
Jim Ingham360f53f2010-11-30 02:22:11 +00003379 {
Jim Inghamf9f40c22011-02-08 05:20:59 +00003380 // Do the initial resume and wait for the running event before going further.
3381
3382 Error resume_error = exe_ctx.process->Resume ();
3383 if (!resume_error.Success())
3384 {
3385 errors.Printf("Error resuming inferior: \"%s\".\n", resume_error.AsCString());
Greg Claytonb3448432011-03-24 21:19:54 +00003386 return_value = eExecutionSetupError;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003387 break;
3388 }
3389
3390 real_timeout = TimeValue::Now();
3391 real_timeout.OffsetWithMicroSeconds(500000);
3392 timeout_ptr = &real_timeout;
3393
3394 got_event = listener.WaitForEvent(NULL, event_sp);
3395 if (!got_event)
3396 {
3397 if (log)
3398 log->Printf("Didn't get any event after initial resume, exiting.");
3399
3400 errors.Printf("Didn't get any event after initial resume, exiting.");
Greg Claytonb3448432011-03-24 21:19:54 +00003401 return_value = eExecutionSetupError;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003402 break;
3403 }
3404
3405 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3406 if (stop_state != eStateRunning)
3407 {
3408 if (log)
3409 log->Printf("Didn't get running event after initial resume, got %s instead.", StateAsCString(stop_state));
3410
3411 errors.Printf("Didn't get running event after initial resume, got %s instead.", StateAsCString(stop_state));
Greg Claytonb3448432011-03-24 21:19:54 +00003412 return_value = eExecutionSetupError;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003413 break;
3414 }
3415
3416 if (log)
3417 log->Printf ("Resuming succeeded.");
3418 // We need to call the function synchronously, so spin waiting for it to return.
3419 // If we get interrupted while executing, we're going to lose our context, and
3420 // won't be able to gather the result at this point.
3421 // We set the timeout AFTER the resume, since the resume takes some time and we
3422 // don't want to charge that to the timeout.
3423
3424 if (single_thread_timeout_usec != 0)
3425 {
3426 real_timeout = TimeValue::Now();
3427 if (first_timeout)
3428 real_timeout.OffsetWithMicroSeconds(single_thread_timeout_usec);
3429 else
3430 real_timeout.OffsetWithSeconds(10);
3431
3432 timeout_ptr = &real_timeout;
3433 }
3434 }
3435 else
3436 {
3437 if (log)
3438 log->Printf ("Handled an extra running event.");
3439 do_resume = true;
3440 }
3441
3442 // Now wait for the process to stop again:
3443 stop_state = lldb::eStateInvalid;
3444 event_sp.reset();
3445 got_event = listener.WaitForEvent (timeout_ptr, event_sp);
3446
3447 if (got_event)
3448 {
3449 if (event_sp.get())
3450 {
3451 bool keep_going = false;
3452 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3453 if (log)
3454 log->Printf("In while loop, got event: %s.", StateAsCString(stop_state));
3455
3456 switch (stop_state)
3457 {
3458 case lldb::eStateStopped:
Jim Ingham2370a972011-05-17 01:10:11 +00003459 {
Greg Clayton43994462011-06-03 22:12:42 +00003460 // Yay, we're done. Now make sure that our thread plan actually completed.
3461 ThreadSP thread_sp = exe_ctx.process->GetThreadList().FindThreadByIndexID (thread_idx_id);
3462 if (!thread_sp)
Jim Ingham2370a972011-05-17 01:10:11 +00003463 {
Greg Clayton43994462011-06-03 22:12:42 +00003464 // Ooh, our thread has vanished. Unlikely that this was successful execution...
Jim Ingham2370a972011-05-17 01:10:11 +00003465 if (log)
Greg Clayton43994462011-06-03 22:12:42 +00003466 log->Printf ("Execution completed but our thread (index-id=%u) has vanished.", thread_idx_id);
3467 return_value = eExecutionInterrupted;
Jim Ingham2370a972011-05-17 01:10:11 +00003468 }
3469 else
3470 {
Greg Clayton43994462011-06-03 22:12:42 +00003471 StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
3472 StopReason stop_reason = eStopReasonInvalid;
3473 if (stop_info_sp)
3474 stop_reason = stop_info_sp->GetStopReason();
3475 if (stop_reason == eStopReasonPlanComplete)
3476 {
3477 if (log)
3478 log->Printf ("Execution completed successfully.");
3479 // Now mark this plan as private so it doesn't get reported as the stop reason
3480 // after this point.
3481 if (thread_plan_sp)
3482 thread_plan_sp->SetPrivate (orig_plan_private);
3483 return_value = eExecutionCompleted;
3484 }
3485 else
3486 {
3487 if (log)
3488 log->Printf ("Thread plan didn't successfully complete.");
3489
3490 return_value = eExecutionInterrupted;
3491 }
Jim Ingham2370a972011-05-17 01:10:11 +00003492 }
Greg Clayton43994462011-06-03 22:12:42 +00003493 }
3494 break;
3495
Jim Inghamf9f40c22011-02-08 05:20:59 +00003496 case lldb::eStateCrashed:
3497 if (log)
3498 log->Printf ("Execution crashed.");
Greg Claytonb3448432011-03-24 21:19:54 +00003499 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003500 break;
Greg Clayton43994462011-06-03 22:12:42 +00003501
Jim Inghamf9f40c22011-02-08 05:20:59 +00003502 case lldb::eStateRunning:
3503 do_resume = false;
3504 keep_going = true;
3505 break;
Greg Clayton43994462011-06-03 22:12:42 +00003506
Jim Inghamf9f40c22011-02-08 05:20:59 +00003507 default:
3508 if (log)
3509 log->Printf("Execution stopped with unexpected state: %s.", StateAsCString(stop_state));
Jim Ingham2370a972011-05-17 01:10:11 +00003510
3511 errors.Printf ("Execution stopped with unexpected state.");
Greg Claytonb3448432011-03-24 21:19:54 +00003512 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003513 break;
3514 }
3515 if (keep_going)
3516 continue;
3517 else
3518 break;
3519 }
3520 else
3521 {
3522 if (log)
3523 log->Printf ("got_event was true, but the event pointer was null. How odd...");
Greg Claytonb3448432011-03-24 21:19:54 +00003524 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003525 break;
3526 }
3527 }
3528 else
3529 {
3530 // If we didn't get an event that means we've timed out...
3531 // We will interrupt the process here. Depending on what we were asked to do we will
3532 // either exit, or try with all threads running for the same timeout.
Jim Ingham360f53f2010-11-30 02:22:11 +00003533 // Not really sure what to do if Halt fails here...
Jim Inghamf9f40c22011-02-08 05:20:59 +00003534
Stephen Wilsonc2b98252011-01-12 04:20:03 +00003535 if (log) {
Jim Ingham360f53f2010-11-30 02:22:11 +00003536 if (try_all_threads)
Jim Inghamf9f40c22011-02-08 05:20:59 +00003537 {
3538 if (first_timeout)
3539 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %d timed out, "
3540 "trying with all threads enabled.",
3541 single_thread_timeout_usec);
3542 else
3543 log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled "
3544 "and timeout: %d timed out.",
3545 single_thread_timeout_usec);
3546 }
Jim Ingham360f53f2010-11-30 02:22:11 +00003547 else
Jim Inghamf9f40c22011-02-08 05:20:59 +00003548 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %d timed out, "
3549 "halt and abandoning execution.",
Jim Ingham360f53f2010-11-30 02:22:11 +00003550 single_thread_timeout_usec);
Stephen Wilsonc2b98252011-01-12 04:20:03 +00003551 }
Jim Ingham360f53f2010-11-30 02:22:11 +00003552
Jim Inghamc556b462011-01-22 01:30:53 +00003553 Error halt_error = exe_ctx.process->Halt();
Jim Inghamc556b462011-01-22 01:30:53 +00003554 if (halt_error.Success())
Jim Ingham360f53f2010-11-30 02:22:11 +00003555 {
Jim Ingham360f53f2010-11-30 02:22:11 +00003556 if (log)
Greg Clayton68ca8232011-01-25 02:58:48 +00003557 log->Printf ("Process::RunThreadPlan(): Halt succeeded.");
Jim Ingham360f53f2010-11-30 02:22:11 +00003558
Jim Inghamf9f40c22011-02-08 05:20:59 +00003559 // If halt succeeds, it always produces a stopped event. Wait for that:
3560
3561 real_timeout = TimeValue::Now();
3562 real_timeout.OffsetWithMicroSeconds(500000);
3563
3564 got_event = listener.WaitForEvent(&real_timeout, event_sp);
Jim Ingham360f53f2010-11-30 02:22:11 +00003565
3566 if (got_event)
3567 {
3568 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3569 if (log)
3570 {
Greg Clayton68ca8232011-01-25 02:58:48 +00003571 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state));
Jim Inghamf9f40c22011-02-08 05:20:59 +00003572 if (stop_state == lldb::eStateStopped
3573 && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
Jim Ingham360f53f2010-11-30 02:22:11 +00003574 log->Printf (" Event was the Halt interruption event.");
3575 }
3576
Jim Inghamf9f40c22011-02-08 05:20:59 +00003577 if (stop_state == lldb::eStateStopped)
Jim Ingham360f53f2010-11-30 02:22:11 +00003578 {
Jim Inghamf9f40c22011-02-08 05:20:59 +00003579 // Between the time we initiated the Halt and the time we delivered it, the process could have
3580 // already finished its job. Check that here:
Jim Ingham360f53f2010-11-30 02:22:11 +00003581
Jim Inghamf9f40c22011-02-08 05:20:59 +00003582 if (exe_ctx.thread->IsThreadPlanDone (thread_plan_sp.get()))
3583 {
3584 if (log)
3585 log->Printf ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
3586 "Exiting wait loop.");
Greg Claytonb3448432011-03-24 21:19:54 +00003587 return_value = eExecutionCompleted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003588 break;
3589 }
Jim Ingham360f53f2010-11-30 02:22:11 +00003590
Jim Inghamf9f40c22011-02-08 05:20:59 +00003591 if (!try_all_threads)
3592 {
3593 if (log)
3594 log->Printf ("try_all_threads was false, we stopped so now we're quitting.");
Greg Claytonb3448432011-03-24 21:19:54 +00003595 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003596 break;
3597 }
3598
3599 if (first_timeout)
3600 {
3601 // Set all the other threads to run, and return to the top of the loop, which will continue;
3602 first_timeout = false;
3603 thread_plan_sp->SetStopOthers (false);
3604 if (log)
3605 log->Printf ("Process::RunThreadPlan(): About to resume.");
3606
3607 continue;
3608 }
3609 else
3610 {
3611 // Running all threads failed, so return Interrupted.
3612 if (log)
3613 log->Printf("Process::RunThreadPlan(): running all threads timed out.");
Greg Claytonb3448432011-03-24 21:19:54 +00003614 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003615 break;
3616 }
Jim Ingham360f53f2010-11-30 02:22:11 +00003617 }
Jim Inghamf9f40c22011-02-08 05:20:59 +00003618 }
3619 else
3620 { if (log)
3621 log->Printf("Process::RunThreadPlan(): halt said it succeeded, but I got no event. "
3622 "I'm getting out of here passing Interrupted.");
Greg Claytonb3448432011-03-24 21:19:54 +00003623 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003624 break;
Jim Ingham360f53f2010-11-30 02:22:11 +00003625 }
3626 }
Jim Inghamc556b462011-01-22 01:30:53 +00003627 else
3628 {
Jim Inghamf9f40c22011-02-08 05:20:59 +00003629 // This branch is to work around some problems with gdb-remote's Halt. It is a little racy, and can return
3630 // an error from halt, but if you wait a bit you'll get a stopped event anyway.
Jim Inghamc556b462011-01-22 01:30:53 +00003631 if (log)
Jim Inghamf9f40c22011-02-08 05:20:59 +00003632 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.",
3633 halt_error.AsCString());
3634 real_timeout = TimeValue::Now();
3635 real_timeout.OffsetWithMicroSeconds(500000);
3636 timeout_ptr = &real_timeout;
3637 got_event = listener.WaitForEvent(&real_timeout, event_sp);
3638 if (!got_event || event_sp.get() == NULL)
Jim Ingham6ae318c2011-01-23 21:14:08 +00003639 {
Jim Inghamf9f40c22011-02-08 05:20:59 +00003640 // This is not going anywhere, bag out.
3641 if (log)
3642 log->Printf ("Process::RunThreadPlan(): halt failed: and waiting for the stopped event failed.");
Greg Claytonb3448432011-03-24 21:19:54 +00003643 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003644 break;
Jim Ingham6ae318c2011-01-23 21:14:08 +00003645 }
Jim Inghamf9f40c22011-02-08 05:20:59 +00003646 else
3647 {
3648 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3649 if (log)
3650 log->Printf ("Process::RunThreadPlan(): halt failed: but then I got a stopped event. Whatever...");
3651 if (stop_state == lldb::eStateStopped)
3652 {
3653 // Between the time we initiated the Halt and the time we delivered it, the process could have
3654 // already finished its job. Check that here:
3655
3656 if (exe_ctx.thread->IsThreadPlanDone (thread_plan_sp.get()))
3657 {
3658 if (log)
3659 log->Printf ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
3660 "Exiting wait loop.");
Greg Claytonb3448432011-03-24 21:19:54 +00003661 return_value = eExecutionCompleted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003662 break;
3663 }
3664
3665 if (first_timeout)
3666 {
3667 // Set all the other threads to run, and return to the top of the loop, which will continue;
3668 first_timeout = false;
3669 thread_plan_sp->SetStopOthers (false);
3670 if (log)
3671 log->Printf ("Process::RunThreadPlan(): About to resume.");
3672
3673 continue;
3674 }
3675 else
3676 {
3677 // Running all threads failed, so return Interrupted.
3678 if (log)
3679 log->Printf("Process::RunThreadPlan(): running all threads timed out.");
Greg Claytonb3448432011-03-24 21:19:54 +00003680 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003681 break;
3682 }
3683 }
3684 else
3685 {
3686 log->Printf ("Process::RunThreadPlan(): halt failed, I waited and didn't get"
3687 " a stopped event, instead got %s.", StateAsCString(stop_state));
Greg Claytonb3448432011-03-24 21:19:54 +00003688 return_value = eExecutionInterrupted;
Jim Inghamf9f40c22011-02-08 05:20:59 +00003689 break;
3690 }
3691 }
Jim Inghamc556b462011-01-22 01:30:53 +00003692 }
3693
Jim Ingham360f53f2010-11-30 02:22:11 +00003694 }
3695
Jim Inghamf9f40c22011-02-08 05:20:59 +00003696 } // END WAIT LOOP
3697
3698 // Now do some processing on the results of the run:
3699 if (return_value == eExecutionInterrupted)
3700 {
Jim Ingham360f53f2010-11-30 02:22:11 +00003701 if (log)
Jim Inghamf9f40c22011-02-08 05:20:59 +00003702 {
3703 StreamString s;
3704 if (event_sp)
3705 event_sp->Dump (&s);
3706 else
3707 {
3708 log->Printf ("Process::RunThreadPlan(): Stop event that interrupted us is NULL.");
3709 }
3710
3711 StreamString ts;
3712
3713 const char *event_explanation;
3714
3715 do
3716 {
3717 const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get());
3718
3719 if (!event_data)
3720 {
3721 event_explanation = "<no event data>";
3722 break;
3723 }
3724
3725 Process *process = event_data->GetProcessSP().get();
3726
3727 if (!process)
3728 {
3729 event_explanation = "<no process>";
3730 break;
3731 }
3732
3733 ThreadList &thread_list = process->GetThreadList();
3734
3735 uint32_t num_threads = thread_list.GetSize();
3736 uint32_t thread_index;
3737
3738 ts.Printf("<%u threads> ", num_threads);
3739
3740 for (thread_index = 0;
3741 thread_index < num_threads;
3742 ++thread_index)
3743 {
3744 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
3745
3746 if (!thread)
3747 {
3748 ts.Printf("<?> ");
3749 continue;
3750 }
3751
3752 ts.Printf("<0x%4.4x ", thread->GetID());
3753 RegisterContext *register_context = thread->GetRegisterContext().get();
3754
3755 if (register_context)
3756 ts.Printf("[ip 0x%llx] ", register_context->GetPC());
3757 else
3758 ts.Printf("[ip unknown] ");
3759
3760 lldb::StopInfoSP stop_info_sp = thread->GetStopInfo();
3761 if (stop_info_sp)
3762 {
3763 const char *stop_desc = stop_info_sp->GetDescription();
3764 if (stop_desc)
3765 ts.PutCString (stop_desc);
3766 }
3767 ts.Printf(">");
3768 }
3769
3770 event_explanation = ts.GetData();
3771 } while (0);
3772
3773 if (log)
3774 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation);
3775
3776 if (discard_on_error && thread_plan_sp)
3777 {
3778 exe_ctx.thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
3779 }
3780 }
3781 }
3782 else if (return_value == eExecutionSetupError)
3783 {
3784 if (log)
3785 log->Printf("Process::RunThreadPlan(): execution set up error.");
3786
3787 if (discard_on_error && thread_plan_sp)
3788 {
3789 exe_ctx.thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
3790 }
3791 }
3792 else
3793 {
Jim Ingham360f53f2010-11-30 02:22:11 +00003794 if (exe_ctx.thread->IsThreadPlanDone (thread_plan_sp.get()))
3795 {
Greg Clayton68ca8232011-01-25 02:58:48 +00003796 if (log)
3797 log->Printf("Process::RunThreadPlan(): thread plan is done");
Greg Claytonb3448432011-03-24 21:19:54 +00003798 return_value = eExecutionCompleted;
Jim Ingham360f53f2010-11-30 02:22:11 +00003799 }
3800 else if (exe_ctx.thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
3801 {
Greg Clayton68ca8232011-01-25 02:58:48 +00003802 if (log)
3803 log->Printf("Process::RunThreadPlan(): thread plan was discarded");
Greg Claytonb3448432011-03-24 21:19:54 +00003804 return_value = eExecutionDiscarded;
Jim Ingham360f53f2010-11-30 02:22:11 +00003805 }
3806 else
3807 {
3808 if (log)
Jim Inghamf9f40c22011-02-08 05:20:59 +00003809 log->Printf("Process::RunThreadPlan(): thread plan stopped in mid course");
Jim Ingham360f53f2010-11-30 02:22:11 +00003810 if (discard_on_error && thread_plan_sp)
3811 {
Jim Inghamf9f40c22011-02-08 05:20:59 +00003812 if (log)
3813 log->Printf("Process::RunThreadPlan(): discarding thread plan 'cause discard_on_error is set.");
Jim Ingham360f53f2010-11-30 02:22:11 +00003814 exe_ctx.thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
3815 }
Jim Ingham360f53f2010-11-30 02:22:11 +00003816 }
3817 }
Jim Inghamf9f40c22011-02-08 05:20:59 +00003818
Jim Ingham360f53f2010-11-30 02:22:11 +00003819 // Thread we ran the function in may have gone away because we ran the target
3820 // Check that it's still there.
Greg Clayton265ab332011-05-19 18:17:41 +00003821 exe_ctx.thread = exe_ctx.process->GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
Jim Ingham360f53f2010-11-30 02:22:11 +00003822 if (exe_ctx.thread)
3823 exe_ctx.frame = exe_ctx.thread->GetStackFrameAtIndex(0).get();
3824
3825 // Also restore the current process'es selected frame & thread, since this function calling may
3826 // be done behind the user's back.
3827
3828 if (selected_tid != LLDB_INVALID_THREAD_ID)
3829 {
3830 if (exe_ctx.process->GetThreadList().SetSelectedThreadByIndexID (selected_tid))
3831 {
3832 // We were able to restore the selected thread, now restore the frame:
3833 exe_ctx.process->GetThreadList().GetSelectedThread()->SetSelectedFrame(selected_frame_sp.get());
3834 }
3835 }
3836
3837 return return_value;
3838}
3839
3840const char *
3841Process::ExecutionResultAsCString (ExecutionResults result)
3842{
3843 const char *result_name;
3844
3845 switch (result)
3846 {
Greg Claytonb3448432011-03-24 21:19:54 +00003847 case eExecutionCompleted:
Jim Ingham360f53f2010-11-30 02:22:11 +00003848 result_name = "eExecutionCompleted";
3849 break;
Greg Claytonb3448432011-03-24 21:19:54 +00003850 case eExecutionDiscarded:
Jim Ingham360f53f2010-11-30 02:22:11 +00003851 result_name = "eExecutionDiscarded";
3852 break;
Greg Claytonb3448432011-03-24 21:19:54 +00003853 case eExecutionInterrupted:
Jim Ingham360f53f2010-11-30 02:22:11 +00003854 result_name = "eExecutionInterrupted";
3855 break;
Greg Claytonb3448432011-03-24 21:19:54 +00003856 case eExecutionSetupError:
Jim Ingham360f53f2010-11-30 02:22:11 +00003857 result_name = "eExecutionSetupError";
3858 break;
Greg Claytonb3448432011-03-24 21:19:54 +00003859 case eExecutionTimedOut:
Jim Ingham360f53f2010-11-30 02:22:11 +00003860 result_name = "eExecutionTimedOut";
3861 break;
3862 }
3863 return result_name;
3864}
3865
Greg Claytonabe0fed2011-04-18 08:33:37 +00003866void
3867Process::GetStatus (Stream &strm)
3868{
3869 const StateType state = GetState();
3870 if (StateIsStoppedState(state))
3871 {
3872 if (state == eStateExited)
3873 {
3874 int exit_status = GetExitStatus();
3875 const char *exit_description = GetExitDescription();
3876 strm.Printf ("Process %d exited with status = %i (0x%8.8x) %s\n",
3877 GetID(),
3878 exit_status,
3879 exit_status,
3880 exit_description ? exit_description : "");
3881 }
3882 else
3883 {
3884 if (state == eStateConnected)
3885 strm.Printf ("Connected to remote target.\n");
3886 else
3887 strm.Printf ("Process %d %s\n", GetID(), StateAsCString (state));
3888 }
3889 }
3890 else
3891 {
3892 strm.Printf ("Process %d is running.\n", GetID());
3893 }
3894}
3895
3896size_t
3897Process::GetThreadStatus (Stream &strm,
3898 bool only_threads_with_stop_reason,
3899 uint32_t start_frame,
3900 uint32_t num_frames,
3901 uint32_t num_frames_with_source)
3902{
3903 size_t num_thread_infos_dumped = 0;
3904
3905 const size_t num_threads = GetThreadList().GetSize();
3906 for (uint32_t i = 0; i < num_threads; i++)
3907 {
3908 Thread *thread = GetThreadList().GetThreadAtIndex(i).get();
3909 if (thread)
3910 {
3911 if (only_threads_with_stop_reason)
3912 {
3913 if (thread->GetStopInfo().get() == NULL)
3914 continue;
3915 }
3916 thread->GetStatus (strm,
3917 start_frame,
3918 num_frames,
3919 num_frames_with_source);
3920 ++num_thread_infos_dumped;
3921 }
3922 }
3923 return num_thread_infos_dumped;
3924}
3925
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003926//--------------------------------------------------------------
Greg Claytond0a5a232010-09-19 02:33:57 +00003927// class Process::SettingsController
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003928//--------------------------------------------------------------
3929
Greg Claytond0a5a232010-09-19 02:33:57 +00003930Process::SettingsController::SettingsController () :
Caroline Tice5bc8c972010-09-20 20:44:43 +00003931 UserSettingsController ("process", Target::GetSettingsController())
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003932{
Greg Clayton638351a2010-12-04 00:10:17 +00003933 m_default_settings.reset (new ProcessInstanceSettings (*this,
3934 false,
Caroline Tice004afcb2010-09-08 17:48:55 +00003935 InstanceSettings::GetDefaultName().AsCString()));
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003936}
3937
Greg Claytond0a5a232010-09-19 02:33:57 +00003938Process::SettingsController::~SettingsController ()
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003939{
3940}
3941
3942lldb::InstanceSettingsSP
Greg Claytond0a5a232010-09-19 02:33:57 +00003943Process::SettingsController::CreateInstanceSettings (const char *instance_name)
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003944{
Greg Claytonc0c1b0c2010-11-19 03:46:01 +00003945 ProcessInstanceSettings *new_settings = new ProcessInstanceSettings (*GetSettingsController(),
3946 false,
3947 instance_name);
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003948 lldb::InstanceSettingsSP new_settings_sp (new_settings);
3949 return new_settings_sp;
3950}
3951
3952//--------------------------------------------------------------
3953// class ProcessInstanceSettings
3954//--------------------------------------------------------------
3955
Greg Clayton638351a2010-12-04 00:10:17 +00003956ProcessInstanceSettings::ProcessInstanceSettings
3957(
3958 UserSettingsController &owner,
3959 bool live_instance,
3960 const char *name
3961) :
3962 InstanceSettings (owner, name ? name : InstanceSettings::InvalidName().AsCString(), live_instance),
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003963 m_run_args (),
3964 m_env_vars (),
3965 m_input_path (),
3966 m_output_path (),
3967 m_error_path (),
Caroline Ticebd666012010-12-03 18:46:09 +00003968 m_disable_aslr (true),
Greg Clayton638351a2010-12-04 00:10:17 +00003969 m_disable_stdio (false),
3970 m_inherit_host_env (true),
3971 m_got_host_env (false)
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003972{
Caroline Tice396704b2010-09-09 18:26:37 +00003973 // CopyInstanceSettings is a pure virtual function in InstanceSettings; it therefore cannot be called
3974 // until the vtables for ProcessInstanceSettings are properly set up, i.e. AFTER all the initializers.
3975 // For this reason it has to be called here, rather than in the initializer or in the parent constructor.
Caroline Tice75b11a32010-09-16 19:05:55 +00003976 // This is true for CreateInstanceName() too.
3977
3978 if (GetInstanceName () == InstanceSettings::InvalidName())
3979 {
3980 ChangeInstanceName (std::string (CreateInstanceName().AsCString()));
3981 m_owner.RegisterInstanceSettings (this);
3982 }
Caroline Tice396704b2010-09-09 18:26:37 +00003983
3984 if (live_instance)
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003985 {
3986 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name);
3987 CopyInstanceSettings (pending_settings,false);
Caroline Tice396704b2010-09-09 18:26:37 +00003988 //m_owner.RemovePendingSettings (m_instance_name);
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003989 }
3990}
3991
3992ProcessInstanceSettings::ProcessInstanceSettings (const ProcessInstanceSettings &rhs) :
Greg Claytonc0c1b0c2010-11-19 03:46:01 +00003993 InstanceSettings (*Process::GetSettingsController(), CreateInstanceName().AsCString()),
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00003994 m_run_args (rhs.m_run_args),
3995 m_env_vars (rhs.m_env_vars),
3996 m_input_path (rhs.m_input_path),
3997 m_output_path (rhs.m_output_path),
3998 m_error_path (rhs.m_error_path),
Caroline Ticebd666012010-12-03 18:46:09 +00003999 m_disable_aslr (rhs.m_disable_aslr),
4000 m_disable_stdio (rhs.m_disable_stdio)
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004001{
4002 if (m_instance_name != InstanceSettings::GetDefaultName())
4003 {
4004 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name);
4005 CopyInstanceSettings (pending_settings,false);
4006 m_owner.RemovePendingSettings (m_instance_name);
4007 }
4008}
4009
4010ProcessInstanceSettings::~ProcessInstanceSettings ()
4011{
4012}
4013
4014ProcessInstanceSettings&
4015ProcessInstanceSettings::operator= (const ProcessInstanceSettings &rhs)
4016{
4017 if (this != &rhs)
4018 {
4019 m_run_args = rhs.m_run_args;
4020 m_env_vars = rhs.m_env_vars;
4021 m_input_path = rhs.m_input_path;
4022 m_output_path = rhs.m_output_path;
4023 m_error_path = rhs.m_error_path;
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004024 m_disable_aslr = rhs.m_disable_aslr;
Caroline Ticebd666012010-12-03 18:46:09 +00004025 m_disable_stdio = rhs.m_disable_stdio;
Greg Clayton638351a2010-12-04 00:10:17 +00004026 m_inherit_host_env = rhs.m_inherit_host_env;
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004027 }
4028
4029 return *this;
4030}
4031
4032
4033void
4034ProcessInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var_name,
4035 const char *index_value,
4036 const char *value,
4037 const ConstString &instance_name,
4038 const SettingEntry &entry,
Greg Claytonb3448432011-03-24 21:19:54 +00004039 VarSetOperationType op,
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004040 Error &err,
4041 bool pending)
4042{
4043 if (var_name == RunArgsVarName())
4044 UserSettingsController::UpdateStringArrayVariable (op, index_value, m_run_args, value, err);
4045 else if (var_name == EnvVarsVarName())
Greg Clayton638351a2010-12-04 00:10:17 +00004046 {
Greg Claytonb72d0f02011-04-12 05:54:46 +00004047 // This is nice for local debugging, but it is isn't correct for
4048 // remote debugging. We need to stop process.env-vars from being
4049 // populated with the host environment and add this as a launch option
4050 // and get the correct environment from the Target's platform.
4051 // GetHostEnvironmentIfNeeded ();
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004052 UserSettingsController::UpdateDictionaryVariable (op, index_value, m_env_vars, value, err);
Greg Clayton638351a2010-12-04 00:10:17 +00004053 }
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004054 else if (var_name == InputPathVarName())
4055 UserSettingsController::UpdateStringVariable (op, m_input_path, value, err);
4056 else if (var_name == OutputPathVarName())
4057 UserSettingsController::UpdateStringVariable (op, m_output_path, value, err);
4058 else if (var_name == ErrorPathVarName())
4059 UserSettingsController::UpdateStringVariable (op, m_error_path, value, err);
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004060 else if (var_name == DisableASLRVarName())
Greg Clayton17cd9952011-04-22 03:55:06 +00004061 UserSettingsController::UpdateBooleanVariable (op, m_disable_aslr, value, true, err);
Caroline Ticebd666012010-12-03 18:46:09 +00004062 else if (var_name == DisableSTDIOVarName ())
Greg Clayton17cd9952011-04-22 03:55:06 +00004063 UserSettingsController::UpdateBooleanVariable (op, m_disable_stdio, value, false, err);
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004064}
4065
4066void
4067ProcessInstanceSettings::CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings,
4068 bool pending)
4069{
4070 if (new_settings.get() == NULL)
4071 return;
4072
4073 ProcessInstanceSettings *new_process_settings = (ProcessInstanceSettings *) new_settings.get();
4074
4075 m_run_args = new_process_settings->m_run_args;
4076 m_env_vars = new_process_settings->m_env_vars;
4077 m_input_path = new_process_settings->m_input_path;
4078 m_output_path = new_process_settings->m_output_path;
4079 m_error_path = new_process_settings->m_error_path;
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004080 m_disable_aslr = new_process_settings->m_disable_aslr;
Caroline Ticebd666012010-12-03 18:46:09 +00004081 m_disable_stdio = new_process_settings->m_disable_stdio;
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004082}
4083
Caroline Ticebcb5b452010-09-20 21:37:42 +00004084bool
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004085ProcessInstanceSettings::GetInstanceSettingsValue (const SettingEntry &entry,
4086 const ConstString &var_name,
Caroline Tice5bc8c972010-09-20 20:44:43 +00004087 StringList &value,
Caroline Ticebcb5b452010-09-20 21:37:42 +00004088 Error *err)
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004089{
4090 if (var_name == RunArgsVarName())
4091 {
4092 if (m_run_args.GetArgumentCount() > 0)
Greg Claytonc14069e2010-09-14 03:47:41 +00004093 {
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004094 for (int i = 0; i < m_run_args.GetArgumentCount(); ++i)
4095 value.AppendString (m_run_args.GetArgumentAtIndex (i));
Greg Claytonc14069e2010-09-14 03:47:41 +00004096 }
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004097 }
4098 else if (var_name == EnvVarsVarName())
4099 {
Greg Clayton638351a2010-12-04 00:10:17 +00004100 GetHostEnvironmentIfNeeded ();
4101
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004102 if (m_env_vars.size() > 0)
4103 {
4104 std::map<std::string, std::string>::iterator pos;
4105 for (pos = m_env_vars.begin(); pos != m_env_vars.end(); ++pos)
4106 {
4107 StreamString value_str;
4108 value_str.Printf ("%s=%s", pos->first.c_str(), pos->second.c_str());
4109 value.AppendString (value_str.GetData());
4110 }
4111 }
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004112 }
4113 else if (var_name == InputPathVarName())
4114 {
4115 value.AppendString (m_input_path.c_str());
4116 }
4117 else if (var_name == OutputPathVarName())
4118 {
4119 value.AppendString (m_output_path.c_str());
4120 }
4121 else if (var_name == ErrorPathVarName())
4122 {
4123 value.AppendString (m_error_path.c_str());
4124 }
Greg Claytona99b0bf2010-12-04 00:12:24 +00004125 else if (var_name == InheritHostEnvVarName())
4126 {
4127 if (m_inherit_host_env)
4128 value.AppendString ("true");
4129 else
4130 value.AppendString ("false");
4131 }
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004132 else if (var_name == DisableASLRVarName())
4133 {
4134 if (m_disable_aslr)
4135 value.AppendString ("true");
4136 else
4137 value.AppendString ("false");
4138 }
Caroline Ticebd666012010-12-03 18:46:09 +00004139 else if (var_name == DisableSTDIOVarName())
4140 {
4141 if (m_disable_stdio)
4142 value.AppendString ("true");
4143 else
4144 value.AppendString ("false");
4145 }
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004146 else
Caroline Ticebcb5b452010-09-20 21:37:42 +00004147 {
4148 if (err)
4149 err->SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString());
4150 return false;
4151 }
4152 return true;
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004153}
4154
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004155const ConstString
4156ProcessInstanceSettings::CreateInstanceName ()
4157{
4158 static int instance_count = 1;
4159 StreamString sstr;
4160
4161 sstr.Printf ("process_%d", instance_count);
4162 ++instance_count;
4163
4164 const ConstString ret_val (sstr.GetData());
4165 return ret_val;
4166}
4167
4168const ConstString &
4169ProcessInstanceSettings::RunArgsVarName ()
4170{
4171 static ConstString run_args_var_name ("run-args");
4172
4173 return run_args_var_name;
4174}
4175
4176const ConstString &
4177ProcessInstanceSettings::EnvVarsVarName ()
4178{
4179 static ConstString env_vars_var_name ("env-vars");
4180
4181 return env_vars_var_name;
4182}
4183
4184const ConstString &
Greg Clayton638351a2010-12-04 00:10:17 +00004185ProcessInstanceSettings::InheritHostEnvVarName ()
4186{
4187 static ConstString g_name ("inherit-env");
4188
4189 return g_name;
4190}
4191
4192const ConstString &
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004193ProcessInstanceSettings::InputPathVarName ()
4194{
4195 static ConstString input_path_var_name ("input-path");
4196
4197 return input_path_var_name;
4198}
4199
4200const ConstString &
4201ProcessInstanceSettings::OutputPathVarName ()
4202{
Caroline Tice87097232010-09-07 18:35:40 +00004203 static ConstString output_path_var_name ("output-path");
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004204
4205 return output_path_var_name;
4206}
4207
4208const ConstString &
4209ProcessInstanceSettings::ErrorPathVarName ()
4210{
Caroline Tice87097232010-09-07 18:35:40 +00004211 static ConstString error_path_var_name ("error-path");
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004212
4213 return error_path_var_name;
4214}
4215
4216const ConstString &
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004217ProcessInstanceSettings::DisableASLRVarName ()
4218{
4219 static ConstString disable_aslr_var_name ("disable-aslr");
4220
4221 return disable_aslr_var_name;
4222}
4223
Caroline Ticebd666012010-12-03 18:46:09 +00004224const ConstString &
4225ProcessInstanceSettings::DisableSTDIOVarName ()
4226{
4227 static ConstString disable_stdio_var_name ("disable-stdio");
4228
4229 return disable_stdio_var_name;
4230}
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004231
4232//--------------------------------------------------
Greg Claytond0a5a232010-09-19 02:33:57 +00004233// SettingsController Variable Tables
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004234//--------------------------------------------------
4235
4236SettingEntry
Greg Claytond0a5a232010-09-19 02:33:57 +00004237Process::SettingsController::global_settings_table[] =
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004238{
4239 //{ "var-name", var-type , "default", enum-table, init'd, hidden, "help-text"},
4240 { NULL, eSetVarTypeNone, NULL, NULL, 0, 0, NULL }
4241};
4242
4243
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004244SettingEntry
Greg Claytond0a5a232010-09-19 02:33:57 +00004245Process::SettingsController::instance_settings_table[] =
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004246{
Greg Clayton638351a2010-12-04 00:10:17 +00004247 //{ "var-name", var-type, "default", enum-table, init'd, hidden, "help-text"},
4248 { "run-args", eSetVarTypeArray, NULL, NULL, false, false, "A list containing all the arguments to be passed to the executable when it is run." },
4249 { "env-vars", eSetVarTypeDictionary, NULL, NULL, false, false, "A list of all the environment variables to be passed to the executable's environment, and their values." },
4250 { "inherit-env", eSetVarTypeBoolean, "true", NULL, false, false, "Inherit the environment from the process that is running LLDB." },
Greg Claytonde915be2011-01-23 05:56:20 +00004251 { "input-path", eSetVarTypeString, NULL, NULL, false, false, "The file/path to be used by the executable program for reading its input." },
4252 { "output-path", eSetVarTypeString, NULL, NULL, false, false, "The file/path to be used by the executable program for writing its output." },
4253 { "error-path", eSetVarTypeString, NULL, NULL, false, false, "The file/path to be used by the executable program for writings its error messages." },
Greg Claytond284b662011-02-18 01:44:25 +00004254 { "plugin", eSetVarTypeEnum, NULL, NULL, false, false, "The plugin to be used to run the process." },
Greg Clayton638351a2010-12-04 00:10:17 +00004255 { "disable-aslr", eSetVarTypeBoolean, "true", NULL, false, false, "Disable Address Space Layout Randomization (ASLR)" },
4256 { "disable-stdio", eSetVarTypeBoolean, "false", NULL, false, false, "Disable stdin/stdout for process (e.g. for a GUI application)" },
4257 { NULL, eSetVarTypeNone, NULL, NULL, false, false, NULL }
Caroline Tice6e4c5ce2010-09-04 00:03:46 +00004258};
4259
4260
Jim Ingham7508e732010-08-09 23:31:02 +00004261