1 //===-- SBTarget.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/SBTarget.h" 13 14 #include "lldb/lldb-public.h" 15 16 #include "lldb/API/SBDebugger.h" 17 #include "lldb/API/SBBreakpoint.h" 18 #include "lldb/API/SBExpressionOptions.h" 19 #include "lldb/API/SBFileSpec.h" 20 #include "lldb/API/SBListener.h" 21 #include "lldb/API/SBModule.h" 22 #include "lldb/API/SBModuleSpec.h" 23 #include "lldb/API/SBSourceManager.h" 24 #include "lldb/API/SBProcess.h" 25 #include "lldb/API/SBStream.h" 26 #include "lldb/API/SBSymbolContextList.h" 27 #include "lldb/Breakpoint/BreakpointID.h" 28 #include "lldb/Breakpoint/BreakpointIDList.h" 29 #include "lldb/Breakpoint/BreakpointList.h" 30 #include "lldb/Breakpoint/BreakpointLocation.h" 31 #include "lldb/Core/Address.h" 32 #include "lldb/Core/AddressResolver.h" 33 #include "lldb/Core/AddressResolverName.h" 34 #include "lldb/Core/ArchSpec.h" 35 #include "lldb/Core/Debugger.h" 36 #include "lldb/Core/Disassembler.h" 37 #include "lldb/Core/Log.h" 38 #include "lldb/Core/Module.h" 39 #include "lldb/Core/ModuleSpec.h" 40 #include "lldb/Core/RegularExpression.h" 41 #include "lldb/Core/SearchFilter.h" 42 #include "lldb/Core/Section.h" 43 #include "lldb/Core/STLUtils.h" 44 #include "lldb/Core/ValueObjectList.h" 45 #include "lldb/Core/ValueObjectVariable.h" 46 #include "lldb/Host/FileSpec.h" 47 #include "lldb/Host/Host.h" 48 #include "lldb/Interpreter/Args.h" 49 #include "lldb/Symbol/ObjectFile.h" 50 #include "lldb/Symbol/SymbolVendor.h" 51 #include "lldb/Symbol/VariableList.h" 52 #include "lldb/Target/LanguageRuntime.h" 53 #include "lldb/Target/Process.h" 54 #include "lldb/Target/Target.h" 55 #include "lldb/Target/TargetList.h" 56 57 #include "lldb/Interpreter/CommandReturnObject.h" 58 #include "../source/Commands/CommandObjectBreakpoint.h" 59 60 61 using namespace lldb; 62 using namespace lldb_private; 63 64 #define DEFAULT_DISASM_BYTE_SIZE 32 65 66 SBLaunchInfo::SBLaunchInfo (const char **argv) : 67 m_opaque_sp(new ProcessLaunchInfo()) 68 { 69 m_opaque_sp->GetFlags().Reset (eLaunchFlagDebug | eLaunchFlagDisableASLR); 70 if (argv && argv[0]) 71 m_opaque_sp->GetArguments().SetArguments(argv); 72 } 73 74 SBLaunchInfo::~SBLaunchInfo() 75 { 76 } 77 78 lldb_private::ProcessLaunchInfo & 79 SBLaunchInfo::ref () 80 { 81 return *m_opaque_sp; 82 } 83 84 85 uint32_t 86 SBLaunchInfo::GetUserID() 87 { 88 return m_opaque_sp->GetUserID(); 89 } 90 91 uint32_t 92 SBLaunchInfo::GetGroupID() 93 { 94 return m_opaque_sp->GetGroupID(); 95 } 96 97 bool 98 SBLaunchInfo::UserIDIsValid () 99 { 100 return m_opaque_sp->UserIDIsValid(); 101 } 102 103 bool 104 SBLaunchInfo::GroupIDIsValid () 105 { 106 return m_opaque_sp->GroupIDIsValid(); 107 } 108 109 void 110 SBLaunchInfo::SetUserID (uint32_t uid) 111 { 112 m_opaque_sp->SetUserID (uid); 113 } 114 115 void 116 SBLaunchInfo::SetGroupID (uint32_t gid) 117 { 118 m_opaque_sp->SetGroupID (gid); 119 } 120 121 uint32_t 122 SBLaunchInfo::GetNumArguments () 123 { 124 return m_opaque_sp->GetArguments().GetArgumentCount(); 125 } 126 127 const char * 128 SBLaunchInfo::GetArgumentAtIndex (uint32_t idx) 129 { 130 return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx); 131 } 132 133 void 134 SBLaunchInfo::SetArguments (const char **argv, bool append) 135 { 136 if (append) 137 { 138 if (argv) 139 m_opaque_sp->GetArguments().AppendArguments(argv); 140 } 141 else 142 { 143 if (argv) 144 m_opaque_sp->GetArguments().SetArguments(argv); 145 else 146 m_opaque_sp->GetArguments().Clear(); 147 } 148 } 149 150 uint32_t 151 SBLaunchInfo::GetNumEnvironmentEntries () 152 { 153 return m_opaque_sp->GetEnvironmentEntries().GetArgumentCount(); 154 } 155 156 const char * 157 SBLaunchInfo::GetEnvironmentEntryAtIndex (uint32_t idx) 158 { 159 return m_opaque_sp->GetEnvironmentEntries().GetArgumentAtIndex(idx); 160 } 161 162 void 163 SBLaunchInfo::SetEnvironmentEntries (const char **envp, bool append) 164 { 165 if (append) 166 { 167 if (envp) 168 m_opaque_sp->GetEnvironmentEntries().AppendArguments(envp); 169 } 170 else 171 { 172 if (envp) 173 m_opaque_sp->GetEnvironmentEntries().SetArguments(envp); 174 else 175 m_opaque_sp->GetEnvironmentEntries().Clear(); 176 } 177 } 178 179 void 180 SBLaunchInfo::Clear () 181 { 182 m_opaque_sp->Clear(); 183 } 184 185 const char * 186 SBLaunchInfo::GetWorkingDirectory () const 187 { 188 return m_opaque_sp->GetWorkingDirectory(); 189 } 190 191 void 192 SBLaunchInfo::SetWorkingDirectory (const char *working_dir) 193 { 194 m_opaque_sp->SetWorkingDirectory(working_dir); 195 } 196 197 uint32_t 198 SBLaunchInfo::GetLaunchFlags () 199 { 200 return m_opaque_sp->GetFlags().Get(); 201 } 202 203 void 204 SBLaunchInfo::SetLaunchFlags (uint32_t flags) 205 { 206 m_opaque_sp->GetFlags().Reset(flags); 207 } 208 209 const char * 210 SBLaunchInfo::GetProcessPluginName () 211 { 212 return m_opaque_sp->GetProcessPluginName(); 213 } 214 215 void 216 SBLaunchInfo::SetProcessPluginName (const char *plugin_name) 217 { 218 return m_opaque_sp->SetProcessPluginName (plugin_name); 219 } 220 221 const char * 222 SBLaunchInfo::GetShell () 223 { 224 return m_opaque_sp->GetShell(); 225 } 226 227 void 228 SBLaunchInfo::SetShell (const char * path) 229 { 230 m_opaque_sp->SetShell (path); 231 } 232 233 uint32_t 234 SBLaunchInfo::GetResumeCount () 235 { 236 return m_opaque_sp->GetResumeCount(); 237 } 238 239 void 240 SBLaunchInfo::SetResumeCount (uint32_t c) 241 { 242 m_opaque_sp->SetResumeCount (c); 243 } 244 245 bool 246 SBLaunchInfo::AddCloseFileAction (int fd) 247 { 248 return m_opaque_sp->AppendCloseFileAction(fd); 249 } 250 251 bool 252 SBLaunchInfo::AddDuplicateFileAction (int fd, int dup_fd) 253 { 254 return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd); 255 } 256 257 bool 258 SBLaunchInfo::AddOpenFileAction (int fd, const char *path, bool read, bool write) 259 { 260 return m_opaque_sp->AppendOpenFileAction(fd, path, read, write); 261 } 262 263 bool 264 SBLaunchInfo::AddSuppressFileAction (int fd, bool read, bool write) 265 { 266 return m_opaque_sp->AppendSuppressFileAction(fd, read, write); 267 } 268 269 270 SBAttachInfo::SBAttachInfo () : 271 m_opaque_sp (new ProcessAttachInfo()) 272 { 273 } 274 275 SBAttachInfo::SBAttachInfo (lldb::pid_t pid) : 276 m_opaque_sp (new ProcessAttachInfo()) 277 { 278 m_opaque_sp->SetProcessID (pid); 279 } 280 281 SBAttachInfo::SBAttachInfo (const char *path, bool wait_for) : 282 m_opaque_sp (new ProcessAttachInfo()) 283 { 284 if (path && path[0]) 285 m_opaque_sp->GetExecutableFile().SetFile(path, false); 286 m_opaque_sp->SetWaitForLaunch (wait_for); 287 } 288 289 SBAttachInfo::SBAttachInfo (const SBAttachInfo &rhs) : 290 m_opaque_sp (new ProcessAttachInfo()) 291 { 292 *m_opaque_sp = *rhs.m_opaque_sp; 293 } 294 295 SBAttachInfo::~SBAttachInfo() 296 { 297 } 298 299 lldb_private::ProcessAttachInfo & 300 SBAttachInfo::ref () 301 { 302 return *m_opaque_sp; 303 } 304 305 SBAttachInfo & 306 SBAttachInfo::operator = (const SBAttachInfo &rhs) 307 { 308 if (this != &rhs) 309 *m_opaque_sp = *rhs.m_opaque_sp; 310 return *this; 311 } 312 313 lldb::pid_t 314 SBAttachInfo::GetProcessID () 315 { 316 return m_opaque_sp->GetProcessID(); 317 } 318 319 void 320 SBAttachInfo::SetProcessID (lldb::pid_t pid) 321 { 322 m_opaque_sp->SetProcessID (pid); 323 } 324 325 326 uint32_t 327 SBAttachInfo::GetResumeCount () 328 { 329 return m_opaque_sp->GetResumeCount(); 330 } 331 332 void 333 SBAttachInfo::SetResumeCount (uint32_t c) 334 { 335 m_opaque_sp->SetResumeCount (c); 336 } 337 338 const char * 339 SBAttachInfo::GetProcessPluginName () 340 { 341 return m_opaque_sp->GetProcessPluginName(); 342 } 343 344 void 345 SBAttachInfo::SetProcessPluginName (const char *plugin_name) 346 { 347 return m_opaque_sp->SetProcessPluginName (plugin_name); 348 } 349 350 void 351 SBAttachInfo::SetExecutable (const char *path) 352 { 353 if (path && path[0]) 354 m_opaque_sp->GetExecutableFile().SetFile(path, false); 355 else 356 m_opaque_sp->GetExecutableFile().Clear(); 357 } 358 359 void 360 SBAttachInfo::SetExecutable (SBFileSpec exe_file) 361 { 362 if (exe_file.IsValid()) 363 m_opaque_sp->GetExecutableFile() = exe_file.ref(); 364 else 365 m_opaque_sp->GetExecutableFile().Clear(); 366 } 367 368 bool 369 SBAttachInfo::GetWaitForLaunch () 370 { 371 return m_opaque_sp->GetWaitForLaunch(); 372 } 373 374 void 375 SBAttachInfo::SetWaitForLaunch (bool b) 376 { 377 m_opaque_sp->SetWaitForLaunch (b); 378 } 379 380 bool 381 SBAttachInfo::GetIgnoreExisting () 382 { 383 return m_opaque_sp->GetIgnoreExisting(); 384 } 385 386 void 387 SBAttachInfo::SetIgnoreExisting (bool b) 388 { 389 m_opaque_sp->SetIgnoreExisting (b); 390 } 391 392 uint32_t 393 SBAttachInfo::GetUserID() 394 { 395 return m_opaque_sp->GetUserID(); 396 } 397 398 uint32_t 399 SBAttachInfo::GetGroupID() 400 { 401 return m_opaque_sp->GetGroupID(); 402 } 403 404 bool 405 SBAttachInfo::UserIDIsValid () 406 { 407 return m_opaque_sp->UserIDIsValid(); 408 } 409 410 bool 411 SBAttachInfo::GroupIDIsValid () 412 { 413 return m_opaque_sp->GroupIDIsValid(); 414 } 415 416 void 417 SBAttachInfo::SetUserID (uint32_t uid) 418 { 419 m_opaque_sp->SetUserID (uid); 420 } 421 422 void 423 SBAttachInfo::SetGroupID (uint32_t gid) 424 { 425 m_opaque_sp->SetGroupID (gid); 426 } 427 428 uint32_t 429 SBAttachInfo::GetEffectiveUserID() 430 { 431 return m_opaque_sp->GetEffectiveUserID(); 432 } 433 434 uint32_t 435 SBAttachInfo::GetEffectiveGroupID() 436 { 437 return m_opaque_sp->GetEffectiveGroupID(); 438 } 439 440 bool 441 SBAttachInfo::EffectiveUserIDIsValid () 442 { 443 return m_opaque_sp->EffectiveUserIDIsValid(); 444 } 445 446 bool 447 SBAttachInfo::EffectiveGroupIDIsValid () 448 { 449 return m_opaque_sp->EffectiveGroupIDIsValid (); 450 } 451 452 void 453 SBAttachInfo::SetEffectiveUserID (uint32_t uid) 454 { 455 m_opaque_sp->SetEffectiveUserID(uid); 456 } 457 458 void 459 SBAttachInfo::SetEffectiveGroupID (uint32_t gid) 460 { 461 m_opaque_sp->SetEffectiveGroupID(gid); 462 } 463 464 lldb::pid_t 465 SBAttachInfo::GetParentProcessID () 466 { 467 return m_opaque_sp->GetParentProcessID(); 468 } 469 470 void 471 SBAttachInfo::SetParentProcessID (lldb::pid_t pid) 472 { 473 m_opaque_sp->SetParentProcessID (pid); 474 } 475 476 bool 477 SBAttachInfo::ParentProcessIDIsValid() 478 { 479 return m_opaque_sp->ParentProcessIDIsValid(); 480 } 481 482 483 //---------------------------------------------------------------------- 484 // SBTarget constructor 485 //---------------------------------------------------------------------- 486 SBTarget::SBTarget () : 487 m_opaque_sp () 488 { 489 } 490 491 SBTarget::SBTarget (const SBTarget& rhs) : 492 m_opaque_sp (rhs.m_opaque_sp) 493 { 494 } 495 496 SBTarget::SBTarget(const TargetSP& target_sp) : 497 m_opaque_sp (target_sp) 498 { 499 } 500 501 const SBTarget& 502 SBTarget::operator = (const SBTarget& rhs) 503 { 504 if (this != &rhs) 505 m_opaque_sp = rhs.m_opaque_sp; 506 return *this; 507 } 508 509 //---------------------------------------------------------------------- 510 // Destructor 511 //---------------------------------------------------------------------- 512 SBTarget::~SBTarget() 513 { 514 } 515 516 const char * 517 SBTarget::GetBroadcasterClassName () 518 { 519 return Target::GetStaticBroadcasterClass().AsCString(); 520 } 521 522 bool 523 SBTarget::IsValid () const 524 { 525 return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid(); 526 } 527 528 SBProcess 529 SBTarget::GetProcess () 530 { 531 SBProcess sb_process; 532 ProcessSP process_sp; 533 TargetSP target_sp(GetSP()); 534 if (target_sp) 535 { 536 process_sp = target_sp->GetProcessSP(); 537 sb_process.SetSP (process_sp); 538 } 539 540 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 541 if (log) 542 { 543 log->Printf ("SBTarget(%p)::GetProcess () => SBProcess(%p)", 544 target_sp.get(), process_sp.get()); 545 } 546 547 return sb_process; 548 } 549 550 SBDebugger 551 SBTarget::GetDebugger () const 552 { 553 SBDebugger debugger; 554 TargetSP target_sp(GetSP()); 555 if (target_sp) 556 debugger.reset (target_sp->GetDebugger().shared_from_this()); 557 return debugger; 558 } 559 560 SBProcess 561 SBTarget::LoadCore (const char *core_file) 562 { 563 SBProcess sb_process; 564 TargetSP target_sp(GetSP()); 565 if (target_sp) 566 { 567 FileSpec filespec(core_file, true); 568 ProcessSP process_sp (target_sp->CreateProcess(target_sp->GetDebugger().GetListener(), 569 NULL, 570 &filespec)); 571 if (process_sp) 572 { 573 process_sp->LoadCore(); 574 sb_process.SetSP (process_sp); 575 } 576 } 577 return sb_process; 578 } 579 580 SBProcess 581 SBTarget::LaunchSimple 582 ( 583 char const **argv, 584 char const **envp, 585 const char *working_directory 586 ) 587 { 588 char *stdin_path = NULL; 589 char *stdout_path = NULL; 590 char *stderr_path = NULL; 591 uint32_t launch_flags = 0; 592 bool stop_at_entry = false; 593 SBError error; 594 SBListener listener = GetDebugger().GetListener(); 595 return Launch (listener, 596 argv, 597 envp, 598 stdin_path, 599 stdout_path, 600 stderr_path, 601 working_directory, 602 launch_flags, 603 stop_at_entry, 604 error); 605 } 606 607 SBProcess 608 SBTarget::Launch 609 ( 610 SBListener &listener, 611 char const **argv, 612 char const **envp, 613 const char *stdin_path, 614 const char *stdout_path, 615 const char *stderr_path, 616 const char *working_directory, 617 uint32_t launch_flags, // See LaunchFlags 618 bool stop_at_entry, 619 lldb::SBError& error 620 ) 621 { 622 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 623 624 SBProcess sb_process; 625 ProcessSP process_sp; 626 TargetSP target_sp(GetSP()); 627 628 if (log) 629 { 630 log->Printf ("SBTarget(%p)::Launch (argv=%p, envp=%p, stdin=%s, stdout=%s, stderr=%s, working-dir=%s, launch_flags=0x%x, stop_at_entry=%i, &error (%p))...", 631 target_sp.get(), 632 argv, 633 envp, 634 stdin_path ? stdin_path : "NULL", 635 stdout_path ? stdout_path : "NULL", 636 stderr_path ? stderr_path : "NULL", 637 working_directory ? working_directory : "NULL", 638 launch_flags, 639 stop_at_entry, 640 error.get()); 641 } 642 643 if (target_sp) 644 { 645 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 646 647 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) 648 launch_flags |= eLaunchFlagDisableASLR; 649 650 StateType state = eStateInvalid; 651 process_sp = target_sp->GetProcessSP(); 652 if (process_sp) 653 { 654 state = process_sp->GetState(); 655 656 if (process_sp->IsAlive() && state != eStateConnected) 657 { 658 if (state == eStateAttaching) 659 error.SetErrorString ("process attach is in progress"); 660 else 661 error.SetErrorString ("a process is already being debugged"); 662 return sb_process; 663 } 664 } 665 666 if (state == eStateConnected) 667 { 668 // If we are already connected, then we have already specified the 669 // listener, so if a valid listener is supplied, we need to error out 670 // to let the client know. 671 if (listener.IsValid()) 672 { 673 error.SetErrorString ("process is connected and already has a listener, pass empty listener"); 674 return sb_process; 675 } 676 } 677 else 678 { 679 if (listener.IsValid()) 680 process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL); 681 else 682 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL); 683 } 684 685 if (process_sp) 686 { 687 sb_process.SetSP (process_sp); 688 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) 689 launch_flags |= eLaunchFlagDisableSTDIO; 690 691 ProcessLaunchInfo launch_info (stdin_path, stdout_path, stderr_path, working_directory, launch_flags); 692 693 Module *exe_module = target_sp->GetExecutableModulePointer(); 694 if (exe_module) 695 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 696 if (argv) 697 launch_info.GetArguments().AppendArguments (argv); 698 if (envp) 699 launch_info.GetEnvironmentEntries ().SetArguments (envp); 700 701 error.SetError (process_sp->Launch (launch_info)); 702 if (error.Success()) 703 { 704 // We we are stopping at the entry point, we can return now! 705 if (stop_at_entry) 706 return sb_process; 707 708 // Make sure we are stopped at the entry 709 StateType state = process_sp->WaitForProcessToStop (NULL); 710 if (state == eStateStopped) 711 { 712 // resume the process to skip the entry point 713 error.SetError (process_sp->Resume()); 714 if (error.Success()) 715 { 716 // If we are doing synchronous mode, then wait for the 717 // process to stop yet again! 718 if (target_sp->GetDebugger().GetAsyncExecution () == false) 719 process_sp->WaitForProcessToStop (NULL); 720 } 721 } 722 } 723 } 724 else 725 { 726 error.SetErrorString ("unable to create lldb_private::Process"); 727 } 728 } 729 else 730 { 731 error.SetErrorString ("SBTarget is invalid"); 732 } 733 734 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API); 735 if (log) 736 { 737 log->Printf ("SBTarget(%p)::Launch (...) => SBProcess(%p)", 738 target_sp.get(), process_sp.get()); 739 } 740 741 return sb_process; 742 } 743 744 SBProcess 745 SBTarget::Launch (SBLaunchInfo &sb_launch_info, SBError& error) 746 { 747 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 748 749 SBProcess sb_process; 750 ProcessSP process_sp; 751 TargetSP target_sp(GetSP()); 752 753 if (log) 754 { 755 log->Printf ("SBTarget(%p)::Launch (launch_info, error)...", target_sp.get()); 756 } 757 758 if (target_sp) 759 { 760 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 761 StateType state = eStateInvalid; 762 process_sp = target_sp->GetProcessSP(); 763 if (process_sp) 764 { 765 state = process_sp->GetState(); 766 767 if (process_sp->IsAlive() && state != eStateConnected) 768 { 769 if (state == eStateAttaching) 770 error.SetErrorString ("process attach is in progress"); 771 else 772 error.SetErrorString ("a process is already being debugged"); 773 return sb_process; 774 } 775 } 776 777 if (state != eStateConnected) 778 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL); 779 780 if (process_sp) 781 { 782 sb_process.SetSP (process_sp); 783 lldb_private::ProcessLaunchInfo &launch_info = sb_launch_info.ref(); 784 785 Module *exe_module = target_sp->GetExecutableModulePointer(); 786 if (exe_module) 787 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 788 789 const ArchSpec &arch_spec = target_sp->GetArchitecture(); 790 if (arch_spec.IsValid()) 791 launch_info.GetArchitecture () = arch_spec; 792 793 error.SetError (process_sp->Launch (launch_info)); 794 const bool synchronous_execution = target_sp->GetDebugger().GetAsyncExecution () == false; 795 if (error.Success()) 796 { 797 if (launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) 798 { 799 // If we are doing synchronous mode, then wait for the initial 800 // stop to happen, else, return and let the caller watch for 801 // the stop 802 if (synchronous_execution) 803 process_sp->WaitForProcessToStop (NULL); 804 // We we are stopping at the entry point, we can return now! 805 return sb_process; 806 } 807 808 // Make sure we are stopped at the entry 809 StateType state = process_sp->WaitForProcessToStop (NULL); 810 if (state == eStateStopped) 811 { 812 // resume the process to skip the entry point 813 error.SetError (process_sp->Resume()); 814 if (error.Success()) 815 { 816 // If we are doing synchronous mode, then wait for the 817 // process to stop yet again! 818 if (synchronous_execution) 819 process_sp->WaitForProcessToStop (NULL); 820 } 821 } 822 } 823 } 824 else 825 { 826 error.SetErrorString ("unable to create lldb_private::Process"); 827 } 828 } 829 else 830 { 831 error.SetErrorString ("SBTarget is invalid"); 832 } 833 834 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API); 835 if (log) 836 { 837 log->Printf ("SBTarget(%p)::Launch (...) => SBProcess(%p)", 838 target_sp.get(), process_sp.get()); 839 } 840 841 return sb_process; 842 } 843 844 lldb::SBProcess 845 SBTarget::Attach (SBAttachInfo &sb_attach_info, SBError& error) 846 { 847 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 848 849 SBProcess sb_process; 850 ProcessSP process_sp; 851 TargetSP target_sp(GetSP()); 852 853 if (log) 854 { 855 log->Printf ("SBTarget(%p)::Attach (sb_attach_info, error)...", target_sp.get()); 856 } 857 858 if (target_sp) 859 { 860 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 861 862 StateType state = eStateInvalid; 863 process_sp = target_sp->GetProcessSP(); 864 if (process_sp) 865 { 866 state = process_sp->GetState(); 867 868 if (process_sp->IsAlive() && state != eStateConnected) 869 { 870 if (state == eStateAttaching) 871 error.SetErrorString ("process attach is in progress"); 872 else 873 error.SetErrorString ("a process is already being debugged"); 874 if (log) 875 { 876 log->Printf ("SBTarget(%p)::Attach (...) => error %s", 877 target_sp.get(), error.GetCString()); 878 } 879 return sb_process; 880 } 881 } 882 883 if (state != eStateConnected) 884 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL); 885 886 if (process_sp) 887 { 888 ProcessAttachInfo &attach_info = sb_attach_info.ref(); 889 if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) 890 { 891 PlatformSP platform_sp = target_sp->GetPlatform(); 892 // See if we can pre-verify if a process exists or not 893 if (platform_sp && platform_sp->IsConnected()) 894 { 895 lldb::pid_t attach_pid = attach_info.GetProcessID(); 896 ProcessInstanceInfo instance_info; 897 if (platform_sp->GetProcessInfo(attach_pid, instance_info)) 898 { 899 attach_info.SetUserID(instance_info.GetEffectiveUserID()); 900 } 901 else 902 { 903 error.ref().SetErrorStringWithFormat("no process found with process ID %" PRIu64, attach_pid); 904 if (log) 905 { 906 log->Printf ("SBTarget(%p)::Attach (...) => error %s", 907 target_sp.get(), error.GetCString()); 908 } 909 return sb_process; 910 } 911 } 912 } 913 error.SetError (process_sp->Attach (attach_info)); 914 if (error.Success()) 915 { 916 sb_process.SetSP (process_sp); 917 // If we are doing synchronous mode, then wait for the 918 // process to stop! 919 if (target_sp->GetDebugger().GetAsyncExecution () == false) 920 process_sp->WaitForProcessToStop (NULL); 921 } 922 } 923 else 924 { 925 error.SetErrorString ("unable to create lldb_private::Process"); 926 } 927 } 928 else 929 { 930 error.SetErrorString ("SBTarget is invalid"); 931 } 932 933 if (log) 934 { 935 log->Printf ("SBTarget(%p)::Attach (...) => SBProcess(%p)", 936 target_sp.get(), process_sp.get()); 937 } 938 939 return sb_process; 940 } 941 942 943 #if defined(__APPLE__) 944 945 lldb::SBProcess 946 SBTarget::AttachToProcessWithID (SBListener &listener, 947 ::pid_t pid, 948 lldb::SBError& error) 949 { 950 return AttachToProcessWithID (listener, (lldb::pid_t)pid, error); 951 } 952 953 #endif // #if defined(__APPLE__) 954 955 lldb::SBProcess 956 SBTarget::AttachToProcessWithID 957 ( 958 SBListener &listener, 959 lldb::pid_t pid,// The process ID to attach to 960 SBError& error // An error explaining what went wrong if attach fails 961 ) 962 { 963 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 964 965 SBProcess sb_process; 966 ProcessSP process_sp; 967 TargetSP target_sp(GetSP()); 968 969 if (log) 970 { 971 log->Printf ("SBTarget(%p)::AttachToProcessWithID (listener, pid=%" PRId64 ", error)...", target_sp.get(), pid); 972 } 973 974 if (target_sp) 975 { 976 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 977 978 StateType state = eStateInvalid; 979 process_sp = target_sp->GetProcessSP(); 980 if (process_sp) 981 { 982 state = process_sp->GetState(); 983 984 if (process_sp->IsAlive() && state != eStateConnected) 985 { 986 if (state == eStateAttaching) 987 error.SetErrorString ("process attach is in progress"); 988 else 989 error.SetErrorString ("a process is already being debugged"); 990 return sb_process; 991 } 992 } 993 994 if (state == eStateConnected) 995 { 996 // If we are already connected, then we have already specified the 997 // listener, so if a valid listener is supplied, we need to error out 998 // to let the client know. 999 if (listener.IsValid()) 1000 { 1001 error.SetErrorString ("process is connected and already has a listener, pass empty listener"); 1002 return sb_process; 1003 } 1004 } 1005 else 1006 { 1007 if (listener.IsValid()) 1008 process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL); 1009 else 1010 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL); 1011 } 1012 if (process_sp) 1013 { 1014 sb_process.SetSP (process_sp); 1015 1016 ProcessAttachInfo attach_info; 1017 attach_info.SetProcessID (pid); 1018 1019 PlatformSP platform_sp = target_sp->GetPlatform(); 1020 ProcessInstanceInfo instance_info; 1021 if (platform_sp->GetProcessInfo(pid, instance_info)) 1022 { 1023 attach_info.SetUserID(instance_info.GetEffectiveUserID()); 1024 } 1025 error.SetError (process_sp->Attach (attach_info)); 1026 if (error.Success()) 1027 { 1028 // If we are doing synchronous mode, then wait for the 1029 // process to stop! 1030 if (target_sp->GetDebugger().GetAsyncExecution () == false) 1031 process_sp->WaitForProcessToStop (NULL); 1032 } 1033 } 1034 else 1035 { 1036 error.SetErrorString ("unable to create lldb_private::Process"); 1037 } 1038 } 1039 else 1040 { 1041 error.SetErrorString ("SBTarget is invalid"); 1042 } 1043 1044 if (log) 1045 { 1046 log->Printf ("SBTarget(%p)::AttachToProcessWithID (...) => SBProcess(%p)", 1047 target_sp.get(), process_sp.get()); 1048 } 1049 return sb_process; 1050 } 1051 1052 lldb::SBProcess 1053 SBTarget::AttachToProcessWithName 1054 ( 1055 SBListener &listener, 1056 const char *name, // basename of process to attach to 1057 bool wait_for, // if true wait for a new instance of "name" to be launched 1058 SBError& error // An error explaining what went wrong if attach fails 1059 ) 1060 { 1061 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1062 1063 SBProcess sb_process; 1064 ProcessSP process_sp; 1065 TargetSP target_sp(GetSP()); 1066 1067 if (log) 1068 { 1069 log->Printf ("SBTarget(%p)::AttachToProcessWithName (listener, name=%s, wait_for=%s, error)...", target_sp.get(), name, wait_for ? "true" : "false"); 1070 } 1071 1072 if (name && target_sp) 1073 { 1074 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1075 1076 StateType state = eStateInvalid; 1077 process_sp = target_sp->GetProcessSP(); 1078 if (process_sp) 1079 { 1080 state = process_sp->GetState(); 1081 1082 if (process_sp->IsAlive() && state != eStateConnected) 1083 { 1084 if (state == eStateAttaching) 1085 error.SetErrorString ("process attach is in progress"); 1086 else 1087 error.SetErrorString ("a process is already being debugged"); 1088 return sb_process; 1089 } 1090 } 1091 1092 if (state == eStateConnected) 1093 { 1094 // If we are already connected, then we have already specified the 1095 // listener, so if a valid listener is supplied, we need to error out 1096 // to let the client know. 1097 if (listener.IsValid()) 1098 { 1099 error.SetErrorString ("process is connected and already has a listener, pass empty listener"); 1100 return sb_process; 1101 } 1102 } 1103 else 1104 { 1105 if (listener.IsValid()) 1106 process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL); 1107 else 1108 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL); 1109 } 1110 1111 if (process_sp) 1112 { 1113 sb_process.SetSP (process_sp); 1114 ProcessAttachInfo attach_info; 1115 attach_info.GetExecutableFile().SetFile(name, false); 1116 attach_info.SetWaitForLaunch(wait_for); 1117 error.SetError (process_sp->Attach (attach_info)); 1118 if (error.Success()) 1119 { 1120 // If we are doing synchronous mode, then wait for the 1121 // process to stop! 1122 if (target_sp->GetDebugger().GetAsyncExecution () == false) 1123 process_sp->WaitForProcessToStop (NULL); 1124 } 1125 } 1126 else 1127 { 1128 error.SetErrorString ("unable to create lldb_private::Process"); 1129 } 1130 } 1131 else 1132 { 1133 error.SetErrorString ("SBTarget is invalid"); 1134 } 1135 1136 if (log) 1137 { 1138 log->Printf ("SBTarget(%p)::AttachToPorcessWithName (...) => SBProcess(%p)", 1139 target_sp.get(), process_sp.get()); 1140 } 1141 return sb_process; 1142 } 1143 1144 lldb::SBProcess 1145 SBTarget::ConnectRemote 1146 ( 1147 SBListener &listener, 1148 const char *url, 1149 const char *plugin_name, 1150 SBError& error 1151 ) 1152 { 1153 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1154 1155 SBProcess sb_process; 1156 ProcessSP process_sp; 1157 TargetSP target_sp(GetSP()); 1158 1159 if (log) 1160 { 1161 log->Printf ("SBTarget(%p)::ConnectRemote (listener, url=%s, plugin_name=%s, error)...", target_sp.get(), url, plugin_name); 1162 } 1163 1164 if (target_sp) 1165 { 1166 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1167 if (listener.IsValid()) 1168 process_sp = target_sp->CreateProcess (listener.ref(), plugin_name, NULL); 1169 else 1170 process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), plugin_name, NULL); 1171 1172 1173 if (process_sp) 1174 { 1175 sb_process.SetSP (process_sp); 1176 error.SetError (process_sp->ConnectRemote (NULL, url)); 1177 } 1178 else 1179 { 1180 error.SetErrorString ("unable to create lldb_private::Process"); 1181 } 1182 } 1183 else 1184 { 1185 error.SetErrorString ("SBTarget is invalid"); 1186 } 1187 1188 if (log) 1189 { 1190 log->Printf ("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)", 1191 target_sp.get(), process_sp.get()); 1192 } 1193 return sb_process; 1194 } 1195 1196 SBFileSpec 1197 SBTarget::GetExecutable () 1198 { 1199 1200 SBFileSpec exe_file_spec; 1201 TargetSP target_sp(GetSP()); 1202 if (target_sp) 1203 { 1204 Module *exe_module = target_sp->GetExecutableModulePointer(); 1205 if (exe_module) 1206 exe_file_spec.SetFileSpec (exe_module->GetFileSpec()); 1207 } 1208 1209 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1210 if (log) 1211 { 1212 log->Printf ("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)", 1213 target_sp.get(), exe_file_spec.get()); 1214 } 1215 1216 return exe_file_spec; 1217 } 1218 1219 bool 1220 SBTarget::operator == (const SBTarget &rhs) const 1221 { 1222 return m_opaque_sp.get() == rhs.m_opaque_sp.get(); 1223 } 1224 1225 bool 1226 SBTarget::operator != (const SBTarget &rhs) const 1227 { 1228 return m_opaque_sp.get() != rhs.m_opaque_sp.get(); 1229 } 1230 1231 lldb::TargetSP 1232 SBTarget::GetSP () const 1233 { 1234 return m_opaque_sp; 1235 } 1236 1237 void 1238 SBTarget::SetSP (const lldb::TargetSP& target_sp) 1239 { 1240 m_opaque_sp = target_sp; 1241 } 1242 1243 lldb::SBAddress 1244 SBTarget::ResolveLoadAddress (lldb::addr_t vm_addr) 1245 { 1246 lldb::SBAddress sb_addr; 1247 Address &addr = sb_addr.ref(); 1248 TargetSP target_sp(GetSP()); 1249 if (target_sp) 1250 { 1251 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1252 if (target_sp->GetSectionLoadList().ResolveLoadAddress (vm_addr, addr)) 1253 return sb_addr; 1254 } 1255 1256 // We have a load address that isn't in a section, just return an address 1257 // with the offset filled in (the address) and the section set to NULL 1258 addr.SetRawAddress(vm_addr); 1259 return sb_addr; 1260 } 1261 1262 SBSymbolContext 1263 SBTarget::ResolveSymbolContextForAddress (const SBAddress& addr, uint32_t resolve_scope) 1264 { 1265 SBSymbolContext sc; 1266 if (addr.IsValid()) 1267 { 1268 TargetSP target_sp(GetSP()); 1269 if (target_sp) 1270 target_sp->GetImages().ResolveSymbolContextForAddress (addr.ref(), resolve_scope, sc.ref()); 1271 } 1272 return sc; 1273 } 1274 1275 1276 SBBreakpoint 1277 SBTarget::BreakpointCreateByLocation (const char *file, uint32_t line) 1278 { 1279 return SBBreakpoint(BreakpointCreateByLocation (SBFileSpec (file, false), line)); 1280 } 1281 1282 SBBreakpoint 1283 SBTarget::BreakpointCreateByLocation (const SBFileSpec &sb_file_spec, uint32_t line) 1284 { 1285 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1286 1287 SBBreakpoint sb_bp; 1288 TargetSP target_sp(GetSP()); 1289 if (target_sp && line != 0) 1290 { 1291 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1292 1293 const LazyBool check_inlines = eLazyBoolCalculate; 1294 const LazyBool skip_prologue = eLazyBoolCalculate; 1295 const bool internal = false; 1296 *sb_bp = target_sp->CreateBreakpoint (NULL, *sb_file_spec, line, check_inlines, skip_prologue, internal); 1297 } 1298 1299 if (log) 1300 { 1301 SBStream sstr; 1302 sb_bp.GetDescription (sstr); 1303 char path[PATH_MAX]; 1304 sb_file_spec->GetPath (path, sizeof(path)); 1305 log->Printf ("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => SBBreakpoint(%p): %s", 1306 target_sp.get(), 1307 path, 1308 line, 1309 sb_bp.get(), 1310 sstr.GetData()); 1311 } 1312 1313 return sb_bp; 1314 } 1315 1316 SBBreakpoint 1317 SBTarget::BreakpointCreateByName (const char *symbol_name, const char *module_name) 1318 { 1319 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1320 1321 SBBreakpoint sb_bp; 1322 TargetSP target_sp(GetSP()); 1323 if (target_sp.get()) 1324 { 1325 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1326 1327 const bool internal = false; 1328 const LazyBool skip_prologue = eLazyBoolCalculate; 1329 if (module_name && module_name[0]) 1330 { 1331 FileSpecList module_spec_list; 1332 module_spec_list.Append (FileSpec (module_name, false)); 1333 *sb_bp = target_sp->CreateBreakpoint (&module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, skip_prologue, internal); 1334 } 1335 else 1336 { 1337 *sb_bp = target_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, skip_prologue, internal); 1338 } 1339 } 1340 1341 if (log) 1342 { 1343 log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", module=\"%s\") => SBBreakpoint(%p)", 1344 target_sp.get(), symbol_name, module_name, sb_bp.get()); 1345 } 1346 1347 return sb_bp; 1348 } 1349 1350 lldb::SBBreakpoint 1351 SBTarget::BreakpointCreateByName (const char *symbol_name, 1352 const SBFileSpecList &module_list, 1353 const SBFileSpecList &comp_unit_list) 1354 { 1355 uint32_t name_type_mask = eFunctionNameTypeAuto; 1356 return BreakpointCreateByName (symbol_name, name_type_mask, module_list, comp_unit_list); 1357 } 1358 1359 lldb::SBBreakpoint 1360 SBTarget::BreakpointCreateByName (const char *symbol_name, 1361 uint32_t name_type_mask, 1362 const SBFileSpecList &module_list, 1363 const SBFileSpecList &comp_unit_list) 1364 { 1365 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1366 1367 SBBreakpoint sb_bp; 1368 TargetSP target_sp(GetSP()); 1369 if (target_sp && symbol_name && symbol_name[0]) 1370 { 1371 const bool internal = false; 1372 const LazyBool skip_prologue = eLazyBoolCalculate; 1373 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1374 *sb_bp = target_sp->CreateBreakpoint (module_list.get(), 1375 comp_unit_list.get(), 1376 symbol_name, 1377 name_type_mask, 1378 skip_prologue, 1379 internal); 1380 } 1381 1382 if (log) 1383 { 1384 log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)", 1385 target_sp.get(), symbol_name, name_type_mask, sb_bp.get()); 1386 } 1387 1388 return sb_bp; 1389 } 1390 1391 lldb::SBBreakpoint 1392 SBTarget::BreakpointCreateByNames (const char *symbol_names[], 1393 uint32_t num_names, 1394 uint32_t name_type_mask, 1395 const SBFileSpecList &module_list, 1396 const SBFileSpecList &comp_unit_list) 1397 { 1398 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1399 1400 SBBreakpoint sb_bp; 1401 TargetSP target_sp(GetSP()); 1402 if (target_sp && num_names > 0) 1403 { 1404 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1405 const bool internal = false; 1406 const LazyBool skip_prologue = eLazyBoolCalculate; 1407 *sb_bp = target_sp->CreateBreakpoint (module_list.get(), 1408 comp_unit_list.get(), 1409 symbol_names, 1410 num_names, 1411 name_type_mask, 1412 skip_prologue, 1413 internal); 1414 } 1415 1416 if (log) 1417 { 1418 log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbols={", target_sp.get()); 1419 for (uint32_t i = 0 ; i < num_names; i++) 1420 { 1421 char sep; 1422 if (i < num_names - 1) 1423 sep = ','; 1424 else 1425 sep = '}'; 1426 if (symbol_names[i] != NULL) 1427 log->Printf ("\"%s\"%c ", symbol_names[i], sep); 1428 else 1429 log->Printf ("\"<NULL>\"%c ", sep); 1430 1431 } 1432 log->Printf ("name_type: %d) => SBBreakpoint(%p)", name_type_mask, sb_bp.get()); 1433 } 1434 1435 return sb_bp; 1436 } 1437 1438 SBBreakpoint 1439 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name) 1440 { 1441 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1442 1443 SBBreakpoint sb_bp; 1444 TargetSP target_sp(GetSP()); 1445 if (target_sp && symbol_name_regex && symbol_name_regex[0]) 1446 { 1447 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1448 RegularExpression regexp(symbol_name_regex); 1449 const bool internal = false; 1450 const LazyBool skip_prologue = eLazyBoolCalculate; 1451 1452 if (module_name && module_name[0]) 1453 { 1454 FileSpecList module_spec_list; 1455 module_spec_list.Append (FileSpec (module_name, false)); 1456 1457 *sb_bp = target_sp->CreateFuncRegexBreakpoint (&module_spec_list, NULL, regexp, skip_prologue, internal); 1458 } 1459 else 1460 { 1461 *sb_bp = target_sp->CreateFuncRegexBreakpoint (NULL, NULL, regexp, skip_prologue, internal); 1462 } 1463 } 1464 1465 if (log) 1466 { 1467 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)", 1468 target_sp.get(), symbol_name_regex, module_name, sb_bp.get()); 1469 } 1470 1471 return sb_bp; 1472 } 1473 1474 lldb::SBBreakpoint 1475 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, 1476 const SBFileSpecList &module_list, 1477 const SBFileSpecList &comp_unit_list) 1478 { 1479 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1480 1481 SBBreakpoint sb_bp; 1482 TargetSP target_sp(GetSP()); 1483 if (target_sp && symbol_name_regex && symbol_name_regex[0]) 1484 { 1485 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1486 RegularExpression regexp(symbol_name_regex); 1487 const bool internal = false; 1488 const LazyBool skip_prologue = eLazyBoolCalculate; 1489 1490 *sb_bp = target_sp->CreateFuncRegexBreakpoint (module_list.get(), comp_unit_list.get(), regexp, skip_prologue, internal); 1491 } 1492 1493 if (log) 1494 { 1495 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") => SBBreakpoint(%p)", 1496 target_sp.get(), symbol_name_regex, sb_bp.get()); 1497 } 1498 1499 return sb_bp; 1500 } 1501 1502 SBBreakpoint 1503 SBTarget::BreakpointCreateByAddress (addr_t address) 1504 { 1505 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1506 1507 SBBreakpoint sb_bp; 1508 TargetSP target_sp(GetSP()); 1509 if (target_sp) 1510 { 1511 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1512 *sb_bp = target_sp->CreateBreakpoint (address, false); 1513 } 1514 1515 if (log) 1516 { 1517 log->Printf ("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64 ") => SBBreakpoint(%p)", target_sp.get(), (uint64_t) address, sb_bp.get()); 1518 } 1519 1520 return sb_bp; 1521 } 1522 1523 lldb::SBBreakpoint 1524 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name) 1525 { 1526 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1527 1528 SBBreakpoint sb_bp; 1529 TargetSP target_sp(GetSP()); 1530 if (target_sp && source_regex && source_regex[0]) 1531 { 1532 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1533 RegularExpression regexp(source_regex); 1534 FileSpecList source_file_spec_list; 1535 source_file_spec_list.Append (source_file.ref()); 1536 1537 if (module_name && module_name[0]) 1538 { 1539 FileSpecList module_spec_list; 1540 module_spec_list.Append (FileSpec (module_name, false)); 1541 1542 *sb_bp = target_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false); 1543 } 1544 else 1545 { 1546 *sb_bp = target_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false); 1547 } 1548 } 1549 1550 if (log) 1551 { 1552 char path[PATH_MAX]; 1553 source_file->GetPath (path, sizeof(path)); 1554 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\", file=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)", 1555 target_sp.get(), source_regex, path, module_name, sb_bp.get()); 1556 } 1557 1558 return sb_bp; 1559 } 1560 1561 lldb::SBBreakpoint 1562 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, 1563 const SBFileSpecList &module_list, 1564 const lldb::SBFileSpecList &source_file_list) 1565 { 1566 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1567 1568 SBBreakpoint sb_bp; 1569 TargetSP target_sp(GetSP()); 1570 if (target_sp && source_regex && source_regex[0]) 1571 { 1572 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1573 RegularExpression regexp(source_regex); 1574 *sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false); 1575 } 1576 1577 if (log) 1578 { 1579 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)", 1580 target_sp.get(), source_regex, sb_bp.get()); 1581 } 1582 1583 return sb_bp; 1584 } 1585 1586 lldb::SBBreakpoint 1587 SBTarget::BreakpointCreateForException (lldb::LanguageType language, 1588 bool catch_bp, 1589 bool throw_bp) 1590 { 1591 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1592 1593 SBBreakpoint sb_bp; 1594 TargetSP target_sp(GetSP()); 1595 if (target_sp) 1596 { 1597 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1598 *sb_bp = target_sp->CreateExceptionBreakpoint (language, catch_bp, throw_bp); 1599 } 1600 1601 if (log) 1602 { 1603 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: %s throw: %s) => SBBreakpoint(%p)", 1604 target_sp.get(), 1605 LanguageRuntime::GetNameForLanguageType(language), 1606 catch_bp ? "on" : "off", 1607 throw_bp ? "on" : "off", 1608 sb_bp.get()); 1609 } 1610 1611 return sb_bp; 1612 } 1613 1614 uint32_t 1615 SBTarget::GetNumBreakpoints () const 1616 { 1617 TargetSP target_sp(GetSP()); 1618 if (target_sp) 1619 { 1620 // The breakpoint list is thread safe, no need to lock 1621 return target_sp->GetBreakpointList().GetSize(); 1622 } 1623 return 0; 1624 } 1625 1626 SBBreakpoint 1627 SBTarget::GetBreakpointAtIndex (uint32_t idx) const 1628 { 1629 SBBreakpoint sb_breakpoint; 1630 TargetSP target_sp(GetSP()); 1631 if (target_sp) 1632 { 1633 // The breakpoint list is thread safe, no need to lock 1634 *sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); 1635 } 1636 return sb_breakpoint; 1637 } 1638 1639 bool 1640 SBTarget::BreakpointDelete (break_id_t bp_id) 1641 { 1642 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1643 1644 bool result = false; 1645 TargetSP target_sp(GetSP()); 1646 if (target_sp) 1647 { 1648 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1649 result = target_sp->RemoveBreakpointByID (bp_id); 1650 } 1651 1652 if (log) 1653 { 1654 log->Printf ("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", target_sp.get(), (uint32_t) bp_id, result); 1655 } 1656 1657 return result; 1658 } 1659 1660 SBBreakpoint 1661 SBTarget::FindBreakpointByID (break_id_t bp_id) 1662 { 1663 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1664 1665 SBBreakpoint sb_breakpoint; 1666 TargetSP target_sp(GetSP()); 1667 if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) 1668 { 1669 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1670 *sb_breakpoint = target_sp->GetBreakpointByID (bp_id); 1671 } 1672 1673 if (log) 1674 { 1675 log->Printf ("SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)", 1676 target_sp.get(), (uint32_t) bp_id, sb_breakpoint.get()); 1677 } 1678 1679 return sb_breakpoint; 1680 } 1681 1682 bool 1683 SBTarget::EnableAllBreakpoints () 1684 { 1685 TargetSP target_sp(GetSP()); 1686 if (target_sp) 1687 { 1688 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1689 target_sp->EnableAllBreakpoints (); 1690 return true; 1691 } 1692 return false; 1693 } 1694 1695 bool 1696 SBTarget::DisableAllBreakpoints () 1697 { 1698 TargetSP target_sp(GetSP()); 1699 if (target_sp) 1700 { 1701 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1702 target_sp->DisableAllBreakpoints (); 1703 return true; 1704 } 1705 return false; 1706 } 1707 1708 bool 1709 SBTarget::DeleteAllBreakpoints () 1710 { 1711 TargetSP target_sp(GetSP()); 1712 if (target_sp) 1713 { 1714 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1715 target_sp->RemoveAllBreakpoints (); 1716 return true; 1717 } 1718 return false; 1719 } 1720 1721 uint32_t 1722 SBTarget::GetNumWatchpoints () const 1723 { 1724 TargetSP target_sp(GetSP()); 1725 if (target_sp) 1726 { 1727 // The watchpoint list is thread safe, no need to lock 1728 return target_sp->GetWatchpointList().GetSize(); 1729 } 1730 return 0; 1731 } 1732 1733 SBWatchpoint 1734 SBTarget::GetWatchpointAtIndex (uint32_t idx) const 1735 { 1736 SBWatchpoint sb_watchpoint; 1737 TargetSP target_sp(GetSP()); 1738 if (target_sp) 1739 { 1740 // The watchpoint list is thread safe, no need to lock 1741 sb_watchpoint.SetSP (target_sp->GetWatchpointList().GetByIndex(idx)); 1742 } 1743 return sb_watchpoint; 1744 } 1745 1746 bool 1747 SBTarget::DeleteWatchpoint (watch_id_t wp_id) 1748 { 1749 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1750 1751 bool result = false; 1752 TargetSP target_sp(GetSP()); 1753 if (target_sp) 1754 { 1755 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1756 Mutex::Locker locker; 1757 target_sp->GetWatchpointList().GetListMutex(locker); 1758 result = target_sp->RemoveWatchpointByID (wp_id); 1759 } 1760 1761 if (log) 1762 { 1763 log->Printf ("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", target_sp.get(), (uint32_t) wp_id, result); 1764 } 1765 1766 return result; 1767 } 1768 1769 SBWatchpoint 1770 SBTarget::FindWatchpointByID (lldb::watch_id_t wp_id) 1771 { 1772 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1773 1774 SBWatchpoint sb_watchpoint; 1775 lldb::WatchpointSP watchpoint_sp; 1776 TargetSP target_sp(GetSP()); 1777 if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) 1778 { 1779 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1780 Mutex::Locker locker; 1781 target_sp->GetWatchpointList().GetListMutex(locker); 1782 watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id); 1783 sb_watchpoint.SetSP (watchpoint_sp); 1784 } 1785 1786 if (log) 1787 { 1788 log->Printf ("SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)", 1789 target_sp.get(), (uint32_t) wp_id, watchpoint_sp.get()); 1790 } 1791 1792 return sb_watchpoint; 1793 } 1794 1795 lldb::SBWatchpoint 1796 SBTarget::WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write, SBError &error) 1797 { 1798 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1799 1800 SBWatchpoint sb_watchpoint; 1801 lldb::WatchpointSP watchpoint_sp; 1802 TargetSP target_sp(GetSP()); 1803 if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && size > 0) 1804 { 1805 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1806 uint32_t watch_type = 0; 1807 if (read) 1808 watch_type |= LLDB_WATCH_TYPE_READ; 1809 if (write) 1810 watch_type |= LLDB_WATCH_TYPE_WRITE; 1811 if (watch_type == 0) 1812 { 1813 error.SetErrorString("Can't create a watchpoint that is neither read nor write."); 1814 return sb_watchpoint; 1815 } 1816 1817 // Target::CreateWatchpoint() is thread safe. 1818 Error cw_error; 1819 // This API doesn't take in a type, so we can't figure out what it is. 1820 ClangASTType *type = NULL; 1821 watchpoint_sp = target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error); 1822 error.SetError(cw_error); 1823 sb_watchpoint.SetSP (watchpoint_sp); 1824 } 1825 1826 if (log) 1827 { 1828 log->Printf ("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64 ", 0x%u) => SBWatchpoint(%p)", 1829 target_sp.get(), addr, (uint32_t) size, watchpoint_sp.get()); 1830 } 1831 1832 return sb_watchpoint; 1833 } 1834 1835 bool 1836 SBTarget::EnableAllWatchpoints () 1837 { 1838 TargetSP target_sp(GetSP()); 1839 if (target_sp) 1840 { 1841 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1842 Mutex::Locker locker; 1843 target_sp->GetWatchpointList().GetListMutex(locker); 1844 target_sp->EnableAllWatchpoints (); 1845 return true; 1846 } 1847 return false; 1848 } 1849 1850 bool 1851 SBTarget::DisableAllWatchpoints () 1852 { 1853 TargetSP target_sp(GetSP()); 1854 if (target_sp) 1855 { 1856 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1857 Mutex::Locker locker; 1858 target_sp->GetWatchpointList().GetListMutex(locker); 1859 target_sp->DisableAllWatchpoints (); 1860 return true; 1861 } 1862 return false; 1863 } 1864 1865 bool 1866 SBTarget::DeleteAllWatchpoints () 1867 { 1868 TargetSP target_sp(GetSP()); 1869 if (target_sp) 1870 { 1871 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1872 Mutex::Locker locker; 1873 target_sp->GetWatchpointList().GetListMutex(locker); 1874 target_sp->RemoveAllWatchpoints (); 1875 return true; 1876 } 1877 return false; 1878 } 1879 1880 1881 lldb::SBModule 1882 SBTarget::AddModule (const char *path, 1883 const char *triple, 1884 const char *uuid_cstr) 1885 { 1886 return AddModule (path, triple, uuid_cstr, NULL); 1887 } 1888 1889 lldb::SBModule 1890 SBTarget::AddModule (const char *path, 1891 const char *triple, 1892 const char *uuid_cstr, 1893 const char *symfile) 1894 { 1895 lldb::SBModule sb_module; 1896 TargetSP target_sp(GetSP()); 1897 if (target_sp) 1898 { 1899 ModuleSpec module_spec; 1900 if (path) 1901 module_spec.GetFileSpec().SetFile(path, false); 1902 1903 if (uuid_cstr) 1904 module_spec.GetUUID().SetFromCString(uuid_cstr); 1905 1906 if (triple) 1907 module_spec.GetArchitecture().SetTriple (triple, target_sp->GetPlatform ().get()); 1908 1909 if (symfile) 1910 module_spec.GetSymbolFileSpec ().SetFile(symfile, false); 1911 1912 sb_module.SetSP(target_sp->GetSharedModule (module_spec)); 1913 } 1914 return sb_module; 1915 } 1916 1917 lldb::SBModule 1918 SBTarget::AddModule (const SBModuleSpec &module_spec) 1919 { 1920 lldb::SBModule sb_module; 1921 TargetSP target_sp(GetSP()); 1922 if (target_sp) 1923 sb_module.SetSP(target_sp->GetSharedModule (*module_spec.m_opaque_ap)); 1924 return sb_module; 1925 } 1926 1927 bool 1928 SBTarget::AddModule (lldb::SBModule &module) 1929 { 1930 TargetSP target_sp(GetSP()); 1931 if (target_sp) 1932 { 1933 target_sp->GetImages().AppendIfNeeded (module.GetSP()); 1934 return true; 1935 } 1936 return false; 1937 } 1938 1939 uint32_t 1940 SBTarget::GetNumModules () const 1941 { 1942 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1943 1944 uint32_t num = 0; 1945 TargetSP target_sp(GetSP()); 1946 if (target_sp) 1947 { 1948 // The module list is thread safe, no need to lock 1949 num = target_sp->GetImages().GetSize(); 1950 } 1951 1952 if (log) 1953 log->Printf ("SBTarget(%p)::GetNumModules () => %d", target_sp.get(), num); 1954 1955 return num; 1956 } 1957 1958 void 1959 SBTarget::Clear () 1960 { 1961 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1962 1963 if (log) 1964 log->Printf ("SBTarget(%p)::Clear ()", m_opaque_sp.get()); 1965 1966 m_opaque_sp.reset(); 1967 } 1968 1969 1970 SBModule 1971 SBTarget::FindModule (const SBFileSpec &sb_file_spec) 1972 { 1973 SBModule sb_module; 1974 TargetSP target_sp(GetSP()); 1975 if (target_sp && sb_file_spec.IsValid()) 1976 { 1977 ModuleSpec module_spec(*sb_file_spec); 1978 // The module list is thread safe, no need to lock 1979 sb_module.SetSP (target_sp->GetImages().FindFirstModule (module_spec)); 1980 } 1981 return sb_module; 1982 } 1983 1984 lldb::ByteOrder 1985 SBTarget::GetByteOrder () 1986 { 1987 TargetSP target_sp(GetSP()); 1988 if (target_sp) 1989 return target_sp->GetArchitecture().GetByteOrder(); 1990 return eByteOrderInvalid; 1991 } 1992 1993 const char * 1994 SBTarget::GetTriple () 1995 { 1996 TargetSP target_sp(GetSP()); 1997 if (target_sp) 1998 { 1999 std::string triple (target_sp->GetArchitecture().GetTriple().str()); 2000 // Unique the string so we don't run into ownership issues since 2001 // the const strings put the string into the string pool once and 2002 // the strings never comes out 2003 ConstString const_triple (triple.c_str()); 2004 return const_triple.GetCString(); 2005 } 2006 return NULL; 2007 } 2008 2009 uint32_t 2010 SBTarget::GetAddressByteSize() 2011 { 2012 TargetSP target_sp(GetSP()); 2013 if (target_sp) 2014 return target_sp->GetArchitecture().GetAddressByteSize(); 2015 return sizeof(void*); 2016 } 2017 2018 2019 SBModule 2020 SBTarget::GetModuleAtIndex (uint32_t idx) 2021 { 2022 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 2023 2024 SBModule sb_module; 2025 ModuleSP module_sp; 2026 TargetSP target_sp(GetSP()); 2027 if (target_sp) 2028 { 2029 // The module list is thread safe, no need to lock 2030 module_sp = target_sp->GetImages().GetModuleAtIndex(idx); 2031 sb_module.SetSP (module_sp); 2032 } 2033 2034 if (log) 2035 { 2036 log->Printf ("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)", 2037 target_sp.get(), idx, module_sp.get()); 2038 } 2039 2040 return sb_module; 2041 } 2042 2043 bool 2044 SBTarget::RemoveModule (lldb::SBModule module) 2045 { 2046 TargetSP target_sp(GetSP()); 2047 if (target_sp) 2048 return target_sp->GetImages().Remove(module.GetSP()); 2049 return false; 2050 } 2051 2052 2053 SBBroadcaster 2054 SBTarget::GetBroadcaster () const 2055 { 2056 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 2057 2058 TargetSP target_sp(GetSP()); 2059 SBBroadcaster broadcaster(target_sp.get(), false); 2060 2061 if (log) 2062 log->Printf ("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)", 2063 target_sp.get(), broadcaster.get()); 2064 2065 return broadcaster; 2066 } 2067 2068 bool 2069 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) 2070 { 2071 Stream &strm = description.ref(); 2072 2073 TargetSP target_sp(GetSP()); 2074 if (target_sp) 2075 { 2076 target_sp->Dump (&strm, description_level); 2077 } 2078 else 2079 strm.PutCString ("No value"); 2080 2081 return true; 2082 } 2083 2084 lldb::SBSymbolContextList 2085 SBTarget::FindFunctions (const char *name, uint32_t name_type_mask) 2086 { 2087 lldb::SBSymbolContextList sb_sc_list; 2088 if (name && name[0]) 2089 { 2090 TargetSP target_sp(GetSP()); 2091 if (target_sp) 2092 { 2093 const bool symbols_ok = true; 2094 const bool inlines_ok = true; 2095 const bool append = true; 2096 target_sp->GetImages().FindFunctions (ConstString(name), 2097 name_type_mask, 2098 symbols_ok, 2099 inlines_ok, 2100 append, 2101 *sb_sc_list); 2102 } 2103 } 2104 return sb_sc_list; 2105 } 2106 2107 lldb::SBType 2108 SBTarget::FindFirstType (const char* typename_cstr) 2109 { 2110 TargetSP target_sp(GetSP()); 2111 if (typename_cstr && typename_cstr[0] && target_sp) 2112 { 2113 ConstString const_typename(typename_cstr); 2114 SymbolContext sc; 2115 const bool exact_match = false; 2116 2117 const ModuleList &module_list = target_sp->GetImages(); 2118 size_t count = module_list.GetSize(); 2119 for (size_t idx = 0; idx < count; idx++) 2120 { 2121 ModuleSP module_sp (module_list.GetModuleAtIndex(idx)); 2122 if (module_sp) 2123 { 2124 TypeSP type_sp (module_sp->FindFirstType(sc, const_typename, exact_match)); 2125 if (type_sp) 2126 return SBType(type_sp); 2127 } 2128 } 2129 2130 // Didn't find the type in the symbols; try the Objective-C runtime 2131 // if one is installed 2132 2133 ProcessSP process_sp(target_sp->GetProcessSP()); 2134 2135 if (process_sp) 2136 { 2137 ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime(); 2138 2139 if (objc_language_runtime) 2140 { 2141 TypeVendor *objc_type_vendor = objc_language_runtime->GetTypeVendor(); 2142 2143 if (objc_type_vendor) 2144 { 2145 std::vector <ClangASTType> types; 2146 2147 if (objc_type_vendor->FindTypes(const_typename, true, 1, types) > 0) 2148 return SBType(types[0]); 2149 } 2150 } 2151 } 2152 2153 // No matches, search for basic typename matches 2154 ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); 2155 if (clang_ast) 2156 return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename)); 2157 } 2158 return SBType(); 2159 } 2160 2161 SBType 2162 SBTarget::GetBasicType(lldb::BasicType type) 2163 { 2164 TargetSP target_sp(GetSP()); 2165 if (target_sp) 2166 { 2167 ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); 2168 if (clang_ast) 2169 return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), type)); 2170 } 2171 return SBType(); 2172 } 2173 2174 2175 lldb::SBTypeList 2176 SBTarget::FindTypes (const char* typename_cstr) 2177 { 2178 SBTypeList sb_type_list; 2179 TargetSP target_sp(GetSP()); 2180 if (typename_cstr && typename_cstr[0] && target_sp) 2181 { 2182 ModuleList& images = target_sp->GetImages(); 2183 ConstString const_typename(typename_cstr); 2184 bool exact_match = false; 2185 SymbolContext sc; 2186 TypeList type_list; 2187 2188 uint32_t num_matches = images.FindTypes (sc, 2189 const_typename, 2190 exact_match, 2191 UINT32_MAX, 2192 type_list); 2193 2194 if (num_matches > 0) 2195 { 2196 for (size_t idx = 0; idx < num_matches; idx++) 2197 { 2198 TypeSP type_sp (type_list.GetTypeAtIndex(idx)); 2199 if (type_sp) 2200 sb_type_list.Append(SBType(type_sp)); 2201 } 2202 } 2203 2204 // Try the Objective-C runtime if one is installed 2205 2206 ProcessSP process_sp(target_sp->GetProcessSP()); 2207 2208 if (process_sp) 2209 { 2210 ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime(); 2211 2212 if (objc_language_runtime) 2213 { 2214 TypeVendor *objc_type_vendor = objc_language_runtime->GetTypeVendor(); 2215 2216 if (objc_type_vendor) 2217 { 2218 std::vector <ClangASTType> types; 2219 2220 if (objc_type_vendor->FindTypes(const_typename, true, UINT32_MAX, types)) 2221 { 2222 for (ClangASTType &type : types) 2223 { 2224 sb_type_list.Append(SBType(type)); 2225 } 2226 } 2227 } 2228 } 2229 } 2230 2231 if (sb_type_list.GetSize() == 0) 2232 { 2233 // No matches, search for basic typename matches 2234 ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); 2235 if (clang_ast) 2236 sb_type_list.Append (SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename))); 2237 } 2238 } 2239 return sb_type_list; 2240 } 2241 2242 SBValueList 2243 SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches) 2244 { 2245 SBValueList sb_value_list; 2246 2247 TargetSP target_sp(GetSP()); 2248 if (name && target_sp) 2249 { 2250 VariableList variable_list; 2251 const bool append = true; 2252 const uint32_t match_count = target_sp->GetImages().FindGlobalVariables (ConstString (name), 2253 append, 2254 max_matches, 2255 variable_list); 2256 2257 if (match_count > 0) 2258 { 2259 ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); 2260 if (exe_scope == NULL) 2261 exe_scope = target_sp.get(); 2262 for (uint32_t i=0; i<match_count; ++i) 2263 { 2264 lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i))); 2265 if (valobj_sp) 2266 sb_value_list.Append(SBValue(valobj_sp)); 2267 } 2268 } 2269 } 2270 2271 return sb_value_list; 2272 } 2273 2274 lldb::SBValue 2275 SBTarget::FindFirstGlobalVariable (const char* name) 2276 { 2277 SBValueList sb_value_list(FindGlobalVariables(name, 1)); 2278 if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) 2279 return sb_value_list.GetValueAtIndex(0); 2280 return SBValue(); 2281 } 2282 2283 SBSourceManager 2284 SBTarget::GetSourceManager() 2285 { 2286 SBSourceManager source_manager (*this); 2287 return source_manager; 2288 } 2289 2290 lldb::SBInstructionList 2291 SBTarget::ReadInstructions (lldb::SBAddress base_addr, uint32_t count) 2292 { 2293 return ReadInstructions (base_addr, count, NULL); 2294 } 2295 2296 lldb::SBInstructionList 2297 SBTarget::ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string) 2298 { 2299 SBInstructionList sb_instructions; 2300 2301 TargetSP target_sp(GetSP()); 2302 if (target_sp) 2303 { 2304 Address *addr_ptr = base_addr.get(); 2305 2306 if (addr_ptr) 2307 { 2308 DataBufferHeap data (target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0); 2309 bool prefer_file_cache = false; 2310 lldb_private::Error error; 2311 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; 2312 const size_t bytes_read = target_sp->ReadMemory(*addr_ptr, 2313 prefer_file_cache, 2314 data.GetBytes(), 2315 data.GetByteSize(), 2316 error, 2317 &load_addr); 2318 const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; 2319 sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(), 2320 NULL, 2321 flavor_string, 2322 *addr_ptr, 2323 data.GetBytes(), 2324 bytes_read, 2325 count, 2326 data_from_file)); 2327 } 2328 } 2329 2330 return sb_instructions; 2331 2332 } 2333 2334 lldb::SBInstructionList 2335 SBTarget::GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size) 2336 { 2337 return GetInstructionsWithFlavor (base_addr, NULL, buf, size); 2338 } 2339 2340 lldb::SBInstructionList 2341 SBTarget::GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size) 2342 { 2343 SBInstructionList sb_instructions; 2344 2345 TargetSP target_sp(GetSP()); 2346 if (target_sp) 2347 { 2348 Address addr; 2349 2350 if (base_addr.get()) 2351 addr = *base_addr.get(); 2352 2353 const bool data_from_file = true; 2354 2355 sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(), 2356 NULL, 2357 flavor_string, 2358 addr, 2359 buf, 2360 size, 2361 UINT32_MAX, 2362 data_from_file)); 2363 } 2364 2365 return sb_instructions; 2366 } 2367 2368 lldb::SBInstructionList 2369 SBTarget::GetInstructions (lldb::addr_t base_addr, const void *buf, size_t size) 2370 { 2371 return GetInstructionsWithFlavor (ResolveLoadAddress(base_addr), NULL, buf, size); 2372 } 2373 2374 lldb::SBInstructionList 2375 SBTarget::GetInstructionsWithFlavor (lldb::addr_t base_addr, const char *flavor_string, const void *buf, size_t size) 2376 { 2377 return GetInstructionsWithFlavor (ResolveLoadAddress(base_addr), flavor_string, buf, size); 2378 } 2379 2380 SBError 2381 SBTarget::SetSectionLoadAddress (lldb::SBSection section, 2382 lldb::addr_t section_base_addr) 2383 { 2384 SBError sb_error; 2385 TargetSP target_sp(GetSP()); 2386 if (target_sp) 2387 { 2388 if (!section.IsValid()) 2389 { 2390 sb_error.SetErrorStringWithFormat ("invalid section"); 2391 } 2392 else 2393 { 2394 SectionSP section_sp (section.GetSP()); 2395 if (section_sp) 2396 { 2397 if (section_sp->IsThreadSpecific()) 2398 { 2399 sb_error.SetErrorString ("thread specific sections are not yet supported"); 2400 } 2401 else 2402 { 2403 if (target_sp->GetSectionLoadList().SetSectionLoadAddress (section_sp, section_base_addr)) 2404 { 2405 // Flush info in the process (stack frames, etc) 2406 ProcessSP process_sp (target_sp->GetProcessSP()); 2407 if (process_sp) 2408 process_sp->Flush(); 2409 } 2410 } 2411 } 2412 } 2413 } 2414 else 2415 { 2416 sb_error.SetErrorString ("invalid target"); 2417 } 2418 return sb_error; 2419 } 2420 2421 SBError 2422 SBTarget::ClearSectionLoadAddress (lldb::SBSection section) 2423 { 2424 SBError sb_error; 2425 2426 TargetSP target_sp(GetSP()); 2427 if (target_sp) 2428 { 2429 if (!section.IsValid()) 2430 { 2431 sb_error.SetErrorStringWithFormat ("invalid section"); 2432 } 2433 else 2434 { 2435 if (target_sp->GetSectionLoadList().SetSectionUnloaded (section.GetSP())) 2436 { 2437 // Flush info in the process (stack frames, etc) 2438 ProcessSP process_sp (target_sp->GetProcessSP()); 2439 if (process_sp) 2440 process_sp->Flush(); 2441 } 2442 } 2443 } 2444 else 2445 { 2446 sb_error.SetErrorStringWithFormat ("invalid target"); 2447 } 2448 return sb_error; 2449 } 2450 2451 SBError 2452 SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset) 2453 { 2454 SBError sb_error; 2455 2456 TargetSP target_sp(GetSP()); 2457 if (target_sp) 2458 { 2459 ModuleSP module_sp (module.GetSP()); 2460 if (module_sp) 2461 { 2462 bool changed = false; 2463 if (module_sp->SetLoadAddress (*target_sp, slide_offset, changed)) 2464 { 2465 // The load was successful, make sure that at least some sections 2466 // changed before we notify that our module was loaded. 2467 if (changed) 2468 { 2469 ModuleList module_list; 2470 module_list.Append(module_sp); 2471 target_sp->ModulesDidLoad (module_list); 2472 // Flush info in the process (stack frames, etc) 2473 ProcessSP process_sp (target_sp->GetProcessSP()); 2474 if (process_sp) 2475 process_sp->Flush(); 2476 } 2477 } 2478 } 2479 else 2480 { 2481 sb_error.SetErrorStringWithFormat ("invalid module"); 2482 } 2483 2484 } 2485 else 2486 { 2487 sb_error.SetErrorStringWithFormat ("invalid target"); 2488 } 2489 return sb_error; 2490 } 2491 2492 SBError 2493 SBTarget::ClearModuleLoadAddress (lldb::SBModule module) 2494 { 2495 SBError sb_error; 2496 2497 char path[PATH_MAX]; 2498 TargetSP target_sp(GetSP()); 2499 if (target_sp) 2500 { 2501 ModuleSP module_sp (module.GetSP()); 2502 if (module_sp) 2503 { 2504 ObjectFile *objfile = module_sp->GetObjectFile(); 2505 if (objfile) 2506 { 2507 SectionList *section_list = objfile->GetSectionList(); 2508 if (section_list) 2509 { 2510 bool changed = false; 2511 const size_t num_sections = section_list->GetSize(); 2512 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) 2513 { 2514 SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx)); 2515 if (section_sp) 2516 changed |= target_sp->GetSectionLoadList().SetSectionUnloaded (section_sp) > 0; 2517 } 2518 if (changed) 2519 { 2520 // Flush info in the process (stack frames, etc) 2521 ProcessSP process_sp (target_sp->GetProcessSP()); 2522 if (process_sp) 2523 process_sp->Flush(); 2524 } 2525 } 2526 else 2527 { 2528 module_sp->GetFileSpec().GetPath (path, sizeof(path)); 2529 sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path); 2530 } 2531 } 2532 else 2533 { 2534 module_sp->GetFileSpec().GetPath (path, sizeof(path)); 2535 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path); 2536 } 2537 } 2538 else 2539 { 2540 sb_error.SetErrorStringWithFormat ("invalid module"); 2541 } 2542 } 2543 else 2544 { 2545 sb_error.SetErrorStringWithFormat ("invalid target"); 2546 } 2547 return sb_error; 2548 } 2549 2550 2551 lldb::SBSymbolContextList 2552 SBTarget::FindSymbols (const char *name, lldb::SymbolType symbol_type) 2553 { 2554 SBSymbolContextList sb_sc_list; 2555 if (name && name[0]) 2556 { 2557 TargetSP target_sp(GetSP()); 2558 if (target_sp) 2559 { 2560 bool append = true; 2561 target_sp->GetImages().FindSymbolsWithNameAndType (ConstString(name), 2562 symbol_type, 2563 *sb_sc_list, 2564 append); 2565 } 2566 } 2567 return sb_sc_list; 2568 2569 } 2570 2571 2572 lldb::SBValue 2573 SBTarget::EvaluateExpression (const char *expr, const SBExpressionOptions &options) 2574 { 2575 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 2576 Log * expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 2577 SBValue expr_result; 2578 ExecutionResults exe_results = eExecutionSetupError; 2579 ValueObjectSP expr_value_sp; 2580 TargetSP target_sp(GetSP()); 2581 StackFrame *frame = NULL; 2582 if (target_sp) 2583 { 2584 if (expr == NULL || expr[0] == '\0') 2585 { 2586 if (log) 2587 log->Printf ("SBTarget::EvaluateExpression called with an empty expression"); 2588 return expr_result; 2589 } 2590 2591 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 2592 ExecutionContext exe_ctx (m_opaque_sp.get()); 2593 2594 if (log) 2595 log->Printf ("SBTarget()::EvaluateExpression (expr=\"%s\")...", expr); 2596 2597 frame = exe_ctx.GetFramePtr(); 2598 Target *target = exe_ctx.GetTargetPtr(); 2599 2600 if (target) 2601 { 2602 #ifdef LLDB_CONFIGURATION_DEBUG 2603 StreamString frame_description; 2604 if (frame) 2605 frame->DumpUsingSettingsFormat (&frame_description); 2606 Host::SetCrashDescriptionWithFormat ("SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s", 2607 expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str()); 2608 #endif 2609 exe_results = target->EvaluateExpression (expr, 2610 frame, 2611 expr_value_sp, 2612 options.ref()); 2613 2614 expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); 2615 #ifdef LLDB_CONFIGURATION_DEBUG 2616 Host::SetCrashDescription (NULL); 2617 #endif 2618 } 2619 else 2620 { 2621 if (log) 2622 log->Printf ("SBTarget::EvaluateExpression () => error: could not reconstruct frame object for this SBTarget."); 2623 } 2624 } 2625 #ifndef LLDB_DISABLE_PYTHON 2626 if (expr_log) 2627 expr_log->Printf("** [SBTarget::EvaluateExpression] Expression result is %s, summary %s **", 2628 expr_result.GetValue(), 2629 expr_result.GetSummary()); 2630 2631 if (log) 2632 log->Printf ("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) (execution result=%d)", 2633 frame, 2634 expr, 2635 expr_value_sp.get(), 2636 exe_results); 2637 #endif 2638 2639 return expr_result; 2640 } 2641 2642 2643 lldb::addr_t 2644 SBTarget::GetStackRedZoneSize() 2645 { 2646 TargetSP target_sp(GetSP()); 2647 if (target_sp) 2648 { 2649 ABISP abi_sp; 2650 ProcessSP process_sp (target_sp->GetProcessSP()); 2651 if (process_sp) 2652 abi_sp = process_sp->GetABI(); 2653 else 2654 abi_sp = ABI::FindPlugin(target_sp->GetArchitecture()); 2655 if (abi_sp) 2656 return abi_sp->GetRedZoneSize(); 2657 } 2658 return 0; 2659 } 2660 2661
