1 //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/lldb-python.h"
11 
12 #include "lldb/API/SBDebugger.h"
13 
14 #include "lldb/lldb-private.h"
15 
16 #include "lldb/API/SBListener.h"
17 #include "lldb/API/SBBroadcaster.h"
18 #include "lldb/API/SBCommandInterpreter.h"
19 #include "lldb/API/SBCommandReturnObject.h"
20 #include "lldb/API/SBError.h"
21 #include "lldb/API/SBEvent.h"
22 #include "lldb/API/SBFrame.h"
23 #include "lldb/API/SBInputReader.h"
24 #include "lldb/API/SBProcess.h"
25 #include "lldb/API/SBSourceManager.h"
26 #include "lldb/API/SBStream.h"
27 #include "lldb/API/SBStringList.h"
28 #include "lldb/API/SBTarget.h"
29 #include "lldb/API/SBThread.h"
30 #include "lldb/API/SBTypeCategory.h"
31 #include "lldb/API/SBTypeFormat.h"
32 #include "lldb/API/SBTypeFilter.h"
33 #include "lldb/API/SBTypeNameSpecifier.h"
34 #include "lldb/API/SBTypeSummary.h"
35 #include "lldb/API/SBTypeSynthetic.h"
36 
37 
38 #include "lldb/Core/Debugger.h"
39 #include "lldb/Core/State.h"
40 #include "lldb/DataFormatters/DataVisualization.h"
41 #include "lldb/Interpreter/Args.h"
42 #include "lldb/Interpreter/CommandInterpreter.h"
43 #include "lldb/Interpreter/OptionGroupPlatform.h"
44 #include "lldb/Target/Process.h"
45 #include "lldb/Target/TargetList.h"
46 
47 using namespace lldb;
48 using namespace lldb_private;
49 
50 void
Initialize()51 SBDebugger::Initialize ()
52 {
53     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
54 
55     if (log)
56         log->Printf ("SBDebugger::Initialize ()");
57 
58     SBCommandInterpreter::InitializeSWIG ();
59 
60     Debugger::Initialize();
61 }
62 
63 void
Terminate()64 SBDebugger::Terminate ()
65 {
66     Debugger::Terminate();
67 }
68 
69 void
Clear()70 SBDebugger::Clear ()
71 {
72     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
73 
74     if (log)
75         log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get());
76 
77     if (m_opaque_sp)
78         m_opaque_sp->CleanUpInputReaders ();
79 
80     m_opaque_sp.reset();
81 }
82 
83 SBDebugger
Create()84 SBDebugger::Create()
85 {
86     return SBDebugger::Create(false, NULL, NULL);
87 }
88 
89 SBDebugger
Create(bool source_init_files)90 SBDebugger::Create(bool source_init_files)
91 {
92     return SBDebugger::Create (source_init_files, NULL, NULL);
93 }
94 
95 SBDebugger
Create(bool source_init_files,lldb::LogOutputCallback callback,void * baton)96 SBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton)
97 
98 {
99     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
100 
101     SBDebugger debugger;
102     debugger.reset(Debugger::CreateInstance(callback, baton));
103 
104     if (log)
105     {
106         SBStream sstr;
107         debugger.GetDescription (sstr);
108         log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData());
109     }
110 
111     SBCommandInterpreter interp = debugger.GetCommandInterpreter();
112     if (source_init_files)
113     {
114         interp.get()->SkipLLDBInitFiles(false);
115         interp.get()->SkipAppInitFiles (false);
116         SBCommandReturnObject result;
117         interp.SourceInitFileInHomeDirectory(result);
118     }
119     else
120     {
121         interp.get()->SkipLLDBInitFiles(true);
122         interp.get()->SkipAppInitFiles (true);
123     }
124     return debugger;
125 }
126 
127 void
Destroy(SBDebugger & debugger)128 SBDebugger::Destroy (SBDebugger &debugger)
129 {
130     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
131 
132     if (log)
133     {
134         SBStream sstr;
135         debugger.GetDescription (sstr);
136         log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData());
137     }
138 
139     Debugger::Destroy (debugger.m_opaque_sp);
140 
141     if (debugger.m_opaque_sp.get() != NULL)
142         debugger.m_opaque_sp.reset();
143 }
144 
145 void
MemoryPressureDetected()146 SBDebugger::MemoryPressureDetected ()
147 {
148     // Since this function can be call asynchronously, we allow it to be
149     // non-mandatory. We have seen deadlocks with this function when called
150     // so we need to safeguard against this until we can determine what is
151     // causing the deadlocks.
152     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
153 
154     const bool mandatory = false;
155     if (log)
156     {
157         log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory);
158     }
159 
160     ModuleList::RemoveOrphanSharedModules(mandatory);
161 }
162 
SBDebugger()163 SBDebugger::SBDebugger () :
164     m_opaque_sp ()
165 {
166 }
167 
SBDebugger(const lldb::DebuggerSP & debugger_sp)168 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) :
169     m_opaque_sp(debugger_sp)
170 {
171 }
172 
SBDebugger(const SBDebugger & rhs)173 SBDebugger::SBDebugger(const SBDebugger &rhs) :
174     m_opaque_sp (rhs.m_opaque_sp)
175 {
176 }
177 
178 SBDebugger &
operator =(const SBDebugger & rhs)179 SBDebugger::operator = (const SBDebugger &rhs)
180 {
181     if (this != &rhs)
182     {
183         m_opaque_sp = rhs.m_opaque_sp;
184     }
185     return *this;
186 }
187 
~SBDebugger()188 SBDebugger::~SBDebugger ()
189 {
190 }
191 
192 bool
IsValid() const193 SBDebugger::IsValid() const
194 {
195     return m_opaque_sp.get() != NULL;
196 }
197 
198 
199 void
SetAsync(bool b)200 SBDebugger::SetAsync (bool b)
201 {
202     if (m_opaque_sp)
203         m_opaque_sp->SetAsyncExecution(b);
204 }
205 
206 bool
GetAsync()207 SBDebugger::GetAsync ()
208 {
209     if (m_opaque_sp)
210         return m_opaque_sp->GetAsyncExecution();
211     else
212         return false;
213 }
214 
215 void
SkipLLDBInitFiles(bool b)216 SBDebugger::SkipLLDBInitFiles (bool b)
217 {
218     if (m_opaque_sp)
219         m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b);
220 }
221 
222 void
SkipAppInitFiles(bool b)223 SBDebugger::SkipAppInitFiles (bool b)
224 {
225     if (m_opaque_sp)
226         m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b);
227 }
228 
229 // Shouldn't really be settable after initialization as this could cause lots of problems; don't want users
230 // trying to switch modes in the middle of a debugging session.
231 void
SetInputFileHandle(FILE * fh,bool transfer_ownership)232 SBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership)
233 {
234     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
235 
236     if (log)
237         log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
238                      fh, transfer_ownership);
239 
240     if (m_opaque_sp)
241         m_opaque_sp->SetInputFileHandle (fh, transfer_ownership);
242 }
243 
244 void
SetOutputFileHandle(FILE * fh,bool transfer_ownership)245 SBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership)
246 {
247     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
248 
249 
250     if (log)
251         log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
252                      fh, transfer_ownership);
253 
254     if (m_opaque_sp)
255         m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership);
256 }
257 
258 void
SetErrorFileHandle(FILE * fh,bool transfer_ownership)259 SBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership)
260 {
261     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
262 
263 
264     if (log)
265         log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
266                      fh, transfer_ownership);
267 
268     if (m_opaque_sp)
269         m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership);
270 }
271 
272 FILE *
GetInputFileHandle()273 SBDebugger::GetInputFileHandle ()
274 {
275     if (m_opaque_sp)
276         return m_opaque_sp->GetInputFile().GetStream();
277     return NULL;
278 }
279 
280 FILE *
GetOutputFileHandle()281 SBDebugger::GetOutputFileHandle ()
282 {
283     if (m_opaque_sp)
284         return m_opaque_sp->GetOutputFile().GetStream();
285     return NULL;
286 }
287 
288 FILE *
GetErrorFileHandle()289 SBDebugger::GetErrorFileHandle ()
290 {
291     if (m_opaque_sp)
292         return m_opaque_sp->GetErrorFile().GetStream();
293     return NULL;
294 }
295 
296 void
SaveInputTerminalState()297 SBDebugger::SaveInputTerminalState()
298 {
299     if (m_opaque_sp)
300         m_opaque_sp->SaveInputTerminalState();
301 }
302 
303 void
RestoreInputTerminalState()304 SBDebugger::RestoreInputTerminalState()
305 {
306     if (m_opaque_sp)
307         m_opaque_sp->RestoreInputTerminalState();
308 
309 }
310 SBCommandInterpreter
GetCommandInterpreter()311 SBDebugger::GetCommandInterpreter ()
312 {
313     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
314 
315     SBCommandInterpreter sb_interpreter;
316     if (m_opaque_sp)
317         sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter());
318 
319     if (log)
320         log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
321                      m_opaque_sp.get(), sb_interpreter.get());
322 
323     return sb_interpreter;
324 }
325 
326 void
HandleCommand(const char * command)327 SBDebugger::HandleCommand (const char *command)
328 {
329     if (m_opaque_sp)
330     {
331         TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
332         Mutex::Locker api_locker;
333         if (target_sp)
334             api_locker.Lock(target_sp->GetAPIMutex());
335 
336         SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
337         SBCommandReturnObject result;
338 
339         sb_interpreter.HandleCommand (command, result, false);
340 
341         if (GetErrorFileHandle() != NULL)
342             result.PutError (GetErrorFileHandle());
343         if (GetOutputFileHandle() != NULL)
344             result.PutOutput (GetOutputFileHandle());
345 
346         if (m_opaque_sp->GetAsyncExecution() == false)
347         {
348             SBProcess process(GetCommandInterpreter().GetProcess ());
349             ProcessSP process_sp (process.GetSP());
350             if (process_sp)
351             {
352                 EventSP event_sp;
353                 Listener &lldb_listener = m_opaque_sp->GetListener();
354                 while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp))
355                 {
356                     SBEvent event(event_sp);
357                     HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle());
358                 }
359             }
360         }
361     }
362 }
363 
364 SBListener
GetListener()365 SBDebugger::GetListener ()
366 {
367     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
368 
369     SBListener sb_listener;
370     if (m_opaque_sp)
371         sb_listener.reset(&m_opaque_sp->GetListener(), false);
372 
373     if (log)
374         log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(),
375                      sb_listener.get());
376 
377     return sb_listener;
378 }
379 
380 void
HandleProcessEvent(const SBProcess & process,const SBEvent & event,FILE * out,FILE * err)381 SBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err)
382 {
383     if (!process.IsValid())
384         return;
385 
386     TargetSP target_sp (process.GetTarget().GetSP());
387     if (!target_sp)
388         return;
389 
390     const uint32_t event_type = event.GetType();
391     char stdio_buffer[1024];
392     size_t len;
393 
394     Mutex::Locker api_locker (target_sp->GetAPIMutex());
395 
396     if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged))
397     {
398         // Drain stdout when we stop just in case we have any bytes
399         while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0)
400             if (out != NULL)
401                 ::fwrite (stdio_buffer, 1, len, out);
402     }
403 
404     if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged))
405     {
406         // Drain stderr when we stop just in case we have any bytes
407         while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0)
408             if (err != NULL)
409                 ::fwrite (stdio_buffer, 1, len, err);
410     }
411 
412     if (event_type & Process::eBroadcastBitStateChanged)
413     {
414         StateType event_state = SBProcess::GetStateFromEvent (event);
415 
416         if (event_state == eStateInvalid)
417             return;
418 
419         bool is_stopped = StateIsStoppedState (event_state);
420         if (!is_stopped)
421             process.ReportEventState (event, out);
422     }
423 }
424 
425 SBSourceManager
GetSourceManager()426 SBDebugger::GetSourceManager ()
427 {
428     SBSourceManager sb_source_manager (*this);
429     return sb_source_manager;
430 }
431 
432 
433 bool
GetDefaultArchitecture(char * arch_name,size_t arch_name_len)434 SBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len)
435 {
436     if (arch_name && arch_name_len)
437     {
438         ArchSpec default_arch = Target::GetDefaultArchitecture ();
439 
440         if (default_arch.IsValid())
441         {
442             const std::string &triple_str = default_arch.GetTriple().str();
443             if (!triple_str.empty())
444                 ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str());
445             else
446                 ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName());
447             return true;
448         }
449     }
450     if (arch_name && arch_name_len)
451         arch_name[0] = '\0';
452     return false;
453 }
454 
455 
456 bool
SetDefaultArchitecture(const char * arch_name)457 SBDebugger::SetDefaultArchitecture (const char *arch_name)
458 {
459     if (arch_name)
460     {
461         ArchSpec arch (arch_name);
462         if (arch.IsValid())
463         {
464             Target::SetDefaultArchitecture (arch);
465             return true;
466         }
467     }
468     return false;
469 }
470 
471 ScriptLanguage
GetScriptingLanguage(const char * script_language_name)472 SBDebugger::GetScriptingLanguage (const char *script_language_name)
473 {
474 
475     return Args::StringToScriptLanguage (script_language_name,
476                                          eScriptLanguageDefault,
477                                          NULL);
478 }
479 
480 const char *
GetVersionString()481 SBDebugger::GetVersionString ()
482 {
483     return GetVersion();
484 }
485 
486 const char *
StateAsCString(StateType state)487 SBDebugger::StateAsCString (StateType state)
488 {
489     return lldb_private::StateAsCString (state);
490 }
491 
492 bool
StateIsRunningState(StateType state)493 SBDebugger::StateIsRunningState (StateType state)
494 {
495     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
496 
497     const bool result = lldb_private::StateIsRunningState (state);
498     if (log)
499         log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i",
500                      StateAsCString (state), result);
501 
502     return result;
503 }
504 
505 bool
StateIsStoppedState(StateType state)506 SBDebugger::StateIsStoppedState (StateType state)
507 {
508     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
509 
510     const bool result = lldb_private::StateIsStoppedState (state, false);
511     if (log)
512         log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i",
513                      StateAsCString (state), result);
514 
515     return result;
516 }
517 
518 lldb::SBTarget
CreateTarget(const char * filename,const char * target_triple,const char * platform_name,bool add_dependent_modules,lldb::SBError & sb_error)519 SBDebugger::CreateTarget (const char *filename,
520                           const char *target_triple,
521                           const char *platform_name,
522                           bool add_dependent_modules,
523                           lldb::SBError& sb_error)
524 {
525     SBTarget sb_target;
526     TargetSP target_sp;
527     if (m_opaque_sp)
528     {
529         sb_error.Clear();
530         OptionGroupPlatform platform_options (false);
531         platform_options.SetPlatformName (platform_name);
532 
533         sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
534                                                                     filename,
535                                                                     target_triple,
536                                                                     add_dependent_modules,
537                                                                     &platform_options,
538                                                                     target_sp);
539 
540         if (sb_error.Success())
541             sb_target.SetSP (target_sp);
542     }
543     else
544     {
545         sb_error.SetErrorString("invalid target");
546     }
547 
548     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
549     if (log)
550     {
551         log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)",
552                      m_opaque_sp.get(),
553                      filename,
554                      target_triple,
555                      platform_name,
556                      add_dependent_modules,
557                      sb_error.GetCString(),
558                      target_sp.get());
559     }
560 
561     return sb_target;
562 }
563 
564 SBTarget
CreateTargetWithFileAndTargetTriple(const char * filename,const char * target_triple)565 SBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename,
566                                                  const char *target_triple)
567 {
568     SBTarget sb_target;
569     TargetSP target_sp;
570     if (m_opaque_sp)
571     {
572         const bool add_dependent_modules = true;
573         Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
574                                                                 filename,
575                                                                 target_triple,
576                                                                 add_dependent_modules,
577                                                                 NULL,
578                                                                 target_sp));
579         sb_target.SetSP (target_sp);
580     }
581 
582     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
583     if (log)
584     {
585         log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)",
586                      m_opaque_sp.get(), filename, target_triple, target_sp.get());
587     }
588 
589     return sb_target;
590 }
591 
592 SBTarget
CreateTargetWithFileAndArch(const char * filename,const char * arch_cstr)593 SBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr)
594 {
595     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
596 
597     SBTarget sb_target;
598     TargetSP target_sp;
599     if (m_opaque_sp)
600     {
601         Error error;
602         const bool add_dependent_modules = true;
603 
604         error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
605                                                            filename,
606                                                            arch_cstr,
607                                                            add_dependent_modules,
608                                                            NULL,
609                                                            target_sp);
610 
611         if (error.Success())
612         {
613             m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
614             sb_target.SetSP (target_sp);
615         }
616     }
617 
618     if (log)
619     {
620         log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)",
621                      m_opaque_sp.get(), filename, arch_cstr, target_sp.get());
622     }
623 
624     return sb_target;
625 }
626 
627 SBTarget
CreateTarget(const char * filename)628 SBDebugger::CreateTarget (const char *filename)
629 {
630     SBTarget sb_target;
631     TargetSP target_sp;
632     if (m_opaque_sp)
633     {
634         ArchSpec arch = Target::GetDefaultArchitecture ();
635         Error error;
636         const bool add_dependent_modules = true;
637 
638         PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform());
639         error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
640                                                            filename,
641                                                            arch,
642                                                            add_dependent_modules,
643                                                            platform_sp,
644                                                            target_sp);
645 
646         if (error.Success())
647         {
648             m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
649             sb_target.SetSP (target_sp);
650         }
651     }
652     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
653     if (log)
654     {
655         log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
656                      m_opaque_sp.get(), filename, target_sp.get());
657     }
658     return sb_target;
659 }
660 
661 bool
DeleteTarget(lldb::SBTarget & target)662 SBDebugger::DeleteTarget (lldb::SBTarget &target)
663 {
664     bool result = false;
665     if (m_opaque_sp)
666     {
667         TargetSP target_sp(target.GetSP());
668         if (target_sp)
669         {
670             // No need to lock, the target list is thread safe
671             result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp);
672             target_sp->Destroy();
673             target.Clear();
674             const bool mandatory = true;
675             ModuleList::RemoveOrphanSharedModules(mandatory);
676         }
677     }
678 
679     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
680     if (log)
681     {
682         log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result);
683     }
684 
685     return result;
686 }
687 SBTarget
GetTargetAtIndex(uint32_t idx)688 SBDebugger::GetTargetAtIndex (uint32_t idx)
689 {
690     SBTarget sb_target;
691     if (m_opaque_sp)
692     {
693         // No need to lock, the target list is thread safe
694         sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx));
695     }
696     return sb_target;
697 }
698 
699 uint32_t
GetIndexOfTarget(lldb::SBTarget target)700 SBDebugger::GetIndexOfTarget (lldb::SBTarget target)
701 {
702 
703     lldb::TargetSP target_sp = target.GetSP();
704     if (!target_sp)
705         return UINT32_MAX;
706 
707     if (!m_opaque_sp)
708         return UINT32_MAX;
709 
710     return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP());
711 }
712 
713 SBTarget
FindTargetWithProcessID(pid_t pid)714 SBDebugger::FindTargetWithProcessID (pid_t pid)
715 {
716     SBTarget sb_target;
717     if (m_opaque_sp)
718     {
719         // No need to lock, the target list is thread safe
720         sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid));
721     }
722     return sb_target;
723 }
724 
725 SBTarget
FindTargetWithFileAndArch(const char * filename,const char * arch_name)726 SBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name)
727 {
728     SBTarget sb_target;
729     if (m_opaque_sp && filename && filename[0])
730     {
731         // No need to lock, the target list is thread safe
732         ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
733         TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL));
734         sb_target.SetSP (target_sp);
735     }
736     return sb_target;
737 }
738 
739 SBTarget
FindTargetWithLLDBProcess(const ProcessSP & process_sp)740 SBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp)
741 {
742     SBTarget sb_target;
743     if (m_opaque_sp)
744     {
745         // No need to lock, the target list is thread safe
746         sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get()));
747     }
748     return sb_target;
749 }
750 
751 
752 uint32_t
GetNumTargets()753 SBDebugger::GetNumTargets ()
754 {
755     if (m_opaque_sp)
756     {
757         // No need to lock, the target list is thread safe
758         return m_opaque_sp->GetTargetList().GetNumTargets ();
759     }
760     return 0;
761 }
762 
763 SBTarget
GetSelectedTarget()764 SBDebugger::GetSelectedTarget ()
765 {
766     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
767 
768     SBTarget sb_target;
769     TargetSP target_sp;
770     if (m_opaque_sp)
771     {
772         // No need to lock, the target list is thread safe
773         target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget ();
774         sb_target.SetSP (target_sp);
775     }
776 
777     if (log)
778     {
779         SBStream sstr;
780         sb_target.GetDescription (sstr, eDescriptionLevelBrief);
781         log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(),
782                      target_sp.get(), sstr.GetData());
783     }
784 
785     return sb_target;
786 }
787 
788 void
SetSelectedTarget(SBTarget & sb_target)789 SBDebugger::SetSelectedTarget (SBTarget &sb_target)
790 {
791     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
792 
793     TargetSP target_sp (sb_target.GetSP());
794     if (m_opaque_sp)
795     {
796         m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
797     }
798     if (log)
799     {
800         SBStream sstr;
801         sb_target.GetDescription (sstr, eDescriptionLevelBrief);
802         log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(),
803                      target_sp.get(), sstr.GetData());
804     }
805 }
806 
807 void
DispatchInput(void * baton,const void * data,size_t data_len)808 SBDebugger::DispatchInput (void* baton, const void *data, size_t data_len)
809 {
810     DispatchInput (data,data_len);
811 }
812 
813 void
DispatchInput(const void * data,size_t data_len)814 SBDebugger::DispatchInput (const void *data, size_t data_len)
815 {
816     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
817 
818     if (log)
819         log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")",
820                      m_opaque_sp.get(),
821                      (int) data_len,
822                      (const char *) data,
823                      (uint64_t)data_len);
824 
825     if (m_opaque_sp)
826         m_opaque_sp->DispatchInput ((const char *) data, data_len);
827 }
828 
829 void
DispatchInputInterrupt()830 SBDebugger::DispatchInputInterrupt ()
831 {
832     if (m_opaque_sp)
833         m_opaque_sp->DispatchInputInterrupt ();
834 }
835 
836 void
DispatchInputEndOfFile()837 SBDebugger::DispatchInputEndOfFile ()
838 {
839     if (m_opaque_sp)
840         m_opaque_sp->DispatchInputEndOfFile ();
841 }
842 
843 bool
InputReaderIsTopReader(const lldb::SBInputReader & reader)844 SBDebugger::InputReaderIsTopReader (const lldb::SBInputReader &reader)
845 {
846     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
847 
848     if (log)
849         log->Printf ("SBDebugger(%p)::InputReaderIsTopReader (SBInputReader(%p))", m_opaque_sp.get(), &reader);
850 
851     if (m_opaque_sp && reader.IsValid())
852     {
853         InputReaderSP reader_sp (*reader);
854         return m_opaque_sp->InputReaderIsTopReader (reader_sp);
855     }
856 
857     return false;
858 }
859 
860 
861 void
PushInputReader(SBInputReader & reader)862 SBDebugger::PushInputReader (SBInputReader &reader)
863 {
864     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
865 
866     if (log)
867         log->Printf ("SBDebugger(%p)::PushInputReader (SBInputReader(%p))", m_opaque_sp.get(), &reader);
868 
869     if (m_opaque_sp && reader.IsValid())
870     {
871         TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
872         Mutex::Locker api_locker;
873         if (target_sp)
874             api_locker.Lock(target_sp->GetAPIMutex());
875         InputReaderSP reader_sp(*reader);
876         m_opaque_sp->PushInputReader (reader_sp);
877     }
878 }
879 
880 void
NotifyTopInputReader(InputReaderAction notification)881 SBDebugger::NotifyTopInputReader (InputReaderAction notification)
882 {
883     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
884 
885     if (log)
886         log->Printf ("SBDebugger(%p)::NotifyTopInputReader (%d)", m_opaque_sp.get(), notification);
887 
888     if (m_opaque_sp)
889         m_opaque_sp->NotifyTopInputReader (notification);
890 }
891 
892 void
reset(const DebuggerSP & debugger_sp)893 SBDebugger::reset (const DebuggerSP &debugger_sp)
894 {
895     m_opaque_sp = debugger_sp;
896 }
897 
898 Debugger *
get() const899 SBDebugger::get () const
900 {
901     return m_opaque_sp.get();
902 }
903 
904 Debugger &
ref() const905 SBDebugger::ref () const
906 {
907     assert (m_opaque_sp.get());
908     return *m_opaque_sp;
909 }
910 
911 const lldb::DebuggerSP &
get_sp() const912 SBDebugger::get_sp () const
913 {
914     return m_opaque_sp;
915 }
916 
917 SBDebugger
FindDebuggerWithID(int id)918 SBDebugger::FindDebuggerWithID (int id)
919 {
920     // No need to lock, the debugger list is thread safe
921     SBDebugger sb_debugger;
922     DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id);
923     if (debugger_sp)
924         sb_debugger.reset (debugger_sp);
925     return sb_debugger;
926 }
927 
928 const char *
GetInstanceName()929 SBDebugger::GetInstanceName()
930 {
931     if (m_opaque_sp)
932         return m_opaque_sp->GetInstanceName().AsCString();
933     else
934         return NULL;
935 }
936 
937 SBError
SetInternalVariable(const char * var_name,const char * value,const char * debugger_instance_name)938 SBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name)
939 {
940     SBError sb_error;
941     DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
942     Error error;
943     if (debugger_sp)
944     {
945         ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
946         error = debugger_sp->SetPropertyValue (&exe_ctx,
947                                                eVarSetOperationAssign,
948                                                var_name,
949                                                value);
950     }
951     else
952     {
953         error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name);
954     }
955     if (error.Fail())
956         sb_error.SetError(error);
957     return sb_error;
958 }
959 
960 SBStringList
GetInternalVariableValue(const char * var_name,const char * debugger_instance_name)961 SBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name)
962 {
963     SBStringList ret_value;
964     DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
965     Error error;
966     if (debugger_sp)
967     {
968         ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
969         lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx,
970                                                                      var_name,
971                                                                      false,
972                                                                      error));
973         if (value_sp)
974         {
975             StreamString value_strm;
976             value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
977             const std::string &value_str = value_strm.GetString();
978             if (!value_str.empty())
979             {
980                 StringList string_list;
981                 string_list.SplitIntoLines(value_str.c_str(), value_str.size());
982                 return SBStringList(&string_list);
983             }
984         }
985     }
986     return SBStringList();
987 }
988 
989 uint32_t
GetTerminalWidth() const990 SBDebugger::GetTerminalWidth () const
991 {
992     if (m_opaque_sp)
993         return m_opaque_sp->GetTerminalWidth ();
994     return 0;
995 }
996 
997 void
SetTerminalWidth(uint32_t term_width)998 SBDebugger::SetTerminalWidth (uint32_t term_width)
999 {
1000     if (m_opaque_sp)
1001         m_opaque_sp->SetTerminalWidth (term_width);
1002 }
1003 
1004 const char *
GetPrompt() const1005 SBDebugger::GetPrompt() const
1006 {
1007     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1008 
1009     if (log)
1010         log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(),
1011                      (m_opaque_sp ? m_opaque_sp->GetPrompt() : ""));
1012 
1013     if (m_opaque_sp)
1014         return m_opaque_sp->GetPrompt ();
1015     return 0;
1016 }
1017 
1018 void
SetPrompt(const char * prompt)1019 SBDebugger::SetPrompt (const char *prompt)
1020 {
1021     if (m_opaque_sp)
1022         m_opaque_sp->SetPrompt (prompt);
1023 }
1024 
1025 
1026 ScriptLanguage
GetScriptLanguage() const1027 SBDebugger::GetScriptLanguage() const
1028 {
1029     if (m_opaque_sp)
1030         return m_opaque_sp->GetScriptLanguage ();
1031     return eScriptLanguageNone;
1032 }
1033 
1034 void
SetScriptLanguage(ScriptLanguage script_lang)1035 SBDebugger::SetScriptLanguage (ScriptLanguage script_lang)
1036 {
1037     if (m_opaque_sp)
1038     {
1039         m_opaque_sp->SetScriptLanguage (script_lang);
1040     }
1041 }
1042 
1043 bool
SetUseExternalEditor(bool value)1044 SBDebugger::SetUseExternalEditor (bool value)
1045 {
1046     if (m_opaque_sp)
1047         return m_opaque_sp->SetUseExternalEditor (value);
1048     return false;
1049 }
1050 
1051 bool
GetUseExternalEditor()1052 SBDebugger::GetUseExternalEditor ()
1053 {
1054     if (m_opaque_sp)
1055         return m_opaque_sp->GetUseExternalEditor ();
1056     return false;
1057 }
1058 
1059 bool
SetUseColor(bool value)1060 SBDebugger::SetUseColor (bool value)
1061 {
1062     if (m_opaque_sp)
1063         return m_opaque_sp->SetUseColor (value);
1064     return false;
1065 }
1066 
1067 bool
GetUseColor() const1068 SBDebugger::GetUseColor () const
1069 {
1070     if (m_opaque_sp)
1071         return m_opaque_sp->GetUseColor ();
1072     return false;
1073 }
1074 
1075 bool
GetDescription(SBStream & description)1076 SBDebugger::GetDescription (SBStream &description)
1077 {
1078     Stream &strm = description.ref();
1079 
1080     if (m_opaque_sp)
1081     {
1082         const char *name = m_opaque_sp->GetInstanceName().AsCString();
1083         user_id_t id = m_opaque_sp->GetID();
1084         strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1085     }
1086     else
1087         strm.PutCString ("No value");
1088 
1089     return true;
1090 }
1091 
1092 user_id_t
GetID()1093 SBDebugger::GetID()
1094 {
1095     if (m_opaque_sp)
1096         return m_opaque_sp->GetID();
1097     return LLDB_INVALID_UID;
1098 }
1099 
1100 
1101 SBError
SetCurrentPlatform(const char * platform_name)1102 SBDebugger::SetCurrentPlatform (const char *platform_name)
1103 {
1104     SBError sb_error;
1105     if (m_opaque_sp)
1106     {
1107         PlatformSP platform_sp (Platform::Create (platform_name, sb_error.ref()));
1108 
1109         if (platform_sp)
1110         {
1111             bool make_selected = true;
1112             m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected);
1113         }
1114     }
1115     return sb_error;
1116 }
1117 
1118 bool
SetCurrentPlatformSDKRoot(const char * sysroot)1119 SBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot)
1120 {
1121     if (m_opaque_sp)
1122     {
1123         PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1124 
1125         if (platform_sp)
1126         {
1127             platform_sp->SetSDKRootDirectory (ConstString (sysroot));
1128             return true;
1129         }
1130     }
1131     return false;
1132 }
1133 
1134 bool
GetCloseInputOnEOF() const1135 SBDebugger::GetCloseInputOnEOF () const
1136 {
1137     if (m_opaque_sp)
1138         return m_opaque_sp->GetCloseInputOnEOF ();
1139     return false;
1140 }
1141 
1142 void
SetCloseInputOnEOF(bool b)1143 SBDebugger::SetCloseInputOnEOF (bool b)
1144 {
1145     if (m_opaque_sp)
1146         m_opaque_sp->SetCloseInputOnEOF (b);
1147 }
1148 
1149 SBTypeCategory
GetCategory(const char * category_name)1150 SBDebugger::GetCategory (const char* category_name)
1151 {
1152     if (!category_name || *category_name == 0)
1153         return SBTypeCategory();
1154 
1155     TypeCategoryImplSP category_sp;
1156 
1157     if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false))
1158         return SBTypeCategory(category_sp);
1159     else
1160         return SBTypeCategory();
1161 }
1162 
1163 SBTypeCategory
CreateCategory(const char * category_name)1164 SBDebugger::CreateCategory (const char* category_name)
1165 {
1166     if (!category_name || *category_name == 0)
1167         return SBTypeCategory();
1168 
1169     TypeCategoryImplSP category_sp;
1170 
1171     if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true))
1172         return SBTypeCategory(category_sp);
1173     else
1174         return SBTypeCategory();
1175 }
1176 
1177 bool
DeleteCategory(const char * category_name)1178 SBDebugger::DeleteCategory (const char* category_name)
1179 {
1180     if (!category_name || *category_name == 0)
1181         return false;
1182 
1183     return DataVisualization::Categories::Delete(ConstString(category_name));
1184 }
1185 
1186 uint32_t
GetNumCategories()1187 SBDebugger::GetNumCategories()
1188 {
1189     return DataVisualization::Categories::GetCount();
1190 }
1191 
1192 SBTypeCategory
GetCategoryAtIndex(uint32_t index)1193 SBDebugger::GetCategoryAtIndex (uint32_t index)
1194 {
1195     return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index));
1196 }
1197 
1198 SBTypeCategory
GetDefaultCategory()1199 SBDebugger::GetDefaultCategory()
1200 {
1201     return GetCategory("default");
1202 }
1203 
1204 SBTypeFormat
GetFormatForType(SBTypeNameSpecifier type_name)1205 SBDebugger::GetFormatForType (SBTypeNameSpecifier type_name)
1206 {
1207     SBTypeCategory default_category_sb = GetDefaultCategory();
1208     if (default_category_sb.GetEnabled())
1209         return default_category_sb.GetFormatForType(type_name);
1210     return SBTypeFormat();
1211 }
1212 
1213 #ifndef LLDB_DISABLE_PYTHON
1214 SBTypeSummary
GetSummaryForType(SBTypeNameSpecifier type_name)1215 SBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name)
1216 {
1217     if (type_name.IsValid() == false)
1218         return SBTypeSummary();
1219     return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
1220 }
1221 #endif // LLDB_DISABLE_PYTHON
1222 
1223 SBTypeFilter
GetFilterForType(SBTypeNameSpecifier type_name)1224 SBDebugger::GetFilterForType (SBTypeNameSpecifier type_name)
1225 {
1226     if (type_name.IsValid() == false)
1227         return SBTypeFilter();
1228     return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
1229 }
1230 
1231 #ifndef LLDB_DISABLE_PYTHON
1232 SBTypeSynthetic
GetSyntheticForType(SBTypeNameSpecifier type_name)1233 SBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name)
1234 {
1235     if (type_name.IsValid() == false)
1236         return SBTypeSynthetic();
1237     return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP()));
1238 }
1239 #endif // LLDB_DISABLE_PYTHON
1240 
1241 bool
EnableLog(const char * channel,const char ** categories)1242 SBDebugger::EnableLog (const char *channel, const char **categories)
1243 {
1244     if (m_opaque_sp)
1245     {
1246         uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1247         StreamString errors;
1248         return m_opaque_sp->EnableLog (channel, categories, NULL, log_options, errors);
1249 
1250     }
1251     else
1252         return false;
1253 }
1254 
1255 void
SetLoggingCallback(lldb::LogOutputCallback log_callback,void * baton)1256 SBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
1257 {
1258     if (m_opaque_sp)
1259     {
1260         return m_opaque_sp->SetLoggingCallback (log_callback, baton);
1261     }
1262 }
1263 
1264 
1265