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 const bool add_dependent_modules = true; 808 PlatformSP platform_sp = m_opaque_sp->GetPlatformList().GetSelectedPlatform(); 809 ArchSpec arch = Platform::GetAugmentedArchSpec( 810 platform_sp.get(), arch_cstr); 811 error = m_opaque_sp->GetTargetList().CreateTarget( 812 *m_opaque_sp, filename, arch, 813 add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, 814 platform_sp, target_sp); 815 816 if (error.Success()) 817 sb_target.SetSP(target_sp); 818 } 819 820 LLDB_LOGF(log, 821 "SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", " 822 "arch=%s) => SBTarget(%p)", 823 static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr, 824 static_cast<void *>(target_sp.get())); 825 826 return LLDB_RECORD_RESULT(sb_target); 827 } 828 829 SBTarget SBDebugger::CreateTarget(const char *filename) { 830 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *), 831 filename); 832 833 SBTarget sb_target; 834 TargetSP target_sp; 835 if (m_opaque_sp) { 836 Status error; 837 const bool add_dependent_modules = true; 838 error = m_opaque_sp->GetTargetList().CreateTarget( 839 *m_opaque_sp, filename, "", 840 add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, 841 target_sp); 842 843 if (error.Success()) 844 sb_target.SetSP(target_sp); 845 } 846 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 847 LLDB_LOGF(log, 848 "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 849 static_cast<void *>(m_opaque_sp.get()), filename, 850 static_cast<void *>(target_sp.get())); 851 return LLDB_RECORD_RESULT(sb_target); 852 } 853 854 SBTarget SBDebugger::GetDummyTarget() { 855 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); 856 857 SBTarget sb_target; 858 if (m_opaque_sp) { 859 sb_target.SetSP(m_opaque_sp->GetDummyTarget().shared_from_this()); 860 } 861 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 862 LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)", 863 static_cast<void *>(m_opaque_sp.get()), 864 static_cast<void *>(sb_target.GetSP().get())); 865 return LLDB_RECORD_RESULT(sb_target); 866 } 867 868 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { 869 LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), 870 target); 871 872 bool result = false; 873 if (m_opaque_sp) { 874 TargetSP target_sp(target.GetSP()); 875 if (target_sp) { 876 // No need to lock, the target list is thread safe 877 result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp); 878 target_sp->Destroy(); 879 target.Clear(); 880 } 881 } 882 883 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 884 LLDB_LOGF(log, "SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", 885 static_cast<void *>(m_opaque_sp.get()), 886 static_cast<void *>(target.m_opaque_sp.get()), result); 887 888 return result; 889 } 890 891 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) { 892 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t), 893 idx); 894 895 SBTarget sb_target; 896 if (m_opaque_sp) { 897 // No need to lock, the target list is thread safe 898 sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx)); 899 } 900 return LLDB_RECORD_RESULT(sb_target); 901 } 902 903 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { 904 LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget), 905 target); 906 907 lldb::TargetSP target_sp = target.GetSP(); 908 if (!target_sp) 909 return UINT32_MAX; 910 911 if (!m_opaque_sp) 912 return UINT32_MAX; 913 914 return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP()); 915 } 916 917 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) { 918 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, 919 (lldb::pid_t), pid); 920 921 SBTarget sb_target; 922 if (m_opaque_sp) { 923 // No need to lock, the target list is thread safe 924 sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid)); 925 } 926 return LLDB_RECORD_RESULT(sb_target); 927 } 928 929 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, 930 const char *arch_name) { 931 LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, 932 (const char *, const char *), filename, arch_name); 933 934 SBTarget sb_target; 935 if (m_opaque_sp && filename && filename[0]) { 936 // No need to lock, the target list is thread safe 937 ArchSpec arch = Platform::GetAugmentedArchSpec( 938 m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name); 939 TargetSP target_sp( 940 m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture( 941 FileSpec(filename), arch_name ? &arch : nullptr)); 942 sb_target.SetSP(target_sp); 943 } 944 return LLDB_RECORD_RESULT(sb_target); 945 } 946 947 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { 948 SBTarget sb_target; 949 if (m_opaque_sp) { 950 // No need to lock, the target list is thread safe 951 sb_target.SetSP( 952 m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get())); 953 } 954 return sb_target; 955 } 956 957 uint32_t SBDebugger::GetNumTargets() { 958 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); 959 960 if (m_opaque_sp) { 961 // No need to lock, the target list is thread safe 962 return m_opaque_sp->GetTargetList().GetNumTargets(); 963 } 964 return 0; 965 } 966 967 SBTarget SBDebugger::GetSelectedTarget() { 968 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); 969 970 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 971 972 SBTarget sb_target; 973 TargetSP target_sp; 974 if (m_opaque_sp) { 975 // No need to lock, the target list is thread safe 976 target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget(); 977 sb_target.SetSP(target_sp); 978 } 979 980 if (log) { 981 SBStream sstr; 982 sb_target.GetDescription(sstr, eDescriptionLevelBrief); 983 LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", 984 static_cast<void *>(m_opaque_sp.get()), 985 static_cast<void *>(target_sp.get()), sstr.GetData()); 986 } 987 988 return LLDB_RECORD_RESULT(sb_target); 989 } 990 991 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { 992 LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &), 993 sb_target); 994 995 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 996 997 TargetSP target_sp(sb_target.GetSP()); 998 if (m_opaque_sp) { 999 m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp); 1000 } 1001 if (log) { 1002 SBStream sstr; 1003 sb_target.GetDescription(sstr, eDescriptionLevelBrief); 1004 LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", 1005 static_cast<void *>(m_opaque_sp.get()), 1006 static_cast<void *>(target_sp.get()), sstr.GetData()); 1007 } 1008 } 1009 1010 SBPlatform SBDebugger::GetSelectedPlatform() { 1011 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); 1012 1013 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1014 1015 SBPlatform sb_platform; 1016 DebuggerSP debugger_sp(m_opaque_sp); 1017 if (debugger_sp) { 1018 sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); 1019 } 1020 LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", 1021 static_cast<void *>(m_opaque_sp.get()), 1022 static_cast<void *>(sb_platform.GetSP().get()), 1023 sb_platform.GetName()); 1024 return LLDB_RECORD_RESULT(sb_platform); 1025 } 1026 1027 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { 1028 LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform, 1029 (lldb::SBPlatform &), sb_platform); 1030 1031 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1032 1033 DebuggerSP debugger_sp(m_opaque_sp); 1034 if (debugger_sp) { 1035 debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); 1036 } 1037 1038 LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", 1039 static_cast<void *>(m_opaque_sp.get()), 1040 static_cast<void *>(sb_platform.GetSP().get()), 1041 sb_platform.GetName()); 1042 } 1043 1044 uint32_t SBDebugger::GetNumPlatforms() { 1045 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); 1046 1047 if (m_opaque_sp) { 1048 // No need to lock, the platform list is thread safe 1049 return m_opaque_sp->GetPlatformList().GetSize(); 1050 } 1051 return 0; 1052 } 1053 1054 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) { 1055 LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, 1056 (uint32_t), idx); 1057 1058 SBPlatform sb_platform; 1059 if (m_opaque_sp) { 1060 // No need to lock, the platform list is thread safe 1061 sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx)); 1062 } 1063 return LLDB_RECORD_RESULT(sb_platform); 1064 } 1065 1066 uint32_t SBDebugger::GetNumAvailablePlatforms() { 1067 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms); 1068 1069 uint32_t idx = 0; 1070 while (true) { 1071 if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) { 1072 break; 1073 } 1074 ++idx; 1075 } 1076 // +1 for the host platform, which should always appear first in the list. 1077 return idx + 1; 1078 } 1079 1080 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { 1081 LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, 1082 GetAvailablePlatformInfoAtIndex, (uint32_t), idx); 1083 1084 SBStructuredData data; 1085 auto platform_dict = std::make_unique<StructuredData::Dictionary>(); 1086 llvm::StringRef name_str("name"), desc_str("description"); 1087 1088 if (idx == 0) { 1089 PlatformSP host_platform_sp(Platform::GetHostPlatform()); 1090 platform_dict->AddStringItem( 1091 name_str, host_platform_sp->GetPluginName().GetStringRef()); 1092 platform_dict->AddStringItem( 1093 desc_str, llvm::StringRef(host_platform_sp->GetDescription())); 1094 } else if (idx > 0) { 1095 const char *plugin_name = 1096 PluginManager::GetPlatformPluginNameAtIndex(idx - 1); 1097 if (!plugin_name) { 1098 return LLDB_RECORD_RESULT(data); 1099 } 1100 platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name)); 1101 1102 const char *plugin_desc = 1103 PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1); 1104 if (!plugin_desc) { 1105 return LLDB_RECORD_RESULT(data); 1106 } 1107 platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc)); 1108 } 1109 1110 data.m_impl_up->SetObjectSP( 1111 StructuredData::ObjectSP(platform_dict.release())); 1112 return LLDB_RECORD_RESULT(data); 1113 } 1114 1115 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) { 1116 LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, 1117 (void *, const void *, size_t), baton, data, data_len); 1118 1119 DispatchInput(data, data_len); 1120 } 1121 1122 void SBDebugger::DispatchInput(const void *data, size_t data_len) { 1123 LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t), 1124 data, data_len); 1125 1126 // Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1127 // 1128 // if (log) 1129 // LLDB_LOGF(log, "SBDebugger(%p)::DispatchInput (data=\"%.*s\", 1130 // size_t=%" PRIu64 ")", 1131 // m_opaque_sp.get(), 1132 // (int) data_len, 1133 // (const char *) data, 1134 // (uint64_t)data_len); 1135 // 1136 // if (m_opaque_sp) 1137 // m_opaque_sp->DispatchInput ((const char *) data, data_len); 1138 } 1139 1140 void SBDebugger::DispatchInputInterrupt() { 1141 LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); 1142 1143 if (m_opaque_sp) 1144 m_opaque_sp->DispatchInputInterrupt(); 1145 } 1146 1147 void SBDebugger::DispatchInputEndOfFile() { 1148 LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); 1149 1150 if (m_opaque_sp) 1151 m_opaque_sp->DispatchInputEndOfFile(); 1152 } 1153 1154 void SBDebugger::PushInputReader(SBInputReader &reader) { 1155 LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &), 1156 reader); 1157 } 1158 1159 void SBDebugger::RunCommandInterpreter(bool auto_handle_events, 1160 bool spawn_thread) { 1161 LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), 1162 auto_handle_events, spawn_thread); 1163 1164 if (m_opaque_sp) { 1165 CommandInterpreterRunOptions options; 1166 options.SetAutoHandleEvents(auto_handle_events); 1167 options.SetSpawnThread(spawn_thread); 1168 m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(options); 1169 } 1170 } 1171 1172 void SBDebugger::RunCommandInterpreter(bool auto_handle_events, 1173 bool spawn_thread, 1174 SBCommandInterpreterRunOptions &options, 1175 int &num_errors, bool &quit_requested, 1176 bool &stopped_for_crash) 1177 1178 { 1179 LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, 1180 (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &, 1181 bool &, bool &), 1182 auto_handle_events, spawn_thread, options, num_errors, 1183 quit_requested, stopped_for_crash); 1184 1185 if (m_opaque_sp) { 1186 options.SetAutoHandleEvents(auto_handle_events); 1187 options.SetSpawnThread(spawn_thread); 1188 CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); 1189 CommandInterpreterRunResult result = 1190 interp.RunCommandInterpreter(options.ref()); 1191 num_errors = result.GetNumErrors(); 1192 quit_requested = 1193 result.IsResult(lldb::eCommandInterpreterResultQuitRequested); 1194 stopped_for_crash = 1195 result.IsResult(lldb::eCommandInterpreterResultInferiorCrash); 1196 } 1197 } 1198 1199 SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter( 1200 const SBCommandInterpreterRunOptions &options) { 1201 LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, 1202 RunCommandInterpreter, 1203 (const lldb::SBCommandInterpreterRunOptions &), options); 1204 1205 if (!m_opaque_sp) 1206 return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult()); 1207 1208 CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); 1209 CommandInterpreterRunResult result = 1210 interp.RunCommandInterpreter(options.ref()); 1211 1212 return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult(result)); 1213 } 1214 1215 SBError SBDebugger::RunREPL(lldb::LanguageType language, 1216 const char *repl_options) { 1217 LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL, 1218 (lldb::LanguageType, const char *), language, 1219 repl_options); 1220 1221 SBError error; 1222 if (m_opaque_sp) 1223 error.ref() = m_opaque_sp->RunREPL(language, repl_options); 1224 else 1225 error.SetErrorString("invalid debugger"); 1226 return LLDB_RECORD_RESULT(error); 1227 } 1228 1229 void SBDebugger::reset(const DebuggerSP &debugger_sp) { 1230 m_opaque_sp = debugger_sp; 1231 } 1232 1233 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); } 1234 1235 Debugger &SBDebugger::ref() const { 1236 assert(m_opaque_sp.get()); 1237 return *m_opaque_sp; 1238 } 1239 1240 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; } 1241 1242 SBDebugger SBDebugger::FindDebuggerWithID(int id) { 1243 LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, 1244 (int), id); 1245 1246 // No need to lock, the debugger list is thread safe 1247 SBDebugger sb_debugger; 1248 DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id); 1249 if (debugger_sp) 1250 sb_debugger.reset(debugger_sp); 1251 return LLDB_RECORD_RESULT(sb_debugger); 1252 } 1253 1254 const char *SBDebugger::GetInstanceName() { 1255 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); 1256 1257 return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); 1258 } 1259 1260 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, 1261 const char *debugger_instance_name) { 1262 LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, 1263 (const char *, const char *, const char *), 1264 var_name, value, debugger_instance_name); 1265 1266 SBError sb_error; 1267 DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( 1268 ConstString(debugger_instance_name))); 1269 Status error; 1270 if (debugger_sp) { 1271 ExecutionContext exe_ctx( 1272 debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1273 error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign, 1274 var_name, value); 1275 } else { 1276 error.SetErrorStringWithFormat("invalid debugger instance name '%s'", 1277 debugger_instance_name); 1278 } 1279 if (error.Fail()) 1280 sb_error.SetError(error); 1281 return LLDB_RECORD_RESULT(sb_error); 1282 } 1283 1284 SBStringList 1285 SBDebugger::GetInternalVariableValue(const char *var_name, 1286 const char *debugger_instance_name) { 1287 LLDB_RECORD_STATIC_METHOD( 1288 lldb::SBStringList, SBDebugger, GetInternalVariableValue, 1289 (const char *, const char *), var_name, debugger_instance_name); 1290 1291 SBStringList ret_value; 1292 DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( 1293 ConstString(debugger_instance_name))); 1294 Status error; 1295 if (debugger_sp) { 1296 ExecutionContext exe_ctx( 1297 debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1298 lldb::OptionValueSP value_sp( 1299 debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error)); 1300 if (value_sp) { 1301 StreamString value_strm; 1302 value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 1303 const std::string &value_str = std::string(value_strm.GetString()); 1304 if (!value_str.empty()) { 1305 StringList string_list; 1306 string_list.SplitIntoLines(value_str); 1307 return LLDB_RECORD_RESULT(SBStringList(&string_list)); 1308 } 1309 } 1310 } 1311 return LLDB_RECORD_RESULT(SBStringList()); 1312 } 1313 1314 uint32_t SBDebugger::GetTerminalWidth() const { 1315 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth); 1316 1317 return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0); 1318 } 1319 1320 void SBDebugger::SetTerminalWidth(uint32_t term_width) { 1321 LLDB_RECORD_DUMMY(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width); 1322 1323 if (m_opaque_sp) 1324 m_opaque_sp->SetTerminalWidth(term_width); 1325 } 1326 1327 const char *SBDebugger::GetPrompt() const { 1328 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); 1329 1330 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1331 1332 LLDB_LOGF(log, "SBDebugger(%p)::GetPrompt () => \"%s\"", 1333 static_cast<void *>(m_opaque_sp.get()), 1334 (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : "")); 1335 1336 return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString() 1337 : nullptr); 1338 } 1339 1340 void SBDebugger::SetPrompt(const char *prompt) { 1341 LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt); 1342 1343 if (m_opaque_sp) 1344 m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt)); 1345 } 1346 1347 const char *SBDebugger::GetReproducerPath() const { 1348 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath); 1349 1350 return (m_opaque_sp 1351 ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString() 1352 : nullptr); 1353 } 1354 1355 ScriptLanguage SBDebugger::GetScriptLanguage() const { 1356 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, 1357 GetScriptLanguage); 1358 1359 return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone); 1360 } 1361 1362 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) { 1363 LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage, 1364 (lldb::ScriptLanguage), script_lang); 1365 1366 if (m_opaque_sp) { 1367 m_opaque_sp->SetScriptLanguage(script_lang); 1368 } 1369 } 1370 1371 bool SBDebugger::SetUseExternalEditor(bool value) { 1372 LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); 1373 1374 return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); 1375 } 1376 1377 bool SBDebugger::GetUseExternalEditor() { 1378 LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); 1379 1380 return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); 1381 } 1382 1383 bool SBDebugger::SetUseColor(bool value) { 1384 LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value); 1385 1386 return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); 1387 } 1388 1389 bool SBDebugger::GetUseColor() const { 1390 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); 1391 1392 return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); 1393 } 1394 1395 bool SBDebugger::SetUseSourceCache(bool value) { 1396 LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value); 1397 1398 return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false); 1399 } 1400 1401 bool SBDebugger::GetUseSourceCache() const { 1402 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache); 1403 1404 return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false); 1405 } 1406 1407 bool SBDebugger::GetDescription(SBStream &description) { 1408 LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), 1409 description); 1410 1411 Stream &strm = description.ref(); 1412 1413 if (m_opaque_sp) { 1414 const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1415 user_id_t id = m_opaque_sp->GetID(); 1416 strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1417 } else 1418 strm.PutCString("No value"); 1419 1420 return true; 1421 } 1422 1423 user_id_t SBDebugger::GetID() { 1424 LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID); 1425 1426 return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID); 1427 } 1428 1429 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { 1430 LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, 1431 (const char *), platform_name_cstr); 1432 1433 SBError sb_error; 1434 if (m_opaque_sp) { 1435 if (platform_name_cstr && platform_name_cstr[0]) { 1436 ConstString platform_name(platform_name_cstr); 1437 PlatformSP platform_sp(Platform::Find(platform_name)); 1438 1439 if (platform_sp) { 1440 // Already have a platform with this name, just select it 1441 m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp); 1442 } else { 1443 // We don't have a platform by this name yet, create one 1444 platform_sp = Platform::Create(platform_name, sb_error.ref()); 1445 if (platform_sp) { 1446 // We created the platform, now append and select it 1447 bool make_selected = true; 1448 m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected); 1449 } 1450 } 1451 } else { 1452 sb_error.ref().SetErrorString("invalid platform name"); 1453 } 1454 } else { 1455 sb_error.ref().SetErrorString("invalid debugger"); 1456 } 1457 return LLDB_RECORD_RESULT(sb_error); 1458 } 1459 1460 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { 1461 LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, 1462 (const char *), sysroot); 1463 1464 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1465 if (m_opaque_sp) { 1466 PlatformSP platform_sp( 1467 m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1468 1469 if (platform_sp) { 1470 if (log && sysroot) 1471 LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", 1472 sysroot); 1473 platform_sp->SetSDKRootDirectory(ConstString(sysroot)); 1474 return true; 1475 } 1476 } 1477 return false; 1478 } 1479 1480 bool SBDebugger::GetCloseInputOnEOF() const { 1481 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); 1482 1483 return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); 1484 } 1485 1486 void SBDebugger::SetCloseInputOnEOF(bool b) { 1487 LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); 1488 1489 if (m_opaque_sp) 1490 m_opaque_sp->SetCloseInputOnEOF(b); 1491 } 1492 1493 SBTypeCategory SBDebugger::GetCategory(const char *category_name) { 1494 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1495 (const char *), category_name); 1496 1497 if (!category_name || *category_name == 0) 1498 return LLDB_RECORD_RESULT(SBTypeCategory()); 1499 1500 TypeCategoryImplSP category_sp; 1501 1502 if (DataVisualization::Categories::GetCategory(ConstString(category_name), 1503 category_sp, false)) { 1504 return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1505 } else { 1506 return LLDB_RECORD_RESULT(SBTypeCategory()); 1507 } 1508 } 1509 1510 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { 1511 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1512 (lldb::LanguageType), lang_type); 1513 1514 TypeCategoryImplSP category_sp; 1515 if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) { 1516 return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1517 } else { 1518 return LLDB_RECORD_RESULT(SBTypeCategory()); 1519 } 1520 } 1521 1522 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) { 1523 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, 1524 (const char *), category_name); 1525 1526 if (!category_name || *category_name == 0) 1527 return LLDB_RECORD_RESULT(SBTypeCategory()); 1528 1529 TypeCategoryImplSP category_sp; 1530 1531 if (DataVisualization::Categories::GetCategory(ConstString(category_name), 1532 category_sp, true)) { 1533 return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); 1534 } else { 1535 return LLDB_RECORD_RESULT(SBTypeCategory()); 1536 } 1537 } 1538 1539 bool SBDebugger::DeleteCategory(const char *category_name) { 1540 LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *), 1541 category_name); 1542 1543 if (!category_name || *category_name == 0) 1544 return false; 1545 1546 return DataVisualization::Categories::Delete(ConstString(category_name)); 1547 } 1548 1549 uint32_t SBDebugger::GetNumCategories() { 1550 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); 1551 1552 return DataVisualization::Categories::GetCount(); 1553 } 1554 1555 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) { 1556 LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, 1557 (uint32_t), index); 1558 1559 return LLDB_RECORD_RESULT( 1560 SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index))); 1561 } 1562 1563 SBTypeCategory SBDebugger::GetDefaultCategory() { 1564 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, 1565 GetDefaultCategory); 1566 1567 return LLDB_RECORD_RESULT(GetCategory("default")); 1568 } 1569 1570 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) { 1571 LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, 1572 (lldb::SBTypeNameSpecifier), type_name); 1573 1574 SBTypeCategory default_category_sb = GetDefaultCategory(); 1575 if (default_category_sb.GetEnabled()) 1576 return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name)); 1577 return LLDB_RECORD_RESULT(SBTypeFormat()); 1578 } 1579 1580 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { 1581 LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, 1582 (lldb::SBTypeNameSpecifier), type_name); 1583 1584 if (!type_name.IsValid()) 1585 return LLDB_RECORD_RESULT(SBTypeSummary()); 1586 return LLDB_RECORD_RESULT( 1587 SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()))); 1588 } 1589 1590 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { 1591 LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, 1592 (lldb::SBTypeNameSpecifier), type_name); 1593 1594 if (!type_name.IsValid()) 1595 return LLDB_RECORD_RESULT(SBTypeFilter()); 1596 return LLDB_RECORD_RESULT( 1597 SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()))); 1598 } 1599 1600 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { 1601 LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, 1602 (lldb::SBTypeNameSpecifier), type_name); 1603 1604 if (!type_name.IsValid()) 1605 return LLDB_RECORD_RESULT(SBTypeSynthetic()); 1606 return LLDB_RECORD_RESULT(SBTypeSynthetic( 1607 DataVisualization::GetSyntheticForType(type_name.GetSP()))); 1608 } 1609 1610 static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { 1611 if (categories == nullptr) 1612 return {}; 1613 size_t len = 0; 1614 while (categories[len] != nullptr) 1615 ++len; 1616 return llvm::makeArrayRef(categories, len); 1617 } 1618 1619 bool SBDebugger::EnableLog(const char *channel, const char **categories) { 1620 LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **), 1621 channel, categories); 1622 1623 if (m_opaque_sp) { 1624 uint32_t log_options = 1625 LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1626 std::string error; 1627 llvm::raw_string_ostream error_stream(error); 1628 return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "", 1629 log_options, error_stream); 1630 } else 1631 return false; 1632 } 1633 1634 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, 1635 void *baton) { 1636 LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback, 1637 (lldb::LogOutputCallback, void *), log_callback, baton); 1638 1639 if (m_opaque_sp) { 1640 return m_opaque_sp->SetLoggingCallback(log_callback, baton); 1641 } 1642 } 1643 1644 namespace lldb_private { 1645 namespace repro { 1646 1647 template <> void RegisterMethods<SBInputReader>(Registry &R) { 1648 LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool)); 1649 LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ()); 1650 } 1651 1652 static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) { 1653 // Do nothing. 1654 } 1655 1656 static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); } 1657 1658 static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); } 1659 1660 template <> void RegisterMethods<SBDebugger>(Registry &R) { 1661 // Custom implementation. 1662 R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< 1663 &SBDebugger::SetErrorFileHandle>::record, 1664 &SetFileHandleRedirect); 1665 R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< 1666 &SBDebugger::SetOutputFileHandle>::record, 1667 &SetFileHandleRedirect); 1668 1669 R.Register(&invoke<SBError (SBDebugger::*)( 1670 SBFile)>::method<&SBDebugger::SetInputFile>::record, 1671 &SetFileRedirect); 1672 R.Register(&invoke<SBError (SBDebugger::*)( 1673 SBFile)>::method<&SBDebugger::SetOutputFile>::record, 1674 &SetFileRedirect); 1675 R.Register(&invoke<SBError (SBDebugger::*)( 1676 SBFile)>::method<&SBDebugger::SetErrorFile>::record, 1677 &SetFileRedirect); 1678 1679 R.Register(&invoke<SBError (SBDebugger::*)( 1680 FileSP)>::method<&SBDebugger::SetInputFile>::record, 1681 &SetFileRedirect); 1682 R.Register(&invoke<SBError (SBDebugger::*)( 1683 FileSP)>::method<&SBDebugger::SetOutputFile>::record, 1684 &SetFileRedirect); 1685 R.Register(&invoke<SBError (SBDebugger::*)( 1686 FileSP)>::method<&SBDebugger::SetErrorFile>::record, 1687 &SetFileRedirect); 1688 1689 LLDB_REGISTER_CHAR_PTR_METHOD_STATIC(bool, SBDebugger, 1690 GetDefaultArchitecture); 1691 1692 LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ()); 1693 LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &)); 1694 LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &)); 1695 LLDB_REGISTER_METHOD(lldb::SBDebugger &, 1696 SBDebugger, operator=,(const lldb::SBDebugger &)); 1697 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ()); 1698 LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, 1699 InitializeWithErrorHandling, ()); 1700 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ()); 1701 LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ()); 1702 LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ()); 1703 LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool)); 1704 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &)); 1705 LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ()); 1706 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ()); 1707 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,()); 1708 LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool)); 1709 LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ()); 1710 LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool)); 1711 LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool)); 1712 LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool)); 1713 LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ()); 1714 LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ()); 1715 LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ()); 1716 LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ()); 1717 LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ()); 1718 LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ()); 1719 LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ()); 1720 LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ()); 1721 LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger, 1722 GetCommandInterpreter, ()); 1723 LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *)); 1724 LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ()); 1725 LLDB_REGISTER_METHOD( 1726 void, SBDebugger, HandleProcessEvent, 1727 (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *)); 1728 LLDB_REGISTER_METHOD( 1729 void, SBDebugger, HandleProcessEvent, 1730 (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile)); 1731 LLDB_REGISTER_METHOD( 1732 void, SBDebugger, HandleProcessEvent, 1733 (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP)); 1734 LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ()); 1735 LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, 1736 (const char *)); 1737 LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, 1738 (const char *)); 1739 LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ()); 1740 LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString, 1741 (lldb::StateType)); 1742 LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger, 1743 GetBuildConfiguration, ()); 1744 LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, 1745 (lldb::StateType)); 1746 LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, 1747 (lldb::StateType)); 1748 LLDB_REGISTER_METHOD( 1749 lldb::SBTarget, SBDebugger, CreateTarget, 1750 (const char *, const char *, const char *, bool, lldb::SBError &)); 1751 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, 1752 CreateTargetWithFileAndTargetTriple, 1753 (const char *, const char *)); 1754 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, 1755 (const char *, const char *)); 1756 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, 1757 (const char *)); 1758 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ()); 1759 LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &)); 1760 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, 1761 (uint32_t)); 1762 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, 1763 (lldb::SBTarget)); 1764 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, 1765 (lldb::pid_t)); 1766 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, 1767 (const char *, const char *)); 1768 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ()); 1769 LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ()); 1770 LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &)); 1771 LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ()); 1772 LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform, 1773 (lldb::SBPlatform &)); 1774 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ()); 1775 LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, 1776 (uint32_t)); 1777 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ()); 1778 LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger, 1779 GetAvailablePlatformInfoAtIndex, (uint32_t)); 1780 LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ()); 1781 LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ()); 1782 LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader, 1783 (lldb::SBInputReader &)); 1784 LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool)); 1785 LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, 1786 (bool, bool, lldb::SBCommandInterpreterRunOptions &, 1787 int &, bool &, bool &)); 1788 LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL, 1789 (lldb::LanguageType, const char *)); 1790 LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, 1791 (int)); 1792 LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ()); 1793 LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, 1794 (const char *, const char *, const char *)); 1795 LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger, 1796 GetInternalVariableValue, 1797 (const char *, const char *)); 1798 LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ()); 1799 LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t)); 1800 LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ()); 1801 LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *)); 1802 LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ()); 1803 LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger, 1804 GetScriptLanguage, ()); 1805 LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage, 1806 (lldb::ScriptLanguage)); 1807 LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool)); 1808 LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ()); 1809 LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool)); 1810 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ()); 1811 LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &)); 1812 LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ()); 1813 LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, 1814 (const char *)); 1815 LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, 1816 (const char *)); 1817 LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ()); 1818 LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool)); 1819 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1820 (const char *)); 1821 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, 1822 (lldb::LanguageType)); 1823 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, 1824 (const char *)); 1825 LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *)); 1826 LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ()); 1827 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, 1828 (uint32_t)); 1829 LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory, 1830 ()); 1831 LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, 1832 (lldb::SBTypeNameSpecifier)); 1833 LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, 1834 (lldb::SBTypeNameSpecifier)); 1835 LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, 1836 (lldb::SBTypeNameSpecifier)); 1837 LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, 1838 (lldb::SBTypeNameSpecifier)); 1839 LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog, 1840 (const char *, const char **)); 1841 LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, 1842 RunCommandInterpreter, 1843 (const lldb::SBCommandInterpreterRunOptions &)); 1844 } 1845 1846 } // namespace repro 1847 } // namespace lldb_private 1848