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