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