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