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