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