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/Process.h"
45 #include "lldb/Target/Target.h"
46 #include "lldb/Target/TargetList.h"
47 
48 #include "lldb/Interpreter/CommandReturnObject.h"
49 #include "../source/Commands/CommandObjectBreakpoint.h"
50 
51 
52 using namespace lldb;
53 using namespace lldb_private;
54 
55 #define DEFAULT_DISASM_BYTE_SIZE 32
56 
57 //----------------------------------------------------------------------
58 // SBTarget constructor
59 //----------------------------------------------------------------------
60 SBTarget::SBTarget () :
61     m_opaque_sp ()
62 {
63 }
64 
65 SBTarget::SBTarget (const SBTarget& rhs) :
66     m_opaque_sp (rhs.m_opaque_sp)
67 {
68 }
69 
70 SBTarget::SBTarget(const TargetSP& target_sp) :
71     m_opaque_sp (target_sp)
72 {
73 }
74 
75 const SBTarget&
76 SBTarget::operator = (const SBTarget& rhs)
77 {
78     if (this != &rhs)
79         m_opaque_sp = rhs.m_opaque_sp;
80     return *this;
81 }
82 
83 //----------------------------------------------------------------------
84 // Destructor
85 //----------------------------------------------------------------------
86 SBTarget::~SBTarget()
87 {
88 }
89 
90 bool
91 SBTarget::IsValid () const
92 {
93     return m_opaque_sp.get() != NULL;
94 }
95 
96 SBProcess
97 SBTarget::GetProcess ()
98 {
99 
100     SBProcess sb_process;
101     if (m_opaque_sp)
102     {
103         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
104         sb_process.SetProcess (m_opaque_sp->GetProcessSP());
105     }
106 
107     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
108     if (log)
109     {
110         log->Printf ("SBTarget(%p)::GetProcess () => SBProcess(%p)",
111                      m_opaque_sp.get(), sb_process.get());
112     }
113 
114     return sb_process;
115 }
116 
117 SBDebugger
118 SBTarget::GetDebugger () const
119 {
120     SBDebugger debugger;
121     if (m_opaque_sp)
122         debugger.reset (m_opaque_sp->GetDebugger().GetSP());
123     return debugger;
124 }
125 
126 SBProcess
127 SBTarget::LaunchSimple
128 (
129     char const **argv,
130     char const **envp,
131     const char *working_directory
132 )
133 {
134     char *stdin_path = NULL;
135     char *stdout_path = NULL;
136     char *stderr_path = NULL;
137     uint32_t launch_flags = 0;
138     bool stop_at_entry = false;
139     SBError error;
140     SBListener listener = GetDebugger().GetListener();
141     return Launch (listener,
142                    argv,
143                    envp,
144                    stdin_path,
145                    stdout_path,
146                    stderr_path,
147                    working_directory,
148                    launch_flags,
149                    stop_at_entry,
150                    error);
151 }
152 
153 SBProcess
154 SBTarget::Launch
155 (
156     SBListener &listener,
157     char const **argv,
158     char const **envp,
159     const char *stdin_path,
160     const char *stdout_path,
161     const char *stderr_path,
162     const char *working_directory,
163     uint32_t launch_flags,   // See LaunchFlags
164     bool stop_at_entry,
165     lldb::SBError& error
166 )
167 {
168     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
169 
170     if (log)
171     {
172         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))...",
173                      m_opaque_sp.get(),
174                      argv,
175                      envp,
176                      stdin_path ? stdin_path : "NULL",
177                      stdout_path ? stdout_path : "NULL",
178                      stderr_path ? stderr_path : "NULL",
179                      working_directory ? working_directory : "NULL",
180                      launch_flags,
181                      stop_at_entry,
182                      error.get());
183     }
184     SBProcess sb_process;
185     if (m_opaque_sp)
186     {
187         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
188 
189         if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR"))
190             launch_flags |= eLaunchFlagDisableASLR;
191 
192         StateType state = eStateInvalid;
193         sb_process.SetProcess (m_opaque_sp->GetProcessSP());
194         if (sb_process.IsValid())
195         {
196             state = sb_process->GetState();
197 
198             if (sb_process->IsAlive() && state != eStateConnected)
199             {
200                 if (state == eStateAttaching)
201                     error.SetErrorString ("process attach is in progress");
202                 else
203                     error.SetErrorString ("a process is already being debugged");
204                 sb_process.Clear();
205                 return sb_process;
206             }
207         }
208 
209         if (state == eStateConnected)
210         {
211             // If we are already connected, then we have already specified the
212             // listener, so if a valid listener is supplied, we need to error out
213             // to let the client know.
214             if (listener.IsValid())
215             {
216                 error.SetErrorString ("process is connected and already has a listener, pass empty listener");
217                 sb_process.Clear();
218                 return sb_process;
219             }
220         }
221         else
222         {
223             if (listener.IsValid())
224                 sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref()));
225             else
226                 sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener()));
227         }
228 
229         if (sb_process.IsValid())
230         {
231             if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO"))
232                 launch_flags |= eLaunchFlagDisableSTDIO;
233 
234             error.SetError (sb_process->Launch (argv, envp, launch_flags, stdin_path, stdout_path, stderr_path, working_directory));
235             if (error.Success())
236             {
237                 // We we are stopping at the entry point, we can return now!
238                 if (stop_at_entry)
239                     return sb_process;
240 
241                 // Make sure we are stopped at the entry
242                 StateType state = sb_process->WaitForProcessToStop (NULL);
243                 if (state == eStateStopped)
244                 {
245                     // resume the process to skip the entry point
246                     error.SetError (sb_process->Resume());
247                     if (error.Success())
248                     {
249                         // If we are doing synchronous mode, then wait for the
250                         // process to stop yet again!
251                         if (m_opaque_sp->GetDebugger().GetAsyncExecution () == false)
252                             sb_process->WaitForProcessToStop (NULL);
253                     }
254                 }
255             }
256         }
257         else
258         {
259             error.SetErrorString ("unable to create lldb_private::Process");
260         }
261     }
262     else
263     {
264         error.SetErrorString ("SBTarget is invalid");
265     }
266 
267     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
268     if (log)
269     {
270         log->Printf ("SBTarget(%p)::Launch (...) => SBProceess(%p)",
271                      m_opaque_sp.get(), sb_process.get());
272     }
273 
274     return sb_process;
275 }
276 
277 
278 lldb::SBProcess
279 SBTarget::AttachToProcessWithID
280 (
281     SBListener &listener,
282     lldb::pid_t pid,// The process ID to attach to
283     SBError& error  // An error explaining what went wrong if attach fails
284 )
285 {
286     SBProcess sb_process;
287     if (m_opaque_sp)
288     {
289         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
290 
291         StateType state = eStateInvalid;
292         sb_process.SetProcess (m_opaque_sp->GetProcessSP());
293         if (sb_process.IsValid())
294         {
295             state = sb_process->GetState();
296 
297             if (sb_process->IsAlive() && state != eStateConnected)
298             {
299                 if (state == eStateAttaching)
300                     error.SetErrorString ("process attach is in progress");
301                 else
302                     error.SetErrorString ("a process is already being debugged");
303                 sb_process.Clear();
304                 return sb_process;
305             }
306         }
307 
308         if (state == eStateConnected)
309         {
310             // If we are already connected, then we have already specified the
311             // listener, so if a valid listener is supplied, we need to error out
312             // to let the client know.
313             if (listener.IsValid())
314             {
315                 error.SetErrorString ("process is connected and already has a listener, pass empty listener");
316                 sb_process.Clear();
317                 return sb_process;
318             }
319         }
320         else
321         {
322             if (listener.IsValid())
323                 sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref()));
324             else
325                 sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener()));
326         }
327 
328         if (sb_process.IsValid())
329         {
330             error.SetError (sb_process->Attach (pid));
331             // If we are doing synchronous mode, then wait for the
332             // process to stop!
333             if (m_opaque_sp->GetDebugger().GetAsyncExecution () == false)
334                 sb_process->WaitForProcessToStop (NULL);
335         }
336         else
337         {
338             error.SetErrorString ("unable to create lldb_private::Process");
339         }
340     }
341     else
342     {
343         error.SetErrorString ("SBTarget is invalid");
344     }
345     return sb_process;
346 
347 }
348 
349 lldb::SBProcess
350 SBTarget::AttachToProcessWithName
351 (
352     SBListener &listener,
353     const char *name,   // basename of process to attach to
354     bool wait_for,      // if true wait for a new instance of "name" to be launched
355     SBError& error      // An error explaining what went wrong if attach fails
356 )
357 {
358     SBProcess sb_process;
359     if (m_opaque_sp)
360     {
361         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
362 
363         StateType state = eStateInvalid;
364         sb_process.SetProcess (m_opaque_sp->GetProcessSP());
365         if (sb_process.IsValid())
366         {
367             state = sb_process->GetState();
368 
369             if (sb_process->IsAlive() && state != eStateConnected)
370             {
371                 if (state == eStateAttaching)
372                     error.SetErrorString ("process attach is in progress");
373                 else
374                     error.SetErrorString ("a process is already being debugged");
375                 sb_process.Clear();
376                 return sb_process;
377             }
378         }
379 
380         if (state == eStateConnected)
381         {
382             // If we are already connected, then we have already specified the
383             // listener, so if a valid listener is supplied, we need to error out
384             // to let the client know.
385             if (listener.IsValid())
386             {
387                 error.SetErrorString ("process is connected and already has a listener, pass empty listener");
388                 sb_process.Clear();
389                 return sb_process;
390             }
391         }
392         else
393         {
394             if (listener.IsValid())
395                 sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref()));
396             else
397                 sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener()));
398         }
399 
400         if (sb_process.IsValid())
401         {
402             error.SetError (sb_process->Attach (name, wait_for));
403             // If we are doing synchronous mode, then wait for the
404             // process to stop!
405             if (m_opaque_sp->GetDebugger().GetAsyncExecution () == false)
406                 sb_process->WaitForProcessToStop (NULL);
407         }
408         else
409         {
410             error.SetErrorString ("unable to create lldb_private::Process");
411         }
412     }
413     else
414     {
415         error.SetErrorString ("SBTarget is invalid");
416     }
417     return sb_process;
418 
419 }
420 
421 lldb::SBProcess
422 SBTarget::ConnectRemote
423 (
424     SBListener &listener,
425     const char *url,
426     const char *plugin_name,
427     SBError& error
428 )
429 {
430     SBProcess sb_process;
431     if (m_opaque_sp)
432     {
433         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
434         if (listener.IsValid())
435             sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref(), plugin_name));
436         else
437             sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener(), plugin_name));
438 
439 
440         if (sb_process.IsValid())
441         {
442             error.SetError (sb_process->ConnectRemote (url));
443         }
444         else
445         {
446             error.SetErrorString ("unable to create lldb_private::Process");
447         }
448     }
449     else
450     {
451         error.SetErrorString ("SBTarget is invalid");
452     }
453     return sb_process;
454 }
455 
456 SBFileSpec
457 SBTarget::GetExecutable ()
458 {
459 
460     SBFileSpec exe_file_spec;
461     if (m_opaque_sp)
462     {
463         Module *exe_module = m_opaque_sp->GetExecutableModulePointer();
464         if (exe_module)
465             exe_file_spec.SetFileSpec (exe_module->GetFileSpec());
466     }
467 
468     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
469     if (log)
470     {
471         log->Printf ("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)",
472                      m_opaque_sp.get(), exe_file_spec.get());
473     }
474 
475     return exe_file_spec;
476 }
477 
478 bool
479 SBTarget::operator == (const SBTarget &rhs) const
480 {
481     return m_opaque_sp.get() == rhs.m_opaque_sp.get();
482 }
483 
484 bool
485 SBTarget::operator != (const SBTarget &rhs) const
486 {
487     return m_opaque_sp.get() != rhs.m_opaque_sp.get();
488 }
489 
490 lldb_private::Target *
491 SBTarget::operator ->() const
492 {
493     return m_opaque_sp.get();
494 }
495 
496 lldb_private::Target *
497 SBTarget::get() const
498 {
499     return m_opaque_sp.get();
500 }
501 
502 const lldb::TargetSP &
503 SBTarget::get_sp () const
504 {
505     return m_opaque_sp;
506 }
507 
508 void
509 SBTarget::reset (const lldb::TargetSP& target_sp)
510 {
511     m_opaque_sp = target_sp;
512 }
513 
514 lldb::SBAddress
515 SBTarget::ResolveLoadAddress (lldb::addr_t vm_addr)
516 {
517     lldb::SBAddress sb_addr;
518     Address &addr = sb_addr.ref();
519     if (m_opaque_sp)
520     {
521         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
522         if (m_opaque_sp->GetSectionLoadList().ResolveLoadAddress (vm_addr, addr))
523             return sb_addr;
524     }
525 
526     // We have a load address that isn't in a section, just return an address
527     // with the offset filled in (the address) and the section set to NULL
528     addr.SetSection(NULL);
529     addr.SetOffset(vm_addr);
530     return sb_addr;
531 }
532 
533 SBSymbolContext
534 SBTarget::ResolveSymbolContextForAddress (const SBAddress& addr, uint32_t resolve_scope)
535 {
536     SBSymbolContext sc;
537     if (m_opaque_sp && addr.IsValid())
538         m_opaque_sp->GetImages().ResolveSymbolContextForAddress (addr.ref(), resolve_scope, sc.ref());
539     return sc;
540 }
541 
542 
543 SBBreakpoint
544 SBTarget::BreakpointCreateByLocation (const char *file, uint32_t line)
545 {
546     return SBBreakpoint(BreakpointCreateByLocation (SBFileSpec (file, false), line));
547 }
548 
549 SBBreakpoint
550 SBTarget::BreakpointCreateByLocation (const SBFileSpec &sb_file_spec, uint32_t line)
551 {
552     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
553 
554     SBBreakpoint sb_bp;
555     if (m_opaque_sp.get() && line != 0)
556     {
557         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
558         *sb_bp = m_opaque_sp->CreateBreakpoint (NULL, *sb_file_spec, line, true, false);
559     }
560 
561     if (log)
562     {
563         SBStream sstr;
564         sb_bp.GetDescription (sstr);
565         char path[PATH_MAX];
566         sb_file_spec->GetPath (path, sizeof(path));
567         log->Printf ("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => SBBreakpoint(%p): %s",
568                      m_opaque_sp.get(),
569                      path,
570                      line,
571                      sb_bp.get(),
572                      sstr.GetData());
573     }
574 
575     return sb_bp;
576 }
577 
578 SBBreakpoint
579 SBTarget::BreakpointCreateByName (const char *symbol_name, const char *module_name)
580 {
581     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
582 
583     SBBreakpoint sb_bp;
584     if (m_opaque_sp.get())
585     {
586         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
587         if (module_name && module_name[0])
588         {
589             FileSpecList module_spec_list;
590             module_spec_list.Append (FileSpec (module_name, false));
591             *sb_bp = m_opaque_sp->CreateBreakpoint (&module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, false);
592         }
593         else
594         {
595             *sb_bp = m_opaque_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, false);
596         }
597     }
598 
599     if (log)
600     {
601         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", module=\"%s\") => SBBreakpoint(%p)",
602                      m_opaque_sp.get(), symbol_name, module_name, sb_bp.get());
603     }
604 
605     return sb_bp;
606 }
607 
608 lldb::SBBreakpoint
609 SBTarget::BreakpointCreateByName (const char *symbol_name,
610                             const SBFileSpecList &module_list,
611                             const SBFileSpecList &comp_unit_list)
612 {
613     uint32_t name_type_mask = eFunctionNameTypeAuto;
614     return BreakpointCreateByName (symbol_name, name_type_mask, module_list, comp_unit_list);
615 }
616 
617 lldb::SBBreakpoint
618 SBTarget::BreakpointCreateByName (const char *symbol_name,
619                             uint32_t name_type_mask,
620                             const SBFileSpecList &module_list,
621                             const SBFileSpecList &comp_unit_list)
622 {
623     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
624 
625     SBBreakpoint sb_bp;
626     if (m_opaque_sp.get() && symbol_name && symbol_name[0])
627     {
628         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
629         *sb_bp = m_opaque_sp->CreateBreakpoint (module_list.get(),
630                                                 comp_unit_list.get(),
631                                                 symbol_name,
632                                                 name_type_mask,
633                                                 false);
634     }
635 
636     if (log)
637     {
638         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)",
639                      m_opaque_sp.get(), symbol_name, name_type_mask, sb_bp.get());
640     }
641 
642     return sb_bp;
643 }
644 
645 
646 SBBreakpoint
647 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name)
648 {
649     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
650 
651     SBBreakpoint sb_bp;
652     if (m_opaque_sp.get() && symbol_name_regex && symbol_name_regex[0])
653     {
654         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
655         RegularExpression regexp(symbol_name_regex);
656 
657         if (module_name && module_name[0])
658         {
659             FileSpecList module_spec_list;
660             module_spec_list.Append (FileSpec (module_name, false));
661 
662             *sb_bp = m_opaque_sp->CreateFuncRegexBreakpoint (&module_spec_list, NULL, regexp, false);
663         }
664         else
665         {
666             *sb_bp = m_opaque_sp->CreateFuncRegexBreakpoint (NULL, NULL, regexp, false);
667         }
668     }
669 
670     if (log)
671     {
672         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
673                      m_opaque_sp.get(), symbol_name_regex, module_name, sb_bp.get());
674     }
675 
676     return sb_bp;
677 }
678 
679 lldb::SBBreakpoint
680 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex,
681                          const SBFileSpecList &module_list,
682                          const SBFileSpecList &comp_unit_list)
683 {
684     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
685 
686     SBBreakpoint sb_bp;
687     if (m_opaque_sp.get() && symbol_name_regex && symbol_name_regex[0])
688     {
689         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
690         RegularExpression regexp(symbol_name_regex);
691 
692         *sb_bp = m_opaque_sp->CreateFuncRegexBreakpoint (module_list.get(), comp_unit_list.get(), regexp, false);
693     }
694 
695     if (log)
696     {
697         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") => SBBreakpoint(%p)",
698                      m_opaque_sp.get(), symbol_name_regex, sb_bp.get());
699     }
700 
701     return sb_bp;
702 }
703 
704 SBBreakpoint
705 SBTarget::BreakpointCreateByAddress (addr_t address)
706 {
707     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
708 
709     SBBreakpoint sb_bp;
710     if (m_opaque_sp.get())
711     {
712         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
713         *sb_bp = m_opaque_sp->CreateBreakpoint (address, false);
714     }
715 
716     if (log)
717     {
718         log->Printf ("SBTarget(%p)::BreakpointCreateByAddress (address=%llu) => SBBreakpoint(%p)", m_opaque_sp.get(), (uint64_t) address, sb_bp.get());
719     }
720 
721     return sb_bp;
722 }
723 
724 lldb::SBBreakpoint
725 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name)
726 {
727     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
728 
729     SBBreakpoint sb_bp;
730     if (m_opaque_sp.get() && source_regex && source_regex[0])
731     {
732         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
733         RegularExpression regexp(source_regex);
734         FileSpecList source_file_spec_list;
735         source_file_spec_list.Append (source_file.ref());
736 
737         if (module_name && module_name[0])
738         {
739             FileSpecList module_spec_list;
740             module_spec_list.Append (FileSpec (module_name, false));
741 
742             *sb_bp = m_opaque_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false);
743         }
744         else
745         {
746             *sb_bp = m_opaque_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false);
747         }
748     }
749 
750     if (log)
751     {
752         char path[PATH_MAX];
753         source_file->GetPath (path, sizeof(path));
754         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\", file=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
755                      m_opaque_sp.get(), source_regex, path, module_name, sb_bp.get());
756     }
757 
758     return sb_bp;
759 }
760 
761 lldb::SBBreakpoint
762 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
763                                const SBFileSpecList &module_list,
764                                const lldb::SBFileSpecList &source_file_list)
765 {
766     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
767 
768     SBBreakpoint sb_bp;
769     if (m_opaque_sp.get() && source_regex && source_regex[0])
770     {
771         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
772         RegularExpression regexp(source_regex);
773         *sb_bp = m_opaque_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false);
774     }
775 
776     if (log)
777     {
778         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)",
779                      m_opaque_sp.get(), source_regex, sb_bp.get());
780     }
781 
782     return sb_bp;
783 }
784 
785 uint32_t
786 SBTarget::GetNumBreakpoints () const
787 {
788     if (m_opaque_sp)
789     {
790         // The breakpoint list is thread safe, no need to lock
791         return m_opaque_sp->GetBreakpointList().GetSize();
792     }
793     return 0;
794 }
795 
796 SBBreakpoint
797 SBTarget::GetBreakpointAtIndex (uint32_t idx) const
798 {
799     SBBreakpoint sb_breakpoint;
800     if (m_opaque_sp)
801     {
802         // The breakpoint list is thread safe, no need to lock
803         *sb_breakpoint = m_opaque_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
804     }
805     return sb_breakpoint;
806 }
807 
808 bool
809 SBTarget::BreakpointDelete (break_id_t bp_id)
810 {
811     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
812 
813     bool result = false;
814     if (m_opaque_sp)
815     {
816         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
817         result = m_opaque_sp->RemoveBreakpointByID (bp_id);
818     }
819 
820     if (log)
821     {
822         log->Printf ("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", m_opaque_sp.get(), (uint32_t) bp_id, result);
823     }
824 
825     return result;
826 }
827 
828 SBBreakpoint
829 SBTarget::FindBreakpointByID (break_id_t bp_id)
830 {
831     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
832 
833     SBBreakpoint sb_breakpoint;
834     if (m_opaque_sp && bp_id != LLDB_INVALID_BREAK_ID)
835     {
836         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
837         *sb_breakpoint = m_opaque_sp->GetBreakpointByID (bp_id);
838     }
839 
840     if (log)
841     {
842         log->Printf ("SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)",
843                      m_opaque_sp.get(), (uint32_t) bp_id, sb_breakpoint.get());
844     }
845 
846     return sb_breakpoint;
847 }
848 
849 bool
850 SBTarget::EnableAllBreakpoints ()
851 {
852     if (m_opaque_sp)
853     {
854         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
855         m_opaque_sp->EnableAllBreakpoints ();
856         return true;
857     }
858     return false;
859 }
860 
861 bool
862 SBTarget::DisableAllBreakpoints ()
863 {
864     if (m_opaque_sp)
865     {
866         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
867         m_opaque_sp->DisableAllBreakpoints ();
868         return true;
869     }
870     return false;
871 }
872 
873 bool
874 SBTarget::DeleteAllBreakpoints ()
875 {
876     if (m_opaque_sp)
877     {
878         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
879         m_opaque_sp->RemoveAllBreakpoints ();
880         return true;
881     }
882     return false;
883 }
884 
885 uint32_t
886 SBTarget::GetNumWatchpoints () const
887 {
888     if (m_opaque_sp)
889     {
890         // The watchpoint list is thread safe, no need to lock
891         return m_opaque_sp->GetWatchpointList().GetSize();
892     }
893     return 0;
894 }
895 
896 SBWatchpoint
897 SBTarget::GetWatchpointAtIndex (uint32_t idx) const
898 {
899     SBWatchpoint sb_watchpoint;
900     if (m_opaque_sp)
901     {
902         // The watchpoint list is thread safe, no need to lock
903         *sb_watchpoint = m_opaque_sp->GetWatchpointList().GetByIndex(idx);
904     }
905     return sb_watchpoint;
906 }
907 
908 bool
909 SBTarget::DeleteWatchpoint (watch_id_t wp_id)
910 {
911     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
912 
913     bool result = false;
914     if (m_opaque_sp)
915     {
916         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
917         result = m_opaque_sp->RemoveWatchpointByID (wp_id);
918     }
919 
920     if (log)
921     {
922         log->Printf ("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", m_opaque_sp.get(), (uint32_t) wp_id, result);
923     }
924 
925     return result;
926 }
927 
928 SBWatchpoint
929 SBTarget::FindWatchpointByID (lldb::watch_id_t wp_id)
930 {
931     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
932 
933     SBWatchpoint sb_watchpoint;
934     if (m_opaque_sp && wp_id != LLDB_INVALID_WATCH_ID)
935     {
936         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
937         *sb_watchpoint = m_opaque_sp->GetWatchpointList().FindByID(wp_id);
938     }
939 
940     if (log)
941     {
942         log->Printf ("SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)",
943                      m_opaque_sp.get(), (uint32_t) wp_id, sb_watchpoint.get());
944     }
945 
946     return sb_watchpoint;
947 }
948 
949 lldb::SBWatchpoint
950 SBTarget::WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write)
951 {
952     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
953 
954     SBWatchpoint sb_watchpoint;
955     if (m_opaque_sp)
956     {
957         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
958         uint32_t watch_type = (read ? LLDB_WATCH_TYPE_READ : 0) |
959             (write ? LLDB_WATCH_TYPE_WRITE : 0);
960         sb_watchpoint = m_opaque_sp->CreateWatchpoint(addr, size, watch_type);
961     }
962 
963     if (log)
964     {
965         log->Printf ("SBTarget(%p)::WatchAddress (addr=0x%llx, 0x%u) => SBWatchpoint(%p)",
966                      m_opaque_sp.get(), addr, (uint32_t) size, sb_watchpoint.get());
967     }
968 
969     return sb_watchpoint;
970 }
971 
972 bool
973 SBTarget::EnableAllWatchpoints ()
974 {
975     if (m_opaque_sp)
976     {
977         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
978         m_opaque_sp->EnableAllWatchpoints ();
979         return true;
980     }
981     return false;
982 }
983 
984 bool
985 SBTarget::DisableAllWatchpoints ()
986 {
987     if (m_opaque_sp)
988     {
989         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
990         m_opaque_sp->DisableAllWatchpoints ();
991         return true;
992     }
993     return false;
994 }
995 
996 bool
997 SBTarget::DeleteAllWatchpoints ()
998 {
999     if (m_opaque_sp)
1000     {
1001         Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex());
1002         m_opaque_sp->RemoveAllWatchpoints ();
1003         return true;
1004     }
1005     return false;
1006 }
1007 
1008 
1009 lldb::SBModule
1010 SBTarget::AddModule (const char *path,
1011                      const char *triple,
1012                      const char *uuid_cstr)
1013 {
1014     lldb::SBModule sb_module;
1015     if (m_opaque_sp)
1016     {
1017         FileSpec module_file_spec;
1018         UUID module_uuid;
1019         ArchSpec module_arch;
1020 
1021         if (path)
1022             module_file_spec.SetFile(path, false);
1023 
1024         if (uuid_cstr)
1025             module_uuid.SetfromCString(uuid_cstr);
1026 
1027         if (triple)
1028             module_arch.SetTriple (triple, m_opaque_sp->GetPlatform ().get());
1029 
1030         sb_module.SetModule(m_opaque_sp->GetSharedModule (module_file_spec,
1031                                                           module_arch,
1032                                                           uuid_cstr ? &module_uuid : NULL));
1033     }
1034     return sb_module;
1035 }
1036 
1037 bool
1038 SBTarget::AddModule (lldb::SBModule &module)
1039 {
1040     if (m_opaque_sp)
1041     {
1042         m_opaque_sp->GetImages().AppendIfNeeded (module.get_sp());
1043         return true;
1044     }
1045     return false;
1046 }
1047 
1048 lldb::SBModule
1049 AddModule (const char *path,
1050            const char *triple,
1051            const char *uuid);
1052 
1053 
1054 
1055 uint32_t
1056 SBTarget::GetNumModules () const
1057 {
1058     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1059 
1060     uint32_t num = 0;
1061     if (m_opaque_sp)
1062     {
1063         // The module list is thread safe, no need to lock
1064         num = m_opaque_sp->GetImages().GetSize();
1065     }
1066 
1067     if (log)
1068         log->Printf ("SBTarget(%p)::GetNumModules () => %d", m_opaque_sp.get(), num);
1069 
1070     return num;
1071 }
1072 
1073 void
1074 SBTarget::Clear ()
1075 {
1076     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1077 
1078     if (log)
1079         log->Printf ("SBTarget(%p)::Clear ()", m_opaque_sp.get());
1080 
1081     m_opaque_sp.reset();
1082 }
1083 
1084 
1085 SBModule
1086 SBTarget::FindModule (const SBFileSpec &sb_file_spec)
1087 {
1088     SBModule sb_module;
1089     if (m_opaque_sp && sb_file_spec.IsValid())
1090     {
1091         // The module list is thread safe, no need to lock
1092         sb_module.SetModule (m_opaque_sp->GetImages().FindFirstModuleForFileSpec (*sb_file_spec, NULL, NULL));
1093     }
1094     return sb_module;
1095 }
1096 
1097 SBModule
1098 SBTarget::GetModuleAtIndex (uint32_t idx)
1099 {
1100     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1101 
1102     SBModule sb_module;
1103     if (m_opaque_sp)
1104     {
1105         // The module list is thread safe, no need to lock
1106         sb_module.SetModule(m_opaque_sp->GetImages().GetModuleAtIndex(idx));
1107     }
1108 
1109     if (log)
1110     {
1111         log->Printf ("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)",
1112                      m_opaque_sp.get(), idx, sb_module.get());
1113     }
1114 
1115     return sb_module;
1116 }
1117 
1118 bool
1119 SBTarget::RemoveModule (lldb::SBModule module)
1120 {
1121     if (m_opaque_sp)
1122         return m_opaque_sp->GetImages().Remove(module.get_sp());
1123     return false;
1124 }
1125 
1126 
1127 SBBroadcaster
1128 SBTarget::GetBroadcaster () const
1129 {
1130     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1131 
1132     SBBroadcaster broadcaster(m_opaque_sp.get(), false);
1133 
1134     if (log)
1135         log->Printf ("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)",
1136                      m_opaque_sp.get(), broadcaster.get());
1137 
1138     return broadcaster;
1139 }
1140 
1141 
1142 bool
1143 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level)
1144 {
1145     if (m_opaque_sp)
1146     {
1147         description.ref();
1148         m_opaque_sp->Dump (description.get(), description_level);
1149     }
1150     else
1151         description.Printf ("No value");
1152 
1153     return true;
1154 }
1155 
1156 bool
1157 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) const
1158 {
1159     if (m_opaque_sp)
1160     {
1161         description.ref();
1162         m_opaque_sp->Dump (description.get(), description_level);
1163     }
1164     else
1165         description.Printf ("No value");
1166 
1167     return true;
1168 }
1169 
1170 
1171 uint32_t
1172 SBTarget::FindFunctions (const char *name,
1173                          uint32_t name_type_mask,
1174                          bool append,
1175                          lldb::SBSymbolContextList& sc_list)
1176 {
1177     if (!append)
1178         sc_list.Clear();
1179     if (m_opaque_sp)
1180     {
1181         const bool symbols_ok = true;
1182         return m_opaque_sp->GetImages().FindFunctions (ConstString(name),
1183                                                        name_type_mask,
1184                                                        symbols_ok,
1185                                                        append,
1186                                                        *sc_list);
1187     }
1188     return 0;
1189 }
1190 
1191 lldb::SBType
1192 SBTarget::FindFirstType (const char* type)
1193 {
1194     if (m_opaque_sp)
1195     {
1196         size_t count = m_opaque_sp->GetImages().GetSize();
1197         for (size_t idx = 0; idx < count; idx++)
1198         {
1199             SBType found_at_idx = GetModuleAtIndex(idx).FindFirstType(type);
1200 
1201             if (found_at_idx.IsValid())
1202                 return found_at_idx;
1203         }
1204     }
1205     return SBType();
1206 }
1207 
1208 lldb::SBTypeList
1209 SBTarget::FindTypes (const char* type)
1210 {
1211 
1212     SBTypeList retval;
1213 
1214     if (m_opaque_sp)
1215     {
1216         ModuleList& images = m_opaque_sp->GetImages();
1217         ConstString name_const(type);
1218         SymbolContext sc;
1219         TypeList type_list;
1220 
1221         uint32_t num_matches = images.FindTypes(sc,
1222                                                 name_const,
1223                                                 true,
1224                                                 UINT32_MAX,
1225                                                 type_list);
1226 
1227         for (size_t idx = 0; idx < num_matches; idx++)
1228         {
1229             TypeSP type_sp (type_list.GetTypeAtIndex(idx));
1230             if (type_sp)
1231                 retval.Append(SBType(type_sp));
1232         }
1233     }
1234     return retval;
1235 }
1236 
1237 SBValueList
1238 SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches)
1239 {
1240     SBValueList sb_value_list;
1241 
1242     if (m_opaque_sp)
1243     {
1244         VariableList variable_list;
1245         const bool append = true;
1246         const uint32_t match_count = m_opaque_sp->GetImages().FindGlobalVariables (ConstString (name),
1247                                                                                    append,
1248                                                                                    max_matches,
1249                                                                                    variable_list);
1250 
1251         if (match_count > 0)
1252         {
1253             ExecutionContextScope *exe_scope = m_opaque_sp->GetProcessSP().get();
1254             if (exe_scope == NULL)
1255                 exe_scope = m_opaque_sp.get();
1256             ValueObjectList &value_object_list = sb_value_list.ref();
1257             for (uint32_t i=0; i<match_count; ++i)
1258             {
1259                 lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i)));
1260                 if (valobj_sp)
1261                     value_object_list.Append(valobj_sp);
1262             }
1263         }
1264     }
1265 
1266     return sb_value_list;
1267 }
1268 
1269 SBSourceManager
1270 SBTarget::GetSourceManager()
1271 {
1272     SBSourceManager source_manager (*this);
1273     return source_manager;
1274 }
1275 
1276 
1277 SBError
1278 SBTarget::SetSectionLoadAddress (lldb::SBSection section,
1279                                  lldb::addr_t section_base_addr)
1280 {
1281     SBError sb_error;
1282 
1283     if (IsValid())
1284     {
1285         if (!section.IsValid())
1286         {
1287             sb_error.SetErrorStringWithFormat ("invalid section");
1288         }
1289         else
1290         {
1291             m_opaque_sp->GetSectionLoadList().SetSectionLoadAddress (section.GetSection(), section_base_addr);
1292         }
1293     }
1294     else
1295     {
1296         sb_error.SetErrorStringWithFormat ("invalid target");
1297     }
1298     return sb_error;
1299 }
1300 
1301 SBError
1302 SBTarget::ClearSectionLoadAddress (lldb::SBSection section)
1303 {
1304     SBError sb_error;
1305 
1306     if (IsValid())
1307     {
1308         if (!section.IsValid())
1309         {
1310             sb_error.SetErrorStringWithFormat ("invalid section");
1311         }
1312         else
1313         {
1314             m_opaque_sp->GetSectionLoadList().SetSectionUnloaded (section.GetSection());
1315         }
1316     }
1317     else
1318     {
1319         sb_error.SetErrorStringWithFormat ("invalid target");
1320     }
1321     return sb_error;
1322 }
1323 
1324 SBError
1325 SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset)
1326 {
1327     SBError sb_error;
1328 
1329     char path[PATH_MAX];
1330     if (IsValid())
1331     {
1332         if (!module.IsValid())
1333         {
1334             sb_error.SetErrorStringWithFormat ("invalid module");
1335         }
1336         else
1337         {
1338             ObjectFile *objfile = module->GetObjectFile();
1339             if (objfile)
1340             {
1341                 SectionList *section_list = objfile->GetSectionList();
1342                 if (section_list)
1343                 {
1344                     const size_t num_sections = section_list->GetSize();
1345                     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
1346                     {
1347                         SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx));
1348                         if (section_sp)
1349                             m_opaque_sp->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), section_sp->GetFileAddress() + slide_offset);
1350                     }
1351                 }
1352                 else
1353                 {
1354                     module->GetFileSpec().GetPath (path, sizeof(path));
1355                     sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path);
1356                 }
1357             }
1358             else
1359             {
1360                 module->GetFileSpec().GetPath (path, sizeof(path));
1361                 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path);
1362             }
1363         }
1364     }
1365     else
1366     {
1367         sb_error.SetErrorStringWithFormat ("invalid target");
1368     }
1369     return sb_error;
1370 }
1371 
1372 SBError
1373 SBTarget::ClearModuleLoadAddress (lldb::SBModule module)
1374 {
1375     SBError sb_error;
1376 
1377     char path[PATH_MAX];
1378     if (IsValid())
1379     {
1380         if (!module.IsValid())
1381         {
1382             sb_error.SetErrorStringWithFormat ("invalid module");
1383         }
1384         else
1385         {
1386             ObjectFile *objfile = module->GetObjectFile();
1387             if (objfile)
1388             {
1389                 SectionList *section_list = objfile->GetSectionList();
1390                 if (section_list)
1391                 {
1392                     const size_t num_sections = section_list->GetSize();
1393                     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
1394                     {
1395                         SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx));
1396                         if (section_sp)
1397                             m_opaque_sp->GetSectionLoadList().SetSectionUnloaded (section_sp.get());
1398                     }
1399                 }
1400                 else
1401                 {
1402                     module->GetFileSpec().GetPath (path, sizeof(path));
1403                     sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path);
1404                 }
1405             }
1406             else
1407             {
1408                 module->GetFileSpec().GetPath (path, sizeof(path));
1409                 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path);
1410             }
1411         }
1412     }
1413     else
1414     {
1415         sb_error.SetErrorStringWithFormat ("invalid target");
1416     }
1417     return sb_error;
1418 }
1419 
1420 
1421