contrib/llvm/tools/lldb/source/API/SBDebugger.cpp

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