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