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