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 10296417Sdim// C Includes 11296417Sdim// C++ Includes 12296417Sdim// Other libraries and framework includes 13296417Sdim// Project includes 14254721Semaste#include "lldb/API/SBDebugger.h" 15254721Semaste 16254721Semaste#include "lldb/lldb-private.h" 17254721Semaste 18288943Sdim#include "lldb/API/SystemInitializerFull.h" 19254721Semaste#include "lldb/API/SBListener.h" 20254721Semaste#include "lldb/API/SBBroadcaster.h" 21254721Semaste#include "lldb/API/SBCommandInterpreter.h" 22254721Semaste#include "lldb/API/SBCommandReturnObject.h" 23254721Semaste#include "lldb/API/SBError.h" 24254721Semaste#include "lldb/API/SBEvent.h" 25254721Semaste#include "lldb/API/SBFrame.h" 26254721Semaste#include "lldb/API/SBProcess.h" 27254721Semaste#include "lldb/API/SBSourceManager.h" 28254721Semaste#include "lldb/API/SBStream.h" 29254721Semaste#include "lldb/API/SBStringList.h" 30254721Semaste#include "lldb/API/SBTarget.h" 31254721Semaste#include "lldb/API/SBThread.h" 32254721Semaste#include "lldb/API/SBTypeCategory.h" 33254721Semaste#include "lldb/API/SBTypeFormat.h" 34254721Semaste#include "lldb/API/SBTypeFilter.h" 35254721Semaste#include "lldb/API/SBTypeNameSpecifier.h" 36254721Semaste#include "lldb/API/SBTypeSummary.h" 37254721Semaste#include "lldb/API/SBTypeSynthetic.h" 38254721Semaste 39254721Semaste#include "lldb/Core/Debugger.h" 40254721Semaste#include "lldb/Core/State.h" 41262528Semaste#include "lldb/Core/StreamFile.h" 42254721Semaste#include "lldb/DataFormatters/DataVisualization.h" 43288943Sdim#include "lldb/Initialization/SystemLifetimeManager.h" 44254721Semaste#include "lldb/Interpreter/Args.h" 45254721Semaste#include "lldb/Interpreter/CommandInterpreter.h" 46254721Semaste#include "lldb/Interpreter/OptionGroupPlatform.h" 47254721Semaste#include "lldb/Target/Process.h" 48254721Semaste#include "lldb/Target/TargetList.h" 49254721Semaste 50296417Sdim#include "llvm/ADT/STLExtras.h" 51288943Sdim#include "llvm/Support/ManagedStatic.h" 52276479Sdim#include "llvm/Support/DynamicLibrary.h" 53276479Sdim 54254721Semasteusing namespace lldb; 55254721Semasteusing namespace lldb_private; 56254721Semaste 57276479Sdimstatic llvm::sys::DynamicLibrary 58258884SemasteLoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error) 59258884Semaste{ 60276479Sdim llvm::sys::DynamicLibrary dynlib = llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str()); 61276479Sdim if (dynlib.isValid()) 62258884Semaste { 63258884Semaste typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger); 64258884Semaste 65258884Semaste lldb::SBDebugger debugger_sb(debugger_sp); 66258884Semaste // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function. 67258884Semaste // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays 68276479Sdim LLDBCommandPluginInit init_func = (LLDBCommandPluginInit)dynlib.getAddressOfSymbol("_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); 69258884Semaste if (init_func) 70258884Semaste { 71258884Semaste if (init_func(debugger_sb)) 72276479Sdim return dynlib; 73258884Semaste else 74258884Semaste error.SetErrorString("plug-in refused to load (lldb::PluginInitialize(lldb::SBDebugger) returned false)"); 75258884Semaste } 76258884Semaste else 77258884Semaste { 78258884Semaste error.SetErrorString("plug-in is missing the required initialization: lldb::PluginInitialize(lldb::SBDebugger)"); 79258884Semaste } 80258884Semaste } 81258884Semaste else 82258884Semaste { 83258884Semaste if (spec.Exists()) 84258884Semaste error.SetErrorString("this file does not represent a loadable dylib"); 85258884Semaste else 86258884Semaste error.SetErrorString("no such file"); 87258884Semaste } 88276479Sdim return llvm::sys::DynamicLibrary(); 89258884Semaste} 90258884Semaste 91288943Sdimstatic llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime; 92288943Sdim 93288943SdimSBError 94288943SdimSBInputReader::Initialize(lldb::SBDebugger &sb_debugger, 95288943Sdim unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, char const *, 96288943Sdim unsigned long), 97288943Sdim void *, lldb::InputReaderGranularity, char const *, char const *, bool) 98288943Sdim{ 99288943Sdim return SBError(); 100288943Sdim} 101288943Sdim 102254721Semastevoid 103288943SdimSBInputReader::SetIsDone(bool) 104288943Sdim{ 105288943Sdim} 106296417Sdim 107288943Sdimbool 108288943SdimSBInputReader::IsActive() const 109288943Sdim{ 110288943Sdim return false; 111288943Sdim} 112288943Sdim 113296417SdimSBDebugger::SBDebugger() = default; 114296417Sdim 115296417SdimSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : 116296417Sdim m_opaque_sp(debugger_sp) 117296417Sdim{ 118296417Sdim} 119296417Sdim 120296417SdimSBDebugger::SBDebugger(const SBDebugger &rhs) : 121296417Sdim m_opaque_sp (rhs.m_opaque_sp) 122296417Sdim{ 123296417Sdim} 124296417Sdim 125296417SdimSBDebugger::~SBDebugger() = default; 126296417Sdim 127296417SdimSBDebugger & 128296417SdimSBDebugger::operator = (const SBDebugger &rhs) 129296417Sdim{ 130296417Sdim if (this != &rhs) 131296417Sdim { 132296417Sdim m_opaque_sp = rhs.m_opaque_sp; 133296417Sdim } 134296417Sdim return *this; 135296417Sdim} 136296417Sdim 137288943Sdimvoid 138254721SemasteSBDebugger::Initialize () 139254721Semaste{ 140254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 141254721Semaste 142254721Semaste if (log) 143254721Semaste log->Printf ("SBDebugger::Initialize ()"); 144254721Semaste 145288943Sdim g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(), LoadPlugin); 146254721Semaste} 147254721Semaste 148254721Semastevoid 149254721SemasteSBDebugger::Terminate () 150254721Semaste{ 151288943Sdim g_debugger_lifetime->Terminate(); 152254721Semaste} 153254721Semaste 154254721Semastevoid 155254721SemasteSBDebugger::Clear () 156254721Semaste{ 157254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 158254721Semaste 159254721Semaste if (log) 160276479Sdim log->Printf ("SBDebugger(%p)::Clear ()", 161276479Sdim static_cast<void*>(m_opaque_sp.get())); 162276479Sdim 163254721Semaste if (m_opaque_sp) 164262528Semaste m_opaque_sp->ClearIOHandlers (); 165254721Semaste 166254721Semaste m_opaque_sp.reset(); 167254721Semaste} 168254721Semaste 169254721SemasteSBDebugger 170254721SemasteSBDebugger::Create() 171254721Semaste{ 172296417Sdim return SBDebugger::Create(false, nullptr, nullptr); 173254721Semaste} 174254721Semaste 175254721SemasteSBDebugger 176254721SemasteSBDebugger::Create(bool source_init_files) 177254721Semaste{ 178296417Sdim return SBDebugger::Create (source_init_files, nullptr, nullptr); 179254721Semaste} 180254721Semaste 181254721SemasteSBDebugger 182254721SemasteSBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton) 183254721Semaste 184254721Semaste{ 185254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 186254721Semaste 187254721Semaste SBDebugger debugger; 188276479Sdim 189276479Sdim // Currently we have issues if this function is called simultaneously on two different 190276479Sdim // threads. The issues mainly revolve around the fact that the lldb_private::FormatManager 191276479Sdim // uses global collections and having two threads parsing the .lldbinit files can cause 192276479Sdim // mayhem. So to get around this for now we need to use a mutex to prevent bad things 193276479Sdim // from happening. 194276479Sdim static Mutex g_mutex(Mutex::eMutexTypeRecursive); 195276479Sdim Mutex::Locker locker(g_mutex); 196276479Sdim 197254721Semaste debugger.reset(Debugger::CreateInstance(callback, baton)); 198254721Semaste 199254721Semaste if (log) 200254721Semaste { 201254721Semaste SBStream sstr; 202254721Semaste debugger.GetDescription (sstr); 203276479Sdim log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", 204276479Sdim static_cast<void*>(debugger.m_opaque_sp.get()), 205276479Sdim sstr.GetData()); 206254721Semaste } 207254721Semaste 208254721Semaste SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 209254721Semaste if (source_init_files) 210254721Semaste { 211254721Semaste interp.get()->SkipLLDBInitFiles(false); 212254721Semaste interp.get()->SkipAppInitFiles (false); 213254721Semaste SBCommandReturnObject result; 214254721Semaste interp.SourceInitFileInHomeDirectory(result); 215254721Semaste } 216254721Semaste else 217254721Semaste { 218254721Semaste interp.get()->SkipLLDBInitFiles(true); 219254721Semaste interp.get()->SkipAppInitFiles (true); 220254721Semaste } 221254721Semaste return debugger; 222254721Semaste} 223254721Semaste 224254721Semastevoid 225254721SemasteSBDebugger::Destroy (SBDebugger &debugger) 226254721Semaste{ 227254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 228276479Sdim 229254721Semaste if (log) 230254721Semaste { 231254721Semaste SBStream sstr; 232254721Semaste debugger.GetDescription (sstr); 233276479Sdim log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", 234276479Sdim static_cast<void*>(debugger.m_opaque_sp.get()), 235276479Sdim sstr.GetData()); 236254721Semaste } 237276479Sdim 238254721Semaste Debugger::Destroy (debugger.m_opaque_sp); 239276479Sdim 240296417Sdim if (debugger.m_opaque_sp.get() != nullptr) 241254721Semaste debugger.m_opaque_sp.reset(); 242254721Semaste} 243254721Semaste 244254721Semastevoid 245254721SemasteSBDebugger::MemoryPressureDetected () 246254721Semaste{ 247254721Semaste // Since this function can be call asynchronously, we allow it to be 248254721Semaste // non-mandatory. We have seen deadlocks with this function when called 249254721Semaste // so we need to safeguard against this until we can determine what is 250254721Semaste // causing the deadlocks. 251254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 252254721Semaste 253254721Semaste const bool mandatory = false; 254254721Semaste if (log) 255254721Semaste { 256254721Semaste log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory); 257254721Semaste } 258254721Semaste 259254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 260254721Semaste} 261254721Semaste 262254721Semastebool 263254721SemasteSBDebugger::IsValid() const 264254721Semaste{ 265296417Sdim return m_opaque_sp.get() != nullptr; 266254721Semaste} 267254721Semaste 268254721Semastevoid 269254721SemasteSBDebugger::SetAsync (bool b) 270254721Semaste{ 271254721Semaste if (m_opaque_sp) 272254721Semaste m_opaque_sp->SetAsyncExecution(b); 273254721Semaste} 274254721Semaste 275254721Semastebool 276296417SdimSBDebugger::GetAsync() 277254721Semaste{ 278296417Sdim return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false); 279254721Semaste} 280254721Semaste 281254721Semastevoid 282254721SemasteSBDebugger::SkipLLDBInitFiles (bool b) 283254721Semaste{ 284254721Semaste if (m_opaque_sp) 285254721Semaste m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b); 286254721Semaste} 287254721Semaste 288254721Semastevoid 289254721SemasteSBDebugger::SkipAppInitFiles (bool b) 290254721Semaste{ 291254721Semaste if (m_opaque_sp) 292254721Semaste m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b); 293254721Semaste} 294254721Semaste 295254721Semaste// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users 296254721Semaste// trying to switch modes in the middle of a debugging session. 297254721Semastevoid 298254721SemasteSBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership) 299254721Semaste{ 300254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 301254721Semaste 302254721Semaste if (log) 303276479Sdim log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", 304276479Sdim static_cast<void*>(m_opaque_sp.get()), 305276479Sdim static_cast<void*>(fh), transfer_ownership); 306254721Semaste 307254721Semaste if (m_opaque_sp) 308254721Semaste m_opaque_sp->SetInputFileHandle (fh, transfer_ownership); 309254721Semaste} 310254721Semaste 311254721Semastevoid 312254721SemasteSBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership) 313254721Semaste{ 314254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 315254721Semaste 316254721Semaste 317254721Semaste if (log) 318276479Sdim log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", 319276479Sdim static_cast<void*>(m_opaque_sp.get()), 320276479Sdim static_cast<void*>(fh), transfer_ownership); 321254721Semaste 322254721Semaste if (m_opaque_sp) 323254721Semaste m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership); 324254721Semaste} 325254721Semaste 326254721Semastevoid 327254721SemasteSBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership) 328254721Semaste{ 329254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 330254721Semaste 331254721Semaste 332254721Semaste if (log) 333276479Sdim log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", 334276479Sdim static_cast<void*>(m_opaque_sp.get()), 335276479Sdim static_cast<void*>(fh), transfer_ownership); 336254721Semaste 337254721Semaste if (m_opaque_sp) 338254721Semaste m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership); 339254721Semaste} 340254721Semaste 341254721SemasteFILE * 342254721SemasteSBDebugger::GetInputFileHandle () 343254721Semaste{ 344254721Semaste if (m_opaque_sp) 345262528Semaste { 346262528Semaste StreamFileSP stream_file_sp (m_opaque_sp->GetInputFile()); 347262528Semaste if (stream_file_sp) 348262528Semaste return stream_file_sp->GetFile().GetStream(); 349262528Semaste } 350296417Sdim return nullptr; 351254721Semaste} 352254721Semaste 353254721SemasteFILE * 354254721SemasteSBDebugger::GetOutputFileHandle () 355254721Semaste{ 356254721Semaste if (m_opaque_sp) 357262528Semaste { 358262528Semaste StreamFileSP stream_file_sp (m_opaque_sp->GetOutputFile()); 359262528Semaste if (stream_file_sp) 360262528Semaste return stream_file_sp->GetFile().GetStream(); 361262528Semaste } 362296417Sdim return nullptr; 363254721Semaste} 364254721Semaste 365254721SemasteFILE * 366254721SemasteSBDebugger::GetErrorFileHandle () 367254721Semaste{ 368254721Semaste if (m_opaque_sp) 369296417Sdim { 370296417Sdim StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile()); 371296417Sdim if (stream_file_sp) 372296417Sdim return stream_file_sp->GetFile().GetStream(); 373296417Sdim } 374296417Sdim return nullptr; 375254721Semaste} 376254721Semaste 377254721Semastevoid 378254721SemasteSBDebugger::SaveInputTerminalState() 379254721Semaste{ 380254721Semaste if (m_opaque_sp) 381254721Semaste m_opaque_sp->SaveInputTerminalState(); 382254721Semaste} 383254721Semaste 384254721Semastevoid 385254721SemasteSBDebugger::RestoreInputTerminalState() 386254721Semaste{ 387254721Semaste if (m_opaque_sp) 388254721Semaste m_opaque_sp->RestoreInputTerminalState(); 389254721Semaste 390254721Semaste} 391254721SemasteSBCommandInterpreter 392254721SemasteSBDebugger::GetCommandInterpreter () 393254721Semaste{ 394254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 395254721Semaste 396254721Semaste SBCommandInterpreter sb_interpreter; 397254721Semaste if (m_opaque_sp) 398254721Semaste sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter()); 399254721Semaste 400254721Semaste if (log) 401276479Sdim log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)", 402276479Sdim static_cast<void*>(m_opaque_sp.get()), 403276479Sdim static_cast<void*>(sb_interpreter.get())); 404254721Semaste 405254721Semaste return sb_interpreter; 406254721Semaste} 407254721Semaste 408254721Semastevoid 409254721SemasteSBDebugger::HandleCommand (const char *command) 410254721Semaste{ 411254721Semaste if (m_opaque_sp) 412254721Semaste { 413254721Semaste TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 414254721Semaste Mutex::Locker api_locker; 415254721Semaste if (target_sp) 416254721Semaste api_locker.Lock(target_sp->GetAPIMutex()); 417254721Semaste 418254721Semaste SBCommandInterpreter sb_interpreter(GetCommandInterpreter ()); 419254721Semaste SBCommandReturnObject result; 420254721Semaste 421254721Semaste sb_interpreter.HandleCommand (command, result, false); 422254721Semaste 423296417Sdim if (GetErrorFileHandle() != nullptr) 424254721Semaste result.PutError (GetErrorFileHandle()); 425296417Sdim if (GetOutputFileHandle() != nullptr) 426254721Semaste result.PutOutput (GetOutputFileHandle()); 427254721Semaste 428296417Sdim if (!m_opaque_sp->GetAsyncExecution()) 429254721Semaste { 430254721Semaste SBProcess process(GetCommandInterpreter().GetProcess ()); 431254721Semaste ProcessSP process_sp (process.GetSP()); 432254721Semaste if (process_sp) 433254721Semaste { 434254721Semaste EventSP event_sp; 435254721Semaste Listener &lldb_listener = m_opaque_sp->GetListener(); 436254721Semaste while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp)) 437254721Semaste { 438254721Semaste SBEvent event(event_sp); 439254721Semaste HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); 440254721Semaste } 441254721Semaste } 442254721Semaste } 443254721Semaste } 444254721Semaste} 445254721Semaste 446254721SemasteSBListener 447254721SemasteSBDebugger::GetListener () 448254721Semaste{ 449254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 450254721Semaste 451254721Semaste SBListener sb_listener; 452254721Semaste if (m_opaque_sp) 453254721Semaste sb_listener.reset(&m_opaque_sp->GetListener(), false); 454254721Semaste 455254721Semaste if (log) 456276479Sdim log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", 457276479Sdim static_cast<void*>(m_opaque_sp.get()), 458276479Sdim static_cast<void*>(sb_listener.get())); 459254721Semaste 460254721Semaste return sb_listener; 461254721Semaste} 462254721Semaste 463254721Semastevoid 464254721SemasteSBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) 465254721Semaste{ 466254721Semaste if (!process.IsValid()) 467254721Semaste return; 468254721Semaste 469254721Semaste TargetSP target_sp (process.GetTarget().GetSP()); 470254721Semaste if (!target_sp) 471254721Semaste return; 472254721Semaste 473254721Semaste const uint32_t event_type = event.GetType(); 474254721Semaste char stdio_buffer[1024]; 475254721Semaste size_t len; 476254721Semaste 477254721Semaste Mutex::Locker api_locker (target_sp->GetAPIMutex()); 478254721Semaste 479254721Semaste if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) 480254721Semaste { 481254721Semaste // Drain stdout when we stop just in case we have any bytes 482254721Semaste while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) 483296417Sdim if (out != nullptr) 484254721Semaste ::fwrite (stdio_buffer, 1, len, out); 485254721Semaste } 486254721Semaste 487254721Semaste if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) 488254721Semaste { 489254721Semaste // Drain stderr when we stop just in case we have any bytes 490254721Semaste while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) 491296417Sdim if (err != nullptr) 492254721Semaste ::fwrite (stdio_buffer, 1, len, err); 493254721Semaste } 494254721Semaste 495254721Semaste if (event_type & Process::eBroadcastBitStateChanged) 496254721Semaste { 497254721Semaste StateType event_state = SBProcess::GetStateFromEvent (event); 498254721Semaste 499254721Semaste if (event_state == eStateInvalid) 500254721Semaste return; 501254721Semaste 502254721Semaste bool is_stopped = StateIsStoppedState (event_state); 503254721Semaste if (!is_stopped) 504254721Semaste process.ReportEventState (event, out); 505254721Semaste } 506254721Semaste} 507254721Semaste 508254721SemasteSBSourceManager 509254721SemasteSBDebugger::GetSourceManager () 510254721Semaste{ 511254721Semaste SBSourceManager sb_source_manager (*this); 512254721Semaste return sb_source_manager; 513254721Semaste} 514254721Semaste 515254721Semastebool 516254721SemasteSBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len) 517254721Semaste{ 518254721Semaste if (arch_name && arch_name_len) 519254721Semaste { 520254721Semaste ArchSpec default_arch = Target::GetDefaultArchitecture (); 521254721Semaste 522254721Semaste if (default_arch.IsValid()) 523254721Semaste { 524254721Semaste const std::string &triple_str = default_arch.GetTriple().str(); 525254721Semaste if (!triple_str.empty()) 526254721Semaste ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str()); 527254721Semaste else 528254721Semaste ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName()); 529254721Semaste return true; 530254721Semaste } 531254721Semaste } 532254721Semaste if (arch_name && arch_name_len) 533254721Semaste arch_name[0] = '\0'; 534254721Semaste return false; 535254721Semaste} 536254721Semaste 537254721Semastebool 538254721SemasteSBDebugger::SetDefaultArchitecture (const char *arch_name) 539254721Semaste{ 540254721Semaste if (arch_name) 541254721Semaste { 542254721Semaste ArchSpec arch (arch_name); 543254721Semaste if (arch.IsValid()) 544254721Semaste { 545254721Semaste Target::SetDefaultArchitecture (arch); 546254721Semaste return true; 547254721Semaste } 548254721Semaste } 549254721Semaste return false; 550254721Semaste} 551254721Semaste 552254721SemasteScriptLanguage 553296417SdimSBDebugger::GetScriptingLanguage(const char *script_language_name) 554254721Semaste{ 555296417Sdim return Args::StringToScriptLanguage(script_language_name, 556296417Sdim eScriptLanguageDefault, 557296417Sdim nullptr); 558254721Semaste} 559254721Semaste 560254721Semasteconst char * 561254721SemasteSBDebugger::GetVersionString () 562254721Semaste{ 563258054Semaste return lldb_private::GetVersion(); 564254721Semaste} 565254721Semaste 566254721Semasteconst char * 567254721SemasteSBDebugger::StateAsCString (StateType state) 568254721Semaste{ 569254721Semaste return lldb_private::StateAsCString (state); 570254721Semaste} 571254721Semaste 572254721Semastebool 573254721SemasteSBDebugger::StateIsRunningState (StateType state) 574254721Semaste{ 575254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 576254721Semaste 577254721Semaste const bool result = lldb_private::StateIsRunningState (state); 578254721Semaste if (log) 579254721Semaste log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", 580254721Semaste StateAsCString (state), result); 581254721Semaste 582254721Semaste return result; 583254721Semaste} 584254721Semaste 585254721Semastebool 586254721SemasteSBDebugger::StateIsStoppedState (StateType state) 587254721Semaste{ 588254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 589254721Semaste 590254721Semaste const bool result = lldb_private::StateIsStoppedState (state, false); 591254721Semaste if (log) 592254721Semaste log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", 593254721Semaste StateAsCString (state), result); 594254721Semaste 595254721Semaste return result; 596254721Semaste} 597254721Semaste 598254721Semastelldb::SBTarget 599254721SemasteSBDebugger::CreateTarget (const char *filename, 600254721Semaste const char *target_triple, 601254721Semaste const char *platform_name, 602254721Semaste bool add_dependent_modules, 603254721Semaste lldb::SBError& sb_error) 604254721Semaste{ 605254721Semaste SBTarget sb_target; 606254721Semaste TargetSP target_sp; 607254721Semaste if (m_opaque_sp) 608254721Semaste { 609254721Semaste sb_error.Clear(); 610254721Semaste OptionGroupPlatform platform_options (false); 611254721Semaste platform_options.SetPlatformName (platform_name); 612276479Sdim 613254721Semaste sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 614254721Semaste filename, 615254721Semaste target_triple, 616254721Semaste add_dependent_modules, 617254721Semaste &platform_options, 618254721Semaste target_sp); 619276479Sdim 620254721Semaste if (sb_error.Success()) 621254721Semaste sb_target.SetSP (target_sp); 622254721Semaste } 623254721Semaste else 624254721Semaste { 625296417Sdim sb_error.SetErrorString("invalid debugger"); 626254721Semaste } 627276479Sdim 628254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 629254721Semaste if (log) 630276479Sdim log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)", 631276479Sdim static_cast<void*>(m_opaque_sp.get()), filename, 632276479Sdim target_triple, platform_name, add_dependent_modules, 633276479Sdim sb_error.GetCString(), static_cast<void*>(target_sp.get())); 634276479Sdim 635254721Semaste return sb_target; 636254721Semaste} 637254721Semaste 638254721SemasteSBTarget 639254721SemasteSBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename, 640254721Semaste const char *target_triple) 641254721Semaste{ 642254721Semaste SBTarget sb_target; 643254721Semaste TargetSP target_sp; 644254721Semaste if (m_opaque_sp) 645254721Semaste { 646254721Semaste const bool add_dependent_modules = true; 647296417Sdim Error error (m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, 648296417Sdim filename, 649296417Sdim target_triple, 650296417Sdim add_dependent_modules, 651296417Sdim nullptr, 652296417Sdim target_sp)); 653254721Semaste sb_target.SetSP (target_sp); 654254721Semaste } 655276479Sdim 656254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 657254721Semaste if (log) 658276479Sdim log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)", 659276479Sdim static_cast<void*>(m_opaque_sp.get()), filename, 660276479Sdim target_triple, static_cast<void*>(target_sp.get())); 661254721Semaste 662254721Semaste return sb_target; 663254721Semaste} 664254721Semaste 665254721SemasteSBTarget 666254721SemasteSBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr) 667254721Semaste{ 668254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 669254721Semaste 670254721Semaste SBTarget sb_target; 671254721Semaste TargetSP target_sp; 672254721Semaste if (m_opaque_sp) 673254721Semaste { 674254721Semaste Error error; 675254721Semaste const bool add_dependent_modules = true; 676254721Semaste 677296417Sdim error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, 678296417Sdim filename, 679296417Sdim arch_cstr, 680296417Sdim add_dependent_modules, 681296417Sdim nullptr, 682296417Sdim target_sp); 683254721Semaste 684254721Semaste if (error.Success()) 685254721Semaste { 686254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 687254721Semaste sb_target.SetSP (target_sp); 688254721Semaste } 689254721Semaste } 690254721Semaste 691254721Semaste if (log) 692276479Sdim log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)", 693276479Sdim static_cast<void*>(m_opaque_sp.get()), filename, arch_cstr, 694276479Sdim static_cast<void*>(target_sp.get())); 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 Error error; 707254721Semaste const bool add_dependent_modules = true; 708296417Sdim error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, 709296417Sdim filename, 710296417Sdim nullptr, 711296417Sdim add_dependent_modules, 712296417Sdim nullptr, 713296417Sdim target_sp); 714254721Semaste 715254721Semaste if (error.Success()) 716254721Semaste { 717254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 718254721Semaste sb_target.SetSP (target_sp); 719254721Semaste } 720254721Semaste } 721254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 722254721Semaste if (log) 723276479Sdim log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 724276479Sdim static_cast<void*>(m_opaque_sp.get()), filename, 725276479Sdim static_cast<void*>(target_sp.get())); 726254721Semaste return sb_target; 727254721Semaste} 728254721Semaste 729254721Semastebool 730254721SemasteSBDebugger::DeleteTarget (lldb::SBTarget &target) 731254721Semaste{ 732254721Semaste bool result = false; 733254721Semaste if (m_opaque_sp) 734254721Semaste { 735254721Semaste TargetSP target_sp(target.GetSP()); 736254721Semaste if (target_sp) 737254721Semaste { 738254721Semaste // No need to lock, the target list is thread safe 739254721Semaste result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp); 740254721Semaste target_sp->Destroy(); 741254721Semaste target.Clear(); 742254721Semaste const bool mandatory = true; 743254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 744254721Semaste } 745254721Semaste } 746254721Semaste 747254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 748254721Semaste if (log) 749276479Sdim log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", 750276479Sdim static_cast<void*>(m_opaque_sp.get()), 751276479Sdim static_cast<void*>(target.m_opaque_sp.get()), result); 752254721Semaste 753254721Semaste return result; 754254721Semaste} 755296417Sdim 756254721SemasteSBTarget 757254721SemasteSBDebugger::GetTargetAtIndex (uint32_t idx) 758254721Semaste{ 759254721Semaste SBTarget sb_target; 760254721Semaste if (m_opaque_sp) 761254721Semaste { 762254721Semaste // No need to lock, the target list is thread safe 763254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx)); 764254721Semaste } 765254721Semaste return sb_target; 766254721Semaste} 767254721Semaste 768254721Semasteuint32_t 769254721SemasteSBDebugger::GetIndexOfTarget (lldb::SBTarget target) 770254721Semaste{ 771254721Semaste 772254721Semaste lldb::TargetSP target_sp = target.GetSP(); 773254721Semaste if (!target_sp) 774254721Semaste return UINT32_MAX; 775254721Semaste 776254721Semaste if (!m_opaque_sp) 777254721Semaste return UINT32_MAX; 778254721Semaste 779254721Semaste return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP()); 780254721Semaste} 781254721Semaste 782254721SemasteSBTarget 783258054SemasteSBDebugger::FindTargetWithProcessID (lldb::pid_t pid) 784254721Semaste{ 785254721Semaste SBTarget sb_target; 786254721Semaste if (m_opaque_sp) 787254721Semaste { 788254721Semaste // No need to lock, the target list is thread safe 789254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid)); 790254721Semaste } 791254721Semaste return sb_target; 792254721Semaste} 793254721Semaste 794254721SemasteSBTarget 795254721SemasteSBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name) 796254721Semaste{ 797254721Semaste SBTarget sb_target; 798254721Semaste if (m_opaque_sp && filename && filename[0]) 799254721Semaste { 800254721Semaste // No need to lock, the target list is thread safe 801254721Semaste ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get()); 802296417Sdim TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(FileSpec(filename, false), arch_name ? &arch : nullptr)); 803254721Semaste sb_target.SetSP (target_sp); 804254721Semaste } 805254721Semaste return sb_target; 806254721Semaste} 807254721Semaste 808254721SemasteSBTarget 809254721SemasteSBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp) 810254721Semaste{ 811254721Semaste SBTarget sb_target; 812254721Semaste if (m_opaque_sp) 813254721Semaste { 814254721Semaste // No need to lock, the target list is thread safe 815254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get())); 816254721Semaste } 817254721Semaste return sb_target; 818254721Semaste} 819254721Semaste 820254721Semasteuint32_t 821254721SemasteSBDebugger::GetNumTargets () 822254721Semaste{ 823254721Semaste if (m_opaque_sp) 824254721Semaste { 825254721Semaste // No need to lock, the target list is thread safe 826254721Semaste return m_opaque_sp->GetTargetList().GetNumTargets (); 827254721Semaste } 828254721Semaste return 0; 829254721Semaste} 830254721Semaste 831254721SemasteSBTarget 832254721SemasteSBDebugger::GetSelectedTarget () 833254721Semaste{ 834254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 835254721Semaste 836254721Semaste SBTarget sb_target; 837254721Semaste TargetSP target_sp; 838254721Semaste if (m_opaque_sp) 839254721Semaste { 840254721Semaste // No need to lock, the target list is thread safe 841254721Semaste target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget (); 842254721Semaste sb_target.SetSP (target_sp); 843254721Semaste } 844254721Semaste 845254721Semaste if (log) 846254721Semaste { 847254721Semaste SBStream sstr; 848254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 849276479Sdim log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", 850276479Sdim static_cast<void*>(m_opaque_sp.get()), 851276479Sdim static_cast<void*>(target_sp.get()), sstr.GetData()); 852254721Semaste } 853254721Semaste 854254721Semaste return sb_target; 855254721Semaste} 856254721Semaste 857254721Semastevoid 858254721SemasteSBDebugger::SetSelectedTarget (SBTarget &sb_target) 859254721Semaste{ 860254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 861254721Semaste 862254721Semaste TargetSP target_sp (sb_target.GetSP()); 863254721Semaste if (m_opaque_sp) 864254721Semaste { 865254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 866254721Semaste } 867254721Semaste if (log) 868254721Semaste { 869254721Semaste SBStream sstr; 870254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 871276479Sdim log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", 872276479Sdim static_cast<void*>(m_opaque_sp.get()), 873276479Sdim static_cast<void*>(target_sp.get()), sstr.GetData()); 874254721Semaste } 875254721Semaste} 876254721Semaste 877258884SemasteSBPlatform 878258884SemasteSBDebugger::GetSelectedPlatform() 879258884Semaste{ 880258884Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 881258884Semaste 882258884Semaste SBPlatform sb_platform; 883258884Semaste DebuggerSP debugger_sp(m_opaque_sp); 884258884Semaste if (debugger_sp) 885258884Semaste { 886258884Semaste sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); 887258884Semaste } 888258884Semaste if (log) 889276479Sdim log->Printf ("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", 890276479Sdim static_cast<void*>(m_opaque_sp.get()), 891276479Sdim static_cast<void*>(sb_platform.GetSP().get()), 892276479Sdim sb_platform.GetName()); 893258884Semaste return sb_platform; 894258884Semaste} 895258884Semaste 896254721Semastevoid 897258884SemasteSBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) 898258884Semaste{ 899258884Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 900276479Sdim 901258884Semaste DebuggerSP debugger_sp(m_opaque_sp); 902258884Semaste if (debugger_sp) 903258884Semaste { 904258884Semaste debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); 905258884Semaste } 906276479Sdim 907258884Semaste if (log) 908276479Sdim log->Printf ("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", 909276479Sdim static_cast<void*>(m_opaque_sp.get()), 910276479Sdim static_cast<void*>(sb_platform.GetSP().get()), 911276479Sdim sb_platform.GetName()); 912258884Semaste} 913258884Semaste 914258884Semastevoid 915254721SemasteSBDebugger::DispatchInput (void* baton, const void *data, size_t data_len) 916254721Semaste{ 917254721Semaste DispatchInput (data,data_len); 918254721Semaste} 919254721Semaste 920254721Semastevoid 921254721SemasteSBDebugger::DispatchInput (const void *data, size_t data_len) 922254721Semaste{ 923262528Semaste// Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 924262528Semaste// 925262528Semaste// if (log) 926262528Semaste// log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")", 927262528Semaste// m_opaque_sp.get(), 928262528Semaste// (int) data_len, 929262528Semaste// (const char *) data, 930262528Semaste// (uint64_t)data_len); 931262528Semaste// 932262528Semaste// if (m_opaque_sp) 933262528Semaste// m_opaque_sp->DispatchInput ((const char *) data, data_len); 934254721Semaste} 935254721Semaste 936254721Semastevoid 937254721SemasteSBDebugger::DispatchInputInterrupt () 938254721Semaste{ 939254721Semaste if (m_opaque_sp) 940254721Semaste m_opaque_sp->DispatchInputInterrupt (); 941254721Semaste} 942254721Semaste 943254721Semastevoid 944254721SemasteSBDebugger::DispatchInputEndOfFile () 945254721Semaste{ 946254721Semaste if (m_opaque_sp) 947254721Semaste m_opaque_sp->DispatchInputEndOfFile (); 948254721Semaste} 949254721Semaste 950254721Semastevoid 951254721SemasteSBDebugger::PushInputReader (SBInputReader &reader) 952254721Semaste{ 953254721Semaste} 954254721Semaste 955254721Semastevoid 956262528SemasteSBDebugger::RunCommandInterpreter (bool auto_handle_events, 957262528Semaste bool spawn_thread) 958254721Semaste{ 959254721Semaste if (m_opaque_sp) 960280031Sdim { 961280031Sdim CommandInterpreterRunOptions options; 962280031Sdim 963280031Sdim m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(auto_handle_events, 964280031Sdim spawn_thread, 965280031Sdim options); 966280031Sdim } 967254721Semaste} 968254721Semaste 969254721Semastevoid 970280031SdimSBDebugger::RunCommandInterpreter (bool auto_handle_events, 971280031Sdim bool spawn_thread, 972280031Sdim SBCommandInterpreterRunOptions &options, 973280031Sdim int &num_errors, 974280031Sdim bool &quit_requested, 975280031Sdim bool &stopped_for_crash) 976280031Sdim 977280031Sdim{ 978280031Sdim if (m_opaque_sp) 979280031Sdim { 980280031Sdim CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); 981280031Sdim interp.RunCommandInterpreter(auto_handle_events, spawn_thread, options.ref()); 982280031Sdim num_errors = interp.GetNumErrors(); 983280031Sdim quit_requested = interp.GetQuitRequested(); 984280031Sdim stopped_for_crash = interp.GetStoppedForCrash(); 985280031Sdim } 986280031Sdim} 987280031Sdim 988296417SdimSBError 989296417SdimSBDebugger::RunREPL (lldb::LanguageType language, const char *repl_options) 990296417Sdim{ 991296417Sdim SBError error; 992296417Sdim if (m_opaque_sp) 993296417Sdim error.ref() = m_opaque_sp->RunREPL(language, repl_options); 994296417Sdim else 995296417Sdim error.SetErrorString ("invalid debugger"); 996296417Sdim return error; 997296417Sdim} 998296417Sdim 999280031Sdimvoid 1000254721SemasteSBDebugger::reset (const DebuggerSP &debugger_sp) 1001254721Semaste{ 1002254721Semaste m_opaque_sp = debugger_sp; 1003254721Semaste} 1004254721Semaste 1005254721SemasteDebugger * 1006254721SemasteSBDebugger::get () const 1007254721Semaste{ 1008254721Semaste return m_opaque_sp.get(); 1009254721Semaste} 1010254721Semaste 1011254721SemasteDebugger & 1012254721SemasteSBDebugger::ref () const 1013254721Semaste{ 1014254721Semaste assert (m_opaque_sp.get()); 1015254721Semaste return *m_opaque_sp; 1016254721Semaste} 1017254721Semaste 1018254721Semasteconst lldb::DebuggerSP & 1019254721SemasteSBDebugger::get_sp () const 1020254721Semaste{ 1021254721Semaste return m_opaque_sp; 1022254721Semaste} 1023254721Semaste 1024254721SemasteSBDebugger 1025254721SemasteSBDebugger::FindDebuggerWithID (int id) 1026254721Semaste{ 1027254721Semaste // No need to lock, the debugger list is thread safe 1028254721Semaste SBDebugger sb_debugger; 1029254721Semaste DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id); 1030254721Semaste if (debugger_sp) 1031254721Semaste sb_debugger.reset (debugger_sp); 1032254721Semaste return sb_debugger; 1033254721Semaste} 1034254721Semaste 1035254721Semasteconst char * 1036254721SemasteSBDebugger::GetInstanceName() 1037254721Semaste{ 1038296417Sdim return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); 1039254721Semaste} 1040254721Semaste 1041254721SemasteSBError 1042254721SemasteSBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name) 1043254721Semaste{ 1044254721Semaste SBError sb_error; 1045254721Semaste DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 1046254721Semaste Error error; 1047254721Semaste if (debugger_sp) 1048254721Semaste { 1049254721Semaste ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1050254721Semaste error = debugger_sp->SetPropertyValue (&exe_ctx, 1051254721Semaste eVarSetOperationAssign, 1052254721Semaste var_name, 1053254721Semaste value); 1054254721Semaste } 1055254721Semaste else 1056254721Semaste { 1057254721Semaste error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name); 1058254721Semaste } 1059254721Semaste if (error.Fail()) 1060254721Semaste sb_error.SetError(error); 1061254721Semaste return sb_error; 1062254721Semaste} 1063254721Semaste 1064254721SemasteSBStringList 1065254721SemasteSBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name) 1066254721Semaste{ 1067254721Semaste SBStringList ret_value; 1068254721Semaste DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 1069254721Semaste Error error; 1070254721Semaste if (debugger_sp) 1071254721Semaste { 1072254721Semaste ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1073254721Semaste lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx, 1074254721Semaste var_name, 1075254721Semaste false, 1076254721Semaste error)); 1077254721Semaste if (value_sp) 1078254721Semaste { 1079254721Semaste StreamString value_strm; 1080254721Semaste value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 1081254721Semaste const std::string &value_str = value_strm.GetString(); 1082254721Semaste if (!value_str.empty()) 1083254721Semaste { 1084254721Semaste StringList string_list; 1085262528Semaste string_list.SplitIntoLines(value_str); 1086254721Semaste return SBStringList(&string_list); 1087254721Semaste } 1088254721Semaste } 1089254721Semaste } 1090254721Semaste return SBStringList(); 1091254721Semaste} 1092254721Semaste 1093254721Semasteuint32_t 1094296417SdimSBDebugger::GetTerminalWidth() const 1095254721Semaste{ 1096296417Sdim return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0); 1097254721Semaste} 1098254721Semaste 1099254721Semastevoid 1100254721SemasteSBDebugger::SetTerminalWidth (uint32_t term_width) 1101254721Semaste{ 1102254721Semaste if (m_opaque_sp) 1103254721Semaste m_opaque_sp->SetTerminalWidth (term_width); 1104254721Semaste} 1105254721Semaste 1106254721Semasteconst char * 1107254721SemasteSBDebugger::GetPrompt() const 1108254721Semaste{ 1109254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1110276479Sdim 1111254721Semaste if (log) 1112276479Sdim log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", 1113276479Sdim static_cast<void*>(m_opaque_sp.get()), 1114254721Semaste (m_opaque_sp ? m_opaque_sp->GetPrompt() : "")); 1115254721Semaste 1116296417Sdim return (m_opaque_sp ? m_opaque_sp->GetPrompt() : nullptr); 1117254721Semaste} 1118254721Semaste 1119254721Semastevoid 1120254721SemasteSBDebugger::SetPrompt (const char *prompt) 1121254721Semaste{ 1122254721Semaste if (m_opaque_sp) 1123254721Semaste m_opaque_sp->SetPrompt (prompt); 1124254721Semaste} 1125254721Semaste 1126254721SemasteScriptLanguage 1127254721SemasteSBDebugger::GetScriptLanguage() const 1128254721Semaste{ 1129296417Sdim return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone); 1130254721Semaste} 1131254721Semaste 1132254721Semastevoid 1133254721SemasteSBDebugger::SetScriptLanguage (ScriptLanguage script_lang) 1134254721Semaste{ 1135254721Semaste if (m_opaque_sp) 1136254721Semaste { 1137254721Semaste m_opaque_sp->SetScriptLanguage (script_lang); 1138254721Semaste } 1139254721Semaste} 1140254721Semaste 1141254721Semastebool 1142296417SdimSBDebugger::SetUseExternalEditor(bool value) 1143254721Semaste{ 1144296417Sdim return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); 1145254721Semaste} 1146254721Semaste 1147254721Semastebool 1148296417SdimSBDebugger::GetUseExternalEditor() 1149254721Semaste{ 1150296417Sdim return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); 1151254721Semaste} 1152254721Semaste 1153254721Semastebool 1154296417SdimSBDebugger::SetUseColor(bool value) 1155254721Semaste{ 1156296417Sdim return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); 1157254721Semaste} 1158254721Semaste 1159254721Semastebool 1160296417SdimSBDebugger::GetUseColor() const 1161254721Semaste{ 1162296417Sdim return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); 1163254721Semaste} 1164254721Semaste 1165254721Semastebool 1166254721SemasteSBDebugger::GetDescription (SBStream &description) 1167254721Semaste{ 1168254721Semaste Stream &strm = description.ref(); 1169254721Semaste 1170254721Semaste if (m_opaque_sp) 1171254721Semaste { 1172254721Semaste const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1173254721Semaste user_id_t id = m_opaque_sp->GetID(); 1174254721Semaste strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1175254721Semaste } 1176254721Semaste else 1177254721Semaste strm.PutCString ("No value"); 1178254721Semaste 1179254721Semaste return true; 1180254721Semaste} 1181254721Semaste 1182254721Semasteuser_id_t 1183254721SemasteSBDebugger::GetID() 1184254721Semaste{ 1185296417Sdim return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID); 1186254721Semaste} 1187254721Semaste 1188254721SemasteSBError 1189280031SdimSBDebugger::SetCurrentPlatform (const char *platform_name_cstr) 1190254721Semaste{ 1191254721Semaste SBError sb_error; 1192254721Semaste if (m_opaque_sp) 1193254721Semaste { 1194280031Sdim if (platform_name_cstr && platform_name_cstr[0]) 1195254721Semaste { 1196280031Sdim ConstString platform_name (platform_name_cstr); 1197280031Sdim PlatformSP platform_sp (Platform::Find (platform_name)); 1198280031Sdim 1199280031Sdim if (platform_sp) 1200280031Sdim { 1201280031Sdim // Already have a platform with this name, just select it 1202280031Sdim m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp); 1203280031Sdim } 1204280031Sdim else 1205280031Sdim { 1206280031Sdim // We don't have a platform by this name yet, create one 1207280031Sdim platform_sp = Platform::Create (platform_name, sb_error.ref()); 1208280031Sdim if (platform_sp) 1209280031Sdim { 1210280031Sdim // We created the platform, now append and select it 1211280031Sdim bool make_selected = true; 1212280031Sdim m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected); 1213280031Sdim } 1214280031Sdim } 1215254721Semaste } 1216280031Sdim else 1217280031Sdim { 1218280031Sdim sb_error.ref().SetErrorString("invalid platform name"); 1219280031Sdim } 1220254721Semaste } 1221280031Sdim else 1222280031Sdim { 1223280031Sdim sb_error.ref().SetErrorString("invalid debugger"); 1224280031Sdim } 1225254721Semaste return sb_error; 1226254721Semaste} 1227254721Semaste 1228254721Semastebool 1229254721SemasteSBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot) 1230254721Semaste{ 1231254721Semaste if (m_opaque_sp) 1232254721Semaste { 1233254721Semaste PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1234254721Semaste 1235254721Semaste if (platform_sp) 1236254721Semaste { 1237254721Semaste platform_sp->SetSDKRootDirectory (ConstString (sysroot)); 1238254721Semaste return true; 1239254721Semaste } 1240254721Semaste } 1241254721Semaste return false; 1242254721Semaste} 1243254721Semaste 1244254721Semastebool 1245296417SdimSBDebugger::GetCloseInputOnEOF() const 1246254721Semaste{ 1247296417Sdim return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); 1248254721Semaste} 1249254721Semaste 1250254721Semastevoid 1251254721SemasteSBDebugger::SetCloseInputOnEOF (bool b) 1252254721Semaste{ 1253254721Semaste if (m_opaque_sp) 1254254721Semaste m_opaque_sp->SetCloseInputOnEOF (b); 1255254721Semaste} 1256254721Semaste 1257254721SemasteSBTypeCategory 1258254721SemasteSBDebugger::GetCategory (const char* category_name) 1259254721Semaste{ 1260254721Semaste if (!category_name || *category_name == 0) 1261254721Semaste return SBTypeCategory(); 1262254721Semaste 1263254721Semaste TypeCategoryImplSP category_sp; 1264254721Semaste 1265254721Semaste if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false)) 1266254721Semaste return SBTypeCategory(category_sp); 1267254721Semaste else 1268254721Semaste return SBTypeCategory(); 1269254721Semaste} 1270254721Semaste 1271254721SemasteSBTypeCategory 1272296417SdimSBDebugger::GetCategory (lldb::LanguageType lang_type) 1273296417Sdim{ 1274296417Sdim TypeCategoryImplSP category_sp; 1275296417Sdim if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) 1276296417Sdim return SBTypeCategory(category_sp); 1277296417Sdim else 1278296417Sdim return SBTypeCategory(); 1279296417Sdim} 1280296417Sdim 1281296417SdimSBTypeCategory 1282254721SemasteSBDebugger::CreateCategory (const char* category_name) 1283254721Semaste{ 1284254721Semaste if (!category_name || *category_name == 0) 1285254721Semaste return SBTypeCategory(); 1286254721Semaste 1287254721Semaste TypeCategoryImplSP category_sp; 1288254721Semaste 1289254721Semaste if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true)) 1290254721Semaste return SBTypeCategory(category_sp); 1291254721Semaste else 1292254721Semaste return SBTypeCategory(); 1293254721Semaste} 1294254721Semaste 1295254721Semastebool 1296254721SemasteSBDebugger::DeleteCategory (const char* category_name) 1297254721Semaste{ 1298254721Semaste if (!category_name || *category_name == 0) 1299254721Semaste return false; 1300254721Semaste 1301254721Semaste return DataVisualization::Categories::Delete(ConstString(category_name)); 1302254721Semaste} 1303254721Semaste 1304254721Semasteuint32_t 1305254721SemasteSBDebugger::GetNumCategories() 1306254721Semaste{ 1307254721Semaste return DataVisualization::Categories::GetCount(); 1308254721Semaste} 1309254721Semaste 1310254721SemasteSBTypeCategory 1311254721SemasteSBDebugger::GetCategoryAtIndex (uint32_t index) 1312254721Semaste{ 1313254721Semaste return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)); 1314254721Semaste} 1315254721Semaste 1316254721SemasteSBTypeCategory 1317254721SemasteSBDebugger::GetDefaultCategory() 1318254721Semaste{ 1319254721Semaste return GetCategory("default"); 1320254721Semaste} 1321254721Semaste 1322254721SemasteSBTypeFormat 1323254721SemasteSBDebugger::GetFormatForType (SBTypeNameSpecifier type_name) 1324254721Semaste{ 1325254721Semaste SBTypeCategory default_category_sb = GetDefaultCategory(); 1326254721Semaste if (default_category_sb.GetEnabled()) 1327254721Semaste return default_category_sb.GetFormatForType(type_name); 1328254721Semaste return SBTypeFormat(); 1329254721Semaste} 1330254721Semaste 1331254721Semaste#ifndef LLDB_DISABLE_PYTHON 1332254721SemasteSBTypeSummary 1333254721SemasteSBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name) 1334254721Semaste{ 1335296417Sdim if (!type_name.IsValid()) 1336254721Semaste return SBTypeSummary(); 1337254721Semaste return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())); 1338254721Semaste} 1339254721Semaste#endif // LLDB_DISABLE_PYTHON 1340254721Semaste 1341254721SemasteSBTypeFilter 1342254721SemasteSBDebugger::GetFilterForType (SBTypeNameSpecifier type_name) 1343254721Semaste{ 1344296417Sdim if (!type_name.IsValid()) 1345254721Semaste return SBTypeFilter(); 1346254721Semaste return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())); 1347254721Semaste} 1348254721Semaste 1349254721Semaste#ifndef LLDB_DISABLE_PYTHON 1350254721SemasteSBTypeSynthetic 1351254721SemasteSBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name) 1352254721Semaste{ 1353296417Sdim if (!type_name.IsValid()) 1354254721Semaste return SBTypeSynthetic(); 1355254721Semaste return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP())); 1356254721Semaste} 1357254721Semaste#endif // LLDB_DISABLE_PYTHON 1358254721Semaste 1359254721Semastebool 1360254721SemasteSBDebugger::EnableLog (const char *channel, const char **categories) 1361254721Semaste{ 1362254721Semaste if (m_opaque_sp) 1363254721Semaste { 1364254721Semaste uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1365254721Semaste StreamString errors; 1366296417Sdim return m_opaque_sp->EnableLog(channel, categories, nullptr, log_options, errors); 1367254721Semaste } 1368254721Semaste else 1369254721Semaste return false; 1370254721Semaste} 1371254721Semaste 1372254721Semastevoid 1373254721SemasteSBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 1374254721Semaste{ 1375254721Semaste if (m_opaque_sp) 1376254721Semaste { 1377254721Semaste return m_opaque_sp->SetLoggingCallback (log_callback, baton); 1378254721Semaste } 1379254721Semaste} 1380