1 //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/lldb-python.h" 11 12 #include "lldb/API/SBDebugger.h" 13 14 #include "lldb/lldb-private.h" 15 16 #include "lldb/API/SBListener.h" 17 #include "lldb/API/SBBroadcaster.h" 18 #include "lldb/API/SBCommandInterpreter.h" 19 #include "lldb/API/SBCommandReturnObject.h" 20 #include "lldb/API/SBError.h" 21 #include "lldb/API/SBEvent.h" 22 #include "lldb/API/SBFrame.h" 23 #include "lldb/API/SBInputReader.h" 24 #include "lldb/API/SBProcess.h" 25 #include "lldb/API/SBSourceManager.h" 26 #include "lldb/API/SBStream.h" 27 #include "lldb/API/SBStringList.h" 28 #include "lldb/API/SBTarget.h" 29 #include "lldb/API/SBThread.h" 30 #include "lldb/API/SBTypeCategory.h" 31 #include "lldb/API/SBTypeFormat.h" 32 #include "lldb/API/SBTypeFilter.h" 33 #include "lldb/API/SBTypeNameSpecifier.h" 34 #include "lldb/API/SBTypeSummary.h" 35 #include "lldb/API/SBTypeSynthetic.h" 36 37 38 #include "lldb/Core/Debugger.h" 39 #include "lldb/Core/State.h" 40 #include "lldb/DataFormatters/DataVisualization.h" 41 #include "lldb/Interpreter/Args.h" 42 #include "lldb/Interpreter/CommandInterpreter.h" 43 #include "lldb/Interpreter/OptionGroupPlatform.h" 44 #include "lldb/Target/Process.h" 45 #include "lldb/Target/TargetList.h" 46 47 using namespace lldb; 48 using namespace lldb_private; 49 50 void 51 SBDebugger::Initialize () 52 { 53 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 54 55 if (log) 56 log->Printf ("SBDebugger::Initialize ()"); 57 58 SBCommandInterpreter::InitializeSWIG (); 59 60 Debugger::Initialize(); 61 } 62 63 void 64 SBDebugger::Terminate () 65 { 66 Debugger::Terminate(); 67 } 68 69 void 70 SBDebugger::Clear () 71 { 72 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 73 74 if (log) 75 log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get()); 76 77 if (m_opaque_sp) 78 m_opaque_sp->CleanUpInputReaders (); 79 80 m_opaque_sp.reset(); 81 } 82 83 SBDebugger 84 SBDebugger::Create() 85 { 86 return SBDebugger::Create(false, NULL, NULL); 87 } 88 89 SBDebugger 90 SBDebugger::Create(bool source_init_files) 91 { 92 return SBDebugger::Create (source_init_files, NULL, NULL); 93 } 94 95 SBDebugger 96 SBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton) 97 98 { 99 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 100 101 SBDebugger debugger; 102 debugger.reset(Debugger::CreateInstance(callback, baton)); 103 104 if (log) 105 { 106 SBStream sstr; 107 debugger.GetDescription (sstr); 108 log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 109 } 110 111 SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 112 if (source_init_files) 113 { 114 interp.get()->SkipLLDBInitFiles(false); 115 interp.get()->SkipAppInitFiles (false); 116 SBCommandReturnObject result; 117 interp.SourceInitFileInHomeDirectory(result); 118 } 119 else 120 { 121 interp.get()->SkipLLDBInitFiles(true); 122 interp.get()->SkipAppInitFiles (true); 123 } 124 return debugger; 125 } 126 127 void 128 SBDebugger::Destroy (SBDebugger &debugger) 129 { 130 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 131 132 if (log) 133 { 134 SBStream sstr; 135 debugger.GetDescription (sstr); 136 log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 137 } 138 139 Debugger::Destroy (debugger.m_opaque_sp); 140 141 if (debugger.m_opaque_sp.get() != NULL) 142 debugger.m_opaque_sp.reset(); 143 } 144 145 void 146 SBDebugger::MemoryPressureDetected () 147 { 148 // Since this function can be call asynchronously, we allow it to be 149 // non-mandatory. We have seen deadlocks with this function when called 150 // so we need to safeguard against this until we can determine what is 151 // causing the deadlocks. 152 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 153 154 const bool mandatory = false; 155 if (log) 156 { 157 log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory); 158 } 159 160 ModuleList::RemoveOrphanSharedModules(mandatory); 161 } 162 163 SBDebugger::SBDebugger () : 164 m_opaque_sp () 165 { 166 } 167 168 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : 169 m_opaque_sp(debugger_sp) 170 { 171 } 172 173 SBDebugger::SBDebugger(const SBDebugger &rhs) : 174 m_opaque_sp (rhs.m_opaque_sp) 175 { 176 } 177 178 SBDebugger & 179 SBDebugger::operator = (const SBDebugger &rhs) 180 { 181 if (this != &rhs) 182 { 183 m_opaque_sp = rhs.m_opaque_sp; 184 } 185 return *this; 186 } 187 188 SBDebugger::~SBDebugger () 189 { 190 } 191 192 bool 193 SBDebugger::IsValid() const 194 { 195 return m_opaque_sp.get() != NULL; 196 } 197 198 199 void 200 SBDebugger::SetAsync (bool b) 201 { 202 if (m_opaque_sp) 203 m_opaque_sp->SetAsyncExecution(b); 204 } 205 206 bool 207 SBDebugger::GetAsync () 208 { 209 if (m_opaque_sp) 210 return m_opaque_sp->GetAsyncExecution(); 211 else 212 return false; 213 } 214 215 void 216 SBDebugger::SkipLLDBInitFiles (bool b) 217 { 218 if (m_opaque_sp) 219 m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b); 220 } 221 222 void 223 SBDebugger::SkipAppInitFiles (bool b) 224 { 225 if (m_opaque_sp) 226 m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b); 227 } 228 229 // Shouldn't really be settable after initialization as this could cause lots of problems; don't want users 230 // trying to switch modes in the middle of a debugging session. 231 void 232 SBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership) 233 { 234 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 235 236 if (log) 237 log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 238 fh, transfer_ownership); 239 240 if (m_opaque_sp) 241 m_opaque_sp->SetInputFileHandle (fh, transfer_ownership); 242 } 243 244 void 245 SBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership) 246 { 247 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 248 249 250 if (log) 251 log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 252 fh, transfer_ownership); 253 254 if (m_opaque_sp) 255 m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership); 256 } 257 258 void 259 SBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership) 260 { 261 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 262 263 264 if (log) 265 log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 266 fh, transfer_ownership); 267 268 if (m_opaque_sp) 269 m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership); 270 } 271 272 FILE * 273 SBDebugger::GetInputFileHandle () 274 { 275 if (m_opaque_sp) 276 return m_opaque_sp->GetInputFile().GetStream(); 277 return NULL; 278 } 279 280 FILE * 281 SBDebugger::GetOutputFileHandle () 282 { 283 if (m_opaque_sp) 284 return m_opaque_sp->GetOutputFile().GetStream(); 285 return NULL; 286 } 287 288 FILE * 289 SBDebugger::GetErrorFileHandle () 290 { 291 if (m_opaque_sp) 292 return m_opaque_sp->GetErrorFile().GetStream(); 293 return NULL; 294 } 295 296 void 297 SBDebugger::SaveInputTerminalState() 298 { 299 if (m_opaque_sp) 300 m_opaque_sp->SaveInputTerminalState(); 301 } 302 303 void 304 SBDebugger::RestoreInputTerminalState() 305 { 306 if (m_opaque_sp) 307 m_opaque_sp->RestoreInputTerminalState(); 308 309 } 310 SBCommandInterpreter 311 SBDebugger::GetCommandInterpreter () 312 { 313 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 314 315 SBCommandInterpreter sb_interpreter; 316 if (m_opaque_sp) 317 sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter()); 318 319 if (log) 320 log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)", 321 m_opaque_sp.get(), sb_interpreter.get()); 322 323 return sb_interpreter; 324 } 325 326 void 327 SBDebugger::HandleCommand (const char *command) 328 { 329 if (m_opaque_sp) 330 { 331 TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 332 Mutex::Locker api_locker; 333 if (target_sp) 334 api_locker.Lock(target_sp->GetAPIMutex()); 335 336 SBCommandInterpreter sb_interpreter(GetCommandInterpreter ()); 337 SBCommandReturnObject result; 338 339 sb_interpreter.HandleCommand (command, result, false); 340 341 if (GetErrorFileHandle() != NULL) 342 result.PutError (GetErrorFileHandle()); 343 if (GetOutputFileHandle() != NULL) 344 result.PutOutput (GetOutputFileHandle()); 345 346 if (m_opaque_sp->GetAsyncExecution() == false) 347 { 348 SBProcess process(GetCommandInterpreter().GetProcess ()); 349 ProcessSP process_sp (process.GetSP()); 350 if (process_sp) 351 { 352 EventSP event_sp; 353 Listener &lldb_listener = m_opaque_sp->GetListener(); 354 while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp)) 355 { 356 SBEvent event(event_sp); 357 HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); 358 } 359 } 360 } 361 } 362 } 363 364 SBListener 365 SBDebugger::GetListener () 366 { 367 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 368 369 SBListener sb_listener; 370 if (m_opaque_sp) 371 sb_listener.reset(&m_opaque_sp->GetListener(), false); 372 373 if (log) 374 log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(), 375 sb_listener.get()); 376 377 return sb_listener; 378 } 379 380 void 381 SBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) 382 { 383 if (!process.IsValid()) 384 return; 385 386 TargetSP target_sp (process.GetTarget().GetSP()); 387 if (!target_sp) 388 return; 389 390 const uint32_t event_type = event.GetType(); 391 char stdio_buffer[1024]; 392 size_t len; 393 394 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 395 396 if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) 397 { 398 // Drain stdout when we stop just in case we have any bytes 399 while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) 400 if (out != NULL) 401 ::fwrite (stdio_buffer, 1, len, out); 402 } 403 404 if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) 405 { 406 // Drain stderr when we stop just in case we have any bytes 407 while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) 408 if (err != NULL) 409 ::fwrite (stdio_buffer, 1, len, err); 410 } 411 412 if (event_type & Process::eBroadcastBitStateChanged) 413 { 414 StateType event_state = SBProcess::GetStateFromEvent (event); 415 416 if (event_state == eStateInvalid) 417 return; 418 419 bool is_stopped = StateIsStoppedState (event_state); 420 if (!is_stopped) 421 process.ReportEventState (event, out); 422 } 423 } 424 425 SBSourceManager 426 SBDebugger::GetSourceManager () 427 { 428 SBSourceManager sb_source_manager (*this); 429 return sb_source_manager; 430 } 431 432 433 bool 434 SBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len) 435 { 436 if (arch_name && arch_name_len) 437 { 438 ArchSpec default_arch = Target::GetDefaultArchitecture (); 439 440 if (default_arch.IsValid()) 441 { 442 const std::string &triple_str = default_arch.GetTriple().str(); 443 if (!triple_str.empty()) 444 ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str()); 445 else 446 ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName()); 447 return true; 448 } 449 } 450 if (arch_name && arch_name_len) 451 arch_name[0] = '\0'; 452 return false; 453 } 454 455 456 bool 457 SBDebugger::SetDefaultArchitecture (const char *arch_name) 458 { 459 if (arch_name) 460 { 461 ArchSpec arch (arch_name); 462 if (arch.IsValid()) 463 { 464 Target::SetDefaultArchitecture (arch); 465 return true; 466 } 467 } 468 return false; 469 } 470 471 ScriptLanguage 472 SBDebugger::GetScriptingLanguage (const char *script_language_name) 473 { 474 475 return Args::StringToScriptLanguage (script_language_name, 476 eScriptLanguageDefault, 477 NULL); 478 } 479 480 const char * 481 SBDebugger::GetVersionString () 482 { 483 return GetVersion(); 484 } 485 486 const char * 487 SBDebugger::StateAsCString (StateType state) 488 { 489 return lldb_private::StateAsCString (state); 490 } 491 492 bool 493 SBDebugger::StateIsRunningState (StateType state) 494 { 495 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 496 497 const bool result = lldb_private::StateIsRunningState (state); 498 if (log) 499 log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", 500 StateAsCString (state), result); 501 502 return result; 503 } 504 505 bool 506 SBDebugger::StateIsStoppedState (StateType state) 507 { 508 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 509 510 const bool result = lldb_private::StateIsStoppedState (state, false); 511 if (log) 512 log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", 513 StateAsCString (state), result); 514 515 return result; 516 } 517 518 lldb::SBTarget 519 SBDebugger::CreateTarget (const char *filename, 520 const char *target_triple, 521 const char *platform_name, 522 bool add_dependent_modules, 523 lldb::SBError& sb_error) 524 { 525 SBTarget sb_target; 526 TargetSP target_sp; 527 if (m_opaque_sp) 528 { 529 sb_error.Clear(); 530 OptionGroupPlatform platform_options (false); 531 platform_options.SetPlatformName (platform_name); 532 533 sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 534 filename, 535 target_triple, 536 add_dependent_modules, 537 &platform_options, 538 target_sp); 539 540 if (sb_error.Success()) 541 sb_target.SetSP (target_sp); 542 } 543 else 544 { 545 sb_error.SetErrorString("invalid target"); 546 } 547 548 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 549 if (log) 550 { 551 log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)", 552 m_opaque_sp.get(), 553 filename, 554 target_triple, 555 platform_name, 556 add_dependent_modules, 557 sb_error.GetCString(), 558 target_sp.get()); 559 } 560 561 return sb_target; 562 } 563 564 SBTarget 565 SBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename, 566 const char *target_triple) 567 { 568 SBTarget sb_target; 569 TargetSP target_sp; 570 if (m_opaque_sp) 571 { 572 const bool add_dependent_modules = true; 573 Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 574 filename, 575 target_triple, 576 add_dependent_modules, 577 NULL, 578 target_sp)); 579 sb_target.SetSP (target_sp); 580 } 581 582 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 583 if (log) 584 { 585 log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)", 586 m_opaque_sp.get(), filename, target_triple, target_sp.get()); 587 } 588 589 return sb_target; 590 } 591 592 SBTarget 593 SBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr) 594 { 595 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 596 597 SBTarget sb_target; 598 TargetSP target_sp; 599 if (m_opaque_sp) 600 { 601 Error error; 602 const bool add_dependent_modules = true; 603 604 error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 605 filename, 606 arch_cstr, 607 add_dependent_modules, 608 NULL, 609 target_sp); 610 611 if (error.Success()) 612 { 613 m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 614 sb_target.SetSP (target_sp); 615 } 616 } 617 618 if (log) 619 { 620 log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)", 621 m_opaque_sp.get(), filename, arch_cstr, target_sp.get()); 622 } 623 624 return sb_target; 625 } 626 627 SBTarget 628 SBDebugger::CreateTarget (const char *filename) 629 { 630 SBTarget sb_target; 631 TargetSP target_sp; 632 if (m_opaque_sp) 633 { 634 ArchSpec arch = Target::GetDefaultArchitecture (); 635 Error error; 636 const bool add_dependent_modules = true; 637 638 PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 639 error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 640 filename, 641 arch, 642 add_dependent_modules, 643 platform_sp, 644 target_sp); 645 646 if (error.Success()) 647 { 648 m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 649 sb_target.SetSP (target_sp); 650 } 651 } 652 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 653 if (log) 654 { 655 log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 656 m_opaque_sp.get(), filename, target_sp.get()); 657 } 658 return sb_target; 659 } 660 661 bool 662 SBDebugger::DeleteTarget (lldb::SBTarget &target) 663 { 664 bool result = false; 665 if (m_opaque_sp) 666 { 667 TargetSP target_sp(target.GetSP()); 668 if (target_sp) 669 { 670 // No need to lock, the target list is thread safe 671 result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp); 672 target_sp->Destroy(); 673 target.Clear(); 674 const bool mandatory = true; 675 ModuleList::RemoveOrphanSharedModules(mandatory); 676 } 677 } 678 679 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 680 if (log) 681 { 682 log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result); 683 } 684 685 return result; 686 } 687 SBTarget 688 SBDebugger::GetTargetAtIndex (uint32_t idx) 689 { 690 SBTarget sb_target; 691 if (m_opaque_sp) 692 { 693 // No need to lock, the target list is thread safe 694 sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx)); 695 } 696 return sb_target; 697 } 698 699 uint32_t 700 SBDebugger::GetIndexOfTarget (lldb::SBTarget target) 701 { 702 703 lldb::TargetSP target_sp = target.GetSP(); 704 if (!target_sp) 705 return UINT32_MAX; 706 707 if (!m_opaque_sp) 708 return UINT32_MAX; 709 710 return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP()); 711 } 712 713 SBTarget 714 SBDebugger::FindTargetWithProcessID (pid_t pid) 715 { 716 SBTarget sb_target; 717 if (m_opaque_sp) 718 { 719 // No need to lock, the target list is thread safe 720 sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid)); 721 } 722 return sb_target; 723 } 724 725 SBTarget 726 SBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name) 727 { 728 SBTarget sb_target; 729 if (m_opaque_sp && filename && filename[0]) 730 { 731 // No need to lock, the target list is thread safe 732 ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get()); 733 TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL)); 734 sb_target.SetSP (target_sp); 735 } 736 return sb_target; 737 } 738 739 SBTarget 740 SBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp) 741 { 742 SBTarget sb_target; 743 if (m_opaque_sp) 744 { 745 // No need to lock, the target list is thread safe 746 sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get())); 747 } 748 return sb_target; 749 } 750 751 752 uint32_t 753 SBDebugger::GetNumTargets () 754 { 755 if (m_opaque_sp) 756 { 757 // No need to lock, the target list is thread safe 758 return m_opaque_sp->GetTargetList().GetNumTargets (); 759 } 760 return 0; 761 } 762 763 SBTarget 764 SBDebugger::GetSelectedTarget () 765 { 766 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 767 768 SBTarget sb_target; 769 TargetSP target_sp; 770 if (m_opaque_sp) 771 { 772 // No need to lock, the target list is thread safe 773 target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget (); 774 sb_target.SetSP (target_sp); 775 } 776 777 if (log) 778 { 779 SBStream sstr; 780 sb_target.GetDescription (sstr, eDescriptionLevelBrief); 781 log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 782 target_sp.get(), sstr.GetData()); 783 } 784 785 return sb_target; 786 } 787 788 void 789 SBDebugger::SetSelectedTarget (SBTarget &sb_target) 790 { 791 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 792 793 TargetSP target_sp (sb_target.GetSP()); 794 if (m_opaque_sp) 795 { 796 m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 797 } 798 if (log) 799 { 800 SBStream sstr; 801 sb_target.GetDescription (sstr, eDescriptionLevelBrief); 802 log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 803 target_sp.get(), sstr.GetData()); 804 } 805 } 806 807 void 808 SBDebugger::DispatchInput (void* baton, const void *data, size_t data_len) 809 { 810 DispatchInput (data,data_len); 811 } 812 813 void 814 SBDebugger::DispatchInput (const void *data, size_t data_len) 815 { 816 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 817 818 if (log) 819 log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")", 820 m_opaque_sp.get(), 821 (int) data_len, 822 (const char *) data, 823 (uint64_t)data_len); 824 825 if (m_opaque_sp) 826 m_opaque_sp->DispatchInput ((const char *) data, data_len); 827 } 828 829 void 830 SBDebugger::DispatchInputInterrupt () 831 { 832 if (m_opaque_sp) 833 m_opaque_sp->DispatchInputInterrupt (); 834 } 835 836 void 837 SBDebugger::DispatchInputEndOfFile () 838 { 839 if (m_opaque_sp) 840 m_opaque_sp->DispatchInputEndOfFile (); 841 } 842 843 bool 844 SBDebugger::InputReaderIsTopReader (const lldb::SBInputReader &reader) 845 { 846 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 847 848 if (log) 849 log->Printf ("SBDebugger(%p)::InputReaderIsTopReader (SBInputReader(%p))", m_opaque_sp.get(), &reader); 850 851 if (m_opaque_sp && reader.IsValid()) 852 { 853 InputReaderSP reader_sp (*reader); 854 return m_opaque_sp->InputReaderIsTopReader (reader_sp); 855 } 856 857 return false; 858 } 859 860 861 void 862 SBDebugger::PushInputReader (SBInputReader &reader) 863 { 864 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 865 866 if (log) 867 log->Printf ("SBDebugger(%p)::PushInputReader (SBInputReader(%p))", m_opaque_sp.get(), &reader); 868 869 if (m_opaque_sp && reader.IsValid()) 870 { 871 TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 872 Mutex::Locker api_locker; 873 if (target_sp) 874 api_locker.Lock(target_sp->GetAPIMutex()); 875 InputReaderSP reader_sp(*reader); 876 m_opaque_sp->PushInputReader (reader_sp); 877 } 878 } 879 880 void 881 SBDebugger::NotifyTopInputReader (InputReaderAction notification) 882 { 883 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 884 885 if (log) 886 log->Printf ("SBDebugger(%p)::NotifyTopInputReader (%d)", m_opaque_sp.get(), notification); 887 888 if (m_opaque_sp) 889 m_opaque_sp->NotifyTopInputReader (notification); 890 } 891 892 void 893 SBDebugger::reset (const DebuggerSP &debugger_sp) 894 { 895 m_opaque_sp = debugger_sp; 896 } 897 898 Debugger * 899 SBDebugger::get () const 900 { 901 return m_opaque_sp.get(); 902 } 903 904 Debugger & 905 SBDebugger::ref () const 906 { 907 assert (m_opaque_sp.get()); 908 return *m_opaque_sp; 909 } 910 911 const lldb::DebuggerSP & 912 SBDebugger::get_sp () const 913 { 914 return m_opaque_sp; 915 } 916 917 SBDebugger 918 SBDebugger::FindDebuggerWithID (int id) 919 { 920 // No need to lock, the debugger list is thread safe 921 SBDebugger sb_debugger; 922 DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id); 923 if (debugger_sp) 924 sb_debugger.reset (debugger_sp); 925 return sb_debugger; 926 } 927 928 const char * 929 SBDebugger::GetInstanceName() 930 { 931 if (m_opaque_sp) 932 return m_opaque_sp->GetInstanceName().AsCString(); 933 else 934 return NULL; 935 } 936 937 SBError 938 SBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name) 939 { 940 SBError sb_error; 941 DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 942 Error error; 943 if (debugger_sp) 944 { 945 ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 946 error = debugger_sp->SetPropertyValue (&exe_ctx, 947 eVarSetOperationAssign, 948 var_name, 949 value); 950 } 951 else 952 { 953 error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name); 954 } 955 if (error.Fail()) 956 sb_error.SetError(error); 957 return sb_error; 958 } 959 960 SBStringList 961 SBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name) 962 { 963 SBStringList ret_value; 964 DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 965 Error error; 966 if (debugger_sp) 967 { 968 ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 969 lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx, 970 var_name, 971 false, 972 error)); 973 if (value_sp) 974 { 975 StreamString value_strm; 976 value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 977 const std::string &value_str = value_strm.GetString(); 978 if (!value_str.empty()) 979 { 980 StringList string_list; 981 string_list.SplitIntoLines(value_str.c_str(), value_str.size()); 982 return SBStringList(&string_list); 983 } 984 } 985 } 986 return SBStringList(); 987 } 988 989 uint32_t 990 SBDebugger::GetTerminalWidth () const 991 { 992 if (m_opaque_sp) 993 return m_opaque_sp->GetTerminalWidth (); 994 return 0; 995 } 996 997 void 998 SBDebugger::SetTerminalWidth (uint32_t term_width) 999 { 1000 if (m_opaque_sp) 1001 m_opaque_sp->SetTerminalWidth (term_width); 1002 } 1003 1004 const char * 1005 SBDebugger::GetPrompt() const 1006 { 1007 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1008 1009 if (log) 1010 log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(), 1011 (m_opaque_sp ? m_opaque_sp->GetPrompt() : "")); 1012 1013 if (m_opaque_sp) 1014 return m_opaque_sp->GetPrompt (); 1015 return 0; 1016 } 1017 1018 void 1019 SBDebugger::SetPrompt (const char *prompt) 1020 { 1021 if (m_opaque_sp) 1022 m_opaque_sp->SetPrompt (prompt); 1023 } 1024 1025 1026 ScriptLanguage 1027 SBDebugger::GetScriptLanguage() const 1028 { 1029 if (m_opaque_sp) 1030 return m_opaque_sp->GetScriptLanguage (); 1031 return eScriptLanguageNone; 1032 } 1033 1034 void 1035 SBDebugger::SetScriptLanguage (ScriptLanguage script_lang) 1036 { 1037 if (m_opaque_sp) 1038 { 1039 m_opaque_sp->SetScriptLanguage (script_lang); 1040 } 1041 } 1042 1043 bool 1044 SBDebugger::SetUseExternalEditor (bool value) 1045 { 1046 if (m_opaque_sp) 1047 return m_opaque_sp->SetUseExternalEditor (value); 1048 return false; 1049 } 1050 1051 bool 1052 SBDebugger::GetUseExternalEditor () 1053 { 1054 if (m_opaque_sp) 1055 return m_opaque_sp->GetUseExternalEditor (); 1056 return false; 1057 } 1058 1059 bool 1060 SBDebugger::SetUseColor (bool value) 1061 { 1062 if (m_opaque_sp) 1063 return m_opaque_sp->SetUseColor (value); 1064 return false; 1065 } 1066 1067 bool 1068 SBDebugger::GetUseColor () const 1069 { 1070 if (m_opaque_sp) 1071 return m_opaque_sp->GetUseColor (); 1072 return false; 1073 } 1074 1075 bool 1076 SBDebugger::GetDescription (SBStream &description) 1077 { 1078 Stream &strm = description.ref(); 1079 1080 if (m_opaque_sp) 1081 { 1082 const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1083 user_id_t id = m_opaque_sp->GetID(); 1084 strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1085 } 1086 else 1087 strm.PutCString ("No value"); 1088 1089 return true; 1090 } 1091 1092 user_id_t 1093 SBDebugger::GetID() 1094 { 1095 if (m_opaque_sp) 1096 return m_opaque_sp->GetID(); 1097 return LLDB_INVALID_UID; 1098 } 1099 1100 1101 SBError 1102 SBDebugger::SetCurrentPlatform (const char *platform_name) 1103 { 1104 SBError sb_error; 1105 if (m_opaque_sp) 1106 { 1107 PlatformSP platform_sp (Platform::Create (platform_name, sb_error.ref())); 1108 1109 if (platform_sp) 1110 { 1111 bool make_selected = true; 1112 m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected); 1113 } 1114 } 1115 return sb_error; 1116 } 1117 1118 bool 1119 SBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot) 1120 { 1121 if (m_opaque_sp) 1122 { 1123 PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1124 1125 if (platform_sp) 1126 { 1127 platform_sp->SetSDKRootDirectory (ConstString (sysroot)); 1128 return true; 1129 } 1130 } 1131 return false; 1132 } 1133 1134 bool 1135 SBDebugger::GetCloseInputOnEOF () const 1136 { 1137 if (m_opaque_sp) 1138 return m_opaque_sp->GetCloseInputOnEOF (); 1139 return false; 1140 } 1141 1142 void 1143 SBDebugger::SetCloseInputOnEOF (bool b) 1144 { 1145 if (m_opaque_sp) 1146 m_opaque_sp->SetCloseInputOnEOF (b); 1147 } 1148 1149 SBTypeCategory 1150 SBDebugger::GetCategory (const char* category_name) 1151 { 1152 if (!category_name || *category_name == 0) 1153 return SBTypeCategory(); 1154 1155 TypeCategoryImplSP category_sp; 1156 1157 if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false)) 1158 return SBTypeCategory(category_sp); 1159 else 1160 return SBTypeCategory(); 1161 } 1162 1163 SBTypeCategory 1164 SBDebugger::CreateCategory (const char* category_name) 1165 { 1166 if (!category_name || *category_name == 0) 1167 return SBTypeCategory(); 1168 1169 TypeCategoryImplSP category_sp; 1170 1171 if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true)) 1172 return SBTypeCategory(category_sp); 1173 else 1174 return SBTypeCategory(); 1175 } 1176 1177 bool 1178 SBDebugger::DeleteCategory (const char* category_name) 1179 { 1180 if (!category_name || *category_name == 0) 1181 return false; 1182 1183 return DataVisualization::Categories::Delete(ConstString(category_name)); 1184 } 1185 1186 uint32_t 1187 SBDebugger::GetNumCategories() 1188 { 1189 return DataVisualization::Categories::GetCount(); 1190 } 1191 1192 SBTypeCategory 1193 SBDebugger::GetCategoryAtIndex (uint32_t index) 1194 { 1195 return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)); 1196 } 1197 1198 SBTypeCategory 1199 SBDebugger::GetDefaultCategory() 1200 { 1201 return GetCategory("default"); 1202 } 1203 1204 SBTypeFormat 1205 SBDebugger::GetFormatForType (SBTypeNameSpecifier type_name) 1206 { 1207 SBTypeCategory default_category_sb = GetDefaultCategory(); 1208 if (default_category_sb.GetEnabled()) 1209 return default_category_sb.GetFormatForType(type_name); 1210 return SBTypeFormat(); 1211 } 1212 1213 #ifndef LLDB_DISABLE_PYTHON 1214 SBTypeSummary 1215 SBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name) 1216 { 1217 if (type_name.IsValid() == false) 1218 return SBTypeSummary(); 1219 return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())); 1220 } 1221 #endif // LLDB_DISABLE_PYTHON 1222 1223 SBTypeFilter 1224 SBDebugger::GetFilterForType (SBTypeNameSpecifier type_name) 1225 { 1226 if (type_name.IsValid() == false) 1227 return SBTypeFilter(); 1228 return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())); 1229 } 1230 1231 #ifndef LLDB_DISABLE_PYTHON 1232 SBTypeSynthetic 1233 SBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name) 1234 { 1235 if (type_name.IsValid() == false) 1236 return SBTypeSynthetic(); 1237 return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP())); 1238 } 1239 #endif // LLDB_DISABLE_PYTHON 1240 1241 bool 1242 SBDebugger::EnableLog (const char *channel, const char **categories) 1243 { 1244 if (m_opaque_sp) 1245 { 1246 uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1247 StreamString errors; 1248 return m_opaque_sp->EnableLog (channel, categories, NULL, log_options, errors); 1249 1250 } 1251 else 1252 return false; 1253 } 1254 1255 void 1256 SBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 1257 { 1258 if (m_opaque_sp) 1259 { 1260 return m_opaque_sp->SetLoggingCallback (log_callback, baton); 1261 } 1262 } 1263 1264 1265