1254721Semaste//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===// 2254721Semaste// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6254721Semaste// 7254721Semaste//===----------------------------------------------------------------------===// 8254721Semaste 9353358Sdim#include "SBReproducerPrivate.h" 10341825Sdim#include "SystemInitializerFull.h" 11341825Sdim 12254721Semaste#include "lldb/API/SBDebugger.h" 13254721Semaste 14254721Semaste#include "lldb/lldb-private.h" 15254721Semaste 16254721Semaste#include "lldb/API/SBBroadcaster.h" 17254721Semaste#include "lldb/API/SBCommandInterpreter.h" 18254721Semaste#include "lldb/API/SBCommandReturnObject.h" 19254721Semaste#include "lldb/API/SBError.h" 20254721Semaste#include "lldb/API/SBEvent.h" 21360784Sdim#include "lldb/API/SBFile.h" 22254721Semaste#include "lldb/API/SBFrame.h" 23314564Sdim#include "lldb/API/SBListener.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" 28327952Sdim#include "lldb/API/SBStructuredData.h" 29254721Semaste#include "lldb/API/SBTarget.h" 30254721Semaste#include "lldb/API/SBThread.h" 31254721Semaste#include "lldb/API/SBTypeCategory.h" 32314564Sdim#include "lldb/API/SBTypeFilter.h" 33254721Semaste#include "lldb/API/SBTypeFormat.h" 34254721Semaste#include "lldb/API/SBTypeNameSpecifier.h" 35254721Semaste#include "lldb/API/SBTypeSummary.h" 36254721Semaste#include "lldb/API/SBTypeSynthetic.h" 37254721Semaste 38254721Semaste#include "lldb/Core/Debugger.h" 39327952Sdim#include "lldb/Core/PluginManager.h" 40262528Semaste#include "lldb/Core/StreamFile.h" 41327952Sdim#include "lldb/Core/StructuredDataImpl.h" 42254721Semaste#include "lldb/DataFormatters/DataVisualization.h" 43360784Sdim#include "lldb/Host/Config.h" 44341825Sdim#include "lldb/Host/XML.h" 45288943Sdim#include "lldb/Initialization/SystemLifetimeManager.h" 46254721Semaste#include "lldb/Interpreter/CommandInterpreter.h" 47341825Sdim#include "lldb/Interpreter/OptionArgParser.h" 48254721Semaste#include "lldb/Interpreter/OptionGroupPlatform.h" 49254721Semaste#include "lldb/Target/Process.h" 50254721Semaste#include "lldb/Target/TargetList.h" 51341825Sdim#include "lldb/Utility/Args.h" 52344779Sdim#include "lldb/Utility/State.h" 53254721Semaste 54296417Sdim#include "llvm/ADT/STLExtras.h" 55314564Sdim#include "llvm/ADT/StringRef.h" 56314564Sdim#include "llvm/Support/DynamicLibrary.h" 57288943Sdim#include "llvm/Support/ManagedStatic.h" 58276479Sdim 59254721Semasteusing namespace lldb; 60254721Semasteusing namespace lldb_private; 61254721Semaste 62314564Sdimstatic llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp, 63314564Sdim const FileSpec &spec, 64321369Sdim Status &error) { 65314564Sdim llvm::sys::DynamicLibrary dynlib = 66314564Sdim llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str()); 67314564Sdim if (dynlib.isValid()) { 68314564Sdim typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger); 69314564Sdim 70314564Sdim lldb::SBDebugger debugger_sb(debugger_sp); 71314564Sdim // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) 72314564Sdim // function. 73314564Sdim // TODO: mangle this differently for your system - on OSX, the first 74314564Sdim // underscore needs to be removed and the second one stays 75314564Sdim LLDBCommandPluginInit init_func = 76327952Sdim (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol( 77314564Sdim "_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); 78314564Sdim if (init_func) { 79314564Sdim if (init_func(debugger_sb)) 80314564Sdim return dynlib; 81314564Sdim else 82314564Sdim error.SetErrorString("plug-in refused to load " 83314564Sdim "(lldb::PluginInitialize(lldb::SBDebugger) " 84314564Sdim "returned false)"); 85314564Sdim } else { 86314564Sdim error.SetErrorString("plug-in is missing the required initialization: " 87314564Sdim "lldb::PluginInitialize(lldb::SBDebugger)"); 88258884Semaste } 89314564Sdim } else { 90344779Sdim if (FileSystem::Instance().Exists(spec)) 91314564Sdim error.SetErrorString("this file does not represent a loadable dylib"); 92258884Semaste else 93314564Sdim error.SetErrorString("no such file"); 94314564Sdim } 95314564Sdim return llvm::sys::DynamicLibrary(); 96258884Semaste} 97258884Semaste 98288943Sdimstatic llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime; 99288943Sdim 100314564SdimSBError SBInputReader::Initialize( 101314564Sdim lldb::SBDebugger &sb_debugger, 102353358Sdim unsigned long (*callback)(void *, lldb::SBInputReader *, 103353358Sdim lldb::InputReaderAction, char const *, 104353358Sdim unsigned long), 105353358Sdim void *a, lldb::InputReaderGranularity b, char const *c, char const *d, 106353358Sdim bool e) { 107353358Sdim LLDB_RECORD_DUMMY( 108353358Sdim lldb::SBError, SBInputReader, Initialize, 109353358Sdim (lldb::SBDebugger &, 110353358Sdim unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, 111353358Sdim const char *, unsigned long), 112353358Sdim void *, lldb::InputReaderGranularity, const char *, const char *, bool), 113353358Sdim sb_debugger, callback, a, b, c, d, e); 114353358Sdim 115314564Sdim return SBError(); 116288943Sdim} 117288943Sdim 118353358Sdimvoid SBInputReader::SetIsDone(bool b) { 119353358Sdim LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b); 120353358Sdim} 121296417Sdim 122353358Sdimbool SBInputReader::IsActive() const { 123353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); 124288943Sdim 125353358Sdim return false; 126353358Sdim} 127296417Sdim 128353358SdimSBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); } 129353358Sdim 130314564SdimSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) 131353358Sdim : m_opaque_sp(debugger_sp) { 132353358Sdim LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp); 133353358Sdim} 134296417Sdim 135353358SdimSBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) { 136353358Sdim LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs); 137353358Sdim} 138296417Sdim 139296417SdimSBDebugger::~SBDebugger() = default; 140296417Sdim 141314564SdimSBDebugger &SBDebugger::operator=(const SBDebugger &rhs) { 142353358Sdim LLDB_RECORD_METHOD(lldb::SBDebugger &, 143353358Sdim SBDebugger, operator=,(const lldb::SBDebugger &), rhs); 144353358Sdim 145314564Sdim if (this != &rhs) { 146314564Sdim m_opaque_sp = rhs.m_opaque_sp; 147314564Sdim } 148353358Sdim return LLDB_RECORD_RESULT(*this); 149296417Sdim} 150296417Sdim 151314564Sdimvoid SBDebugger::Initialize() { 152353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize); 153353358Sdim SBError ignored = SBDebugger::InitializeWithErrorHandling(); 154344779Sdim} 155344779Sdim 156353358Sdimlldb::SBError SBDebugger::InitializeWithErrorHandling() { 157353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger, 158353358Sdim InitializeWithErrorHandling); 159254721Semaste 160344779Sdim SBError error; 161344779Sdim if (auto e = g_debugger_lifetime->Initialize( 162360784Sdim std::make_unique<SystemInitializerFull>(), LoadPlugin)) { 163344779Sdim error.SetError(Status(std::move(e))); 164344779Sdim } 165353358Sdim return LLDB_RECORD_RESULT(error); 166254721Semaste} 167254721Semaste 168353358Sdimvoid SBDebugger::Terminate() { 169353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate); 170254721Semaste 171353358Sdim g_debugger_lifetime->Terminate(); 172353358Sdim} 173353358Sdim 174314564Sdimvoid SBDebugger::Clear() { 175353358Sdim LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear); 176254721Semaste 177314564Sdim if (m_opaque_sp) 178314564Sdim m_opaque_sp->ClearIOHandlers(); 179254721Semaste 180314564Sdim m_opaque_sp.reset(); 181254721Semaste} 182254721Semaste 183314564SdimSBDebugger SBDebugger::Create() { 184353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create); 185353358Sdim 186353358Sdim return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr)); 187254721Semaste} 188254721Semaste 189314564SdimSBDebugger SBDebugger::Create(bool source_init_files) { 190353358Sdim LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool), 191353358Sdim source_init_files); 192353358Sdim 193353358Sdim return LLDB_RECORD_RESULT( 194353358Sdim SBDebugger::Create(source_init_files, nullptr, nullptr)); 195254721Semaste} 196254721Semaste 197314564SdimSBDebugger SBDebugger::Create(bool source_init_files, 198314564Sdim lldb::LogOutputCallback callback, void *baton) 199254721Semaste 200254721Semaste{ 201353358Sdim LLDB_RECORD_DUMMY(lldb::SBDebugger, SBDebugger, Create, 202353358Sdim (bool, lldb::LogOutputCallback, void *), source_init_files, 203353358Sdim callback, baton); 204254721Semaste 205314564Sdim SBDebugger debugger; 206276479Sdim 207314564Sdim // Currently we have issues if this function is called simultaneously on two 208341825Sdim // different threads. The issues mainly revolve around the fact that the 209341825Sdim // lldb_private::FormatManager uses global collections and having two threads 210341825Sdim // parsing the .lldbinit files can cause mayhem. So to get around this for 211341825Sdim // now we need to use a mutex to prevent bad things from happening. 212314564Sdim static std::recursive_mutex g_mutex; 213314564Sdim std::lock_guard<std::recursive_mutex> guard(g_mutex); 214254721Semaste 215314564Sdim debugger.reset(Debugger::CreateInstance(callback, baton)); 216254721Semaste 217314564Sdim SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 218314564Sdim if (source_init_files) { 219314564Sdim interp.get()->SkipLLDBInitFiles(false); 220314564Sdim interp.get()->SkipAppInitFiles(false); 221314564Sdim SBCommandReturnObject result; 222314564Sdim interp.SourceInitFileInHomeDirectory(result); 223314564Sdim } else { 224314564Sdim interp.get()->SkipLLDBInitFiles(true); 225314564Sdim interp.get()->SkipAppInitFiles(true); 226314564Sdim } 227314564Sdim return debugger; 228254721Semaste} 229254721Semaste 230314564Sdimvoid SBDebugger::Destroy(SBDebugger &debugger) { 231353358Sdim LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &), 232353358Sdim debugger); 233276479Sdim 234314564Sdim Debugger::Destroy(debugger.m_opaque_sp); 235276479Sdim 236314564Sdim if (debugger.m_opaque_sp.get() != nullptr) 237314564Sdim debugger.m_opaque_sp.reset(); 238254721Semaste} 239254721Semaste 240314564Sdimvoid SBDebugger::MemoryPressureDetected() { 241353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected); 242353358Sdim 243341825Sdim // Since this function can be call asynchronously, we allow it to be non- 244341825Sdim // mandatory. We have seen deadlocks with this function when called so we 245341825Sdim // need to safeguard against this until we can determine what is causing the 246341825Sdim // deadlocks. 247254721Semaste 248314564Sdim const bool mandatory = false; 249314564Sdim 250314564Sdim ModuleList::RemoveOrphanSharedModules(mandatory); 251254721Semaste} 252254721Semaste 253353358Sdimbool SBDebugger::IsValid() const { 254353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); 255353358Sdim return this->operator bool(); 256353358Sdim} 257353358SdimSBDebugger::operator bool() const { 258353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool); 259314564Sdim 260353358Sdim return m_opaque_sp.get() != nullptr; 261353358Sdim} 262353358Sdim 263314564Sdimvoid SBDebugger::SetAsync(bool b) { 264353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b); 265353358Sdim 266314564Sdim if (m_opaque_sp) 267314564Sdim m_opaque_sp->SetAsyncExecution(b); 268254721Semaste} 269254721Semaste 270314564Sdimbool SBDebugger::GetAsync() { 271353358Sdim LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync); 272353358Sdim 273314564Sdim return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false); 274254721Semaste} 275254721Semaste 276314564Sdimvoid SBDebugger::SkipLLDBInitFiles(bool b) { 277353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b); 278353358Sdim 279314564Sdim if (m_opaque_sp) 280314564Sdim m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b); 281254721Semaste} 282254721Semaste 283314564Sdimvoid SBDebugger::SkipAppInitFiles(bool b) { 284353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b); 285353358Sdim 286314564Sdim if (m_opaque_sp) 287314564Sdim m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b); 288254721Semaste} 289254721Semaste 290314564Sdimvoid SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { 291353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh, 292353358Sdim transfer_ownership); 293360784Sdim SetInputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); 294360784Sdim} 295254721Semaste 296360784SdimSBError SBDebugger::SetInputFile(FileSP file_sp) { 297360784Sdim LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp); 298360784Sdim return LLDB_RECORD_RESULT(SetInputFile(SBFile(file_sp))); 299360784Sdim} 300254721Semaste 301360784Sdim// Shouldn't really be settable after initialization as this could cause lots 302360784Sdim// of problems; don't want users trying to switch modes in the middle of a 303360784Sdim// debugging session. 304360784SdimSBError SBDebugger::SetInputFile(SBFile file) { 305360784Sdim LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file); 306360784Sdim 307360784Sdim SBError error; 308360784Sdim if (!m_opaque_sp) { 309360784Sdim error.ref().SetErrorString("invalid debugger"); 310360784Sdim return LLDB_RECORD_RESULT(error); 311360784Sdim } 312360784Sdim 313353358Sdim repro::DataRecorder *recorder = nullptr; 314353358Sdim if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) 315353358Sdim recorder = g->GetOrCreate<repro::CommandProvider>().GetNewDataRecorder(); 316353358Sdim 317360784Sdim FileSP file_sp = file.m_opaque_sp; 318353358Sdim 319360784Sdim static std::unique_ptr<repro::MultiLoader<repro::CommandProvider>> loader = 320360784Sdim repro::MultiLoader<repro::CommandProvider>::Create( 321360784Sdim repro::Reproducer::Instance().GetLoader()); 322360784Sdim if (loader) { 323360784Sdim llvm::Optional<std::string> nextfile = loader->GetNextFile(); 324360784Sdim FILE *fh = nextfile ? FileSystem::Instance().Fopen(nextfile->c_str(), "r") 325360784Sdim : nullptr; 326360784Sdim // FIXME Jonas Devlieghere: shouldn't this error be propagated out to the 327360784Sdim // reproducer somehow if fh is NULL? 328360784Sdim if (fh) { 329360784Sdim file_sp = std::make_shared<NativeFile>(fh, true); 330360784Sdim } 331360784Sdim } 332360784Sdim 333360784Sdim if (!file_sp || !file_sp->IsValid()) { 334360784Sdim error.ref().SetErrorString("invalid file"); 335360784Sdim return LLDB_RECORD_RESULT(error); 336360784Sdim } 337360784Sdim 338360784Sdim m_opaque_sp->SetInputFile(file_sp, recorder); 339360784Sdim return LLDB_RECORD_RESULT(error); 340254721Semaste} 341254721Semaste 342360784SdimSBError SBDebugger::SetOutputFile(FileSP file_sp) { 343360784Sdim LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp); 344360784Sdim return LLDB_RECORD_RESULT(SetOutputFile(SBFile(file_sp))); 345360784Sdim} 346360784Sdim 347314564Sdimvoid SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { 348353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh, 349353358Sdim transfer_ownership); 350360784Sdim SetOutputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); 351360784Sdim} 352254721Semaste 353360784SdimSBError SBDebugger::SetOutputFile(SBFile file) { 354360784Sdim LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file); 355360784Sdim SBError error; 356360784Sdim if (!m_opaque_sp) { 357360784Sdim error.ref().SetErrorString("invalid debugger"); 358360784Sdim return LLDB_RECORD_RESULT(error); 359360784Sdim } 360360784Sdim if (!file) { 361360784Sdim error.ref().SetErrorString("invalid file"); 362360784Sdim return LLDB_RECORD_RESULT(error); 363360784Sdim } 364360784Sdim m_opaque_sp->SetOutputFile(file.m_opaque_sp); 365360784Sdim return LLDB_RECORD_RESULT(error); 366254721Semaste} 367254721Semaste 368314564Sdimvoid SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { 369353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh, 370353358Sdim transfer_ownership); 371360784Sdim SetErrorFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); 372360784Sdim} 373254721Semaste 374360784SdimSBError SBDebugger::SetErrorFile(FileSP file_sp) { 375360784Sdim LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp); 376360784Sdim return LLDB_RECORD_RESULT(SetErrorFile(SBFile(file_sp))); 377360784Sdim} 378254721Semaste 379360784SdimSBError SBDebugger::SetErrorFile(SBFile file) { 380360784Sdim LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file); 381360784Sdim SBError error; 382360784Sdim if (!m_opaque_sp) { 383360784Sdim error.ref().SetErrorString("invalid debugger"); 384360784Sdim return LLDB_RECORD_RESULT(error); 385360784Sdim } 386360784Sdim if (!file) { 387360784Sdim error.ref().SetErrorString("invalid file"); 388360784Sdim return LLDB_RECORD_RESULT(error); 389360784Sdim } 390360784Sdim m_opaque_sp->SetErrorFile(file.m_opaque_sp); 391360784Sdim return LLDB_RECORD_RESULT(error); 392254721Semaste} 393254721Semaste 394314564SdimFILE *SBDebugger::GetInputFileHandle() { 395353358Sdim LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); 396360784Sdim if (m_opaque_sp) { 397360784Sdim File &file_sp = m_opaque_sp->GetInputFile(); 398360784Sdim return LLDB_RECORD_RESULT(file_sp.GetStream()); 399360784Sdim } 400360784Sdim return LLDB_RECORD_RESULT(nullptr); 401360784Sdim} 402353358Sdim 403360784SdimSBFile SBDebugger::GetInputFile() { 404360784Sdim LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile); 405314564Sdim if (m_opaque_sp) { 406360784Sdim return LLDB_RECORD_RESULT(SBFile(m_opaque_sp->GetInputFileSP())); 407314564Sdim } 408360784Sdim return LLDB_RECORD_RESULT(SBFile()); 409254721Semaste} 410254721Semaste 411314564SdimFILE *SBDebugger::GetOutputFileHandle() { 412353358Sdim LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); 413360784Sdim if (m_opaque_sp) { 414360784Sdim StreamFile &stream_file = m_opaque_sp->GetOutputStream(); 415360784Sdim return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); 416360784Sdim } 417360784Sdim return LLDB_RECORD_RESULT(nullptr); 418360784Sdim} 419353358Sdim 420360784SdimSBFile SBDebugger::GetOutputFile() { 421360784Sdim LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile); 422314564Sdim if (m_opaque_sp) { 423360784Sdim SBFile file(m_opaque_sp->GetOutputStream().GetFileSP()); 424360784Sdim return LLDB_RECORD_RESULT(file); 425314564Sdim } 426360784Sdim return LLDB_RECORD_RESULT(SBFile()); 427254721Semaste} 428254721Semaste 429314564SdimFILE *SBDebugger::GetErrorFileHandle() { 430353358Sdim LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); 431353358Sdim 432314564Sdim if (m_opaque_sp) { 433360784Sdim StreamFile &stream_file = m_opaque_sp->GetErrorStream(); 434360784Sdim return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); 435314564Sdim } 436360784Sdim return LLDB_RECORD_RESULT(nullptr); 437254721Semaste} 438254721Semaste 439360784SdimSBFile SBDebugger::GetErrorFile() { 440360784Sdim LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile); 441360784Sdim SBFile file; 442360784Sdim if (m_opaque_sp) { 443360784Sdim SBFile file(m_opaque_sp->GetErrorStream().GetFileSP()); 444360784Sdim return LLDB_RECORD_RESULT(file); 445360784Sdim } 446360784Sdim return LLDB_RECORD_RESULT(SBFile()); 447360784Sdim} 448360784Sdim 449314564Sdimvoid SBDebugger::SaveInputTerminalState() { 450360784Sdim LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, SaveInputTerminalState); 451353358Sdim 452314564Sdim if (m_opaque_sp) 453314564Sdim m_opaque_sp->SaveInputTerminalState(); 454254721Semaste} 455254721Semaste 456314564Sdimvoid SBDebugger::RestoreInputTerminalState() { 457360784Sdim LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, RestoreInputTerminalState); 458353358Sdim 459314564Sdim if (m_opaque_sp) 460314564Sdim m_opaque_sp->RestoreInputTerminalState(); 461254721Semaste} 462314564SdimSBCommandInterpreter SBDebugger::GetCommandInterpreter() { 463353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger, 464353358Sdim GetCommandInterpreter); 465254721Semaste 466314564Sdim SBCommandInterpreter sb_interpreter; 467314564Sdim if (m_opaque_sp) 468314564Sdim sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter()); 469254721Semaste 470353358Sdim return LLDB_RECORD_RESULT(sb_interpreter); 471254721Semaste} 472254721Semaste 473314564Sdimvoid SBDebugger::HandleCommand(const char *command) { 474353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command); 475353358Sdim 476314564Sdim if (m_opaque_sp) { 477314564Sdim TargetSP target_sp(m_opaque_sp->GetSelectedTarget()); 478314564Sdim std::unique_lock<std::recursive_mutex> lock; 479314564Sdim if (target_sp) 480314564Sdim lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); 481254721Semaste 482314564Sdim SBCommandInterpreter sb_interpreter(GetCommandInterpreter()); 483314564Sdim SBCommandReturnObject result; 484254721Semaste 485314564Sdim sb_interpreter.HandleCommand(command, result, false); 486254721Semaste 487360784Sdim result.PutError(m_opaque_sp->GetErrorStream().GetFileSP()); 488360784Sdim result.PutOutput(m_opaque_sp->GetOutputStream().GetFileSP()); 489254721Semaste 490314564Sdim if (!m_opaque_sp->GetAsyncExecution()) { 491314564Sdim SBProcess process(GetCommandInterpreter().GetProcess()); 492314564Sdim ProcessSP process_sp(process.GetSP()); 493314564Sdim if (process_sp) { 494314564Sdim EventSP event_sp; 495314564Sdim ListenerSP lldb_listener_sp = m_opaque_sp->GetListener(); 496314564Sdim while (lldb_listener_sp->GetEventForBroadcaster( 497314564Sdim process_sp.get(), event_sp, std::chrono::seconds(0))) { 498314564Sdim SBEvent event(event_sp); 499360784Sdim HandleProcessEvent(process, event, GetOutputFile(), GetErrorFile()); 500254721Semaste } 501314564Sdim } 502254721Semaste } 503314564Sdim } 504254721Semaste} 505254721Semaste 506314564SdimSBListener SBDebugger::GetListener() { 507353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); 508254721Semaste 509314564Sdim SBListener sb_listener; 510314564Sdim if (m_opaque_sp) 511314564Sdim sb_listener.reset(m_opaque_sp->GetListener()); 512254721Semaste 513353358Sdim return LLDB_RECORD_RESULT(sb_listener); 514254721Semaste} 515254721Semaste 516314564Sdimvoid SBDebugger::HandleProcessEvent(const SBProcess &process, 517360784Sdim const SBEvent &event, SBFile out, 518360784Sdim SBFile err) { 519360784Sdim LLDB_RECORD_METHOD( 520360784Sdim void, SBDebugger, HandleProcessEvent, 521360784Sdim (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process, 522360784Sdim event, out, err); 523360784Sdim 524360784Sdim return HandleProcessEvent(process, event, out.m_opaque_sp, err.m_opaque_sp); 525360784Sdim} 526360784Sdim 527360784Sdimvoid SBDebugger::HandleProcessEvent(const SBProcess &process, 528314564Sdim const SBEvent &event, FILE *out, 529314564Sdim FILE *err) { 530353358Sdim LLDB_RECORD_METHOD( 531353358Sdim void, SBDebugger, HandleProcessEvent, 532353358Sdim (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process, 533353358Sdim event, out, err); 534353358Sdim 535360784Sdim FileSP outfile = std::make_shared<NativeFile>(out, false); 536360784Sdim FileSP errfile = std::make_shared<NativeFile>(err, false); 537360784Sdim return HandleProcessEvent(process, event, outfile, errfile); 538360784Sdim} 539360784Sdim 540360784Sdimvoid SBDebugger::HandleProcessEvent(const SBProcess &process, 541360784Sdim const SBEvent &event, FileSP out_sp, 542360784Sdim FileSP err_sp) { 543360784Sdim 544360784Sdim LLDB_RECORD_METHOD( 545360784Sdim void, SBDebugger, HandleProcessEvent, 546360784Sdim (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process, 547360784Sdim event, out_sp, err_sp); 548360784Sdim 549314564Sdim if (!process.IsValid()) 550314564Sdim return; 551254721Semaste 552314564Sdim TargetSP target_sp(process.GetTarget().GetSP()); 553314564Sdim if (!target_sp) 554314564Sdim return; 555254721Semaste 556314564Sdim const uint32_t event_type = event.GetType(); 557314564Sdim char stdio_buffer[1024]; 558314564Sdim size_t len; 559254721Semaste 560314564Sdim std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 561309124Sdim 562314564Sdim if (event_type & 563314564Sdim (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) { 564314564Sdim // Drain stdout when we stop just in case we have any bytes 565314564Sdim while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0) 566360784Sdim if (out_sp) 567360784Sdim out_sp->Write(stdio_buffer, len); 568314564Sdim } 569314564Sdim 570314564Sdim if (event_type & 571314564Sdim (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) { 572314564Sdim // Drain stderr when we stop just in case we have any bytes 573314564Sdim while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0) 574360784Sdim if (err_sp) 575360784Sdim err_sp->Write(stdio_buffer, len); 576314564Sdim } 577314564Sdim 578314564Sdim if (event_type & Process::eBroadcastBitStateChanged) { 579314564Sdim StateType event_state = SBProcess::GetStateFromEvent(event); 580314564Sdim 581314564Sdim if (event_state == eStateInvalid) 582314564Sdim return; 583314564Sdim 584314564Sdim bool is_stopped = StateIsStoppedState(event_state); 585314564Sdim if (!is_stopped) 586360784Sdim process.ReportEventState(event, out_sp); 587314564Sdim } 588254721Semaste} 589254721Semaste 590314564SdimSBSourceManager SBDebugger::GetSourceManager() { 591353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, 592353358Sdim GetSourceManager); 593353358Sdim 594314564Sdim SBSourceManager sb_source_manager(*this); 595353358Sdim return LLDB_RECORD_RESULT(sb_source_manager); 596254721Semaste} 597254721Semaste 598314564Sdimbool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) { 599353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture, 600353358Sdim (char *, size_t), "", arch_name_len); 601353358Sdim 602314564Sdim if (arch_name && arch_name_len) { 603314564Sdim ArchSpec default_arch = Target::GetDefaultArchitecture(); 604254721Semaste 605314564Sdim if (default_arch.IsValid()) { 606314564Sdim const std::string &triple_str = default_arch.GetTriple().str(); 607314564Sdim if (!triple_str.empty()) 608314564Sdim ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str()); 609314564Sdim else 610314564Sdim ::snprintf(arch_name, arch_name_len, "%s", 611314564Sdim default_arch.GetArchitectureName()); 612314564Sdim return true; 613254721Semaste } 614314564Sdim } 615314564Sdim if (arch_name && arch_name_len) 616314564Sdim arch_name[0] = '\0'; 617314564Sdim return false; 618254721Semaste} 619254721Semaste 620314564Sdimbool SBDebugger::SetDefaultArchitecture(const char *arch_name) { 621353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, 622353358Sdim (const char *), arch_name); 623353358Sdim 624314564Sdim if (arch_name) { 625314564Sdim ArchSpec arch(arch_name); 626314564Sdim if (arch.IsValid()) { 627314564Sdim Target::SetDefaultArchitecture(arch); 628314564Sdim return true; 629254721Semaste } 630314564Sdim } 631314564Sdim return false; 632254721Semaste} 633254721Semaste 634254721SemasteScriptLanguage 635314564SdimSBDebugger::GetScriptingLanguage(const char *script_language_name) { 636353358Sdim LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, 637353358Sdim (const char *), script_language_name); 638353358Sdim 639360784Sdim if (!script_language_name) 640360784Sdim return eScriptLanguageDefault; 641341825Sdim return OptionArgParser::ToScriptLanguage( 642341825Sdim llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr); 643254721Semaste} 644254721Semaste 645314564Sdimconst char *SBDebugger::GetVersionString() { 646353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString); 647353358Sdim 648314564Sdim return lldb_private::GetVersion(); 649254721Semaste} 650254721Semaste 651314564Sdimconst char *SBDebugger::StateAsCString(StateType state) { 652353358Sdim LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString, 653353358Sdim (lldb::StateType), state); 654353358Sdim 655314564Sdim return lldb_private::StateAsCString(state); 656254721Semaste} 657254721Semaste 658341825Sdimstatic void AddBoolConfigEntry(StructuredData::Dictionary &dict, 659341825Sdim llvm::StringRef name, bool value, 660341825Sdim llvm::StringRef description) { 661360784Sdim auto entry_up = std::make_unique<StructuredData::Dictionary>(); 662341825Sdim entry_up->AddBooleanItem("value", value); 663341825Sdim entry_up->AddStringItem("description", description); 664341825Sdim dict.AddItem(name, std::move(entry_up)); 665341825Sdim} 666341825Sdim 667341825Sdimstatic void AddLLVMTargets(StructuredData::Dictionary &dict) { 668360784Sdim auto array_up = std::make_unique<StructuredData::Array>(); 669341825Sdim#define LLVM_TARGET(target) \ 670360784Sdim array_up->AddItem(std::make_unique<StructuredData::String>(#target)); 671341825Sdim#include "llvm/Config/Targets.def" 672360784Sdim auto entry_up = std::make_unique<StructuredData::Dictionary>(); 673341825Sdim entry_up->AddItem("value", std::move(array_up)); 674341825Sdim entry_up->AddStringItem("description", "A list of configured LLVM targets."); 675341825Sdim dict.AddItem("targets", std::move(entry_up)); 676341825Sdim} 677341825Sdim 678341825SdimSBStructuredData SBDebugger::GetBuildConfiguration() { 679353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, 680353358Sdim GetBuildConfiguration); 681353358Sdim 682360784Sdim auto config_up = std::make_unique<StructuredData::Dictionary>(); 683341825Sdim AddBoolConfigEntry( 684341825Sdim *config_up, "xml", XMLDocument::XMLEnabled(), 685341825Sdim "A boolean value that indicates if XML support is enabled in LLDB"); 686360784Sdim AddBoolConfigEntry( 687360784Sdim *config_up, "curses", LLDB_ENABLE_CURSES, 688360784Sdim "A boolean value that indicates if curses support is enabled in LLDB"); 689360784Sdim AddBoolConfigEntry( 690360784Sdim *config_up, "editline", LLDB_ENABLE_LIBEDIT, 691360784Sdim "A boolean value that indicates if editline support is enabled in LLDB"); 692360784Sdim AddBoolConfigEntry( 693360784Sdim *config_up, "lzma", LLDB_ENABLE_LZMA, 694360784Sdim "A boolean value that indicates if lzma support is enabled in LLDB"); 695360784Sdim AddBoolConfigEntry( 696360784Sdim *config_up, "python", LLDB_ENABLE_PYTHON, 697360784Sdim "A boolean value that indicates if python support is enabled in LLDB"); 698360784Sdim AddBoolConfigEntry( 699360784Sdim *config_up, "lua", LLDB_ENABLE_LUA, 700360784Sdim "A boolean value that indicates if lua support is enabled in LLDB"); 701341825Sdim AddLLVMTargets(*config_up); 702341825Sdim 703341825Sdim SBStructuredData data; 704341825Sdim data.m_impl_up->SetObjectSP(std::move(config_up)); 705353358Sdim return LLDB_RECORD_RESULT(data); 706341825Sdim} 707341825Sdim 708314564Sdimbool SBDebugger::StateIsRunningState(StateType state) { 709353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, 710353358Sdim (lldb::StateType), state); 711254721Semaste 712314564Sdim const bool result = lldb_private::StateIsRunningState(state); 713254721Semaste 714314564Sdim return result; 715254721Semaste} 716254721Semaste 717314564Sdimbool SBDebugger::StateIsStoppedState(StateType state) { 718353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, 719353358Sdim (lldb::StateType), state); 720254721Semaste 721314564Sdim const bool result = lldb_private::StateIsStoppedState(state, false); 722254721Semaste 723314564Sdim return result; 724254721Semaste} 725254721Semaste 726314564Sdimlldb::SBTarget SBDebugger::CreateTarget(const char *filename, 727314564Sdim const char *target_triple, 728314564Sdim const char *platform_name, 729314564Sdim bool add_dependent_modules, 730314564Sdim lldb::SBError &sb_error) { 731353358Sdim LLDB_RECORD_METHOD( 732353358Sdim lldb::SBTarget, SBDebugger, CreateTarget, 733353358Sdim (const char *, const char *, const char *, bool, lldb::SBError &), 734353358Sdim filename, target_triple, platform_name, add_dependent_modules, sb_error); 735353358Sdim 736314564Sdim SBTarget sb_target; 737314564Sdim TargetSP target_sp; 738314564Sdim if (m_opaque_sp) { 739314564Sdim sb_error.Clear(); 740314564Sdim OptionGroupPlatform platform_options(false); 741314564Sdim platform_options.SetPlatformName(platform_name); 742276479Sdim 743314564Sdim sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget( 744344779Sdim *m_opaque_sp, filename, target_triple, 745344779Sdim add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, 746314564Sdim &platform_options, target_sp); 747276479Sdim 748314564Sdim if (sb_error.Success()) 749314564Sdim sb_target.SetSP(target_sp); 750314564Sdim } else { 751314564Sdim sb_error.SetErrorString("invalid debugger"); 752314564Sdim } 753276479Sdim 754314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 755360784Sdim LLDB_LOGF(log, 756360784Sdim "SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, " 757360784Sdim "platform_name=%s, add_dependent_modules=%u, error=%s) => " 758360784Sdim "SBTarget(%p)", 759360784Sdim static_cast<void *>(m_opaque_sp.get()), filename, target_triple, 760360784Sdim platform_name, add_dependent_modules, sb_error.GetCString(), 761360784Sdim static_cast<void *>(target_sp.get())); 762276479Sdim 763353358Sdim return LLDB_RECORD_RESULT(sb_target); 764254721Semaste} 765254721Semaste 766254721SemasteSBTarget 767314564SdimSBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, 768314564Sdim const char *target_triple) { 769353358Sdim LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, 770353358Sdim CreateTargetWithFileAndTargetTriple, 771353358Sdim (const char *, const char *), filename, target_triple); 772353358Sdim 773314564Sdim SBTarget sb_target; 774314564Sdim TargetSP target_sp; 775314564Sdim if (m_opaque_sp) { 776314564Sdim const bool add_dependent_modules = true; 777321369Sdim Status error(m_opaque_sp->GetTargetList().CreateTarget( 778344779Sdim *m_opaque_sp, filename, target_triple, 779344779Sdim add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, 780314564Sdim target_sp)); 781314564Sdim sb_target.SetSP(target_sp); 782314564Sdim } 783276479Sdim 784314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 785360784Sdim LLDB_LOGF(log, 786360784Sdim "SBDebugger(%p)::CreateTargetWithFileAndTargetTriple " 787360784Sdim "(filename=\"%s\", triple=%s) => SBTarget(%p)", 788360784Sdim static_cast<void *>(m_opaque_sp.get()), filename, target_triple, 789360784Sdim static_cast<void *>(target_sp.get())); 790254721Semaste 791353358Sdim return LLDB_RECORD_RESULT(sb_target); 792254721Semaste} 793254721Semaste 794314564SdimSBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, 795314564Sdim const char *arch_cstr) { 796353358Sdim LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, 797353358Sdim (const char *, const char *), filename, arch_cstr); 798353358Sdim 799314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 800254721Semaste 801314564Sdim SBTarget sb_target; 802314564Sdim TargetSP target_sp; 803314564Sdim if (m_opaque_sp) { 804321369Sdim Status error; 805314564Sdim const bool add_dependent_modules = true; 806254721Semaste 807314564Sdim error = m_opaque_sp->GetTargetList().CreateTarget( 808344779Sdim *m_opaque_sp, filename, arch_cstr, 809344779Sdim add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, 810314564Sdim target_sp); 811254721Semaste 812314564Sdim if (error.Success()) { 813314564Sdim m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get()); 814314564Sdim sb_target.SetSP(target_sp); 815254721Semaste } 816314564Sdim } 817254721Semaste 818360784Sdim LLDB_LOGF(log, 819360784Sdim "SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", " 820360784Sdim "arch=%s) => SBTarget(%p)", 821360784Sdim static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr, 822360784Sdim static_cast<void *>(target_sp.get())); 823254721Semaste 824353358Sdim return LLDB_RECORD_RESULT(sb_target); 825254721Semaste} 826254721Semaste 827314564SdimSBTarget SBDebugger::CreateTarget(const char *filename) { 828353358Sdim LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *), 829353358Sdim filename); 830353358Sdim 831314564Sdim SBTarget sb_target; 832314564Sdim TargetSP target_sp; 833314564Sdim if (m_opaque_sp) { 834321369Sdim Status error; 835314564Sdim const bool add_dependent_modules = true; 836314564Sdim error = m_opaque_sp->GetTargetList().CreateTarget( 837344779Sdim *m_opaque_sp, filename, "", 838344779Sdim add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, 839344779Sdim target_sp); 840254721Semaste 841314564Sdim if (error.Success()) { 842314564Sdim m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get()); 843314564Sdim sb_target.SetSP(target_sp); 844254721Semaste } 845314564Sdim } 846314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 847360784Sdim LLDB_LOGF(log, 848360784Sdim "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 849360784Sdim static_cast<void *>(m_opaque_sp.get()), filename, 850360784Sdim static_cast<void *>(target_sp.get())); 851353358Sdim return LLDB_RECORD_RESULT(sb_target); 852254721Semaste} 853254721Semaste 854327952SdimSBTarget SBDebugger::GetDummyTarget() { 855353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); 856353358Sdim 857327952Sdim SBTarget sb_target; 858327952Sdim if (m_opaque_sp) { 859360784Sdim sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this()); 860327952Sdim } 861327952Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 862360784Sdim LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)", 863360784Sdim static_cast<void *>(m_opaque_sp.get()), 864360784Sdim static_cast<void *>(sb_target.GetSP().get())); 865353358Sdim return LLDB_RECORD_RESULT(sb_target); 866327952Sdim} 867327952Sdim 868314564Sdimbool SBDebugger::DeleteTarget(lldb::SBTarget &target) { 869353358Sdim LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), 870353358Sdim target); 871353358Sdim 872314564Sdim bool result = false; 873314564Sdim if (m_opaque_sp) { 874314564Sdim TargetSP target_sp(target.GetSP()); 875314564Sdim if (target_sp) { 876314564Sdim // No need to lock, the target list is thread safe 877314564Sdim result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp); 878314564Sdim target_sp->Destroy(); 879314564Sdim target.Clear(); 880314564Sdim const bool mandatory = true; 881314564Sdim ModuleList::RemoveOrphanSharedModules(mandatory); 882254721Semaste } 883314564Sdim } 884254721Semaste 885314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 886360784Sdim LLDB_LOGF(log, "SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", 887360784Sdim static_cast<void *>(m_opaque_sp.get()), 888360784Sdim static_cast<void *>(target.m_opaque_sp.get()), result); 889254721Semaste 890314564Sdim return result; 891254721Semaste} 892296417Sdim 893314564SdimSBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) { 894353358Sdim LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t), 895353358Sdim idx); 896353358Sdim 897314564Sdim SBTarget sb_target; 898314564Sdim if (m_opaque_sp) { 899314564Sdim // No need to lock, the target list is thread safe 900314564Sdim sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx)); 901314564Sdim } 902353358Sdim return LLDB_RECORD_RESULT(sb_target); 903254721Semaste} 904254721Semaste 905314564Sdimuint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { 906353358Sdim LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget), 907353358Sdim target); 908254721Semaste 909314564Sdim lldb::TargetSP target_sp = target.GetSP(); 910314564Sdim if (!target_sp) 911314564Sdim return UINT32_MAX; 912254721Semaste 913314564Sdim if (!m_opaque_sp) 914314564Sdim return UINT32_MAX; 915254721Semaste 916314564Sdim return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP()); 917254721Semaste} 918254721Semaste 919314564SdimSBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) { 920353358Sdim LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, 921353358Sdim (lldb::pid_t), pid); 922353358Sdim 923314564Sdim SBTarget sb_target; 924314564Sdim if (m_opaque_sp) { 925314564Sdim // No need to lock, the target list is thread safe 926314564Sdim sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid)); 927314564Sdim } 928353358Sdim return LLDB_RECORD_RESULT(sb_target); 929254721Semaste} 930254721Semaste 931314564SdimSBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, 932314564Sdim const char *arch_name) { 933353358Sdim LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, 934353358Sdim (const char *, const char *), filename, arch_name); 935353358Sdim 936314564Sdim SBTarget sb_target; 937314564Sdim if (m_opaque_sp && filename && filename[0]) { 938314564Sdim // No need to lock, the target list is thread safe 939327952Sdim ArchSpec arch = Platform::GetAugmentedArchSpec( 940327952Sdim m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name); 941314564Sdim TargetSP target_sp( 942314564Sdim m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture( 943344779Sdim FileSpec(filename), arch_name ? &arch : nullptr)); 944314564Sdim sb_target.SetSP(target_sp); 945314564Sdim } 946353358Sdim return LLDB_RECORD_RESULT(sb_target); 947254721Semaste} 948254721Semaste 949314564SdimSBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { 950314564Sdim SBTarget sb_target; 951314564Sdim if (m_opaque_sp) { 952314564Sdim // No need to lock, the target list is thread safe 953314564Sdim sb_target.SetSP( 954314564Sdim m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get())); 955314564Sdim } 956314564Sdim return sb_target; 957254721Semaste} 958254721Semaste 959314564Sdimuint32_t SBDebugger::GetNumTargets() { 960353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); 961353358Sdim 962314564Sdim if (m_opaque_sp) { 963314564Sdim // No need to lock, the target list is thread safe 964314564Sdim return m_opaque_sp->GetTargetList().GetNumTargets(); 965314564Sdim } 966314564Sdim return 0; 967254721Semaste} 968254721Semaste 969314564SdimSBTarget SBDebugger::GetSelectedTarget() { 970353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); 971353358Sdim 972314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 973254721Semaste 974314564Sdim SBTarget sb_target; 975314564Sdim TargetSP target_sp; 976314564Sdim if (m_opaque_sp) { 977314564Sdim // No need to lock, the target list is thread safe 978314564Sdim target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget(); 979314564Sdim sb_target.SetSP(target_sp); 980314564Sdim } 981254721Semaste 982314564Sdim if (log) { 983314564Sdim SBStream sstr; 984314564Sdim sb_target.GetDescription(sstr, eDescriptionLevelBrief); 985360784Sdim LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", 986360784Sdim static_cast<void *>(m_opaque_sp.get()), 987360784Sdim static_cast<void *>(target_sp.get()), sstr.GetData()); 988314564Sdim } 989254721Semaste 990353358Sdim return LLDB_RECORD_RESULT(sb_target); 991254721Semaste} 992254721Semaste 993314564Sdimvoid SBDebugger::SetSelectedTarget(SBTarget &sb_target) { 994353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &), 995353358Sdim sb_target); 996353358Sdim 997314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 998254721Semaste 999314564Sdim TargetSP target_sp(sb_target.GetSP()); 1000314564Sdim if (m_opaque_sp) { 1001314564Sdim m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get()); 1002314564Sdim } 1003314564Sdim if (log) { 1004314564Sdim SBStream sstr; 1005314564Sdim sb_target.GetDescription(sstr, eDescriptionLevelBrief); 1006360784Sdim LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", 1007360784Sdim static_cast<void *>(m_opaque_sp.get()), 1008360784Sdim static_cast<void *>(target_sp.get()), sstr.GetData()); 1009314564Sdim } 1010254721Semaste} 1011254721Semaste 1012314564SdimSBPlatform SBDebugger::GetSelectedPlatform() { 1013353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); 1014353358Sdim 1015314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1016258884Semaste 1017314564Sdim SBPlatform sb_platform; 1018314564Sdim DebuggerSP debugger_sp(m_opaque_sp); 1019314564Sdim if (debugger_sp) { 1020314564Sdim sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); 1021314564Sdim } 1022360784Sdim LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", 1023360784Sdim static_cast<void *>(m_opaque_sp.get()), 1024360784Sdim static_cast<void *>(sb_platform.GetSP().get()), 1025360784Sdim sb_platform.GetName()); 1026353358Sdim return LLDB_RECORD_RESULT(sb_platform); 1027258884Semaste} 1028258884Semaste 1029314564Sdimvoid SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { 1030353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform, 1031353358Sdim (lldb::SBPlatform &), sb_platform); 1032353358Sdim 1033314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1034276479Sdim 1035314564Sdim DebuggerSP debugger_sp(m_opaque_sp); 1036314564Sdim if (debugger_sp) { 1037314564Sdim debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); 1038314564Sdim } 1039276479Sdim 1040360784Sdim LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", 1041360784Sdim static_cast<void *>(m_opaque_sp.get()), 1042360784Sdim static_cast<void *>(sb_platform.GetSP().get()), 1043360784Sdim sb_platform.GetName()); 1044258884Semaste} 1045258884Semaste 1046327952Sdimuint32_t SBDebugger::GetNumPlatforms() { 1047353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); 1048353358Sdim 1049327952Sdim if (m_opaque_sp) { 1050327952Sdim // No need to lock, the platform list is thread safe 1051327952Sdim return m_opaque_sp->GetPlatformList().GetSize(); 1052327952Sdim } 1053327952Sdim return 0; 1054327952Sdim} 1055327952Sdim 1056327952SdimSBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) { 1057353358Sdim LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, 1058353358Sdim (uint32_t), idx); 1059353358Sdim 1060327952Sdim SBPlatform sb_platform; 1061327952Sdim if (m_opaque_sp) { 1062327952Sdim // No need to lock, the platform list is thread safe 1063327952Sdim sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx)); 1064327952Sdim } 1065353358Sdim return LLDB_RECORD_RESULT(sb_platform); 1066327952Sdim} 1067327952Sdim 1068327952Sdimuint32_t SBDebugger::GetNumAvailablePlatforms() { 1069353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms); 1070353358Sdim 1071327952Sdim uint32_t idx = 0; 1072327952Sdim while (true) { 1073327952Sdim if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) { 1074327952Sdim break; 1075327952Sdim } 1076327952Sdim ++idx; 1077327952Sdim } 1078327952Sdim // +1 for the host platform, which should always appear first in the list. 1079327952Sdim return idx + 1; 1080327952Sdim} 1081327952Sdim 1082327952SdimSBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { 1083353358Sdim LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, 1084353358Sdim GetAvailablePlatformInfoAtIndex, (uint32_t), idx); 1085353358Sdim 1086327952Sdim SBStructuredData data; 1087360784Sdim auto platform_dict = std::make_unique<StructuredData::Dictionary>(); 1088327952Sdim llvm::StringRef name_str("name"), desc_str("description"); 1089327952Sdim 1090327952Sdim if (idx == 0) { 1091327952Sdim PlatformSP host_platform_sp(Platform::GetHostPlatform()); 1092327952Sdim platform_dict->AddStringItem( 1093327952Sdim name_str, host_platform_sp->GetPluginName().GetStringRef()); 1094327952Sdim platform_dict->AddStringItem( 1095327952Sdim desc_str, llvm::StringRef(host_platform_sp->GetDescription())); 1096327952Sdim } else if (idx > 0) { 1097327952Sdim const char *plugin_name = 1098327952Sdim PluginManager::GetPlatformPluginNameAtIndex(idx - 1); 1099327952Sdim if (!plugin_name) { 1100353358Sdim return LLDB_RECORD_RESULT(data); 1101327952Sdim } 1102327952Sdim platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name)); 1103327952Sdim 1104327952Sdim const char *plugin_desc = 1105327952Sdim PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1); 1106327952Sdim if (!plugin_desc) { 1107353358Sdim return LLDB_RECORD_RESULT(data); 1108327952Sdim } 1109327952Sdim platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc)); 1110327952Sdim } 1111327952Sdim 1112327952Sdim data.m_impl_up->SetObjectSP( 1113327952Sdim StructuredData::ObjectSP(platform_dict.release())); 1114353358Sdim return LLDB_RECORD_RESULT(data); 1115327952Sdim} 1116327952Sdim 1117314564Sdimvoid SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) { 1118353358Sdim LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, 1119353358Sdim (void *, const void *, size_t), baton, data, data_len); 1120353358Sdim 1121314564Sdim DispatchInput(data, data_len); 1122254721Semaste} 1123254721Semaste 1124314564Sdimvoid SBDebugger::DispatchInput(const void *data, size_t data_len) { 1125353358Sdim LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t), 1126353358Sdim data, data_len); 1127353358Sdim 1128314564Sdim // Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1129314564Sdim // 1130314564Sdim // if (log) 1131360784Sdim // LLDB_LOGF(log, "SBDebugger(%p)::DispatchInput (data=\"%.*s\", 1132314564Sdim // size_t=%" PRIu64 ")", 1133314564Sdim // m_opaque_sp.get(), 1134314564Sdim // (int) data_len, 1135314564Sdim // (const char *) data, 1136314564Sdim // (uint64_t)data_len); 1137314564Sdim // 1138314564Sdim // if (m_opaque_sp) 1139314564Sdim // m_opaque_sp->DispatchInput ((const char *) data, data_len); 1140254721Semaste} 1141254721Semaste 1142314564Sdimvoid SBDebugger::DispatchInputInterrupt() { 1143360784Sdim LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); 1144353358Sdim 1145314564Sdim if (m_opaque_sp) 1146314564Sdim m_opaque_sp->DispatchInputInterrupt(); 1147254721Semaste} 1148254721Semaste 1149314564Sdimvoid SBDebugger::DispatchInputEndOfFile() { 1150353358Sdim LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); 1151353358Sdim 1152314564Sdim if (m_opaque_sp) 1153314564Sdim m_opaque_sp->DispatchInputEndOfFile(); 1154254721Semaste} 1155254721Semaste 1156353358Sdimvoid SBDebugger::PushInputReader(SBInputReader &reader) { 1157353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &), 1158353358Sdim reader); 1159353358Sdim} 1160254721Semaste 1161314564Sdimvoid SBDebugger::RunCommandInterpreter(bool auto_handle_events, 1162314564Sdim bool spawn_thread) { 1163353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), 1164353358Sdim auto_handle_events, spawn_thread); 1165353358Sdim 1166314564Sdim if (m_opaque_sp) { 1167314564Sdim CommandInterpreterRunOptions options; 1168280031Sdim 1169314564Sdim m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter( 1170314564Sdim auto_handle_events, spawn_thread, options); 1171314564Sdim } 1172254721Semaste} 1173254721Semaste 1174314564Sdimvoid SBDebugger::RunCommandInterpreter(bool auto_handle_events, 1175314564Sdim bool spawn_thread, 1176314564Sdim SBCommandInterpreterRunOptions &options, 1177314564Sdim int &num_errors, bool &quit_requested, 1178314564Sdim bool &stopped_for_crash) 1179280031Sdim 1180280031Sdim{ 1181353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, 1182353358Sdim (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &, 1183353358Sdim bool &, bool &), 1184353358Sdim auto_handle_events, spawn_thread, options, num_errors, 1185353358Sdim quit_requested, stopped_for_crash); 1186353358Sdim 1187314564Sdim if (m_opaque_sp) { 1188314564Sdim CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); 1189314564Sdim interp.RunCommandInterpreter(auto_handle_events, spawn_thread, 1190314564Sdim options.ref()); 1191314564Sdim num_errors = interp.GetNumErrors(); 1192314564Sdim quit_requested = interp.GetQuitRequested(); 1193314564Sdim stopped_for_crash = interp.GetStoppedForCrash(); 1194314564Sdim } 1195280031Sdim} 1196280031Sdim 1197314564SdimSBError SBDebugger::RunREPL(lldb::LanguageType language, 1198314564Sdim const char *repl_options) { 1199353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL, 1200353358Sdim (lldb::LanguageType, const char *), language, 1201353358Sdim repl_options); 1202353358Sdim 1203314564Sdim SBError error; 1204314564Sdim if (m_opaque_sp) 1205314564Sdim error.ref() = m_opaque_sp->RunREPL(language, repl_options); 1206314564Sdim else 1207314564Sdim error.SetErrorString("invalid debugger"); 1208353358Sdim return LLDB_RECORD_RESULT(error); 1209296417Sdim} 1210296417Sdim 1211314564Sdimvoid SBDebugger::reset(const DebuggerSP &debugger_sp) { 1212314564Sdim m_opaque_sp = debugger_sp; 1213254721Semaste} 1214254721Semaste 1215314564SdimDebugger *SBDebugger::get() const { return m_opaque_sp.get(); } 1216254721Semaste 1217314564SdimDebugger &SBDebugger::ref() const { 1218314564Sdim assert(m_opaque_sp.get()); 1219314564Sdim return *m_opaque_sp; 1220254721Semaste} 1221254721Semaste 1222314564Sdimconst lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; } 1223254721Semaste 1224314564SdimSBDebugger SBDebugger::FindDebuggerWithID(int id) { 1225353358Sdim LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, 1226353358Sdim (int), id); 1227353358Sdim 1228314564Sdim // No need to lock, the debugger list is thread safe 1229314564Sdim SBDebugger sb_debugger; 1230314564Sdim DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id); 1231314564Sdim if (debugger_sp) 1232314564Sdim sb_debugger.reset(debugger_sp); 1233353358Sdim return LLDB_RECORD_RESULT(sb_debugger); 1234254721Semaste} 1235254721Semaste 1236314564Sdimconst char *SBDebugger::GetInstanceName() { 1237353358Sdim LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); 1238353358Sdim 1239314564Sdim return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); 1240254721Semaste} 1241254721Semaste 1242314564SdimSBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, 1243314564Sdim const char *debugger_instance_name) { 1244353358Sdim LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, 1245353358Sdim (const char *, const char *, const char *), 1246353358Sdim var_name, value, debugger_instance_name); 1247353358Sdim 1248314564Sdim SBError sb_error; 1249314564Sdim DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( 1250314564Sdim ConstString(debugger_instance_name))); 1251321369Sdim Status error; 1252314564Sdim if (debugger_sp) { 1253314564Sdim ExecutionContext exe_ctx( 1254314564Sdim debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1255314564Sdim error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign, 1256314564Sdim var_name, value); 1257314564Sdim } else { 1258314564Sdim error.SetErrorStringWithFormat("invalid debugger instance name '%s'", 1259314564Sdim debugger_instance_name); 1260314564Sdim } 1261314564Sdim if (error.Fail()) 1262314564Sdim sb_error.SetError(error); 1263353358Sdim return LLDB_RECORD_RESULT(sb_error); 1264254721Semaste} 1265254721Semaste 1266254721SemasteSBStringList 1267314564SdimSBDebugger::GetInternalVariableValue(const char *var_name, 1268314564Sdim const char *debugger_instance_name) { 1269353358Sdim LLDB_RECORD_STATIC_METHOD( 1270353358Sdim lldb::SBStringList, SBDebugger, GetInternalVariableValue, 1271353358Sdim (const char *, const char *), var_name, debugger_instance_name); 1272353358Sdim 1273314564Sdim SBStringList ret_value; 1274314564Sdim DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( 1275314564Sdim ConstString(debugger_instance_name))); 1276321369Sdim Status error; 1277314564Sdim if (debugger_sp) { 1278314564Sdim ExecutionContext exe_ctx( 1279314564Sdim debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1280314564Sdim lldb::OptionValueSP value_sp( 1281314564Sdim debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error)); 1282314564Sdim if (value_sp) { 1283314564Sdim StreamString value_strm; 1284314564Sdim value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 1285314564Sdim const std::string &value_str = value_strm.GetString(); 1286314564Sdim if (!value_str.empty()) { 1287314564Sdim StringList string_list; 1288314564Sdim string_list.SplitIntoLines(value_str); 1289353358Sdim return LLDB_RECORD_RESULT(SBStringList(&string_list)); 1290314564Sdim } 1291254721Semaste } 1292314564Sdim } 1293353358Sdim return LLDB_RECORD_RESULT(SBStringList()); 1294254721Semaste} 1295254721Semaste 1296314564Sdimuint32_t SBDebugger::GetTerminalWidth() const { 1297353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth); 1298353358Sdim 1299314564Sdim return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0); 1300254721Semaste} 1301254721Semaste 1302314564Sdimvoid SBDebugger::SetTerminalWidth(uint32_t term_width) { 1303360784Sdim LLDB_RECORD_DUMMY(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width); 1304353358Sdim 1305314564Sdim if (m_opaque_sp) 1306314564Sdim m_opaque_sp->SetTerminalWidth(term_width); 1307254721Semaste} 1308254721Semaste 1309314564Sdimconst char *SBDebugger::GetPrompt() const { 1310353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); 1311353358Sdim 1312314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1313276479Sdim 1314360784Sdim LLDB_LOGF(log, "SBDebugger(%p)::GetPrompt () => \"%s\"", 1315360784Sdim static_cast<void *>(m_opaque_sp.get()), 1316360784Sdim (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : "")); 1317254721Semaste 1318314564Sdim return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString() 1319314564Sdim : nullptr); 1320254721Semaste} 1321254721Semaste 1322314564Sdimvoid SBDebugger::SetPrompt(const char *prompt) { 1323353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt); 1324353358Sdim 1325314564Sdim if (m_opaque_sp) 1326314564Sdim m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt)); 1327254721Semaste} 1328314564Sdim 1329344779Sdimconst char *SBDebugger::GetReproducerPath() const { 1330353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath); 1331353358Sdim 1332344779Sdim return (m_opaque_sp 1333344779Sdim ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString() 1334344779Sdim : nullptr); 1335344779Sdim} 1336344779Sdim 1337314564SdimScriptLanguage SBDebugger::GetScriptLanguage() const { 1338353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, 1339353358Sdim GetScriptLanguage); 1340353358Sdim 1341314564Sdim return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone); 1342254721Semaste} 1343254721Semaste 1344314564Sdimvoid SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) { 1345353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage, 1346353358Sdim (lldb::ScriptLanguage), script_lang); 1347353358Sdim 1348314564Sdim if (m_opaque_sp) { 1349314564Sdim m_opaque_sp->SetScriptLanguage(script_lang); 1350314564Sdim } 1351254721Semaste} 1352254721Semaste 1353314564Sdimbool SBDebugger::SetUseExternalEditor(bool value) { 1354353358Sdim LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); 1355353358Sdim 1356314564Sdim return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); 1357254721Semaste} 1358254721Semaste 1359314564Sdimbool SBDebugger::GetUseExternalEditor() { 1360353358Sdim LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); 1361353358Sdim 1362314564Sdim return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); 1363254721Semaste} 1364254721Semaste 1365314564Sdimbool SBDebugger::SetUseColor(bool value) { 1366353358Sdim LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value); 1367353358Sdim 1368314564Sdim return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); 1369254721Semaste} 1370254721Semaste 1371314564Sdimbool SBDebugger::GetUseColor() const { 1372353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); 1373353358Sdim 1374314564Sdim return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); 1375254721Semaste} 1376254721Semaste 1377314564Sdimbool SBDebugger::GetDescription(SBStream &description) { 1378353358Sdim LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), 1379353358Sdim description); 1380353358Sdim 1381314564Sdim Stream &strm = description.ref(); 1382254721Semaste 1383314564Sdim if (m_opaque_sp) { 1384314564Sdim const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1385314564Sdim user_id_t id = m_opaque_sp->GetID(); 1386314564Sdim strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1387314564Sdim } else 1388314564Sdim strm.PutCString("No value"); 1389314564Sdim 1390314564Sdim return true; 1391254721Semaste} 1392254721Semaste 1393314564Sdimuser_id_t SBDebugger::GetID() { 1394353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID); 1395353358Sdim 1396314564Sdim return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID); 1397254721Semaste} 1398254721Semaste 1399314564SdimSBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { 1400353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, 1401353358Sdim (const char *), platform_name_cstr); 1402353358Sdim 1403314564Sdim SBError sb_error; 1404314564Sdim if (m_opaque_sp) { 1405314564Sdim if (platform_name_cstr && platform_name_cstr[0]) { 1406314564Sdim ConstString platform_name(platform_name_cstr); 1407314564Sdim PlatformSP platform_sp(Platform::Find(platform_name)); 1408280031Sdim 1409314564Sdim if (platform_sp) { 1410314564Sdim // Already have a platform with this name, just select it 1411314564Sdim m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp); 1412314564Sdim } else { 1413314564Sdim // We don't have a platform by this name yet, create one 1414314564Sdim platform_sp = Platform::Create(platform_name, sb_error.ref()); 1415314564Sdim if (platform_sp) { 1416314564Sdim // We created the platform, now append and select it 1417314564Sdim bool make_selected = true; 1418314564Sdim m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected); 1419254721Semaste } 1420314564Sdim } 1421314564Sdim } else { 1422314564Sdim sb_error.ref().SetErrorString("invalid platform name"); 1423254721Semaste } 1424314564Sdim } else { 1425314564Sdim sb_error.ref().SetErrorString("invalid debugger"); 1426314564Sdim } 1427353358Sdim return LLDB_RECORD_RESULT(sb_error); 1428254721Semaste} 1429254721Semaste 1430314564Sdimbool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { 1431353358Sdim LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, 1432353358Sdim (const char *), sysroot); 1433353358Sdim 1434314564Sdim Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1435314564Sdim if (m_opaque_sp) { 1436314564Sdim PlatformSP platform_sp( 1437314564Sdim m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1438314564Sdim 1439314564Sdim if (platform_sp) { 1440314564Sdim if (log && sysroot) 1441360784Sdim LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", 1442360784Sdim sysroot); 1443314564Sdim platform_sp->SetSDKRootDirectory(ConstString(sysroot)); 1444314564Sdim return true; 1445254721Semaste } 1446314564Sdim } 1447314564Sdim return false; 1448254721Semaste} 1449254721Semaste 1450314564Sdimbool SBDebugger::GetCloseInputOnEOF() const { 1451353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); 1452353358Sdim 1453314564Sdim return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); 1454254721Semaste} 1455254721Semaste 1456314564Sdimvoid SBDebugger::SetCloseInputOnEOF(bool b) { 1457353358Sdim LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); 1458353358Sdim 1459314564Sdim if (m_opaque_sp) 1460314564Sdim m_opaque_sp->SetCloseInputOnEOF(b); 1461254721Semaste} 1462254721Semaste 1463314564SdimSBTypeCategory SBDebugger::GetCategory(const char *category_name) { 1464353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1465353358Sdim (const char *), category_name); 1466353358Sdim 1467314564Sdim if (!category_name || *category_name == 0) 1468353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory()); 1469314564Sdim 1470314564Sdim TypeCategoryImplSP category_sp; 1471314564Sdim 1472314564Sdim if (DataVisualization::Categories::GetCategory(ConstString(category_name), 1473353358Sdim category_sp, false)) { 1474353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1475353358Sdim } else { 1476353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory()); 1477353358Sdim } 1478254721Semaste} 1479254721Semaste 1480314564SdimSBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { 1481353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1482353358Sdim (lldb::LanguageType), lang_type); 1483353358Sdim 1484314564Sdim TypeCategoryImplSP category_sp; 1485353358Sdim if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) { 1486353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1487353358Sdim } else { 1488353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory()); 1489353358Sdim } 1490296417Sdim} 1491296417Sdim 1492314564SdimSBTypeCategory SBDebugger::CreateCategory(const char *category_name) { 1493353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, 1494353358Sdim (const char *), category_name); 1495353358Sdim 1496314564Sdim if (!category_name || *category_name == 0) 1497353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory()); 1498314564Sdim 1499314564Sdim TypeCategoryImplSP category_sp; 1500314564Sdim 1501314564Sdim if (DataVisualization::Categories::GetCategory(ConstString(category_name), 1502353358Sdim category_sp, true)) { 1503353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1504353358Sdim } else { 1505353358Sdim return LLDB_RECORD_RESULT(SBTypeCategory()); 1506353358Sdim } 1507254721Semaste} 1508254721Semaste 1509314564Sdimbool SBDebugger::DeleteCategory(const char *category_name) { 1510353358Sdim LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *), 1511353358Sdim category_name); 1512353358Sdim 1513314564Sdim if (!category_name || *category_name == 0) 1514314564Sdim return false; 1515314564Sdim 1516314564Sdim return DataVisualization::Categories::Delete(ConstString(category_name)); 1517254721Semaste} 1518254721Semaste 1519314564Sdimuint32_t SBDebugger::GetNumCategories() { 1520353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); 1521353358Sdim 1522314564Sdim return DataVisualization::Categories::GetCount(); 1523254721Semaste} 1524254721Semaste 1525314564SdimSBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) { 1526353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, 1527353358Sdim (uint32_t), index); 1528353358Sdim 1529353358Sdim return LLDB_RECORD_RESULT( 1530353358Sdim SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index))); 1531254721Semaste} 1532254721Semaste 1533314564SdimSBTypeCategory SBDebugger::GetDefaultCategory() { 1534353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, 1535353358Sdim GetDefaultCategory); 1536353358Sdim 1537353358Sdim return LLDB_RECORD_RESULT(GetCategory("default")); 1538254721Semaste} 1539254721Semaste 1540314564SdimSBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) { 1541353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, 1542353358Sdim (lldb::SBTypeNameSpecifier), type_name); 1543353358Sdim 1544314564Sdim SBTypeCategory default_category_sb = GetDefaultCategory(); 1545314564Sdim if (default_category_sb.GetEnabled()) 1546353358Sdim return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name)); 1547353358Sdim return LLDB_RECORD_RESULT(SBTypeFormat()); 1548254721Semaste} 1549254721Semaste 1550314564SdimSBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { 1551353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, 1552353358Sdim (lldb::SBTypeNameSpecifier), type_name); 1553353358Sdim 1554314564Sdim if (!type_name.IsValid()) 1555353358Sdim return LLDB_RECORD_RESULT(SBTypeSummary()); 1556353358Sdim return LLDB_RECORD_RESULT( 1557353358Sdim SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()))); 1558254721Semaste} 1559254721Semaste 1560314564SdimSBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { 1561353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, 1562353358Sdim (lldb::SBTypeNameSpecifier), type_name); 1563353358Sdim 1564314564Sdim if (!type_name.IsValid()) 1565353358Sdim return LLDB_RECORD_RESULT(SBTypeFilter()); 1566353358Sdim return LLDB_RECORD_RESULT( 1567353358Sdim SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()))); 1568254721Semaste} 1569254721Semaste 1570314564SdimSBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { 1571353358Sdim LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, 1572353358Sdim (lldb::SBTypeNameSpecifier), type_name); 1573353358Sdim 1574314564Sdim if (!type_name.IsValid()) 1575353358Sdim return LLDB_RECORD_RESULT(SBTypeSynthetic()); 1576353358Sdim return LLDB_RECORD_RESULT(SBTypeSynthetic( 1577353358Sdim DataVisualization::GetSyntheticForType(type_name.GetSP()))); 1578254721Semaste} 1579254721Semaste 1580321369Sdimstatic llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { 1581321369Sdim if (categories == nullptr) 1582321369Sdim return {}; 1583321369Sdim size_t len = 0; 1584321369Sdim while (categories[len] != nullptr) 1585321369Sdim ++len; 1586321369Sdim return llvm::makeArrayRef(categories, len); 1587321369Sdim} 1588321369Sdim 1589314564Sdimbool SBDebugger::EnableLog(const char *channel, const char **categories) { 1590353358Sdim LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **), 1591353358Sdim channel, categories); 1592353358Sdim 1593314564Sdim if (m_opaque_sp) { 1594314564Sdim uint32_t log_options = 1595314564Sdim LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1596321369Sdim std::string error; 1597321369Sdim llvm::raw_string_ostream error_stream(error); 1598321369Sdim return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "", 1599321369Sdim log_options, error_stream); 1600314564Sdim } else 1601314564Sdim return false; 1602254721Semaste} 1603254721Semaste 1604314564Sdimvoid SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, 1605314564Sdim void *baton) { 1606353358Sdim LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback, 1607353358Sdim (lldb::LogOutputCallback, void *), log_callback, baton); 1608353358Sdim 1609314564Sdim if (m_opaque_sp) { 1610314564Sdim return m_opaque_sp->SetLoggingCallback(log_callback, baton); 1611314564Sdim } 1612254721Semaste} 1613353358Sdim 1614353358Sdimnamespace lldb_private { 1615353358Sdimnamespace repro { 1616353358Sdim 1617360784Sdimtemplate <> void RegisterMethods<SBInputReader>(Registry &R) { 1618353358Sdim LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool)); 1619353358Sdim LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ()); 1620353358Sdim} 1621353358Sdim 1622353358Sdimstatic void SetFileHandleRedirect(SBDebugger *, FILE *, bool) { 1623353358Sdim // Do nothing. 1624353358Sdim} 1625353358Sdim 1626360784Sdimstatic SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); } 1627360784Sdim 1628360784Sdimstatic SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); } 1629360784Sdim 1630353358Sdimstatic bool GetDefaultArchitectureRedirect(char *arch_name, 1631353358Sdim size_t arch_name_len) { 1632353358Sdim // The function is writing to its argument. Without the redirect it would 1633353358Sdim // write into the replay buffer. 1634353358Sdim char buffer[1024]; 1635353358Sdim return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len); 1636353358Sdim} 1637353358Sdim 1638360784Sdimtemplate <> void RegisterMethods<SBDebugger>(Registry &R) { 1639353358Sdim // Custom implementation. 1640353358Sdim R.Register(&invoke<void (SBDebugger::*)( 1641353358Sdim FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit, 1642353358Sdim &SetFileHandleRedirect); 1643353358Sdim R.Register(&invoke<void (SBDebugger::*)( 1644353358Sdim FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit, 1645353358Sdim &SetFileHandleRedirect); 1646353358Sdim R.Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>( 1647353358Sdim &SBDebugger::GetDefaultArchitecture), 1648353358Sdim &GetDefaultArchitectureRedirect); 1649353358Sdim 1650360784Sdim R.Register(&invoke<SBError (SBDebugger::*)( 1651360784Sdim SBFile)>::method<&SBDebugger::SetInputFile>::doit, 1652360784Sdim &SetFileRedirect); 1653360784Sdim R.Register(&invoke<SBError (SBDebugger::*)( 1654360784Sdim SBFile)>::method<&SBDebugger::SetOutputFile>::doit, 1655360784Sdim &SetFileRedirect); 1656360784Sdim R.Register(&invoke<SBError (SBDebugger::*)( 1657360784Sdim SBFile)>::method<&SBDebugger::SetErrorFile>::doit, 1658360784Sdim &SetFileRedirect); 1659360784Sdim 1660360784Sdim R.Register(&invoke<SBError (SBDebugger::*)( 1661360784Sdim FileSP)>::method<&SBDebugger::SetInputFile>::doit, 1662360784Sdim &SetFileRedirect); 1663360784Sdim R.Register(&invoke<SBError (SBDebugger::*)( 1664360784Sdim FileSP)>::method<&SBDebugger::SetOutputFile>::doit, 1665360784Sdim &SetFileRedirect); 1666360784Sdim R.Register(&invoke<SBError (SBDebugger::*)( 1667360784Sdim FileSP)>::method<&SBDebugger::SetErrorFile>::doit, 1668360784Sdim &SetFileRedirect); 1669360784Sdim 1670353358Sdim LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ()); 1671353358Sdim LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &)); 1672353358Sdim LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &)); 1673353358Sdim LLDB_REGISTER_METHOD(lldb::SBDebugger &, 1674353358Sdim SBDebugger, operator=,(const lldb::SBDebugger &)); 1675353358Sdim LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ()); 1676353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, 1677353358Sdim InitializeWithErrorHandling, ()); 1678353358Sdim LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ()); 1679353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ()); 1680353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ()); 1681353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool)); 1682360784Sdim LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &)); 1683353358Sdim LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ()); 1684353358Sdim LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ()); 1685360784Sdim LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,()); 1686353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool)); 1687353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ()); 1688353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool)); 1689353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool)); 1690353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool)); 1691353358Sdim LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ()); 1692353358Sdim LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ()); 1693353358Sdim LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ()); 1694360784Sdim LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ()); 1695360784Sdim LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ()); 1696360784Sdim LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ()); 1697353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ()); 1698353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ()); 1699353358Sdim LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger, 1700353358Sdim GetCommandInterpreter, ()); 1701353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *)); 1702353358Sdim LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ()); 1703353358Sdim LLDB_REGISTER_METHOD( 1704353358Sdim void, SBDebugger, HandleProcessEvent, 1705353358Sdim (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *)); 1706360784Sdim LLDB_REGISTER_METHOD( 1707360784Sdim void, SBDebugger, HandleProcessEvent, 1708360784Sdim (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile)); 1709360784Sdim LLDB_REGISTER_METHOD( 1710360784Sdim void, SBDebugger, HandleProcessEvent, 1711360784Sdim (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP)); 1712360784Sdim LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ()); 1713353358Sdim LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, 1714353358Sdim (const char *)); 1715353358Sdim LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, 1716353358Sdim (const char *)); 1717353358Sdim LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ()); 1718353358Sdim LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString, 1719353358Sdim (lldb::StateType)); 1720353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger, 1721353358Sdim GetBuildConfiguration, ()); 1722353358Sdim LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, 1723353358Sdim (lldb::StateType)); 1724353358Sdim LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, 1725353358Sdim (lldb::StateType)); 1726353358Sdim LLDB_REGISTER_METHOD( 1727353358Sdim lldb::SBTarget, SBDebugger, CreateTarget, 1728353358Sdim (const char *, const char *, const char *, bool, lldb::SBError &)); 1729353358Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, 1730353358Sdim CreateTargetWithFileAndTargetTriple, 1731353358Sdim (const char *, const char *)); 1732360784Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, 1733353358Sdim (const char *, const char *)); 1734353358Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, 1735353358Sdim (const char *)); 1736353358Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ()); 1737353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &)); 1738353358Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, 1739353358Sdim (uint32_t)); 1740353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, 1741353358Sdim (lldb::SBTarget)); 1742353358Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, 1743353358Sdim (lldb::pid_t)); 1744353358Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, 1745353358Sdim (const char *, const char *)); 1746353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ()); 1747353358Sdim LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ()); 1748360784Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &)); 1749353358Sdim LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ()); 1750353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform, 1751353358Sdim (lldb::SBPlatform &)); 1752353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ()); 1753353358Sdim LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, 1754353358Sdim (uint32_t)); 1755353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ()); 1756353358Sdim LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger, 1757353358Sdim GetAvailablePlatformInfoAtIndex, (uint32_t)); 1758353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ()); 1759353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ()); 1760353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader, 1761353358Sdim (lldb::SBInputReader &)); 1762353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool)); 1763353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, 1764353358Sdim (bool, bool, lldb::SBCommandInterpreterRunOptions &, 1765353358Sdim int &, bool &, bool &)); 1766353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL, 1767353358Sdim (lldb::LanguageType, const char *)); 1768360784Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, 1769360784Sdim (int)); 1770353358Sdim LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ()); 1771353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, 1772353358Sdim (const char *, const char *, const char *)); 1773353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger, 1774353358Sdim GetInternalVariableValue, 1775353358Sdim (const char *, const char *)); 1776353358Sdim LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ()); 1777353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t)); 1778353358Sdim LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ()); 1779353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *)); 1780353358Sdim LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ()); 1781353358Sdim LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger, 1782353358Sdim GetScriptLanguage, ()); 1783353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage, 1784353358Sdim (lldb::ScriptLanguage)); 1785353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool)); 1786353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ()); 1787353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool)); 1788353358Sdim LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ()); 1789353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &)); 1790353358Sdim LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ()); 1791353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, 1792353358Sdim (const char *)); 1793353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, 1794353358Sdim (const char *)); 1795353358Sdim LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ()); 1796353358Sdim LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool)); 1797353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1798353358Sdim (const char *)); 1799353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1800353358Sdim (lldb::LanguageType)); 1801353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, 1802353358Sdim (const char *)); 1803353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *)); 1804353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ()); 1805353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, 1806353358Sdim (uint32_t)); 1807353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory, 1808353358Sdim ()); 1809353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, 1810353358Sdim (lldb::SBTypeNameSpecifier)); 1811353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, 1812353358Sdim (lldb::SBTypeNameSpecifier)); 1813353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, 1814353358Sdim (lldb::SBTypeNameSpecifier)); 1815353358Sdim LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, 1816353358Sdim (lldb::SBTypeNameSpecifier)); 1817353358Sdim LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog, 1818353358Sdim (const char *, const char **)); 1819353358Sdim} 1820353358Sdim 1821360784Sdim} // namespace repro 1822360784Sdim} // namespace lldb_private 1823