1 //===-- SBTarget.cpp --------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/API/SBTarget.h"
11 
12 #include "lldb/lldb-public.h"
13 
14 #include "lldb/API/SBDebugger.h"
15 #include "lldb/API/SBBreakpoint.h"
16 #include "lldb/API/SBFileSpec.h"
17 #include "lldb/API/SBListener.h"
18 #include "lldb/API/SBModule.h"
19 #include "lldb/API/SBSourceManager.h"
20 #include "lldb/API/SBProcess.h"
21 #include "lldb/API/SBStream.h"
22 #include "lldb/API/SBSymbolContextList.h"
23 #include "lldb/Breakpoint/BreakpointID.h"
24 #include "lldb/Breakpoint/BreakpointIDList.h"
25 #include "lldb/Breakpoint/BreakpointList.h"
26 #include "lldb/Breakpoint/BreakpointLocation.h"
27 #include "lldb/Core/Address.h"
28 #include "lldb/Core/AddressResolver.h"
29 #include "lldb/Core/AddressResolverName.h"
30 #include "lldb/Core/ArchSpec.h"
31 #include "lldb/Core/Debugger.h"
32 #include "lldb/Core/Disassembler.h"
33 #include "lldb/Core/Log.h"
34 #include "lldb/Core/RegularExpression.h"
35 #include "lldb/Core/SearchFilter.h"
36 #include "lldb/Core/STLUtils.h"
37 #include "lldb/Core/ValueObjectList.h"
38 #include "lldb/Core/ValueObjectVariable.h"
39 #include "lldb/Host/FileSpec.h"
40 #include "lldb/Host/Host.h"
41 #include "lldb/Interpreter/Args.h"
42 #include "lldb/Symbol/SymbolVendor.h"
43 #include "lldb/Symbol/VariableList.h"
44 #include "lldb/Target/LanguageRuntime.h"
45 #include "lldb/Target/Process.h"
46 #include "lldb/Target/Target.h"
47 #include "lldb/Target/TargetList.h"
48 
49 #include "lldb/Interpreter/CommandReturnObject.h"
50 #include "../source/Commands/CommandObjectBreakpoint.h"
51 
52 
53 using namespace lldb;
54 using namespace lldb_private;
55 
56 #define DEFAULT_DISASM_BYTE_SIZE 32
57 
58 SBLaunchInfo::SBLaunchInfo (const char **argv) :
59     m_opaque_sp(new ProcessLaunchInfo())
60 {
61     m_opaque_sp->GetFlags().Reset (eLaunchFlagDebug | eLaunchFlagDisableASLR);
62     if (argv && argv[0])
63         m_opaque_sp->GetArguments().SetArguments(argv);
64 }
65 
66 SBLaunchInfo::~SBLaunchInfo()
67 {
68 }
69 
70 lldb_private::ProcessLaunchInfo &
71 SBLaunchInfo::ref ()
72 {
73     return *m_opaque_sp;
74 }
75 
76 
77 uint32_t
78 SBLaunchInfo::GetUserID()
79 {
80     return m_opaque_sp->GetUserID();
81 }
82 
83 uint32_t
84 SBLaunchInfo::GetGroupID()
85 {
86     return m_opaque_sp->GetGroupID();
87 }
88 
89 bool
90 SBLaunchInfo::UserIDIsValid ()
91 {
92     return m_opaque_sp->UserIDIsValid();
93 }
94 
95 bool
96 SBLaunchInfo::GroupIDIsValid ()
97 {
98     return m_opaque_sp->GroupIDIsValid();
99 }
100 
101 void
102 SBLaunchInfo::SetUserID (uint32_t uid)
103 {
104     m_opaque_sp->SetUserID (uid);
105 }
106 
107 void
108 SBLaunchInfo::SetGroupID (uint32_t gid)
109 {
110     m_opaque_sp->SetGroupID (gid);
111 }
112 
113 uint32_t
114 SBLaunchInfo::GetNumArguments ()
115 {
116     return m_opaque_sp->GetArguments().GetArgumentCount();
117 }
118 
119 const char *
120 SBLaunchInfo::GetArgumentAtIndex (uint32_t idx)
121 {
122     return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
123 }
124 
125 void
126 SBLaunchInfo::SetArguments (const char **argv, bool append)
127 {
128     if (append)
129     {
130         if (argv)
131             m_opaque_sp->GetArguments().AppendArguments(argv);
132     }
133     else
134     {
135         if (argv)
136             m_opaque_sp->GetArguments().SetArguments(argv);
137         else
138             m_opaque_sp->GetArguments().Clear();
139     }
140 }
141 
142 uint32_t
143 SBLaunchInfo::GetNumEnvironmentEntries ()
144 {
145     return m_opaque_sp->GetEnvironmentEntries().GetArgumentCount();
146 }
147 
148 const char *
149 SBLaunchInfo::GetEnvironmentEntryAtIndex (uint32_t idx)
150 {
151     return m_opaque_sp->GetEnvironmentEntries().GetArgumentAtIndex(idx);
152 }
153 
154 void
155 SBLaunchInfo::SetEnvironmentEntries (const char **envp, bool append)
156 {
157     if (append)
158     {
159         if (envp)
160             m_opaque_sp->GetEnvironmentEntries().AppendArguments(envp);
161     }
162     else
163     {
164         if (envp)
165             m_opaque_sp->GetEnvironmentEntries().SetArguments(envp);
166         else
167             m_opaque_sp->GetEnvironmentEntries().Clear();
168     }
169 }
170 
171 void
172 SBLaunchInfo::Clear ()
173 {
174     m_opaque_sp->Clear();
175 }
176 
177 const char *
178 SBLaunchInfo::GetWorkingDirectory () const
179 {
180     return m_opaque_sp->GetWorkingDirectory();
181 }
182 
183 void
184 SBLaunchInfo::SetWorkingDirectory (const char *working_dir)
185 {
186     m_opaque_sp->SetWorkingDirectory(working_dir);
187 }
188 
189 uint32_t
190 SBLaunchInfo::GetLaunchFlags ()
191 {
192     return m_opaque_sp->GetFlags().Get();
193 }
194 
195 void
196 SBLaunchInfo::SetLaunchFlags (uint32_t flags)
197 {
198     m_opaque_sp->GetFlags().Reset(flags);
199 }
200 
201 const char *
202 SBLaunchInfo::GetProcessPluginName ()
203 {
204     return m_opaque_sp->GetProcessPluginName();
205 }
206 
207 void
208 SBLaunchInfo::SetProcessPluginName (const char *plugin_name)
209 {
210     return m_opaque_sp->SetProcessPluginName (plugin_name);
211 }
212 
213 const char *
214 SBLaunchInfo::GetShell ()
215 {
216     return m_opaque_sp->GetShell();
217 }
218 
219 void
220 SBLaunchInfo::SetShell (const char * path)
221 {
222     m_opaque_sp->SetShell (path);
223 }
224 
225 uint32_t
226 SBLaunchInfo::GetResumeCount ()
227 {
228     return m_opaque_sp->GetResumeCount();
229 }
230 
231 void
232 SBLaunchInfo::SetResumeCount (uint32_t c)
233 {
234     m_opaque_sp->SetResumeCount (c);
235 }
236 
237 bool
238 SBLaunchInfo::AddCloseFileAction (int fd)
239 {
240     return m_opaque_sp->AppendCloseFileAction(fd);
241 }
242 
243 bool
244 SBLaunchInfo::AddDuplicateFileAction (int fd, int dup_fd)
245 {
246     return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
247 }
248 
249 bool
250 SBLaunchInfo::AddOpenFileAction (int fd, const char *path, bool read, bool write)
251 {
252     return m_opaque_sp->AppendOpenFileAction(fd, path, read, write);
253 }
254 
255 bool
256 SBLaunchInfo::AddSuppressFileAction (int fd, bool read, bool write)
257 {
258     return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
259 }
260 
261 
262 SBAttachInfo::SBAttachInfo () :
263     m_opaque_sp (new ProcessAttachInfo())
264 {
265 }
266 
267 SBAttachInfo::SBAttachInfo (lldb::pid_t pid) :
268     m_opaque_sp (new ProcessAttachInfo())
269 {
270     m_opaque_sp->SetProcessID (pid);
271 }
272 
273 SBAttachInfo::SBAttachInfo (const char *path, bool wait_for) :
274     m_opaque_sp (new ProcessAttachInfo())
275 {
276     if (path && path[0])
277         m_opaque_sp->GetExecutableFile().SetFile(path, false);
278     m_opaque_sp->SetWaitForLaunch (wait_for);
279 }
280 
281 SBAttachInfo::SBAttachInfo (const SBAttachInfo &rhs) :
282     m_opaque_sp (new ProcessAttachInfo())
283 {
284     *m_opaque_sp = *rhs.m_opaque_sp;
285 }
286 
287 SBAttachInfo::~SBAttachInfo()
288 {
289 }
290 
291 lldb_private::ProcessAttachInfo &
292 SBAttachInfo::ref ()
293 {
294     return *m_opaque_sp;
295 }
296 
297 SBAttachInfo &
298 SBAttachInfo::operator = (const SBAttachInfo &rhs)
299 {
300     if (this != &rhs)
301         *m_opaque_sp = *rhs.m_opaque_sp;
302     return *this;
303 }
304 
305 lldb::pid_t
306 SBAttachInfo::GetProcessID ()
307 {
308     return m_opaque_sp->GetProcessID();
309 }
310 
311 void
312 SBAttachInfo::SetProcessID (lldb::pid_t pid)
313 {
314     m_opaque_sp->SetProcessID (pid);
315 }
316 
317 
318 uint32_t
319 SBAttachInfo::GetResumeCount ()
320 {
321     return m_opaque_sp->GetResumeCount();
322 }
323 
324 void
325 SBAttachInfo::SetResumeCount (uint32_t c)
326 {
327     m_opaque_sp->SetResumeCount (c);
328 }
329 
330 const char *
331 SBAttachInfo::GetProcessPluginName ()
332 {
333     return m_opaque_sp->GetProcessPluginName();
334 }
335 
336 void
337 SBAttachInfo::SetProcessPluginName (const char *plugin_name)
338 {
339     return m_opaque_sp->SetProcessPluginName (plugin_name);
340 }
341 
342 void
343 SBAttachInfo::SetExecutable (const char *path)
344 {
345     if (path && path[0])
346         m_opaque_sp->GetExecutableFile().SetFile(path, false);
347     else
348         m_opaque_sp->GetExecutableFile().Clear();
349 }
350 
351 void
352 SBAttachInfo::SetExecutable (SBFileSpec exe_file)
353 {
354     if (exe_file.IsValid())
355         m_opaque_sp->GetExecutableFile() = exe_file.ref();
356     else
357         m_opaque_sp->GetExecutableFile().Clear();
358 }
359 
360 bool
361 SBAttachInfo::GetWaitForLaunch ()
362 {
363     return m_opaque_sp->GetWaitForLaunch();
364 }
365 
366 void
367 SBAttachInfo::SetWaitForLaunch (bool b)
368 {
369     m_opaque_sp->SetWaitForLaunch (b);
370 }
371 
372 uint32_t
373 SBAttachInfo::GetUserID()
374 {
375     return m_opaque_sp->GetUserID();
376 }
377 
378 uint32_t
379 SBAttachInfo::GetGroupID()
380 {
381     return m_opaque_sp->GetGroupID();
382 }
383 
384 bool
385 SBAttachInfo::UserIDIsValid ()
386 {
387     return m_opaque_sp->UserIDIsValid();
388 }
389 
390 bool
391 SBAttachInfo::GroupIDIsValid ()
392 {
393     return m_opaque_sp->GroupIDIsValid();
394 }
395 
396 void
397 SBAttachInfo::SetUserID (uint32_t uid)
398 {
399     m_opaque_sp->SetUserID (uid);
400 }
401 
402 void
403 SBAttachInfo::SetGroupID (uint32_t gid)
404 {
405     m_opaque_sp->SetGroupID (gid);
406 }
407 
408 uint32_t
409 SBAttachInfo::GetEffectiveUserID()
410 {
411     return m_opaque_sp->GetEffectiveUserID();
412 }
413 
414 uint32_t
415 SBAttachInfo::GetEffectiveGroupID()
416 {
417     return m_opaque_sp->GetEffectiveGroupID();
418 }
419 
420 bool
421 SBAttachInfo::EffectiveUserIDIsValid ()
422 {
423     return m_opaque_sp->EffectiveUserIDIsValid();
424 }
425 
426 bool
427 SBAttachInfo::EffectiveGroupIDIsValid ()
428 {
429     return m_opaque_sp->EffectiveGroupIDIsValid ();
430 }
431 
432 void
433 SBAttachInfo::SetEffectiveUserID (uint32_t uid)
434 {
435     m_opaque_sp->SetEffectiveUserID(uid);
436 }
437 
438 void
439 SBAttachInfo::SetEffectiveGroupID (uint32_t gid)
440 {
441     m_opaque_sp->SetEffectiveGroupID(gid);
442 }
443 
444 lldb::pid_t
445 SBAttachInfo::GetParentProcessID ()
446 {
447     return m_opaque_sp->GetParentProcessID();
448 }
449 
450 void
451 SBAttachInfo::SetParentProcessID (lldb::pid_t pid)
452 {
453     m_opaque_sp->SetParentProcessID (pid);
454 }
455 
456 bool
457 SBAttachInfo::ParentProcessIDIsValid()
458 {
459     return m_opaque_sp->ParentProcessIDIsValid();
460 }
461 
462 
463 //----------------------------------------------------------------------
464 // SBTarget constructor
465 //----------------------------------------------------------------------
466 SBTarget::SBTarget () :
467     m_opaque_sp ()
468 {
469 }
470 
471 SBTarget::SBTarget (const SBTarget& rhs) :
472     m_opaque_sp (rhs.m_opaque_sp)
473 {
474 }
475 
476 SBTarget::SBTarget(const TargetSP& target_sp) :
477     m_opaque_sp (target_sp)
478 {
479 }
480 
481 const SBTarget&
482 SBTarget::operator = (const SBTarget& rhs)
483 {
484     if (this != &rhs)
485         m_opaque_sp = rhs.m_opaque_sp;
486     return *this;
487 }
488 
489 //----------------------------------------------------------------------
490 // Destructor
491 //----------------------------------------------------------------------
492 SBTarget::~SBTarget()
493 {
494 }
495 
496 const char *
497 SBTarget::GetBroadcasterClassName ()
498 {
499     return Target::GetStaticBroadcasterClass().AsCString();
500 }
501 
502 bool
503 SBTarget::IsValid () const
504 {
505     return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid();
506 }
507 
508 SBProcess
509 SBTarget::GetProcess ()
510 {
511     SBProcess sb_process;
512     ProcessSP process_sp;
513     TargetSP target_sp(GetSP());
514     if (target_sp)
515     {
516         process_sp = target_sp->GetProcessSP();
517         sb_process.SetSP (process_sp);
518     }
519 
520     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
521     if (log)
522     {
523         log->Printf ("SBTarget(%p)::GetProcess () => SBProcess(%p)",
524                      target_sp.get(), process_sp.get());
525     }
526 
527     return sb_process;
528 }
529 
530 SBDebugger
531 SBTarget::GetDebugger () const
532 {
533     SBDebugger debugger;
534     TargetSP target_sp(GetSP());
535     if (target_sp)
536         debugger.reset (target_sp->GetDebugger().shared_from_this());
537     return debugger;
538 }
539 
540 SBProcess
541 SBTarget::LaunchSimple
542 (
543     char const **argv,
544     char const **envp,
545     const char *working_directory
546 )
547 {
548     char *stdin_path = NULL;
549     char *stdout_path = NULL;
550     char *stderr_path = NULL;
551     uint32_t launch_flags = 0;
552     bool stop_at_entry = false;
553     SBError error;
554     SBListener listener = GetDebugger().GetListener();
555     return Launch (listener,
556                    argv,
557                    envp,
558                    stdin_path,
559                    stdout_path,
560                    stderr_path,
561                    working_directory,
562                    launch_flags,
563                    stop_at_entry,
564                    error);
565 }
566 
567 SBProcess
568 SBTarget::Launch
569 (
570     SBListener &listener,
571     char const **argv,
572     char const **envp,
573     const char *stdin_path,
574     const char *stdout_path,
575     const char *stderr_path,
576     const char *working_directory,
577     uint32_t launch_flags,   // See LaunchFlags
578     bool stop_at_entry,
579     lldb::SBError& error
580 )
581 {
582     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
583 
584     SBProcess sb_process;
585     ProcessSP process_sp;
586     TargetSP target_sp(GetSP());
587 
588     if (log)
589     {
590         log->Printf ("SBTarget(%p)::Launch (argv=%p, envp=%p, stdin=%s, stdout=%s, stderr=%s, working-dir=%s, launch_flags=0x%x, stop_at_entry=%i, &error (%p))...",
591                      target_sp.get(),
592                      argv,
593                      envp,
594                      stdin_path ? stdin_path : "NULL",
595                      stdout_path ? stdout_path : "NULL",
596                      stderr_path ? stderr_path : "NULL",
597                      working_directory ? working_directory : "NULL",
598                      launch_flags,
599                      stop_at_entry,
600                      error.get());
601     }
602 
603     if (target_sp)
604     {
605         Mutex::Locker api_locker (target_sp->GetAPIMutex());
606 
607         if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR"))
608             launch_flags |= eLaunchFlagDisableASLR;
609 
610         StateType state = eStateInvalid;
611         process_sp = target_sp->GetProcessSP();
612         if (process_sp)
613         {
614             state = process_sp->GetState();
615 
616             if (process_sp->IsAlive() && state != eStateConnected)
617             {
618                 if (state == eStateAttaching)
619                     error.SetErrorString ("process attach is in progress");
620                 else
621                     error.SetErrorString ("a process is already being debugged");
622                 return sb_process;
623             }
624         }
625 
626         if (state == eStateConnected)
627         {
628             // If we are already connected, then we have already specified the
629             // listener, so if a valid listener is supplied, we need to error out
630             // to let the client know.
631             if (listener.IsValid())
632             {
633                 error.SetErrorString ("process is connected and already has a listener, pass empty listener");
634                 return sb_process;
635             }
636         }
637         else
638         {
639             if (listener.IsValid())
640                 process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL);
641             else
642                 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
643         }
644 
645         if (process_sp)
646         {
647             sb_process.SetSP (process_sp);
648             if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO"))
649                 launch_flags |= eLaunchFlagDisableSTDIO;
650 
651             ProcessLaunchInfo launch_info (stdin_path, stdout_path, stderr_path, working_directory, launch_flags);
652 
653             Module *exe_module = target_sp->GetExecutableModulePointer();
654             if (exe_module)
655                 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
656             if (argv)
657                 launch_info.GetArguments().AppendArguments (argv);
658             if (envp)
659                 launch_info.GetEnvironmentEntries ().SetArguments (envp);
660 
661             error.SetError (process_sp->Launch (launch_info));
662             if (error.Success())
663             {
664                 // We we are stopping at the entry point, we can return now!
665                 if (stop_at_entry)
666                     return sb_process;
667 
668                 // Make sure we are stopped at the entry
669                 StateType state = process_sp->WaitForProcessToStop (NULL);
670                 if (state == eStateStopped)
671                 {
672                     // resume the process to skip the entry point
673                     error.SetError (process_sp->Resume());
674                     if (error.Success())
675                     {
676                         // If we are doing synchronous mode, then wait for the
677                         // process to stop yet again!
678                         if (target_sp->GetDebugger().GetAsyncExecution () == false)
679                             process_sp->WaitForProcessToStop (NULL);
680                     }
681                 }
682             }
683         }
684         else
685         {
686             error.SetErrorString ("unable to create lldb_private::Process");
687         }
688     }
689     else
690     {
691         error.SetErrorString ("SBTarget is invalid");
692     }
693 
694     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
695     if (log)
696     {
697         log->Printf ("SBTarget(%p)::Launch (...) => SBProceess(%p)",
698                      target_sp.get(), process_sp.get());
699     }
700 
701     return sb_process;
702 }
703 
704 SBProcess
705 SBTarget::Launch (SBLaunchInfo &sb_launch_info, SBError& error)
706 {
707     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
708 
709     SBProcess sb_process;
710     ProcessSP process_sp;
711     TargetSP target_sp(GetSP());
712 
713     if (log)
714     {
715         log->Printf ("SBTarget(%p)::Launch (launch_info, error)...", target_sp.get());
716     }
717 
718     if (target_sp)
719     {
720         Mutex::Locker api_locker (target_sp->GetAPIMutex());
721         StateType state = eStateInvalid;
722         process_sp = target_sp->GetProcessSP();
723         if (process_sp)
724         {
725             state = process_sp->GetState();
726 
727             if (process_sp->IsAlive() && state != eStateConnected)
728             {
729                 if (state == eStateAttaching)
730                     error.SetErrorString ("process attach is in progress");
731                 else
732                     error.SetErrorString ("a process is already being debugged");
733                 return sb_process;
734             }
735         }
736 
737         if (state != eStateConnected)
738             process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
739 
740         if (process_sp)
741         {
742             sb_process.SetSP (process_sp);
743             lldb_private::ProcessLaunchInfo &launch_info = sb_launch_info.ref();
744 
745             Module *exe_module = target_sp->GetExecutableModulePointer();
746             if (exe_module)
747                 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
748 
749             const ArchSpec &arch_spec = target_sp->GetArchitecture();
750             if (arch_spec.IsValid())
751                 launch_info.GetArchitecture () = arch_spec;
752 
753             error.SetError (process_sp->Launch (launch_info));
754             const bool synchronous_execution = target_sp->GetDebugger().GetAsyncExecution () == false;
755             if (error.Success())
756             {
757                 StateType state = eStateInvalid;
758                 if (launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
759                 {
760                     // If we are doing synchronous mode, then wait for the initial
761                     // stop to happen, else, return and let the caller watch for
762                     // the stop
763                     if (synchronous_execution)
764                          state = process_sp->WaitForProcessToStop (NULL);
765                     // We we are stopping at the entry point, we can return now!
766                     return sb_process;
767                 }
768 
769                 // Make sure we are stopped at the entry
770                 state = process_sp->WaitForProcessToStop (NULL);
771                 if (state == eStateStopped)
772                 {
773                     // resume the process to skip the entry point
774                     error.SetError (process_sp->Resume());
775                     if (error.Success())
776                     {
777                         // If we are doing synchronous mode, then wait for the
778                         // process to stop yet again!
779                         if (synchronous_execution)
780                             process_sp->WaitForProcessToStop (NULL);
781                     }
782                 }
783             }
784         }
785         else
786         {
787             error.SetErrorString ("unable to create lldb_private::Process");
788         }
789     }
790     else
791     {
792         error.SetErrorString ("SBTarget is invalid");
793     }
794 
795     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
796     if (log)
797     {
798         log->Printf ("SBTarget(%p)::Launch (...) => SBProceess(%p)",
799                      target_sp.get(), process_sp.get());
800     }
801 
802     return sb_process;
803 }
804 
805 lldb::SBProcess
806 SBTarget::Attach (SBAttachInfo &sb_attach_info, SBError& error)
807 {
808     SBProcess sb_process;
809     ProcessSP process_sp;
810     TargetSP target_sp(GetSP());
811     if (target_sp)
812     {
813         Mutex::Locker api_locker (target_sp->GetAPIMutex());
814 
815         StateType state = eStateInvalid;
816         process_sp = target_sp->GetProcessSP();
817         if (process_sp)
818         {
819             state = process_sp->GetState();
820 
821             if (process_sp->IsAlive() && state != eStateConnected)
822             {
823                 if (state == eStateAttaching)
824                     error.SetErrorString ("process attach is in progress");
825                 else
826                     error.SetErrorString ("a process is already being debugged");
827                 return sb_process;
828             }
829         }
830 
831         if (state != eStateConnected)
832             process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
833 
834         if (process_sp)
835         {
836             ProcessAttachInfo &attach_info = sb_attach_info.ref();
837             lldb::pid_t attach_pid = attach_info.GetProcessID();
838             if (attach_pid != LLDB_INVALID_PROCESS_ID)
839             {
840                 PlatformSP platform_sp = target_sp->GetPlatform();
841                 ProcessInstanceInfo instance_info;
842                 if (platform_sp->GetProcessInfo(attach_pid, instance_info))
843                 {
844                     attach_info.SetUserID(instance_info.GetEffectiveUserID());
845                 }
846             }
847             error.SetError (process_sp->Attach (attach_info));
848             if (error.Success())
849             {
850                 sb_process.SetSP (process_sp);
851                 // If we are doing synchronous mode, then wait for the
852                 // process to stop!
853                 if (target_sp->GetDebugger().GetAsyncExecution () == false)
854                     process_sp->WaitForProcessToStop (NULL);
855             }
856         }
857         else
858         {
859             error.SetErrorString ("unable to create lldb_private::Process");
860         }
861     }
862     else
863     {
864         error.SetErrorString ("SBTarget is invalid");
865     }
866     return sb_process;
867 }
868 
869 
870 #if defined(__APPLE__)
871 
872 lldb::SBProcess
873 SBTarget::AttachToProcessWithID (SBListener &listener,
874                                 ::pid_t pid,
875                                  lldb::SBError& error)
876 {
877     return AttachToProcessWithID (listener, (lldb::pid_t)pid, error);
878 }
879 
880 #endif // #if defined(__APPLE__)
881 
882 lldb::SBProcess
883 SBTarget::AttachToProcessWithID
884 (
885     SBListener &listener,
886     lldb::pid_t pid,// The process ID to attach to
887     SBError& error  // An error explaining what went wrong if attach fails
888 )
889 {
890     SBProcess sb_process;
891     ProcessSP process_sp;
892     TargetSP target_sp(GetSP());
893     if (target_sp)
894     {
895         Mutex::Locker api_locker (target_sp->GetAPIMutex());
896 
897         StateType state = eStateInvalid;
898         process_sp = target_sp->GetProcessSP();
899         if (process_sp)
900         {
901             state = process_sp->GetState();
902 
903             if (process_sp->IsAlive() && state != eStateConnected)
904             {
905                 if (state == eStateAttaching)
906                     error.SetErrorString ("process attach is in progress");
907                 else
908                     error.SetErrorString ("a process is already being debugged");
909                 return sb_process;
910             }
911         }
912 
913         if (state == eStateConnected)
914         {
915             // If we are already connected, then we have already specified the
916             // listener, so if a valid listener is supplied, we need to error out
917             // to let the client know.
918             if (listener.IsValid())
919             {
920                 error.SetErrorString ("process is connected and already has a listener, pass empty listener");
921                 return sb_process;
922             }
923         }
924         else
925         {
926             if (listener.IsValid())
927                 process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL);
928             else
929                 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
930         }
931         if (process_sp)
932         {
933             sb_process.SetSP (process_sp);
934 
935             ProcessAttachInfo attach_info;
936             attach_info.SetProcessID (pid);
937 
938             PlatformSP platform_sp = target_sp->GetPlatform();
939             ProcessInstanceInfo instance_info;
940             if (platform_sp->GetProcessInfo(pid, instance_info))
941             {
942                 attach_info.SetUserID(instance_info.GetEffectiveUserID());
943             }
944             error.SetError (process_sp->Attach (attach_info));
945             // If we are doing synchronous mode, then wait for the
946             // process to stop!
947             if (target_sp->GetDebugger().GetAsyncExecution () == false)
948                 process_sp->WaitForProcessToStop (NULL);
949         }
950         else
951         {
952             error.SetErrorString ("unable to create lldb_private::Process");
953         }
954     }
955     else
956     {
957         error.SetErrorString ("SBTarget is invalid");
958     }
959     return sb_process;
960 
961 }
962 
963 lldb::SBProcess
964 SBTarget::AttachToProcessWithName
965 (
966     SBListener &listener,
967     const char *name,   // basename of process to attach to
968     bool wait_for,      // if true wait for a new instance of "name" to be launched
969     SBError& error      // An error explaining what went wrong if attach fails
970 )
971 {
972     SBProcess sb_process;
973     ProcessSP process_sp;
974     TargetSP target_sp(GetSP());
975     if (name && target_sp)
976     {
977         Mutex::Locker api_locker (target_sp->GetAPIMutex());
978 
979         StateType state = eStateInvalid;
980         process_sp = target_sp->GetProcessSP();
981         if (process_sp)
982         {
983             state = process_sp->GetState();
984 
985             if (process_sp->IsAlive() && state != eStateConnected)
986             {
987                 if (state == eStateAttaching)
988                     error.SetErrorString ("process attach is in progress");
989                 else
990                     error.SetErrorString ("a process is already being debugged");
991                 return sb_process;
992             }
993         }
994 
995         if (state == eStateConnected)
996         {
997             // If we are already connected, then we have already specified the
998             // listener, so if a valid listener is supplied, we need to error out
999             // to let the client know.
1000             if (listener.IsValid())
1001             {
1002                 error.SetErrorString ("process is connected and already has a listener, pass empty listener");
1003                 return sb_process;
1004             }
1005         }
1006         else
1007         {
1008             if (listener.IsValid())
1009                 process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL);
1010             else
1011                 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
1012         }
1013 
1014         if (process_sp)
1015         {
1016             sb_process.SetSP (process_sp);
1017             ProcessAttachInfo attach_info;
1018             attach_info.GetExecutableFile().SetFile(name, false);
1019             attach_info.SetWaitForLaunch(wait_for);
1020             error.SetError (process_sp->Attach (attach_info));
1021             // If we are doing synchronous mode, then wait for the
1022             // process to stop!
1023             if (target_sp->GetDebugger().GetAsyncExecution () == false)
1024                 process_sp->WaitForProcessToStop (NULL);
1025         }
1026         else
1027         {
1028             error.SetErrorString ("unable to create lldb_private::Process");
1029         }
1030     }
1031     else
1032     {
1033         error.SetErrorString ("SBTarget is invalid");
1034     }
1035     return sb_process;
1036 
1037 }
1038 
1039 lldb::SBProcess
1040 SBTarget::ConnectRemote
1041 (
1042     SBListener &listener,
1043     const char *url,
1044     const char *plugin_name,
1045     SBError& error
1046 )
1047 {
1048     SBProcess sb_process;
1049     ProcessSP process_sp;
1050     TargetSP target_sp(GetSP());
1051     if (target_sp)
1052     {
1053         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1054         if (listener.IsValid())
1055             process_sp = target_sp->CreateProcess (listener.ref(), plugin_name, NULL);
1056         else
1057             process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), plugin_name, NULL);
1058 
1059 
1060         if (process_sp)
1061         {
1062             sb_process.SetSP (process_sp);
1063             error.SetError (process_sp->ConnectRemote (url));
1064         }
1065         else
1066         {
1067             error.SetErrorString ("unable to create lldb_private::Process");
1068         }
1069     }
1070     else
1071     {
1072         error.SetErrorString ("SBTarget is invalid");
1073     }
1074     return sb_process;
1075 }
1076 
1077 SBFileSpec
1078 SBTarget::GetExecutable ()
1079 {
1080 
1081     SBFileSpec exe_file_spec;
1082     TargetSP target_sp(GetSP());
1083     if (target_sp)
1084     {
1085         Module *exe_module = target_sp->GetExecutableModulePointer();
1086         if (exe_module)
1087             exe_file_spec.SetFileSpec (exe_module->GetFileSpec());
1088     }
1089 
1090     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1091     if (log)
1092     {
1093         log->Printf ("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)",
1094                      target_sp.get(), exe_file_spec.get());
1095     }
1096 
1097     return exe_file_spec;
1098 }
1099 
1100 bool
1101 SBTarget::operator == (const SBTarget &rhs) const
1102 {
1103     return m_opaque_sp.get() == rhs.m_opaque_sp.get();
1104 }
1105 
1106 bool
1107 SBTarget::operator != (const SBTarget &rhs) const
1108 {
1109     return m_opaque_sp.get() != rhs.m_opaque_sp.get();
1110 }
1111 
1112 lldb::TargetSP
1113 SBTarget::GetSP () const
1114 {
1115     return m_opaque_sp;
1116 }
1117 
1118 void
1119 SBTarget::SetSP (const lldb::TargetSP& target_sp)
1120 {
1121     m_opaque_sp = target_sp;
1122 }
1123 
1124 lldb::SBAddress
1125 SBTarget::ResolveLoadAddress (lldb::addr_t vm_addr)
1126 {
1127     lldb::SBAddress sb_addr;
1128     Address &addr = sb_addr.ref();
1129     TargetSP target_sp(GetSP());
1130     if (target_sp)
1131     {
1132         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1133         if (target_sp->GetSectionLoadList().ResolveLoadAddress (vm_addr, addr))
1134             return sb_addr;
1135     }
1136 
1137     // We have a load address that isn't in a section, just return an address
1138     // with the offset filled in (the address) and the section set to NULL
1139     addr.SetRawAddress(vm_addr);
1140     return sb_addr;
1141 }
1142 
1143 SBSymbolContext
1144 SBTarget::ResolveSymbolContextForAddress (const SBAddress& addr, uint32_t resolve_scope)
1145 {
1146     SBSymbolContext sc;
1147     if (addr.IsValid())
1148     {
1149         TargetSP target_sp(GetSP());
1150         if (target_sp)
1151             target_sp->GetImages().ResolveSymbolContextForAddress (addr.ref(), resolve_scope, sc.ref());
1152     }
1153     return sc;
1154 }
1155 
1156 
1157 SBBreakpoint
1158 SBTarget::BreakpointCreateByLocation (const char *file, uint32_t line)
1159 {
1160     return SBBreakpoint(BreakpointCreateByLocation (SBFileSpec (file, false), line));
1161 }
1162 
1163 SBBreakpoint
1164 SBTarget::BreakpointCreateByLocation (const SBFileSpec &sb_file_spec, uint32_t line)
1165 {
1166     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1167 
1168     SBBreakpoint sb_bp;
1169     TargetSP target_sp(GetSP());
1170     if (target_sp && line != 0)
1171     {
1172         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1173 
1174         const bool check_inlines = true;
1175         const bool internal = false;
1176         const LazyBool skip_prologue = eLazyBoolCalculate;
1177         *sb_bp = target_sp->CreateBreakpoint (NULL, *sb_file_spec, line, check_inlines, skip_prologue, internal);
1178     }
1179 
1180     if (log)
1181     {
1182         SBStream sstr;
1183         sb_bp.GetDescription (sstr);
1184         char path[PATH_MAX];
1185         sb_file_spec->GetPath (path, sizeof(path));
1186         log->Printf ("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => SBBreakpoint(%p): %s",
1187                      target_sp.get(),
1188                      path,
1189                      line,
1190                      sb_bp.get(),
1191                      sstr.GetData());
1192     }
1193 
1194     return sb_bp;
1195 }
1196 
1197 SBBreakpoint
1198 SBTarget::BreakpointCreateByName (const char *symbol_name, const char *module_name)
1199 {
1200     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1201 
1202     SBBreakpoint sb_bp;
1203     TargetSP target_sp(GetSP());
1204     if (target_sp.get())
1205     {
1206         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1207 
1208         const bool internal = false;
1209         const LazyBool skip_prologue = eLazyBoolCalculate;
1210         if (module_name && module_name[0])
1211         {
1212             FileSpecList module_spec_list;
1213             module_spec_list.Append (FileSpec (module_name, false));
1214             *sb_bp = target_sp->CreateBreakpoint (&module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, skip_prologue, internal);
1215         }
1216         else
1217         {
1218             *sb_bp = target_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, skip_prologue, internal);
1219         }
1220     }
1221 
1222     if (log)
1223     {
1224         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", module=\"%s\") => SBBreakpoint(%p)",
1225                      target_sp.get(), symbol_name, module_name, sb_bp.get());
1226     }
1227 
1228     return sb_bp;
1229 }
1230 
1231 lldb::SBBreakpoint
1232 SBTarget::BreakpointCreateByName (const char *symbol_name,
1233                             const SBFileSpecList &module_list,
1234                             const SBFileSpecList &comp_unit_list)
1235 {
1236     uint32_t name_type_mask = eFunctionNameTypeAuto;
1237     return BreakpointCreateByName (symbol_name, name_type_mask, module_list, comp_unit_list);
1238 }
1239 
1240 lldb::SBBreakpoint
1241 SBTarget::BreakpointCreateByName (const char *symbol_name,
1242                             uint32_t name_type_mask,
1243                             const SBFileSpecList &module_list,
1244                             const SBFileSpecList &comp_unit_list)
1245 {
1246     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1247 
1248     SBBreakpoint sb_bp;
1249     TargetSP target_sp(GetSP());
1250     if (target_sp && symbol_name && symbol_name[0])
1251     {
1252         const bool internal = false;
1253         const LazyBool skip_prologue = eLazyBoolCalculate;
1254         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1255         *sb_bp = target_sp->CreateBreakpoint (module_list.get(),
1256                                                 comp_unit_list.get(),
1257                                                 symbol_name,
1258                                                 name_type_mask,
1259                                                 skip_prologue,
1260                                                 internal);
1261     }
1262 
1263     if (log)
1264     {
1265         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)",
1266                      target_sp.get(), symbol_name, name_type_mask, sb_bp.get());
1267     }
1268 
1269     return sb_bp;
1270 }
1271 
1272 lldb::SBBreakpoint
1273 SBTarget::BreakpointCreateByNames (const char *symbol_names[],
1274                                    uint32_t num_names,
1275                                    uint32_t name_type_mask,
1276                                    const SBFileSpecList &module_list,
1277                                    const SBFileSpecList &comp_unit_list)
1278 {
1279     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1280 
1281     SBBreakpoint sb_bp;
1282     TargetSP target_sp(GetSP());
1283     if (target_sp && num_names > 0)
1284     {
1285         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1286         const bool internal = false;
1287         const LazyBool skip_prologue = eLazyBoolCalculate;
1288         *sb_bp = target_sp->CreateBreakpoint (module_list.get(),
1289                                                 comp_unit_list.get(),
1290                                                 symbol_names,
1291                                                 num_names,
1292                                                 name_type_mask,
1293                                                 skip_prologue,
1294                                                 internal);
1295     }
1296 
1297     if (log)
1298     {
1299         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbols={", target_sp.get());
1300         for (uint32_t i = 0 ; i < num_names; i++)
1301         {
1302             char sep;
1303             if (i < num_names - 1)
1304                 sep = ',';
1305             else
1306                 sep = '}';
1307             if (symbol_names[i] != NULL)
1308                 log->Printf ("\"%s\"%c ", symbol_names[i], sep);
1309             else
1310                 log->Printf ("\"<NULL>\"%c ", sep);
1311 
1312         }
1313         log->Printf ("name_type: %d) => SBBreakpoint(%p)", name_type_mask, sb_bp.get());
1314     }
1315 
1316     return sb_bp;
1317 }
1318 
1319 SBBreakpoint
1320 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name)
1321 {
1322     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1323 
1324     SBBreakpoint sb_bp;
1325     TargetSP target_sp(GetSP());
1326     if (target_sp && symbol_name_regex && symbol_name_regex[0])
1327     {
1328         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1329         RegularExpression regexp(symbol_name_regex);
1330         const bool internal = false;
1331         const LazyBool skip_prologue = eLazyBoolCalculate;
1332 
1333         if (module_name && module_name[0])
1334         {
1335             FileSpecList module_spec_list;
1336             module_spec_list.Append (FileSpec (module_name, false));
1337 
1338             *sb_bp = target_sp->CreateFuncRegexBreakpoint (&module_spec_list, NULL, regexp, skip_prologue, internal);
1339         }
1340         else
1341         {
1342             *sb_bp = target_sp->CreateFuncRegexBreakpoint (NULL, NULL, regexp, skip_prologue, internal);
1343         }
1344     }
1345 
1346     if (log)
1347     {
1348         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
1349                      target_sp.get(), symbol_name_regex, module_name, sb_bp.get());
1350     }
1351 
1352     return sb_bp;
1353 }
1354 
1355 lldb::SBBreakpoint
1356 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex,
1357                          const SBFileSpecList &module_list,
1358                          const SBFileSpecList &comp_unit_list)
1359 {
1360     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1361 
1362     SBBreakpoint sb_bp;
1363     TargetSP target_sp(GetSP());
1364     if (target_sp && symbol_name_regex && symbol_name_regex[0])
1365     {
1366         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1367         RegularExpression regexp(symbol_name_regex);
1368         const bool internal = false;
1369         const LazyBool skip_prologue = eLazyBoolCalculate;
1370 
1371         *sb_bp = target_sp->CreateFuncRegexBreakpoint (module_list.get(), comp_unit_list.get(), regexp, skip_prologue, internal);
1372     }
1373 
1374     if (log)
1375     {
1376         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") => SBBreakpoint(%p)",
1377                      target_sp.get(), symbol_name_regex, sb_bp.get());
1378     }
1379 
1380     return sb_bp;
1381 }
1382 
1383 SBBreakpoint
1384 SBTarget::BreakpointCreateByAddress (addr_t address)
1385 {
1386     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1387 
1388     SBBreakpoint sb_bp;
1389     TargetSP target_sp(GetSP());
1390     if (target_sp)
1391     {
1392         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1393         *sb_bp = target_sp->CreateBreakpoint (address, false);
1394     }
1395 
1396     if (log)
1397     {
1398         log->Printf ("SBTarget(%p)::BreakpointCreateByAddress (address=%llu) => SBBreakpoint(%p)", target_sp.get(), (uint64_t) address, sb_bp.get());
1399     }
1400 
1401     return sb_bp;
1402 }
1403 
1404 lldb::SBBreakpoint
1405 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name)
1406 {
1407     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1408 
1409     SBBreakpoint sb_bp;
1410     TargetSP target_sp(GetSP());
1411     if (target_sp && source_regex && source_regex[0])
1412     {
1413         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1414         RegularExpression regexp(source_regex);
1415         FileSpecList source_file_spec_list;
1416         source_file_spec_list.Append (source_file.ref());
1417 
1418         if (module_name && module_name[0])
1419         {
1420             FileSpecList module_spec_list;
1421             module_spec_list.Append (FileSpec (module_name, false));
1422 
1423             *sb_bp = target_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false);
1424         }
1425         else
1426         {
1427             *sb_bp = target_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false);
1428         }
1429     }
1430 
1431     if (log)
1432     {
1433         char path[PATH_MAX];
1434         source_file->GetPath (path, sizeof(path));
1435         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\", file=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
1436                      target_sp.get(), source_regex, path, module_name, sb_bp.get());
1437     }
1438 
1439     return sb_bp;
1440 }
1441 
1442 lldb::SBBreakpoint
1443 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
1444                                const SBFileSpecList &module_list,
1445                                const lldb::SBFileSpecList &source_file_list)
1446 {
1447     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1448 
1449     SBBreakpoint sb_bp;
1450     TargetSP target_sp(GetSP());
1451     if (target_sp && source_regex && source_regex[0])
1452     {
1453         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1454         RegularExpression regexp(source_regex);
1455         *sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false);
1456     }
1457 
1458     if (log)
1459     {
1460         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)",
1461                      target_sp.get(), source_regex, sb_bp.get());
1462     }
1463 
1464     return sb_bp;
1465 }
1466 
1467 lldb::SBBreakpoint
1468 SBTarget::BreakpointCreateForException  (lldb::LanguageType language,
1469                                bool catch_bp,
1470                                bool throw_bp)
1471 {
1472     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1473 
1474     SBBreakpoint sb_bp;
1475     TargetSP target_sp(GetSP());
1476     if (target_sp)
1477     {
1478         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1479         *sb_bp = target_sp->CreateExceptionBreakpoint (language, catch_bp, throw_bp);
1480     }
1481 
1482     if (log)
1483     {
1484         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: %s throw: %s) => SBBreakpoint(%p)",
1485                      target_sp.get(),
1486                      LanguageRuntime::GetNameForLanguageType(language),
1487                      catch_bp ? "on" : "off",
1488                      throw_bp ? "on" : "off",
1489                      sb_bp.get());
1490     }
1491 
1492     return sb_bp;
1493 }
1494 
1495 uint32_t
1496 SBTarget::GetNumBreakpoints () const
1497 {
1498     TargetSP target_sp(GetSP());
1499     if (target_sp)
1500     {
1501         // The breakpoint list is thread safe, no need to lock
1502         return target_sp->GetBreakpointList().GetSize();
1503     }
1504     return 0;
1505 }
1506 
1507 SBBreakpoint
1508 SBTarget::GetBreakpointAtIndex (uint32_t idx) const
1509 {
1510     SBBreakpoint sb_breakpoint;
1511     TargetSP target_sp(GetSP());
1512     if (target_sp)
1513     {
1514         // The breakpoint list is thread safe, no need to lock
1515         *sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
1516     }
1517     return sb_breakpoint;
1518 }
1519 
1520 bool
1521 SBTarget::BreakpointDelete (break_id_t bp_id)
1522 {
1523     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1524 
1525     bool result = false;
1526     TargetSP target_sp(GetSP());
1527     if (target_sp)
1528     {
1529         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1530         result = target_sp->RemoveBreakpointByID (bp_id);
1531     }
1532 
1533     if (log)
1534     {
1535         log->Printf ("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", target_sp.get(), (uint32_t) bp_id, result);
1536     }
1537 
1538     return result;
1539 }
1540 
1541 SBBreakpoint
1542 SBTarget::FindBreakpointByID (break_id_t bp_id)
1543 {
1544     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1545 
1546     SBBreakpoint sb_breakpoint;
1547     TargetSP target_sp(GetSP());
1548     if (target_sp && bp_id != LLDB_INVALID_BREAK_ID)
1549     {
1550         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1551         *sb_breakpoint = target_sp->GetBreakpointByID (bp_id);
1552     }
1553 
1554     if (log)
1555     {
1556         log->Printf ("SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)",
1557                      target_sp.get(), (uint32_t) bp_id, sb_breakpoint.get());
1558     }
1559 
1560     return sb_breakpoint;
1561 }
1562 
1563 bool
1564 SBTarget::EnableAllBreakpoints ()
1565 {
1566     TargetSP target_sp(GetSP());
1567     if (target_sp)
1568     {
1569         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1570         target_sp->EnableAllBreakpoints ();
1571         return true;
1572     }
1573     return false;
1574 }
1575 
1576 bool
1577 SBTarget::DisableAllBreakpoints ()
1578 {
1579     TargetSP target_sp(GetSP());
1580     if (target_sp)
1581     {
1582         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1583         target_sp->DisableAllBreakpoints ();
1584         return true;
1585     }
1586     return false;
1587 }
1588 
1589 bool
1590 SBTarget::DeleteAllBreakpoints ()
1591 {
1592     TargetSP target_sp(GetSP());
1593     if (target_sp)
1594     {
1595         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1596         target_sp->RemoveAllBreakpoints ();
1597         return true;
1598     }
1599     return false;
1600 }
1601 
1602 uint32_t
1603 SBTarget::GetNumWatchpoints () const
1604 {
1605     TargetSP target_sp(GetSP());
1606     if (target_sp)
1607     {
1608         // The watchpoint list is thread safe, no need to lock
1609         return target_sp->GetWatchpointList().GetSize();
1610     }
1611     return 0;
1612 }
1613 
1614 SBWatchpoint
1615 SBTarget::GetWatchpointAtIndex (uint32_t idx) const
1616 {
1617     SBWatchpoint sb_watchpoint;
1618     TargetSP target_sp(GetSP());
1619     if (target_sp)
1620     {
1621         // The watchpoint list is thread safe, no need to lock
1622         sb_watchpoint.SetSP (target_sp->GetWatchpointList().GetByIndex(idx));
1623     }
1624     return sb_watchpoint;
1625 }
1626 
1627 bool
1628 SBTarget::DeleteWatchpoint (watch_id_t wp_id)
1629 {
1630     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1631 
1632     bool result = false;
1633     TargetSP target_sp(GetSP());
1634     if (target_sp)
1635     {
1636         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1637         Mutex::Locker locker;
1638         target_sp->GetWatchpointList().GetListMutex(locker);
1639         result = target_sp->RemoveWatchpointByID (wp_id);
1640     }
1641 
1642     if (log)
1643     {
1644         log->Printf ("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", target_sp.get(), (uint32_t) wp_id, result);
1645     }
1646 
1647     return result;
1648 }
1649 
1650 SBWatchpoint
1651 SBTarget::FindWatchpointByID (lldb::watch_id_t wp_id)
1652 {
1653     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1654 
1655     SBWatchpoint sb_watchpoint;
1656     lldb::WatchpointSP watchpoint_sp;
1657     TargetSP target_sp(GetSP());
1658     if (target_sp && wp_id != LLDB_INVALID_WATCH_ID)
1659     {
1660         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1661         Mutex::Locker locker;
1662         target_sp->GetWatchpointList().GetListMutex(locker);
1663         watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id);
1664         sb_watchpoint.SetSP (watchpoint_sp);
1665     }
1666 
1667     if (log)
1668     {
1669         log->Printf ("SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)",
1670                      target_sp.get(), (uint32_t) wp_id, watchpoint_sp.get());
1671     }
1672 
1673     return sb_watchpoint;
1674 }
1675 
1676 lldb::SBWatchpoint
1677 SBTarget::WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write, SBError &error)
1678 {
1679     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1680 
1681     SBWatchpoint sb_watchpoint;
1682     lldb::WatchpointSP watchpoint_sp;
1683     TargetSP target_sp(GetSP());
1684     if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && size > 0)
1685     {
1686         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1687         uint32_t watch_type = 0;
1688         if (read)
1689             watch_type |= LLDB_WATCH_TYPE_READ;
1690         if (write)
1691             watch_type |= LLDB_WATCH_TYPE_WRITE;
1692         // Target::CreateWatchpoint() is thread safe.
1693         Error cw_error;
1694         watchpoint_sp = target_sp->CreateWatchpoint(addr, size, watch_type, cw_error);
1695         error.SetError(cw_error);
1696         sb_watchpoint.SetSP (watchpoint_sp);
1697     }
1698 
1699     if (log)
1700     {
1701         log->Printf ("SBTarget(%p)::WatchAddress (addr=0x%llx, 0x%u) => SBWatchpoint(%p)",
1702                      target_sp.get(), addr, (uint32_t) size, watchpoint_sp.get());
1703     }
1704 
1705     return sb_watchpoint;
1706 }
1707 
1708 bool
1709 SBTarget::EnableAllWatchpoints ()
1710 {
1711     TargetSP target_sp(GetSP());
1712     if (target_sp)
1713     {
1714         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1715         Mutex::Locker locker;
1716         target_sp->GetWatchpointList().GetListMutex(locker);
1717         target_sp->EnableAllWatchpoints ();
1718         return true;
1719     }
1720     return false;
1721 }
1722 
1723 bool
1724 SBTarget::DisableAllWatchpoints ()
1725 {
1726     TargetSP target_sp(GetSP());
1727     if (target_sp)
1728     {
1729         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1730         Mutex::Locker locker;
1731         target_sp->GetWatchpointList().GetListMutex(locker);
1732         target_sp->DisableAllWatchpoints ();
1733         return true;
1734     }
1735     return false;
1736 }
1737 
1738 bool
1739 SBTarget::DeleteAllWatchpoints ()
1740 {
1741     TargetSP target_sp(GetSP());
1742     if (target_sp)
1743     {
1744         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1745         Mutex::Locker locker;
1746         target_sp->GetWatchpointList().GetListMutex(locker);
1747         target_sp->RemoveAllWatchpoints ();
1748         return true;
1749     }
1750     return false;
1751 }
1752 
1753 
1754 lldb::SBModule
1755 SBTarget::AddModule (const char *path,
1756                      const char *triple,
1757                      const char *uuid_cstr)
1758 {
1759     return AddModule (path, triple, uuid_cstr, NULL);
1760 }
1761 
1762 lldb::SBModule
1763 SBTarget::AddModule (const char *path,
1764                      const char *triple,
1765                      const char *uuid_cstr,
1766                      const char *symfile)
1767 {
1768     lldb::SBModule sb_module;
1769     TargetSP target_sp(GetSP());
1770     if (target_sp)
1771     {
1772         ModuleSpec module_spec;
1773         if (path)
1774             module_spec.GetFileSpec().SetFile(path, false);
1775 
1776         if (uuid_cstr)
1777             module_spec.GetUUID().SetfromCString(uuid_cstr);
1778 
1779         if (triple)
1780             module_spec.GetArchitecture().SetTriple (triple, target_sp->GetPlatform ().get());
1781 
1782         if (symfile)
1783             module_spec.GetSymbolFileSpec ().SetFile(symfile, false);
1784 
1785         sb_module.SetSP(target_sp->GetSharedModule (module_spec));
1786     }
1787     return sb_module;
1788 }
1789 
1790 bool
1791 SBTarget::AddModule (lldb::SBModule &module)
1792 {
1793     TargetSP target_sp(GetSP());
1794     if (target_sp)
1795     {
1796         target_sp->GetImages().AppendIfNeeded (module.GetSP());
1797         return true;
1798     }
1799     return false;
1800 }
1801 
1802 uint32_t
1803 SBTarget::GetNumModules () const
1804 {
1805     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1806 
1807     uint32_t num = 0;
1808     TargetSP target_sp(GetSP());
1809     if (target_sp)
1810     {
1811         // The module list is thread safe, no need to lock
1812         num = target_sp->GetImages().GetSize();
1813     }
1814 
1815     if (log)
1816         log->Printf ("SBTarget(%p)::GetNumModules () => %d", target_sp.get(), num);
1817 
1818     return num;
1819 }
1820 
1821 void
1822 SBTarget::Clear ()
1823 {
1824     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1825 
1826     if (log)
1827         log->Printf ("SBTarget(%p)::Clear ()", m_opaque_sp.get());
1828 
1829     m_opaque_sp.reset();
1830 }
1831 
1832 
1833 SBModule
1834 SBTarget::FindModule (const SBFileSpec &sb_file_spec)
1835 {
1836     SBModule sb_module;
1837     TargetSP target_sp(GetSP());
1838     if (target_sp && sb_file_spec.IsValid())
1839     {
1840         ModuleSpec module_spec(*sb_file_spec);
1841         // The module list is thread safe, no need to lock
1842         sb_module.SetSP (target_sp->GetImages().FindFirstModule (module_spec));
1843     }
1844     return sb_module;
1845 }
1846 
1847 lldb::ByteOrder
1848 SBTarget::GetByteOrder ()
1849 {
1850     TargetSP target_sp(GetSP());
1851     if (target_sp)
1852         return target_sp->GetArchitecture().GetByteOrder();
1853     return eByteOrderInvalid;
1854 }
1855 
1856 const char *
1857 SBTarget::GetTriple ()
1858 {
1859     TargetSP target_sp(GetSP());
1860     if (target_sp)
1861     {
1862         std::string triple (target_sp->GetArchitecture().GetTriple().str());
1863         // Unique the string so we don't run into ownership issues since
1864         // the const strings put the string into the string pool once and
1865         // the strings never comes out
1866         ConstString const_triple (triple.c_str());
1867         return const_triple.GetCString();
1868     }
1869     return NULL;
1870 }
1871 
1872 uint32_t
1873 SBTarget::GetAddressByteSize()
1874 {
1875     TargetSP target_sp(GetSP());
1876     if (target_sp)
1877         return target_sp->GetArchitecture().GetAddressByteSize();
1878     return sizeof(void*);
1879 }
1880 
1881 
1882 SBModule
1883 SBTarget::GetModuleAtIndex (uint32_t idx)
1884 {
1885     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1886 
1887     SBModule sb_module;
1888     ModuleSP module_sp;
1889     TargetSP target_sp(GetSP());
1890     if (target_sp)
1891     {
1892         // The module list is thread safe, no need to lock
1893         module_sp = target_sp->GetImages().GetModuleAtIndex(idx);
1894         sb_module.SetSP (module_sp);
1895     }
1896 
1897     if (log)
1898     {
1899         log->Printf ("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)",
1900                      target_sp.get(), idx, module_sp.get());
1901     }
1902 
1903     return sb_module;
1904 }
1905 
1906 bool
1907 SBTarget::RemoveModule (lldb::SBModule module)
1908 {
1909     TargetSP target_sp(GetSP());
1910     if (target_sp)
1911         return target_sp->GetImages().Remove(module.GetSP());
1912     return false;
1913 }
1914 
1915 
1916 SBBroadcaster
1917 SBTarget::GetBroadcaster () const
1918 {
1919     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1920 
1921     TargetSP target_sp(GetSP());
1922     SBBroadcaster broadcaster(target_sp.get(), false);
1923 
1924     if (log)
1925         log->Printf ("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)",
1926                      target_sp.get(), broadcaster.get());
1927 
1928     return broadcaster;
1929 }
1930 
1931 bool
1932 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level)
1933 {
1934     Stream &strm = description.ref();
1935 
1936     TargetSP target_sp(GetSP());
1937     if (target_sp)
1938     {
1939         target_sp->Dump (&strm, description_level);
1940     }
1941     else
1942         strm.PutCString ("No value");
1943 
1944     return true;
1945 }
1946 
1947 lldb::SBSymbolContextList
1948 SBTarget::FindFunctions (const char *name, uint32_t name_type_mask)
1949 {
1950     lldb::SBSymbolContextList sb_sc_list;
1951     if (name && name[0])
1952     {
1953         TargetSP target_sp(GetSP());
1954         if (target_sp)
1955         {
1956             const bool symbols_ok = true;
1957             const bool inlines_ok = true;
1958             const bool append = true;
1959             target_sp->GetImages().FindFunctions (ConstString(name),
1960                                                   name_type_mask,
1961                                                   symbols_ok,
1962                                                   inlines_ok,
1963                                                   append,
1964                                                   *sb_sc_list);
1965         }
1966     }
1967     return sb_sc_list;
1968 }
1969 
1970 lldb::SBType
1971 SBTarget::FindFirstType (const char* type)
1972 {
1973     TargetSP target_sp(GetSP());
1974     if (type && target_sp)
1975     {
1976         size_t count = target_sp->GetImages().GetSize();
1977         for (size_t idx = 0; idx < count; idx++)
1978         {
1979             SBType found_at_idx = GetModuleAtIndex(idx).FindFirstType(type);
1980 
1981             if (found_at_idx.IsValid())
1982                 return found_at_idx;
1983         }
1984     }
1985     return SBType();
1986 }
1987 
1988 lldb::SBTypeList
1989 SBTarget::FindTypes (const char* type)
1990 {
1991 
1992     SBTypeList retval;
1993 
1994     TargetSP target_sp(GetSP());
1995     if (type && target_sp)
1996     {
1997         ModuleList& images = target_sp->GetImages();
1998         ConstString name_const(type);
1999         bool exact_match = false;
2000         SymbolContext sc;
2001         TypeList type_list;
2002 
2003         uint32_t num_matches = images.FindTypes (sc,
2004                                                  name_const,
2005                                                  exact_match,
2006                                                  UINT32_MAX,
2007                                                  type_list);
2008 
2009         for (size_t idx = 0; idx < num_matches; idx++)
2010         {
2011             TypeSP type_sp (type_list.GetTypeAtIndex(idx));
2012             if (type_sp)
2013                 retval.Append(SBType(type_sp));
2014         }
2015     }
2016     return retval;
2017 }
2018 
2019 SBValueList
2020 SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches)
2021 {
2022     SBValueList sb_value_list;
2023 
2024     TargetSP target_sp(GetSP());
2025     if (name && target_sp)
2026     {
2027         VariableList variable_list;
2028         const bool append = true;
2029         const uint32_t match_count = target_sp->GetImages().FindGlobalVariables (ConstString (name),
2030                                                                                  append,
2031                                                                                  max_matches,
2032                                                                                  variable_list);
2033 
2034         if (match_count > 0)
2035         {
2036             ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
2037             if (exe_scope == NULL)
2038                 exe_scope = target_sp.get();
2039             ValueObjectList &value_object_list = sb_value_list.ref();
2040             for (uint32_t i=0; i<match_count; ++i)
2041             {
2042                 lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i)));
2043                 if (valobj_sp)
2044                     value_object_list.Append(valobj_sp);
2045             }
2046         }
2047     }
2048 
2049     return sb_value_list;
2050 }
2051 
2052 SBSourceManager
2053 SBTarget::GetSourceManager()
2054 {
2055     SBSourceManager source_manager (*this);
2056     return source_manager;
2057 }
2058 
2059 lldb::SBInstructionList
2060 SBTarget::ReadInstructions (lldb::SBAddress base_addr, uint32_t count)
2061 {
2062     SBInstructionList sb_instructions;
2063 
2064     TargetSP target_sp(GetSP());
2065     if (target_sp)
2066     {
2067         Address *addr_ptr = base_addr.get();
2068 
2069         if (addr_ptr)
2070         {
2071             DataBufferHeap data (target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
2072             bool prefer_file_cache = false;
2073             lldb_private::Error error;
2074             const size_t bytes_read = target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(), data.GetByteSize(), error);
2075             sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(),
2076                                                                              NULL,
2077                                                                              *addr_ptr,
2078                                                                              data.GetBytes(),
2079                                                                              bytes_read,
2080                                                                              count));
2081         }
2082     }
2083 
2084     return sb_instructions;
2085 
2086 }
2087 
2088 lldb::SBInstructionList
2089 SBTarget::GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size)
2090 {
2091     SBInstructionList sb_instructions;
2092 
2093     TargetSP target_sp(GetSP());
2094     if (target_sp)
2095     {
2096         Address addr;
2097 
2098         if (base_addr.get())
2099             addr = *base_addr.get();
2100 
2101         sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(),
2102                                                                          NULL,
2103                                                                          addr,
2104                                                                          buf,
2105                                                                          size));
2106     }
2107 
2108     return sb_instructions;
2109 }
2110 
2111 lldb::SBInstructionList
2112 SBTarget::GetInstructions (lldb::addr_t base_addr, const void *buf, size_t size)
2113 {
2114     return GetInstructions (ResolveLoadAddress(base_addr), buf, size);
2115 }
2116 
2117 SBError
2118 SBTarget::SetSectionLoadAddress (lldb::SBSection section,
2119                                  lldb::addr_t section_base_addr)
2120 {
2121     SBError sb_error;
2122     TargetSP target_sp(GetSP());
2123     if (target_sp)
2124     {
2125         if (!section.IsValid())
2126         {
2127             sb_error.SetErrorStringWithFormat ("invalid section");
2128         }
2129         else
2130         {
2131             SectionSP section_sp (section.GetSP());
2132             if (section_sp)
2133             {
2134                 if (section_sp->IsThreadSpecific())
2135                 {
2136                     sb_error.SetErrorString ("thread specific sections are not yet supported");
2137                 }
2138                 else
2139                 {
2140                     target_sp->GetSectionLoadList().SetSectionLoadAddress (section_sp, section_base_addr);
2141                 }
2142             }
2143         }
2144     }
2145     else
2146     {
2147         sb_error.SetErrorString ("invalid target");
2148     }
2149     return sb_error;
2150 }
2151 
2152 SBError
2153 SBTarget::ClearSectionLoadAddress (lldb::SBSection section)
2154 {
2155     SBError sb_error;
2156 
2157     TargetSP target_sp(GetSP());
2158     if (target_sp)
2159     {
2160         if (!section.IsValid())
2161         {
2162             sb_error.SetErrorStringWithFormat ("invalid section");
2163         }
2164         else
2165         {
2166             target_sp->GetSectionLoadList().SetSectionUnloaded (section.GetSP());
2167         }
2168     }
2169     else
2170     {
2171         sb_error.SetErrorStringWithFormat ("invalid target");
2172     }
2173     return sb_error;
2174 }
2175 
2176 SBError
2177 SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset)
2178 {
2179     SBError sb_error;
2180 
2181     TargetSP target_sp(GetSP());
2182     if (target_sp)
2183     {
2184         ModuleSP module_sp (module.GetSP());
2185         if (module_sp)
2186         {
2187             bool changed = false;
2188             if (module_sp->SetLoadAddress (*target_sp, slide_offset, changed))
2189             {
2190                 // The load was successful, make sure that at least some sections
2191                 // changed before we notify that our module was loaded.
2192                 if (changed)
2193                 {
2194                     ModuleList module_list;
2195                     module_list.Append(module_sp);
2196                     target_sp->ModulesDidLoad (module_list);
2197                 }
2198             }
2199         }
2200         else
2201         {
2202             sb_error.SetErrorStringWithFormat ("invalid module");
2203         }
2204 
2205     }
2206     else
2207     {
2208         sb_error.SetErrorStringWithFormat ("invalid target");
2209     }
2210     return sb_error;
2211 }
2212 
2213 SBError
2214 SBTarget::ClearModuleLoadAddress (lldb::SBModule module)
2215 {
2216     SBError sb_error;
2217 
2218     char path[PATH_MAX];
2219     TargetSP target_sp(GetSP());
2220     if (target_sp)
2221     {
2222         ModuleSP module_sp (module.GetSP());
2223         if (module_sp)
2224         {
2225             ObjectFile *objfile = module_sp->GetObjectFile();
2226             if (objfile)
2227             {
2228                 SectionList *section_list = objfile->GetSectionList();
2229                 if (section_list)
2230                 {
2231                     const size_t num_sections = section_list->GetSize();
2232                     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
2233                     {
2234                         SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx));
2235                         if (section_sp)
2236                             target_sp->GetSectionLoadList().SetSectionUnloaded (section_sp);
2237                     }
2238                 }
2239                 else
2240                 {
2241                     module_sp->GetFileSpec().GetPath (path, sizeof(path));
2242                     sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path);
2243                 }
2244             }
2245             else
2246             {
2247                 module_sp->GetFileSpec().GetPath (path, sizeof(path));
2248                 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path);
2249             }
2250         }
2251         else
2252         {
2253             sb_error.SetErrorStringWithFormat ("invalid module");
2254         }
2255     }
2256     else
2257     {
2258         sb_error.SetErrorStringWithFormat ("invalid target");
2259     }
2260     return sb_error;
2261 }
2262 
2263 
2264