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