1254721Semaste//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
2254721Semaste//
3254721Semaste//                     The LLVM Compiler Infrastructure
4254721Semaste//
5254721Semaste// This file is distributed under the University of Illinois Open Source
6254721Semaste// License. See LICENSE.TXT for details.
7254721Semaste//
8254721Semaste//===----------------------------------------------------------------------===//
9254721Semaste
10296417Sdim// C Includes
11296417Sdim// C++ Includes
12296417Sdim// Other libraries and framework includes
13296417Sdim// Project includes
14254721Semaste#include "lldb/API/SBDebugger.h"
15254721Semaste
16254721Semaste#include "lldb/lldb-private.h"
17254721Semaste
18288943Sdim#include "lldb/API/SystemInitializerFull.h"
19254721Semaste#include "lldb/API/SBListener.h"
20254721Semaste#include "lldb/API/SBBroadcaster.h"
21254721Semaste#include "lldb/API/SBCommandInterpreter.h"
22254721Semaste#include "lldb/API/SBCommandReturnObject.h"
23254721Semaste#include "lldb/API/SBError.h"
24254721Semaste#include "lldb/API/SBEvent.h"
25254721Semaste#include "lldb/API/SBFrame.h"
26254721Semaste#include "lldb/API/SBProcess.h"
27254721Semaste#include "lldb/API/SBSourceManager.h"
28254721Semaste#include "lldb/API/SBStream.h"
29254721Semaste#include "lldb/API/SBStringList.h"
30254721Semaste#include "lldb/API/SBTarget.h"
31254721Semaste#include "lldb/API/SBThread.h"
32254721Semaste#include "lldb/API/SBTypeCategory.h"
33254721Semaste#include "lldb/API/SBTypeFormat.h"
34254721Semaste#include "lldb/API/SBTypeFilter.h"
35254721Semaste#include "lldb/API/SBTypeNameSpecifier.h"
36254721Semaste#include "lldb/API/SBTypeSummary.h"
37254721Semaste#include "lldb/API/SBTypeSynthetic.h"
38254721Semaste
39254721Semaste#include "lldb/Core/Debugger.h"
40254721Semaste#include "lldb/Core/State.h"
41262528Semaste#include "lldb/Core/StreamFile.h"
42254721Semaste#include "lldb/DataFormatters/DataVisualization.h"
43288943Sdim#include "lldb/Initialization/SystemLifetimeManager.h"
44254721Semaste#include "lldb/Interpreter/Args.h"
45254721Semaste#include "lldb/Interpreter/CommandInterpreter.h"
46254721Semaste#include "lldb/Interpreter/OptionGroupPlatform.h"
47254721Semaste#include "lldb/Target/Process.h"
48254721Semaste#include "lldb/Target/TargetList.h"
49254721Semaste
50296417Sdim#include "llvm/ADT/STLExtras.h"
51288943Sdim#include "llvm/Support/ManagedStatic.h"
52276479Sdim#include "llvm/Support/DynamicLibrary.h"
53276479Sdim
54254721Semasteusing namespace lldb;
55254721Semasteusing namespace lldb_private;
56254721Semaste
57276479Sdimstatic llvm::sys::DynamicLibrary
58258884SemasteLoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error)
59258884Semaste{
60276479Sdim    llvm::sys::DynamicLibrary dynlib = llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
61276479Sdim    if (dynlib.isValid())
62258884Semaste    {
63258884Semaste        typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger);
64258884Semaste
65258884Semaste        lldb::SBDebugger debugger_sb(debugger_sp);
66258884Semaste        // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function.
67258884Semaste        // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays
68276479Sdim        LLDBCommandPluginInit init_func = (LLDBCommandPluginInit)dynlib.getAddressOfSymbol("_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
69258884Semaste        if (init_func)
70258884Semaste        {
71258884Semaste            if (init_func(debugger_sb))
72276479Sdim                return dynlib;
73258884Semaste            else
74258884Semaste                error.SetErrorString("plug-in refused to load (lldb::PluginInitialize(lldb::SBDebugger) returned false)");
75258884Semaste        }
76258884Semaste        else
77258884Semaste        {
78258884Semaste            error.SetErrorString("plug-in is missing the required initialization: lldb::PluginInitialize(lldb::SBDebugger)");
79258884Semaste        }
80258884Semaste    }
81258884Semaste    else
82258884Semaste    {
83258884Semaste        if (spec.Exists())
84258884Semaste            error.SetErrorString("this file does not represent a loadable dylib");
85258884Semaste        else
86258884Semaste            error.SetErrorString("no such file");
87258884Semaste    }
88276479Sdim    return llvm::sys::DynamicLibrary();
89258884Semaste}
90258884Semaste
91288943Sdimstatic llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
92288943Sdim
93288943SdimSBError
94288943SdimSBInputReader::Initialize(lldb::SBDebugger &sb_debugger,
95288943Sdim                          unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, char const *,
96288943Sdim                                            unsigned long),
97288943Sdim                          void *, lldb::InputReaderGranularity, char const *, char const *, bool)
98288943Sdim{
99288943Sdim    return SBError();
100288943Sdim}
101288943Sdim
102254721Semastevoid
103288943SdimSBInputReader::SetIsDone(bool)
104288943Sdim{
105288943Sdim}
106296417Sdim
107288943Sdimbool
108288943SdimSBInputReader::IsActive() const
109288943Sdim{
110288943Sdim    return false;
111288943Sdim}
112288943Sdim
113296417SdimSBDebugger::SBDebugger() = default;
114296417Sdim
115296417SdimSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) :
116296417Sdim    m_opaque_sp(debugger_sp)
117296417Sdim{
118296417Sdim}
119296417Sdim
120296417SdimSBDebugger::SBDebugger(const SBDebugger &rhs) :
121296417Sdim    m_opaque_sp (rhs.m_opaque_sp)
122296417Sdim{
123296417Sdim}
124296417Sdim
125296417SdimSBDebugger::~SBDebugger() = default;
126296417Sdim
127296417SdimSBDebugger &
128296417SdimSBDebugger::operator = (const SBDebugger &rhs)
129296417Sdim{
130296417Sdim    if (this != &rhs)
131296417Sdim    {
132296417Sdim        m_opaque_sp = rhs.m_opaque_sp;
133296417Sdim    }
134296417Sdim    return *this;
135296417Sdim}
136296417Sdim
137288943Sdimvoid
138254721SemasteSBDebugger::Initialize ()
139254721Semaste{
140254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
141254721Semaste
142254721Semaste    if (log)
143254721Semaste        log->Printf ("SBDebugger::Initialize ()");
144254721Semaste
145288943Sdim    g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(), LoadPlugin);
146254721Semaste}
147254721Semaste
148254721Semastevoid
149254721SemasteSBDebugger::Terminate ()
150254721Semaste{
151288943Sdim    g_debugger_lifetime->Terminate();
152254721Semaste}
153254721Semaste
154254721Semastevoid
155254721SemasteSBDebugger::Clear ()
156254721Semaste{
157254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
158254721Semaste
159254721Semaste    if (log)
160276479Sdim        log->Printf ("SBDebugger(%p)::Clear ()",
161276479Sdim                     static_cast<void*>(m_opaque_sp.get()));
162276479Sdim
163254721Semaste    if (m_opaque_sp)
164262528Semaste        m_opaque_sp->ClearIOHandlers ();
165254721Semaste
166254721Semaste    m_opaque_sp.reset();
167254721Semaste}
168254721Semaste
169254721SemasteSBDebugger
170254721SemasteSBDebugger::Create()
171254721Semaste{
172296417Sdim    return SBDebugger::Create(false, nullptr, nullptr);
173254721Semaste}
174254721Semaste
175254721SemasteSBDebugger
176254721SemasteSBDebugger::Create(bool source_init_files)
177254721Semaste{
178296417Sdim    return SBDebugger::Create (source_init_files, nullptr, nullptr);
179254721Semaste}
180254721Semaste
181254721SemasteSBDebugger
182254721SemasteSBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton)
183254721Semaste
184254721Semaste{
185254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
186254721Semaste
187254721Semaste    SBDebugger debugger;
188276479Sdim
189276479Sdim    // Currently we have issues if this function is called simultaneously on two different
190276479Sdim    // threads. The issues mainly revolve around the fact that the lldb_private::FormatManager
191276479Sdim    // uses global collections and having two threads parsing the .lldbinit files can cause
192276479Sdim    // mayhem. So to get around this for now we need to use a mutex to prevent bad things
193276479Sdim    // from happening.
194276479Sdim    static Mutex g_mutex(Mutex::eMutexTypeRecursive);
195276479Sdim    Mutex::Locker locker(g_mutex);
196276479Sdim
197254721Semaste    debugger.reset(Debugger::CreateInstance(callback, baton));
198254721Semaste
199254721Semaste    if (log)
200254721Semaste    {
201254721Semaste        SBStream sstr;
202254721Semaste        debugger.GetDescription (sstr);
203276479Sdim        log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s",
204276479Sdim                     static_cast<void*>(debugger.m_opaque_sp.get()),
205276479Sdim                     sstr.GetData());
206254721Semaste    }
207254721Semaste
208254721Semaste    SBCommandInterpreter interp = debugger.GetCommandInterpreter();
209254721Semaste    if (source_init_files)
210254721Semaste    {
211254721Semaste        interp.get()->SkipLLDBInitFiles(false);
212254721Semaste        interp.get()->SkipAppInitFiles (false);
213254721Semaste        SBCommandReturnObject result;
214254721Semaste        interp.SourceInitFileInHomeDirectory(result);
215254721Semaste    }
216254721Semaste    else
217254721Semaste    {
218254721Semaste        interp.get()->SkipLLDBInitFiles(true);
219254721Semaste        interp.get()->SkipAppInitFiles (true);
220254721Semaste    }
221254721Semaste    return debugger;
222254721Semaste}
223254721Semaste
224254721Semastevoid
225254721SemasteSBDebugger::Destroy (SBDebugger &debugger)
226254721Semaste{
227254721Semaste    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
228276479Sdim
229254721Semaste    if (log)
230254721Semaste    {
231254721Semaste        SBStream sstr;
232254721Semaste        debugger.GetDescription (sstr);
233276479Sdim        log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s",
234276479Sdim                     static_cast<void*>(debugger.m_opaque_sp.get()),
235276479Sdim                     sstr.GetData());
236254721Semaste    }
237276479Sdim
238254721Semaste    Debugger::Destroy (debugger.m_opaque_sp);
239276479Sdim
240296417Sdim    if (debugger.m_opaque_sp.get() != nullptr)
241254721Semaste        debugger.m_opaque_sp.reset();
242254721Semaste}
243254721Semaste
244254721Semastevoid
245254721SemasteSBDebugger::MemoryPressureDetected ()
246254721Semaste{
247254721Semaste    // Since this function can be call asynchronously, we allow it to be
248254721Semaste    // non-mandatory. We have seen deadlocks with this function when called
249254721Semaste    // so we need to safeguard against this until we can determine what is
250254721Semaste    // causing the deadlocks.
251254721Semaste    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
252254721Semaste
253254721Semaste    const bool mandatory = false;
254254721Semaste    if (log)
255254721Semaste    {
256254721Semaste        log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory);
257254721Semaste    }
258254721Semaste
259254721Semaste    ModuleList::RemoveOrphanSharedModules(mandatory);
260254721Semaste}
261254721Semaste
262254721Semastebool
263254721SemasteSBDebugger::IsValid() const
264254721Semaste{
265296417Sdim    return m_opaque_sp.get() != nullptr;
266254721Semaste}
267254721Semaste
268254721Semastevoid
269254721SemasteSBDebugger::SetAsync (bool b)
270254721Semaste{
271254721Semaste    if (m_opaque_sp)
272254721Semaste        m_opaque_sp->SetAsyncExecution(b);
273254721Semaste}
274254721Semaste
275254721Semastebool
276296417SdimSBDebugger::GetAsync()
277254721Semaste{
278296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
279254721Semaste}
280254721Semaste
281254721Semastevoid
282254721SemasteSBDebugger::SkipLLDBInitFiles (bool b)
283254721Semaste{
284254721Semaste    if (m_opaque_sp)
285254721Semaste        m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b);
286254721Semaste}
287254721Semaste
288254721Semastevoid
289254721SemasteSBDebugger::SkipAppInitFiles (bool b)
290254721Semaste{
291254721Semaste    if (m_opaque_sp)
292254721Semaste        m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b);
293254721Semaste}
294254721Semaste
295254721Semaste// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users
296254721Semaste// trying to switch modes in the middle of a debugging session.
297254721Semastevoid
298254721SemasteSBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership)
299254721Semaste{
300254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
301254721Semaste
302254721Semaste    if (log)
303276479Sdim        log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
304276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
305276479Sdim                     static_cast<void*>(fh), transfer_ownership);
306254721Semaste
307254721Semaste    if (m_opaque_sp)
308254721Semaste        m_opaque_sp->SetInputFileHandle (fh, transfer_ownership);
309254721Semaste}
310254721Semaste
311254721Semastevoid
312254721SemasteSBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership)
313254721Semaste{
314254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
315254721Semaste
316254721Semaste
317254721Semaste    if (log)
318276479Sdim        log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
319276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
320276479Sdim                     static_cast<void*>(fh), transfer_ownership);
321254721Semaste
322254721Semaste    if (m_opaque_sp)
323254721Semaste        m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership);
324254721Semaste}
325254721Semaste
326254721Semastevoid
327254721SemasteSBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership)
328254721Semaste{
329254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
330254721Semaste
331254721Semaste
332254721Semaste    if (log)
333276479Sdim        log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
334276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
335276479Sdim                     static_cast<void*>(fh), transfer_ownership);
336254721Semaste
337254721Semaste    if (m_opaque_sp)
338254721Semaste        m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership);
339254721Semaste}
340254721Semaste
341254721SemasteFILE *
342254721SemasteSBDebugger::GetInputFileHandle ()
343254721Semaste{
344254721Semaste    if (m_opaque_sp)
345262528Semaste    {
346262528Semaste        StreamFileSP stream_file_sp (m_opaque_sp->GetInputFile());
347262528Semaste        if (stream_file_sp)
348262528Semaste            return stream_file_sp->GetFile().GetStream();
349262528Semaste    }
350296417Sdim    return nullptr;
351254721Semaste}
352254721Semaste
353254721SemasteFILE *
354254721SemasteSBDebugger::GetOutputFileHandle ()
355254721Semaste{
356254721Semaste    if (m_opaque_sp)
357262528Semaste    {
358262528Semaste        StreamFileSP stream_file_sp (m_opaque_sp->GetOutputFile());
359262528Semaste        if (stream_file_sp)
360262528Semaste            return stream_file_sp->GetFile().GetStream();
361262528Semaste    }
362296417Sdim    return nullptr;
363254721Semaste}
364254721Semaste
365254721SemasteFILE *
366254721SemasteSBDebugger::GetErrorFileHandle ()
367254721Semaste{
368254721Semaste    if (m_opaque_sp)
369296417Sdim    {
370296417Sdim        StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
371296417Sdim        if (stream_file_sp)
372296417Sdim            return stream_file_sp->GetFile().GetStream();
373296417Sdim    }
374296417Sdim    return nullptr;
375254721Semaste}
376254721Semaste
377254721Semastevoid
378254721SemasteSBDebugger::SaveInputTerminalState()
379254721Semaste{
380254721Semaste    if (m_opaque_sp)
381254721Semaste        m_opaque_sp->SaveInputTerminalState();
382254721Semaste}
383254721Semaste
384254721Semastevoid
385254721SemasteSBDebugger::RestoreInputTerminalState()
386254721Semaste{
387254721Semaste    if (m_opaque_sp)
388254721Semaste        m_opaque_sp->RestoreInputTerminalState();
389254721Semaste
390254721Semaste}
391254721SemasteSBCommandInterpreter
392254721SemasteSBDebugger::GetCommandInterpreter ()
393254721Semaste{
394254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
395254721Semaste
396254721Semaste    SBCommandInterpreter sb_interpreter;
397254721Semaste    if (m_opaque_sp)
398254721Semaste        sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter());
399254721Semaste
400254721Semaste    if (log)
401276479Sdim        log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
402276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
403276479Sdim                     static_cast<void*>(sb_interpreter.get()));
404254721Semaste
405254721Semaste    return sb_interpreter;
406254721Semaste}
407254721Semaste
408254721Semastevoid
409254721SemasteSBDebugger::HandleCommand (const char *command)
410254721Semaste{
411254721Semaste    if (m_opaque_sp)
412254721Semaste    {
413254721Semaste        TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
414254721Semaste        Mutex::Locker api_locker;
415254721Semaste        if (target_sp)
416254721Semaste            api_locker.Lock(target_sp->GetAPIMutex());
417254721Semaste
418254721Semaste        SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
419254721Semaste        SBCommandReturnObject result;
420254721Semaste
421254721Semaste        sb_interpreter.HandleCommand (command, result, false);
422254721Semaste
423296417Sdim        if (GetErrorFileHandle() != nullptr)
424254721Semaste            result.PutError (GetErrorFileHandle());
425296417Sdim        if (GetOutputFileHandle() != nullptr)
426254721Semaste            result.PutOutput (GetOutputFileHandle());
427254721Semaste
428296417Sdim        if (!m_opaque_sp->GetAsyncExecution())
429254721Semaste        {
430254721Semaste            SBProcess process(GetCommandInterpreter().GetProcess ());
431254721Semaste            ProcessSP process_sp (process.GetSP());
432254721Semaste            if (process_sp)
433254721Semaste            {
434254721Semaste                EventSP event_sp;
435254721Semaste                Listener &lldb_listener = m_opaque_sp->GetListener();
436254721Semaste                while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp))
437254721Semaste                {
438254721Semaste                    SBEvent event(event_sp);
439254721Semaste                    HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle());
440254721Semaste                }
441254721Semaste            }
442254721Semaste        }
443254721Semaste    }
444254721Semaste}
445254721Semaste
446254721SemasteSBListener
447254721SemasteSBDebugger::GetListener ()
448254721Semaste{
449254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
450254721Semaste
451254721Semaste    SBListener sb_listener;
452254721Semaste    if (m_opaque_sp)
453254721Semaste        sb_listener.reset(&m_opaque_sp->GetListener(), false);
454254721Semaste
455254721Semaste    if (log)
456276479Sdim        log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)",
457276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
458276479Sdim                     static_cast<void*>(sb_listener.get()));
459254721Semaste
460254721Semaste    return sb_listener;
461254721Semaste}
462254721Semaste
463254721Semastevoid
464254721SemasteSBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err)
465254721Semaste{
466254721Semaste    if (!process.IsValid())
467254721Semaste        return;
468254721Semaste
469254721Semaste    TargetSP target_sp (process.GetTarget().GetSP());
470254721Semaste    if (!target_sp)
471254721Semaste        return;
472254721Semaste
473254721Semaste    const uint32_t event_type = event.GetType();
474254721Semaste    char stdio_buffer[1024];
475254721Semaste    size_t len;
476254721Semaste
477254721Semaste    Mutex::Locker api_locker (target_sp->GetAPIMutex());
478254721Semaste
479254721Semaste    if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged))
480254721Semaste    {
481254721Semaste        // Drain stdout when we stop just in case we have any bytes
482254721Semaste        while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0)
483296417Sdim            if (out != nullptr)
484254721Semaste                ::fwrite (stdio_buffer, 1, len, out);
485254721Semaste    }
486254721Semaste
487254721Semaste    if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged))
488254721Semaste    {
489254721Semaste        // Drain stderr when we stop just in case we have any bytes
490254721Semaste        while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0)
491296417Sdim            if (err != nullptr)
492254721Semaste                ::fwrite (stdio_buffer, 1, len, err);
493254721Semaste    }
494254721Semaste
495254721Semaste    if (event_type & Process::eBroadcastBitStateChanged)
496254721Semaste    {
497254721Semaste        StateType event_state = SBProcess::GetStateFromEvent (event);
498254721Semaste
499254721Semaste        if (event_state == eStateInvalid)
500254721Semaste            return;
501254721Semaste
502254721Semaste        bool is_stopped = StateIsStoppedState (event_state);
503254721Semaste        if (!is_stopped)
504254721Semaste            process.ReportEventState (event, out);
505254721Semaste    }
506254721Semaste}
507254721Semaste
508254721SemasteSBSourceManager
509254721SemasteSBDebugger::GetSourceManager ()
510254721Semaste{
511254721Semaste    SBSourceManager sb_source_manager (*this);
512254721Semaste    return sb_source_manager;
513254721Semaste}
514254721Semaste
515254721Semastebool
516254721SemasteSBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len)
517254721Semaste{
518254721Semaste    if (arch_name && arch_name_len)
519254721Semaste    {
520254721Semaste        ArchSpec default_arch = Target::GetDefaultArchitecture ();
521254721Semaste
522254721Semaste        if (default_arch.IsValid())
523254721Semaste        {
524254721Semaste            const std::string &triple_str = default_arch.GetTriple().str();
525254721Semaste            if (!triple_str.empty())
526254721Semaste                ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str());
527254721Semaste            else
528254721Semaste                ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName());
529254721Semaste            return true;
530254721Semaste        }
531254721Semaste    }
532254721Semaste    if (arch_name && arch_name_len)
533254721Semaste        arch_name[0] = '\0';
534254721Semaste    return false;
535254721Semaste}
536254721Semaste
537254721Semastebool
538254721SemasteSBDebugger::SetDefaultArchitecture (const char *arch_name)
539254721Semaste{
540254721Semaste    if (arch_name)
541254721Semaste    {
542254721Semaste        ArchSpec arch (arch_name);
543254721Semaste        if (arch.IsValid())
544254721Semaste        {
545254721Semaste            Target::SetDefaultArchitecture (arch);
546254721Semaste            return true;
547254721Semaste        }
548254721Semaste    }
549254721Semaste    return false;
550254721Semaste}
551254721Semaste
552254721SemasteScriptLanguage
553296417SdimSBDebugger::GetScriptingLanguage(const char *script_language_name)
554254721Semaste{
555296417Sdim    return Args::StringToScriptLanguage(script_language_name,
556296417Sdim                                        eScriptLanguageDefault,
557296417Sdim                                        nullptr);
558254721Semaste}
559254721Semaste
560254721Semasteconst char *
561254721SemasteSBDebugger::GetVersionString ()
562254721Semaste{
563258054Semaste    return lldb_private::GetVersion();
564254721Semaste}
565254721Semaste
566254721Semasteconst char *
567254721SemasteSBDebugger::StateAsCString (StateType state)
568254721Semaste{
569254721Semaste    return lldb_private::StateAsCString (state);
570254721Semaste}
571254721Semaste
572254721Semastebool
573254721SemasteSBDebugger::StateIsRunningState (StateType state)
574254721Semaste{
575254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
576254721Semaste
577254721Semaste    const bool result = lldb_private::StateIsRunningState (state);
578254721Semaste    if (log)
579254721Semaste        log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i",
580254721Semaste                     StateAsCString (state), result);
581254721Semaste
582254721Semaste    return result;
583254721Semaste}
584254721Semaste
585254721Semastebool
586254721SemasteSBDebugger::StateIsStoppedState (StateType state)
587254721Semaste{
588254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
589254721Semaste
590254721Semaste    const bool result = lldb_private::StateIsStoppedState (state, false);
591254721Semaste    if (log)
592254721Semaste        log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i",
593254721Semaste                     StateAsCString (state), result);
594254721Semaste
595254721Semaste    return result;
596254721Semaste}
597254721Semaste
598254721Semastelldb::SBTarget
599254721SemasteSBDebugger::CreateTarget (const char *filename,
600254721Semaste                          const char *target_triple,
601254721Semaste                          const char *platform_name,
602254721Semaste                          bool add_dependent_modules,
603254721Semaste                          lldb::SBError& sb_error)
604254721Semaste{
605254721Semaste    SBTarget sb_target;
606254721Semaste    TargetSP target_sp;
607254721Semaste    if (m_opaque_sp)
608254721Semaste    {
609254721Semaste        sb_error.Clear();
610254721Semaste        OptionGroupPlatform platform_options (false);
611254721Semaste        platform_options.SetPlatformName (platform_name);
612276479Sdim
613254721Semaste        sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
614254721Semaste                                                                    filename,
615254721Semaste                                                                    target_triple,
616254721Semaste                                                                    add_dependent_modules,
617254721Semaste                                                                    &platform_options,
618254721Semaste                                                                    target_sp);
619276479Sdim
620254721Semaste        if (sb_error.Success())
621254721Semaste            sb_target.SetSP (target_sp);
622254721Semaste    }
623254721Semaste    else
624254721Semaste    {
625296417Sdim        sb_error.SetErrorString("invalid debugger");
626254721Semaste    }
627276479Sdim
628254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
629254721Semaste    if (log)
630276479Sdim        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)",
631276479Sdim                     static_cast<void*>(m_opaque_sp.get()), filename,
632276479Sdim                     target_triple, platform_name, add_dependent_modules,
633276479Sdim                     sb_error.GetCString(), static_cast<void*>(target_sp.get()));
634276479Sdim
635254721Semaste    return sb_target;
636254721Semaste}
637254721Semaste
638254721SemasteSBTarget
639254721SemasteSBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename,
640254721Semaste                                                 const char *target_triple)
641254721Semaste{
642254721Semaste    SBTarget sb_target;
643254721Semaste    TargetSP target_sp;
644254721Semaste    if (m_opaque_sp)
645254721Semaste    {
646254721Semaste        const bool add_dependent_modules = true;
647296417Sdim        Error error (m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp,
648296417Sdim                                                               filename,
649296417Sdim                                                               target_triple,
650296417Sdim                                                               add_dependent_modules,
651296417Sdim                                                               nullptr,
652296417Sdim                                                               target_sp));
653254721Semaste        sb_target.SetSP (target_sp);
654254721Semaste    }
655276479Sdim
656254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
657254721Semaste    if (log)
658276479Sdim        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)",
659276479Sdim                     static_cast<void*>(m_opaque_sp.get()), filename,
660276479Sdim                     target_triple, static_cast<void*>(target_sp.get()));
661254721Semaste
662254721Semaste    return sb_target;
663254721Semaste}
664254721Semaste
665254721SemasteSBTarget
666254721SemasteSBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr)
667254721Semaste{
668254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
669254721Semaste
670254721Semaste    SBTarget sb_target;
671254721Semaste    TargetSP target_sp;
672254721Semaste    if (m_opaque_sp)
673254721Semaste    {
674254721Semaste        Error error;
675254721Semaste        const bool add_dependent_modules = true;
676254721Semaste
677296417Sdim        error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp,
678296417Sdim                                                          filename,
679296417Sdim                                                          arch_cstr,
680296417Sdim                                                          add_dependent_modules,
681296417Sdim                                                          nullptr,
682296417Sdim                                                          target_sp);
683254721Semaste
684254721Semaste        if (error.Success())
685254721Semaste        {
686254721Semaste            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
687254721Semaste            sb_target.SetSP (target_sp);
688254721Semaste        }
689254721Semaste    }
690254721Semaste
691254721Semaste    if (log)
692276479Sdim        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)",
693276479Sdim                     static_cast<void*>(m_opaque_sp.get()), filename, arch_cstr,
694276479Sdim                     static_cast<void*>(target_sp.get()));
695254721Semaste
696254721Semaste    return sb_target;
697254721Semaste}
698254721Semaste
699254721SemasteSBTarget
700254721SemasteSBDebugger::CreateTarget (const char *filename)
701254721Semaste{
702254721Semaste    SBTarget sb_target;
703254721Semaste    TargetSP target_sp;
704254721Semaste    if (m_opaque_sp)
705254721Semaste    {
706254721Semaste        Error error;
707254721Semaste        const bool add_dependent_modules = true;
708296417Sdim        error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp,
709296417Sdim                                                          filename,
710296417Sdim                                                          nullptr,
711296417Sdim                                                          add_dependent_modules,
712296417Sdim                                                          nullptr,
713296417Sdim                                                          target_sp);
714254721Semaste
715254721Semaste        if (error.Success())
716254721Semaste        {
717254721Semaste            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
718254721Semaste            sb_target.SetSP (target_sp);
719254721Semaste        }
720254721Semaste    }
721254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
722254721Semaste    if (log)
723276479Sdim        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
724276479Sdim                     static_cast<void*>(m_opaque_sp.get()), filename,
725276479Sdim                     static_cast<void*>(target_sp.get()));
726254721Semaste    return sb_target;
727254721Semaste}
728254721Semaste
729254721Semastebool
730254721SemasteSBDebugger::DeleteTarget (lldb::SBTarget &target)
731254721Semaste{
732254721Semaste    bool result = false;
733254721Semaste    if (m_opaque_sp)
734254721Semaste    {
735254721Semaste        TargetSP target_sp(target.GetSP());
736254721Semaste        if (target_sp)
737254721Semaste        {
738254721Semaste            // No need to lock, the target list is thread safe
739254721Semaste            result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp);
740254721Semaste            target_sp->Destroy();
741254721Semaste            target.Clear();
742254721Semaste            const bool mandatory = true;
743254721Semaste            ModuleList::RemoveOrphanSharedModules(mandatory);
744254721Semaste        }
745254721Semaste    }
746254721Semaste
747254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
748254721Semaste    if (log)
749276479Sdim        log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
750276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
751276479Sdim                     static_cast<void*>(target.m_opaque_sp.get()), result);
752254721Semaste
753254721Semaste    return result;
754254721Semaste}
755296417Sdim
756254721SemasteSBTarget
757254721SemasteSBDebugger::GetTargetAtIndex (uint32_t idx)
758254721Semaste{
759254721Semaste    SBTarget sb_target;
760254721Semaste    if (m_opaque_sp)
761254721Semaste    {
762254721Semaste        // No need to lock, the target list is thread safe
763254721Semaste        sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx));
764254721Semaste    }
765254721Semaste    return sb_target;
766254721Semaste}
767254721Semaste
768254721Semasteuint32_t
769254721SemasteSBDebugger::GetIndexOfTarget (lldb::SBTarget target)
770254721Semaste{
771254721Semaste
772254721Semaste    lldb::TargetSP target_sp = target.GetSP();
773254721Semaste    if (!target_sp)
774254721Semaste        return UINT32_MAX;
775254721Semaste
776254721Semaste    if (!m_opaque_sp)
777254721Semaste        return UINT32_MAX;
778254721Semaste
779254721Semaste    return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP());
780254721Semaste}
781254721Semaste
782254721SemasteSBTarget
783258054SemasteSBDebugger::FindTargetWithProcessID (lldb::pid_t pid)
784254721Semaste{
785254721Semaste    SBTarget sb_target;
786254721Semaste    if (m_opaque_sp)
787254721Semaste    {
788254721Semaste        // No need to lock, the target list is thread safe
789254721Semaste        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid));
790254721Semaste    }
791254721Semaste    return sb_target;
792254721Semaste}
793254721Semaste
794254721SemasteSBTarget
795254721SemasteSBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name)
796254721Semaste{
797254721Semaste    SBTarget sb_target;
798254721Semaste    if (m_opaque_sp && filename && filename[0])
799254721Semaste    {
800254721Semaste        // No need to lock, the target list is thread safe
801254721Semaste        ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
802296417Sdim        TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(FileSpec(filename, false), arch_name ? &arch : nullptr));
803254721Semaste        sb_target.SetSP (target_sp);
804254721Semaste    }
805254721Semaste    return sb_target;
806254721Semaste}
807254721Semaste
808254721SemasteSBTarget
809254721SemasteSBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp)
810254721Semaste{
811254721Semaste    SBTarget sb_target;
812254721Semaste    if (m_opaque_sp)
813254721Semaste    {
814254721Semaste        // No need to lock, the target list is thread safe
815254721Semaste        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get()));
816254721Semaste    }
817254721Semaste    return sb_target;
818254721Semaste}
819254721Semaste
820254721Semasteuint32_t
821254721SemasteSBDebugger::GetNumTargets ()
822254721Semaste{
823254721Semaste    if (m_opaque_sp)
824254721Semaste    {
825254721Semaste        // No need to lock, the target list is thread safe
826254721Semaste        return m_opaque_sp->GetTargetList().GetNumTargets ();
827254721Semaste    }
828254721Semaste    return 0;
829254721Semaste}
830254721Semaste
831254721SemasteSBTarget
832254721SemasteSBDebugger::GetSelectedTarget ()
833254721Semaste{
834254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
835254721Semaste
836254721Semaste    SBTarget sb_target;
837254721Semaste    TargetSP target_sp;
838254721Semaste    if (m_opaque_sp)
839254721Semaste    {
840254721Semaste        // No need to lock, the target list is thread safe
841254721Semaste        target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget ();
842254721Semaste        sb_target.SetSP (target_sp);
843254721Semaste    }
844254721Semaste
845254721Semaste    if (log)
846254721Semaste    {
847254721Semaste        SBStream sstr;
848254721Semaste        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
849276479Sdim        log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
850276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
851276479Sdim                     static_cast<void*>(target_sp.get()), sstr.GetData());
852254721Semaste    }
853254721Semaste
854254721Semaste    return sb_target;
855254721Semaste}
856254721Semaste
857254721Semastevoid
858254721SemasteSBDebugger::SetSelectedTarget (SBTarget &sb_target)
859254721Semaste{
860254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
861254721Semaste
862254721Semaste    TargetSP target_sp (sb_target.GetSP());
863254721Semaste    if (m_opaque_sp)
864254721Semaste    {
865254721Semaste        m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
866254721Semaste    }
867254721Semaste    if (log)
868254721Semaste    {
869254721Semaste        SBStream sstr;
870254721Semaste        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
871276479Sdim        log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
872276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
873276479Sdim                     static_cast<void*>(target_sp.get()), sstr.GetData());
874254721Semaste    }
875254721Semaste}
876254721Semaste
877258884SemasteSBPlatform
878258884SemasteSBDebugger::GetSelectedPlatform()
879258884Semaste{
880258884Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
881258884Semaste
882258884Semaste    SBPlatform sb_platform;
883258884Semaste    DebuggerSP debugger_sp(m_opaque_sp);
884258884Semaste    if (debugger_sp)
885258884Semaste    {
886258884Semaste        sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
887258884Semaste    }
888258884Semaste    if (log)
889276479Sdim        log->Printf ("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
890276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
891276479Sdim                     static_cast<void*>(sb_platform.GetSP().get()),
892276479Sdim                     sb_platform.GetName());
893258884Semaste    return sb_platform;
894258884Semaste}
895258884Semaste
896254721Semastevoid
897258884SemasteSBDebugger::SetSelectedPlatform(SBPlatform &sb_platform)
898258884Semaste{
899258884Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
900276479Sdim
901258884Semaste    DebuggerSP debugger_sp(m_opaque_sp);
902258884Semaste    if (debugger_sp)
903258884Semaste    {
904258884Semaste        debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
905258884Semaste    }
906276479Sdim
907258884Semaste    if (log)
908276479Sdim        log->Printf ("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
909276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
910276479Sdim                     static_cast<void*>(sb_platform.GetSP().get()),
911276479Sdim                     sb_platform.GetName());
912258884Semaste}
913258884Semaste
914258884Semastevoid
915254721SemasteSBDebugger::DispatchInput (void* baton, const void *data, size_t data_len)
916254721Semaste{
917254721Semaste    DispatchInput (data,data_len);
918254721Semaste}
919254721Semaste
920254721Semastevoid
921254721SemasteSBDebugger::DispatchInput (const void *data, size_t data_len)
922254721Semaste{
923262528Semaste//    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
924262528Semaste//
925262528Semaste//    if (log)
926262528Semaste//        log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")",
927262528Semaste//                     m_opaque_sp.get(),
928262528Semaste//                     (int) data_len,
929262528Semaste//                     (const char *) data,
930262528Semaste//                     (uint64_t)data_len);
931262528Semaste//
932262528Semaste//    if (m_opaque_sp)
933262528Semaste//        m_opaque_sp->DispatchInput ((const char *) data, data_len);
934254721Semaste}
935254721Semaste
936254721Semastevoid
937254721SemasteSBDebugger::DispatchInputInterrupt ()
938254721Semaste{
939254721Semaste    if (m_opaque_sp)
940254721Semaste        m_opaque_sp->DispatchInputInterrupt ();
941254721Semaste}
942254721Semaste
943254721Semastevoid
944254721SemasteSBDebugger::DispatchInputEndOfFile ()
945254721Semaste{
946254721Semaste    if (m_opaque_sp)
947254721Semaste        m_opaque_sp->DispatchInputEndOfFile ();
948254721Semaste}
949254721Semaste
950254721Semastevoid
951254721SemasteSBDebugger::PushInputReader (SBInputReader &reader)
952254721Semaste{
953254721Semaste}
954254721Semaste
955254721Semastevoid
956262528SemasteSBDebugger::RunCommandInterpreter (bool auto_handle_events,
957262528Semaste                                   bool spawn_thread)
958254721Semaste{
959254721Semaste    if (m_opaque_sp)
960280031Sdim    {
961280031Sdim        CommandInterpreterRunOptions options;
962280031Sdim
963280031Sdim        m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(auto_handle_events,
964280031Sdim                                                                   spawn_thread,
965280031Sdim                                                                   options);
966280031Sdim    }
967254721Semaste}
968254721Semaste
969254721Semastevoid
970280031SdimSBDebugger::RunCommandInterpreter (bool auto_handle_events,
971280031Sdim                                   bool spawn_thread,
972280031Sdim                                   SBCommandInterpreterRunOptions &options,
973280031Sdim                                   int  &num_errors,
974280031Sdim                                   bool &quit_requested,
975280031Sdim                                   bool &stopped_for_crash)
976280031Sdim
977280031Sdim{
978280031Sdim    if (m_opaque_sp)
979280031Sdim    {
980280031Sdim        CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
981280031Sdim        interp.RunCommandInterpreter(auto_handle_events, spawn_thread, options.ref());
982280031Sdim        num_errors = interp.GetNumErrors();
983280031Sdim        quit_requested = interp.GetQuitRequested();
984280031Sdim        stopped_for_crash = interp.GetStoppedForCrash();
985280031Sdim    }
986280031Sdim}
987280031Sdim
988296417SdimSBError
989296417SdimSBDebugger::RunREPL (lldb::LanguageType language, const char *repl_options)
990296417Sdim{
991296417Sdim    SBError error;
992296417Sdim    if (m_opaque_sp)
993296417Sdim        error.ref() = m_opaque_sp->RunREPL(language, repl_options);
994296417Sdim    else
995296417Sdim        error.SetErrorString ("invalid debugger");
996296417Sdim    return error;
997296417Sdim}
998296417Sdim
999280031Sdimvoid
1000254721SemasteSBDebugger::reset (const DebuggerSP &debugger_sp)
1001254721Semaste{
1002254721Semaste    m_opaque_sp = debugger_sp;
1003254721Semaste}
1004254721Semaste
1005254721SemasteDebugger *
1006254721SemasteSBDebugger::get () const
1007254721Semaste{
1008254721Semaste    return m_opaque_sp.get();
1009254721Semaste}
1010254721Semaste
1011254721SemasteDebugger &
1012254721SemasteSBDebugger::ref () const
1013254721Semaste{
1014254721Semaste    assert (m_opaque_sp.get());
1015254721Semaste    return *m_opaque_sp;
1016254721Semaste}
1017254721Semaste
1018254721Semasteconst lldb::DebuggerSP &
1019254721SemasteSBDebugger::get_sp () const
1020254721Semaste{
1021254721Semaste    return m_opaque_sp;
1022254721Semaste}
1023254721Semaste
1024254721SemasteSBDebugger
1025254721SemasteSBDebugger::FindDebuggerWithID (int id)
1026254721Semaste{
1027254721Semaste    // No need to lock, the debugger list is thread safe
1028254721Semaste    SBDebugger sb_debugger;
1029254721Semaste    DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id);
1030254721Semaste    if (debugger_sp)
1031254721Semaste        sb_debugger.reset (debugger_sp);
1032254721Semaste    return sb_debugger;
1033254721Semaste}
1034254721Semaste
1035254721Semasteconst char *
1036254721SemasteSBDebugger::GetInstanceName()
1037254721Semaste{
1038296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
1039254721Semaste}
1040254721Semaste
1041254721SemasteSBError
1042254721SemasteSBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name)
1043254721Semaste{
1044254721Semaste    SBError sb_error;
1045254721Semaste    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
1046254721Semaste    Error error;
1047254721Semaste    if (debugger_sp)
1048254721Semaste    {
1049254721Semaste        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
1050254721Semaste        error = debugger_sp->SetPropertyValue (&exe_ctx,
1051254721Semaste                                               eVarSetOperationAssign,
1052254721Semaste                                               var_name,
1053254721Semaste                                               value);
1054254721Semaste    }
1055254721Semaste    else
1056254721Semaste    {
1057254721Semaste        error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name);
1058254721Semaste    }
1059254721Semaste    if (error.Fail())
1060254721Semaste        sb_error.SetError(error);
1061254721Semaste    return sb_error;
1062254721Semaste}
1063254721Semaste
1064254721SemasteSBStringList
1065254721SemasteSBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name)
1066254721Semaste{
1067254721Semaste    SBStringList ret_value;
1068254721Semaste    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
1069254721Semaste    Error error;
1070254721Semaste    if (debugger_sp)
1071254721Semaste    {
1072254721Semaste        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
1073254721Semaste        lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx,
1074254721Semaste                                                                     var_name,
1075254721Semaste                                                                     false,
1076254721Semaste                                                                     error));
1077254721Semaste        if (value_sp)
1078254721Semaste        {
1079254721Semaste            StreamString value_strm;
1080254721Semaste            value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
1081254721Semaste            const std::string &value_str = value_strm.GetString();
1082254721Semaste            if (!value_str.empty())
1083254721Semaste            {
1084254721Semaste                StringList string_list;
1085262528Semaste                string_list.SplitIntoLines(value_str);
1086254721Semaste                return SBStringList(&string_list);
1087254721Semaste            }
1088254721Semaste        }
1089254721Semaste    }
1090254721Semaste    return SBStringList();
1091254721Semaste}
1092254721Semaste
1093254721Semasteuint32_t
1094296417SdimSBDebugger::GetTerminalWidth() const
1095254721Semaste{
1096296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
1097254721Semaste}
1098254721Semaste
1099254721Semastevoid
1100254721SemasteSBDebugger::SetTerminalWidth (uint32_t term_width)
1101254721Semaste{
1102254721Semaste    if (m_opaque_sp)
1103254721Semaste        m_opaque_sp->SetTerminalWidth (term_width);
1104254721Semaste}
1105254721Semaste
1106254721Semasteconst char *
1107254721SemasteSBDebugger::GetPrompt() const
1108254721Semaste{
1109254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1110276479Sdim
1111254721Semaste    if (log)
1112276479Sdim        log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"",
1113276479Sdim                     static_cast<void*>(m_opaque_sp.get()),
1114254721Semaste                     (m_opaque_sp ? m_opaque_sp->GetPrompt() : ""));
1115254721Semaste
1116296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetPrompt() : nullptr);
1117254721Semaste}
1118254721Semaste
1119254721Semastevoid
1120254721SemasteSBDebugger::SetPrompt (const char *prompt)
1121254721Semaste{
1122254721Semaste    if (m_opaque_sp)
1123254721Semaste        m_opaque_sp->SetPrompt (prompt);
1124254721Semaste}
1125254721Semaste
1126254721SemasteScriptLanguage
1127254721SemasteSBDebugger::GetScriptLanguage() const
1128254721Semaste{
1129296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
1130254721Semaste}
1131254721Semaste
1132254721Semastevoid
1133254721SemasteSBDebugger::SetScriptLanguage (ScriptLanguage script_lang)
1134254721Semaste{
1135254721Semaste    if (m_opaque_sp)
1136254721Semaste    {
1137254721Semaste        m_opaque_sp->SetScriptLanguage (script_lang);
1138254721Semaste    }
1139254721Semaste}
1140254721Semaste
1141254721Semastebool
1142296417SdimSBDebugger::SetUseExternalEditor(bool value)
1143254721Semaste{
1144296417Sdim    return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
1145254721Semaste}
1146254721Semaste
1147254721Semastebool
1148296417SdimSBDebugger::GetUseExternalEditor()
1149254721Semaste{
1150296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
1151254721Semaste}
1152254721Semaste
1153254721Semastebool
1154296417SdimSBDebugger::SetUseColor(bool value)
1155254721Semaste{
1156296417Sdim    return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
1157254721Semaste}
1158254721Semaste
1159254721Semastebool
1160296417SdimSBDebugger::GetUseColor() const
1161254721Semaste{
1162296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
1163254721Semaste}
1164254721Semaste
1165254721Semastebool
1166254721SemasteSBDebugger::GetDescription (SBStream &description)
1167254721Semaste{
1168254721Semaste    Stream &strm = description.ref();
1169254721Semaste
1170254721Semaste    if (m_opaque_sp)
1171254721Semaste    {
1172254721Semaste        const char *name = m_opaque_sp->GetInstanceName().AsCString();
1173254721Semaste        user_id_t id = m_opaque_sp->GetID();
1174254721Semaste        strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1175254721Semaste    }
1176254721Semaste    else
1177254721Semaste        strm.PutCString ("No value");
1178254721Semaste
1179254721Semaste    return true;
1180254721Semaste}
1181254721Semaste
1182254721Semasteuser_id_t
1183254721SemasteSBDebugger::GetID()
1184254721Semaste{
1185296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
1186254721Semaste}
1187254721Semaste
1188254721SemasteSBError
1189280031SdimSBDebugger::SetCurrentPlatform (const char *platform_name_cstr)
1190254721Semaste{
1191254721Semaste    SBError sb_error;
1192254721Semaste    if (m_opaque_sp)
1193254721Semaste    {
1194280031Sdim        if (platform_name_cstr && platform_name_cstr[0])
1195254721Semaste        {
1196280031Sdim            ConstString platform_name (platform_name_cstr);
1197280031Sdim            PlatformSP platform_sp (Platform::Find (platform_name));
1198280031Sdim
1199280031Sdim            if (platform_sp)
1200280031Sdim            {
1201280031Sdim                // Already have a platform with this name, just select it
1202280031Sdim                m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
1203280031Sdim            }
1204280031Sdim            else
1205280031Sdim            {
1206280031Sdim                // We don't have a platform by this name yet, create one
1207280031Sdim                platform_sp = Platform::Create (platform_name, sb_error.ref());
1208280031Sdim                if (platform_sp)
1209280031Sdim                {
1210280031Sdim                    // We created the platform, now append and select it
1211280031Sdim                    bool make_selected = true;
1212280031Sdim                    m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected);
1213280031Sdim                }
1214280031Sdim            }
1215254721Semaste        }
1216280031Sdim        else
1217280031Sdim        {
1218280031Sdim            sb_error.ref().SetErrorString("invalid platform name");
1219280031Sdim        }
1220254721Semaste    }
1221280031Sdim    else
1222280031Sdim    {
1223280031Sdim        sb_error.ref().SetErrorString("invalid debugger");
1224280031Sdim    }
1225254721Semaste    return sb_error;
1226254721Semaste}
1227254721Semaste
1228254721Semastebool
1229254721SemasteSBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot)
1230254721Semaste{
1231254721Semaste    if (m_opaque_sp)
1232254721Semaste    {
1233254721Semaste        PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1234254721Semaste
1235254721Semaste        if (platform_sp)
1236254721Semaste        {
1237254721Semaste            platform_sp->SetSDKRootDirectory (ConstString (sysroot));
1238254721Semaste            return true;
1239254721Semaste        }
1240254721Semaste    }
1241254721Semaste    return false;
1242254721Semaste}
1243254721Semaste
1244254721Semastebool
1245296417SdimSBDebugger::GetCloseInputOnEOF() const
1246254721Semaste{
1247296417Sdim    return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
1248254721Semaste}
1249254721Semaste
1250254721Semastevoid
1251254721SemasteSBDebugger::SetCloseInputOnEOF (bool b)
1252254721Semaste{
1253254721Semaste    if (m_opaque_sp)
1254254721Semaste        m_opaque_sp->SetCloseInputOnEOF (b);
1255254721Semaste}
1256254721Semaste
1257254721SemasteSBTypeCategory
1258254721SemasteSBDebugger::GetCategory (const char* category_name)
1259254721Semaste{
1260254721Semaste    if (!category_name || *category_name == 0)
1261254721Semaste        return SBTypeCategory();
1262254721Semaste
1263254721Semaste    TypeCategoryImplSP category_sp;
1264254721Semaste
1265254721Semaste    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false))
1266254721Semaste        return SBTypeCategory(category_sp);
1267254721Semaste    else
1268254721Semaste        return SBTypeCategory();
1269254721Semaste}
1270254721Semaste
1271254721SemasteSBTypeCategory
1272296417SdimSBDebugger::GetCategory (lldb::LanguageType lang_type)
1273296417Sdim{
1274296417Sdim    TypeCategoryImplSP category_sp;
1275296417Sdim    if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
1276296417Sdim        return SBTypeCategory(category_sp);
1277296417Sdim    else
1278296417Sdim        return SBTypeCategory();
1279296417Sdim}
1280296417Sdim
1281296417SdimSBTypeCategory
1282254721SemasteSBDebugger::CreateCategory (const char* category_name)
1283254721Semaste{
1284254721Semaste    if (!category_name || *category_name == 0)
1285254721Semaste        return SBTypeCategory();
1286254721Semaste
1287254721Semaste    TypeCategoryImplSP category_sp;
1288254721Semaste
1289254721Semaste    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true))
1290254721Semaste        return SBTypeCategory(category_sp);
1291254721Semaste    else
1292254721Semaste        return SBTypeCategory();
1293254721Semaste}
1294254721Semaste
1295254721Semastebool
1296254721SemasteSBDebugger::DeleteCategory (const char* category_name)
1297254721Semaste{
1298254721Semaste    if (!category_name || *category_name == 0)
1299254721Semaste        return false;
1300254721Semaste
1301254721Semaste    return DataVisualization::Categories::Delete(ConstString(category_name));
1302254721Semaste}
1303254721Semaste
1304254721Semasteuint32_t
1305254721SemasteSBDebugger::GetNumCategories()
1306254721Semaste{
1307254721Semaste    return DataVisualization::Categories::GetCount();
1308254721Semaste}
1309254721Semaste
1310254721SemasteSBTypeCategory
1311254721SemasteSBDebugger::GetCategoryAtIndex (uint32_t index)
1312254721Semaste{
1313254721Semaste    return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index));
1314254721Semaste}
1315254721Semaste
1316254721SemasteSBTypeCategory
1317254721SemasteSBDebugger::GetDefaultCategory()
1318254721Semaste{
1319254721Semaste    return GetCategory("default");
1320254721Semaste}
1321254721Semaste
1322254721SemasteSBTypeFormat
1323254721SemasteSBDebugger::GetFormatForType (SBTypeNameSpecifier type_name)
1324254721Semaste{
1325254721Semaste    SBTypeCategory default_category_sb = GetDefaultCategory();
1326254721Semaste    if (default_category_sb.GetEnabled())
1327254721Semaste        return default_category_sb.GetFormatForType(type_name);
1328254721Semaste    return SBTypeFormat();
1329254721Semaste}
1330254721Semaste
1331254721Semaste#ifndef LLDB_DISABLE_PYTHON
1332254721SemasteSBTypeSummary
1333254721SemasteSBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name)
1334254721Semaste{
1335296417Sdim    if (!type_name.IsValid())
1336254721Semaste        return SBTypeSummary();
1337254721Semaste    return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
1338254721Semaste}
1339254721Semaste#endif // LLDB_DISABLE_PYTHON
1340254721Semaste
1341254721SemasteSBTypeFilter
1342254721SemasteSBDebugger::GetFilterForType (SBTypeNameSpecifier type_name)
1343254721Semaste{
1344296417Sdim    if (!type_name.IsValid())
1345254721Semaste        return SBTypeFilter();
1346254721Semaste    return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
1347254721Semaste}
1348254721Semaste
1349254721Semaste#ifndef LLDB_DISABLE_PYTHON
1350254721SemasteSBTypeSynthetic
1351254721SemasteSBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name)
1352254721Semaste{
1353296417Sdim    if (!type_name.IsValid())
1354254721Semaste        return SBTypeSynthetic();
1355254721Semaste    return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP()));
1356254721Semaste}
1357254721Semaste#endif // LLDB_DISABLE_PYTHON
1358254721Semaste
1359254721Semastebool
1360254721SemasteSBDebugger::EnableLog (const char *channel, const char **categories)
1361254721Semaste{
1362254721Semaste    if (m_opaque_sp)
1363254721Semaste    {
1364254721Semaste        uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1365254721Semaste        StreamString errors;
1366296417Sdim        return m_opaque_sp->EnableLog(channel, categories, nullptr, log_options, errors);
1367254721Semaste    }
1368254721Semaste    else
1369254721Semaste        return false;
1370254721Semaste}
1371254721Semaste
1372254721Semastevoid
1373254721SemasteSBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
1374254721Semaste{
1375254721Semaste    if (m_opaque_sp)
1376254721Semaste    {
1377254721Semaste        return m_opaque_sp->SetLoggingCallback (log_callback, baton);
1378254721Semaste    }
1379254721Semaste}
1380