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