1 //===-- SBDebugger.cpp ----------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "SBReproducerPrivate.h" 10 #include "SystemInitializerFull.h" 11 12 #include "lldb/API/SBDebugger.h" 13 14 #include "lldb/lldb-private.h" 15 16 #include "lldb/API/SBBroadcaster.h" 17 #include "lldb/API/SBCommandInterpreter.h" 18 #include "lldb/API/SBCommandInterpreterRunOptions.h" 19 #include "lldb/API/SBCommandReturnObject.h" 20 #include "lldb/API/SBError.h" 21 #include "lldb/API/SBEvent.h" 22 #include "lldb/API/SBFile.h" 23 #include "lldb/API/SBFrame.h" 24 #include "lldb/API/SBListener.h" 25 #include "lldb/API/SBProcess.h" 26 #include "lldb/API/SBSourceManager.h" 27 #include "lldb/API/SBStream.h" 28 #include "lldb/API/SBStringList.h" 29 #include "lldb/API/SBStructuredData.h" 30 #include "lldb/API/SBTarget.h" 31 #include "lldb/API/SBThread.h" 32 #include "lldb/API/SBTypeCategory.h" 33 #include "lldb/API/SBTypeFilter.h" 34 #include "lldb/API/SBTypeFormat.h" 35 #include "lldb/API/SBTypeNameSpecifier.h" 36 #include "lldb/API/SBTypeSummary.h" 37 #include "lldb/API/SBTypeSynthetic.h" 38 39 #include "lldb/Core/Debugger.h" 40 #include "lldb/Core/PluginManager.h" 41 #include "lldb/Core/StreamFile.h" 42 #include "lldb/Core/StructuredDataImpl.h" 43 #include "lldb/DataFormatters/DataVisualization.h" 44 #include "lldb/Host/Config.h" 45 #include "lldb/Host/XML.h" 46 #include "lldb/Initialization/SystemLifetimeManager.h" 47 #include "lldb/Interpreter/CommandInterpreter.h" 48 #include "lldb/Interpreter/OptionArgParser.h" 49 #include "lldb/Interpreter/OptionGroupPlatform.h" 50 #include "lldb/Target/Process.h" 51 #include "lldb/Target/TargetList.h" 52 #include "lldb/Utility/Args.h" 53 #include "lldb/Utility/State.h" 54 55 #include "llvm/ADT/STLExtras.h" 56 #include "llvm/ADT/StringRef.h" 57 #include "llvm/Support/DynamicLibrary.h" 58 #include "llvm/Support/ManagedStatic.h" 59 60 using namespace lldb; 61 using namespace lldb_private; 62 63 static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp, 64 const FileSpec &spec, 65 Status &error) { 66 llvm::sys::DynamicLibrary dynlib = 67 llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str()); 68 if (dynlib.isValid()) { 69 typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger); 70 71 lldb::SBDebugger debugger_sb(debugger_sp); 72 // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) 73 // function. 74 // TODO: mangle this differently for your system - on OSX, the first 75 // underscore needs to be removed and the second one stays 76 LLDBCommandPluginInit init_func = 77 (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol( 78 "_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); 79 if (init_func) { 80 if (init_func(debugger_sb)) 81 return dynlib; 82 else 83 error.SetErrorString("plug-in refused to load " 84 "(lldb::PluginInitialize(lldb::SBDebugger) " 85 "returned false)"); 86 } else { 87 error.SetErrorString("plug-in is missing the required initialization: " 88 "lldb::PluginInitialize(lldb::SBDebugger)"); 89 } 90 } else { 91 if (FileSystem::Instance().Exists(spec)) 92 error.SetErrorString("this file does not represent a loadable dylib"); 93 else 94 error.SetErrorString("no such file"); 95 } 96 return llvm::sys::DynamicLibrary(); 97 } 98 99 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime; 100 101 SBError SBInputReader::Initialize( 102 lldb::SBDebugger &sb_debugger, 103 unsigned long (*callback)(void *, lldb::SBInputReader *, 104 lldb::InputReaderAction, char const *, 105 unsigned long), 106 void *a, lldb::InputReaderGranularity b, char const *c, char const *d, 107 bool e) { 108 LLDB_RECORD_DUMMY( 109 lldb::SBError, SBInputReader, Initialize, 110 (lldb::SBDebugger &, 111 unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, 112 const char *, unsigned long), 113 void *, lldb::InputReaderGranularity, const char *, const char *, bool), 114 sb_debugger, callback, a, b, c, d, e); 115 116 return SBError(); 117 } 118 119 void SBInputReader::SetIsDone(bool b) { 120 LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b); 121 } 122 123 bool SBInputReader::IsActive() const { 124 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); 125 126 return false; 127 } 128 129 SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); } 130 131 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) 132 : m_opaque_sp(debugger_sp) { 133 LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp); 134 } 135 136 SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) { 137 LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs); 138 } 139 140 SBDebugger::~SBDebugger() = default; 141 142 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) { 143 LLDB_RECORD_METHOD(lldb::SBDebugger &, 144 SBDebugger, operator=,(const lldb::SBDebugger &), rhs); 145 146 if (this != &rhs) { 147 m_opaque_sp = rhs.m_opaque_sp; 148 } 149 return LLDB_RECORD_RESULT(*this); 150 } 151 152 void SBDebugger::Initialize() { 153 LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize); 154 SBError ignored = SBDebugger::InitializeWithErrorHandling(); 155 } 156 157 lldb::SBError SBDebugger::InitializeWithErrorHandling() { 158 LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger, 159 InitializeWithErrorHandling); 160 161 SBError error; 162 if (auto e = g_debugger_lifetime->Initialize( 163 std::make_unique<SystemInitializerFull>(), LoadPlugin)) { 164 error.SetError(Status(std::move(e))); 165 } 166 return LLDB_RECORD_RESULT(error); 167 } 168 169 void SBDebugger::Terminate() { 170 LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate); 171 172 g_debugger_lifetime->Terminate(); 173 } 174 175 void SBDebugger::Clear() { 176 LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear); 177 178 if (m_opaque_sp) 179 m_opaque_sp->ClearIOHandlers(); 180 181 m_opaque_sp.reset(); 182 } 183 184 SBDebugger SBDebugger::Create() { 185 LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create); 186 187 return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr)); 188 } 189 190 SBDebugger SBDebugger::Create(bool source_init_files) { 191 LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool), 192 source_init_files); 193 194 return LLDB_RECORD_RESULT( 195 SBDebugger::Create(source_init_files, nullptr, nullptr)); 196 } 197 198 SBDebugger SBDebugger::Create(bool source_init_files, 199 lldb::LogOutputCallback callback, void *baton) 200 201 { 202 LLDB_RECORD_DUMMY(lldb::SBDebugger, SBDebugger, Create, 203 (bool, lldb::LogOutputCallback, void *), source_init_files, 204 callback, baton); 205 206 SBDebugger debugger; 207 208 // Currently we have issues if this function is called simultaneously on two 209 // different threads. The issues mainly revolve around the fact that the 210 // lldb_private::FormatManager uses global collections and having two threads 211 // parsing the .lldbinit files can cause mayhem. So to get around this for 212 // now we need to use a mutex to prevent bad things from happening. 213 static std::recursive_mutex g_mutex; 214 std::lock_guard<std::recursive_mutex> guard(g_mutex); 215 216 debugger.reset(Debugger::CreateInstance(callback, baton)); 217 218 SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 219 if (source_init_files) { 220 interp.get()->SkipLLDBInitFiles(false); 221 interp.get()->SkipAppInitFiles(false); 222 SBCommandReturnObject result; 223 interp.SourceInitFileInHomeDirectory(result, false); 224 } else { 225 interp.get()->SkipLLDBInitFiles(true); 226 interp.get()->SkipAppInitFiles(true); 227 } 228 return debugger; 229 } 230 231 void SBDebugger::Destroy(SBDebugger &debugger) { 232 LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &), 233 debugger); 234 235 Debugger::Destroy(debugger.m_opaque_sp); 236 237 if (debugger.m_opaque_sp.get() != nullptr) 238 debugger.m_opaque_sp.reset(); 239 } 240 241 void SBDebugger::MemoryPressureDetected() { 242 LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected); 243 244 // Since this function can be call asynchronously, we allow it to be non- 245 // mandatory. We have seen deadlocks with this function when called so we 246 // need to safeguard against this until we can determine what is causing the 247 // deadlocks. 248 249 const bool mandatory = false; 250 251 ModuleList::RemoveOrphanSharedModules(mandatory); 252 } 253 254 bool SBDebugger::IsValid() const { 255 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); 256 return this->operator bool(); 257 } 258 SBDebugger::operator bool() const { 259 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool); 260 261 return m_opaque_sp.get() != nullptr; 262 } 263 264 void SBDebugger::SetAsync(bool b) { 265 LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b); 266 267 if (m_opaque_sp) 268 m_opaque_sp->SetAsyncExecution(b); 269 } 270 271 bool SBDebugger::GetAsync() { 272 LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync); 273 274 return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false); 275 } 276 277 void SBDebugger::SkipLLDBInitFiles(bool b) { 278 LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b); 279 280 if (m_opaque_sp) 281 m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b); 282 } 283 284 void SBDebugger::SkipAppInitFiles(bool b) { 285 LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b); 286 287 if (m_opaque_sp) 288 m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b); 289 } 290 291 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { 292 LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh, 293 transfer_ownership); 294 SetInputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); 295 } 296 297 SBError SBDebugger::SetInputFile(FileSP file_sp) { 298 LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp); 299 return LLDB_RECORD_RESULT(SetInputFile(SBFile(file_sp))); 300 } 301 302 // Shouldn't really be settable after initialization as this could cause lots 303 // of problems; don't want users trying to switch modes in the middle of a 304 // debugging session. 305 SBError SBDebugger::SetInputFile(SBFile file) { 306 LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file); 307 308 SBError error; 309 if (!m_opaque_sp) { 310 error.ref().SetErrorString("invalid debugger"); 311 return LLDB_RECORD_RESULT(error); 312 } 313 314 repro::DataRecorder *recorder = nullptr; 315 if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) 316 recorder = g->GetOrCreate<repro::CommandProvider>().GetNewRecorder(); 317 318 FileSP file_sp = file.m_opaque_sp; 319 320 static std::unique_ptr<repro::MultiLoader<repro::CommandProvider>> loader = 321 repro::MultiLoader<repro::CommandProvider>::Create( 322 repro::Reproducer::Instance().GetLoader()); 323 if (loader) { 324 llvm::Optional<std::string> nextfile = loader->GetNextFile(); 325 FILE *fh = nextfile ? FileSystem::Instance().Fopen(nextfile->c_str(), "r") 326 : nullptr; 327 // FIXME Jonas Devlieghere: shouldn't this error be propagated out to the 328 // reproducer somehow if fh is NULL? 329 if (fh) { 330 file_sp = std::make_shared<NativeFile>(fh, true); 331 } 332 } 333 334 if (!file_sp || !file_sp->IsValid()) { 335 error.ref().SetErrorString("invalid file"); 336 return LLDB_RECORD_RESULT(error); 337 } 338 339 m_opaque_sp->SetInputFile(file_sp, recorder); 340 return LLDB_RECORD_RESULT(error); 341 } 342 343 SBError SBDebugger::SetOutputFile(FileSP file_sp) { 344 LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp); 345 return LLDB_RECORD_RESULT(SetOutputFile(SBFile(file_sp))); 346 } 347 348 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { 349 LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh, 350 transfer_ownership); 351 SetOutputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); 352 } 353 354 SBError SBDebugger::SetOutputFile(SBFile file) { 355 LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file); 356 SBError error; 357 if (!m_opaque_sp) { 358 error.ref().SetErrorString("invalid debugger"); 359 return LLDB_RECORD_RESULT(error); 360 } 361 if (!file) { 362 error.ref().SetErrorString("invalid file"); 363 return LLDB_RECORD_RESULT(error); 364 } 365 m_opaque_sp->SetOutputFile(file.m_opaque_sp); 366 return LLDB_RECORD_RESULT(error); 367 } 368 369 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { 370 LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh, 371 transfer_ownership); 372 SetErrorFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); 373 } 374 375 SBError SBDebugger::SetErrorFile(FileSP file_sp) { 376 LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp); 377 return LLDB_RECORD_RESULT(SetErrorFile(SBFile(file_sp))); 378 } 379 380 SBError SBDebugger::SetErrorFile(SBFile file) { 381 LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file); 382 SBError error; 383 if (!m_opaque_sp) { 384 error.ref().SetErrorString("invalid debugger"); 385 return LLDB_RECORD_RESULT(error); 386 } 387 if (!file) { 388 error.ref().SetErrorString("invalid file"); 389 return LLDB_RECORD_RESULT(error); 390 } 391 m_opaque_sp->SetErrorFile(file.m_opaque_sp); 392 return LLDB_RECORD_RESULT(error); 393 } 394 395 FILE *SBDebugger::GetInputFileHandle() { 396 LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); 397 if (m_opaque_sp) { 398 File &file_sp = m_opaque_sp->GetInputFile(); 399 return LLDB_RECORD_RESULT(file_sp.GetStream()); 400 } 401 return LLDB_RECORD_RESULT(nullptr); 402 } 403 404 SBFile SBDebugger::GetInputFile() { 405 LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile); 406 if (m_opaque_sp) { 407 return LLDB_RECORD_RESULT(SBFile(m_opaque_sp->GetInputFileSP())); 408 } 409 return LLDB_RECORD_RESULT(SBFile()); 410 } 411 412 FILE *SBDebugger::GetOutputFileHandle() { 413 LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); 414 if (m_opaque_sp) { 415 StreamFile &stream_file = m_opaque_sp->GetOutputStream(); 416 return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); 417 } 418 return LLDB_RECORD_RESULT(nullptr); 419 } 420 421 SBFile SBDebugger::GetOutputFile() { 422 LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile); 423 if (m_opaque_sp) { 424 SBFile file(m_opaque_sp->GetOutputStream().GetFileSP()); 425 return LLDB_RECORD_RESULT(file); 426 } 427 return LLDB_RECORD_RESULT(SBFile()); 428 } 429 430 FILE *SBDebugger::GetErrorFileHandle() { 431 LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); 432 433 if (m_opaque_sp) { 434 StreamFile &stream_file = m_opaque_sp->GetErrorStream(); 435 return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); 436 } 437 return LLDB_RECORD_RESULT(nullptr); 438 } 439 440 SBFile SBDebugger::GetErrorFile() { 441 LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile); 442 SBFile file; 443 if (m_opaque_sp) { 444 SBFile file(m_opaque_sp->GetErrorStream().GetFileSP()); 445 return LLDB_RECORD_RESULT(file); 446 } 447 return LLDB_RECORD_RESULT(SBFile()); 448 } 449 450 void SBDebugger::SaveInputTerminalState() { 451 LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, SaveInputTerminalState); 452 453 if (m_opaque_sp) 454 m_opaque_sp->SaveInputTerminalState(); 455 } 456 457 void SBDebugger::RestoreInputTerminalState() { 458 LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, RestoreInputTerminalState); 459 460 if (m_opaque_sp) 461 m_opaque_sp->RestoreInputTerminalState(); 462 } 463 SBCommandInterpreter SBDebugger::GetCommandInterpreter() { 464 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger, 465 GetCommandInterpreter); 466 467 SBCommandInterpreter sb_interpreter; 468 if (m_opaque_sp) 469 sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter()); 470 471 return LLDB_RECORD_RESULT(sb_interpreter); 472 } 473 474 void SBDebugger::HandleCommand(const char *command) { 475 LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command); 476 477 if (m_opaque_sp) { 478 TargetSP target_sp(m_opaque_sp->GetSelectedTarget()); 479 std::unique_lock<std::recursive_mutex> lock; 480 if (target_sp) 481 lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); 482 483 SBCommandInterpreter sb_interpreter(GetCommandInterpreter()); 484 SBCommandReturnObject result; 485 486 sb_interpreter.HandleCommand(command, result, false); 487 488 result.PutError(m_opaque_sp->GetErrorStream().GetFileSP()); 489 result.PutOutput(m_opaque_sp->GetOutputStream().GetFileSP()); 490 491 if (!m_opaque_sp->GetAsyncExecution()) { 492 SBProcess process(GetCommandInterpreter().GetProcess()); 493 ProcessSP process_sp(process.GetSP()); 494 if (process_sp) { 495 EventSP event_sp; 496 ListenerSP lldb_listener_sp = m_opaque_sp->GetListener(); 497 while (lldb_listener_sp->GetEventForBroadcaster( 498 process_sp.get(), event_sp, std::chrono::seconds(0))) { 499 SBEvent event(event_sp); 500 HandleProcessEvent(process, event, GetOutputFile(), GetErrorFile()); 501 } 502 } 503 } 504 } 505 } 506 507 SBListener SBDebugger::GetListener() { 508 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); 509 510 SBListener sb_listener; 511 if (m_opaque_sp) 512 sb_listener.reset(m_opaque_sp->GetListener()); 513 514 return LLDB_RECORD_RESULT(sb_listener); 515 } 516 517 void SBDebugger::HandleProcessEvent(const SBProcess &process, 518 const SBEvent &event, SBFile out, 519 SBFile err) { 520 LLDB_RECORD_METHOD( 521 void, SBDebugger, HandleProcessEvent, 522 (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process, 523 event, out, err); 524 525 return HandleProcessEvent(process, event, out.m_opaque_sp, err.m_opaque_sp); 526 } 527 528 void SBDebugger::HandleProcessEvent(const SBProcess &process, 529 const SBEvent &event, FILE *out, 530 FILE *err) { 531 LLDB_RECORD_METHOD( 532 void, SBDebugger, HandleProcessEvent, 533 (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process, 534 event, out, err); 535 536 FileSP outfile = std::make_shared<NativeFile>(out, false); 537 FileSP errfile = std::make_shared<NativeFile>(err, false); 538 return HandleProcessEvent(process, event, outfile, errfile); 539 } 540 541 void SBDebugger::HandleProcessEvent(const SBProcess &process, 542 const SBEvent &event, FileSP out_sp, 543 FileSP err_sp) { 544 545 LLDB_RECORD_METHOD( 546 void, SBDebugger, HandleProcessEvent, 547 (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process, 548 event, out_sp, err_sp); 549 550 if (!process.IsValid()) 551 return; 552 553 TargetSP target_sp(process.GetTarget().GetSP()); 554 if (!target_sp) 555 return; 556 557 const uint32_t event_type = event.GetType(); 558 char stdio_buffer[1024]; 559 size_t len; 560 561 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 562 563 if (event_type & 564 (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) { 565 // Drain stdout when we stop just in case we have any bytes 566 while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0) 567 if (out_sp) 568 out_sp->Write(stdio_buffer, len); 569 } 570 571 if (event_type & 572 (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) { 573 // Drain stderr when we stop just in case we have any bytes 574 while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0) 575 if (err_sp) 576 err_sp->Write(stdio_buffer, len); 577 } 578 579 if (event_type & Process::eBroadcastBitStateChanged) { 580 StateType event_state = SBProcess::GetStateFromEvent(event); 581 582 if (event_state == eStateInvalid) 583 return; 584 585 bool is_stopped = StateIsStoppedState(event_state); 586 if (!is_stopped) 587 process.ReportEventState(event, out_sp); 588 } 589 } 590 591 SBSourceManager SBDebugger::GetSourceManager() { 592 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, 593 GetSourceManager); 594 595 SBSourceManager sb_source_manager(*this); 596 return LLDB_RECORD_RESULT(sb_source_manager); 597 } 598 599 bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) { 600 LLDB_RECORD_CHAR_PTR_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture, 601 (char *, size_t), arch_name, "", 602 arch_name_len); 603 604 if (arch_name && arch_name_len) { 605 ArchSpec default_arch = Target::GetDefaultArchitecture(); 606 607 if (default_arch.IsValid()) { 608 const std::string &triple_str = default_arch.GetTriple().str(); 609 if (!triple_str.empty()) 610 ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str()); 611 else 612 ::snprintf(arch_name, arch_name_len, "%s", 613 default_arch.GetArchitectureName()); 614 return true; 615 } 616 } 617 if (arch_name && arch_name_len) 618 arch_name[0] = '\0'; 619 return false; 620 } 621 622 bool SBDebugger::SetDefaultArchitecture(const char *arch_name) { 623 LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, 624 (const char *), arch_name); 625 626 if (arch_name) { 627 ArchSpec arch(arch_name); 628 if (arch.IsValid()) { 629 Target::SetDefaultArchitecture(arch); 630 return true; 631 } 632 } 633 return false; 634 } 635 636 ScriptLanguage 637 SBDebugger::GetScriptingLanguage(const char *script_language_name) { 638 LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, 639 (const char *), script_language_name); 640 641 if (!script_language_name) 642 return eScriptLanguageDefault; 643 return OptionArgParser::ToScriptLanguage( 644 llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr); 645 } 646 647 const char *SBDebugger::GetVersionString() { 648 LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString); 649 650 return lldb_private::GetVersion(); 651 } 652 653 const char *SBDebugger::StateAsCString(StateType state) { 654 LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString, 655 (lldb::StateType), state); 656 657 return lldb_private::StateAsCString(state); 658 } 659 660 static void AddBoolConfigEntry(StructuredData::Dictionary &dict, 661 llvm::StringRef name, bool value, 662 llvm::StringRef description) { 663 auto entry_up = std::make_unique<StructuredData::Dictionary>(); 664 entry_up->AddBooleanItem("value", value); 665 entry_up->AddStringItem("description", description); 666 dict.AddItem(name, std::move(entry_up)); 667 } 668 669 static void AddLLVMTargets(StructuredData::Dictionary &dict) { 670 auto array_up = std::make_unique<StructuredData::Array>(); 671 #define LLVM_TARGET(target) \ 672 array_up->AddItem(std::make_unique<StructuredData::String>(#target)); 673 #include "llvm/Config/Targets.def" 674 auto entry_up = std::make_unique<StructuredData::Dictionary>(); 675 entry_up->AddItem("value", std::move(array_up)); 676 entry_up->AddStringItem("description", "A list of configured LLVM targets."); 677 dict.AddItem("targets", std::move(entry_up)); 678 } 679 680 SBStructuredData SBDebugger::GetBuildConfiguration() { 681 LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, 682 GetBuildConfiguration); 683 684 auto config_up = std::make_unique<StructuredData::Dictionary>(); 685 AddBoolConfigEntry( 686 *config_up, "xml", XMLDocument::XMLEnabled(), 687 "A boolean value that indicates if XML support is enabled in LLDB"); 688 AddBoolConfigEntry( 689 *config_up, "curses", LLDB_ENABLE_CURSES, 690 "A boolean value that indicates if curses support is enabled in LLDB"); 691 AddBoolConfigEntry( 692 *config_up, "editline", LLDB_ENABLE_LIBEDIT, 693 "A boolean value that indicates if editline support is enabled in LLDB"); 694 AddBoolConfigEntry( 695 *config_up, "lzma", LLDB_ENABLE_LZMA, 696 "A boolean value that indicates if lzma support is enabled in LLDB"); 697 AddBoolConfigEntry( 698 *config_up, "python", LLDB_ENABLE_PYTHON, 699 "A boolean value that indicates if python support is enabled in LLDB"); 700 AddBoolConfigEntry( 701 *config_up, "lua", LLDB_ENABLE_LUA, 702 "A boolean value that indicates if lua support is enabled in LLDB"); 703 AddLLVMTargets(*config_up); 704 705 SBStructuredData data; 706 data.m_impl_up->SetObjectSP(std::move(config_up)); 707 return LLDB_RECORD_RESULT(data); 708 } 709 710 bool SBDebugger::StateIsRunningState(StateType state) { 711 LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, 712 (lldb::StateType), state); 713 714 const bool result = lldb_private::StateIsRunningState(state); 715 716 return result; 717 } 718 719 bool SBDebugger::StateIsStoppedState(StateType state) { 720 LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, 721 (lldb::StateType), state); 722 723 const bool result = lldb_private::StateIsStoppedState(state, false); 724 725 return result; 726 } 727 728 lldb::SBTarget SBDebugger::CreateTarget(const char *filename, 729 const char *target_triple, 730 const char *platform_name, 731 bool add_dependent_modules, 732 lldb::SBError &sb_error) { 733 LLDB_RECORD_METHOD( 734 lldb::SBTarget, SBDebugger, CreateTarget, 735 (const char *, const char *, const char *, bool, lldb::SBError &), 736 filename, target_triple, platform_name, add_dependent_modules, sb_error); 737 738 SBTarget sb_target; 739 TargetSP target_sp; 740 if (m_opaque_sp) { 741 sb_error.Clear(); 742 OptionGroupPlatform platform_options(false); 743 platform_options.SetPlatformName(platform_name); 744 745 sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget( 746 *m_opaque_sp, filename, target_triple, 747 add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, 748 &platform_options, target_sp); 749 750 if (sb_error.Success()) 751 sb_target.SetSP(target_sp); 752 } else { 753 sb_error.SetErrorString("invalid debugger"); 754 } 755 756 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 757 LLDB_LOGF(log, 758 "SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, " 759 "platform_name=%s, add_dependent_modules=%u, error=%s) => " 760 "SBTarget(%p)", 761 static_cast<void *>(m_opaque_sp.get()), filename, target_triple, 762 platform_name, add_dependent_modules, sb_error.GetCString(), 763 static_cast<void *>(target_sp.get())); 764 765 return LLDB_RECORD_RESULT(sb_target); 766 } 767 768 SBTarget 769 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, 770 const char *target_triple) { 771 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, 772 CreateTargetWithFileAndTargetTriple, 773 (const char *, const char *), filename, target_triple); 774 775 SBTarget sb_target; 776 TargetSP target_sp; 777 if (m_opaque_sp) { 778 const bool add_dependent_modules = true; 779 Status error(m_opaque_sp->GetTargetList().CreateTarget( 780 *m_opaque_sp, filename, target_triple, 781 add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, 782 target_sp)); 783 sb_target.SetSP(target_sp); 784 } 785 786 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 787 LLDB_LOGF(log, 788 "SBDebugger(%p)::CreateTargetWithFileAndTargetTriple " 789 "(filename=\"%s\", triple=%s) => SBTarget(%p)", 790 static_cast<void *>(m_opaque_sp.get()), filename, target_triple, 791 static_cast<void *>(target_sp.get())); 792 793 return LLDB_RECORD_RESULT(sb_target); 794 } 795 796 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, 797 const char *arch_cstr) { 798 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, 799 (const char *, const char *), filename, arch_cstr); 800 801 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 802 803 SBTarget sb_target; 804 TargetSP target_sp; 805 if (m_opaque_sp) { 806 Status error; 807 if (arch_cstr == nullptr) { 808 // The version of CreateTarget that takes an ArchSpec won't accept an 809 // empty ArchSpec, so when the arch hasn't been specified, we need to 810 // call the target triple version. 811 error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, 812 arch_cstr, eLoadDependentsYes, nullptr, target_sp); 813 } else { 814 PlatformSP platform_sp = m_opaque_sp->GetPlatformList() 815 .GetSelectedPlatform(); 816 ArchSpec arch = Platform::GetAugmentedArchSpec(platform_sp.get(), 817 arch_cstr); 818 if (arch.IsValid()) 819 error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, 820 arch, eLoadDependentsYes, platform_sp, target_sp); 821 else 822 error.SetErrorStringWithFormat("invalid arch_cstr: %s", arch_cstr); 823 } 824 if (error.Success()) 825 sb_target.SetSP(target_sp); 826 } 827 828 LLDB_LOGF(log, 829 "SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", " 830 "arch=%s) => SBTarget(%p)", 831 static_cast<void *>(m_opaque_sp.get()), 832 filename ? filename : "<unspecified>", 833 arch_cstr ? arch_cstr : "<unspecified>", 834 static_cast<void *>(target_sp.get())); 835 836 return LLDB_RECORD_RESULT(sb_target); 837 } 838 839 SBTarget SBDebugger::CreateTarget(const char *filename) { 840 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *), 841 filename); 842 843 SBTarget sb_target; 844 TargetSP target_sp; 845 if (m_opaque_sp) { 846 Status error; 847 const bool add_dependent_modules = true; 848 error = m_opaque_sp->GetTargetList().CreateTarget( 849 *m_opaque_sp, filename, "", 850 add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, 851 target_sp); 852 853 if (error.Success()) 854 sb_target.SetSP(target_sp); 855 } 856 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 857 LLDB_LOGF(log, 858 "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 859 static_cast<void *>(m_opaque_sp.get()), filename, 860 static_cast<void *>(target_sp.get())); 861 return LLDB_RECORD_RESULT(sb_target); 862 } 863 864 SBTarget SBDebugger::GetDummyTarget() { 865 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); 866 867 SBTarget sb_target; 868 if (m_opaque_sp) { 869 sb_target.SetSP(m_opaque_sp->GetDummyTarget().shared_from_this()); 870 } 871 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 872 LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)", 873 static_cast<void *>(m_opaque_sp.get()), 874 static_cast<void *>(sb_target.GetSP().get())); 875 return LLDB_RECORD_RESULT(sb_target); 876 } 877 878 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { 879 LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), 880 target); 881 882 bool result = false; 883 if (m_opaque_sp) { 884 TargetSP target_sp(target.GetSP()); 885 if (target_sp) { 886 // No need to lock, the target list is thread safe 887 result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp); 888 target_sp->Destroy(); 889 target.Clear(); 890 } 891 } 892 893 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 894 LLDB_LOGF(log, "SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", 895 static_cast<void *>(m_opaque_sp.get()), 896 static_cast<void *>(target.m_opaque_sp.get()), result); 897 898 return result; 899 } 900 901 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) { 902 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t), 903 idx); 904 905 SBTarget sb_target; 906 if (m_opaque_sp) { 907 // No need to lock, the target list is thread safe 908 sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx)); 909 } 910 return LLDB_RECORD_RESULT(sb_target); 911 } 912 913 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { 914 LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget), 915 target); 916 917 lldb::TargetSP target_sp = target.GetSP(); 918 if (!target_sp) 919 return UINT32_MAX; 920 921 if (!m_opaque_sp) 922 return UINT32_MAX; 923 924 return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP()); 925 } 926 927 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) { 928 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, 929 (lldb::pid_t), pid); 930 931 SBTarget sb_target; 932 if (m_opaque_sp) { 933 // No need to lock, the target list is thread safe 934 sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid)); 935 } 936 return LLDB_RECORD_RESULT(sb_target); 937 } 938 939 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, 940 const char *arch_name) { 941 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, 942 (const char *, const char *), filename, arch_name); 943 944 SBTarget sb_target; 945 if (m_opaque_sp && filename && filename[0]) { 946 // No need to lock, the target list is thread safe 947 ArchSpec arch = Platform::GetAugmentedArchSpec( 948 m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name); 949 TargetSP target_sp( 950 m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture( 951 FileSpec(filename), arch_name ? &arch : nullptr)); 952 sb_target.SetSP(target_sp); 953 } 954 return LLDB_RECORD_RESULT(sb_target); 955 } 956 957 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { 958 SBTarget sb_target; 959 if (m_opaque_sp) { 960 // No need to lock, the target list is thread safe 961 sb_target.SetSP( 962 m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get())); 963 } 964 return sb_target; 965 } 966 967 uint32_t SBDebugger::GetNumTargets() { 968 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); 969 970 if (m_opaque_sp) { 971 // No need to lock, the target list is thread safe 972 return m_opaque_sp->GetTargetList().GetNumTargets(); 973 } 974 return 0; 975 } 976 977 SBTarget SBDebugger::GetSelectedTarget() { 978 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); 979 980 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 981 982 SBTarget sb_target; 983 TargetSP target_sp; 984 if (m_opaque_sp) { 985 // No need to lock, the target list is thread safe 986 target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget(); 987 sb_target.SetSP(target_sp); 988 } 989 990 if (log) { 991 SBStream sstr; 992 sb_target.GetDescription(sstr, eDescriptionLevelBrief); 993 LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", 994 static_cast<void *>(m_opaque_sp.get()), 995 static_cast<void *>(target_sp.get()), sstr.GetData()); 996 } 997 998 return LLDB_RECORD_RESULT(sb_target); 999 } 1000 1001 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { 1002 LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &), 1003 sb_target); 1004 1005 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1006 1007 TargetSP target_sp(sb_target.GetSP()); 1008 if (m_opaque_sp) { 1009 m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp); 1010 } 1011 if (log) { 1012 SBStream sstr; 1013 sb_target.GetDescription(sstr, eDescriptionLevelBrief); 1014 LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", 1015 static_cast<void *>(m_opaque_sp.get()), 1016 static_cast<void *>(target_sp.get()), sstr.GetData()); 1017 } 1018 } 1019 1020 SBPlatform SBDebugger::GetSelectedPlatform() { 1021 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); 1022 1023 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1024 1025 SBPlatform sb_platform; 1026 DebuggerSP debugger_sp(m_opaque_sp); 1027 if (debugger_sp) { 1028 sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); 1029 } 1030 LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", 1031 static_cast<void *>(m_opaque_sp.get()), 1032 static_cast<void *>(sb_platform.GetSP().get()), 1033 sb_platform.GetName()); 1034 return LLDB_RECORD_RESULT(sb_platform); 1035 } 1036 1037 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { 1038 LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform, 1039 (lldb::SBPlatform &), sb_platform); 1040 1041 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1042 1043 DebuggerSP debugger_sp(m_opaque_sp); 1044 if (debugger_sp) { 1045 debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); 1046 } 1047 1048 LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", 1049 static_cast<void *>(m_opaque_sp.get()), 1050 static_cast<void *>(sb_platform.GetSP().get()), 1051 sb_platform.GetName()); 1052 } 1053 1054 uint32_t SBDebugger::GetNumPlatforms() { 1055 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); 1056 1057 if (m_opaque_sp) { 1058 // No need to lock, the platform list is thread safe 1059 return m_opaque_sp->GetPlatformList().GetSize(); 1060 } 1061 return 0; 1062 } 1063 1064 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) { 1065 LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, 1066 (uint32_t), idx); 1067 1068 SBPlatform sb_platform; 1069 if (m_opaque_sp) { 1070 // No need to lock, the platform list is thread safe 1071 sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx)); 1072 } 1073 return LLDB_RECORD_RESULT(sb_platform); 1074 } 1075 1076 uint32_t SBDebugger::GetNumAvailablePlatforms() { 1077 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms); 1078 1079 uint32_t idx = 0; 1080 while (true) { 1081 if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) { 1082 break; 1083 } 1084 ++idx; 1085 } 1086 // +1 for the host platform, which should always appear first in the list. 1087 return idx + 1; 1088 } 1089 1090 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { 1091 LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, 1092 GetAvailablePlatformInfoAtIndex, (uint32_t), idx); 1093 1094 SBStructuredData data; 1095 auto platform_dict = std::make_unique<StructuredData::Dictionary>(); 1096 llvm::StringRef name_str("name"), desc_str("description"); 1097 1098 if (idx == 0) { 1099 PlatformSP host_platform_sp(Platform::GetHostPlatform()); 1100 platform_dict->AddStringItem( 1101 name_str, host_platform_sp->GetPluginName().GetStringRef()); 1102 platform_dict->AddStringItem( 1103 desc_str, llvm::StringRef(host_platform_sp->GetDescription())); 1104 } else if (idx > 0) { 1105 const char *plugin_name = 1106 PluginManager::GetPlatformPluginNameAtIndex(idx - 1); 1107 if (!plugin_name) { 1108 return LLDB_RECORD_RESULT(data); 1109 } 1110 platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name)); 1111 1112 const char *plugin_desc = 1113 PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1); 1114 if (!plugin_desc) { 1115 return LLDB_RECORD_RESULT(data); 1116 } 1117 platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc)); 1118 } 1119 1120 data.m_impl_up->SetObjectSP( 1121 StructuredData::ObjectSP(platform_dict.release())); 1122 return LLDB_RECORD_RESULT(data); 1123 } 1124 1125 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) { 1126 LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, 1127 (void *, const void *, size_t), baton, data, data_len); 1128 1129 DispatchInput(data, data_len); 1130 } 1131 1132 void SBDebugger::DispatchInput(const void *data, size_t data_len) { 1133 LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t), 1134 data, data_len); 1135 1136 // Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1137 // 1138 // if (log) 1139 // LLDB_LOGF(log, "SBDebugger(%p)::DispatchInput (data=\"%.*s\", 1140 // size_t=%" PRIu64 ")", 1141 // m_opaque_sp.get(), 1142 // (int) data_len, 1143 // (const char *) data, 1144 // (uint64_t)data_len); 1145 // 1146 // if (m_opaque_sp) 1147 // m_opaque_sp->DispatchInput ((const char *) data, data_len); 1148 } 1149 1150 void SBDebugger::DispatchInputInterrupt() { 1151 LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); 1152 1153 if (m_opaque_sp) 1154 m_opaque_sp->DispatchInputInterrupt(); 1155 } 1156 1157 void SBDebugger::DispatchInputEndOfFile() { 1158 LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); 1159 1160 if (m_opaque_sp) 1161 m_opaque_sp->DispatchInputEndOfFile(); 1162 } 1163 1164 void SBDebugger::PushInputReader(SBInputReader &reader) { 1165 LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &), 1166 reader); 1167 } 1168 1169 void SBDebugger::RunCommandInterpreter(bool auto_handle_events, 1170 bool spawn_thread) { 1171 LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), 1172 auto_handle_events, spawn_thread); 1173 1174 if (m_opaque_sp) { 1175 CommandInterpreterRunOptions options; 1176 options.SetAutoHandleEvents(auto_handle_events); 1177 options.SetSpawnThread(spawn_thread); 1178 m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(options); 1179 } 1180 } 1181 1182 void SBDebugger::RunCommandInterpreter(bool auto_handle_events, 1183 bool spawn_thread, 1184 SBCommandInterpreterRunOptions &options, 1185 int &num_errors, bool &quit_requested, 1186 bool &stopped_for_crash) 1187 1188 { 1189 LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, 1190 (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &, 1191 bool &, bool &), 1192 auto_handle_events, spawn_thread, options, num_errors, 1193 quit_requested, stopped_for_crash); 1194 1195 if (m_opaque_sp) { 1196 options.SetAutoHandleEvents(auto_handle_events); 1197 options.SetSpawnThread(spawn_thread); 1198 CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); 1199 CommandInterpreterRunResult result = 1200 interp.RunCommandInterpreter(options.ref()); 1201 num_errors = result.GetNumErrors(); 1202 quit_requested = 1203 result.IsResult(lldb::eCommandInterpreterResultQuitRequested); 1204 stopped_for_crash = 1205 result.IsResult(lldb::eCommandInterpreterResultInferiorCrash); 1206 } 1207 } 1208 1209 SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter( 1210 const SBCommandInterpreterRunOptions &options) { 1211 LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, 1212 RunCommandInterpreter, 1213 (const lldb::SBCommandInterpreterRunOptions &), options); 1214 1215 if (!m_opaque_sp) 1216 return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult()); 1217 1218 CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); 1219 CommandInterpreterRunResult result = 1220 interp.RunCommandInterpreter(options.ref()); 1221 1222 return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult(result)); 1223 } 1224 1225 SBError SBDebugger::RunREPL(lldb::LanguageType language, 1226 const char *repl_options) { 1227 LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL, 1228 (lldb::LanguageType, const char *), language, 1229 repl_options); 1230 1231 SBError error; 1232 if (m_opaque_sp) 1233 error.ref() = m_opaque_sp->RunREPL(language, repl_options); 1234 else 1235 error.SetErrorString("invalid debugger"); 1236 return LLDB_RECORD_RESULT(error); 1237 } 1238 1239 void SBDebugger::reset(const DebuggerSP &debugger_sp) { 1240 m_opaque_sp = debugger_sp; 1241 } 1242 1243 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); } 1244 1245 Debugger &SBDebugger::ref() const { 1246 assert(m_opaque_sp.get()); 1247 return *m_opaque_sp; 1248 } 1249 1250 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; } 1251 1252 SBDebugger SBDebugger::FindDebuggerWithID(int id) { 1253 LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, 1254 (int), id); 1255 1256 // No need to lock, the debugger list is thread safe 1257 SBDebugger sb_debugger; 1258 DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id); 1259 if (debugger_sp) 1260 sb_debugger.reset(debugger_sp); 1261 return LLDB_RECORD_RESULT(sb_debugger); 1262 } 1263 1264 const char *SBDebugger::GetInstanceName() { 1265 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); 1266 1267 return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); 1268 } 1269 1270 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, 1271 const char *debugger_instance_name) { 1272 LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, 1273 (const char *, const char *, const char *), 1274 var_name, value, debugger_instance_name); 1275 1276 SBError sb_error; 1277 DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( 1278 ConstString(debugger_instance_name))); 1279 Status error; 1280 if (debugger_sp) { 1281 ExecutionContext exe_ctx( 1282 debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1283 error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign, 1284 var_name, value); 1285 } else { 1286 error.SetErrorStringWithFormat("invalid debugger instance name '%s'", 1287 debugger_instance_name); 1288 } 1289 if (error.Fail()) 1290 sb_error.SetError(error); 1291 return LLDB_RECORD_RESULT(sb_error); 1292 } 1293 1294 SBStringList 1295 SBDebugger::GetInternalVariableValue(const char *var_name, 1296 const char *debugger_instance_name) { 1297 LLDB_RECORD_STATIC_METHOD( 1298 lldb::SBStringList, SBDebugger, GetInternalVariableValue, 1299 (const char *, const char *), var_name, debugger_instance_name); 1300 1301 SBStringList ret_value; 1302 DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( 1303 ConstString(debugger_instance_name))); 1304 Status error; 1305 if (debugger_sp) { 1306 ExecutionContext exe_ctx( 1307 debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1308 lldb::OptionValueSP value_sp( 1309 debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error)); 1310 if (value_sp) { 1311 StreamString value_strm; 1312 value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 1313 const std::string &value_str = std::string(value_strm.GetString()); 1314 if (!value_str.empty()) { 1315 StringList string_list; 1316 string_list.SplitIntoLines(value_str); 1317 return LLDB_RECORD_RESULT(SBStringList(&string_list)); 1318 } 1319 } 1320 } 1321 return LLDB_RECORD_RESULT(SBStringList()); 1322 } 1323 1324 uint32_t SBDebugger::GetTerminalWidth() const { 1325 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth); 1326 1327 return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0); 1328 } 1329 1330 void SBDebugger::SetTerminalWidth(uint32_t term_width) { 1331 LLDB_RECORD_DUMMY(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width); 1332 1333 if (m_opaque_sp) 1334 m_opaque_sp->SetTerminalWidth(term_width); 1335 } 1336 1337 const char *SBDebugger::GetPrompt() const { 1338 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); 1339 1340 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1341 1342 LLDB_LOGF(log, "SBDebugger(%p)::GetPrompt () => \"%s\"", 1343 static_cast<void *>(m_opaque_sp.get()), 1344 (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : "")); 1345 1346 return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString() 1347 : nullptr); 1348 } 1349 1350 void SBDebugger::SetPrompt(const char *prompt) { 1351 LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt); 1352 1353 if (m_opaque_sp) 1354 m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt)); 1355 } 1356 1357 const char *SBDebugger::GetReproducerPath() const { 1358 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath); 1359 1360 return (m_opaque_sp 1361 ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString() 1362 : nullptr); 1363 } 1364 1365 ScriptLanguage SBDebugger::GetScriptLanguage() const { 1366 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, 1367 GetScriptLanguage); 1368 1369 return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone); 1370 } 1371 1372 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) { 1373 LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage, 1374 (lldb::ScriptLanguage), script_lang); 1375 1376 if (m_opaque_sp) { 1377 m_opaque_sp->SetScriptLanguage(script_lang); 1378 } 1379 } 1380 1381 bool SBDebugger::SetUseExternalEditor(bool value) { 1382 LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); 1383 1384 return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); 1385 } 1386 1387 bool SBDebugger::GetUseExternalEditor() { 1388 LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); 1389 1390 return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); 1391 } 1392 1393 bool SBDebugger::SetUseColor(bool value) { 1394 LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value); 1395 1396 return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); 1397 } 1398 1399 bool SBDebugger::GetUseColor() const { 1400 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); 1401 1402 return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); 1403 } 1404 1405 bool SBDebugger::SetUseSourceCache(bool value) { 1406 LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value); 1407 1408 return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false); 1409 } 1410 1411 bool SBDebugger::GetUseSourceCache() const { 1412 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache); 1413 1414 return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false); 1415 } 1416 1417 bool SBDebugger::GetDescription(SBStream &description) { 1418 LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), 1419 description); 1420 1421 Stream &strm = description.ref(); 1422 1423 if (m_opaque_sp) { 1424 const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1425 user_id_t id = m_opaque_sp->GetID(); 1426 strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1427 } else 1428 strm.PutCString("No value"); 1429 1430 return true; 1431 } 1432 1433 user_id_t SBDebugger::GetID() { 1434 LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID); 1435 1436 return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID); 1437 } 1438 1439 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { 1440 LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, 1441 (const char *), platform_name_cstr); 1442 1443 SBError sb_error; 1444 if (m_opaque_sp) { 1445 if (platform_name_cstr && platform_name_cstr[0]) { 1446 ConstString platform_name(platform_name_cstr); 1447 PlatformSP platform_sp(Platform::Find(platform_name)); 1448 1449 if (platform_sp) { 1450 // Already have a platform with this name, just select it 1451 m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp); 1452 } else { 1453 // We don't have a platform by this name yet, create one 1454 platform_sp = Platform::Create(platform_name, sb_error.ref()); 1455 if (platform_sp) { 1456 // We created the platform, now append and select it 1457 bool make_selected = true; 1458 m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected); 1459 } 1460 } 1461 } else { 1462 sb_error.ref().SetErrorString("invalid platform name"); 1463 } 1464 } else { 1465 sb_error.ref().SetErrorString("invalid debugger"); 1466 } 1467 return LLDB_RECORD_RESULT(sb_error); 1468 } 1469 1470 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { 1471 LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, 1472 (const char *), sysroot); 1473 1474 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1475 if (m_opaque_sp) { 1476 PlatformSP platform_sp( 1477 m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1478 1479 if (platform_sp) { 1480 if (log && sysroot) 1481 LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", 1482 sysroot); 1483 platform_sp->SetSDKRootDirectory(ConstString(sysroot)); 1484 return true; 1485 } 1486 } 1487 return false; 1488 } 1489 1490 bool SBDebugger::GetCloseInputOnEOF() const { 1491 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); 1492 1493 return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); 1494 } 1495 1496 void SBDebugger::SetCloseInputOnEOF(bool b) { 1497 LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); 1498 1499 if (m_opaque_sp) 1500 m_opaque_sp->SetCloseInputOnEOF(b); 1501 } 1502 1503 SBTypeCategory SBDebugger::GetCategory(const char *category_name) { 1504 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1505 (const char *), category_name); 1506 1507 if (!category_name || *category_name == 0) 1508 return LLDB_RECORD_RESULT(SBTypeCategory()); 1509 1510 TypeCategoryImplSP category_sp; 1511 1512 if (DataVisualization::Categories::GetCategory(ConstString(category_name), 1513 category_sp, false)) { 1514 return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1515 } else { 1516 return LLDB_RECORD_RESULT(SBTypeCategory()); 1517 } 1518 } 1519 1520 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { 1521 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1522 (lldb::LanguageType), lang_type); 1523 1524 TypeCategoryImplSP category_sp; 1525 if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) { 1526 return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1527 } else { 1528 return LLDB_RECORD_RESULT(SBTypeCategory()); 1529 } 1530 } 1531 1532 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) { 1533 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, 1534 (const char *), category_name); 1535 1536 if (!category_name || *category_name == 0) 1537 return LLDB_RECORD_RESULT(SBTypeCategory()); 1538 1539 TypeCategoryImplSP category_sp; 1540 1541 if (DataVisualization::Categories::GetCategory(ConstString(category_name), 1542 category_sp, true)) { 1543 return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1544 } else { 1545 return LLDB_RECORD_RESULT(SBTypeCategory()); 1546 } 1547 } 1548 1549 bool SBDebugger::DeleteCategory(const char *category_name) { 1550 LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *), 1551 category_name); 1552 1553 if (!category_name || *category_name == 0) 1554 return false; 1555 1556 return DataVisualization::Categories::Delete(ConstString(category_name)); 1557 } 1558 1559 uint32_t SBDebugger::GetNumCategories() { 1560 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); 1561 1562 return DataVisualization::Categories::GetCount(); 1563 } 1564 1565 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) { 1566 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, 1567 (uint32_t), index); 1568 1569 return LLDB_RECORD_RESULT( 1570 SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index))); 1571 } 1572 1573 SBTypeCategory SBDebugger::GetDefaultCategory() { 1574 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, 1575 GetDefaultCategory); 1576 1577 return LLDB_RECORD_RESULT(GetCategory("default")); 1578 } 1579 1580 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) { 1581 LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, 1582 (lldb::SBTypeNameSpecifier), type_name); 1583 1584 SBTypeCategory default_category_sb = GetDefaultCategory(); 1585 if (default_category_sb.GetEnabled()) 1586 return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name)); 1587 return LLDB_RECORD_RESULT(SBTypeFormat()); 1588 } 1589 1590 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { 1591 LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, 1592 (lldb::SBTypeNameSpecifier), type_name); 1593 1594 if (!type_name.IsValid()) 1595 return LLDB_RECORD_RESULT(SBTypeSummary()); 1596 return LLDB_RECORD_RESULT( 1597 SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()))); 1598 } 1599 1600 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { 1601 LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, 1602 (lldb::SBTypeNameSpecifier), type_name); 1603 1604 if (!type_name.IsValid()) 1605 return LLDB_RECORD_RESULT(SBTypeFilter()); 1606 return LLDB_RECORD_RESULT( 1607 SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()))); 1608 } 1609 1610 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { 1611 LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, 1612 (lldb::SBTypeNameSpecifier), type_name); 1613 1614 if (!type_name.IsValid()) 1615 return LLDB_RECORD_RESULT(SBTypeSynthetic()); 1616 return LLDB_RECORD_RESULT(SBTypeSynthetic( 1617 DataVisualization::GetSyntheticForType(type_name.GetSP()))); 1618 } 1619 1620 static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { 1621 if (categories == nullptr) 1622 return {}; 1623 size_t len = 0; 1624 while (categories[len] != nullptr) 1625 ++len; 1626 return llvm::makeArrayRef(categories, len); 1627 } 1628 1629 bool SBDebugger::EnableLog(const char *channel, const char **categories) { 1630 LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **), 1631 channel, categories); 1632 1633 if (m_opaque_sp) { 1634 uint32_t log_options = 1635 LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1636 std::string error; 1637 llvm::raw_string_ostream error_stream(error); 1638 return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "", 1639 log_options, error_stream); 1640 } else 1641 return false; 1642 } 1643 1644 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, 1645 void *baton) { 1646 LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback, 1647 (lldb::LogOutputCallback, void *), log_callback, baton); 1648 1649 if (m_opaque_sp) { 1650 return m_opaque_sp->SetLoggingCallback(log_callback, baton); 1651 } 1652 } 1653 1654 namespace lldb_private { 1655 namespace repro { 1656 1657 template <> void RegisterMethods<SBInputReader>(Registry &R) { 1658 LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool)); 1659 LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ()); 1660 } 1661 1662 static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) { 1663 // Do nothing. 1664 } 1665 1666 static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); } 1667 1668 static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); } 1669 1670 template <> void RegisterMethods<SBDebugger>(Registry &R) { 1671 // Custom implementation. 1672 R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< 1673 &SBDebugger::SetErrorFileHandle>::record, 1674 &SetFileHandleRedirect); 1675 R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< 1676 &SBDebugger::SetOutputFileHandle>::record, 1677 &SetFileHandleRedirect); 1678 1679 R.Register(&invoke<SBError (SBDebugger::*)( 1680 SBFile)>::method<&SBDebugger::SetInputFile>::record, 1681 &SetFileRedirect); 1682 R.Register(&invoke<SBError (SBDebugger::*)( 1683 SBFile)>::method<&SBDebugger::SetOutputFile>::record, 1684 &SetFileRedirect); 1685 R.Register(&invoke<SBError (SBDebugger::*)( 1686 SBFile)>::method<&SBDebugger::SetErrorFile>::record, 1687 &SetFileRedirect); 1688 1689 R.Register(&invoke<SBError (SBDebugger::*)( 1690 FileSP)>::method<&SBDebugger::SetInputFile>::record, 1691 &SetFileRedirect); 1692 R.Register(&invoke<SBError (SBDebugger::*)( 1693 FileSP)>::method<&SBDebugger::SetOutputFile>::record, 1694 &SetFileRedirect); 1695 R.Register(&invoke<SBError (SBDebugger::*)( 1696 FileSP)>::method<&SBDebugger::SetErrorFile>::record, 1697 &SetFileRedirect); 1698 1699 LLDB_REGISTER_CHAR_PTR_METHOD_STATIC(bool, SBDebugger, 1700 GetDefaultArchitecture); 1701 1702 LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ()); 1703 LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &)); 1704 LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &)); 1705 LLDB_REGISTER_METHOD(lldb::SBDebugger &, 1706 SBDebugger, operator=,(const lldb::SBDebugger &)); 1707 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ()); 1708 LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, 1709 InitializeWithErrorHandling, ()); 1710 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ()); 1711 LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ()); 1712 LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ()); 1713 LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool)); 1714 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &)); 1715 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ()); 1716 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ()); 1717 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,()); 1718 LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool)); 1719 LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ()); 1720 LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool)); 1721 LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool)); 1722 LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool)); 1723 LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ()); 1724 LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ()); 1725 LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ()); 1726 LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ()); 1727 LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ()); 1728 LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ()); 1729 LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ()); 1730 LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ()); 1731 LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger, 1732 GetCommandInterpreter, ()); 1733 LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *)); 1734 LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ()); 1735 LLDB_REGISTER_METHOD( 1736 void, SBDebugger, HandleProcessEvent, 1737 (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *)); 1738 LLDB_REGISTER_METHOD( 1739 void, SBDebugger, HandleProcessEvent, 1740 (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile)); 1741 LLDB_REGISTER_METHOD( 1742 void, SBDebugger, HandleProcessEvent, 1743 (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP)); 1744 LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ()); 1745 LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, 1746 (const char *)); 1747 LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, 1748 (const char *)); 1749 LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ()); 1750 LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString, 1751 (lldb::StateType)); 1752 LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger, 1753 GetBuildConfiguration, ()); 1754 LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, 1755 (lldb::StateType)); 1756 LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, 1757 (lldb::StateType)); 1758 LLDB_REGISTER_METHOD( 1759 lldb::SBTarget, SBDebugger, CreateTarget, 1760 (const char *, const char *, const char *, bool, lldb::SBError &)); 1761 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, 1762 CreateTargetWithFileAndTargetTriple, 1763 (const char *, const char *)); 1764 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, 1765 (const char *, const char *)); 1766 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, 1767 (const char *)); 1768 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ()); 1769 LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &)); 1770 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, 1771 (uint32_t)); 1772 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, 1773 (lldb::SBTarget)); 1774 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, 1775 (lldb::pid_t)); 1776 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, 1777 (const char *, const char *)); 1778 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ()); 1779 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ()); 1780 LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &)); 1781 LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ()); 1782 LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform, 1783 (lldb::SBPlatform &)); 1784 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ()); 1785 LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, 1786 (uint32_t)); 1787 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ()); 1788 LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger, 1789 GetAvailablePlatformInfoAtIndex, (uint32_t)); 1790 LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ()); 1791 LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ()); 1792 LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader, 1793 (lldb::SBInputReader &)); 1794 LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool)); 1795 LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, 1796 (bool, bool, lldb::SBCommandInterpreterRunOptions &, 1797 int &, bool &, bool &)); 1798 LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL, 1799 (lldb::LanguageType, const char *)); 1800 LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, 1801 (int)); 1802 LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ()); 1803 LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, 1804 (const char *, const char *, const char *)); 1805 LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger, 1806 GetInternalVariableValue, 1807 (const char *, const char *)); 1808 LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ()); 1809 LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t)); 1810 LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ()); 1811 LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *)); 1812 LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ()); 1813 LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger, 1814 GetScriptLanguage, ()); 1815 LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage, 1816 (lldb::ScriptLanguage)); 1817 LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool)); 1818 LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ()); 1819 LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool)); 1820 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ()); 1821 LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &)); 1822 LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ()); 1823 LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, 1824 (const char *)); 1825 LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, 1826 (const char *)); 1827 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ()); 1828 LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool)); 1829 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1830 (const char *)); 1831 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1832 (lldb::LanguageType)); 1833 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, 1834 (const char *)); 1835 LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *)); 1836 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ()); 1837 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, 1838 (uint32_t)); 1839 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory, 1840 ()); 1841 LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, 1842 (lldb::SBTypeNameSpecifier)); 1843 LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, 1844 (lldb::SBTypeNameSpecifier)); 1845 LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, 1846 (lldb::SBTypeNameSpecifier)); 1847 LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, 1848 (lldb::SBTypeNameSpecifier)); 1849 LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog, 1850 (const char *, const char **)); 1851 LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, 1852 RunCommandInterpreter, 1853 (const lldb::SBCommandInterpreterRunOptions &)); 1854 } 1855 1856 } // namespace repro 1857 } // namespace lldb_private 1858