SBDebugger.cpp revision 263367
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/SBInputReader.h" 24254721Semaste#include "lldb/API/SBProcess.h" 25254721Semaste#include "lldb/API/SBSourceManager.h" 26254721Semaste#include "lldb/API/SBStream.h" 27254721Semaste#include "lldb/API/SBStringList.h" 28254721Semaste#include "lldb/API/SBTarget.h" 29254721Semaste#include "lldb/API/SBThread.h" 30254721Semaste#include "lldb/API/SBTypeCategory.h" 31254721Semaste#include "lldb/API/SBTypeFormat.h" 32254721Semaste#include "lldb/API/SBTypeFilter.h" 33254721Semaste#include "lldb/API/SBTypeNameSpecifier.h" 34254721Semaste#include "lldb/API/SBTypeSummary.h" 35254721Semaste#include "lldb/API/SBTypeSynthetic.h" 36254721Semaste 37254721Semaste 38254721Semaste#include "lldb/Core/Debugger.h" 39254721Semaste#include "lldb/Core/State.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 52263367Semastestatic lldb::DynamicLibrarySP 53263367SemasteLoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error) 54263367Semaste{ 55263367Semaste lldb::DynamicLibrarySP dynlib_sp(new lldb_private::DynamicLibrary(spec)); 56263367Semaste if (dynlib_sp && dynlib_sp->IsValid()) 57263367Semaste { 58263367Semaste typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger); 59263367Semaste 60263367Semaste lldb::SBDebugger debugger_sb(debugger_sp); 61263367Semaste // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function. 62263367Semaste // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays 63263367Semaste LLDBCommandPluginInit init_func = dynlib_sp->GetSymbol<LLDBCommandPluginInit>("_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); 64263367Semaste if (init_func) 65263367Semaste { 66263367Semaste if (init_func(debugger_sb)) 67263367Semaste return dynlib_sp; 68263367Semaste else 69263367Semaste error.SetErrorString("plug-in refused to load (lldb::PluginInitialize(lldb::SBDebugger) returned false)"); 70263367Semaste } 71263367Semaste else 72263367Semaste { 73263367Semaste error.SetErrorString("plug-in is missing the required initialization: lldb::PluginInitialize(lldb::SBDebugger)"); 74263367Semaste } 75263367Semaste } 76263367Semaste else 77263367Semaste { 78263367Semaste if (spec.Exists()) 79263367Semaste error.SetErrorString("this file does not represent a loadable dylib"); 80263367Semaste else 81263367Semaste error.SetErrorString("no such file"); 82263367Semaste } 83263367Semaste return lldb::DynamicLibrarySP(); 84263367Semaste} 85263367Semaste 86254721Semastevoid 87254721SemasteSBDebugger::Initialize () 88254721Semaste{ 89254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 90254721Semaste 91254721Semaste if (log) 92254721Semaste log->Printf ("SBDebugger::Initialize ()"); 93254721Semaste 94254721Semaste SBCommandInterpreter::InitializeSWIG (); 95254721Semaste 96263367Semaste Debugger::Initialize(LoadPlugin); 97254721Semaste} 98254721Semaste 99254721Semastevoid 100254721SemasteSBDebugger::Terminate () 101254721Semaste{ 102254721Semaste Debugger::Terminate(); 103254721Semaste} 104254721Semaste 105254721Semastevoid 106254721SemasteSBDebugger::Clear () 107254721Semaste{ 108254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 109254721Semaste 110254721Semaste if (log) 111254721Semaste log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get()); 112254721Semaste 113254721Semaste if (m_opaque_sp) 114254721Semaste m_opaque_sp->CleanUpInputReaders (); 115254721Semaste 116254721Semaste m_opaque_sp.reset(); 117254721Semaste} 118254721Semaste 119254721SemasteSBDebugger 120254721SemasteSBDebugger::Create() 121254721Semaste{ 122254721Semaste return SBDebugger::Create(false, NULL, NULL); 123254721Semaste} 124254721Semaste 125254721SemasteSBDebugger 126254721SemasteSBDebugger::Create(bool source_init_files) 127254721Semaste{ 128254721Semaste return SBDebugger::Create (source_init_files, NULL, NULL); 129254721Semaste} 130254721Semaste 131254721SemasteSBDebugger 132254721SemasteSBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton) 133254721Semaste 134254721Semaste{ 135254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 136254721Semaste 137254721Semaste SBDebugger debugger; 138254721Semaste debugger.reset(Debugger::CreateInstance(callback, baton)); 139254721Semaste 140254721Semaste if (log) 141254721Semaste { 142254721Semaste SBStream sstr; 143254721Semaste debugger.GetDescription (sstr); 144254721Semaste log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 145254721Semaste } 146254721Semaste 147254721Semaste SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 148254721Semaste if (source_init_files) 149254721Semaste { 150254721Semaste interp.get()->SkipLLDBInitFiles(false); 151254721Semaste interp.get()->SkipAppInitFiles (false); 152254721Semaste SBCommandReturnObject result; 153254721Semaste interp.SourceInitFileInHomeDirectory(result); 154254721Semaste } 155254721Semaste else 156254721Semaste { 157254721Semaste interp.get()->SkipLLDBInitFiles(true); 158254721Semaste interp.get()->SkipAppInitFiles (true); 159254721Semaste } 160254721Semaste return debugger; 161254721Semaste} 162254721Semaste 163254721Semastevoid 164254721SemasteSBDebugger::Destroy (SBDebugger &debugger) 165254721Semaste{ 166254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 167254721Semaste 168254721Semaste if (log) 169254721Semaste { 170254721Semaste SBStream sstr; 171254721Semaste debugger.GetDescription (sstr); 172254721Semaste log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 173254721Semaste } 174254721Semaste 175254721Semaste Debugger::Destroy (debugger.m_opaque_sp); 176254721Semaste 177254721Semaste if (debugger.m_opaque_sp.get() != NULL) 178254721Semaste debugger.m_opaque_sp.reset(); 179254721Semaste} 180254721Semaste 181254721Semastevoid 182254721SemasteSBDebugger::MemoryPressureDetected () 183254721Semaste{ 184254721Semaste // Since this function can be call asynchronously, we allow it to be 185254721Semaste // non-mandatory. We have seen deadlocks with this function when called 186254721Semaste // so we need to safeguard against this until we can determine what is 187254721Semaste // causing the deadlocks. 188254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 189254721Semaste 190254721Semaste const bool mandatory = false; 191254721Semaste if (log) 192254721Semaste { 193254721Semaste log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory); 194254721Semaste } 195254721Semaste 196254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 197254721Semaste} 198254721Semaste 199254721SemasteSBDebugger::SBDebugger () : 200254721Semaste m_opaque_sp () 201254721Semaste{ 202254721Semaste} 203254721Semaste 204254721SemasteSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : 205254721Semaste m_opaque_sp(debugger_sp) 206254721Semaste{ 207254721Semaste} 208254721Semaste 209254721SemasteSBDebugger::SBDebugger(const SBDebugger &rhs) : 210254721Semaste m_opaque_sp (rhs.m_opaque_sp) 211254721Semaste{ 212254721Semaste} 213254721Semaste 214254721SemasteSBDebugger & 215254721SemasteSBDebugger::operator = (const SBDebugger &rhs) 216254721Semaste{ 217254721Semaste if (this != &rhs) 218254721Semaste { 219254721Semaste m_opaque_sp = rhs.m_opaque_sp; 220254721Semaste } 221254721Semaste return *this; 222254721Semaste} 223254721Semaste 224254721SemasteSBDebugger::~SBDebugger () 225254721Semaste{ 226254721Semaste} 227254721Semaste 228254721Semastebool 229254721SemasteSBDebugger::IsValid() const 230254721Semaste{ 231254721Semaste return m_opaque_sp.get() != NULL; 232254721Semaste} 233254721Semaste 234254721Semaste 235254721Semastevoid 236254721SemasteSBDebugger::SetAsync (bool b) 237254721Semaste{ 238254721Semaste if (m_opaque_sp) 239254721Semaste m_opaque_sp->SetAsyncExecution(b); 240254721Semaste} 241254721Semaste 242254721Semastebool 243254721SemasteSBDebugger::GetAsync () 244254721Semaste{ 245254721Semaste if (m_opaque_sp) 246254721Semaste return m_opaque_sp->GetAsyncExecution(); 247254721Semaste else 248254721Semaste return false; 249254721Semaste} 250254721Semaste 251254721Semastevoid 252254721SemasteSBDebugger::SkipLLDBInitFiles (bool b) 253254721Semaste{ 254254721Semaste if (m_opaque_sp) 255254721Semaste m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b); 256254721Semaste} 257254721Semaste 258254721Semastevoid 259254721SemasteSBDebugger::SkipAppInitFiles (bool b) 260254721Semaste{ 261254721Semaste if (m_opaque_sp) 262254721Semaste m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b); 263254721Semaste} 264254721Semaste 265254721Semaste// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users 266254721Semaste// trying to switch modes in the middle of a debugging session. 267254721Semastevoid 268254721SemasteSBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership) 269254721Semaste{ 270254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 271254721Semaste 272254721Semaste if (log) 273254721Semaste log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 274254721Semaste fh, transfer_ownership); 275254721Semaste 276254721Semaste if (m_opaque_sp) 277254721Semaste m_opaque_sp->SetInputFileHandle (fh, transfer_ownership); 278254721Semaste} 279254721Semaste 280254721Semastevoid 281254721SemasteSBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership) 282254721Semaste{ 283254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 284254721Semaste 285254721Semaste 286254721Semaste if (log) 287254721Semaste log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 288254721Semaste fh, transfer_ownership); 289254721Semaste 290254721Semaste if (m_opaque_sp) 291254721Semaste m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership); 292254721Semaste} 293254721Semaste 294254721Semastevoid 295254721SemasteSBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership) 296254721Semaste{ 297254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 298254721Semaste 299254721Semaste 300254721Semaste if (log) 301254721Semaste log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 302254721Semaste fh, transfer_ownership); 303254721Semaste 304254721Semaste if (m_opaque_sp) 305254721Semaste m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership); 306254721Semaste} 307254721Semaste 308254721SemasteFILE * 309254721SemasteSBDebugger::GetInputFileHandle () 310254721Semaste{ 311254721Semaste if (m_opaque_sp) 312254721Semaste return m_opaque_sp->GetInputFile().GetStream(); 313254721Semaste return NULL; 314254721Semaste} 315254721Semaste 316254721SemasteFILE * 317254721SemasteSBDebugger::GetOutputFileHandle () 318254721Semaste{ 319254721Semaste if (m_opaque_sp) 320254721Semaste return m_opaque_sp->GetOutputFile().GetStream(); 321254721Semaste return NULL; 322254721Semaste} 323254721Semaste 324254721SemasteFILE * 325254721SemasteSBDebugger::GetErrorFileHandle () 326254721Semaste{ 327254721Semaste if (m_opaque_sp) 328254721Semaste return m_opaque_sp->GetErrorFile().GetStream(); 329254721Semaste return NULL; 330254721Semaste} 331254721Semaste 332254721Semastevoid 333254721SemasteSBDebugger::SaveInputTerminalState() 334254721Semaste{ 335254721Semaste if (m_opaque_sp) 336254721Semaste m_opaque_sp->SaveInputTerminalState(); 337254721Semaste} 338254721Semaste 339254721Semastevoid 340254721SemasteSBDebugger::RestoreInputTerminalState() 341254721Semaste{ 342254721Semaste if (m_opaque_sp) 343254721Semaste m_opaque_sp->RestoreInputTerminalState(); 344254721Semaste 345254721Semaste} 346254721SemasteSBCommandInterpreter 347254721SemasteSBDebugger::GetCommandInterpreter () 348254721Semaste{ 349254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 350254721Semaste 351254721Semaste SBCommandInterpreter sb_interpreter; 352254721Semaste if (m_opaque_sp) 353254721Semaste sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter()); 354254721Semaste 355254721Semaste if (log) 356254721Semaste log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)", 357254721Semaste m_opaque_sp.get(), sb_interpreter.get()); 358254721Semaste 359254721Semaste return sb_interpreter; 360254721Semaste} 361254721Semaste 362254721Semastevoid 363254721SemasteSBDebugger::HandleCommand (const char *command) 364254721Semaste{ 365254721Semaste if (m_opaque_sp) 366254721Semaste { 367254721Semaste TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 368254721Semaste Mutex::Locker api_locker; 369254721Semaste if (target_sp) 370254721Semaste api_locker.Lock(target_sp->GetAPIMutex()); 371254721Semaste 372254721Semaste SBCommandInterpreter sb_interpreter(GetCommandInterpreter ()); 373254721Semaste SBCommandReturnObject result; 374254721Semaste 375254721Semaste sb_interpreter.HandleCommand (command, result, false); 376254721Semaste 377254721Semaste if (GetErrorFileHandle() != NULL) 378254721Semaste result.PutError (GetErrorFileHandle()); 379254721Semaste if (GetOutputFileHandle() != NULL) 380254721Semaste result.PutOutput (GetOutputFileHandle()); 381254721Semaste 382254721Semaste if (m_opaque_sp->GetAsyncExecution() == false) 383254721Semaste { 384254721Semaste SBProcess process(GetCommandInterpreter().GetProcess ()); 385254721Semaste ProcessSP process_sp (process.GetSP()); 386254721Semaste if (process_sp) 387254721Semaste { 388254721Semaste EventSP event_sp; 389254721Semaste Listener &lldb_listener = m_opaque_sp->GetListener(); 390254721Semaste while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp)) 391254721Semaste { 392254721Semaste SBEvent event(event_sp); 393254721Semaste HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); 394254721Semaste } 395254721Semaste } 396254721Semaste } 397254721Semaste } 398254721Semaste} 399254721Semaste 400254721SemasteSBListener 401254721SemasteSBDebugger::GetListener () 402254721Semaste{ 403254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 404254721Semaste 405254721Semaste SBListener sb_listener; 406254721Semaste if (m_opaque_sp) 407254721Semaste sb_listener.reset(&m_opaque_sp->GetListener(), false); 408254721Semaste 409254721Semaste if (log) 410254721Semaste log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(), 411254721Semaste sb_listener.get()); 412254721Semaste 413254721Semaste return sb_listener; 414254721Semaste} 415254721Semaste 416254721Semastevoid 417254721SemasteSBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) 418254721Semaste{ 419254721Semaste if (!process.IsValid()) 420254721Semaste return; 421254721Semaste 422254721Semaste TargetSP target_sp (process.GetTarget().GetSP()); 423254721Semaste if (!target_sp) 424254721Semaste return; 425254721Semaste 426254721Semaste const uint32_t event_type = event.GetType(); 427254721Semaste char stdio_buffer[1024]; 428254721Semaste size_t len; 429254721Semaste 430254721Semaste Mutex::Locker api_locker (target_sp->GetAPIMutex()); 431254721Semaste 432254721Semaste if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) 433254721Semaste { 434254721Semaste // Drain stdout when we stop just in case we have any bytes 435254721Semaste while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) 436254721Semaste if (out != NULL) 437254721Semaste ::fwrite (stdio_buffer, 1, len, out); 438254721Semaste } 439254721Semaste 440254721Semaste if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) 441254721Semaste { 442254721Semaste // Drain stderr when we stop just in case we have any bytes 443254721Semaste while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) 444254721Semaste if (err != NULL) 445254721Semaste ::fwrite (stdio_buffer, 1, len, err); 446254721Semaste } 447254721Semaste 448254721Semaste if (event_type & Process::eBroadcastBitStateChanged) 449254721Semaste { 450254721Semaste StateType event_state = SBProcess::GetStateFromEvent (event); 451254721Semaste 452254721Semaste if (event_state == eStateInvalid) 453254721Semaste return; 454254721Semaste 455254721Semaste bool is_stopped = StateIsStoppedState (event_state); 456254721Semaste if (!is_stopped) 457254721Semaste process.ReportEventState (event, out); 458254721Semaste } 459254721Semaste} 460254721Semaste 461254721SemasteSBSourceManager 462254721SemasteSBDebugger::GetSourceManager () 463254721Semaste{ 464254721Semaste SBSourceManager sb_source_manager (*this); 465254721Semaste return sb_source_manager; 466254721Semaste} 467254721Semaste 468254721Semaste 469254721Semastebool 470254721SemasteSBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len) 471254721Semaste{ 472254721Semaste if (arch_name && arch_name_len) 473254721Semaste { 474254721Semaste ArchSpec default_arch = Target::GetDefaultArchitecture (); 475254721Semaste 476254721Semaste if (default_arch.IsValid()) 477254721Semaste { 478254721Semaste const std::string &triple_str = default_arch.GetTriple().str(); 479254721Semaste if (!triple_str.empty()) 480254721Semaste ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str()); 481254721Semaste else 482254721Semaste ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName()); 483254721Semaste return true; 484254721Semaste } 485254721Semaste } 486254721Semaste if (arch_name && arch_name_len) 487254721Semaste arch_name[0] = '\0'; 488254721Semaste return false; 489254721Semaste} 490254721Semaste 491254721Semaste 492254721Semastebool 493254721SemasteSBDebugger::SetDefaultArchitecture (const char *arch_name) 494254721Semaste{ 495254721Semaste if (arch_name) 496254721Semaste { 497254721Semaste ArchSpec arch (arch_name); 498254721Semaste if (arch.IsValid()) 499254721Semaste { 500254721Semaste Target::SetDefaultArchitecture (arch); 501254721Semaste return true; 502254721Semaste } 503254721Semaste } 504254721Semaste return false; 505254721Semaste} 506254721Semaste 507254721SemasteScriptLanguage 508254721SemasteSBDebugger::GetScriptingLanguage (const char *script_language_name) 509254721Semaste{ 510254721Semaste 511254721Semaste return Args::StringToScriptLanguage (script_language_name, 512254721Semaste eScriptLanguageDefault, 513254721Semaste NULL); 514254721Semaste} 515254721Semaste 516254721Semasteconst char * 517254721SemasteSBDebugger::GetVersionString () 518254721Semaste{ 519263363Semaste return lldb_private::GetVersion(); 520254721Semaste} 521254721Semaste 522254721Semasteconst char * 523254721SemasteSBDebugger::StateAsCString (StateType state) 524254721Semaste{ 525254721Semaste return lldb_private::StateAsCString (state); 526254721Semaste} 527254721Semaste 528254721Semastebool 529254721SemasteSBDebugger::StateIsRunningState (StateType state) 530254721Semaste{ 531254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 532254721Semaste 533254721Semaste const bool result = lldb_private::StateIsRunningState (state); 534254721Semaste if (log) 535254721Semaste log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", 536254721Semaste StateAsCString (state), result); 537254721Semaste 538254721Semaste return result; 539254721Semaste} 540254721Semaste 541254721Semastebool 542254721SemasteSBDebugger::StateIsStoppedState (StateType state) 543254721Semaste{ 544254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 545254721Semaste 546254721Semaste const bool result = lldb_private::StateIsStoppedState (state, false); 547254721Semaste if (log) 548254721Semaste log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", 549254721Semaste StateAsCString (state), result); 550254721Semaste 551254721Semaste return result; 552254721Semaste} 553254721Semaste 554254721Semastelldb::SBTarget 555254721SemasteSBDebugger::CreateTarget (const char *filename, 556254721Semaste const char *target_triple, 557254721Semaste const char *platform_name, 558254721Semaste bool add_dependent_modules, 559254721Semaste lldb::SBError& sb_error) 560254721Semaste{ 561254721Semaste SBTarget sb_target; 562254721Semaste TargetSP target_sp; 563254721Semaste if (m_opaque_sp) 564254721Semaste { 565254721Semaste sb_error.Clear(); 566254721Semaste OptionGroupPlatform platform_options (false); 567254721Semaste platform_options.SetPlatformName (platform_name); 568254721Semaste 569254721Semaste sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 570254721Semaste filename, 571254721Semaste target_triple, 572254721Semaste add_dependent_modules, 573254721Semaste &platform_options, 574254721Semaste target_sp); 575254721Semaste 576254721Semaste if (sb_error.Success()) 577254721Semaste sb_target.SetSP (target_sp); 578254721Semaste } 579254721Semaste else 580254721Semaste { 581254721Semaste sb_error.SetErrorString("invalid target"); 582254721Semaste } 583254721Semaste 584254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 585254721Semaste if (log) 586254721Semaste { 587254721Semaste log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)", 588254721Semaste m_opaque_sp.get(), 589254721Semaste filename, 590254721Semaste target_triple, 591254721Semaste platform_name, 592254721Semaste add_dependent_modules, 593254721Semaste sb_error.GetCString(), 594254721Semaste target_sp.get()); 595254721Semaste } 596254721Semaste 597254721Semaste return sb_target; 598254721Semaste} 599254721Semaste 600254721SemasteSBTarget 601254721SemasteSBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename, 602254721Semaste const char *target_triple) 603254721Semaste{ 604254721Semaste SBTarget sb_target; 605254721Semaste TargetSP target_sp; 606254721Semaste if (m_opaque_sp) 607254721Semaste { 608254721Semaste const bool add_dependent_modules = true; 609254721Semaste Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 610254721Semaste filename, 611254721Semaste target_triple, 612254721Semaste add_dependent_modules, 613254721Semaste NULL, 614254721Semaste target_sp)); 615254721Semaste sb_target.SetSP (target_sp); 616254721Semaste } 617254721Semaste 618254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 619254721Semaste if (log) 620254721Semaste { 621254721Semaste log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)", 622254721Semaste m_opaque_sp.get(), filename, target_triple, target_sp.get()); 623254721Semaste } 624254721Semaste 625254721Semaste return sb_target; 626254721Semaste} 627254721Semaste 628254721SemasteSBTarget 629254721SemasteSBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr) 630254721Semaste{ 631254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 632254721Semaste 633254721Semaste SBTarget sb_target; 634254721Semaste TargetSP target_sp; 635254721Semaste if (m_opaque_sp) 636254721Semaste { 637254721Semaste Error error; 638254721Semaste const bool add_dependent_modules = true; 639254721Semaste 640254721Semaste error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 641254721Semaste filename, 642254721Semaste arch_cstr, 643254721Semaste add_dependent_modules, 644254721Semaste NULL, 645254721Semaste target_sp); 646254721Semaste 647254721Semaste if (error.Success()) 648254721Semaste { 649254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 650254721Semaste sb_target.SetSP (target_sp); 651254721Semaste } 652254721Semaste } 653254721Semaste 654254721Semaste if (log) 655254721Semaste { 656254721Semaste log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)", 657254721Semaste m_opaque_sp.get(), filename, arch_cstr, target_sp.get()); 658254721Semaste } 659254721Semaste 660254721Semaste return sb_target; 661254721Semaste} 662254721Semaste 663254721SemasteSBTarget 664254721SemasteSBDebugger::CreateTarget (const char *filename) 665254721Semaste{ 666254721Semaste SBTarget sb_target; 667254721Semaste TargetSP target_sp; 668254721Semaste if (m_opaque_sp) 669254721Semaste { 670254721Semaste ArchSpec arch = Target::GetDefaultArchitecture (); 671254721Semaste Error error; 672254721Semaste const bool add_dependent_modules = true; 673254721Semaste 674254721Semaste PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 675254721Semaste error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 676254721Semaste filename, 677254721Semaste arch, 678254721Semaste add_dependent_modules, 679254721Semaste platform_sp, 680254721Semaste target_sp); 681254721Semaste 682254721Semaste if (error.Success()) 683254721Semaste { 684254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 685254721Semaste sb_target.SetSP (target_sp); 686254721Semaste } 687254721Semaste } 688254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 689254721Semaste if (log) 690254721Semaste { 691254721Semaste log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 692254721Semaste m_opaque_sp.get(), filename, target_sp.get()); 693254721Semaste } 694254721Semaste return sb_target; 695254721Semaste} 696254721Semaste 697254721Semastebool 698254721SemasteSBDebugger::DeleteTarget (lldb::SBTarget &target) 699254721Semaste{ 700254721Semaste bool result = false; 701254721Semaste if (m_opaque_sp) 702254721Semaste { 703254721Semaste TargetSP target_sp(target.GetSP()); 704254721Semaste if (target_sp) 705254721Semaste { 706254721Semaste // No need to lock, the target list is thread safe 707254721Semaste result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp); 708254721Semaste target_sp->Destroy(); 709254721Semaste target.Clear(); 710254721Semaste const bool mandatory = true; 711254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 712254721Semaste } 713254721Semaste } 714254721Semaste 715254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 716254721Semaste if (log) 717254721Semaste { 718254721Semaste log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result); 719254721Semaste } 720254721Semaste 721254721Semaste return result; 722254721Semaste} 723254721SemasteSBTarget 724254721SemasteSBDebugger::GetTargetAtIndex (uint32_t idx) 725254721Semaste{ 726254721Semaste SBTarget sb_target; 727254721Semaste if (m_opaque_sp) 728254721Semaste { 729254721Semaste // No need to lock, the target list is thread safe 730254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx)); 731254721Semaste } 732254721Semaste return sb_target; 733254721Semaste} 734254721Semaste 735254721Semasteuint32_t 736254721SemasteSBDebugger::GetIndexOfTarget (lldb::SBTarget target) 737254721Semaste{ 738254721Semaste 739254721Semaste lldb::TargetSP target_sp = target.GetSP(); 740254721Semaste if (!target_sp) 741254721Semaste return UINT32_MAX; 742254721Semaste 743254721Semaste if (!m_opaque_sp) 744254721Semaste return UINT32_MAX; 745254721Semaste 746254721Semaste return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP()); 747254721Semaste} 748254721Semaste 749254721SemasteSBTarget 750263363SemasteSBDebugger::FindTargetWithProcessID (lldb::pid_t pid) 751254721Semaste{ 752254721Semaste SBTarget sb_target; 753254721Semaste if (m_opaque_sp) 754254721Semaste { 755254721Semaste // No need to lock, the target list is thread safe 756254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid)); 757254721Semaste } 758254721Semaste return sb_target; 759254721Semaste} 760254721Semaste 761254721SemasteSBTarget 762254721SemasteSBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name) 763254721Semaste{ 764254721Semaste SBTarget sb_target; 765254721Semaste if (m_opaque_sp && filename && filename[0]) 766254721Semaste { 767254721Semaste // No need to lock, the target list is thread safe 768254721Semaste ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get()); 769254721Semaste TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL)); 770254721Semaste sb_target.SetSP (target_sp); 771254721Semaste } 772254721Semaste return sb_target; 773254721Semaste} 774254721Semaste 775254721SemasteSBTarget 776254721SemasteSBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp) 777254721Semaste{ 778254721Semaste SBTarget sb_target; 779254721Semaste if (m_opaque_sp) 780254721Semaste { 781254721Semaste // No need to lock, the target list is thread safe 782254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get())); 783254721Semaste } 784254721Semaste return sb_target; 785254721Semaste} 786254721Semaste 787254721Semaste 788254721Semasteuint32_t 789254721SemasteSBDebugger::GetNumTargets () 790254721Semaste{ 791254721Semaste if (m_opaque_sp) 792254721Semaste { 793254721Semaste // No need to lock, the target list is thread safe 794254721Semaste return m_opaque_sp->GetTargetList().GetNumTargets (); 795254721Semaste } 796254721Semaste return 0; 797254721Semaste} 798254721Semaste 799254721SemasteSBTarget 800254721SemasteSBDebugger::GetSelectedTarget () 801254721Semaste{ 802254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 803254721Semaste 804254721Semaste SBTarget sb_target; 805254721Semaste TargetSP target_sp; 806254721Semaste if (m_opaque_sp) 807254721Semaste { 808254721Semaste // No need to lock, the target list is thread safe 809254721Semaste target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget (); 810254721Semaste sb_target.SetSP (target_sp); 811254721Semaste } 812254721Semaste 813254721Semaste if (log) 814254721Semaste { 815254721Semaste SBStream sstr; 816254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 817254721Semaste log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 818254721Semaste target_sp.get(), sstr.GetData()); 819254721Semaste } 820254721Semaste 821254721Semaste return sb_target; 822254721Semaste} 823254721Semaste 824254721Semastevoid 825254721SemasteSBDebugger::SetSelectedTarget (SBTarget &sb_target) 826254721Semaste{ 827254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 828254721Semaste 829254721Semaste TargetSP target_sp (sb_target.GetSP()); 830254721Semaste if (m_opaque_sp) 831254721Semaste { 832254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 833254721Semaste } 834254721Semaste if (log) 835254721Semaste { 836254721Semaste SBStream sstr; 837254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 838254721Semaste log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 839254721Semaste target_sp.get(), sstr.GetData()); 840254721Semaste } 841254721Semaste} 842254721Semaste 843263367SemasteSBPlatform 844263367SemasteSBDebugger::GetSelectedPlatform() 845263367Semaste{ 846263367Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 847263367Semaste 848263367Semaste SBPlatform sb_platform; 849263367Semaste DebuggerSP debugger_sp(m_opaque_sp); 850263367Semaste if (debugger_sp) 851263367Semaste { 852263367Semaste sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); 853263367Semaste } 854263367Semaste if (log) 855263367Semaste { 856263367Semaste log->Printf ("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", m_opaque_sp.get(), 857263367Semaste sb_platform.GetSP().get(), sb_platform.GetName()); 858263367Semaste } 859263367Semaste return sb_platform; 860263367Semaste} 861263367Semaste 862254721Semastevoid 863263367SemasteSBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) 864263367Semaste{ 865263367Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 866263367Semaste 867263367Semaste DebuggerSP debugger_sp(m_opaque_sp); 868263367Semaste if (debugger_sp) 869263367Semaste { 870263367Semaste debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); 871263367Semaste } 872263367Semaste if (log) 873263367Semaste { 874263367Semaste log->Printf ("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", m_opaque_sp.get(), 875263367Semaste sb_platform.GetSP().get(), sb_platform.GetName()); 876263367Semaste } 877263367Semaste} 878263367Semaste 879263367Semastevoid 880254721SemasteSBDebugger::DispatchInput (void* baton, const void *data, size_t data_len) 881254721Semaste{ 882254721Semaste DispatchInput (data,data_len); 883254721Semaste} 884254721Semaste 885254721Semastevoid 886254721SemasteSBDebugger::DispatchInput (const void *data, size_t data_len) 887254721Semaste{ 888254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 889254721Semaste 890254721Semaste if (log) 891254721Semaste log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")", 892254721Semaste m_opaque_sp.get(), 893254721Semaste (int) data_len, 894254721Semaste (const char *) data, 895254721Semaste (uint64_t)data_len); 896254721Semaste 897254721Semaste if (m_opaque_sp) 898254721Semaste m_opaque_sp->DispatchInput ((const char *) data, data_len); 899254721Semaste} 900254721Semaste 901254721Semastevoid 902254721SemasteSBDebugger::DispatchInputInterrupt () 903254721Semaste{ 904254721Semaste if (m_opaque_sp) 905254721Semaste m_opaque_sp->DispatchInputInterrupt (); 906254721Semaste} 907254721Semaste 908254721Semastevoid 909254721SemasteSBDebugger::DispatchInputEndOfFile () 910254721Semaste{ 911254721Semaste if (m_opaque_sp) 912254721Semaste m_opaque_sp->DispatchInputEndOfFile (); 913254721Semaste} 914254721Semaste 915254721Semastebool 916254721SemasteSBDebugger::InputReaderIsTopReader (const lldb::SBInputReader &reader) 917254721Semaste{ 918254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 919254721Semaste 920254721Semaste if (log) 921254721Semaste log->Printf ("SBDebugger(%p)::InputReaderIsTopReader (SBInputReader(%p))", m_opaque_sp.get(), &reader); 922254721Semaste 923254721Semaste if (m_opaque_sp && reader.IsValid()) 924254721Semaste { 925254721Semaste InputReaderSP reader_sp (*reader); 926254721Semaste return m_opaque_sp->InputReaderIsTopReader (reader_sp); 927254721Semaste } 928254721Semaste 929254721Semaste return false; 930254721Semaste} 931254721Semaste 932254721Semaste 933254721Semastevoid 934254721SemasteSBDebugger::PushInputReader (SBInputReader &reader) 935254721Semaste{ 936254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 937254721Semaste 938254721Semaste if (log) 939254721Semaste log->Printf ("SBDebugger(%p)::PushInputReader (SBInputReader(%p))", m_opaque_sp.get(), &reader); 940254721Semaste 941254721Semaste if (m_opaque_sp && reader.IsValid()) 942254721Semaste { 943254721Semaste TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 944254721Semaste Mutex::Locker api_locker; 945254721Semaste if (target_sp) 946254721Semaste api_locker.Lock(target_sp->GetAPIMutex()); 947254721Semaste InputReaderSP reader_sp(*reader); 948254721Semaste m_opaque_sp->PushInputReader (reader_sp); 949254721Semaste } 950254721Semaste} 951254721Semaste 952254721Semastevoid 953254721SemasteSBDebugger::NotifyTopInputReader (InputReaderAction notification) 954254721Semaste{ 955254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 956254721Semaste 957254721Semaste if (log) 958254721Semaste log->Printf ("SBDebugger(%p)::NotifyTopInputReader (%d)", m_opaque_sp.get(), notification); 959254721Semaste 960254721Semaste if (m_opaque_sp) 961254721Semaste m_opaque_sp->NotifyTopInputReader (notification); 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; 1053254721Semaste string_list.SplitIntoLines(value_str.c_str(), value_str.size()); 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