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