1254721Semaste//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste#include "lldb/lldb-python.h" 11254721Semaste 12254721Semaste#include "lldb/API/SBDebugger.h" 13254721Semaste 14254721Semaste#include "lldb/lldb-private.h" 15254721Semaste 16254721Semaste#include "lldb/API/SBListener.h" 17254721Semaste#include "lldb/API/SBBroadcaster.h" 18254721Semaste#include "lldb/API/SBCommandInterpreter.h" 19254721Semaste#include "lldb/API/SBCommandReturnObject.h" 20254721Semaste#include "lldb/API/SBError.h" 21254721Semaste#include "lldb/API/SBEvent.h" 22254721Semaste#include "lldb/API/SBFrame.h" 23254721Semaste#include "lldb/API/SBProcess.h" 24254721Semaste#include "lldb/API/SBSourceManager.h" 25254721Semaste#include "lldb/API/SBStream.h" 26254721Semaste#include "lldb/API/SBStringList.h" 27254721Semaste#include "lldb/API/SBTarget.h" 28254721Semaste#include "lldb/API/SBThread.h" 29254721Semaste#include "lldb/API/SBTypeCategory.h" 30254721Semaste#include "lldb/API/SBTypeFormat.h" 31254721Semaste#include "lldb/API/SBTypeFilter.h" 32254721Semaste#include "lldb/API/SBTypeNameSpecifier.h" 33254721Semaste#include "lldb/API/SBTypeSummary.h" 34254721Semaste#include "lldb/API/SBTypeSynthetic.h" 35254721Semaste 36254721Semaste 37254721Semaste#include "lldb/Core/Debugger.h" 38254721Semaste#include "lldb/Core/State.h" 39269024Semaste#include "lldb/Core/StreamFile.h" 40254721Semaste#include "lldb/DataFormatters/DataVisualization.h" 41263367Semaste#include "lldb/Host/DynamicLibrary.h" 42254721Semaste#include "lldb/Interpreter/Args.h" 43254721Semaste#include "lldb/Interpreter/CommandInterpreter.h" 44254721Semaste#include "lldb/Interpreter/OptionGroupPlatform.h" 45254721Semaste#include "lldb/Target/Process.h" 46254721Semaste#include "lldb/Target/TargetList.h" 47254721Semaste 48254721Semasteusing namespace lldb; 49254721Semasteusing namespace lldb_private; 50254721Semaste 51263367Semaste 52269024SemasteSBInputReader::SBInputReader() 53269024Semaste{ 54269024Semaste} 55269024SemasteSBInputReader::~SBInputReader() 56269024Semaste{ 57269024Semaste} 58269024Semaste 59269024SemasteSBError 60269024SemasteSBInputReader::Initialize(lldb::SBDebugger& sb_debugger, unsigned long (*)(void*, lldb::SBInputReader*, lldb::InputReaderAction, char const*, unsigned long), void*, lldb::InputReaderGranularity, char const*, char const*, bool) 61269024Semaste{ 62269024Semaste return SBError(); 63269024Semaste} 64269024Semaste 65269024Semastevoid 66269024SemasteSBInputReader::SetIsDone(bool) 67269024Semaste{ 68269024Semaste} 69269024Semastebool 70269024SemasteSBInputReader::IsActive() const 71269024Semaste{ 72269024Semaste return false; 73269024Semaste} 74269024Semaste 75263367Semastestatic lldb::DynamicLibrarySP 76263367SemasteLoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error) 77263367Semaste{ 78263367Semaste lldb::DynamicLibrarySP dynlib_sp(new lldb_private::DynamicLibrary(spec)); 79263367Semaste if (dynlib_sp && dynlib_sp->IsValid()) 80263367Semaste { 81263367Semaste typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger); 82263367Semaste 83263367Semaste lldb::SBDebugger debugger_sb(debugger_sp); 84263367Semaste // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function. 85263367Semaste // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays 86263367Semaste LLDBCommandPluginInit init_func = dynlib_sp->GetSymbol<LLDBCommandPluginInit>("_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); 87263367Semaste if (init_func) 88263367Semaste { 89263367Semaste if (init_func(debugger_sb)) 90263367Semaste return dynlib_sp; 91263367Semaste else 92263367Semaste error.SetErrorString("plug-in refused to load (lldb::PluginInitialize(lldb::SBDebugger) returned false)"); 93263367Semaste } 94263367Semaste else 95263367Semaste { 96263367Semaste error.SetErrorString("plug-in is missing the required initialization: lldb::PluginInitialize(lldb::SBDebugger)"); 97263367Semaste } 98263367Semaste } 99263367Semaste else 100263367Semaste { 101263367Semaste if (spec.Exists()) 102263367Semaste error.SetErrorString("this file does not represent a loadable dylib"); 103263367Semaste else 104263367Semaste error.SetErrorString("no such file"); 105263367Semaste } 106263367Semaste return lldb::DynamicLibrarySP(); 107263367Semaste} 108263367Semaste 109254721Semastevoid 110254721SemasteSBDebugger::Initialize () 111254721Semaste{ 112254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 113254721Semaste 114254721Semaste if (log) 115254721Semaste log->Printf ("SBDebugger::Initialize ()"); 116254721Semaste 117254721Semaste SBCommandInterpreter::InitializeSWIG (); 118254721Semaste 119263367Semaste Debugger::Initialize(LoadPlugin); 120254721Semaste} 121254721Semaste 122254721Semastevoid 123254721SemasteSBDebugger::Terminate () 124254721Semaste{ 125254721Semaste Debugger::Terminate(); 126254721Semaste} 127254721Semaste 128254721Semastevoid 129254721SemasteSBDebugger::Clear () 130254721Semaste{ 131254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 132254721Semaste 133254721Semaste if (log) 134254721Semaste log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get()); 135254721Semaste 136254721Semaste if (m_opaque_sp) 137269024Semaste m_opaque_sp->ClearIOHandlers (); 138254721Semaste 139254721Semaste m_opaque_sp.reset(); 140254721Semaste} 141254721Semaste 142254721SemasteSBDebugger 143254721SemasteSBDebugger::Create() 144254721Semaste{ 145254721Semaste return SBDebugger::Create(false, NULL, NULL); 146254721Semaste} 147254721Semaste 148254721SemasteSBDebugger 149254721SemasteSBDebugger::Create(bool source_init_files) 150254721Semaste{ 151254721Semaste return SBDebugger::Create (source_init_files, NULL, NULL); 152254721Semaste} 153254721Semaste 154254721SemasteSBDebugger 155254721SemasteSBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton) 156254721Semaste 157254721Semaste{ 158254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 159254721Semaste 160254721Semaste SBDebugger debugger; 161254721Semaste debugger.reset(Debugger::CreateInstance(callback, baton)); 162254721Semaste 163254721Semaste if (log) 164254721Semaste { 165254721Semaste SBStream sstr; 166254721Semaste debugger.GetDescription (sstr); 167254721Semaste log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 168254721Semaste } 169254721Semaste 170254721Semaste SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 171254721Semaste if (source_init_files) 172254721Semaste { 173254721Semaste interp.get()->SkipLLDBInitFiles(false); 174254721Semaste interp.get()->SkipAppInitFiles (false); 175254721Semaste SBCommandReturnObject result; 176254721Semaste interp.SourceInitFileInHomeDirectory(result); 177254721Semaste } 178254721Semaste else 179254721Semaste { 180254721Semaste interp.get()->SkipLLDBInitFiles(true); 181254721Semaste interp.get()->SkipAppInitFiles (true); 182254721Semaste } 183254721Semaste return debugger; 184254721Semaste} 185254721Semaste 186254721Semastevoid 187254721SemasteSBDebugger::Destroy (SBDebugger &debugger) 188254721Semaste{ 189254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 190254721Semaste 191254721Semaste if (log) 192254721Semaste { 193254721Semaste SBStream sstr; 194254721Semaste debugger.GetDescription (sstr); 195254721Semaste log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 196254721Semaste } 197254721Semaste 198254721Semaste Debugger::Destroy (debugger.m_opaque_sp); 199254721Semaste 200254721Semaste if (debugger.m_opaque_sp.get() != NULL) 201254721Semaste debugger.m_opaque_sp.reset(); 202254721Semaste} 203254721Semaste 204254721Semastevoid 205254721SemasteSBDebugger::MemoryPressureDetected () 206254721Semaste{ 207254721Semaste // Since this function can be call asynchronously, we allow it to be 208254721Semaste // non-mandatory. We have seen deadlocks with this function when called 209254721Semaste // so we need to safeguard against this until we can determine what is 210254721Semaste // causing the deadlocks. 211254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 212254721Semaste 213254721Semaste const bool mandatory = false; 214254721Semaste if (log) 215254721Semaste { 216254721Semaste log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory); 217254721Semaste } 218254721Semaste 219254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 220254721Semaste} 221254721Semaste 222254721SemasteSBDebugger::SBDebugger () : 223254721Semaste m_opaque_sp () 224254721Semaste{ 225254721Semaste} 226254721Semaste 227254721SemasteSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : 228254721Semaste m_opaque_sp(debugger_sp) 229254721Semaste{ 230254721Semaste} 231254721Semaste 232254721SemasteSBDebugger::SBDebugger(const SBDebugger &rhs) : 233254721Semaste m_opaque_sp (rhs.m_opaque_sp) 234254721Semaste{ 235254721Semaste} 236254721Semaste 237254721SemasteSBDebugger & 238254721SemasteSBDebugger::operator = (const SBDebugger &rhs) 239254721Semaste{ 240254721Semaste if (this != &rhs) 241254721Semaste { 242254721Semaste m_opaque_sp = rhs.m_opaque_sp; 243254721Semaste } 244254721Semaste return *this; 245254721Semaste} 246254721Semaste 247254721SemasteSBDebugger::~SBDebugger () 248254721Semaste{ 249254721Semaste} 250254721Semaste 251254721Semastebool 252254721SemasteSBDebugger::IsValid() const 253254721Semaste{ 254254721Semaste return m_opaque_sp.get() != NULL; 255254721Semaste} 256254721Semaste 257254721Semaste 258254721Semastevoid 259254721SemasteSBDebugger::SetAsync (bool b) 260254721Semaste{ 261254721Semaste if (m_opaque_sp) 262254721Semaste m_opaque_sp->SetAsyncExecution(b); 263254721Semaste} 264254721Semaste 265254721Semastebool 266254721SemasteSBDebugger::GetAsync () 267254721Semaste{ 268254721Semaste if (m_opaque_sp) 269254721Semaste return m_opaque_sp->GetAsyncExecution(); 270254721Semaste else 271254721Semaste return false; 272254721Semaste} 273254721Semaste 274254721Semastevoid 275254721SemasteSBDebugger::SkipLLDBInitFiles (bool b) 276254721Semaste{ 277254721Semaste if (m_opaque_sp) 278254721Semaste m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b); 279254721Semaste} 280254721Semaste 281254721Semastevoid 282254721SemasteSBDebugger::SkipAppInitFiles (bool b) 283254721Semaste{ 284254721Semaste if (m_opaque_sp) 285254721Semaste m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b); 286254721Semaste} 287254721Semaste 288254721Semaste// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users 289254721Semaste// trying to switch modes in the middle of a debugging session. 290254721Semastevoid 291254721SemasteSBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership) 292254721Semaste{ 293254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 294254721Semaste 295254721Semaste if (log) 296254721Semaste log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 297254721Semaste fh, transfer_ownership); 298254721Semaste 299254721Semaste if (m_opaque_sp) 300254721Semaste m_opaque_sp->SetInputFileHandle (fh, transfer_ownership); 301254721Semaste} 302254721Semaste 303254721Semastevoid 304254721SemasteSBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership) 305254721Semaste{ 306254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 307254721Semaste 308254721Semaste 309254721Semaste if (log) 310254721Semaste log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 311254721Semaste fh, transfer_ownership); 312254721Semaste 313254721Semaste if (m_opaque_sp) 314254721Semaste m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership); 315254721Semaste} 316254721Semaste 317254721Semastevoid 318254721SemasteSBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership) 319254721Semaste{ 320254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 321254721Semaste 322254721Semaste 323254721Semaste if (log) 324254721Semaste log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 325254721Semaste fh, transfer_ownership); 326254721Semaste 327254721Semaste if (m_opaque_sp) 328254721Semaste m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership); 329254721Semaste} 330254721Semaste 331254721SemasteFILE * 332254721SemasteSBDebugger::GetInputFileHandle () 333254721Semaste{ 334254721Semaste if (m_opaque_sp) 335269024Semaste { 336269024Semaste StreamFileSP stream_file_sp (m_opaque_sp->GetInputFile()); 337269024Semaste if (stream_file_sp) 338269024Semaste return stream_file_sp->GetFile().GetStream(); 339269024Semaste } 340254721Semaste return NULL; 341254721Semaste} 342254721Semaste 343254721SemasteFILE * 344254721SemasteSBDebugger::GetOutputFileHandle () 345254721Semaste{ 346254721Semaste if (m_opaque_sp) 347269024Semaste { 348269024Semaste StreamFileSP stream_file_sp (m_opaque_sp->GetOutputFile()); 349269024Semaste if (stream_file_sp) 350269024Semaste return stream_file_sp->GetFile().GetStream(); 351269024Semaste } 352254721Semaste return NULL; 353254721Semaste} 354254721Semaste 355254721SemasteFILE * 356254721SemasteSBDebugger::GetErrorFileHandle () 357254721Semaste{ 358254721Semaste if (m_opaque_sp) 359269024Semaste if (m_opaque_sp) 360269024Semaste { 361269024Semaste StreamFileSP stream_file_sp (m_opaque_sp->GetErrorFile()); 362269024Semaste if (stream_file_sp) 363269024Semaste return stream_file_sp->GetFile().GetStream(); 364269024Semaste } 365254721Semaste return NULL; 366254721Semaste} 367254721Semaste 368254721Semastevoid 369254721SemasteSBDebugger::SaveInputTerminalState() 370254721Semaste{ 371254721Semaste if (m_opaque_sp) 372254721Semaste m_opaque_sp->SaveInputTerminalState(); 373254721Semaste} 374254721Semaste 375254721Semastevoid 376254721SemasteSBDebugger::RestoreInputTerminalState() 377254721Semaste{ 378254721Semaste if (m_opaque_sp) 379254721Semaste m_opaque_sp->RestoreInputTerminalState(); 380254721Semaste 381254721Semaste} 382254721SemasteSBCommandInterpreter 383254721SemasteSBDebugger::GetCommandInterpreter () 384254721Semaste{ 385254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 386254721Semaste 387254721Semaste SBCommandInterpreter sb_interpreter; 388254721Semaste if (m_opaque_sp) 389254721Semaste sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter()); 390254721Semaste 391254721Semaste if (log) 392254721Semaste log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)", 393254721Semaste m_opaque_sp.get(), sb_interpreter.get()); 394254721Semaste 395254721Semaste return sb_interpreter; 396254721Semaste} 397254721Semaste 398254721Semastevoid 399254721SemasteSBDebugger::HandleCommand (const char *command) 400254721Semaste{ 401254721Semaste if (m_opaque_sp) 402254721Semaste { 403254721Semaste TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 404254721Semaste Mutex::Locker api_locker; 405254721Semaste if (target_sp) 406254721Semaste api_locker.Lock(target_sp->GetAPIMutex()); 407254721Semaste 408254721Semaste SBCommandInterpreter sb_interpreter(GetCommandInterpreter ()); 409254721Semaste SBCommandReturnObject result; 410254721Semaste 411254721Semaste sb_interpreter.HandleCommand (command, result, false); 412254721Semaste 413254721Semaste if (GetErrorFileHandle() != NULL) 414254721Semaste result.PutError (GetErrorFileHandle()); 415254721Semaste if (GetOutputFileHandle() != NULL) 416254721Semaste result.PutOutput (GetOutputFileHandle()); 417254721Semaste 418254721Semaste if (m_opaque_sp->GetAsyncExecution() == false) 419254721Semaste { 420254721Semaste SBProcess process(GetCommandInterpreter().GetProcess ()); 421254721Semaste ProcessSP process_sp (process.GetSP()); 422254721Semaste if (process_sp) 423254721Semaste { 424254721Semaste EventSP event_sp; 425254721Semaste Listener &lldb_listener = m_opaque_sp->GetListener(); 426254721Semaste while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp)) 427254721Semaste { 428254721Semaste SBEvent event(event_sp); 429254721Semaste HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); 430254721Semaste } 431254721Semaste } 432254721Semaste } 433254721Semaste } 434254721Semaste} 435254721Semaste 436254721SemasteSBListener 437254721SemasteSBDebugger::GetListener () 438254721Semaste{ 439254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 440254721Semaste 441254721Semaste SBListener sb_listener; 442254721Semaste if (m_opaque_sp) 443254721Semaste sb_listener.reset(&m_opaque_sp->GetListener(), false); 444254721Semaste 445254721Semaste if (log) 446254721Semaste log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(), 447254721Semaste sb_listener.get()); 448254721Semaste 449254721Semaste return sb_listener; 450254721Semaste} 451254721Semaste 452254721Semastevoid 453254721SemasteSBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) 454254721Semaste{ 455254721Semaste if (!process.IsValid()) 456254721Semaste return; 457254721Semaste 458254721Semaste TargetSP target_sp (process.GetTarget().GetSP()); 459254721Semaste if (!target_sp) 460254721Semaste return; 461254721Semaste 462254721Semaste const uint32_t event_type = event.GetType(); 463254721Semaste char stdio_buffer[1024]; 464254721Semaste size_t len; 465254721Semaste 466254721Semaste Mutex::Locker api_locker (target_sp->GetAPIMutex()); 467254721Semaste 468254721Semaste if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) 469254721Semaste { 470254721Semaste // Drain stdout when we stop just in case we have any bytes 471254721Semaste while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) 472254721Semaste if (out != NULL) 473254721Semaste ::fwrite (stdio_buffer, 1, len, out); 474254721Semaste } 475254721Semaste 476254721Semaste if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) 477254721Semaste { 478254721Semaste // Drain stderr when we stop just in case we have any bytes 479254721Semaste while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) 480254721Semaste if (err != NULL) 481254721Semaste ::fwrite (stdio_buffer, 1, len, err); 482254721Semaste } 483254721Semaste 484254721Semaste if (event_type & Process::eBroadcastBitStateChanged) 485254721Semaste { 486254721Semaste StateType event_state = SBProcess::GetStateFromEvent (event); 487254721Semaste 488254721Semaste if (event_state == eStateInvalid) 489254721Semaste return; 490254721Semaste 491254721Semaste bool is_stopped = StateIsStoppedState (event_state); 492254721Semaste if (!is_stopped) 493254721Semaste process.ReportEventState (event, out); 494254721Semaste } 495254721Semaste} 496254721Semaste 497254721SemasteSBSourceManager 498254721SemasteSBDebugger::GetSourceManager () 499254721Semaste{ 500254721Semaste SBSourceManager sb_source_manager (*this); 501254721Semaste return sb_source_manager; 502254721Semaste} 503254721Semaste 504254721Semaste 505254721Semastebool 506254721SemasteSBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len) 507254721Semaste{ 508254721Semaste if (arch_name && arch_name_len) 509254721Semaste { 510254721Semaste ArchSpec default_arch = Target::GetDefaultArchitecture (); 511254721Semaste 512254721Semaste if (default_arch.IsValid()) 513254721Semaste { 514254721Semaste const std::string &triple_str = default_arch.GetTriple().str(); 515254721Semaste if (!triple_str.empty()) 516254721Semaste ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str()); 517254721Semaste else 518254721Semaste ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName()); 519254721Semaste return true; 520254721Semaste } 521254721Semaste } 522254721Semaste if (arch_name && arch_name_len) 523254721Semaste arch_name[0] = '\0'; 524254721Semaste return false; 525254721Semaste} 526254721Semaste 527254721Semaste 528254721Semastebool 529254721SemasteSBDebugger::SetDefaultArchitecture (const char *arch_name) 530254721Semaste{ 531254721Semaste if (arch_name) 532254721Semaste { 533254721Semaste ArchSpec arch (arch_name); 534254721Semaste if (arch.IsValid()) 535254721Semaste { 536254721Semaste Target::SetDefaultArchitecture (arch); 537254721Semaste return true; 538254721Semaste } 539254721Semaste } 540254721Semaste return false; 541254721Semaste} 542254721Semaste 543254721SemasteScriptLanguage 544254721SemasteSBDebugger::GetScriptingLanguage (const char *script_language_name) 545254721Semaste{ 546254721Semaste 547254721Semaste return Args::StringToScriptLanguage (script_language_name, 548254721Semaste eScriptLanguageDefault, 549254721Semaste NULL); 550254721Semaste} 551254721Semaste 552254721Semasteconst char * 553254721SemasteSBDebugger::GetVersionString () 554254721Semaste{ 555263363Semaste return lldb_private::GetVersion(); 556254721Semaste} 557254721Semaste 558254721Semasteconst char * 559254721SemasteSBDebugger::StateAsCString (StateType state) 560254721Semaste{ 561254721Semaste return lldb_private::StateAsCString (state); 562254721Semaste} 563254721Semaste 564254721Semastebool 565254721SemasteSBDebugger::StateIsRunningState (StateType state) 566254721Semaste{ 567254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 568254721Semaste 569254721Semaste const bool result = lldb_private::StateIsRunningState (state); 570254721Semaste if (log) 571254721Semaste log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", 572254721Semaste StateAsCString (state), result); 573254721Semaste 574254721Semaste return result; 575254721Semaste} 576254721Semaste 577254721Semastebool 578254721SemasteSBDebugger::StateIsStoppedState (StateType state) 579254721Semaste{ 580254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 581254721Semaste 582254721Semaste const bool result = lldb_private::StateIsStoppedState (state, false); 583254721Semaste if (log) 584254721Semaste log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", 585254721Semaste StateAsCString (state), result); 586254721Semaste 587254721Semaste return result; 588254721Semaste} 589254721Semaste 590254721Semastelldb::SBTarget 591254721SemasteSBDebugger::CreateTarget (const char *filename, 592254721Semaste const char *target_triple, 593254721Semaste const char *platform_name, 594254721Semaste bool add_dependent_modules, 595254721Semaste lldb::SBError& sb_error) 596254721Semaste{ 597254721Semaste SBTarget sb_target; 598254721Semaste TargetSP target_sp; 599254721Semaste if (m_opaque_sp) 600254721Semaste { 601254721Semaste sb_error.Clear(); 602254721Semaste OptionGroupPlatform platform_options (false); 603254721Semaste platform_options.SetPlatformName (platform_name); 604254721Semaste 605254721Semaste sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 606254721Semaste filename, 607254721Semaste target_triple, 608254721Semaste add_dependent_modules, 609254721Semaste &platform_options, 610254721Semaste target_sp); 611254721Semaste 612254721Semaste if (sb_error.Success()) 613254721Semaste sb_target.SetSP (target_sp); 614254721Semaste } 615254721Semaste else 616254721Semaste { 617254721Semaste sb_error.SetErrorString("invalid target"); 618254721Semaste } 619254721Semaste 620254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 621254721Semaste if (log) 622254721Semaste { 623254721Semaste log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)", 624254721Semaste m_opaque_sp.get(), 625254721Semaste filename, 626254721Semaste target_triple, 627254721Semaste platform_name, 628254721Semaste add_dependent_modules, 629254721Semaste sb_error.GetCString(), 630254721Semaste target_sp.get()); 631254721Semaste } 632254721Semaste 633254721Semaste return sb_target; 634254721Semaste} 635254721Semaste 636254721SemasteSBTarget 637254721SemasteSBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename, 638254721Semaste const char *target_triple) 639254721Semaste{ 640254721Semaste SBTarget sb_target; 641254721Semaste TargetSP target_sp; 642254721Semaste if (m_opaque_sp) 643254721Semaste { 644254721Semaste const bool add_dependent_modules = true; 645254721Semaste Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 646254721Semaste filename, 647254721Semaste target_triple, 648254721Semaste add_dependent_modules, 649254721Semaste NULL, 650254721Semaste target_sp)); 651254721Semaste sb_target.SetSP (target_sp); 652254721Semaste } 653254721Semaste 654254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 655254721Semaste if (log) 656254721Semaste { 657254721Semaste log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)", 658254721Semaste m_opaque_sp.get(), filename, target_triple, target_sp.get()); 659254721Semaste } 660254721Semaste 661254721Semaste return sb_target; 662254721Semaste} 663254721Semaste 664254721SemasteSBTarget 665254721SemasteSBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr) 666254721Semaste{ 667254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 668254721Semaste 669254721Semaste SBTarget sb_target; 670254721Semaste TargetSP target_sp; 671254721Semaste if (m_opaque_sp) 672254721Semaste { 673254721Semaste Error error; 674254721Semaste const bool add_dependent_modules = true; 675254721Semaste 676254721Semaste error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 677254721Semaste filename, 678254721Semaste arch_cstr, 679254721Semaste add_dependent_modules, 680254721Semaste NULL, 681254721Semaste target_sp); 682254721Semaste 683254721Semaste if (error.Success()) 684254721Semaste { 685254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 686254721Semaste sb_target.SetSP (target_sp); 687254721Semaste } 688254721Semaste } 689254721Semaste 690254721Semaste if (log) 691254721Semaste { 692254721Semaste log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)", 693254721Semaste m_opaque_sp.get(), filename, arch_cstr, target_sp.get()); 694254721Semaste } 695254721Semaste 696254721Semaste return sb_target; 697254721Semaste} 698254721Semaste 699254721SemasteSBTarget 700254721SemasteSBDebugger::CreateTarget (const char *filename) 701254721Semaste{ 702254721Semaste SBTarget sb_target; 703254721Semaste TargetSP target_sp; 704254721Semaste if (m_opaque_sp) 705254721Semaste { 706254721Semaste ArchSpec arch = Target::GetDefaultArchitecture (); 707254721Semaste Error error; 708254721Semaste const bool add_dependent_modules = true; 709254721Semaste 710254721Semaste PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 711254721Semaste error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 712254721Semaste filename, 713254721Semaste arch, 714254721Semaste add_dependent_modules, 715254721Semaste platform_sp, 716254721Semaste target_sp); 717254721Semaste 718254721Semaste if (error.Success()) 719254721Semaste { 720254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 721254721Semaste sb_target.SetSP (target_sp); 722254721Semaste } 723254721Semaste } 724254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 725254721Semaste if (log) 726254721Semaste { 727254721Semaste log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 728254721Semaste m_opaque_sp.get(), filename, target_sp.get()); 729254721Semaste } 730254721Semaste return sb_target; 731254721Semaste} 732254721Semaste 733254721Semastebool 734254721SemasteSBDebugger::DeleteTarget (lldb::SBTarget &target) 735254721Semaste{ 736254721Semaste bool result = false; 737254721Semaste if (m_opaque_sp) 738254721Semaste { 739254721Semaste TargetSP target_sp(target.GetSP()); 740254721Semaste if (target_sp) 741254721Semaste { 742254721Semaste // No need to lock, the target list is thread safe 743254721Semaste result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp); 744254721Semaste target_sp->Destroy(); 745254721Semaste target.Clear(); 746254721Semaste const bool mandatory = true; 747254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 748254721Semaste } 749254721Semaste } 750254721Semaste 751254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 752254721Semaste if (log) 753254721Semaste { 754254721Semaste log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result); 755254721Semaste } 756254721Semaste 757254721Semaste return result; 758254721Semaste} 759254721SemasteSBTarget 760254721SemasteSBDebugger::GetTargetAtIndex (uint32_t idx) 761254721Semaste{ 762254721Semaste SBTarget sb_target; 763254721Semaste if (m_opaque_sp) 764254721Semaste { 765254721Semaste // No need to lock, the target list is thread safe 766254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx)); 767254721Semaste } 768254721Semaste return sb_target; 769254721Semaste} 770254721Semaste 771254721Semasteuint32_t 772254721SemasteSBDebugger::GetIndexOfTarget (lldb::SBTarget target) 773254721Semaste{ 774254721Semaste 775254721Semaste lldb::TargetSP target_sp = target.GetSP(); 776254721Semaste if (!target_sp) 777254721Semaste return UINT32_MAX; 778254721Semaste 779254721Semaste if (!m_opaque_sp) 780254721Semaste return UINT32_MAX; 781254721Semaste 782254721Semaste return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP()); 783254721Semaste} 784254721Semaste 785254721SemasteSBTarget 786263363SemasteSBDebugger::FindTargetWithProcessID (lldb::pid_t pid) 787254721Semaste{ 788254721Semaste SBTarget sb_target; 789254721Semaste if (m_opaque_sp) 790254721Semaste { 791254721Semaste // No need to lock, the target list is thread safe 792254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid)); 793254721Semaste } 794254721Semaste return sb_target; 795254721Semaste} 796254721Semaste 797254721SemasteSBTarget 798254721SemasteSBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name) 799254721Semaste{ 800254721Semaste SBTarget sb_target; 801254721Semaste if (m_opaque_sp && filename && filename[0]) 802254721Semaste { 803254721Semaste // No need to lock, the target list is thread safe 804254721Semaste ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get()); 805254721Semaste TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL)); 806254721Semaste sb_target.SetSP (target_sp); 807254721Semaste } 808254721Semaste return sb_target; 809254721Semaste} 810254721Semaste 811254721SemasteSBTarget 812254721SemasteSBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp) 813254721Semaste{ 814254721Semaste SBTarget sb_target; 815254721Semaste if (m_opaque_sp) 816254721Semaste { 817254721Semaste // No need to lock, the target list is thread safe 818254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get())); 819254721Semaste } 820254721Semaste return sb_target; 821254721Semaste} 822254721Semaste 823254721Semaste 824254721Semasteuint32_t 825254721SemasteSBDebugger::GetNumTargets () 826254721Semaste{ 827254721Semaste if (m_opaque_sp) 828254721Semaste { 829254721Semaste // No need to lock, the target list is thread safe 830254721Semaste return m_opaque_sp->GetTargetList().GetNumTargets (); 831254721Semaste } 832254721Semaste return 0; 833254721Semaste} 834254721Semaste 835254721SemasteSBTarget 836254721SemasteSBDebugger::GetSelectedTarget () 837254721Semaste{ 838254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 839254721Semaste 840254721Semaste SBTarget sb_target; 841254721Semaste TargetSP target_sp; 842254721Semaste if (m_opaque_sp) 843254721Semaste { 844254721Semaste // No need to lock, the target list is thread safe 845254721Semaste target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget (); 846254721Semaste sb_target.SetSP (target_sp); 847254721Semaste } 848254721Semaste 849254721Semaste if (log) 850254721Semaste { 851254721Semaste SBStream sstr; 852254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 853254721Semaste log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 854254721Semaste target_sp.get(), sstr.GetData()); 855254721Semaste } 856254721Semaste 857254721Semaste return sb_target; 858254721Semaste} 859254721Semaste 860254721Semastevoid 861254721SemasteSBDebugger::SetSelectedTarget (SBTarget &sb_target) 862254721Semaste{ 863254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 864254721Semaste 865254721Semaste TargetSP target_sp (sb_target.GetSP()); 866254721Semaste if (m_opaque_sp) 867254721Semaste { 868254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 869254721Semaste } 870254721Semaste if (log) 871254721Semaste { 872254721Semaste SBStream sstr; 873254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 874254721Semaste log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 875254721Semaste target_sp.get(), sstr.GetData()); 876254721Semaste } 877254721Semaste} 878254721Semaste 879263367SemasteSBPlatform 880263367SemasteSBDebugger::GetSelectedPlatform() 881263367Semaste{ 882263367Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 883263367Semaste 884263367Semaste SBPlatform sb_platform; 885263367Semaste DebuggerSP debugger_sp(m_opaque_sp); 886263367Semaste if (debugger_sp) 887263367Semaste { 888263367Semaste sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); 889263367Semaste } 890263367Semaste if (log) 891263367Semaste { 892263367Semaste log->Printf ("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", m_opaque_sp.get(), 893263367Semaste sb_platform.GetSP().get(), sb_platform.GetName()); 894263367Semaste } 895263367Semaste return sb_platform; 896263367Semaste} 897263367Semaste 898254721Semastevoid 899263367SemasteSBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) 900263367Semaste{ 901263367Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 902263367Semaste 903263367Semaste DebuggerSP debugger_sp(m_opaque_sp); 904263367Semaste if (debugger_sp) 905263367Semaste { 906263367Semaste debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); 907263367Semaste } 908263367Semaste if (log) 909263367Semaste { 910263367Semaste log->Printf ("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", m_opaque_sp.get(), 911263367Semaste sb_platform.GetSP().get(), sb_platform.GetName()); 912263367Semaste } 913263367Semaste} 914263367Semaste 915263367Semastevoid 916254721SemasteSBDebugger::DispatchInput (void* baton, const void *data, size_t data_len) 917254721Semaste{ 918254721Semaste DispatchInput (data,data_len); 919254721Semaste} 920254721Semaste 921254721Semastevoid 922254721SemasteSBDebugger::DispatchInput (const void *data, size_t data_len) 923254721Semaste{ 924269024Semaste// Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 925269024Semaste// 926269024Semaste// if (log) 927269024Semaste// log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")", 928269024Semaste// m_opaque_sp.get(), 929269024Semaste// (int) data_len, 930269024Semaste// (const char *) data, 931269024Semaste// (uint64_t)data_len); 932269024Semaste// 933269024Semaste// if (m_opaque_sp) 934269024Semaste// m_opaque_sp->DispatchInput ((const char *) data, data_len); 935254721Semaste} 936254721Semaste 937254721Semastevoid 938254721SemasteSBDebugger::DispatchInputInterrupt () 939254721Semaste{ 940254721Semaste if (m_opaque_sp) 941254721Semaste m_opaque_sp->DispatchInputInterrupt (); 942254721Semaste} 943254721Semaste 944254721Semastevoid 945254721SemasteSBDebugger::DispatchInputEndOfFile () 946254721Semaste{ 947254721Semaste if (m_opaque_sp) 948254721Semaste m_opaque_sp->DispatchInputEndOfFile (); 949254721Semaste} 950254721Semaste 951254721Semastevoid 952254721SemasteSBDebugger::PushInputReader (SBInputReader &reader) 953254721Semaste{ 954254721Semaste} 955254721Semaste 956254721Semastevoid 957269024SemasteSBDebugger::RunCommandInterpreter (bool auto_handle_events, 958269024Semaste bool spawn_thread) 959254721Semaste{ 960254721Semaste if (m_opaque_sp) 961269024Semaste m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(auto_handle_events, spawn_thread); 962254721Semaste} 963254721Semaste 964254721Semastevoid 965254721SemasteSBDebugger::reset (const DebuggerSP &debugger_sp) 966254721Semaste{ 967254721Semaste m_opaque_sp = debugger_sp; 968254721Semaste} 969254721Semaste 970254721SemasteDebugger * 971254721SemasteSBDebugger::get () const 972254721Semaste{ 973254721Semaste return m_opaque_sp.get(); 974254721Semaste} 975254721Semaste 976254721SemasteDebugger & 977254721SemasteSBDebugger::ref () const 978254721Semaste{ 979254721Semaste assert (m_opaque_sp.get()); 980254721Semaste return *m_opaque_sp; 981254721Semaste} 982254721Semaste 983254721Semasteconst lldb::DebuggerSP & 984254721SemasteSBDebugger::get_sp () const 985254721Semaste{ 986254721Semaste return m_opaque_sp; 987254721Semaste} 988254721Semaste 989254721SemasteSBDebugger 990254721SemasteSBDebugger::FindDebuggerWithID (int id) 991254721Semaste{ 992254721Semaste // No need to lock, the debugger list is thread safe 993254721Semaste SBDebugger sb_debugger; 994254721Semaste DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id); 995254721Semaste if (debugger_sp) 996254721Semaste sb_debugger.reset (debugger_sp); 997254721Semaste return sb_debugger; 998254721Semaste} 999254721Semaste 1000254721Semasteconst char * 1001254721SemasteSBDebugger::GetInstanceName() 1002254721Semaste{ 1003254721Semaste if (m_opaque_sp) 1004254721Semaste return m_opaque_sp->GetInstanceName().AsCString(); 1005254721Semaste else 1006254721Semaste return NULL; 1007254721Semaste} 1008254721Semaste 1009254721SemasteSBError 1010254721SemasteSBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name) 1011254721Semaste{ 1012254721Semaste SBError sb_error; 1013254721Semaste DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 1014254721Semaste Error error; 1015254721Semaste if (debugger_sp) 1016254721Semaste { 1017254721Semaste ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1018254721Semaste error = debugger_sp->SetPropertyValue (&exe_ctx, 1019254721Semaste eVarSetOperationAssign, 1020254721Semaste var_name, 1021254721Semaste value); 1022254721Semaste } 1023254721Semaste else 1024254721Semaste { 1025254721Semaste error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name); 1026254721Semaste } 1027254721Semaste if (error.Fail()) 1028254721Semaste sb_error.SetError(error); 1029254721Semaste return sb_error; 1030254721Semaste} 1031254721Semaste 1032254721SemasteSBStringList 1033254721SemasteSBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name) 1034254721Semaste{ 1035254721Semaste SBStringList ret_value; 1036254721Semaste DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 1037254721Semaste Error error; 1038254721Semaste if (debugger_sp) 1039254721Semaste { 1040254721Semaste ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1041254721Semaste lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx, 1042254721Semaste var_name, 1043254721Semaste false, 1044254721Semaste error)); 1045254721Semaste if (value_sp) 1046254721Semaste { 1047254721Semaste StreamString value_strm; 1048254721Semaste value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 1049254721Semaste const std::string &value_str = value_strm.GetString(); 1050254721Semaste if (!value_str.empty()) 1051254721Semaste { 1052254721Semaste StringList string_list; 1053269024Semaste string_list.SplitIntoLines(value_str); 1054254721Semaste return SBStringList(&string_list); 1055254721Semaste } 1056254721Semaste } 1057254721Semaste } 1058254721Semaste return SBStringList(); 1059254721Semaste} 1060254721Semaste 1061254721Semasteuint32_t 1062254721SemasteSBDebugger::GetTerminalWidth () const 1063254721Semaste{ 1064254721Semaste if (m_opaque_sp) 1065254721Semaste return m_opaque_sp->GetTerminalWidth (); 1066254721Semaste return 0; 1067254721Semaste} 1068254721Semaste 1069254721Semastevoid 1070254721SemasteSBDebugger::SetTerminalWidth (uint32_t term_width) 1071254721Semaste{ 1072254721Semaste if (m_opaque_sp) 1073254721Semaste m_opaque_sp->SetTerminalWidth (term_width); 1074254721Semaste} 1075254721Semaste 1076254721Semasteconst char * 1077254721SemasteSBDebugger::GetPrompt() const 1078254721Semaste{ 1079254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1080254721Semaste 1081254721Semaste if (log) 1082254721Semaste log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(), 1083254721Semaste (m_opaque_sp ? m_opaque_sp->GetPrompt() : "")); 1084254721Semaste 1085254721Semaste if (m_opaque_sp) 1086254721Semaste return m_opaque_sp->GetPrompt (); 1087254721Semaste return 0; 1088254721Semaste} 1089254721Semaste 1090254721Semastevoid 1091254721SemasteSBDebugger::SetPrompt (const char *prompt) 1092254721Semaste{ 1093254721Semaste if (m_opaque_sp) 1094254721Semaste m_opaque_sp->SetPrompt (prompt); 1095254721Semaste} 1096254721Semaste 1097254721Semaste 1098254721SemasteScriptLanguage 1099254721SemasteSBDebugger::GetScriptLanguage() const 1100254721Semaste{ 1101254721Semaste if (m_opaque_sp) 1102254721Semaste return m_opaque_sp->GetScriptLanguage (); 1103254721Semaste return eScriptLanguageNone; 1104254721Semaste} 1105254721Semaste 1106254721Semastevoid 1107254721SemasteSBDebugger::SetScriptLanguage (ScriptLanguage script_lang) 1108254721Semaste{ 1109254721Semaste if (m_opaque_sp) 1110254721Semaste { 1111254721Semaste m_opaque_sp->SetScriptLanguage (script_lang); 1112254721Semaste } 1113254721Semaste} 1114254721Semaste 1115254721Semastebool 1116254721SemasteSBDebugger::SetUseExternalEditor (bool value) 1117254721Semaste{ 1118254721Semaste if (m_opaque_sp) 1119254721Semaste return m_opaque_sp->SetUseExternalEditor (value); 1120254721Semaste return false; 1121254721Semaste} 1122254721Semaste 1123254721Semastebool 1124254721SemasteSBDebugger::GetUseExternalEditor () 1125254721Semaste{ 1126254721Semaste if (m_opaque_sp) 1127254721Semaste return m_opaque_sp->GetUseExternalEditor (); 1128254721Semaste return false; 1129254721Semaste} 1130254721Semaste 1131254721Semastebool 1132254721SemasteSBDebugger::SetUseColor (bool value) 1133254721Semaste{ 1134254721Semaste if (m_opaque_sp) 1135254721Semaste return m_opaque_sp->SetUseColor (value); 1136254721Semaste return false; 1137254721Semaste} 1138254721Semaste 1139254721Semastebool 1140254721SemasteSBDebugger::GetUseColor () const 1141254721Semaste{ 1142254721Semaste if (m_opaque_sp) 1143254721Semaste return m_opaque_sp->GetUseColor (); 1144254721Semaste return false; 1145254721Semaste} 1146254721Semaste 1147254721Semastebool 1148254721SemasteSBDebugger::GetDescription (SBStream &description) 1149254721Semaste{ 1150254721Semaste Stream &strm = description.ref(); 1151254721Semaste 1152254721Semaste if (m_opaque_sp) 1153254721Semaste { 1154254721Semaste const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1155254721Semaste user_id_t id = m_opaque_sp->GetID(); 1156254721Semaste strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1157254721Semaste } 1158254721Semaste else 1159254721Semaste strm.PutCString ("No value"); 1160254721Semaste 1161254721Semaste return true; 1162254721Semaste} 1163254721Semaste 1164254721Semasteuser_id_t 1165254721SemasteSBDebugger::GetID() 1166254721Semaste{ 1167254721Semaste if (m_opaque_sp) 1168254721Semaste return m_opaque_sp->GetID(); 1169254721Semaste return LLDB_INVALID_UID; 1170254721Semaste} 1171254721Semaste 1172254721Semaste 1173254721SemasteSBError 1174254721SemasteSBDebugger::SetCurrentPlatform (const char *platform_name) 1175254721Semaste{ 1176254721Semaste SBError sb_error; 1177254721Semaste if (m_opaque_sp) 1178254721Semaste { 1179254721Semaste PlatformSP platform_sp (Platform::Create (platform_name, sb_error.ref())); 1180254721Semaste 1181254721Semaste if (platform_sp) 1182254721Semaste { 1183254721Semaste bool make_selected = true; 1184254721Semaste m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected); 1185254721Semaste } 1186254721Semaste } 1187254721Semaste return sb_error; 1188254721Semaste} 1189254721Semaste 1190254721Semastebool 1191254721SemasteSBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot) 1192254721Semaste{ 1193254721Semaste if (m_opaque_sp) 1194254721Semaste { 1195254721Semaste PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1196254721Semaste 1197254721Semaste if (platform_sp) 1198254721Semaste { 1199254721Semaste platform_sp->SetSDKRootDirectory (ConstString (sysroot)); 1200254721Semaste return true; 1201254721Semaste } 1202254721Semaste } 1203254721Semaste return false; 1204254721Semaste} 1205254721Semaste 1206254721Semastebool 1207254721SemasteSBDebugger::GetCloseInputOnEOF () const 1208254721Semaste{ 1209254721Semaste if (m_opaque_sp) 1210254721Semaste return m_opaque_sp->GetCloseInputOnEOF (); 1211254721Semaste return false; 1212254721Semaste} 1213254721Semaste 1214254721Semastevoid 1215254721SemasteSBDebugger::SetCloseInputOnEOF (bool b) 1216254721Semaste{ 1217254721Semaste if (m_opaque_sp) 1218254721Semaste m_opaque_sp->SetCloseInputOnEOF (b); 1219254721Semaste} 1220254721Semaste 1221254721SemasteSBTypeCategory 1222254721SemasteSBDebugger::GetCategory (const char* category_name) 1223254721Semaste{ 1224254721Semaste if (!category_name || *category_name == 0) 1225254721Semaste return SBTypeCategory(); 1226254721Semaste 1227254721Semaste TypeCategoryImplSP category_sp; 1228254721Semaste 1229254721Semaste if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false)) 1230254721Semaste return SBTypeCategory(category_sp); 1231254721Semaste else 1232254721Semaste return SBTypeCategory(); 1233254721Semaste} 1234254721Semaste 1235254721SemasteSBTypeCategory 1236254721SemasteSBDebugger::CreateCategory (const char* category_name) 1237254721Semaste{ 1238254721Semaste if (!category_name || *category_name == 0) 1239254721Semaste return SBTypeCategory(); 1240254721Semaste 1241254721Semaste TypeCategoryImplSP category_sp; 1242254721Semaste 1243254721Semaste if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true)) 1244254721Semaste return SBTypeCategory(category_sp); 1245254721Semaste else 1246254721Semaste return SBTypeCategory(); 1247254721Semaste} 1248254721Semaste 1249254721Semastebool 1250254721SemasteSBDebugger::DeleteCategory (const char* category_name) 1251254721Semaste{ 1252254721Semaste if (!category_name || *category_name == 0) 1253254721Semaste return false; 1254254721Semaste 1255254721Semaste return DataVisualization::Categories::Delete(ConstString(category_name)); 1256254721Semaste} 1257254721Semaste 1258254721Semasteuint32_t 1259254721SemasteSBDebugger::GetNumCategories() 1260254721Semaste{ 1261254721Semaste return DataVisualization::Categories::GetCount(); 1262254721Semaste} 1263254721Semaste 1264254721SemasteSBTypeCategory 1265254721SemasteSBDebugger::GetCategoryAtIndex (uint32_t index) 1266254721Semaste{ 1267254721Semaste return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)); 1268254721Semaste} 1269254721Semaste 1270254721SemasteSBTypeCategory 1271254721SemasteSBDebugger::GetDefaultCategory() 1272254721Semaste{ 1273254721Semaste return GetCategory("default"); 1274254721Semaste} 1275254721Semaste 1276254721SemasteSBTypeFormat 1277254721SemasteSBDebugger::GetFormatForType (SBTypeNameSpecifier type_name) 1278254721Semaste{ 1279254721Semaste SBTypeCategory default_category_sb = GetDefaultCategory(); 1280254721Semaste if (default_category_sb.GetEnabled()) 1281254721Semaste return default_category_sb.GetFormatForType(type_name); 1282254721Semaste return SBTypeFormat(); 1283254721Semaste} 1284254721Semaste 1285254721Semaste#ifndef LLDB_DISABLE_PYTHON 1286254721SemasteSBTypeSummary 1287254721SemasteSBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name) 1288254721Semaste{ 1289254721Semaste if (type_name.IsValid() == false) 1290254721Semaste return SBTypeSummary(); 1291254721Semaste return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())); 1292254721Semaste} 1293254721Semaste#endif // LLDB_DISABLE_PYTHON 1294254721Semaste 1295254721SemasteSBTypeFilter 1296254721SemasteSBDebugger::GetFilterForType (SBTypeNameSpecifier type_name) 1297254721Semaste{ 1298254721Semaste if (type_name.IsValid() == false) 1299254721Semaste return SBTypeFilter(); 1300254721Semaste return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())); 1301254721Semaste} 1302254721Semaste 1303254721Semaste#ifndef LLDB_DISABLE_PYTHON 1304254721SemasteSBTypeSynthetic 1305254721SemasteSBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name) 1306254721Semaste{ 1307254721Semaste if (type_name.IsValid() == false) 1308254721Semaste return SBTypeSynthetic(); 1309254721Semaste return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP())); 1310254721Semaste} 1311254721Semaste#endif // LLDB_DISABLE_PYTHON 1312254721Semaste 1313254721Semastebool 1314254721SemasteSBDebugger::EnableLog (const char *channel, const char **categories) 1315254721Semaste{ 1316254721Semaste if (m_opaque_sp) 1317254721Semaste { 1318254721Semaste uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1319254721Semaste StreamString errors; 1320254721Semaste return m_opaque_sp->EnableLog (channel, categories, NULL, log_options, errors); 1321254721Semaste 1322254721Semaste } 1323254721Semaste else 1324254721Semaste return false; 1325254721Semaste} 1326254721Semaste 1327254721Semastevoid 1328254721SemasteSBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 1329254721Semaste{ 1330254721Semaste if (m_opaque_sp) 1331254721Semaste { 1332254721Semaste return m_opaque_sp->SetLoggingCallback (log_callback, baton); 1333254721Semaste } 1334254721Semaste} 1335254721Semaste 1336254721Semaste 1337