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