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