1 //===-- CommandObjectTarget.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 "CommandObjectTarget.h"
11 
12 // C Includes
13 #include <errno.h>
14 
15 // C++ Includes
16 // Other libraries and framework includes
17 // Project includes
18 #include "lldb/Interpreter/Args.h"
19 #include "lldb/Core/Debugger.h"
20 #include "lldb/Core/InputReader.h"
21 #include "lldb/Core/Section.h"
22 #include "lldb/Core/State.h"
23 #include "lldb/Core/Timer.h"
24 #include "lldb/Core/ValueObjectVariable.h"
25 #include "lldb/Interpreter/CommandInterpreter.h"
26 #include "lldb/Interpreter/CommandReturnObject.h"
27 #include "lldb/Interpreter/Options.h"
28 #include "lldb/Interpreter/OptionGroupArchitecture.h"
29 #include "lldb/Interpreter/OptionGroupFile.h"
30 #include "lldb/Interpreter/OptionGroupVariable.h"
31 #include "lldb/Interpreter/OptionGroupPlatform.h"
32 #include "lldb/Interpreter/OptionGroupUInt64.h"
33 #include "lldb/Interpreter/OptionGroupUUID.h"
34 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
35 #include "lldb/Symbol/LineTable.h"
36 #include "lldb/Symbol/ObjectFile.h"
37 #include "lldb/Symbol/SymbolFile.h"
38 #include "lldb/Symbol/SymbolVendor.h"
39 #include "lldb/Symbol/VariableList.h"
40 #include "lldb/Target/Process.h"
41 #include "lldb/Target/StackFrame.h"
42 #include "lldb/Target/Thread.h"
43 #include "lldb/Target/ThreadSpec.h"
44 
45 using namespace lldb;
46 using namespace lldb_private;
47 
48 
49 
50 static void
51 DumpTargetInfo (uint32_t target_idx, Target *target, const char *prefix_cstr, bool show_stopped_process_status, Stream &strm)
52 {
53     const ArchSpec &target_arch = target->GetArchitecture();
54 
55     ModuleSP exe_module_sp (target->GetExecutableModule ());
56     char exe_path[PATH_MAX];
57     bool exe_valid = false;
58     if (exe_module_sp)
59         exe_valid = exe_module_sp->GetFileSpec().GetPath (exe_path, sizeof(exe_path));
60 
61     if (!exe_valid)
62         ::strcpy (exe_path, "<none>");
63 
64     strm.Printf ("%starget #%u: %s", prefix_cstr ? prefix_cstr : "", target_idx, exe_path);
65 
66     uint32_t properties = 0;
67     if (target_arch.IsValid())
68     {
69         strm.Printf ("%sarch=%s", properties++ > 0 ? ", " : " ( ", target_arch.GetTriple().str().c_str());
70         properties++;
71     }
72     PlatformSP platform_sp (target->GetPlatform());
73     if (platform_sp)
74         strm.Printf ("%splatform=%s", properties++ > 0 ? ", " : " ( ", platform_sp->GetName());
75 
76     ProcessSP process_sp (target->GetProcessSP());
77     bool show_process_status = false;
78     if (process_sp)
79     {
80         lldb::pid_t pid = process_sp->GetID();
81         StateType state = process_sp->GetState();
82         if (show_stopped_process_status)
83             show_process_status = StateIsStoppedState(state);
84         const char *state_cstr = StateAsCString (state);
85         if (pid != LLDB_INVALID_PROCESS_ID)
86             strm.Printf ("%spid=%i", properties++ > 0 ? ", " : " ( ", pid);
87         strm.Printf ("%sstate=%s", properties++ > 0 ? ", " : " ( ", state_cstr);
88     }
89     if (properties > 0)
90         strm.PutCString (" )\n");
91     else
92         strm.EOL();
93     if (show_process_status)
94     {
95         const bool only_threads_with_stop_reason = true;
96         const uint32_t start_frame = 0;
97         const uint32_t num_frames = 1;
98         const uint32_t num_frames_with_source = 1;
99         process_sp->GetStatus (strm);
100         process_sp->GetThreadStatus (strm,
101                                      only_threads_with_stop_reason,
102                                      start_frame,
103                                      num_frames,
104                                      num_frames_with_source);
105 
106     }
107 }
108 
109 static uint32_t
110 DumpTargetList (TargetList &target_list, bool show_stopped_process_status, Stream &strm)
111 {
112     const uint32_t num_targets = target_list.GetNumTargets();
113     if (num_targets)
114     {
115         TargetSP selected_target_sp (target_list.GetSelectedTarget());
116         strm.PutCString ("Current targets:\n");
117         for (uint32_t i=0; i<num_targets; ++i)
118         {
119             TargetSP target_sp (target_list.GetTargetAtIndex (i));
120             if (target_sp)
121             {
122                 bool is_selected = target_sp.get() == selected_target_sp.get();
123                 DumpTargetInfo (i,
124                                 target_sp.get(),
125                                 is_selected ? "* " : "  ",
126                                 show_stopped_process_status,
127                                 strm);
128             }
129         }
130     }
131     return num_targets;
132 }
133 #pragma mark CommandObjectTargetCreate
134 
135 //-------------------------------------------------------------------------
136 // "target create"
137 //-------------------------------------------------------------------------
138 
139 class CommandObjectTargetCreate : public CommandObject
140 {
141 public:
142     CommandObjectTargetCreate(CommandInterpreter &interpreter) :
143         CommandObject (interpreter,
144                        "target create",
145                        "Create a target using the argument as the main executable.",
146                        NULL),
147         m_option_group (interpreter),
148         m_arch_option (),
149         m_platform_options(true) // Do include the "--platform" option in the platform settings by passing true
150     {
151         CommandArgumentEntry arg;
152         CommandArgumentData file_arg;
153 
154         // Define the first (and only) variant of this arg.
155             file_arg.arg_type = eArgTypeFilename;
156         file_arg.arg_repetition = eArgRepeatPlain;
157 
158         // There is only one variant this argument could be; put it into the argument entry.
159         arg.push_back (file_arg);
160 
161         // Push the data for the first argument into the m_arguments vector.
162         m_arguments.push_back (arg);
163 
164         m_option_group.Append (&m_arch_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
165         m_option_group.Append (&m_platform_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
166         m_option_group.Finalize();
167     }
168 
169     ~CommandObjectTargetCreate ()
170     {
171     }
172 
173     Options *
174     GetOptions ()
175     {
176         return &m_option_group;
177     }
178 
179     bool
180     Execute (Args& command, CommandReturnObject &result)
181     {
182         const int argc = command.GetArgumentCount();
183         if (argc == 1)
184         {
185             const char *file_path = command.GetArgumentAtIndex(0);
186             Timer scoped_timer(__PRETTY_FUNCTION__, "(lldb) target create '%s'", file_path);
187             FileSpec file_spec (file_path, true);
188 
189             bool select = true;
190             PlatformSP platform_sp;
191 
192             Error error;
193 
194             if (m_platform_options.PlatformWasSpecified ())
195             {
196                 platform_sp = m_platform_options.CreatePlatformWithOptions(m_interpreter, select, error);
197                 if (!platform_sp)
198                 {
199                     result.AppendError(error.AsCString());
200                     result.SetStatus (eReturnStatusFailed);
201                     return false;
202                 }
203             }
204             ArchSpec file_arch;
205 
206             const char *arch_cstr = m_arch_option.GetArchitectureName();
207             if (arch_cstr)
208             {
209                 if (!platform_sp)
210                     platform_sp = m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform();
211                 if (!m_arch_option.GetArchitecture(platform_sp.get(), file_arch))
212                 {
213                     result.AppendErrorWithFormat("invalid architecture '%s'\n", arch_cstr);
214                     result.SetStatus (eReturnStatusFailed);
215                     return false;
216                 }
217             }
218 
219             if (! file_spec.Exists() && !file_spec.ResolveExecutableLocation())
220             {
221                 result.AppendErrorWithFormat ("File '%s' does not exist.\n", file_path);
222                 result.SetStatus (eReturnStatusFailed);
223                 return false;
224             }
225 
226             TargetSP target_sp;
227             Debugger &debugger = m_interpreter.GetDebugger();
228             error = debugger.GetTargetList().CreateTarget (debugger, file_spec, file_arch, true, target_sp);
229 
230             if (target_sp)
231             {
232                 debugger.GetTargetList().SetSelectedTarget(target_sp.get());
233                 result.AppendMessageWithFormat ("Current executable set to '%s' (%s).\n", file_path, target_sp->GetArchitecture().GetArchitectureName());
234                 result.SetStatus (eReturnStatusSuccessFinishNoResult);
235             }
236             else
237             {
238                 result.AppendError(error.AsCString());
239                 result.SetStatus (eReturnStatusFailed);
240             }
241         }
242         else
243         {
244             result.AppendErrorWithFormat("'%s' takes exactly one executable path argument.\n", m_cmd_name.c_str());
245             result.SetStatus (eReturnStatusFailed);
246         }
247         return result.Succeeded();
248 
249     }
250 
251     int
252     HandleArgumentCompletion (Args &input,
253                               int &cursor_index,
254                               int &cursor_char_position,
255                               OptionElementVector &opt_element_vector,
256                               int match_start_point,
257                               int max_return_elements,
258                               bool &word_complete,
259                               StringList &matches)
260     {
261         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
262         completion_str.erase (cursor_char_position);
263 
264         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
265                                                              CommandCompletions::eDiskFileCompletion,
266                                                              completion_str.c_str(),
267                                                              match_start_point,
268                                                              max_return_elements,
269                                                              NULL,
270                                                              word_complete,
271                                                              matches);
272         return matches.GetSize();
273     }
274 private:
275     OptionGroupOptions m_option_group;
276     OptionGroupArchitecture m_arch_option;
277     OptionGroupPlatform m_platform_options;
278 
279 };
280 
281 #pragma mark CommandObjectTargetList
282 
283 //----------------------------------------------------------------------
284 // "target list"
285 //----------------------------------------------------------------------
286 
287 class CommandObjectTargetList : public CommandObject
288 {
289 public:
290     CommandObjectTargetList (CommandInterpreter &interpreter) :
291         CommandObject (interpreter,
292                        "target list",
293                        "List all current targets in the current debug session.",
294                        NULL,
295                        0)
296     {
297     }
298 
299     virtual
300     ~CommandObjectTargetList ()
301     {
302     }
303 
304     virtual bool
305     Execute (Args& args, CommandReturnObject &result)
306     {
307         if (args.GetArgumentCount() == 0)
308         {
309             Stream &strm = result.GetOutputStream();
310 
311             bool show_stopped_process_status = false;
312             if (DumpTargetList (m_interpreter.GetDebugger().GetTargetList(), show_stopped_process_status, strm) == 0)
313             {
314                 strm.PutCString ("No targets.\n");
315             }
316             result.SetStatus (eReturnStatusSuccessFinishResult);
317         }
318         else
319         {
320             result.AppendError ("the 'target list' command takes no arguments\n");
321             result.SetStatus (eReturnStatusFailed);
322         }
323         return result.Succeeded();
324     }
325 };
326 
327 
328 #pragma mark CommandObjectTargetSelect
329 
330 //----------------------------------------------------------------------
331 // "target select"
332 //----------------------------------------------------------------------
333 
334 class CommandObjectTargetSelect : public CommandObject
335 {
336 public:
337     CommandObjectTargetSelect (CommandInterpreter &interpreter) :
338         CommandObject (interpreter,
339                        "target select",
340                        "Select a target as the current target by target index.",
341                        NULL,
342                        0)
343     {
344     }
345 
346     virtual
347     ~CommandObjectTargetSelect ()
348     {
349     }
350 
351     virtual bool
352     Execute (Args& args, CommandReturnObject &result)
353     {
354         if (args.GetArgumentCount() == 1)
355         {
356             bool success = false;
357             const char *target_idx_arg = args.GetArgumentAtIndex(0);
358             uint32_t target_idx = Args::StringToUInt32 (target_idx_arg, UINT32_MAX, 0, &success);
359             if (success)
360             {
361                 TargetList &target_list = m_interpreter.GetDebugger().GetTargetList();
362                 const uint32_t num_targets = target_list.GetNumTargets();
363                 if (target_idx < num_targets)
364                 {
365                     TargetSP target_sp (target_list.GetTargetAtIndex (target_idx));
366                     if (target_sp)
367                     {
368                         Stream &strm = result.GetOutputStream();
369                         target_list.SetSelectedTarget (target_sp.get());
370                         bool show_stopped_process_status = false;
371                         DumpTargetList (target_list, show_stopped_process_status, strm);
372                         result.SetStatus (eReturnStatusSuccessFinishResult);
373                     }
374                     else
375                     {
376                         result.AppendErrorWithFormat ("target #%u is NULL in target list\n", target_idx);
377                         result.SetStatus (eReturnStatusFailed);
378                     }
379                 }
380                 else
381                 {
382                     result.AppendErrorWithFormat ("index %u is out of range, valid target indexes are 0 - %u\n",
383                                                   target_idx,
384                                                   num_targets - 1);
385                     result.SetStatus (eReturnStatusFailed);
386                 }
387             }
388             else
389             {
390                 result.AppendErrorWithFormat("invalid index string value '%s'\n", target_idx_arg);
391                 result.SetStatus (eReturnStatusFailed);
392             }
393         }
394         else
395         {
396             result.AppendError ("'target select' takes a single argument: a target index\n");
397             result.SetStatus (eReturnStatusFailed);
398         }
399         return result.Succeeded();
400     }
401 };
402 
403 
404 #pragma mark CommandObjectTargetVariable
405 
406 //----------------------------------------------------------------------
407 // "target variable"
408 //----------------------------------------------------------------------
409 
410 class CommandObjectTargetVariable : public CommandObject
411 {
412 public:
413     CommandObjectTargetVariable (CommandInterpreter &interpreter) :
414         CommandObject (interpreter,
415                        "target select",
416                        "Select a target as the current target by target index.",
417                        NULL,
418                        0),
419         m_option_group (interpreter),
420         m_option_variable (false), // Don't include frame options
421         m_option_compile_units    (LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypePath, "A basename or fullpath to a file that contains global variables. This option can be specified multiple times."),
422         m_option_shared_libraries (LLDB_OPT_SET_1, false, "shlib",'s', 0, eArgTypePath, "A basename or fullpath to a shared library to use in the search for global variables. This option can be specified multiple times."),
423         m_varobj_options()
424     {
425         m_option_group.Append (&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
426         m_option_group.Append (&m_option_variable, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
427         m_option_group.Append (&m_option_compile_units, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
428         m_option_group.Append (&m_option_shared_libraries, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
429         m_option_group.Finalize();
430     }
431 
432     virtual
433     ~CommandObjectTargetVariable ()
434     {
435     }
436 
437     virtual bool
438     Execute (Args& args, CommandReturnObject &result)
439     {
440         ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
441 
442         if (exe_ctx.target)
443         {
444             const size_t argc = args.GetArgumentCount();
445             if (argc > 0)
446             {
447                 for (size_t idx = 0; idx < argc; ++idx)
448                 {
449                     VariableList global_var_list;
450                     const char *arg = args.GetArgumentAtIndex(idx);
451                     uint32_t matches = 0;
452                     if (m_option_variable.use_regex)
453                     {
454                         RegularExpression regex(arg);
455                         if (!regex.IsValid ())
456                         {
457                             result.GetErrorStream().Printf ("error: invalid regular expression: '%s'\n", arg);
458                             result.SetStatus (eReturnStatusFailed);
459                             return false;
460                         }
461                         matches = exe_ctx.target->GetImages().FindGlobalVariables (regex,
462                                                                                    true,
463                                                                                    UINT32_MAX,
464                                                                                    global_var_list);
465                     }
466                     else
467                     {
468                         matches = exe_ctx.target->GetImages().FindGlobalVariables (ConstString(arg),
469                                                                                    true,
470                                                                                    UINT32_MAX,
471                                                                                    global_var_list);
472                     }
473 
474                     if (matches == 0)
475                     {
476                         result.GetErrorStream().Printf ("error: can't find global variable '%s'\n", arg);
477                         result.SetStatus (eReturnStatusFailed);
478                         return false;
479                     }
480                     else
481                     {
482                         Stream &s = result.GetOutputStream();
483                         for (uint32_t global_idx=0; global_idx<matches; ++global_idx)
484                         {
485                             VariableSP var_sp (global_var_list.GetVariableAtIndex(global_idx));
486                             if (var_sp)
487                             {
488                                 ValueObjectSP valobj_sp(ValueObjectVariable::Create (exe_ctx.target, var_sp));
489 
490                                 if (valobj_sp)
491                                 {
492                                     if (m_option_variable.format != eFormatDefault)
493                                         valobj_sp->SetFormat (m_option_variable.format);
494 
495                                     switch (var_sp->GetScope())
496                                     {
497                                         case eValueTypeVariableGlobal:
498                                             if (m_option_variable.show_scope)
499                                                 s.PutCString("GLOBAL: ");
500                                             break;
501 
502                                         case eValueTypeVariableStatic:
503                                             if (m_option_variable.show_scope)
504                                                 s.PutCString("STATIC: ");
505                                             break;
506 
507                                         case eValueTypeVariableArgument:
508                                             if (m_option_variable.show_scope)
509                                                 s.PutCString("   ARG: ");
510                                             break;
511 
512                                         case eValueTypeVariableLocal:
513                                             if (m_option_variable.show_scope)
514                                                 s.PutCString(" LOCAL: ");
515                                             break;
516 
517                                         default:
518                                             break;
519                                     }
520 
521                                     if (m_option_variable.show_decl && var_sp->GetDeclaration ().GetFile())
522                                     {
523                                         var_sp->GetDeclaration ().DumpStopContext (&s, false);
524                                         s.PutCString (": ");
525                                     }
526 
527                                     const Format format = m_option_variable.format;
528                                     if (format != eFormatDefault)
529                                         valobj_sp->SetFormat (format);
530 
531                                     ValueObject::DumpValueObject (s,
532                                                                   valobj_sp.get(),
533                                                                   var_sp->GetName().GetCString(),
534                                                                   m_varobj_options.ptr_depth,
535                                                                   0,
536                                                                   m_varobj_options.max_depth,
537                                                                   m_varobj_options.show_types,
538                                                                   m_varobj_options.show_location,
539                                                                   m_varobj_options.use_objc,
540                                                                   m_varobj_options.use_dynamic,
541                                                                   false,
542                                                                   m_varobj_options.flat_output);
543                                 }
544                             }
545                         }
546                     }
547                 }
548             }
549             else
550             {
551                 result.AppendError ("'target variable' takes one or more global variable names as arguments\n");
552                 result.SetStatus (eReturnStatusFailed);
553             }
554         }
555         else
556         {
557             result.AppendError ("invalid target, create a debug target using the 'target create' command");
558             result.SetStatus (eReturnStatusFailed);
559             return false;
560         }
561         return result.Succeeded();
562     }
563 
564     Options *
565     GetOptions ()
566     {
567         return &m_option_group;
568     }
569 
570 protected:
571     OptionGroupOptions m_option_group;
572     OptionGroupVariable m_option_variable;
573     OptionGroupFileList m_option_compile_units;
574     OptionGroupFileList m_option_shared_libraries;
575     OptionGroupValueObjectDisplay m_varobj_options;
576 
577 };
578 
579 
580 #pragma mark CommandObjectTargetModulesSearchPathsAdd
581 
582 class CommandObjectTargetModulesSearchPathsAdd : public CommandObject
583 {
584 public:
585 
586     CommandObjectTargetModulesSearchPathsAdd (CommandInterpreter &interpreter) :
587         CommandObject (interpreter,
588                        "target modules search-paths add",
589                        "Add new image search paths substitution pairs to the current target.",
590                        NULL)
591     {
592         CommandArgumentEntry arg;
593         CommandArgumentData old_prefix_arg;
594         CommandArgumentData new_prefix_arg;
595 
596         // Define the first variant of this arg pair.
597         old_prefix_arg.arg_type = eArgTypeOldPathPrefix;
598         old_prefix_arg.arg_repetition = eArgRepeatPairPlus;
599 
600         // Define the first variant of this arg pair.
601         new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
602         new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
603 
604         // There are two required arguments that must always occur together, i.e. an argument "pair".  Because they
605         // must always occur together, they are treated as two variants of one argument rather than two independent
606         // arguments.  Push them both into the first argument position for m_arguments...
607 
608         arg.push_back (old_prefix_arg);
609         arg.push_back (new_prefix_arg);
610 
611         m_arguments.push_back (arg);
612     }
613 
614     ~CommandObjectTargetModulesSearchPathsAdd ()
615     {
616     }
617 
618     bool
619     Execute (Args& command,
620              CommandReturnObject &result)
621     {
622         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
623         if (target)
624         {
625             uint32_t argc = command.GetArgumentCount();
626             if (argc & 1)
627             {
628                 result.AppendError ("add requires an even number of arguments\n");
629                 result.SetStatus (eReturnStatusFailed);
630             }
631             else
632             {
633                 for (uint32_t i=0; i<argc; i+=2)
634                 {
635                     const char *from = command.GetArgumentAtIndex(i);
636                     const char *to = command.GetArgumentAtIndex(i+1);
637 
638                     if (from[0] && to[0])
639                     {
640                         bool last_pair = ((argc - i) == 2);
641                         target->GetImageSearchPathList().Append (ConstString(from),
642                                                                  ConstString(to),
643                                                                  last_pair); // Notify if this is the last pair
644                         result.SetStatus (eReturnStatusSuccessFinishNoResult);
645                     }
646                     else
647                     {
648                         if (from[0])
649                             result.AppendError ("<path-prefix> can't be empty\n");
650                         else
651                             result.AppendError ("<new-path-prefix> can't be empty\n");
652                         result.SetStatus (eReturnStatusFailed);
653                     }
654                 }
655             }
656         }
657         else
658         {
659             result.AppendError ("invalid target\n");
660             result.SetStatus (eReturnStatusFailed);
661         }
662         return result.Succeeded();
663     }
664 };
665 
666 #pragma mark CommandObjectTargetModulesSearchPathsClear
667 
668 class CommandObjectTargetModulesSearchPathsClear : public CommandObject
669 {
670 public:
671 
672     CommandObjectTargetModulesSearchPathsClear (CommandInterpreter &interpreter) :
673         CommandObject (interpreter,
674                        "target modules search-paths clear",
675                        "Clear all current image search path substitution pairs from the current target.",
676                        "target modules search-paths clear")
677     {
678     }
679 
680     ~CommandObjectTargetModulesSearchPathsClear ()
681     {
682     }
683 
684     bool
685     Execute (Args& command,
686              CommandReturnObject &result)
687     {
688         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
689         if (target)
690         {
691             bool notify = true;
692             target->GetImageSearchPathList().Clear(notify);
693             result.SetStatus (eReturnStatusSuccessFinishNoResult);
694         }
695         else
696         {
697             result.AppendError ("invalid target\n");
698             result.SetStatus (eReturnStatusFailed);
699         }
700         return result.Succeeded();
701     }
702 };
703 
704 #pragma mark CommandObjectTargetModulesSearchPathsInsert
705 
706 class CommandObjectTargetModulesSearchPathsInsert : public CommandObject
707 {
708 public:
709 
710     CommandObjectTargetModulesSearchPathsInsert (CommandInterpreter &interpreter) :
711         CommandObject (interpreter,
712                        "target modules search-paths insert",
713                        "Insert a new image search path substitution pair into the current target at the specified index.",
714                        NULL)
715     {
716         CommandArgumentEntry arg1;
717         CommandArgumentEntry arg2;
718         CommandArgumentData index_arg;
719         CommandArgumentData old_prefix_arg;
720         CommandArgumentData new_prefix_arg;
721 
722         // Define the first and only variant of this arg.
723         index_arg.arg_type = eArgTypeIndex;
724         index_arg.arg_repetition = eArgRepeatPlain;
725 
726         // Put the one and only variant into the first arg for m_arguments:
727         arg1.push_back (index_arg);
728 
729         // Define the first variant of this arg pair.
730         old_prefix_arg.arg_type = eArgTypeOldPathPrefix;
731         old_prefix_arg.arg_repetition = eArgRepeatPairPlus;
732 
733         // Define the first variant of this arg pair.
734         new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
735         new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
736 
737         // There are two required arguments that must always occur together, i.e. an argument "pair".  Because they
738         // must always occur together, they are treated as two variants of one argument rather than two independent
739         // arguments.  Push them both into the same argument position for m_arguments...
740 
741         arg2.push_back (old_prefix_arg);
742         arg2.push_back (new_prefix_arg);
743 
744         // Add arguments to m_arguments.
745         m_arguments.push_back (arg1);
746         m_arguments.push_back (arg2);
747     }
748 
749     ~CommandObjectTargetModulesSearchPathsInsert ()
750     {
751     }
752 
753     bool
754     Execute (Args& command,
755              CommandReturnObject &result)
756     {
757         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
758         if (target)
759         {
760             uint32_t argc = command.GetArgumentCount();
761             // check for at least 3 arguments and an odd nubmer of parameters
762             if (argc >= 3 && argc & 1)
763             {
764                 bool success = false;
765 
766                 uint32_t insert_idx = Args::StringToUInt32(command.GetArgumentAtIndex(0), UINT32_MAX, 0, &success);
767 
768                 if (!success)
769                 {
770                     result.AppendErrorWithFormat("<index> parameter is not an integer: '%s'.\n", command.GetArgumentAtIndex(0));
771                     result.SetStatus (eReturnStatusFailed);
772                     return result.Succeeded();
773                 }
774 
775                 // shift off the index
776                 command.Shift();
777                 argc = command.GetArgumentCount();
778 
779                 for (uint32_t i=0; i<argc; i+=2, ++insert_idx)
780                 {
781                     const char *from = command.GetArgumentAtIndex(i);
782                     const char *to = command.GetArgumentAtIndex(i+1);
783 
784                     if (from[0] && to[0])
785                     {
786                         bool last_pair = ((argc - i) == 2);
787                         target->GetImageSearchPathList().Insert (ConstString(from),
788                                                                  ConstString(to),
789                                                                  insert_idx,
790                                                                  last_pair);
791                         result.SetStatus (eReturnStatusSuccessFinishNoResult);
792                     }
793                     else
794                     {
795                         if (from[0])
796                             result.AppendError ("<path-prefix> can't be empty\n");
797                         else
798                             result.AppendError ("<new-path-prefix> can't be empty\n");
799                         result.SetStatus (eReturnStatusFailed);
800                         return false;
801                     }
802                 }
803             }
804             else
805             {
806                 result.AppendError ("insert requires at least three arguments\n");
807                 result.SetStatus (eReturnStatusFailed);
808                 return result.Succeeded();
809             }
810 
811         }
812         else
813         {
814             result.AppendError ("invalid target\n");
815             result.SetStatus (eReturnStatusFailed);
816         }
817         return result.Succeeded();
818     }
819 };
820 
821 
822 #pragma mark CommandObjectTargetModulesSearchPathsList
823 
824 
825 class CommandObjectTargetModulesSearchPathsList : public CommandObject
826 {
827 public:
828 
829     CommandObjectTargetModulesSearchPathsList (CommandInterpreter &interpreter) :
830         CommandObject (interpreter,
831                        "target modules search-paths list",
832                        "List all current image search path substitution pairs in the current target.",
833                        "target modules search-paths list")
834     {
835     }
836 
837     ~CommandObjectTargetModulesSearchPathsList ()
838     {
839     }
840 
841     bool
842     Execute (Args& command,
843              CommandReturnObject &result)
844     {
845         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
846         if (target)
847         {
848             if (command.GetArgumentCount() != 0)
849             {
850                 result.AppendError ("list takes no arguments\n");
851                 result.SetStatus (eReturnStatusFailed);
852                 return result.Succeeded();
853             }
854 
855             target->GetImageSearchPathList().Dump(&result.GetOutputStream());
856             result.SetStatus (eReturnStatusSuccessFinishResult);
857         }
858         else
859         {
860             result.AppendError ("invalid target\n");
861             result.SetStatus (eReturnStatusFailed);
862         }
863         return result.Succeeded();
864     }
865 };
866 
867 #pragma mark CommandObjectTargetModulesSearchPathsQuery
868 
869 class CommandObjectTargetModulesSearchPathsQuery : public CommandObject
870 {
871 public:
872 
873     CommandObjectTargetModulesSearchPathsQuery (CommandInterpreter &interpreter) :
874     CommandObject (interpreter,
875                    "target modules search-paths query",
876                    "Transform a path using the first applicable image search path.",
877                    NULL)
878     {
879         CommandArgumentEntry arg;
880         CommandArgumentData path_arg;
881 
882         // Define the first (and only) variant of this arg.
883         path_arg.arg_type = eArgTypePath;
884         path_arg.arg_repetition = eArgRepeatPlain;
885 
886         // There is only one variant this argument could be; put it into the argument entry.
887         arg.push_back (path_arg);
888 
889         // Push the data for the first argument into the m_arguments vector.
890         m_arguments.push_back (arg);
891     }
892 
893     ~CommandObjectTargetModulesSearchPathsQuery ()
894     {
895     }
896 
897     bool
898     Execute (Args& command,
899              CommandReturnObject &result)
900     {
901         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
902         if (target)
903         {
904             if (command.GetArgumentCount() != 1)
905             {
906                 result.AppendError ("query requires one argument\n");
907                 result.SetStatus (eReturnStatusFailed);
908                 return result.Succeeded();
909             }
910 
911             ConstString orig(command.GetArgumentAtIndex(0));
912             ConstString transformed;
913             if (target->GetImageSearchPathList().RemapPath(orig, transformed))
914                 result.GetOutputStream().Printf("%s\n", transformed.GetCString());
915             else
916                 result.GetOutputStream().Printf("%s\n", orig.GetCString());
917 
918             result.SetStatus (eReturnStatusSuccessFinishResult);
919         }
920         else
921         {
922             result.AppendError ("invalid target\n");
923             result.SetStatus (eReturnStatusFailed);
924         }
925         return result.Succeeded();
926     }
927 };
928 
929 //----------------------------------------------------------------------
930 // Static Helper functions
931 //----------------------------------------------------------------------
932 static void
933 DumpModuleArchitecture (Stream &strm, Module *module, bool full_triple, uint32_t width)
934 {
935     if (module)
936     {
937         const char *arch_cstr;
938         if (full_triple)
939             arch_cstr = module->GetArchitecture().GetTriple().str().c_str();
940         else
941             arch_cstr = module->GetArchitecture().GetArchitectureName();
942         if (width)
943             strm.Printf("%-*s", width, arch_cstr);
944         else
945             strm.PutCString(arch_cstr);
946     }
947 }
948 
949 static void
950 DumpModuleUUID (Stream &strm, Module *module)
951 {
952     module->GetUUID().Dump (&strm);
953 }
954 
955 static uint32_t
956 DumpCompileUnitLineTable
957 (
958  CommandInterpreter &interpreter,
959  Stream &strm,
960  Module *module,
961  const FileSpec &file_spec,
962  bool load_addresses
963  )
964 {
965     uint32_t num_matches = 0;
966     if (module)
967     {
968         SymbolContextList sc_list;
969         num_matches = module->ResolveSymbolContextsForFileSpec (file_spec,
970                                                                 0,
971                                                                 false,
972                                                                 eSymbolContextCompUnit,
973                                                                 sc_list);
974 
975         for (uint32_t i=0; i<num_matches; ++i)
976         {
977             SymbolContext sc;
978             if (sc_list.GetContextAtIndex(i, sc))
979             {
980                 if (i > 0)
981                     strm << "\n\n";
982 
983                 strm << "Line table for " << *static_cast<FileSpec*> (sc.comp_unit) << " in `"
984                 << module->GetFileSpec().GetFilename() << "\n";
985                 LineTable *line_table = sc.comp_unit->GetLineTable();
986                 if (line_table)
987                     line_table->GetDescription (&strm,
988                                                 interpreter.GetExecutionContext().target,
989                                                 lldb::eDescriptionLevelBrief);
990                 else
991                     strm << "No line table";
992             }
993         }
994     }
995     return num_matches;
996 }
997 
998 static void
999 DumpFullpath (Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
1000 {
1001     if (file_spec_ptr)
1002     {
1003         if (width > 0)
1004         {
1005             char fullpath[PATH_MAX];
1006             if (file_spec_ptr->GetPath(fullpath, sizeof(fullpath)))
1007             {
1008                 strm.Printf("%-*s", width, fullpath);
1009                 return;
1010             }
1011         }
1012         else
1013         {
1014             file_spec_ptr->Dump(&strm);
1015             return;
1016         }
1017     }
1018     // Keep the width spacing correct if things go wrong...
1019     if (width > 0)
1020         strm.Printf("%-*s", width, "");
1021 }
1022 
1023 static void
1024 DumpDirectory (Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
1025 {
1026     if (file_spec_ptr)
1027     {
1028         if (width > 0)
1029             strm.Printf("%-*s", width, file_spec_ptr->GetDirectory().AsCString(""));
1030         else
1031             file_spec_ptr->GetDirectory().Dump(&strm);
1032         return;
1033     }
1034     // Keep the width spacing correct if things go wrong...
1035     if (width > 0)
1036         strm.Printf("%-*s", width, "");
1037 }
1038 
1039 static void
1040 DumpBasename (Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
1041 {
1042     if (file_spec_ptr)
1043     {
1044         if (width > 0)
1045             strm.Printf("%-*s", width, file_spec_ptr->GetFilename().AsCString(""));
1046         else
1047             file_spec_ptr->GetFilename().Dump(&strm);
1048         return;
1049     }
1050     // Keep the width spacing correct if things go wrong...
1051     if (width > 0)
1052         strm.Printf("%-*s", width, "");
1053 }
1054 
1055 
1056 static void
1057 DumpModuleSymtab (CommandInterpreter &interpreter, Stream &strm, Module *module, SortOrder sort_order)
1058 {
1059     if (module)
1060     {
1061         ObjectFile *objfile = module->GetObjectFile ();
1062         if (objfile)
1063         {
1064             Symtab *symtab = objfile->GetSymtab();
1065             if (symtab)
1066                 symtab->Dump(&strm, interpreter.GetExecutionContext().target, sort_order);
1067         }
1068     }
1069 }
1070 
1071 static void
1072 DumpModuleSections (CommandInterpreter &interpreter, Stream &strm, Module *module)
1073 {
1074     if (module)
1075     {
1076         ObjectFile *objfile = module->GetObjectFile ();
1077         if (objfile)
1078         {
1079             SectionList *section_list = objfile->GetSectionList();
1080             if (section_list)
1081             {
1082                 strm.PutCString ("Sections for '");
1083                 strm << module->GetFileSpec();
1084                 if (module->GetObjectName())
1085                     strm << '(' << module->GetObjectName() << ')';
1086                 strm.Printf ("' (%s):\n", module->GetArchitecture().GetArchitectureName());
1087                 strm.IndentMore();
1088                 section_list->Dump(&strm, interpreter.GetExecutionContext().target, true, UINT32_MAX);
1089                 strm.IndentLess();
1090             }
1091         }
1092     }
1093 }
1094 
1095 static bool
1096 DumpModuleSymbolVendor (Stream &strm, Module *module)
1097 {
1098     if (module)
1099     {
1100         SymbolVendor *symbol_vendor = module->GetSymbolVendor(true);
1101         if (symbol_vendor)
1102         {
1103             symbol_vendor->Dump(&strm);
1104             return true;
1105         }
1106     }
1107     return false;
1108 }
1109 
1110 static bool
1111 LookupAddressInModule
1112 (
1113  CommandInterpreter &interpreter,
1114  Stream &strm,
1115  Module *module,
1116  uint32_t resolve_mask,
1117  lldb::addr_t raw_addr,
1118  lldb::addr_t offset,
1119  bool verbose
1120  )
1121 {
1122     if (module)
1123     {
1124         lldb::addr_t addr = raw_addr - offset;
1125         Address so_addr;
1126         SymbolContext sc;
1127         Target *target = interpreter.GetExecutionContext().target;
1128         if (target && !target->GetSectionLoadList().IsEmpty())
1129         {
1130             if (!target->GetSectionLoadList().ResolveLoadAddress (addr, so_addr))
1131                 return false;
1132             else if (so_addr.GetModule() != module)
1133                 return false;
1134         }
1135         else
1136         {
1137             if (!module->ResolveFileAddress (addr, so_addr))
1138                 return false;
1139         }
1140 
1141         // If an offset was given, print out the address we ended up looking up
1142         if (offset)
1143             strm.Printf("File Address: 0x%llx\n", addr);
1144 
1145         ExecutionContextScope *exe_scope = interpreter.GetExecutionContext().GetBestExecutionContextScope();
1146         strm.IndentMore();
1147         strm.Indent ("    Address: ");
1148         so_addr.Dump (&strm, exe_scope, Address::DumpStyleSectionNameOffset);
1149         strm.EOL();
1150         strm.Indent ("    Summary: ");
1151         const uint32_t save_indent = strm.GetIndentLevel ();
1152         strm.SetIndentLevel (save_indent + 11);
1153         so_addr.Dump (&strm, exe_scope, Address::DumpStyleResolvedDescription);
1154         strm.SetIndentLevel (save_indent);
1155         strm.EOL();
1156         // Print out detailed address information when verbose is enabled
1157         if (verbose)
1158         {
1159             if (so_addr.Dump (&strm, exe_scope, Address::DumpStyleDetailedSymbolContext))
1160                 strm.EOL();
1161         }
1162         strm.IndentLess();
1163         return true;
1164     }
1165 
1166     return false;
1167 }
1168 
1169 static uint32_t
1170 LookupSymbolInModule (CommandInterpreter &interpreter, Stream &strm, Module *module, const char *name, bool name_is_regex)
1171 {
1172     if (module)
1173     {
1174         SymbolContext sc;
1175 
1176         ObjectFile *objfile = module->GetObjectFile ();
1177         if (objfile)
1178         {
1179             Symtab *symtab = objfile->GetSymtab();
1180             if (symtab)
1181             {
1182                 uint32_t i;
1183                 std::vector<uint32_t> match_indexes;
1184                 ConstString symbol_name (name);
1185                 uint32_t num_matches = 0;
1186                 if (name_is_regex)
1187                 {
1188                     RegularExpression name_regexp(name);
1189                     num_matches = symtab->AppendSymbolIndexesMatchingRegExAndType (name_regexp,
1190                                                                                    eSymbolTypeAny,
1191                                                                                    match_indexes);
1192                 }
1193                 else
1194                 {
1195                     num_matches = symtab->AppendSymbolIndexesWithName (symbol_name, match_indexes);
1196                 }
1197 
1198 
1199                 if (num_matches > 0)
1200                 {
1201                     strm.Indent ();
1202                     strm.Printf("%u symbols match %s'%s' in ", num_matches,
1203                                 name_is_regex ? "the regular expression " : "", name);
1204                     DumpFullpath (strm, &module->GetFileSpec(), 0);
1205                     strm.PutCString(":\n");
1206                     strm.IndentMore ();
1207                     Symtab::DumpSymbolHeader (&strm);
1208                     for (i=0; i < num_matches; ++i)
1209                     {
1210                         Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]);
1211                         strm.Indent ();
1212                         symbol->Dump (&strm, interpreter.GetExecutionContext().target, i);
1213                     }
1214                     strm.IndentLess ();
1215                     return num_matches;
1216                 }
1217             }
1218         }
1219     }
1220     return 0;
1221 }
1222 
1223 
1224 static void
1225 DumpSymbolContextList (CommandInterpreter &interpreter, Stream &strm, SymbolContextList &sc_list, bool prepend_addr, bool verbose)
1226 {
1227     strm.IndentMore ();
1228     uint32_t i;
1229     const uint32_t num_matches = sc_list.GetSize();
1230 
1231     for (i=0; i<num_matches; ++i)
1232     {
1233         SymbolContext sc;
1234         if (sc_list.GetContextAtIndex(i, sc))
1235         {
1236             strm.Indent();
1237             ExecutionContextScope *exe_scope = interpreter.GetExecutionContext().GetBestExecutionContextScope ();
1238 
1239             if (prepend_addr)
1240             {
1241                 if (sc.line_entry.range.GetBaseAddress().IsValid())
1242                 {
1243                     sc.line_entry.range.GetBaseAddress().Dump (&strm,
1244                                                                exe_scope,
1245                                                                Address::DumpStyleLoadAddress,
1246                                                                Address::DumpStyleModuleWithFileAddress);
1247                     strm.PutCString(" in ");
1248                 }
1249             }
1250             sc.DumpStopContext(&strm,
1251                                exe_scope,
1252                                sc.line_entry.range.GetBaseAddress(),
1253                                true,
1254                                true,
1255                                false);
1256             strm.EOL();
1257             if (verbose)
1258             {
1259                 if (sc.line_entry.range.GetBaseAddress().IsValid())
1260                 {
1261                     if (sc.line_entry.range.GetBaseAddress().Dump (&strm,
1262                                                                    exe_scope,
1263                                                                    Address::DumpStyleDetailedSymbolContext))
1264                         strm.PutCString("\n\n");
1265                 }
1266                 else if (sc.function->GetAddressRange().GetBaseAddress().IsValid())
1267                 {
1268                     if (sc.function->GetAddressRange().GetBaseAddress().Dump (&strm,
1269                                                                               exe_scope,
1270                                                                               Address::DumpStyleDetailedSymbolContext))
1271                         strm.PutCString("\n\n");
1272                 }
1273             }
1274         }
1275     }
1276     strm.IndentLess ();
1277 }
1278 
1279 static uint32_t
1280 LookupFunctionInModule (CommandInterpreter &interpreter, Stream &strm, Module *module, const char *name, bool name_is_regex, bool verbose)
1281 {
1282     if (module && name && name[0])
1283     {
1284         SymbolContextList sc_list;
1285         const bool include_symbols = false;
1286         const bool append = true;
1287         uint32_t num_matches = 0;
1288         if (name_is_regex)
1289         {
1290             RegularExpression function_name_regex (name);
1291             num_matches = module->FindFunctions (function_name_regex,
1292                                                  include_symbols,
1293                                                  append,
1294                                                  sc_list);
1295         }
1296         else
1297         {
1298             ConstString function_name (name);
1299             num_matches = module->FindFunctions (function_name,
1300                                                  eFunctionNameTypeBase | eFunctionNameTypeFull | eFunctionNameTypeMethod | eFunctionNameTypeSelector,
1301                                                  include_symbols,
1302                                                  append,
1303                                                  sc_list);
1304         }
1305 
1306         if (num_matches)
1307         {
1308             strm.Indent ();
1309             strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
1310             DumpFullpath (strm, &module->GetFileSpec(), 0);
1311             strm.PutCString(":\n");
1312             DumpSymbolContextList (interpreter, strm, sc_list, true, verbose);
1313         }
1314         return num_matches;
1315     }
1316     return 0;
1317 }
1318 
1319 static uint32_t
1320 LookupTypeInModule (CommandInterpreter &interpreter,
1321                     Stream &strm,
1322                     Module *module,
1323                     const char *name_cstr,
1324                     bool name_is_regex)
1325 {
1326     if (module && name_cstr && name_cstr[0])
1327     {
1328         SymbolContextList sc_list;
1329 
1330         SymbolVendor *symbol_vendor = module->GetSymbolVendor();
1331         if (symbol_vendor)
1332         {
1333             TypeList type_list;
1334             uint32_t num_matches = 0;
1335             SymbolContext sc;
1336             //            if (name_is_regex)
1337             //            {
1338             //                RegularExpression name_regex (name_cstr);
1339             //                num_matches = symbol_vendor->FindFunctions(sc, name_regex, true, UINT32_MAX, type_list);
1340             //            }
1341             //            else
1342             //            {
1343             ConstString name(name_cstr);
1344             num_matches = symbol_vendor->FindTypes(sc, name, true, UINT32_MAX, type_list);
1345             //            }
1346 
1347             if (num_matches)
1348             {
1349                 strm.Indent ();
1350                 strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
1351                 DumpFullpath (strm, &module->GetFileSpec(), 0);
1352                 strm.PutCString(":\n");
1353                 const uint32_t num_types = type_list.GetSize();
1354                 for (uint32_t i=0; i<num_types; ++i)
1355                 {
1356                     TypeSP type_sp (type_list.GetTypeAtIndex(i));
1357                     if (type_sp)
1358                     {
1359                         // Resolve the clang type so that any forward references
1360                         // to types that haven't yet been parsed will get parsed.
1361                         type_sp->GetClangFullType ();
1362                         type_sp->GetDescription (&strm, eDescriptionLevelFull, true);
1363                     }
1364                     strm.EOL();
1365                 }
1366             }
1367             return num_matches;
1368         }
1369     }
1370     return 0;
1371 }
1372 
1373 static uint32_t
1374 LookupFileAndLineInModule (CommandInterpreter &interpreter,
1375                            Stream &strm,
1376                            Module *module,
1377                            const FileSpec &file_spec,
1378                            uint32_t line,
1379                            bool check_inlines,
1380                            bool verbose)
1381 {
1382     if (module && file_spec)
1383     {
1384         SymbolContextList sc_list;
1385         const uint32_t num_matches = module->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
1386                                                                               eSymbolContextEverything, sc_list);
1387         if (num_matches > 0)
1388         {
1389             strm.Indent ();
1390             strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
1391             strm << file_spec;
1392             if (line > 0)
1393                 strm.Printf (":%u", line);
1394             strm << " in ";
1395             DumpFullpath (strm, &module->GetFileSpec(), 0);
1396             strm.PutCString(":\n");
1397             DumpSymbolContextList (interpreter, strm, sc_list, true, verbose);
1398             return num_matches;
1399         }
1400     }
1401     return 0;
1402 
1403 }
1404 
1405 #pragma mark CommandObjectTargetModulesModuleAutoComplete
1406 
1407 //----------------------------------------------------------------------
1408 // A base command object class that can auto complete with module file
1409 // paths
1410 //----------------------------------------------------------------------
1411 
1412 class CommandObjectTargetModulesModuleAutoComplete : public CommandObject
1413 {
1414 public:
1415 
1416     CommandObjectTargetModulesModuleAutoComplete (CommandInterpreter &interpreter,
1417                                       const char *name,
1418                                       const char *help,
1419                                       const char *syntax) :
1420     CommandObject (interpreter, name, help, syntax)
1421     {
1422         CommandArgumentEntry arg;
1423         CommandArgumentData file_arg;
1424 
1425         // Define the first (and only) variant of this arg.
1426         file_arg.arg_type = eArgTypeFilename;
1427         file_arg.arg_repetition = eArgRepeatStar;
1428 
1429         // There is only one variant this argument could be; put it into the argument entry.
1430         arg.push_back (file_arg);
1431 
1432         // Push the data for the first argument into the m_arguments vector.
1433         m_arguments.push_back (arg);
1434     }
1435 
1436     virtual
1437     ~CommandObjectTargetModulesModuleAutoComplete ()
1438     {
1439     }
1440 
1441     virtual int
1442     HandleArgumentCompletion (Args &input,
1443                               int &cursor_index,
1444                               int &cursor_char_position,
1445                               OptionElementVector &opt_element_vector,
1446                               int match_start_point,
1447                               int max_return_elements,
1448                               bool &word_complete,
1449                               StringList &matches)
1450     {
1451         // Arguments are the standard module completer.
1452         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
1453         completion_str.erase (cursor_char_position);
1454 
1455         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
1456                                                              CommandCompletions::eModuleCompletion,
1457                                                              completion_str.c_str(),
1458                                                              match_start_point,
1459                                                              max_return_elements,
1460                                                              NULL,
1461                                                              word_complete,
1462                                                              matches);
1463         return matches.GetSize();
1464     }
1465 };
1466 
1467 #pragma mark CommandObjectTargetModulesSourceFileAutoComplete
1468 
1469 //----------------------------------------------------------------------
1470 // A base command object class that can auto complete with module source
1471 // file paths
1472 //----------------------------------------------------------------------
1473 
1474 class CommandObjectTargetModulesSourceFileAutoComplete : public CommandObject
1475 {
1476 public:
1477 
1478     CommandObjectTargetModulesSourceFileAutoComplete (CommandInterpreter &interpreter,
1479                                           const char *name,
1480                                           const char *help,
1481                                           const char *syntax) :
1482     CommandObject (interpreter, name, help, syntax)
1483     {
1484         CommandArgumentEntry arg;
1485         CommandArgumentData source_file_arg;
1486 
1487         // Define the first (and only) variant of this arg.
1488         source_file_arg.arg_type = eArgTypeSourceFile;
1489         source_file_arg.arg_repetition = eArgRepeatPlus;
1490 
1491         // There is only one variant this argument could be; put it into the argument entry.
1492         arg.push_back (source_file_arg);
1493 
1494         // Push the data for the first argument into the m_arguments vector.
1495         m_arguments.push_back (arg);
1496     }
1497 
1498     virtual
1499     ~CommandObjectTargetModulesSourceFileAutoComplete ()
1500     {
1501     }
1502 
1503     virtual int
1504     HandleArgumentCompletion (Args &input,
1505                               int &cursor_index,
1506                               int &cursor_char_position,
1507                               OptionElementVector &opt_element_vector,
1508                               int match_start_point,
1509                               int max_return_elements,
1510                               bool &word_complete,
1511                               StringList &matches)
1512     {
1513         // Arguments are the standard source file completer.
1514         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
1515         completion_str.erase (cursor_char_position);
1516 
1517         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
1518                                                              CommandCompletions::eSourceFileCompletion,
1519                                                              completion_str.c_str(),
1520                                                              match_start_point,
1521                                                              max_return_elements,
1522                                                              NULL,
1523                                                              word_complete,
1524                                                              matches);
1525         return matches.GetSize();
1526     }
1527 };
1528 
1529 
1530 #pragma mark CommandObjectTargetModulesDumpSymtab
1531 
1532 
1533 class CommandObjectTargetModulesDumpSymtab : public CommandObjectTargetModulesModuleAutoComplete
1534 {
1535 public:
1536     CommandObjectTargetModulesDumpSymtab (CommandInterpreter &interpreter) :
1537     CommandObjectTargetModulesModuleAutoComplete (interpreter,
1538                                       "target modules dump symtab",
1539                                       "Dump the symbol table from one or more target modules.",
1540                                       NULL),
1541     m_options (interpreter)
1542     {
1543     }
1544 
1545     virtual
1546     ~CommandObjectTargetModulesDumpSymtab ()
1547     {
1548     }
1549 
1550     virtual bool
1551     Execute (Args& command,
1552              CommandReturnObject &result)
1553     {
1554         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1555         if (target == NULL)
1556         {
1557             result.AppendError ("invalid target, create a debug target using the 'target create' command");
1558             result.SetStatus (eReturnStatusFailed);
1559             return false;
1560         }
1561         else
1562         {
1563             uint32_t num_dumped = 0;
1564 
1565             uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
1566             result.GetOutputStream().SetAddressByteSize(addr_byte_size);
1567             result.GetErrorStream().SetAddressByteSize(addr_byte_size);
1568 
1569             if (command.GetArgumentCount() == 0)
1570             {
1571                 // Dump all sections for all modules images
1572                 const uint32_t num_modules = target->GetImages().GetSize();
1573                 if (num_modules > 0)
1574                 {
1575                     result.GetOutputStream().Printf("Dumping symbol table for %u modules.\n", num_modules);
1576                     for (uint32_t image_idx = 0;  image_idx<num_modules; ++image_idx)
1577                     {
1578                         if (num_dumped > 0)
1579                         {
1580                             result.GetOutputStream().EOL();
1581                             result.GetOutputStream().EOL();
1582                         }
1583                         num_dumped++;
1584                         DumpModuleSymtab (m_interpreter, result.GetOutputStream(), target->GetImages().GetModulePointerAtIndex(image_idx), m_options.m_sort_order);
1585                     }
1586                 }
1587                 else
1588                 {
1589                     result.AppendError ("the target has no associated executable images");
1590                     result.SetStatus (eReturnStatusFailed);
1591                     return false;
1592                 }
1593             }
1594             else
1595             {
1596                 // Dump specified images (by basename or fullpath)
1597                 const char *arg_cstr;
1598                 for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
1599                 {
1600                     FileSpec image_file(arg_cstr, false);
1601                     ModuleList matching_modules;
1602                     size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
1603 
1604                     // Not found in our module list for our target, check the main
1605                     // shared module list in case it is a extra file used somewhere
1606                     // else
1607                     if (num_matching_modules == 0)
1608                         num_matching_modules = ModuleList::FindSharedModules (image_file,
1609                                                                               target->GetArchitecture(),
1610                                                                               NULL,
1611                                                                               NULL,
1612                                                                               matching_modules);
1613 
1614                     if (num_matching_modules > 0)
1615                     {
1616                         for (size_t i=0; i<num_matching_modules; ++i)
1617                         {
1618                             Module *image_module = matching_modules.GetModulePointerAtIndex(i);
1619                             if (image_module)
1620                             {
1621                                 if (num_dumped > 0)
1622                                 {
1623                                     result.GetOutputStream().EOL();
1624                                     result.GetOutputStream().EOL();
1625                                 }
1626                                 num_dumped++;
1627                                 DumpModuleSymtab (m_interpreter, result.GetOutputStream(), image_module, m_options.m_sort_order);
1628                             }
1629                         }
1630                     }
1631                     else
1632                         result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
1633                 }
1634             }
1635 
1636             if (num_dumped > 0)
1637                 result.SetStatus (eReturnStatusSuccessFinishResult);
1638             else
1639             {
1640                 result.AppendError ("no matching executable images found");
1641                 result.SetStatus (eReturnStatusFailed);
1642             }
1643         }
1644         return result.Succeeded();
1645     }
1646 
1647     virtual Options *
1648     GetOptions ()
1649     {
1650         return &m_options;
1651     }
1652 
1653     class CommandOptions : public Options
1654     {
1655     public:
1656 
1657         CommandOptions (CommandInterpreter &interpreter) :
1658         Options(interpreter),
1659         m_sort_order (eSortOrderNone)
1660         {
1661         }
1662 
1663         virtual
1664         ~CommandOptions ()
1665         {
1666         }
1667 
1668         virtual Error
1669         SetOptionValue (uint32_t option_idx, const char *option_arg)
1670         {
1671             Error error;
1672             char short_option = (char) m_getopt_table[option_idx].val;
1673 
1674             switch (short_option)
1675             {
1676                 case 's':
1677                 {
1678                     bool found_one = false;
1679                     m_sort_order = (SortOrder) Args::StringToOptionEnum (option_arg,
1680                                                                          g_option_table[option_idx].enum_values,
1681                                                                          eSortOrderNone,
1682                                                                          &found_one);
1683                     if (!found_one)
1684                         error.SetErrorStringWithFormat("Invalid enumeration value '%s' for option '%c'.\n",
1685                                                        option_arg,
1686                                                        short_option);
1687                 }
1688                     break;
1689 
1690                 default:
1691                     error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option);
1692                     break;
1693 
1694             }
1695             return error;
1696         }
1697 
1698         void
1699         OptionParsingStarting ()
1700         {
1701             m_sort_order = eSortOrderNone;
1702         }
1703 
1704         const OptionDefinition*
1705         GetDefinitions ()
1706         {
1707             return g_option_table;
1708         }
1709 
1710         // Options table: Required for subclasses of Options.
1711         static OptionDefinition g_option_table[];
1712 
1713         SortOrder m_sort_order;
1714     };
1715 
1716 protected:
1717 
1718     CommandOptions m_options;
1719 };
1720 
1721 static OptionEnumValueElement
1722 g_sort_option_enumeration[4] =
1723 {
1724     { eSortOrderNone,       "none",     "No sorting, use the original symbol table order."},
1725     { eSortOrderByAddress,  "address",  "Sort output by symbol address."},
1726     { eSortOrderByName,     "name",     "Sort output by symbol name."},
1727     { 0,                    NULL,       NULL }
1728 };
1729 
1730 
1731 OptionDefinition
1732 CommandObjectTargetModulesDumpSymtab::CommandOptions::g_option_table[] =
1733 {
1734     { LLDB_OPT_SET_1, false, "sort", 's', required_argument, g_sort_option_enumeration, 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table."},
1735     { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
1736 };
1737 
1738 #pragma mark CommandObjectTargetModulesDumpSections
1739 
1740 //----------------------------------------------------------------------
1741 // Image section dumping command
1742 //----------------------------------------------------------------------
1743 
1744 class CommandObjectTargetModulesDumpSections : public CommandObjectTargetModulesModuleAutoComplete
1745 {
1746 public:
1747     CommandObjectTargetModulesDumpSections (CommandInterpreter &interpreter) :
1748     CommandObjectTargetModulesModuleAutoComplete (interpreter,
1749                                       "target modules dump sections",
1750                                       "Dump the sections from one or more target modules.",
1751                                       //"target modules dump sections [<file1> ...]")
1752                                       NULL)
1753     {
1754     }
1755 
1756     virtual
1757     ~CommandObjectTargetModulesDumpSections ()
1758     {
1759     }
1760 
1761     virtual bool
1762     Execute (Args& command,
1763              CommandReturnObject &result)
1764     {
1765         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1766         if (target == NULL)
1767         {
1768             result.AppendError ("invalid target, create a debug target using the 'target create' command");
1769             result.SetStatus (eReturnStatusFailed);
1770             return false;
1771         }
1772         else
1773         {
1774             uint32_t num_dumped = 0;
1775 
1776             uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
1777             result.GetOutputStream().SetAddressByteSize(addr_byte_size);
1778             result.GetErrorStream().SetAddressByteSize(addr_byte_size);
1779 
1780             if (command.GetArgumentCount() == 0)
1781             {
1782                 // Dump all sections for all modules images
1783                 const uint32_t num_modules = target->GetImages().GetSize();
1784                 if (num_modules > 0)
1785                 {
1786                     result.GetOutputStream().Printf("Dumping sections for %u modules.\n", num_modules);
1787                     for (uint32_t image_idx = 0;  image_idx<num_modules; ++image_idx)
1788                     {
1789                         num_dumped++;
1790                         DumpModuleSections (m_interpreter, result.GetOutputStream(), target->GetImages().GetModulePointerAtIndex(image_idx));
1791                     }
1792                 }
1793                 else
1794                 {
1795                     result.AppendError ("the target has no associated executable images");
1796                     result.SetStatus (eReturnStatusFailed);
1797                     return false;
1798                 }
1799             }
1800             else
1801             {
1802                 // Dump specified images (by basename or fullpath)
1803                 const char *arg_cstr;
1804                 for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
1805                 {
1806                     FileSpec image_file(arg_cstr, false);
1807                     ModuleList matching_modules;
1808                     size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
1809 
1810                     // Not found in our module list for our target, check the main
1811                     // shared module list in case it is a extra file used somewhere
1812                     // else
1813                     if (num_matching_modules == 0)
1814                         num_matching_modules = ModuleList::FindSharedModules (image_file,
1815                                                                               target->GetArchitecture(),
1816                                                                               NULL,
1817                                                                               NULL,
1818                                                                               matching_modules);
1819 
1820                     if (num_matching_modules > 0)
1821                     {
1822                         for (size_t i=0; i<num_matching_modules; ++i)
1823                         {
1824                             Module * image_module = matching_modules.GetModulePointerAtIndex(i);
1825                             if (image_module)
1826                             {
1827                                 num_dumped++;
1828                                 DumpModuleSections (m_interpreter, result.GetOutputStream(), image_module);
1829                             }
1830                         }
1831                     }
1832                     else
1833                         result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
1834                 }
1835             }
1836 
1837             if (num_dumped > 0)
1838                 result.SetStatus (eReturnStatusSuccessFinishResult);
1839             else
1840             {
1841                 result.AppendError ("no matching executable images found");
1842                 result.SetStatus (eReturnStatusFailed);
1843             }
1844         }
1845         return result.Succeeded();
1846     }
1847 };
1848 
1849 
1850 #pragma mark CommandObjectTargetModulesDumpSymfile
1851 
1852 //----------------------------------------------------------------------
1853 // Image debug symbol dumping command
1854 //----------------------------------------------------------------------
1855 
1856 class CommandObjectTargetModulesDumpSymfile : public CommandObjectTargetModulesModuleAutoComplete
1857 {
1858 public:
1859     CommandObjectTargetModulesDumpSymfile (CommandInterpreter &interpreter) :
1860     CommandObjectTargetModulesModuleAutoComplete (interpreter,
1861                                       "target modules dump symfile",
1862                                       "Dump the debug symbol file for one or more target modules.",
1863                                       //"target modules dump symfile [<file1> ...]")
1864                                       NULL)
1865     {
1866     }
1867 
1868     virtual
1869     ~CommandObjectTargetModulesDumpSymfile ()
1870     {
1871     }
1872 
1873     virtual bool
1874     Execute (Args& command,
1875              CommandReturnObject &result)
1876     {
1877         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1878         if (target == NULL)
1879         {
1880             result.AppendError ("invalid target, create a debug target using the 'target create' command");
1881             result.SetStatus (eReturnStatusFailed);
1882             return false;
1883         }
1884         else
1885         {
1886             uint32_t num_dumped = 0;
1887 
1888             uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
1889             result.GetOutputStream().SetAddressByteSize(addr_byte_size);
1890             result.GetErrorStream().SetAddressByteSize(addr_byte_size);
1891 
1892             if (command.GetArgumentCount() == 0)
1893             {
1894                 // Dump all sections for all modules images
1895                 const uint32_t num_modules = target->GetImages().GetSize();
1896                 if (num_modules > 0)
1897                 {
1898                     result.GetOutputStream().Printf("Dumping debug symbols for %u modules.\n", num_modules);
1899                     for (uint32_t image_idx = 0;  image_idx<num_modules; ++image_idx)
1900                     {
1901                         if (DumpModuleSymbolVendor (result.GetOutputStream(), target->GetImages().GetModulePointerAtIndex(image_idx)))
1902                             num_dumped++;
1903                     }
1904                 }
1905                 else
1906                 {
1907                     result.AppendError ("the target has no associated executable images");
1908                     result.SetStatus (eReturnStatusFailed);
1909                     return false;
1910                 }
1911             }
1912             else
1913             {
1914                 // Dump specified images (by basename or fullpath)
1915                 const char *arg_cstr;
1916                 for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
1917                 {
1918                     FileSpec image_file(arg_cstr, false);
1919                     ModuleList matching_modules;
1920                     size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
1921 
1922                     // Not found in our module list for our target, check the main
1923                     // shared module list in case it is a extra file used somewhere
1924                     // else
1925                     if (num_matching_modules == 0)
1926                         num_matching_modules = ModuleList::FindSharedModules (image_file,
1927                                                                               target->GetArchitecture(),
1928                                                                               NULL,
1929                                                                               NULL,
1930                                                                               matching_modules);
1931 
1932                     if (num_matching_modules > 0)
1933                     {
1934                         for (size_t i=0; i<num_matching_modules; ++i)
1935                         {
1936                             Module * image_module = matching_modules.GetModulePointerAtIndex(i);
1937                             if (image_module)
1938                             {
1939                                 if (DumpModuleSymbolVendor (result.GetOutputStream(), image_module))
1940                                     num_dumped++;
1941                             }
1942                         }
1943                     }
1944                     else
1945                         result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
1946                 }
1947             }
1948 
1949             if (num_dumped > 0)
1950                 result.SetStatus (eReturnStatusSuccessFinishResult);
1951             else
1952             {
1953                 result.AppendError ("no matching executable images found");
1954                 result.SetStatus (eReturnStatusFailed);
1955             }
1956         }
1957         return result.Succeeded();
1958     }
1959 };
1960 
1961 
1962 #pragma mark CommandObjectTargetModulesDumpLineTable
1963 
1964 //----------------------------------------------------------------------
1965 // Image debug line table dumping command
1966 //----------------------------------------------------------------------
1967 
1968 class CommandObjectTargetModulesDumpLineTable : public CommandObjectTargetModulesSourceFileAutoComplete
1969 {
1970 public:
1971     CommandObjectTargetModulesDumpLineTable (CommandInterpreter &interpreter) :
1972     CommandObjectTargetModulesSourceFileAutoComplete (interpreter,
1973                                           "target modules dump line-table",
1974                                           "Dump the debug symbol file for one or more target modules.",
1975                                           NULL)
1976     {
1977     }
1978 
1979     virtual
1980     ~CommandObjectTargetModulesDumpLineTable ()
1981     {
1982     }
1983 
1984     virtual bool
1985     Execute (Args& command,
1986              CommandReturnObject &result)
1987     {
1988         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1989         if (target == NULL)
1990         {
1991             result.AppendError ("invalid target, create a debug target using the 'target create' command");
1992             result.SetStatus (eReturnStatusFailed);
1993             return false;
1994         }
1995         else
1996         {
1997             ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
1998             uint32_t total_num_dumped = 0;
1999 
2000             uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2001             result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2002             result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2003 
2004             if (command.GetArgumentCount() == 0)
2005             {
2006                 result.AppendErrorWithFormat ("\nSyntax: %s\n", m_cmd_syntax.c_str());
2007                 result.SetStatus (eReturnStatusFailed);
2008             }
2009             else
2010             {
2011                 // Dump specified images (by basename or fullpath)
2012                 const char *arg_cstr;
2013                 for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
2014                 {
2015                     FileSpec file_spec(arg_cstr, false);
2016                     const uint32_t num_modules = target->GetImages().GetSize();
2017                     if (num_modules > 0)
2018                     {
2019                         uint32_t num_dumped = 0;
2020                         for (uint32_t i = 0; i<num_modules; ++i)
2021                         {
2022                             if (DumpCompileUnitLineTable (m_interpreter,
2023                                                           result.GetOutputStream(),
2024                                                           target->GetImages().GetModulePointerAtIndex(i),
2025                                                           file_spec,
2026                                                           exe_ctx.process != NULL && exe_ctx.process->IsAlive()))
2027                                 num_dumped++;
2028                         }
2029                         if (num_dumped == 0)
2030                             result.AppendWarningWithFormat ("No source filenames matched '%s'.\n", arg_cstr);
2031                         else
2032                             total_num_dumped += num_dumped;
2033                     }
2034                 }
2035             }
2036 
2037             if (total_num_dumped > 0)
2038                 result.SetStatus (eReturnStatusSuccessFinishResult);
2039             else
2040             {
2041                 result.AppendError ("no source filenames matched any command arguments");
2042                 result.SetStatus (eReturnStatusFailed);
2043             }
2044         }
2045         return result.Succeeded();
2046     }
2047 };
2048 
2049 
2050 #pragma mark CommandObjectTargetModulesDump
2051 
2052 //----------------------------------------------------------------------
2053 // Dump multi-word command for target modules
2054 //----------------------------------------------------------------------
2055 
2056 class CommandObjectTargetModulesDump : public CommandObjectMultiword
2057 {
2058 public:
2059 
2060     //------------------------------------------------------------------
2061     // Constructors and Destructors
2062     //------------------------------------------------------------------
2063     CommandObjectTargetModulesDump(CommandInterpreter &interpreter) :
2064     CommandObjectMultiword (interpreter,
2065                             "target modules dump",
2066                             "A set of commands for dumping information about one or more target modules.",
2067                             "target modules dump [symtab|sections|symfile|line-table] [<file1> <file2> ...]")
2068     {
2069         LoadSubCommand ("symtab",      CommandObjectSP (new CommandObjectTargetModulesDumpSymtab (interpreter)));
2070         LoadSubCommand ("sections",    CommandObjectSP (new CommandObjectTargetModulesDumpSections (interpreter)));
2071         LoadSubCommand ("symfile",     CommandObjectSP (new CommandObjectTargetModulesDumpSymfile (interpreter)));
2072         LoadSubCommand ("line-table",  CommandObjectSP (new CommandObjectTargetModulesDumpLineTable (interpreter)));
2073     }
2074 
2075     virtual
2076     ~CommandObjectTargetModulesDump()
2077     {
2078     }
2079 };
2080 
2081 class CommandObjectTargetModulesAdd : public CommandObject
2082 {
2083 public:
2084     CommandObjectTargetModulesAdd (CommandInterpreter &interpreter) :
2085     CommandObject (interpreter,
2086                    "target modules add",
2087                    "Add a new module to the current target's modules.",
2088                    "target modules add [<module>]")
2089     {
2090     }
2091 
2092     virtual
2093     ~CommandObjectTargetModulesAdd ()
2094     {
2095     }
2096 
2097     virtual bool
2098     Execute (Args& args,
2099              CommandReturnObject &result)
2100     {
2101         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2102         if (target == NULL)
2103         {
2104             result.AppendError ("invalid target, create a debug target using the 'target create' command");
2105             result.SetStatus (eReturnStatusFailed);
2106             return false;
2107         }
2108         else
2109         {
2110             const size_t argc = args.GetArgumentCount();
2111             if (argc == 0)
2112             {
2113                 result.AppendError ("one or more executable image paths must be specified");
2114                 result.SetStatus (eReturnStatusFailed);
2115                 return false;
2116             }
2117             else
2118             {
2119                 for (size_t i=0; i<argc; ++i)
2120                 {
2121                     const char *path = args.GetArgumentAtIndex(i);
2122                     if (path)
2123                     {
2124                         FileSpec file_spec(path, true);
2125                         ArchSpec arch;
2126                         if (file_spec.Exists())
2127                         {
2128                             ModuleSP module_sp (target->GetSharedModule(file_spec, arch));
2129                             if (!module_sp)
2130                             {
2131                                 result.AppendError ("one or more executable image paths must be specified");
2132                                 result.SetStatus (eReturnStatusFailed);
2133                                 return false;
2134                             }
2135                         }
2136                         else
2137                         {
2138                             char resolved_path[PATH_MAX];
2139                             result.SetStatus (eReturnStatusFailed);
2140                             if (file_spec.GetPath (resolved_path, sizeof(resolved_path)))
2141                             {
2142                                 if (strcmp (resolved_path, path) != 0)
2143                                 {
2144                                     result.AppendErrorWithFormat ("invalid module path '%s' with resolved path '%s'\n", path, resolved_path);
2145                                     break;
2146                                 }
2147                             }
2148                             result.AppendErrorWithFormat ("invalid module path '%s'\n", path);
2149                             break;
2150                         }
2151                     }
2152                 }
2153             }
2154         }
2155         return result.Succeeded();
2156     }
2157 
2158     int
2159     HandleArgumentCompletion (Args &input,
2160                               int &cursor_index,
2161                               int &cursor_char_position,
2162                               OptionElementVector &opt_element_vector,
2163                               int match_start_point,
2164                               int max_return_elements,
2165                               bool &word_complete,
2166                               StringList &matches)
2167     {
2168         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
2169         completion_str.erase (cursor_char_position);
2170 
2171         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
2172                                                              CommandCompletions::eDiskFileCompletion,
2173                                                              completion_str.c_str(),
2174                                                              match_start_point,
2175                                                              max_return_elements,
2176                                                              NULL,
2177                                                              word_complete,
2178                                                              matches);
2179         return matches.GetSize();
2180     }
2181 
2182 };
2183 
2184 class CommandObjectTargetModulesLoad : public CommandObjectTargetModulesModuleAutoComplete
2185 {
2186 public:
2187     CommandObjectTargetModulesLoad (CommandInterpreter &interpreter) :
2188         CommandObjectTargetModulesModuleAutoComplete (interpreter,
2189                                                       "target modules load",
2190                                                       "Set the load addresses for one or more sections in a target module.",
2191                                                       "target modules load [--file <module> --uuid <uuid>] <sect-name> <address> [<sect-name> <address> ....]"),
2192         m_option_group (interpreter),
2193         m_file_option (LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypePath, "Fullpath or basename for module to load."),
2194         m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset, "Set the load address for all sections to be the virtual address in the file plus the offset.", 0)
2195     {
2196         m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2197         m_option_group.Append (&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2198         m_option_group.Append (&m_slide_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
2199         m_option_group.Finalize();
2200     }
2201 
2202     virtual
2203     ~CommandObjectTargetModulesLoad ()
2204     {
2205     }
2206 
2207     virtual bool
2208     Execute (Args& args,
2209              CommandReturnObject &result)
2210     {
2211         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2212         if (target == NULL)
2213         {
2214             result.AppendError ("invalid target, create a debug target using the 'target create' command");
2215             result.SetStatus (eReturnStatusFailed);
2216             return false;
2217         }
2218         else
2219         {
2220             const size_t argc = args.GetArgumentCount();
2221             const FileSpec *file_ptr = NULL;
2222             const UUID *uuid_ptr = NULL;
2223             if (m_file_option.GetOptionValue().OptionWasSet())
2224                 file_ptr = &m_file_option.GetOptionValue().GetCurrentValue();
2225 
2226             if (m_uuid_option_group.GetOptionValue().OptionWasSet())
2227                 uuid_ptr = &m_uuid_option_group.GetOptionValue().GetCurrentValue();
2228 
2229             if (file_ptr || uuid_ptr)
2230             {
2231 
2232                 ModuleList matching_modules;
2233                 const size_t num_matches = target->GetImages().FindModules (file_ptr,   // File spec to match (can be NULL to match by UUID only)
2234                                                                             NULL,       // Architecture
2235                                                                             uuid_ptr,   // UUID to match (can be NULL to not match on UUID)
2236                                                                             NULL,       // Object name
2237                                                                             matching_modules);
2238 
2239                 char path[PATH_MAX];
2240                 if (num_matches == 1)
2241                 {
2242                     Module *module = matching_modules.GetModulePointerAtIndex(0);
2243                     if (module)
2244                     {
2245                         ObjectFile *objfile = module->GetObjectFile();
2246                         if (objfile)
2247                         {
2248                             SectionList *section_list = objfile->GetSectionList();
2249                             if (section_list)
2250                             {
2251                                 if (argc == 0)
2252                                 {
2253                                     if (m_slide_option.GetOptionValue().OptionWasSet())
2254                                     {
2255                                         Module *module = matching_modules.GetModulePointerAtIndex(0);
2256                                         if (module)
2257                                         {
2258                                             ObjectFile *objfile = module->GetObjectFile();
2259                                             if (objfile)
2260                                             {
2261                                                 SectionList *section_list = objfile->GetSectionList();
2262                                                 if (section_list)
2263                                                 {
2264                                                     const size_t num_sections = section_list->GetSize();
2265                                                     const addr_t slide = m_slide_option.GetOptionValue().GetCurrentValue();
2266                                                     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
2267                                                     {
2268                                                         SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx));
2269                                                         if (section_sp)
2270                                                             target->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), section_sp->GetFileAddress() + slide);
2271                                                     }
2272                                                 }
2273                                             }
2274                                         }
2275                                     }
2276                                     else
2277                                     {
2278                                         result.AppendError ("one or more section name + load address pair must be specified");
2279                                         result.SetStatus (eReturnStatusFailed);
2280                                         return false;
2281                                     }
2282                                 }
2283                                 else
2284                                 {
2285                                     if (m_slide_option.GetOptionValue().OptionWasSet())
2286                                     {
2287                                         result.AppendError ("The \"--slide <offset>\" option can't be used in conjunction with setting section load addresses.\n");
2288                                         result.SetStatus (eReturnStatusFailed);
2289                                         return false;
2290                                     }
2291 
2292                                     for (size_t i=0; i<argc; i += 2)
2293                                     {
2294                                         const char *sect_name = args.GetArgumentAtIndex(i);
2295                                         const char *load_addr_cstr = args.GetArgumentAtIndex(i+1);
2296                                         if (sect_name && load_addr_cstr)
2297                                         {
2298                                             ConstString const_sect_name(sect_name);
2299                                             bool success = false;
2300                                             addr_t load_addr = Args::StringToUInt64(load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success);
2301                                             if (success)
2302                                             {
2303                                                 SectionSP section_sp (section_list->FindSectionByName(const_sect_name));
2304                                                 if (section_sp)
2305                                                 {
2306                                                     target->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), load_addr);
2307                                                     result.AppendMessageWithFormat("section '%s' loaded at 0x%llx\n", sect_name, load_addr);
2308                                                 }
2309                                                 else
2310                                                 {
2311                                                     result.AppendErrorWithFormat ("no section found that matches the section name '%s'\n", sect_name);
2312                                                     result.SetStatus (eReturnStatusFailed);
2313                                                     break;
2314                                                 }
2315                                             }
2316                                             else
2317                                             {
2318                                                 result.AppendErrorWithFormat ("invalid load address string '%s'\n", load_addr_cstr);
2319                                                 result.SetStatus (eReturnStatusFailed);
2320                                                 break;
2321                                             }
2322                                         }
2323                                         else
2324                                         {
2325                                             if (sect_name)
2326                                                 result.AppendError ("section names must be followed by a load address.\n");
2327                                             else
2328                                                 result.AppendError ("one or more section name + load address pair must be specified.\n");
2329                                             result.SetStatus (eReturnStatusFailed);
2330                                             break;
2331                                         }
2332                                     }
2333                                 }
2334                             }
2335                             else
2336                             {
2337                                 module->GetFileSpec().GetPath (path, sizeof(path));
2338                                 result.AppendErrorWithFormat ("no sections in object file '%s'\n", path);
2339                                 result.SetStatus (eReturnStatusFailed);
2340                             }
2341                         }
2342                         else
2343                         {
2344                             module->GetFileSpec().GetPath (path, sizeof(path));
2345                             result.AppendErrorWithFormat ("no object file for module '%s'\n", path);
2346                             result.SetStatus (eReturnStatusFailed);
2347                         }
2348                     }
2349                     else
2350                     {
2351                         module->GetFileSpec().GetPath (path, sizeof(path));
2352                         result.AppendErrorWithFormat ("invalid module '%s'.\n", path);
2353                         result.SetStatus (eReturnStatusFailed);
2354                     }
2355                 }
2356                 else
2357                 {
2358                     char uuid_cstr[64];
2359                     if (file_ptr)
2360                         file_ptr->GetPath (path, sizeof(path));
2361                     else
2362                         path[0] = '\0';
2363 
2364                     if (uuid_ptr)
2365                         uuid_ptr->GetAsCString(uuid_cstr, sizeof(uuid_cstr));
2366                     else
2367                         uuid_cstr[0] = '\0';
2368                     if (num_matches > 1)
2369                     {
2370                         result.AppendErrorWithFormat ("multiple modules match%s%s%s%s:\n",
2371                                                       path[0] ? " file=" : "",
2372                                                       path,
2373                                                       uuid_cstr[0] ? " uuid=" : "",
2374                                                       uuid_cstr);
2375                         for (size_t i=0; i<num_matches; ++i)
2376                         {
2377                             if (matching_modules.GetModulePointerAtIndex(i)->GetFileSpec().GetPath (path, sizeof(path)))
2378                                 result.AppendMessageWithFormat("%s\n", path);
2379                         }
2380                     }
2381                     else
2382                     {
2383                         result.AppendErrorWithFormat ("no modules were found  that match%s%s%s%s.\n",
2384                                                       path[0] ? " file=" : "",
2385                                                       path,
2386                                                       uuid_cstr[0] ? " uuid=" : "",
2387                                                       uuid_cstr);
2388                     }
2389                     result.SetStatus (eReturnStatusFailed);
2390                 }
2391             }
2392             else
2393             {
2394                 result.AppendError ("either the \"--file <module>\" or the \"--uuid <uuid>\" option must be specified.\n");
2395                 result.SetStatus (eReturnStatusFailed);
2396                 return false;
2397             }
2398         }
2399         return result.Succeeded();
2400     }
2401 
2402     virtual Options *
2403     GetOptions ()
2404     {
2405         return &m_option_group;
2406     }
2407 
2408 protected:
2409     OptionGroupOptions m_option_group;
2410     OptionGroupUUID m_uuid_option_group;
2411     OptionGroupFile m_file_option;
2412     OptionGroupUInt64 m_slide_option;
2413 };
2414 
2415 //----------------------------------------------------------------------
2416 // List images with associated information
2417 //----------------------------------------------------------------------
2418 class CommandObjectTargetModulesList : public CommandObject
2419 {
2420 public:
2421 
2422     class CommandOptions : public Options
2423     {
2424     public:
2425 
2426         CommandOptions (CommandInterpreter &interpreter) :
2427         Options(interpreter),
2428         m_format_array()
2429         {
2430         }
2431 
2432         virtual
2433         ~CommandOptions ()
2434         {
2435         }
2436 
2437         virtual Error
2438         SetOptionValue (uint32_t option_idx, const char *option_arg)
2439         {
2440             char short_option = (char) m_getopt_table[option_idx].val;
2441             uint32_t width = 0;
2442             if (option_arg)
2443                 width = strtoul (option_arg, NULL, 0);
2444             m_format_array.push_back(std::make_pair(short_option, width));
2445             Error error;
2446             return error;
2447         }
2448 
2449         void
2450         OptionParsingStarting ()
2451         {
2452             m_format_array.clear();
2453         }
2454 
2455         const OptionDefinition*
2456         GetDefinitions ()
2457         {
2458             return g_option_table;
2459         }
2460 
2461         // Options table: Required for subclasses of Options.
2462 
2463         static OptionDefinition g_option_table[];
2464 
2465         // Instance variables to hold the values for command options.
2466         typedef std::vector< std::pair<char, uint32_t> > FormatWidthCollection;
2467         FormatWidthCollection m_format_array;
2468     };
2469 
2470     CommandObjectTargetModulesList (CommandInterpreter &interpreter) :
2471     CommandObject (interpreter,
2472                    "target modules list",
2473                    "List current executable and dependent shared library images.",
2474                    "target modules list [<cmd-options>]"),
2475         m_options (interpreter)
2476     {
2477     }
2478 
2479     virtual
2480     ~CommandObjectTargetModulesList ()
2481     {
2482     }
2483 
2484     virtual
2485     Options *
2486     GetOptions ()
2487     {
2488         return &m_options;
2489     }
2490 
2491     virtual bool
2492     Execute (Args& command,
2493              CommandReturnObject &result)
2494     {
2495         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2496         if (target == NULL)
2497         {
2498             result.AppendError ("invalid target, create a debug target using the 'target create' command");
2499             result.SetStatus (eReturnStatusFailed);
2500             return false;
2501         }
2502         else
2503         {
2504             uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2505             result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2506             result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2507             // Dump all sections for all modules images
2508             const uint32_t num_modules = target->GetImages().GetSize();
2509             if (num_modules > 0)
2510             {
2511                 Stream &strm = result.GetOutputStream();
2512 
2513                 for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
2514                 {
2515                     Module *module = target->GetImages().GetModulePointerAtIndex(image_idx);
2516                     strm.Printf("[%3u] ", image_idx);
2517 
2518                     bool dump_object_name = false;
2519                     if (m_options.m_format_array.empty())
2520                     {
2521                         DumpFullpath(strm, &module->GetFileSpec(), 0);
2522                         dump_object_name = true;
2523                     }
2524                     else
2525                     {
2526                         const size_t num_entries = m_options.m_format_array.size();
2527                         for (size_t i=0; i<num_entries; ++i)
2528                         {
2529                             if (i > 0)
2530                                 strm.PutChar(' ');
2531                             char format_char = m_options.m_format_array[i].first;
2532                             uint32_t width = m_options.m_format_array[i].second;
2533                             switch (format_char)
2534                             {
2535                                 case 'a':
2536                                     DumpModuleArchitecture (strm, module, false, width);
2537                                     break;
2538 
2539                                 case 't':
2540                                     DumpModuleArchitecture (strm, module, true, width);
2541                                     break;
2542 
2543                                 case 'f':
2544                                     DumpFullpath (strm, &module->GetFileSpec(), width);
2545                                     dump_object_name = true;
2546                                     break;
2547 
2548                                 case 'd':
2549                                     DumpDirectory (strm, &module->GetFileSpec(), width);
2550                                     break;
2551 
2552                                 case 'b':
2553                                     DumpBasename (strm, &module->GetFileSpec(), width);
2554                                     dump_object_name = true;
2555                                     break;
2556 
2557                                 case 's':
2558                                 case 'S':
2559                                 {
2560                                     SymbolVendor *symbol_vendor = module->GetSymbolVendor();
2561                                     if (symbol_vendor)
2562                                     {
2563                                         SymbolFile *symbol_file = symbol_vendor->GetSymbolFile();
2564                                         if (symbol_file)
2565                                         {
2566                                             if (format_char == 'S')
2567                                                 DumpBasename(strm, &symbol_file->GetObjectFile()->GetFileSpec(), width);
2568                                             else
2569                                                 DumpFullpath (strm, &symbol_file->GetObjectFile()->GetFileSpec(), width);
2570                                             dump_object_name = true;
2571                                             break;
2572                                         }
2573                                     }
2574                                     strm.Printf("%.*s", width, "<NONE>");
2575                                 }
2576                                     break;
2577 
2578                                 case 'u':
2579                                     DumpModuleUUID(strm, module);
2580                                     break;
2581 
2582                                 default:
2583                                     break;
2584                             }
2585 
2586                         }
2587                     }
2588                     if (dump_object_name)
2589                     {
2590                         const char *object_name = module->GetObjectName().GetCString();
2591                         if (object_name)
2592                             strm.Printf ("(%s)", object_name);
2593                     }
2594                     strm.EOL();
2595                 }
2596                 result.SetStatus (eReturnStatusSuccessFinishResult);
2597             }
2598             else
2599             {
2600                 result.AppendError ("the target has no associated executable images");
2601                 result.SetStatus (eReturnStatusFailed);
2602                 return false;
2603             }
2604         }
2605         return result.Succeeded();
2606     }
2607 protected:
2608 
2609     CommandOptions m_options;
2610 };
2611 
2612 OptionDefinition
2613 CommandObjectTargetModulesList::CommandOptions::g_option_table[] =
2614 {
2615     { LLDB_OPT_SET_1, false, "arch",       'a', optional_argument, NULL, 0, eArgTypeWidth,   "Display the architecture when listing images."},
2616     { LLDB_OPT_SET_1, false, "triple",     't', optional_argument, NULL, 0, eArgTypeWidth,   "Display the triple when listing images."},
2617     { LLDB_OPT_SET_1, false, "uuid",       'u', no_argument,       NULL, 0, eArgTypeNone,    "Display the UUID when listing images."},
2618     { LLDB_OPT_SET_1, false, "fullpath",   'f', optional_argument, NULL, 0, eArgTypeWidth,   "Display the fullpath to the image object file."},
2619     { LLDB_OPT_SET_1, false, "directory",  'd', optional_argument, NULL, 0, eArgTypeWidth,   "Display the directory with optional width for the image object file."},
2620     { LLDB_OPT_SET_1, false, "basename",   'b', optional_argument, NULL, 0, eArgTypeWidth,   "Display the basename with optional width for the image object file."},
2621     { LLDB_OPT_SET_1, false, "symfile",    's', optional_argument, NULL, 0, eArgTypeWidth,   "Display the fullpath to the image symbol file with optional width."},
2622     { LLDB_OPT_SET_1, false, "symfile-basename", 'S', optional_argument, NULL, 0, eArgTypeWidth,   "Display the basename to the image symbol file with optional width."},
2623     { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
2624 };
2625 
2626 
2627 
2628 //----------------------------------------------------------------------
2629 // Lookup information in images
2630 //----------------------------------------------------------------------
2631 class CommandObjectTargetModulesLookup : public CommandObject
2632 {
2633 public:
2634 
2635     enum
2636     {
2637         eLookupTypeInvalid = -1,
2638         eLookupTypeAddress = 0,
2639         eLookupTypeSymbol,
2640         eLookupTypeFileLine,    // Line is optional
2641         eLookupTypeFunction,
2642         eLookupTypeType,
2643         kNumLookupTypes
2644     };
2645 
2646     class CommandOptions : public Options
2647     {
2648     public:
2649 
2650         CommandOptions (CommandInterpreter &interpreter) :
2651         Options(interpreter)
2652         {
2653             OptionParsingStarting();
2654         }
2655 
2656         virtual
2657         ~CommandOptions ()
2658         {
2659         }
2660 
2661         virtual Error
2662         SetOptionValue (uint32_t option_idx, const char *option_arg)
2663         {
2664             Error error;
2665 
2666             char short_option = (char) m_getopt_table[option_idx].val;
2667 
2668             switch (short_option)
2669             {
2670                 case 'a':
2671                     m_type = eLookupTypeAddress;
2672                     m_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS);
2673                     if (m_addr == LLDB_INVALID_ADDRESS)
2674                         error.SetErrorStringWithFormat ("Invalid address string '%s'.\n", option_arg);
2675                     break;
2676 
2677                 case 'o':
2678                     m_offset = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS);
2679                     if (m_offset == LLDB_INVALID_ADDRESS)
2680                         error.SetErrorStringWithFormat ("Invalid offset string '%s'.\n", option_arg);
2681                     break;
2682 
2683                 case 's':
2684                     m_str = option_arg;
2685                     m_type = eLookupTypeSymbol;
2686                     break;
2687 
2688                 case 'f':
2689                     m_file.SetFile (option_arg, false);
2690                     m_type = eLookupTypeFileLine;
2691                     break;
2692 
2693                 case 'i':
2694                     m_check_inlines = false;
2695                     break;
2696 
2697                 case 'l':
2698                     m_line_number = Args::StringToUInt32(option_arg, UINT32_MAX);
2699                     if (m_line_number == UINT32_MAX)
2700                         error.SetErrorStringWithFormat ("Invalid line number string '%s'.\n", option_arg);
2701                     else if (m_line_number == 0)
2702                         error.SetErrorString ("Zero is an invalid line number.");
2703                     m_type = eLookupTypeFileLine;
2704                     break;
2705 
2706                 case 'n':
2707                     m_str = option_arg;
2708                     m_type = eLookupTypeFunction;
2709                     break;
2710 
2711                 case 't':
2712                     m_str = option_arg;
2713                     m_type = eLookupTypeType;
2714                     break;
2715 
2716                 case 'v':
2717                     m_verbose = 1;
2718                     break;
2719 
2720                 case 'r':
2721                     m_use_regex = true;
2722                     break;
2723             }
2724 
2725             return error;
2726         }
2727 
2728         void
2729         OptionParsingStarting ()
2730         {
2731             m_type = eLookupTypeInvalid;
2732             m_str.clear();
2733             m_file.Clear();
2734             m_addr = LLDB_INVALID_ADDRESS;
2735             m_offset = 0;
2736             m_line_number = 0;
2737             m_use_regex = false;
2738             m_check_inlines = true;
2739             m_verbose = false;
2740         }
2741 
2742         const OptionDefinition*
2743         GetDefinitions ()
2744         {
2745             return g_option_table;
2746         }
2747 
2748         // Options table: Required for subclasses of Options.
2749 
2750         static OptionDefinition g_option_table[];
2751         int             m_type;         // Should be a eLookupTypeXXX enum after parsing options
2752         std::string     m_str;          // Holds name lookup
2753         FileSpec        m_file;         // Files for file lookups
2754         lldb::addr_t    m_addr;         // Holds the address to lookup
2755         lldb::addr_t    m_offset;       // Subtract this offset from m_addr before doing lookups.
2756         uint32_t        m_line_number;  // Line number for file+line lookups
2757         bool            m_use_regex;    // Name lookups in m_str are regular expressions.
2758         bool            m_check_inlines;// Check for inline entries when looking up by file/line.
2759         bool            m_verbose;      // Enable verbose lookup info
2760 
2761     };
2762 
2763     CommandObjectTargetModulesLookup (CommandInterpreter &interpreter) :
2764     CommandObject (interpreter,
2765                    "target modules lookup",
2766                    "Look up information within executable and dependent shared library images.",
2767                    NULL),
2768     m_options (interpreter)
2769     {
2770         CommandArgumentEntry arg;
2771         CommandArgumentData file_arg;
2772 
2773         // Define the first (and only) variant of this arg.
2774         file_arg.arg_type = eArgTypeFilename;
2775         file_arg.arg_repetition = eArgRepeatStar;
2776 
2777         // There is only one variant this argument could be; put it into the argument entry.
2778         arg.push_back (file_arg);
2779 
2780         // Push the data for the first argument into the m_arguments vector.
2781         m_arguments.push_back (arg);
2782     }
2783 
2784     virtual
2785     ~CommandObjectTargetModulesLookup ()
2786     {
2787     }
2788 
2789     virtual Options *
2790     GetOptions ()
2791     {
2792         return &m_options;
2793     }
2794 
2795 
2796     bool
2797     LookupInModule (CommandInterpreter &interpreter, Module *module, CommandReturnObject &result, bool &syntax_error)
2798     {
2799         switch (m_options.m_type)
2800         {
2801             case eLookupTypeAddress:
2802                 if (m_options.m_addr != LLDB_INVALID_ADDRESS)
2803                 {
2804                     if (LookupAddressInModule (m_interpreter,
2805                                                result.GetOutputStream(),
2806                                                module,
2807                                                eSymbolContextEverything,
2808                                                m_options.m_addr,
2809                                                m_options.m_offset,
2810                                                m_options.m_verbose))
2811                     {
2812                         result.SetStatus(eReturnStatusSuccessFinishResult);
2813                         return true;
2814                     }
2815                 }
2816                 break;
2817 
2818             case eLookupTypeSymbol:
2819                 if (!m_options.m_str.empty())
2820                 {
2821                     if (LookupSymbolInModule (m_interpreter, result.GetOutputStream(), module, m_options.m_str.c_str(), m_options.m_use_regex))
2822                     {
2823                         result.SetStatus(eReturnStatusSuccessFinishResult);
2824                         return true;
2825                     }
2826                 }
2827                 break;
2828 
2829             case eLookupTypeFileLine:
2830                 if (m_options.m_file)
2831                 {
2832 
2833                     if (LookupFileAndLineInModule (m_interpreter,
2834                                                    result.GetOutputStream(),
2835                                                    module,
2836                                                    m_options.m_file,
2837                                                    m_options.m_line_number,
2838                                                    m_options.m_check_inlines,
2839                                                    m_options.m_verbose))
2840                     {
2841                         result.SetStatus(eReturnStatusSuccessFinishResult);
2842                         return true;
2843                     }
2844                 }
2845                 break;
2846 
2847             case eLookupTypeFunction:
2848                 if (!m_options.m_str.empty())
2849                 {
2850                     if (LookupFunctionInModule (m_interpreter,
2851                                                 result.GetOutputStream(),
2852                                                 module,
2853                                                 m_options.m_str.c_str(),
2854                                                 m_options.m_use_regex,
2855                                                 m_options.m_verbose))
2856                     {
2857                         result.SetStatus(eReturnStatusSuccessFinishResult);
2858                         return true;
2859                     }
2860                 }
2861                 break;
2862 
2863             case eLookupTypeType:
2864                 if (!m_options.m_str.empty())
2865                 {
2866                     if (LookupTypeInModule (m_interpreter,
2867                                             result.GetOutputStream(),
2868                                             module,
2869                                             m_options.m_str.c_str(),
2870                                             m_options.m_use_regex))
2871                     {
2872                         result.SetStatus(eReturnStatusSuccessFinishResult);
2873                         return true;
2874                     }
2875                 }
2876                 break;
2877 
2878             default:
2879                 m_options.GenerateOptionUsage (result.GetErrorStream(), this);
2880                 syntax_error = true;
2881                 break;
2882         }
2883 
2884         result.SetStatus (eReturnStatusFailed);
2885         return false;
2886     }
2887 
2888     virtual bool
2889     Execute (Args& command,
2890              CommandReturnObject &result)
2891     {
2892         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
2893         if (target == NULL)
2894         {
2895             result.AppendError ("invalid target, create a debug target using the 'target create' command");
2896             result.SetStatus (eReturnStatusFailed);
2897             return false;
2898         }
2899         else
2900         {
2901             bool syntax_error = false;
2902             uint32_t i;
2903             uint32_t num_successful_lookups = 0;
2904             uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2905             result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2906             result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2907             // Dump all sections for all modules images
2908 
2909             if (command.GetArgumentCount() == 0)
2910             {
2911                 // Dump all sections for all modules images
2912                 const uint32_t num_modules = target->GetImages().GetSize();
2913                 if (num_modules > 0)
2914                 {
2915                     for (i = 0; i<num_modules && syntax_error == false; ++i)
2916                     {
2917                         if (LookupInModule (m_interpreter, target->GetImages().GetModulePointerAtIndex(i), result, syntax_error))
2918                         {
2919                             result.GetOutputStream().EOL();
2920                             num_successful_lookups++;
2921                         }
2922                     }
2923                 }
2924                 else
2925                 {
2926                     result.AppendError ("the target has no associated executable images");
2927                     result.SetStatus (eReturnStatusFailed);
2928                     return false;
2929                 }
2930             }
2931             else
2932             {
2933                 // Dump specified images (by basename or fullpath)
2934                 const char *arg_cstr;
2935                 for (i = 0; (arg_cstr = command.GetArgumentAtIndex(i)) != NULL && syntax_error == false; ++i)
2936                 {
2937                     FileSpec image_file(arg_cstr, false);
2938                     ModuleList matching_modules;
2939                     size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
2940 
2941                     // Not found in our module list for our target, check the main
2942                     // shared module list in case it is a extra file used somewhere
2943                     // else
2944                     if (num_matching_modules == 0)
2945                         num_matching_modules = ModuleList::FindSharedModules (image_file,
2946                                                                               target->GetArchitecture(),
2947                                                                               NULL,
2948                                                                               NULL,
2949                                                                               matching_modules);
2950 
2951                     if (num_matching_modules > 0)
2952                     {
2953                         for (size_t j=0; j<num_matching_modules; ++j)
2954                         {
2955                             Module * image_module = matching_modules.GetModulePointerAtIndex(j);
2956                             if (image_module)
2957                             {
2958                                 if (LookupInModule (m_interpreter, image_module, result, syntax_error))
2959                                 {
2960                                     result.GetOutputStream().EOL();
2961                                     num_successful_lookups++;
2962                                 }
2963                             }
2964                         }
2965                     }
2966                     else
2967                         result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
2968                 }
2969             }
2970 
2971             if (num_successful_lookups > 0)
2972                 result.SetStatus (eReturnStatusSuccessFinishResult);
2973             else
2974                 result.SetStatus (eReturnStatusFailed);
2975         }
2976         return result.Succeeded();
2977     }
2978 protected:
2979 
2980     CommandOptions m_options;
2981 };
2982 
2983 OptionDefinition
2984 CommandObjectTargetModulesLookup::CommandOptions::g_option_table[] =
2985 {
2986     { LLDB_OPT_SET_1,   true,  "address",    'a', required_argument, NULL, 0, eArgTypeAddress,      "Lookup an address in one or more target modules."},
2987     { LLDB_OPT_SET_1,   false, "offset",     'o', required_argument, NULL, 0, eArgTypeOffset,       "When looking up an address subtract <offset> from any addresses before doing the lookup."},
2988     { LLDB_OPT_SET_2| LLDB_OPT_SET_4
2989       /* FIXME: re-enable this for types when the LookupTypeInModule actually uses the regex option: | LLDB_OPT_SET_5 */ ,
2990                         false, "regex",      'r', no_argument,       NULL, 0, eArgTypeNone,         "The <name> argument for name lookups are regular expressions."},
2991     { LLDB_OPT_SET_2,   true,  "symbol",     's', required_argument, NULL, 0, eArgTypeSymbol,       "Lookup a symbol by name in the symbol tables in one or more target modules."},
2992     { LLDB_OPT_SET_3,   true,  "file",       'f', required_argument, NULL, 0, eArgTypeFilename,     "Lookup a file by fullpath or basename in one or more target modules."},
2993     { LLDB_OPT_SET_3,   false, "line",       'l', required_argument, NULL, 0, eArgTypeLineNum,      "Lookup a line number in a file (must be used in conjunction with --file)."},
2994     { LLDB_OPT_SET_3,   false, "no-inlines", 'i', no_argument,       NULL, 0, eArgTypeNone,         "Check inline line entries (must be used in conjunction with --file)."},
2995     { LLDB_OPT_SET_4,   true,  "function",   'n', required_argument, NULL, 0, eArgTypeFunctionName, "Lookup a function by name in the debug symbols in one or more target modules."},
2996     { LLDB_OPT_SET_5,   true,  "type",       't', required_argument, NULL, 0, eArgTypeName,         "Lookup a type by name in the debug symbols in one or more target modules."},
2997     { LLDB_OPT_SET_ALL, false, "verbose",    'v', no_argument,       NULL, 0, eArgTypeNone,         "Enable verbose lookup information."},
2998     { 0, false, NULL,           0, 0,                 NULL, 0, eArgTypeNone, NULL }
2999 };
3000 
3001 
3002 #pragma mark CommandObjectMultiwordImageSearchPaths
3003 
3004 //-------------------------------------------------------------------------
3005 // CommandObjectMultiwordImageSearchPaths
3006 //-------------------------------------------------------------------------
3007 
3008 class CommandObjectTargetModulesImageSearchPaths : public CommandObjectMultiword
3009 {
3010 public:
3011 
3012     CommandObjectTargetModulesImageSearchPaths (CommandInterpreter &interpreter) :
3013     CommandObjectMultiword (interpreter,
3014                             "target modules search-paths",
3015                             "A set of commands for operating on debugger target image search paths.",
3016                             "target modules search-paths <subcommand> [<subcommand-options>]")
3017     {
3018         LoadSubCommand ("add",     CommandObjectSP (new CommandObjectTargetModulesSearchPathsAdd (interpreter)));
3019         LoadSubCommand ("clear",   CommandObjectSP (new CommandObjectTargetModulesSearchPathsClear (interpreter)));
3020         LoadSubCommand ("insert",  CommandObjectSP (new CommandObjectTargetModulesSearchPathsInsert (interpreter)));
3021         LoadSubCommand ("list",    CommandObjectSP (new CommandObjectTargetModulesSearchPathsList (interpreter)));
3022         LoadSubCommand ("query",   CommandObjectSP (new CommandObjectTargetModulesSearchPathsQuery (interpreter)));
3023     }
3024 
3025     ~CommandObjectTargetModulesImageSearchPaths()
3026     {
3027     }
3028 };
3029 
3030 
3031 
3032 #pragma mark CommandObjectTargetModules
3033 
3034 //-------------------------------------------------------------------------
3035 // CommandObjectTargetModules
3036 //-------------------------------------------------------------------------
3037 
3038 class CommandObjectTargetModules : public CommandObjectMultiword
3039 {
3040 public:
3041     //------------------------------------------------------------------
3042     // Constructors and Destructors
3043     //------------------------------------------------------------------
3044     CommandObjectTargetModules(CommandInterpreter &interpreter) :
3045         CommandObjectMultiword (interpreter,
3046                                 "target modules",
3047                                 "A set of commands for accessing information for one or more target modules.",
3048                                 "target modules <sub-command> ...")
3049     {
3050         LoadSubCommand ("add",          CommandObjectSP (new CommandObjectTargetModulesAdd (interpreter)));
3051         LoadSubCommand ("load",         CommandObjectSP (new CommandObjectTargetModulesLoad (interpreter)));
3052         //LoadSubCommand ("unload",       CommandObjectSP (new CommandObjectTargetModulesUnload (interpreter)));
3053         LoadSubCommand ("dump",         CommandObjectSP (new CommandObjectTargetModulesDump (interpreter)));
3054         LoadSubCommand ("list",         CommandObjectSP (new CommandObjectTargetModulesList (interpreter)));
3055         LoadSubCommand ("lookup",       CommandObjectSP (new CommandObjectTargetModulesLookup (interpreter)));
3056         LoadSubCommand ("search-paths", CommandObjectSP (new CommandObjectTargetModulesImageSearchPaths (interpreter)));
3057 
3058     }
3059     virtual
3060     ~CommandObjectTargetModules()
3061     {
3062     }
3063 
3064 private:
3065     //------------------------------------------------------------------
3066     // For CommandObjectTargetModules only
3067     //------------------------------------------------------------------
3068     DISALLOW_COPY_AND_ASSIGN (CommandObjectTargetModules);
3069 };
3070 
3071 
3072 #pragma mark CommandObjectTargetStopHookAdd
3073 
3074 //-------------------------------------------------------------------------
3075 // CommandObjectTargetStopHookAdd
3076 //-------------------------------------------------------------------------
3077 
3078 class CommandObjectTargetStopHookAdd : public CommandObject
3079 {
3080 public:
3081 
3082     class CommandOptions : public Options
3083     {
3084     public:
3085         CommandOptions (CommandInterpreter &interpreter) :
3086             Options(interpreter),
3087             m_line_start(0),
3088             m_line_end (UINT_MAX),
3089             m_func_name_type_mask (eFunctionNameTypeAuto),
3090             m_sym_ctx_specified (false),
3091             m_thread_specified (false),
3092             m_use_one_liner (false),
3093             m_one_liner()
3094         {
3095         }
3096 
3097         ~CommandOptions () {}
3098 
3099         const OptionDefinition*
3100         GetDefinitions ()
3101         {
3102             return g_option_table;
3103         }
3104 
3105         virtual Error
3106         SetOptionValue (uint32_t option_idx, const char *option_arg)
3107         {
3108             Error error;
3109             char short_option = (char) m_getopt_table[option_idx].val;
3110             bool success;
3111 
3112             switch (short_option)
3113             {
3114                 case 'c':
3115                     m_class_name = option_arg;
3116                     m_sym_ctx_specified = true;
3117                 break;
3118 
3119                 case 'e':
3120                     m_line_end = Args::StringToUInt32 (option_arg, UINT_MAX, 0, &success);
3121                     if (!success)
3122                     {
3123                         error.SetErrorStringWithFormat ("Invalid end line number: \"%s\".", option_arg);
3124                         break;
3125                     }
3126                     m_sym_ctx_specified = true;
3127                 break;
3128 
3129                 case 'l':
3130                     m_line_start = Args::StringToUInt32 (option_arg, 0, 0, &success);
3131                     if (!success)
3132                     {
3133                         error.SetErrorStringWithFormat ("Invalid start line number: \"%s\".", option_arg);
3134                         break;
3135                     }
3136                     m_sym_ctx_specified = true;
3137                 break;
3138 
3139                 case 'n':
3140                     m_function_name = option_arg;
3141                     m_func_name_type_mask |= eFunctionNameTypeAuto;
3142                     m_sym_ctx_specified = true;
3143                 break;
3144 
3145                 case 'f':
3146                     m_file_name = option_arg;
3147                     m_sym_ctx_specified = true;
3148                 break;
3149                 case 's':
3150                     m_module_name = option_arg;
3151                     m_sym_ctx_specified = true;
3152                 break;
3153                 case 't' :
3154                 {
3155                     m_thread_id = Args::StringToUInt64(option_arg, LLDB_INVALID_THREAD_ID, 0);
3156                     if (m_thread_id == LLDB_INVALID_THREAD_ID)
3157                        error.SetErrorStringWithFormat ("Invalid thread id string '%s'.\n", option_arg);
3158                     m_thread_specified = true;
3159                 }
3160                 break;
3161                 case 'T':
3162                     m_thread_name = option_arg;
3163                     m_thread_specified = true;
3164                 break;
3165                 case 'q':
3166                     m_queue_name = option_arg;
3167                     m_thread_specified = true;
3168                     break;
3169                 case 'x':
3170                 {
3171                     m_thread_index = Args::StringToUInt32(option_arg, UINT32_MAX, 0);
3172                     if (m_thread_id == UINT32_MAX)
3173                        error.SetErrorStringWithFormat ("Invalid thread index string '%s'.\n", option_arg);
3174                     m_thread_specified = true;
3175                 }
3176                 break;
3177                 case 'o':
3178                     m_use_one_liner = true;
3179                     m_one_liner = option_arg;
3180                 break;
3181                 default:
3182                     error.SetErrorStringWithFormat ("Unrecognized option %c.");
3183                 break;
3184             }
3185             return error;
3186         }
3187 
3188         void
3189         OptionParsingStarting ()
3190         {
3191             m_class_name.clear();
3192             m_function_name.clear();
3193             m_line_start = 0;
3194             m_line_end = UINT_MAX;
3195             m_file_name.clear();
3196             m_module_name.clear();
3197             m_func_name_type_mask = eFunctionNameTypeAuto;
3198             m_thread_id = LLDB_INVALID_THREAD_ID;
3199             m_thread_index = UINT32_MAX;
3200             m_thread_name.clear();
3201             m_queue_name.clear();
3202 
3203             m_sym_ctx_specified = false;
3204             m_thread_specified = false;
3205 
3206             m_use_one_liner = false;
3207             m_one_liner.clear();
3208         }
3209 
3210 
3211         static OptionDefinition g_option_table[];
3212 
3213         std::string m_class_name;
3214         std::string m_function_name;
3215         uint32_t    m_line_start;
3216         uint32_t    m_line_end;
3217         std::string m_file_name;
3218         std::string m_module_name;
3219         uint32_t m_func_name_type_mask;  // A pick from lldb::FunctionNameType.
3220         lldb::tid_t m_thread_id;
3221         uint32_t m_thread_index;
3222         std::string m_thread_name;
3223         std::string m_queue_name;
3224         bool        m_sym_ctx_specified;
3225         bool        m_thread_specified;
3226         // Instance variables to hold the values for one_liner options.
3227         bool m_use_one_liner;
3228         std::string m_one_liner;
3229     };
3230 
3231     Options *
3232     GetOptions ()
3233     {
3234         return &m_options;
3235     }
3236 
3237     CommandObjectTargetStopHookAdd (CommandInterpreter &interpreter) :
3238         CommandObject (interpreter,
3239                        "target stop-hook add ",
3240                        "Add a hook to be executed when the target stops.",
3241                        "target stop-hook add"),
3242         m_options (interpreter)
3243     {
3244     }
3245 
3246     ~CommandObjectTargetStopHookAdd ()
3247     {
3248     }
3249 
3250     static size_t
3251     ReadCommandsCallbackFunction (void *baton,
3252                                   InputReader &reader,
3253                                   lldb::InputReaderAction notification,
3254                                   const char *bytes,
3255                                   size_t bytes_len)
3256     {
3257         StreamSP out_stream = reader.GetDebugger().GetAsyncOutputStream();
3258         Target::StopHook *new_stop_hook = ((Target::StopHook *) baton);
3259         static bool got_interrupted;
3260         bool batch_mode = reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode();
3261 
3262         switch (notification)
3263         {
3264         case eInputReaderActivate:
3265             if (!batch_mode)
3266             {
3267                 out_stream->Printf ("%s\n", "Enter your stop hook command(s).  Type 'DONE' to end.");
3268                 if (reader.GetPrompt())
3269                     out_stream->Printf ("%s", reader.GetPrompt());
3270                 out_stream->Flush();
3271             }
3272             got_interrupted = false;
3273             break;
3274 
3275         case eInputReaderDeactivate:
3276             break;
3277 
3278         case eInputReaderReactivate:
3279             if (reader.GetPrompt() && !batch_mode)
3280             {
3281                 out_stream->Printf ("%s", reader.GetPrompt());
3282                 out_stream->Flush();
3283             }
3284             got_interrupted = false;
3285             break;
3286 
3287         case eInputReaderAsynchronousOutputWritten:
3288             break;
3289 
3290         case eInputReaderGotToken:
3291             if (bytes && bytes_len && baton)
3292             {
3293                 StringList *commands = new_stop_hook->GetCommandPointer();
3294                 if (commands)
3295                 {
3296                     commands->AppendString (bytes, bytes_len);
3297                 }
3298             }
3299             if (!reader.IsDone() && reader.GetPrompt() && !batch_mode)
3300             {
3301                 out_stream->Printf ("%s", reader.GetPrompt());
3302                 out_stream->Flush();
3303             }
3304             break;
3305 
3306         case eInputReaderInterrupt:
3307             {
3308                 // Finish, and cancel the stop hook.
3309                 new_stop_hook->GetTarget()->RemoveStopHookByID(new_stop_hook->GetID());
3310                 if (!batch_mode)
3311                 {
3312                     out_stream->Printf ("Stop hook cancelled.\n");
3313                     out_stream->Flush();
3314                 }
3315 
3316                 reader.SetIsDone (true);
3317             }
3318             got_interrupted = true;
3319             break;
3320 
3321         case eInputReaderEndOfFile:
3322             reader.SetIsDone (true);
3323             break;
3324 
3325         case eInputReaderDone:
3326             if (!got_interrupted && !batch_mode)
3327             {
3328                 out_stream->Printf ("Stop hook #%d added.\n", new_stop_hook->GetID());
3329                 out_stream->Flush();
3330             }
3331             break;
3332         }
3333 
3334         return bytes_len;
3335     }
3336 
3337     bool
3338     Execute (Args& command,
3339              CommandReturnObject &result)
3340     {
3341         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
3342         if (target)
3343         {
3344             Target::StopHookSP new_hook_sp;
3345             target->AddStopHook (new_hook_sp);
3346 
3347             //  First step, make the specifier.
3348             std::auto_ptr<SymbolContextSpecifier> specifier_ap;
3349             if (m_options.m_sym_ctx_specified)
3350             {
3351                 specifier_ap.reset(new SymbolContextSpecifier(m_interpreter.GetDebugger().GetSelectedTarget()));
3352 
3353                 if (!m_options.m_module_name.empty())
3354                 {
3355                     specifier_ap->AddSpecification (m_options.m_module_name.c_str(), SymbolContextSpecifier::eModuleSpecified);
3356                 }
3357 
3358                 if (!m_options.m_class_name.empty())
3359                 {
3360                     specifier_ap->AddSpecification (m_options.m_class_name.c_str(), SymbolContextSpecifier::eClassOrNamespaceSpecified);
3361                 }
3362 
3363                 if (!m_options.m_file_name.empty())
3364                 {
3365                     specifier_ap->AddSpecification (m_options.m_file_name.c_str(), SymbolContextSpecifier::eFileSpecified);
3366                 }
3367 
3368                 if (m_options.m_line_start != 0)
3369                 {
3370                     specifier_ap->AddLineSpecification (m_options.m_line_start, SymbolContextSpecifier::eLineStartSpecified);
3371                 }
3372 
3373                 if (m_options.m_line_end != UINT_MAX)
3374                 {
3375                     specifier_ap->AddLineSpecification (m_options.m_line_end, SymbolContextSpecifier::eLineEndSpecified);
3376                 }
3377 
3378                 if (!m_options.m_function_name.empty())
3379                 {
3380                     specifier_ap->AddSpecification (m_options.m_function_name.c_str(), SymbolContextSpecifier::eFunctionSpecified);
3381                 }
3382             }
3383 
3384             if (specifier_ap.get())
3385                 new_hook_sp->SetSpecifier (specifier_ap.release());
3386 
3387             // Next see if any of the thread options have been entered:
3388 
3389             if (m_options.m_thread_specified)
3390             {
3391                 ThreadSpec *thread_spec = new ThreadSpec();
3392 
3393                 if (m_options.m_thread_id != LLDB_INVALID_THREAD_ID)
3394                 {
3395                     thread_spec->SetTID (m_options.m_thread_id);
3396                 }
3397 
3398                 if (m_options.m_thread_index != UINT32_MAX)
3399                     thread_spec->SetIndex (m_options.m_thread_index);
3400 
3401                 if (!m_options.m_thread_name.empty())
3402                     thread_spec->SetName (m_options.m_thread_name.c_str());
3403 
3404                 if (!m_options.m_queue_name.empty())
3405                     thread_spec->SetQueueName (m_options.m_queue_name.c_str());
3406 
3407                 new_hook_sp->SetThreadSpecifier (thread_spec);
3408 
3409             }
3410             if (m_options.m_use_one_liner)
3411             {
3412                 // Use one-liner.
3413                 new_hook_sp->GetCommandPointer()->AppendString (m_options.m_one_liner.c_str());
3414                 result.AppendMessageWithFormat("Stop hook #%d added.\n", new_hook_sp->GetID());
3415             }
3416             else
3417             {
3418                 // Otherwise gather up the command list, we'll push an input reader and suck the data from that directly into
3419                 // the new stop hook's command string.
3420                 InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger()));
3421                 if (!reader_sp)
3422                 {
3423                     result.AppendError("out of memory\n");
3424                     result.SetStatus (eReturnStatusFailed);
3425                     target->RemoveStopHookByID (new_hook_sp->GetID());
3426                     return false;
3427                 }
3428 
3429                 Error err (reader_sp->Initialize (CommandObjectTargetStopHookAdd::ReadCommandsCallbackFunction,
3430                                                   new_hook_sp.get(), // baton
3431                                                   eInputReaderGranularityLine,  // token size, to pass to callback function
3432                                                   "DONE",                       // end token
3433                                                   "> ",                         // prompt
3434                                                   true));                       // echo input
3435                 if (!err.Success())
3436                 {
3437                     result.AppendError (err.AsCString());
3438                     result.SetStatus (eReturnStatusFailed);
3439                     target->RemoveStopHookByID (new_hook_sp->GetID());
3440                     return false;
3441                 }
3442                 m_interpreter.GetDebugger().PushInputReader (reader_sp);
3443             }
3444             result.SetStatus (eReturnStatusSuccessFinishNoResult);
3445         }
3446         else
3447         {
3448             result.AppendError ("invalid target\n");
3449             result.SetStatus (eReturnStatusFailed);
3450         }
3451 
3452         return result.Succeeded();
3453     }
3454 private:
3455     CommandOptions m_options;
3456 };
3457 
3458 OptionDefinition
3459 CommandObjectTargetStopHookAdd::CommandOptions::g_option_table[] =
3460 {
3461     { LLDB_OPT_SET_ALL, false, "one-liner", 'o', required_argument, NULL, NULL, eArgTypeOneLiner,
3462         "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
3463     { LLDB_OPT_SET_ALL, false, "shlib", 's', required_argument, NULL, CommandCompletions::eModuleCompletion, eArgTypeShlibName,
3464         "Set the module within which the stop-hook is to be run."},
3465     { LLDB_OPT_SET_ALL, false, "thread-index", 'x', required_argument, NULL, NULL, eArgTypeThreadIndex,
3466         "The stop hook is run only for the thread whose index matches this argument."},
3467     { LLDB_OPT_SET_ALL, false, "thread-id", 't', required_argument, NULL, NULL, eArgTypeThreadID,
3468         "The stop hook is run only for the thread whose TID matches this argument."},
3469     { LLDB_OPT_SET_ALL, false, "thread-name", 'T', required_argument, NULL, NULL, eArgTypeThreadName,
3470         "The stop hook is run only for the thread whose thread name matches this argument."},
3471     { LLDB_OPT_SET_ALL, false, "queue-name", 'q', required_argument, NULL, NULL, eArgTypeQueueName,
3472         "The stop hook is run only for threads in the queue whose name is given by this argument."},
3473     { LLDB_OPT_SET_1, false, "file", 'f', required_argument, NULL, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,
3474         "Specify the source file within which the stop-hook is to be run." },
3475     { LLDB_OPT_SET_1, false, "start-line", 'l', required_argument, NULL, 0, eArgTypeLineNum,
3476         "Set the start of the line range for which the stop-hook is to be run."},
3477     { LLDB_OPT_SET_1, false, "end-line", 'e', required_argument, NULL, 0, eArgTypeLineNum,
3478         "Set the end of the line range for which the stop-hook is to be run."},
3479     { LLDB_OPT_SET_2, false, "classname", 'c', required_argument, NULL, NULL, eArgTypeClassName,
3480         "Specify the class within which the stop-hook is to be run." },
3481     { LLDB_OPT_SET_3, false, "name", 'n', required_argument, NULL, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName,
3482         "Set the function name within which the stop hook will be run." },
3483     { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
3484 };
3485 
3486 #pragma mark CommandObjectTargetStopHookDelete
3487 
3488 //-------------------------------------------------------------------------
3489 // CommandObjectTargetStopHookDelete
3490 //-------------------------------------------------------------------------
3491 
3492 class CommandObjectTargetStopHookDelete : public CommandObject
3493 {
3494 public:
3495 
3496     CommandObjectTargetStopHookDelete (CommandInterpreter &interpreter) :
3497         CommandObject (interpreter,
3498                        "target stop-hook delete [<id>]",
3499                        "Delete a stop-hook.",
3500                        "target stop-hook delete")
3501     {
3502     }
3503 
3504     ~CommandObjectTargetStopHookDelete ()
3505     {
3506     }
3507 
3508     bool
3509     Execute (Args& command,
3510              CommandReturnObject &result)
3511     {
3512         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
3513         if (target)
3514         {
3515             // FIXME: see if we can use the breakpoint id style parser?
3516             size_t num_args = command.GetArgumentCount();
3517             if (num_args == 0)
3518             {
3519                 if (!m_interpreter.Confirm ("Delete all stop hooks?", true))
3520                 {
3521                     result.SetStatus (eReturnStatusFailed);
3522                     return false;
3523                 }
3524                 else
3525                 {
3526                     target->RemoveAllStopHooks();
3527                 }
3528             }
3529             else
3530             {
3531                 bool success;
3532                 for (size_t i = 0; i < num_args; i++)
3533                 {
3534                     lldb::user_id_t user_id = Args::StringToUInt32 (command.GetArgumentAtIndex(i), 0, 0, &success);
3535                     if (!success)
3536                     {
3537                         result.AppendErrorWithFormat ("invalid stop hook id: \"%s\".\n", command.GetArgumentAtIndex(i));
3538                         result.SetStatus(eReturnStatusFailed);
3539                         return false;
3540                     }
3541                     success = target->RemoveStopHookByID (user_id);
3542                     if (!success)
3543                     {
3544                         result.AppendErrorWithFormat ("unknown stop hook id: \"%s\".\n", command.GetArgumentAtIndex(i));
3545                         result.SetStatus(eReturnStatusFailed);
3546                         return false;
3547                     }
3548                 }
3549             }
3550             result.SetStatus (eReturnStatusSuccessFinishNoResult);
3551         }
3552         else
3553         {
3554             result.AppendError ("invalid target\n");
3555             result.SetStatus (eReturnStatusFailed);
3556         }
3557 
3558         return result.Succeeded();
3559     }
3560 };
3561 #pragma mark CommandObjectTargetStopHookEnableDisable
3562 
3563 //-------------------------------------------------------------------------
3564 // CommandObjectTargetStopHookEnableDisable
3565 //-------------------------------------------------------------------------
3566 
3567 class CommandObjectTargetStopHookEnableDisable : public CommandObject
3568 {
3569 public:
3570 
3571     CommandObjectTargetStopHookEnableDisable (CommandInterpreter &interpreter, bool enable, const char *name, const char *help, const char *syntax) :
3572         CommandObject (interpreter,
3573                        name,
3574                        help,
3575                        syntax),
3576         m_enable (enable)
3577     {
3578     }
3579 
3580     ~CommandObjectTargetStopHookEnableDisable ()
3581     {
3582     }
3583 
3584     bool
3585     Execute (Args& command,
3586              CommandReturnObject &result)
3587     {
3588         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
3589         if (target)
3590         {
3591             // FIXME: see if we can use the breakpoint id style parser?
3592             size_t num_args = command.GetArgumentCount();
3593             bool success;
3594 
3595             if (num_args == 0)
3596             {
3597                 target->SetAllStopHooksActiveState (m_enable);
3598             }
3599             else
3600             {
3601                 for (size_t i = 0; i < num_args; i++)
3602                 {
3603                     lldb::user_id_t user_id = Args::StringToUInt32 (command.GetArgumentAtIndex(i), 0, 0, &success);
3604                     if (!success)
3605                     {
3606                         result.AppendErrorWithFormat ("invalid stop hook id: \"%s\".\n", command.GetArgumentAtIndex(i));
3607                         result.SetStatus(eReturnStatusFailed);
3608                         return false;
3609                     }
3610                     success = target->SetStopHookActiveStateByID (user_id, m_enable);
3611                     if (!success)
3612                     {
3613                         result.AppendErrorWithFormat ("unknown stop hook id: \"%s\".\n", command.GetArgumentAtIndex(i));
3614                         result.SetStatus(eReturnStatusFailed);
3615                         return false;
3616                     }
3617                 }
3618             }
3619             result.SetStatus (eReturnStatusSuccessFinishNoResult);
3620         }
3621         else
3622         {
3623             result.AppendError ("invalid target\n");
3624             result.SetStatus (eReturnStatusFailed);
3625         }
3626         return result.Succeeded();
3627     }
3628 private:
3629     bool m_enable;
3630 };
3631 
3632 #pragma mark CommandObjectTargetStopHookList
3633 
3634 //-------------------------------------------------------------------------
3635 // CommandObjectTargetStopHookList
3636 //-------------------------------------------------------------------------
3637 
3638 class CommandObjectTargetStopHookList : public CommandObject
3639 {
3640 public:
3641 
3642     CommandObjectTargetStopHookList (CommandInterpreter &interpreter) :
3643         CommandObject (interpreter,
3644                        "target stop-hook list [<type>]",
3645                        "List all stop-hooks.",
3646                        "target stop-hook list")
3647     {
3648     }
3649 
3650     ~CommandObjectTargetStopHookList ()
3651     {
3652     }
3653 
3654     bool
3655     Execute (Args& command,
3656              CommandReturnObject &result)
3657     {
3658         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
3659         if (target)
3660         {
3661             bool notify = true;
3662             target->GetImageSearchPathList().Clear(notify);
3663             result.SetStatus (eReturnStatusSuccessFinishNoResult);
3664         }
3665         else
3666         {
3667             result.AppendError ("invalid target\n");
3668             result.SetStatus (eReturnStatusFailed);
3669         }
3670 
3671         size_t num_hooks = target->GetNumStopHooks ();
3672         if (num_hooks == 0)
3673         {
3674             result.GetOutputStream().PutCString ("No stop hooks.\n");
3675         }
3676         else
3677         {
3678             for (size_t i = 0; i < num_hooks; i++)
3679             {
3680                 Target::StopHookSP this_hook = target->GetStopHookAtIndex (i);
3681                 if (i > 0)
3682                     result.GetOutputStream().PutCString ("\n");
3683                 this_hook->GetDescription (&(result.GetOutputStream()), eDescriptionLevelFull);
3684             }
3685         }
3686         return result.Succeeded();
3687     }
3688 };
3689 
3690 #pragma mark CommandObjectMultiwordTargetStopHooks
3691 //-------------------------------------------------------------------------
3692 // CommandObjectMultiwordTargetStopHooks
3693 //-------------------------------------------------------------------------
3694 
3695 class CommandObjectMultiwordTargetStopHooks : public CommandObjectMultiword
3696 {
3697 public:
3698 
3699     CommandObjectMultiwordTargetStopHooks (CommandInterpreter &interpreter) :
3700         CommandObjectMultiword (interpreter,
3701                                 "target stop-hook",
3702                                 "A set of commands for operating on debugger target stop-hooks.",
3703                                 "target stop-hook <subcommand> [<subcommand-options>]")
3704     {
3705         LoadSubCommand ("add",      CommandObjectSP (new CommandObjectTargetStopHookAdd (interpreter)));
3706         LoadSubCommand ("delete",   CommandObjectSP (new CommandObjectTargetStopHookDelete (interpreter)));
3707         LoadSubCommand ("disable",  CommandObjectSP (new CommandObjectTargetStopHookEnableDisable (interpreter,
3708                                                                                                    false,
3709                                                                                                    "target stop-hook disable [<id>]",
3710                                                                                                    "Disable a stop-hook.",
3711                                                                                                    "target stop-hook disable")));
3712         LoadSubCommand ("enable",   CommandObjectSP (new CommandObjectTargetStopHookEnableDisable (interpreter,
3713                                                                                                    true,
3714                                                                                                    "target stop-hook enable [<id>]",
3715                                                                                                    "Enable a stop-hook.",
3716                                                                                                    "target stop-hook enable")));
3717         LoadSubCommand ("list",     CommandObjectSP (new CommandObjectTargetStopHookList (interpreter)));
3718     }
3719 
3720     ~CommandObjectMultiwordTargetStopHooks()
3721     {
3722     }
3723 };
3724 
3725 
3726 
3727 #pragma mark CommandObjectMultiwordTarget
3728 
3729 //-------------------------------------------------------------------------
3730 // CommandObjectMultiwordTarget
3731 //-------------------------------------------------------------------------
3732 
3733 CommandObjectMultiwordTarget::CommandObjectMultiwordTarget (CommandInterpreter &interpreter) :
3734     CommandObjectMultiword (interpreter,
3735                             "target",
3736                             "A set of commands for operating on debugger targets.",
3737                             "target <subcommand> [<subcommand-options>]")
3738 {
3739 
3740     LoadSubCommand ("create",    CommandObjectSP (new CommandObjectTargetCreate (interpreter)));
3741     LoadSubCommand ("list",      CommandObjectSP (new CommandObjectTargetList   (interpreter)));
3742     LoadSubCommand ("select",    CommandObjectSP (new CommandObjectTargetSelect (interpreter)));
3743     LoadSubCommand ("stop-hook", CommandObjectSP (new CommandObjectMultiwordTargetStopHooks (interpreter)));
3744     LoadSubCommand ("modules",   CommandObjectSP (new CommandObjectTargetModules (interpreter)));
3745     LoadSubCommand ("variable",  CommandObjectSP (new CommandObjectTargetVariable (interpreter)));
3746 }
3747 
3748 CommandObjectMultiwordTarget::~CommandObjectMultiwordTarget ()
3749 {
3750 }
3751 
3752 
3753