contrib/llvm/tools/lldb/source/Commands/CommandObjectProcess.cpp

   1 //===-- CommandObjectProcess.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/lldb-python.h"
  11
  12 #include "CommandObjectProcess.h"
  13
  14 // C Includes
  15 // C++ Includes
  16 // Other libraries and framework includes
  17 // Project includes
  18 #include "lldb/Breakpoint/Breakpoint.h"
  19 #include "lldb/Breakpoint/BreakpointLocation.h"
  20 #include "lldb/Breakpoint/BreakpointSite.h"
  21 #include "lldb/Core/State.h"
  22 #include "lldb/Core/Module.h"
  23 #include "lldb/Host/Host.h"
  24 #include "lldb/Interpreter/Args.h"
  25 #include "lldb/Interpreter/Options.h"
  26 #include "lldb/Interpreter/CommandInterpreter.h"
  27 #include "lldb/Interpreter/CommandReturnObject.h"
  28 #include "lldb/Target/Platform.h"
  29 #include "lldb/Target/Process.h"
  30 #include "lldb/Target/StopInfo.h"
  31 #include "lldb/Target/Target.h"
  32 #include "lldb/Target/Thread.h"
  33
  34 using namespace lldb;
  35 using namespace lldb_private;
  36
  37 class CommandObjectProcessLaunchOrAttach : public CommandObjectParsed
  38 {
  39 public:
  40     CommandObjectProcessLaunchOrAttach (CommandInterpreter &interpreter,
  41                                        const char *name,
  42                                        const char *help,
  43                                        const char *syntax,
  44                                        uint32_t flags,
  45                                        const char *new_process_action) :
  46         CommandObjectParsed (interpreter, name, help, syntax, flags),
  47         m_new_process_action (new_process_action) {}
  48
  49     virtual ~CommandObjectProcessLaunchOrAttach () {}
  50 protected:
  51     bool
  52     StopProcessIfNecessary (Process *&process, StateType &state, CommandReturnObject &result)
  53     {
  54         state = eStateInvalid;
  55         if (process)
  56         {
  57             state = process->GetState();
  58
  59             if (process->IsAlive() && state != eStateConnected)
  60             {
  61                 char message[1024];
  62                 if (process->GetState() == eStateAttaching)
  63                     ::snprintf (message, sizeof(message), "There is a pending attach, abort it and %s?", m_new_process_action.c_str());
  64                 else if (process->GetShouldDetach())
  65                     ::snprintf (message, sizeof(message), "There is a running process, detach from it and %s?", m_new_process_action.c_str());
  66                 else
  67                     ::snprintf (message, sizeof(message), "There is a running process, kill it and %s?", m_new_process_action.c_str());
  68
  69                 if (!m_interpreter.Confirm (message, true))
  70                 {
  71                     result.SetStatus (eReturnStatusFailed);
  72                     return false;
  73                 }
  74                 else
  75                 {
  76                     if (process->GetShouldDetach())
  77                     {
  78                         bool keep_stopped = false;
  79                         Error detach_error (process->Detach(keep_stopped));
  80                         if (detach_error.Success())
  81                         {
  82                             result.SetStatus (eReturnStatusSuccessFinishResult);
  83                             process = NULL;
  84                         }
  85                         else
  86                         {
  87                             result.AppendErrorWithFormat ("Failed to detach from process: %s\n", detach_error.AsCString());
  88                             result.SetStatus (eReturnStatusFailed);
  89                         }
  90                     }
  91                     else
  92                     {
  93                         Error destroy_error (process->Destroy());
  94                         if (destroy_error.Success())
  95                         {
  96                             result.SetStatus (eReturnStatusSuccessFinishResult);
  97                             process = NULL;
  98                         }
  99                         else
 100                         {
 101                             result.AppendErrorWithFormat ("Failed to kill process: %s\n", destroy_error.AsCString());
 102                             result.SetStatus (eReturnStatusFailed);
 103                         }
 104                     }
 105                 }
 106             }
 107         }
 108         return result.Succeeded();
 109     }
 110     std::string m_new_process_action;
 111 };
 112 //-------------------------------------------------------------------------
 113 // CommandObjectProcessLaunch
 114 //-------------------------------------------------------------------------
 115 #pragma mark CommandObjectProcessLaunch
 116 class CommandObjectProcessLaunch : public CommandObjectProcessLaunchOrAttach
 117 {
 118 public:
 119
 120     CommandObjectProcessLaunch (CommandInterpreter &interpreter) :
 121         CommandObjectProcessLaunchOrAttach (interpreter,
 122                                             "process launch",
 123                                             "Launch the executable in the debugger.",
 124                                             NULL,
 125                                             eFlagRequiresTarget,
 126                                             "restart"),
 127         m_options (interpreter)
 128     {
 129         CommandArgumentEntry arg;
 130         CommandArgumentData run_args_arg;
 131
 132         // Define the first (and only) variant of this arg.
 133         run_args_arg.arg_type = eArgTypeRunArgs;
 134         run_args_arg.arg_repetition = eArgRepeatOptional;
 135
 136         // There is only one variant this argument could be; put it into the argument entry.
 137         arg.push_back (run_args_arg);
 138
 139         // Push the data for the first argument into the m_arguments vector.
 140         m_arguments.push_back (arg);
 141     }
 142
 143
 144     ~CommandObjectProcessLaunch ()
 145     {
 146     }
 147
 148     virtual int
 149     HandleArgumentCompletion (Args &input,
 150                               int &cursor_index,
 151                               int &cursor_char_position,
 152                               OptionElementVector &opt_element_vector,
 153                               int match_start_point,
 154                               int max_return_elements,
 155                               bool &word_complete,
 156                               StringList &matches)
 157     {
 158         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
 159         completion_str.erase (cursor_char_position);
 160
 161         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
 162                                                              CommandCompletions::eDiskFileCompletion,
 163                                                              completion_str.c_str(),
 164                                                              match_start_point,
 165                                                              max_return_elements,
 166                                                              NULL,
 167                                                              word_complete,
 168                                                              matches);
 169         return matches.GetSize();
 170     }
 171
 172     Options *
 173     GetOptions ()
 174     {
 175         return &m_options;
 176     }
 177
 178     virtual const char *GetRepeatCommand (Args &current_command_args, uint32_t index)
 179     {
 180         // No repeat for "process launch"...
 181         return "";
 182     }
 183
 184 protected:
 185     bool
 186     DoExecute (Args& launch_args, CommandReturnObject &result)
 187     {
 188         Debugger &debugger = m_interpreter.GetDebugger();
 189         Target *target = debugger.GetSelectedTarget().get();
 190         Error error;
 191         // If our listener is NULL, users aren't allows to launch
 192         char filename[PATH_MAX];
 193         const Module *exe_module = target->GetExecutableModulePointer();
 194
 195         if (exe_module == NULL)
 196         {
 197             result.AppendError ("no file in target, create a debug target using the 'target create' command");
 198             result.SetStatus (eReturnStatusFailed);
 199             return false;
 200         }
 201
 202         StateType state = eStateInvalid;
 203         Process *process = m_exe_ctx.GetProcessPtr();
 204
 205         if (!StopProcessIfNecessary(process, state, result))
 206             return false;
 207
 208         const char *target_settings_argv0 = target->GetArg0();
 209
 210         exe_module->GetFileSpec().GetPath (filename, sizeof(filename));
 211
 212         if (target_settings_argv0)
 213         {
 214             m_options.launch_info.GetArguments().AppendArgument (target_settings_argv0);
 215             m_options.launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), false);
 216         }
 217         else
 218         {
 219             m_options.launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
 220         }
 221
 222         if (launch_args.GetArgumentCount() == 0)
 223         {
 224             Args target_setting_args;
 225             if (target->GetRunArguments(target_setting_args))
 226                 m_options.launch_info.GetArguments().AppendArguments (target_setting_args);
 227         }
 228         else
 229         {
 230             m_options.launch_info.GetArguments().AppendArguments (launch_args);
 231
 232             // Save the arguments for subsequent runs in the current target.
 233             target->SetRunArguments (launch_args);
 234         }
 235
 236         if (target->GetDisableASLR())
 237             m_options.launch_info.GetFlags().Set (eLaunchFlagDisableASLR);
 238
 239         if (target->GetDisableSTDIO())
 240             m_options.launch_info.GetFlags().Set (eLaunchFlagDisableSTDIO);
 241
 242         m_options.launch_info.GetFlags().Set (eLaunchFlagDebug);
 243
 244         Args environment;
 245         target->GetEnvironmentAsArgs (environment);
 246         if (environment.GetArgumentCount() > 0)
 247             m_options.launch_info.GetEnvironmentEntries ().AppendArguments (environment);
 248
 249         // Get the value of synchronous execution here.  If you wait till after you have started to
 250         // run, then you could have hit a breakpoint, whose command might switch the value, and
 251         // then you'll pick up that incorrect value.
 252         bool synchronous_execution = m_interpreter.GetSynchronous ();
 253
 254         // Finalize the file actions, and if none were given, default to opening
 255         // up a pseudo terminal
 256         const bool default_to_use_pty = true;
 257         m_options.launch_info.FinalizeFileActions (target, default_to_use_pty);
 258
 259         if (state == eStateConnected)
 260         {
 261             if (m_options.launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY))
 262             {
 263                 result.AppendWarning("can't launch in tty when launching through a remote connection");
 264                 m_options.launch_info.GetFlags().Clear (eLaunchFlagLaunchInTTY);
 265             }
 266         }
 267
 268         if (!m_options.launch_info.GetArchitecture().IsValid())
 269             m_options.launch_info.GetArchitecture() = target->GetArchitecture();
 270
 271         PlatformSP platform_sp (target->GetPlatform());
 272
 273         if (platform_sp && platform_sp->CanDebugProcess ())
 274         {
 275             process = target->GetPlatform()->DebugProcess (m_options.launch_info,
 276                                                            debugger,
 277                                                            target,
 278                                                            debugger.GetListener(),
 279                                                            error).get();
 280         }
 281         else
 282         {
 283             const char *plugin_name = m_options.launch_info.GetProcessPluginName();
 284             process = target->CreateProcess (debugger.GetListener(), plugin_name, NULL).get();
 285             if (process)
 286                 error = process->Launch (m_options.launch_info);
 287         }
 288
 289         if (process == NULL)
 290         {
 291             result.SetError (error, "failed to launch or debug process");
 292             return false;
 293         }
 294
 295
 296         if (error.Success())
 297         {
 298             const char *archname = exe_module->GetArchitecture().GetArchitectureName();
 299
 300             result.AppendMessageWithFormat ("Process %" PRIu64 " launched: '%s' (%s)\n", process->GetID(), filename, archname);
 301             result.SetDidChangeProcessState (true);
 302             if (m_options.launch_info.GetFlags().Test(eLaunchFlagStopAtEntry) == false)
 303             {
 304                 result.SetStatus (eReturnStatusSuccessContinuingNoResult);
 305                 StateType state = process->WaitForProcessToStop (NULL);
 306
 307                 if (state == eStateStopped)
 308                 {
 309                     error = process->Resume();
 310                     if (error.Success())
 311                     {
 312                         if (synchronous_execution)
 313                         {
 314                             state = process->WaitForProcessToStop (NULL);
 315                             const bool must_be_alive = true;
 316                             if (!StateIsStoppedState(state, must_be_alive))
 317                             {
 318                                 result.AppendErrorWithFormat ("process isn't stopped: %s", StateAsCString(state));
 319                             }
 320                             result.SetDidChangeProcessState (true);
 321                             result.SetStatus (eReturnStatusSuccessFinishResult);
 322                         }
 323                         else
 324                         {
 325                             result.SetStatus (eReturnStatusSuccessContinuingNoResult);
 326                         }
 327                     }
 328                     else
 329                     {
 330                         result.AppendErrorWithFormat ("process resume at entry point failed: %s", error.AsCString());
 331                         result.SetStatus (eReturnStatusFailed);
 332                     }
 333                 }
 334                 else
 335                 {
 336                     result.AppendErrorWithFormat ("initial process state wasn't stopped: %s", StateAsCString(state));
 337                     result.SetStatus (eReturnStatusFailed);
 338                 }
 339             }
 340         }
 341         else
 342         {
 343             result.AppendErrorWithFormat ("process launch failed: %s", error.AsCString());
 344             result.SetStatus (eReturnStatusFailed);
 345         }
 346
 347         return result.Succeeded();
 348     }
 349
 350 protected:
 351     ProcessLaunchCommandOptions m_options;
 352 };
 353
 354
 355 //#define SET1 LLDB_OPT_SET_1
 356 //#define SET2 LLDB_OPT_SET_2
 357 //#define SET3 LLDB_OPT_SET_3
 358 //
 359 //OptionDefinition
 360 //CommandObjectProcessLaunch::CommandOptions::g_option_table[] =
 361 //{
 362 //{ SET1 | SET2 | SET3, false, "stop-at-entry", 's', no_argument,       NULL, 0, eArgTypeNone,    "Stop at the entry point of the program when launching a process."},
 363 //{ SET1              , false, "stdin",         'i', required_argument, NULL, 0, eArgTypeDirectoryName,    "Redirect stdin for the process to <path>."},
 364 //{ SET1              , false, "stdout",        'o', required_argument, NULL, 0, eArgTypeDirectoryName,    "Redirect stdout for the process to <path>."},
 365 //{ SET1              , false, "stderr",        'e', required_argument, NULL, 0, eArgTypeDirectoryName,    "Redirect stderr for the process to <path>."},
 366 //{ SET1 | SET2 | SET3, false, "plugin",        'p', required_argument, NULL, 0, eArgTypePlugin,  "Name of the process plugin you want to use."},
 367 //{        SET2       , false, "tty",           't', optional_argument, NULL, 0, eArgTypeDirectoryName,    "Start the process in a terminal. If <path> is specified, look for a terminal whose name contains <path>, else start the process in a new terminal."},
 368 //{               SET3, false, "no-stdio",      'n', no_argument,       NULL, 0, eArgTypeNone,    "Do not set up for terminal I/O to go to running process."},
 369 //{ SET1 | SET2 | SET3, false, "working-dir",   'w', required_argument, NULL, 0, eArgTypeDirectoryName,    "Set the current working directory to <path> when running the inferior."},
 370 //{ 0,                  false, NULL,             0,  0,                 NULL, 0, eArgTypeNone,    NULL }
 371 //};
 372 //
 373 //#undef SET1
 374 //#undef SET2
 375 //#undef SET3
 376
 377 //-------------------------------------------------------------------------
 378 // CommandObjectProcessAttach
 379 //-------------------------------------------------------------------------
 380 #pragma mark CommandObjectProcessAttach
 381 class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach
 382 {
 383 public:
 384
 385     class CommandOptions : public Options
 386     {
 387     public:
 388
 389         CommandOptions (CommandInterpreter &interpreter) :
 390             Options(interpreter)
 391         {
 392             // Keep default values of all options in one place: OptionParsingStarting ()
 393             OptionParsingStarting ();
 394         }
 395
 396         ~CommandOptions ()
 397         {
 398         }
 399
 400         Error
 401         SetOptionValue (uint32_t option_idx, const char *option_arg)
 402         {
 403             Error error;
 404             const int short_option = m_getopt_table[option_idx].val;
 405             bool success = false;
 406             switch (short_option)
 407             {
 408                 case 'c':
 409                     attach_info.SetContinueOnceAttached(true);
 410                     break;
 411
 412                 case 'p':
 413                     {
 414                         lldb::pid_t pid = Args::StringToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success);
 415                         if (!success || pid == LLDB_INVALID_PROCESS_ID)
 416                         {
 417                             error.SetErrorStringWithFormat("invalid process ID '%s'", option_arg);
 418                         }
 419                         else
 420                         {
 421                             attach_info.SetProcessID (pid);
 422                         }
 423                     }
 424                     break;
 425
 426                 case 'P':
 427                     attach_info.SetProcessPluginName (option_arg);
 428                     break;
 429
 430                 case 'n':
 431                     attach_info.GetExecutableFile().SetFile(option_arg, false);
 432                     break;
 433
 434                 case 'w':
 435                     attach_info.SetWaitForLaunch(true);
 436                     break;
 437
 438                 case 'i':
 439                     attach_info.SetIgnoreExisting(false);
 440                     break;
 441
 442                 default:
 443                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
 444                     break;
 445             }
 446             return error;
 447         }
 448
 449         void
 450         OptionParsingStarting ()
 451         {
 452             attach_info.Clear();
 453         }
 454
 455         const OptionDefinition*
 456         GetDefinitions ()
 457         {
 458             return g_option_table;
 459         }
 460
 461         virtual bool
 462         HandleOptionArgumentCompletion (Args &input,
 463                                         int cursor_index,
 464                                         int char_pos,
 465                                         OptionElementVector &opt_element_vector,
 466                                         int opt_element_index,
 467                                         int match_start_point,
 468                                         int max_return_elements,
 469                                         bool &word_complete,
 470                                         StringList &matches)
 471         {
 472             int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
 473             int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 474
 475             // We are only completing the name option for now...
 476
 477             const OptionDefinition *opt_defs = GetDefinitions();
 478             if (opt_defs[opt_defs_index].short_option == 'n')
 479             {
 480                 // Are we in the name?
 481
 482                 // Look to see if there is a -P argument provided, and if so use that plugin, otherwise
 483                 // use the default plugin.
 484
 485                 const char *partial_name = NULL;
 486                 partial_name = input.GetArgumentAtIndex(opt_arg_pos);
 487
 488                 PlatformSP platform_sp (m_interpreter.GetPlatform (true));
 489                 if (platform_sp)
 490                 {
 491                     ProcessInstanceInfoList process_infos;
 492                     ProcessInstanceInfoMatch match_info;
 493                     if (partial_name)
 494                     {
 495                         match_info.GetProcessInfo().GetExecutableFile().SetFile(partial_name, false);
 496                         match_info.SetNameMatchType(eNameMatchStartsWith);
 497                     }
 498                     platform_sp->FindProcesses (match_info, process_infos);
 499                     const size_t num_matches = process_infos.GetSize();
 500                     if (num_matches > 0)
 501                     {
 502                         for (size_t i=0; i<num_matches; ++i)
 503                         {
 504                             matches.AppendString (process_infos.GetProcessNameAtIndex(i),
 505                                                   process_infos.GetProcessNameLengthAtIndex(i));
 506                         }
 507                     }
 508                 }
 509             }
 510
 511             return false;
 512         }
 513
 514         // Options table: Required for subclasses of Options.
 515
 516         static OptionDefinition g_option_table[];
 517
 518         // Instance variables to hold the values for command options.
 519
 520         ProcessAttachInfo attach_info;
 521     };
 522
 523     CommandObjectProcessAttach (CommandInterpreter &interpreter) :
 524         CommandObjectProcessLaunchOrAttach (interpreter,
 525                                             "process attach",
 526                                             "Attach to a process.",
 527                                             "process attach <cmd-options>",
 528                                             0,
 529                                             "attach"),
 530         m_options (interpreter)
 531     {
 532     }
 533
 534     ~CommandObjectProcessAttach ()
 535     {
 536     }
 537
 538     Options *
 539     GetOptions ()
 540     {
 541         return &m_options;
 542     }
 543
 544 protected:
 545     bool
 546     DoExecute (Args& command,
 547              CommandReturnObject &result)
 548     {
 549         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 550         // N.B. The attach should be synchronous.  It doesn't help much to get the prompt back between initiating the attach
 551         // and the target actually stopping.  So even if the interpreter is set to be asynchronous, we wait for the stop
 552         // ourselves here.
 553
 554         StateType state = eStateInvalid;
 555         Process *process = m_exe_ctx.GetProcessPtr();
 556
 557         if (!StopProcessIfNecessary (process, state, result))
 558             return false;
 559
 560         if (target == NULL)
 561         {
 562             // If there isn't a current target create one.
 563             TargetSP new_target_sp;
 564             Error error;
 565
 566             error = m_interpreter.GetDebugger().GetTargetList().CreateTarget (m_interpreter.GetDebugger(),
 567                                                                               NULL,
 568                                                                               NULL,
 569                                                                               false,
 570                                                                               NULL, // No platform options
 571                                                                               new_target_sp);
 572             target = new_target_sp.get();
 573             if (target == NULL || error.Fail())
 574             {
 575                 result.AppendError(error.AsCString("Error creating target"));
 576                 return false;
 577             }
 578             m_interpreter.GetDebugger().GetTargetList().SetSelectedTarget(target);
 579         }
 580
 581         // Record the old executable module, we want to issue a warning if the process of attaching changed the
 582         // current executable (like somebody said "file foo" then attached to a PID whose executable was bar.)
 583
 584         ModuleSP old_exec_module_sp = target->GetExecutableModule();
 585         ArchSpec old_arch_spec = target->GetArchitecture();
 586
 587         if (command.GetArgumentCount())
 588         {
 589             result.AppendErrorWithFormat("Invalid arguments for '%s'.\nUsage: %s\n", m_cmd_name.c_str(), m_cmd_syntax.c_str());
 590             result.SetStatus (eReturnStatusFailed);
 591         }
 592         else
 593         {
 594             if (state != eStateConnected)
 595             {
 596                 const char *plugin_name = m_options.attach_info.GetProcessPluginName();
 597                 process = target->CreateProcess (m_interpreter.GetDebugger().GetListener(), plugin_name, NULL).get();
 598             }
 599
 600             if (process)
 601             {
 602                 Error error;
 603                 // If no process info was specified, then use the target executable
 604                 // name as the process to attach to by default
 605                 if (!m_options.attach_info.ProcessInfoSpecified ())
 606                 {
 607                     if (old_exec_module_sp)
 608                         m_options.attach_info.GetExecutableFile().GetFilename() = old_exec_module_sp->GetPlatformFileSpec().GetFilename();
 609
 610                     if (!m_options.attach_info.ProcessInfoSpecified ())
 611                     {
 612                         error.SetErrorString ("no process specified, create a target with a file, or specify the --pid or --name command option");
 613                     }
 614                 }
 615
 616                 if (error.Success())
 617                 {
 618                     error = process->Attach (m_options.attach_info);
 619
 620                     if (error.Success())
 621                     {
 622                         result.SetStatus (eReturnStatusSuccessContinuingNoResult);
 623                     }
 624                     else
 625                     {
 626                         result.AppendErrorWithFormat ("attach failed: %s\n", error.AsCString());
 627                         result.SetStatus (eReturnStatusFailed);
 628                         return false;
 629                     }
 630                     // If we're synchronous, wait for the stopped event and report that.
 631                     // Otherwise just return.
 632                     // FIXME: in the async case it will now be possible to get to the command
 633                     // interpreter with a state eStateAttaching.  Make sure we handle that correctly.
 634                     StateType state = process->WaitForProcessToStop (NULL);
 635
 636                     result.SetDidChangeProcessState (true);
 637
 638                     if (state == eStateStopped)
 639                     {
 640                         result.AppendMessageWithFormat ("Process %" PRIu64 " %s\n", process->GetID(), StateAsCString (state));
 641                         result.SetStatus (eReturnStatusSuccessFinishNoResult);
 642                     }
 643                     else
 644                     {
 645                         result.AppendError ("attach failed: process did not stop (no such process or permission problem?)");
 646                         process->Destroy();
 647                         result.SetStatus (eReturnStatusFailed);
 648                         return false;
 649                     }
 650                 }
 651             }
 652         }
 653
 654         if (result.Succeeded())
 655         {
 656             // Okay, we're done.  Last step is to warn if the executable module has changed:
 657             char new_path[PATH_MAX];
 658             ModuleSP new_exec_module_sp (target->GetExecutableModule());
 659             if (!old_exec_module_sp)
 660             {
 661                 // We might not have a module if we attached to a raw pid...
 662                 if (new_exec_module_sp)
 663                 {
 664                     new_exec_module_sp->GetFileSpec().GetPath(new_path, PATH_MAX);
 665                     result.AppendMessageWithFormat("Executable module set to \"%s\".\n", new_path);
 666                 }
 667             }
 668             else if (old_exec_module_sp->GetFileSpec() != new_exec_module_sp->GetFileSpec())
 669             {
 670                 char old_path[PATH_MAX];
 671
 672                 old_exec_module_sp->GetFileSpec().GetPath (old_path, PATH_MAX);
 673                 new_exec_module_sp->GetFileSpec().GetPath (new_path, PATH_MAX);
 674
 675                 result.AppendWarningWithFormat("Executable module changed from \"%s\" to \"%s\".\n",
 676                                                     old_path, new_path);
 677             }
 678
 679             if (!old_arch_spec.IsValid())
 680             {
 681                 result.AppendMessageWithFormat ("Architecture set to: %s.\n", target->GetArchitecture().GetTriple().getTriple().c_str());
 682             }
 683             else if (!old_arch_spec.IsExactMatch(target->GetArchitecture()))
 684             {
 685                 result.AppendWarningWithFormat("Architecture changed from %s to %s.\n",
 686                                                old_arch_spec.GetTriple().getTriple().c_str(),
 687                                                target->GetArchitecture().GetTriple().getTriple().c_str());
 688             }
 689
 690             // This supports the use-case scenario of immediately continuing the process once attached.
 691             if (m_options.attach_info.GetContinueOnceAttached())
 692                 m_interpreter.HandleCommand("process continue", eLazyBoolNo, result);
 693         }
 694         return result.Succeeded();
 695     }
 696
 697     CommandOptions m_options;
 698 };
 699
 700
 701 OptionDefinition
 702 CommandObjectProcessAttach::CommandOptions::g_option_table[] =
 703 {
 704 { LLDB_OPT_SET_ALL, false, "continue",'c', no_argument,         NULL, 0, eArgTypeNone,         "Immediately continue the process once attached."},
 705 { LLDB_OPT_SET_ALL, false, "plugin",  'P', required_argument,   NULL, 0, eArgTypePlugin,       "Name of the process plugin you want to use."},
 706 { LLDB_OPT_SET_1,   false, "pid",     'p', required_argument,   NULL, 0, eArgTypePid,          "The process ID of an existing process to attach to."},
 707 { LLDB_OPT_SET_2,   false, "name",    'n', required_argument,   NULL, 0, eArgTypeProcessName,  "The name of the process to attach to."},
 708 { LLDB_OPT_SET_2,   false, "include-existing", 'i', no_argument, NULL, 0, eArgTypeNone,         "Include existing processes when doing attach -w."},
 709 { LLDB_OPT_SET_2,   false, "waitfor", 'w', no_argument,         NULL, 0, eArgTypeNone,         "Wait for the process with <process-name> to launch."},
 710 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
 711 };
 712
 713 //-------------------------------------------------------------------------
 714 // CommandObjectProcessContinue
 715 //-------------------------------------------------------------------------
 716 #pragma mark CommandObjectProcessContinue
 717
 718 class CommandObjectProcessContinue : public CommandObjectParsed
 719 {
 720 public:
 721
 722     CommandObjectProcessContinue (CommandInterpreter &interpreter) :
 723         CommandObjectParsed (interpreter,
 724                              "process continue",
 725                              "Continue execution of all threads in the current process.",
 726                              "process continue",
 727                              eFlagRequiresProcess       |
 728                              eFlagTryTargetAPILock      |
 729                              eFlagProcessMustBeLaunched |
 730                              eFlagProcessMustBePaused   ),
 731         m_options(interpreter)
 732     {
 733     }
 734
 735
 736     ~CommandObjectProcessContinue ()
 737     {
 738     }
 739
 740 protected:
 741
 742     class CommandOptions : public Options
 743     {
 744     public:
 745
 746         CommandOptions (CommandInterpreter &interpreter) :
 747             Options(interpreter)
 748         {
 749             // Keep default values of all options in one place: OptionParsingStarting ()
 750             OptionParsingStarting ();
 751         }
 752
 753         ~CommandOptions ()
 754         {
 755         }
 756
 757         Error
 758         SetOptionValue (uint32_t option_idx, const char *option_arg)
 759         {
 760             Error error;
 761             const int short_option = m_getopt_table[option_idx].val;
 762             bool success = false;
 763             switch (short_option)
 764             {
 765                 case 'i':
 766                     m_ignore = Args::StringToUInt32 (option_arg, 0, 0, &success);
 767                     if (!success)
 768                         error.SetErrorStringWithFormat ("invalid value for ignore option: \"%s\", should be a number.", option_arg);
 769                     break;
 770
 771                 default:
 772                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
 773                     break;
 774             }
 775             return error;
 776         }
 777
 778         void
 779         OptionParsingStarting ()
 780         {
 781             m_ignore = 0;
 782         }
 783
 784         const OptionDefinition*
 785         GetDefinitions ()
 786         {
 787             return g_option_table;
 788         }
 789
 790         // Options table: Required for subclasses of Options.
 791
 792         static OptionDefinition g_option_table[];
 793
 794         uint32_t m_ignore;
 795     };
 796
 797     bool
 798     DoExecute (Args& command, CommandReturnObject &result)
 799     {
 800         Process *process = m_exe_ctx.GetProcessPtr();
 801         bool synchronous_execution = m_interpreter.GetSynchronous ();
 802         StateType state = process->GetState();
 803         if (state == eStateStopped)
 804         {
 805             if (command.GetArgumentCount() != 0)
 806             {
 807                 result.AppendErrorWithFormat ("The '%s' command does not take any arguments.\n", m_cmd_name.c_str());
 808                 result.SetStatus (eReturnStatusFailed);
 809                 return false;
 810             }
 811
 812             if (m_options.m_ignore > 0)
 813             {
 814                 ThreadSP sel_thread_sp(process->GetThreadList().GetSelectedThread());
 815                 if (sel_thread_sp)
 816                 {
 817                     StopInfoSP stop_info_sp = sel_thread_sp->GetStopInfo();
 818                     if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint)
 819                     {
 820                         lldb::break_id_t bp_site_id = (lldb::break_id_t)stop_info_sp->GetValue();
 821                         BreakpointSiteSP bp_site_sp(process->GetBreakpointSiteList().FindByID(bp_site_id));
 822                         if (bp_site_sp)
 823                         {
 824                             const size_t num_owners = bp_site_sp->GetNumberOfOwners();
 825                             for (size_t i = 0; i < num_owners; i++)
 826                             {
 827                                 Breakpoint &bp_ref = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
 828                                 if (!bp_ref.IsInternal())
 829                                 {
 830                                     bp_ref.SetIgnoreCount(m_options.m_ignore);
 831                                 }
 832                             }
 833                         }
 834                     }
 835                 }
 836             }
 837
 838             {  // Scope for thread list mutex:
 839                 Mutex::Locker locker (process->GetThreadList().GetMutex());
 840                 const uint32_t num_threads = process->GetThreadList().GetSize();
 841
 842                 // Set the actions that the threads should each take when resuming
 843                 for (uint32_t idx=0; idx<num_threads; ++idx)
 844                 {
 845                     process->GetThreadList().GetThreadAtIndex(idx)->SetResumeState (eStateRunning);
 846                 }
 847             }
 848
 849             Error error(process->Resume());
 850             if (error.Success())
 851             {
 852                 result.AppendMessageWithFormat ("Process %" PRIu64 " resuming\n", process->GetID());
 853                 if (synchronous_execution)
 854                 {
 855                     state = process->WaitForProcessToStop (NULL);
 856
 857                     result.SetDidChangeProcessState (true);
 858                     result.AppendMessageWithFormat ("Process %" PRIu64 " %s\n", process->GetID(), StateAsCString (state));
 859                     result.SetStatus (eReturnStatusSuccessFinishNoResult);
 860                 }
 861                 else
 862                 {
 863                     result.SetStatus (eReturnStatusSuccessContinuingNoResult);
 864                 }
 865             }
 866             else
 867             {
 868                 result.AppendErrorWithFormat("Failed to resume process: %s.\n", error.AsCString());
 869                 result.SetStatus (eReturnStatusFailed);
 870             }
 871         }
 872         else
 873         {
 874             result.AppendErrorWithFormat ("Process cannot be continued from its current state (%s).\n",
 875                                          StateAsCString(state));
 876             result.SetStatus (eReturnStatusFailed);
 877         }
 878         return result.Succeeded();
 879     }
 880
 881     Options *
 882     GetOptions ()
 883     {
 884         return &m_options;
 885     }
 886
 887     CommandOptions m_options;
 888
 889 };
 890
 891 OptionDefinition
 892 CommandObjectProcessContinue::CommandOptions::g_option_table[] =
 893 {
 894 { LLDB_OPT_SET_ALL, false, "ignore-count",'i', required_argument,         NULL, 0, eArgTypeUnsignedInteger,
 895                            "Ignore <N> crossings of the breakpoint (if it exists) for the currently selected thread."},
 896 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
 897 };
 898
 899 //-------------------------------------------------------------------------
 900 // CommandObjectProcessDetach
 901 //-------------------------------------------------------------------------
 902 #pragma mark CommandObjectProcessDetach
 903
 904 class CommandObjectProcessDetach : public CommandObjectParsed
 905 {
 906 public:
 907     class CommandOptions : public Options
 908     {
 909     public:
 910
 911         CommandOptions (CommandInterpreter &interpreter) :
 912             Options (interpreter)
 913         {
 914             OptionParsingStarting ();
 915         }
 916
 917         ~CommandOptions ()
 918         {
 919         }
 920
 921         Error
 922         SetOptionValue (uint32_t option_idx, const char *option_arg)
 923         {
 924             Error error;
 925             const int short_option = m_getopt_table[option_idx].val;
 926
 927             switch (short_option)
 928             {
 929                 case 's':
 930                     bool tmp_result;
 931                     bool success;
 932                     tmp_result = Args::StringToBoolean(option_arg, false, &success);
 933                     if (!success)
 934                         error.SetErrorStringWithFormat("invalid boolean option: \"%s\"", option_arg);
 935                     else
 936                     {
 937                         if (tmp_result)
 938                             m_keep_stopped = eLazyBoolYes;
 939                         else
 940                             m_keep_stopped = eLazyBoolNo;
 941                     }
 942                     break;
 943                 default:
 944                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
 945                     break;
 946             }
 947             return error;
 948         }
 949
 950         void
 951         OptionParsingStarting ()
 952         {
 953             m_keep_stopped = eLazyBoolCalculate;
 954         }
 955
 956         const OptionDefinition*
 957         GetDefinitions ()
 958         {
 959             return g_option_table;
 960         }
 961
 962         // Options table: Required for subclasses of Options.
 963
 964         static OptionDefinition g_option_table[];
 965
 966         // Instance variables to hold the values for command options.
 967         LazyBool m_keep_stopped;
 968     };
 969
 970     CommandObjectProcessDetach (CommandInterpreter &interpreter) :
 971         CommandObjectParsed (interpreter,
 972                              "process detach",
 973                              "Detach from the current process being debugged.",
 974                              "process detach",
 975                              eFlagRequiresProcess      |
 976                              eFlagTryTargetAPILock     |
 977                              eFlagProcessMustBeLaunched),
 978         m_options(interpreter)
 979     {
 980     }
 981
 982     ~CommandObjectProcessDetach ()
 983     {
 984     }
 985
 986     Options *
 987     GetOptions ()
 988     {
 989         return &m_options;
 990     }
 991
 992
 993 protected:
 994     bool
 995     DoExecute (Args& command, CommandReturnObject &result)
 996     {
 997         Process *process = m_exe_ctx.GetProcessPtr();
 998         result.AppendMessageWithFormat ("Detaching from process %" PRIu64 "\n", process->GetID());
 999         // FIXME: This will be a Command Option:
1000         bool keep_stopped;
1001         if (m_options.m_keep_stopped == eLazyBoolCalculate)
1002         {
1003             // Check the process default:
1004             if (process->GetDetachKeepsStopped())
1005                 keep_stopped = true;
1006             else
1007                 keep_stopped = false;
1008         }
1009         else if (m_options.m_keep_stopped == eLazyBoolYes)
1010             keep_stopped = true;
1011         else
1012             keep_stopped = false;
1013
1014         Error error (process->Detach(keep_stopped));
1015         if (error.Success())
1016         {
1017             result.SetStatus (eReturnStatusSuccessFinishResult);
1018         }
1019         else
1020         {
1021             result.AppendErrorWithFormat ("Detach failed: %s\n", error.AsCString());
1022             result.SetStatus (eReturnStatusFailed);
1023             return false;
1024         }
1025         return result.Succeeded();
1026     }
1027
1028     CommandOptions m_options;
1029 };
1030
1031 OptionDefinition
1032 CommandObjectProcessDetach::CommandOptions::g_option_table[] =
1033 {
1034 { LLDB_OPT_SET_1, false, "keep-stopped",   's', required_argument, NULL, 0, eArgTypeBoolean, "Whether or not the process should be kept stopped on detach (if possible)." },
1035 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
1036 };
1037
1038 //-------------------------------------------------------------------------
1039 // CommandObjectProcessConnect
1040 //-------------------------------------------------------------------------
1041 #pragma mark CommandObjectProcessConnect
1042
1043 class CommandObjectProcessConnect : public CommandObjectParsed
1044 {
1045 public:
1046
1047     class CommandOptions : public Options
1048     {
1049     public:
1050
1051         CommandOptions (CommandInterpreter &interpreter) :
1052             Options(interpreter)
1053         {
1054             // Keep default values of all options in one place: OptionParsingStarting ()
1055             OptionParsingStarting ();
1056         }
1057
1058         ~CommandOptions ()
1059         {
1060         }
1061
1062         Error
1063         SetOptionValue (uint32_t option_idx, const char *option_arg)
1064         {
1065             Error error;
1066             const int short_option = m_getopt_table[option_idx].val;
1067
1068             switch (short_option)
1069             {
1070             case 'p':
1071                 plugin_name.assign (option_arg);
1072                 break;
1073
1074             default:
1075                 error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
1076                 break;
1077             }
1078             return error;
1079         }
1080
1081         void
1082         OptionParsingStarting ()
1083         {
1084             plugin_name.clear();
1085         }
1086
1087         const OptionDefinition*
1088         GetDefinitions ()
1089         {
1090             return g_option_table;
1091         }
1092
1093         // Options table: Required for subclasses of Options.
1094
1095         static OptionDefinition g_option_table[];
1096
1097         // Instance variables to hold the values for command options.
1098
1099         std::string plugin_name;
1100     };
1101
1102     CommandObjectProcessConnect (CommandInterpreter &interpreter) :
1103         CommandObjectParsed (interpreter,
1104                              "process connect",
1105                              "Connect to a remote debug service.",
1106                              "process connect <remote-url>",
1107                              0),
1108         m_options (interpreter)
1109     {
1110     }
1111
1112     ~CommandObjectProcessConnect ()
1113     {
1114     }
1115
1116
1117     Options *
1118     GetOptions ()
1119     {
1120         return &m_options;
1121     }
1122
1123 protected:
1124     bool
1125     DoExecute (Args& command,
1126              CommandReturnObject &result)
1127     {
1128
1129         TargetSP target_sp (m_interpreter.GetDebugger().GetSelectedTarget());
1130         Error error;
1131         Process *process = m_exe_ctx.GetProcessPtr();
1132         if (process)
1133         {
1134             if (process->IsAlive())
1135             {
1136                 result.AppendErrorWithFormat ("Process %" PRIu64 " is currently being debugged, kill the process before connecting.\n",
1137                                               process->GetID());
1138                 result.SetStatus (eReturnStatusFailed);
1139                 return false;
1140             }
1141         }
1142
1143         if (!target_sp)
1144         {
1145             // If there isn't a current target create one.
1146
1147             error = m_interpreter.GetDebugger().GetTargetList().CreateTarget (m_interpreter.GetDebugger(),
1148                                                                               NULL,
1149                                                                               NULL,
1150                                                                               false,
1151                                                                               NULL, // No platform options
1152                                                                               target_sp);
1153             if (!target_sp || error.Fail())
1154             {
1155                 result.AppendError(error.AsCString("Error creating target"));
1156                 result.SetStatus (eReturnStatusFailed);
1157                 return false;
1158             }
1159             m_interpreter.GetDebugger().GetTargetList().SetSelectedTarget(target_sp.get());
1160         }
1161
1162         if (command.GetArgumentCount() == 1)
1163         {
1164             const char *plugin_name = NULL;
1165             if (!m_options.plugin_name.empty())
1166                 plugin_name = m_options.plugin_name.c_str();
1167
1168             const char *remote_url = command.GetArgumentAtIndex(0);
1169             process = target_sp->CreateProcess (m_interpreter.GetDebugger().GetListener(), plugin_name, NULL).get();
1170
1171             if (process)
1172             {
1173                 error = process->ConnectRemote (&process->GetTarget().GetDebugger().GetOutputStream(), remote_url);
1174
1175                 if (error.Fail())
1176                 {
1177                     result.AppendError(error.AsCString("Remote connect failed"));
1178                     result.SetStatus (eReturnStatusFailed);
1179                     target_sp->DeleteCurrentProcess();
1180                     return false;
1181                 }
1182             }
1183             else
1184             {
1185                 result.AppendErrorWithFormat ("Unable to find process plug-in for remote URL '%s'.\nPlease specify a process plug-in name with the --plugin option, or specify an object file using the \"file\" command.\n",
1186                                               remote_url);
1187                 result.SetStatus (eReturnStatusFailed);
1188             }
1189         }
1190         else
1191         {
1192             result.AppendErrorWithFormat ("'%s' takes exactly one argument:\nUsage: %s\n",
1193                                           m_cmd_name.c_str(),
1194                                           m_cmd_syntax.c_str());
1195             result.SetStatus (eReturnStatusFailed);
1196         }
1197         return result.Succeeded();
1198     }
1199
1200     CommandOptions m_options;
1201 };
1202
1203 OptionDefinition
1204 CommandObjectProcessConnect::CommandOptions::g_option_table[] =
1205 {
1206     { LLDB_OPT_SET_ALL, false, "plugin", 'p', required_argument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
1207     { 0,                false, NULL,      0 , 0,                 NULL, 0, eArgTypeNone,   NULL }
1208 };
1209
1210 //-------------------------------------------------------------------------
1211 // CommandObjectProcessPlugin
1212 //-------------------------------------------------------------------------
1213 #pragma mark CommandObjectProcessPlugin
1214
1215 class CommandObjectProcessPlugin : public CommandObjectProxy
1216 {
1217 public:
1218
1219     CommandObjectProcessPlugin (CommandInterpreter &interpreter) :
1220         CommandObjectProxy (interpreter,
1221                             "process plugin",
1222                             "Send a custom command to the current process plug-in.",
1223                             "process plugin <args>",
1224                             0)
1225     {
1226     }
1227
1228     ~CommandObjectProcessPlugin ()
1229     {
1230     }
1231
1232     virtual CommandObject *
1233     GetProxyCommandObject()
1234     {
1235         Process *process = m_interpreter.GetExecutionContext().GetProcessPtr();
1236         if (process)
1237             return process->GetPluginCommandObject();
1238         return NULL;
1239     }
1240 };
1241
1242
1243 //-------------------------------------------------------------------------
1244 // CommandObjectProcessLoad
1245 //-------------------------------------------------------------------------
1246 #pragma mark CommandObjectProcessLoad
1247
1248 class CommandObjectProcessLoad : public CommandObjectParsed
1249 {
1250 public:
1251
1252     CommandObjectProcessLoad (CommandInterpreter &interpreter) :
1253         CommandObjectParsed (interpreter,
1254                              "process load",
1255                              "Load a shared library into the current process.",
1256                              "process load <filename> [<filename> ...]",
1257                              eFlagRequiresProcess       |
1258                              eFlagTryTargetAPILock      |
1259                              eFlagProcessMustBeLaunched |
1260                              eFlagProcessMustBePaused   )
1261     {
1262     }
1263
1264     ~CommandObjectProcessLoad ()
1265     {
1266     }
1267
1268 protected:
1269     bool
1270     DoExecute (Args& command,
1271              CommandReturnObject &result)
1272     {
1273         Process *process = m_exe_ctx.GetProcessPtr();
1274
1275         const size_t argc = command.GetArgumentCount();
1276
1277         for (uint32_t i=0; i<argc; ++i)
1278         {
1279             Error error;
1280             const char *image_path = command.GetArgumentAtIndex(i);
1281             FileSpec image_spec (image_path, false);
1282             process->GetTarget().GetPlatform()->ResolveRemotePath(image_spec, image_spec);
1283             uint32_t image_token = process->LoadImage(image_spec, error);
1284             if (image_token != LLDB_INVALID_IMAGE_TOKEN)
1285             {
1286                 result.AppendMessageWithFormat ("Loading \"%s\"...ok\nImage %u loaded.\n", image_path, image_token);
1287                 result.SetStatus (eReturnStatusSuccessFinishResult);
1288             }
1289             else
1290             {
1291                 result.AppendErrorWithFormat ("failed to load '%s': %s", image_path, error.AsCString());
1292                 result.SetStatus (eReturnStatusFailed);
1293             }
1294         }
1295         return result.Succeeded();
1296     }
1297 };
1298
1299
1300 //-------------------------------------------------------------------------
1301 // CommandObjectProcessUnload
1302 //-------------------------------------------------------------------------
1303 #pragma mark CommandObjectProcessUnload
1304
1305 class CommandObjectProcessUnload : public CommandObjectParsed
1306 {
1307 public:
1308
1309     CommandObjectProcessUnload (CommandInterpreter &interpreter) :
1310         CommandObjectParsed (interpreter,
1311                              "process unload",
1312                              "Unload a shared library from the current process using the index returned by a previous call to \"process load\".",
1313                              "process unload <index>",
1314                              eFlagRequiresProcess       |
1315                              eFlagTryTargetAPILock      |
1316                              eFlagProcessMustBeLaunched |
1317                              eFlagProcessMustBePaused   )
1318     {
1319     }
1320
1321     ~CommandObjectProcessUnload ()
1322     {
1323     }
1324
1325 protected:
1326     bool
1327     DoExecute (Args& command,
1328              CommandReturnObject &result)
1329     {
1330         Process *process = m_exe_ctx.GetProcessPtr();
1331
1332         const size_t argc = command.GetArgumentCount();
1333
1334         for (uint32_t i=0; i<argc; ++i)
1335         {
1336             const char *image_token_cstr = command.GetArgumentAtIndex(i);
1337             uint32_t image_token = Args::StringToUInt32(image_token_cstr, LLDB_INVALID_IMAGE_TOKEN, 0);
1338             if (image_token == LLDB_INVALID_IMAGE_TOKEN)
1339             {
1340                 result.AppendErrorWithFormat ("invalid image index argument '%s'", image_token_cstr);
1341                 result.SetStatus (eReturnStatusFailed);
1342                 break;
1343             }
1344             else
1345             {
1346                 Error error (process->UnloadImage(image_token));
1347                 if (error.Success())
1348                 {
1349                     result.AppendMessageWithFormat ("Unloading shared library with index %u...ok\n", image_token);
1350                     result.SetStatus (eReturnStatusSuccessFinishResult);
1351                 }
1352                 else
1353                 {
1354                     result.AppendErrorWithFormat ("failed to unload image: %s", error.AsCString());
1355                     result.SetStatus (eReturnStatusFailed);
1356                     break;
1357                 }
1358             }
1359         }
1360         return result.Succeeded();
1361     }
1362 };
1363
1364 //-------------------------------------------------------------------------
1365 // CommandObjectProcessSignal
1366 //-------------------------------------------------------------------------
1367 #pragma mark CommandObjectProcessSignal
1368
1369 class CommandObjectProcessSignal : public CommandObjectParsed
1370 {
1371 public:
1372
1373     CommandObjectProcessSignal (CommandInterpreter &interpreter) :
1374         CommandObjectParsed (interpreter,
1375                              "process signal",
1376                              "Send a UNIX signal to the current process being debugged.",
1377                              NULL,
1378                              eFlagRequiresProcess | eFlagTryTargetAPILock)
1379     {
1380         CommandArgumentEntry arg;
1381         CommandArgumentData signal_arg;
1382
1383         // Define the first (and only) variant of this arg.
1384         signal_arg.arg_type = eArgTypeUnixSignal;
1385         signal_arg.arg_repetition = eArgRepeatPlain;
1386
1387         // There is only one variant this argument could be; put it into the argument entry.
1388         arg.push_back (signal_arg);
1389
1390         // Push the data for the first argument into the m_arguments vector.
1391         m_arguments.push_back (arg);
1392     }
1393
1394     ~CommandObjectProcessSignal ()
1395     {
1396     }
1397
1398 protected:
1399     bool
1400     DoExecute (Args& command,
1401              CommandReturnObject &result)
1402     {
1403         Process *process = m_exe_ctx.GetProcessPtr();
1404
1405         if (command.GetArgumentCount() == 1)
1406         {
1407             int signo = LLDB_INVALID_SIGNAL_NUMBER;
1408
1409             const char *signal_name = command.GetArgumentAtIndex(0);
1410             if (::isxdigit (signal_name[0]))
1411                 signo = Args::StringToSInt32(signal_name, LLDB_INVALID_SIGNAL_NUMBER, 0);
1412             else
1413                 signo = process->GetUnixSignals().GetSignalNumberFromName (signal_name);
1414
1415             if (signo == LLDB_INVALID_SIGNAL_NUMBER)
1416             {
1417                 result.AppendErrorWithFormat ("Invalid signal argument '%s'.\n", command.GetArgumentAtIndex(0));
1418                 result.SetStatus (eReturnStatusFailed);
1419             }
1420             else
1421             {
1422                 Error error (process->Signal (signo));
1423                 if (error.Success())
1424                 {
1425                     result.SetStatus (eReturnStatusSuccessFinishResult);
1426                 }
1427                 else
1428                 {
1429                     result.AppendErrorWithFormat ("Failed to send signal %i: %s\n", signo, error.AsCString());
1430                     result.SetStatus (eReturnStatusFailed);
1431                 }
1432             }
1433         }
1434         else
1435         {
1436             result.AppendErrorWithFormat("'%s' takes exactly one signal number argument:\nUsage: %s\n", m_cmd_name.c_str(),
1437                                         m_cmd_syntax.c_str());
1438             result.SetStatus (eReturnStatusFailed);
1439         }
1440         return result.Succeeded();
1441     }
1442 };
1443
1444
1445 //-------------------------------------------------------------------------
1446 // CommandObjectProcessInterrupt
1447 //-------------------------------------------------------------------------
1448 #pragma mark CommandObjectProcessInterrupt
1449
1450 class CommandObjectProcessInterrupt : public CommandObjectParsed
1451 {
1452 public:
1453
1454
1455     CommandObjectProcessInterrupt (CommandInterpreter &interpreter) :
1456         CommandObjectParsed (interpreter,
1457                              "process interrupt",
1458                              "Interrupt the current process being debugged.",
1459                              "process interrupt",
1460                              eFlagRequiresProcess      |
1461                              eFlagTryTargetAPILock     |
1462                              eFlagProcessMustBeLaunched)
1463     {
1464     }
1465
1466     ~CommandObjectProcessInterrupt ()
1467     {
1468     }
1469
1470 protected:
1471     bool
1472     DoExecute (Args& command,
1473                CommandReturnObject &result)
1474     {
1475         Process *process = m_exe_ctx.GetProcessPtr();
1476         if (process == NULL)
1477         {
1478             result.AppendError ("no process to halt");
1479             result.SetStatus (eReturnStatusFailed);
1480             return false;
1481         }
1482
1483         if (command.GetArgumentCount() == 0)
1484         {
1485             bool clear_thread_plans = true;
1486             Error error(process->Halt (clear_thread_plans));
1487             if (error.Success())
1488             {
1489                 result.SetStatus (eReturnStatusSuccessFinishResult);
1490             }
1491             else
1492             {
1493                 result.AppendErrorWithFormat ("Failed to halt process: %s\n", error.AsCString());
1494                 result.SetStatus (eReturnStatusFailed);
1495             }
1496         }
1497         else
1498         {
1499             result.AppendErrorWithFormat("'%s' takes no arguments:\nUsage: %s\n",
1500                                         m_cmd_name.c_str(),
1501                                         m_cmd_syntax.c_str());
1502             result.SetStatus (eReturnStatusFailed);
1503         }
1504         return result.Succeeded();
1505     }
1506 };
1507
1508 //-------------------------------------------------------------------------
1509 // CommandObjectProcessKill
1510 //-------------------------------------------------------------------------
1511 #pragma mark CommandObjectProcessKill
1512
1513 class CommandObjectProcessKill : public CommandObjectParsed
1514 {
1515 public:
1516
1517     CommandObjectProcessKill (CommandInterpreter &interpreter) :
1518         CommandObjectParsed (interpreter,
1519                              "process kill",
1520                              "Terminate the current process being debugged.",
1521                              "process kill",
1522                              eFlagRequiresProcess      |
1523                              eFlagTryTargetAPILock     |
1524                              eFlagProcessMustBeLaunched)
1525     {
1526     }
1527
1528     ~CommandObjectProcessKill ()
1529     {
1530     }
1531
1532 protected:
1533     bool
1534     DoExecute (Args& command,
1535              CommandReturnObject &result)
1536     {
1537         Process *process = m_exe_ctx.GetProcessPtr();
1538         if (process == NULL)
1539         {
1540             result.AppendError ("no process to kill");
1541             result.SetStatus (eReturnStatusFailed);
1542             return false;
1543         }
1544
1545         if (command.GetArgumentCount() == 0)
1546         {
1547             Error error (process->Destroy());
1548             if (error.Success())
1549             {
1550                 result.SetStatus (eReturnStatusSuccessFinishResult);
1551             }
1552             else
1553             {
1554                 result.AppendErrorWithFormat ("Failed to kill process: %s\n", error.AsCString());
1555                 result.SetStatus (eReturnStatusFailed);
1556             }
1557         }
1558         else
1559         {
1560             result.AppendErrorWithFormat("'%s' takes no arguments:\nUsage: %s\n",
1561                                         m_cmd_name.c_str(),
1562                                         m_cmd_syntax.c_str());
1563             result.SetStatus (eReturnStatusFailed);
1564         }
1565         return result.Succeeded();
1566     }
1567 };
1568
1569 //-------------------------------------------------------------------------
1570 // CommandObjectProcessStatus
1571 //-------------------------------------------------------------------------
1572 #pragma mark CommandObjectProcessStatus
1573
1574 class CommandObjectProcessStatus : public CommandObjectParsed
1575 {
1576 public:
1577     CommandObjectProcessStatus (CommandInterpreter &interpreter) :
1578         CommandObjectParsed (interpreter,
1579                              "process status",
1580                              "Show the current status and location of executing process.",
1581                              "process status",
1582                              eFlagRequiresProcess | eFlagTryTargetAPILock)
1583     {
1584     }
1585
1586     ~CommandObjectProcessStatus()
1587     {
1588     }
1589
1590
1591     bool
1592     DoExecute (Args& command, CommandReturnObject &result)
1593     {
1594         Stream &strm = result.GetOutputStream();
1595         result.SetStatus (eReturnStatusSuccessFinishNoResult);
1596         // No need to check "process" for validity as eFlagRequiresProcess ensures it is valid
1597         Process *process = m_exe_ctx.GetProcessPtr();
1598         const bool only_threads_with_stop_reason = true;
1599         const uint32_t start_frame = 0;
1600         const uint32_t num_frames = 1;
1601         const uint32_t num_frames_with_source = 1;
1602         process->GetStatus(strm);
1603         process->GetThreadStatus (strm,
1604                                   only_threads_with_stop_reason,
1605                                   start_frame,
1606                                   num_frames,
1607                                   num_frames_with_source);
1608         return result.Succeeded();
1609     }
1610 };
1611
1612 //-------------------------------------------------------------------------
1613 // CommandObjectProcessHandle
1614 //-------------------------------------------------------------------------
1615 #pragma mark CommandObjectProcessHandle
1616
1617 class CommandObjectProcessHandle : public CommandObjectParsed
1618 {
1619 public:
1620
1621     class CommandOptions : public Options
1622     {
1623     public:
1624
1625         CommandOptions (CommandInterpreter &interpreter) :
1626             Options (interpreter)
1627         {
1628             OptionParsingStarting ();
1629         }
1630
1631         ~CommandOptions ()
1632         {
1633         }
1634
1635         Error
1636         SetOptionValue (uint32_t option_idx, const char *option_arg)
1637         {
1638             Error error;
1639             const int short_option = m_getopt_table[option_idx].val;
1640
1641             switch (short_option)
1642             {
1643                 case 's':
1644                     stop = option_arg;
1645                     break;
1646                 case 'n':
1647                     notify = option_arg;
1648                     break;
1649                 case 'p':
1650                     pass = option_arg;
1651                     break;
1652                 default:
1653                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
1654                     break;
1655             }
1656             return error;
1657         }
1658
1659         void
1660         OptionParsingStarting ()
1661         {
1662             stop.clear();
1663             notify.clear();
1664             pass.clear();
1665         }
1666
1667         const OptionDefinition*
1668         GetDefinitions ()
1669         {
1670             return g_option_table;
1671         }
1672
1673         // Options table: Required for subclasses of Options.
1674
1675         static OptionDefinition g_option_table[];
1676
1677         // Instance variables to hold the values for command options.
1678
1679         std::string stop;
1680         std::string notify;
1681         std::string pass;
1682     };
1683
1684
1685     CommandObjectProcessHandle (CommandInterpreter &interpreter) :
1686         CommandObjectParsed (interpreter,
1687                              "process handle",
1688                              "Show or update what the process and debugger should do with various signals received from the OS.",
1689                              NULL),
1690         m_options (interpreter)
1691     {
1692         SetHelpLong ("If no signals are specified, update them all.  If no update option is specified, list the current values.\n");
1693         CommandArgumentEntry arg;
1694         CommandArgumentData signal_arg;
1695
1696         signal_arg.arg_type = eArgTypeUnixSignal;
1697         signal_arg.arg_repetition = eArgRepeatStar;
1698
1699         arg.push_back (signal_arg);
1700
1701         m_arguments.push_back (arg);
1702     }
1703
1704     ~CommandObjectProcessHandle ()
1705     {
1706     }
1707
1708     Options *
1709     GetOptions ()
1710     {
1711         return &m_options;
1712     }
1713
1714     bool
1715     VerifyCommandOptionValue (const std::string &option, int &real_value)
1716     {
1717         bool okay = true;
1718
1719         bool success = false;
1720         bool tmp_value = Args::StringToBoolean (option.c_str(), false, &success);
1721
1722         if (success && tmp_value)
1723             real_value = 1;
1724         else if (success && !tmp_value)
1725             real_value = 0;
1726         else
1727         {
1728             // If the value isn't 'true' or 'false', it had better be 0 or 1.
1729             real_value = Args::StringToUInt32 (option.c_str(), 3);
1730             if (real_value != 0 && real_value != 1)
1731                 okay = false;
1732         }
1733
1734         return okay;
1735     }
1736
1737     void
1738     PrintSignalHeader (Stream &str)
1739     {
1740         str.Printf ("NAME        PASS   STOP   NOTIFY\n");
1741         str.Printf ("==========  =====  =====  ======\n");
1742     }
1743
1744     void
1745     PrintSignal (Stream &str, int32_t signo, const char *sig_name, UnixSignals &signals)
1746     {
1747         bool stop;
1748         bool suppress;
1749         bool notify;
1750
1751         str.Printf ("%-10s  ", sig_name);
1752         if (signals.GetSignalInfo (signo, suppress, stop, notify))
1753         {
1754             bool pass = !suppress;
1755             str.Printf ("%s  %s  %s",
1756                         (pass ? "true " : "false"),
1757                         (stop ? "true " : "false"),
1758                         (notify ? "true " : "false"));
1759         }
1760         str.Printf ("\n");
1761     }
1762
1763     void
1764     PrintSignalInformation (Stream &str, Args &signal_args, int num_valid_signals, UnixSignals &signals)
1765     {
1766         PrintSignalHeader (str);
1767
1768         if (num_valid_signals > 0)
1769         {
1770             size_t num_args = signal_args.GetArgumentCount();
1771             for (size_t i = 0; i < num_args; ++i)
1772             {
1773                 int32_t signo = signals.GetSignalNumberFromName (signal_args.GetArgumentAtIndex (i));
1774                 if (signo != LLDB_INVALID_SIGNAL_NUMBER)
1775                     PrintSignal (str, signo, signal_args.GetArgumentAtIndex (i), signals);
1776             }
1777         }
1778         else // Print info for ALL signals
1779         {
1780             int32_t signo = signals.GetFirstSignalNumber();
1781             while (signo != LLDB_INVALID_SIGNAL_NUMBER)
1782             {
1783                 PrintSignal (str, signo, signals.GetSignalAsCString (signo), signals);
1784                 signo = signals.GetNextSignalNumber (signo);
1785             }
1786         }
1787     }
1788
1789 protected:
1790     bool
1791     DoExecute (Args &signal_args, CommandReturnObject &result)
1792     {
1793         TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
1794
1795         if (!target_sp)
1796         {
1797             result.AppendError ("No current target;"
1798                                 " cannot handle signals until you have a valid target and process.\n");
1799             result.SetStatus (eReturnStatusFailed);
1800             return false;
1801         }
1802
1803         ProcessSP process_sp = target_sp->GetProcessSP();
1804
1805         if (!process_sp)
1806         {
1807             result.AppendError ("No current process; cannot handle signals until you have a valid process.\n");
1808             result.SetStatus (eReturnStatusFailed);
1809             return false;
1810         }
1811
1812         int stop_action = -1;   // -1 means leave the current setting alone
1813         int pass_action = -1;   // -1 means leave the current setting alone
1814         int notify_action = -1; // -1 means leave the current setting alone
1815
1816         if (! m_options.stop.empty()
1817             && ! VerifyCommandOptionValue (m_options.stop, stop_action))
1818         {
1819             result.AppendError ("Invalid argument for command option --stop; must be true or false.\n");
1820             result.SetStatus (eReturnStatusFailed);
1821             return false;
1822         }
1823
1824         if (! m_options.notify.empty()
1825             && ! VerifyCommandOptionValue (m_options.notify, notify_action))
1826         {
1827             result.AppendError ("Invalid argument for command option --notify; must be true or false.\n");
1828             result.SetStatus (eReturnStatusFailed);
1829             return false;
1830         }
1831
1832         if (! m_options.pass.empty()
1833             && ! VerifyCommandOptionValue (m_options.pass, pass_action))
1834         {
1835             result.AppendError ("Invalid argument for command option --pass; must be true or false.\n");
1836             result.SetStatus (eReturnStatusFailed);
1837             return false;
1838         }
1839
1840         size_t num_args = signal_args.GetArgumentCount();
1841         UnixSignals &signals = process_sp->GetUnixSignals();
1842         int num_signals_set = 0;
1843
1844         if (num_args > 0)
1845         {
1846             for (size_t i = 0; i < num_args; ++i)
1847             {
1848                 int32_t signo = signals.GetSignalNumberFromName (signal_args.GetArgumentAtIndex (i));
1849                 if (signo != LLDB_INVALID_SIGNAL_NUMBER)
1850                 {
1851                     // Casting the actions as bools here should be okay, because VerifyCommandOptionValue guarantees
1852                     // the value is either 0 or 1.
1853                     if (stop_action != -1)
1854                         signals.SetShouldStop (signo, (bool) stop_action);
1855                     if (pass_action != -1)
1856                     {
1857                         bool suppress = ! ((bool) pass_action);
1858                         signals.SetShouldSuppress (signo, suppress);
1859                     }
1860                     if (notify_action != -1)
1861                         signals.SetShouldNotify (signo, (bool) notify_action);
1862                     ++num_signals_set;
1863                 }
1864                 else
1865                 {
1866                     result.AppendErrorWithFormat ("Invalid signal name '%s'\n", signal_args.GetArgumentAtIndex (i));
1867                 }
1868             }
1869         }
1870         else
1871         {
1872             // No signal specified, if any command options were specified, update ALL signals.
1873             if ((notify_action != -1) || (stop_action != -1) || (pass_action != -1))
1874             {
1875                 if (m_interpreter.Confirm ("Do you really want to update all the signals?", false))
1876                 {
1877                     int32_t signo = signals.GetFirstSignalNumber();
1878                     while (signo != LLDB_INVALID_SIGNAL_NUMBER)
1879                     {
1880                         if (notify_action != -1)
1881                             signals.SetShouldNotify (signo, (bool) notify_action);
1882                         if (stop_action != -1)
1883                             signals.SetShouldStop (signo, (bool) stop_action);
1884                         if (pass_action != -1)
1885                         {
1886                             bool suppress = ! ((bool) pass_action);
1887                             signals.SetShouldSuppress (signo, suppress);
1888                         }
1889                         signo = signals.GetNextSignalNumber (signo);
1890                     }
1891                 }
1892             }
1893         }
1894
1895         PrintSignalInformation (result.GetOutputStream(), signal_args, num_signals_set, signals);
1896
1897         if (num_signals_set > 0)
1898             result.SetStatus (eReturnStatusSuccessFinishNoResult);
1899         else
1900             result.SetStatus (eReturnStatusFailed);
1901
1902         return result.Succeeded();
1903     }
1904
1905     CommandOptions m_options;
1906 };
1907
1908 OptionDefinition
1909 CommandObjectProcessHandle::CommandOptions::g_option_table[] =
1910 {
1911 { LLDB_OPT_SET_1, false, "stop",   's', required_argument, NULL, 0, eArgTypeBoolean, "Whether or not the process should be stopped if the signal is received." },
1912 { LLDB_OPT_SET_1, false, "notify", 'n', required_argument, NULL, 0, eArgTypeBoolean, "Whether or not the debugger should notify the user if the signal is received." },
1913 { LLDB_OPT_SET_1, false, "pass",  'p', required_argument, NULL, 0, eArgTypeBoolean, "Whether or not the signal should be passed to the process." },
1914 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
1915 };
1916
1917 //-------------------------------------------------------------------------
1918 // CommandObjectMultiwordProcess
1919 //-------------------------------------------------------------------------
1920
1921 CommandObjectMultiwordProcess::CommandObjectMultiwordProcess (CommandInterpreter &interpreter) :
1922     CommandObjectMultiword (interpreter,
1923                             "process",
1924                             "A set of commands for operating on a process.",
1925                             "process <subcommand> [<subcommand-options>]")
1926 {
1927     LoadSubCommand ("attach",      CommandObjectSP (new CommandObjectProcessAttach    (interpreter)));
1928     LoadSubCommand ("launch",      CommandObjectSP (new CommandObjectProcessLaunch    (interpreter)));
1929     LoadSubCommand ("continue",    CommandObjectSP (new CommandObjectProcessContinue  (interpreter)));
1930     LoadSubCommand ("connect",     CommandObjectSP (new CommandObjectProcessConnect   (interpreter)));
1931     LoadSubCommand ("detach",      CommandObjectSP (new CommandObjectProcessDetach    (interpreter)));
1932     LoadSubCommand ("load",        CommandObjectSP (new CommandObjectProcessLoad      (interpreter)));
1933     LoadSubCommand ("unload",      CommandObjectSP (new CommandObjectProcessUnload    (interpreter)));
1934     LoadSubCommand ("signal",      CommandObjectSP (new CommandObjectProcessSignal    (interpreter)));
1935     LoadSubCommand ("handle",      CommandObjectSP (new CommandObjectProcessHandle    (interpreter)));
1936     LoadSubCommand ("status",      CommandObjectSP (new CommandObjectProcessStatus    (interpreter)));
1937     LoadSubCommand ("interrupt",   CommandObjectSP (new CommandObjectProcessInterrupt (interpreter)));
1938     LoadSubCommand ("kill",        CommandObjectSP (new CommandObjectProcessKill      (interpreter)));
1939     LoadSubCommand ("plugin",      CommandObjectSP (new CommandObjectProcessPlugin    (interpreter)));
1940 }
1941
1942 CommandObjectMultiwordProcess::~CommandObjectMultiwordProcess ()
1943 {
1944 }
1945