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/SBDebugger.h" 15 #include "lldb/API/SBBreakpoint.h" 16 #include "lldb/API/SBFileSpec.h" 17 #include "lldb/API/SBListener.h" 18 #include "lldb/API/SBModule.h" 19 #include "lldb/API/SBSourceManager.h" 20 #include "lldb/API/SBProcess.h" 21 #include "lldb/API/SBStream.h" 22 #include "lldb/API/SBSymbolContextList.h" 23 #include "lldb/Breakpoint/BreakpointID.h" 24 #include "lldb/Breakpoint/BreakpointIDList.h" 25 #include "lldb/Breakpoint/BreakpointList.h" 26 #include "lldb/Breakpoint/BreakpointLocation.h" 27 #include "lldb/Core/Address.h" 28 #include "lldb/Core/AddressResolver.h" 29 #include "lldb/Core/AddressResolverName.h" 30 #include "lldb/Core/ArchSpec.h" 31 #include "lldb/Core/Debugger.h" 32 #include "lldb/Core/Disassembler.h" 33 #include "lldb/Core/Log.h" 34 #include "lldb/Core/RegularExpression.h" 35 #include "lldb/Core/SearchFilter.h" 36 #include "lldb/Core/STLUtils.h" 37 #include "lldb/Core/ValueObjectList.h" 38 #include "lldb/Core/ValueObjectVariable.h" 39 #include "lldb/Host/FileSpec.h" 40 #include "lldb/Host/Host.h" 41 #include "lldb/Interpreter/Args.h" 42 #include "lldb/Symbol/SymbolVendor.h" 43 #include "lldb/Symbol/VariableList.h" 44 #include "lldb/Target/Process.h" 45 #include "lldb/Target/Target.h" 46 #include "lldb/Target/TargetList.h" 47 48 #include "lldb/Interpreter/CommandReturnObject.h" 49 #include "../source/Commands/CommandObjectBreakpoint.h" 50 51 52 using namespace lldb; 53 using namespace lldb_private; 54 55 #define DEFAULT_DISASM_BYTE_SIZE 32 56 57 //---------------------------------------------------------------------- 58 // SBTarget constructor 59 //---------------------------------------------------------------------- 60 SBTarget::SBTarget () : 61 m_opaque_sp () 62 { 63 } 64 65 SBTarget::SBTarget (const SBTarget& rhs) : 66 m_opaque_sp (rhs.m_opaque_sp) 67 { 68 } 69 70 SBTarget::SBTarget(const TargetSP& target_sp) : 71 m_opaque_sp (target_sp) 72 { 73 } 74 75 const SBTarget& 76 SBTarget::operator = (const SBTarget& rhs) 77 { 78 if (this != &rhs) 79 m_opaque_sp = rhs.m_opaque_sp; 80 return *this; 81 } 82 83 //---------------------------------------------------------------------- 84 // Destructor 85 //---------------------------------------------------------------------- 86 SBTarget::~SBTarget() 87 { 88 } 89 90 bool 91 SBTarget::IsValid () const 92 { 93 return m_opaque_sp.get() != NULL; 94 } 95 96 SBProcess 97 SBTarget::GetProcess () 98 { 99 100 SBProcess sb_process; 101 if (m_opaque_sp) 102 { 103 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 104 sb_process.SetProcess (m_opaque_sp->GetProcessSP()); 105 } 106 107 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 108 if (log) 109 { 110 log->Printf ("SBTarget(%p)::GetProcess () => SBProcess(%p)", 111 m_opaque_sp.get(), sb_process.get()); 112 } 113 114 return sb_process; 115 } 116 117 SBDebugger 118 SBTarget::GetDebugger () const 119 { 120 SBDebugger debugger; 121 if (m_opaque_sp) 122 debugger.reset (m_opaque_sp->GetDebugger().GetSP()); 123 return debugger; 124 } 125 126 SBProcess 127 SBTarget::LaunchSimple 128 ( 129 char const **argv, 130 char const **envp, 131 const char *working_directory 132 ) 133 { 134 char *stdin_path = NULL; 135 char *stdout_path = NULL; 136 char *stderr_path = NULL; 137 uint32_t launch_flags = 0; 138 bool stop_at_entry = false; 139 SBError error; 140 SBListener listener = GetDebugger().GetListener(); 141 return Launch (listener, 142 argv, 143 envp, 144 stdin_path, 145 stdout_path, 146 stderr_path, 147 working_directory, 148 launch_flags, 149 stop_at_entry, 150 error); 151 } 152 153 SBProcess 154 SBTarget::Launch 155 ( 156 SBListener &listener, 157 char const **argv, 158 char const **envp, 159 const char *stdin_path, 160 const char *stdout_path, 161 const char *stderr_path, 162 const char *working_directory, 163 uint32_t launch_flags, // See LaunchFlags 164 bool stop_at_entry, 165 lldb::SBError& error 166 ) 167 { 168 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 169 170 if (log) 171 { 172 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))...", 173 m_opaque_sp.get(), 174 argv, 175 envp, 176 stdin_path ? stdin_path : "NULL", 177 stdout_path ? stdout_path : "NULL", 178 stderr_path ? stderr_path : "NULL", 179 working_directory ? working_directory : "NULL", 180 launch_flags, 181 stop_at_entry, 182 error.get()); 183 } 184 SBProcess sb_process; 185 if (m_opaque_sp) 186 { 187 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 188 189 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) 190 launch_flags |= eLaunchFlagDisableASLR; 191 192 StateType state = eStateInvalid; 193 sb_process.SetProcess (m_opaque_sp->GetProcessSP()); 194 if (sb_process.IsValid()) 195 { 196 state = sb_process->GetState(); 197 198 if (sb_process->IsAlive() && state != eStateConnected) 199 { 200 if (state == eStateAttaching) 201 error.SetErrorString ("process attach is in progress"); 202 else 203 error.SetErrorString ("a process is already being debugged"); 204 sb_process.Clear(); 205 return sb_process; 206 } 207 } 208 209 if (state == eStateConnected) 210 { 211 // If we are already connected, then we have already specified the 212 // listener, so if a valid listener is supplied, we need to error out 213 // to let the client know. 214 if (listener.IsValid()) 215 { 216 error.SetErrorString ("process is connected and already has a listener, pass empty listener"); 217 sb_process.Clear(); 218 return sb_process; 219 } 220 } 221 else 222 { 223 if (listener.IsValid()) 224 sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref())); 225 else 226 sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener())); 227 } 228 229 if (sb_process.IsValid()) 230 { 231 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) 232 launch_flags |= eLaunchFlagDisableSTDIO; 233 234 error.SetError (sb_process->Launch (argv, envp, launch_flags, stdin_path, stdout_path, stderr_path, working_directory)); 235 if (error.Success()) 236 { 237 // We we are stopping at the entry point, we can return now! 238 if (stop_at_entry) 239 return sb_process; 240 241 // Make sure we are stopped at the entry 242 StateType state = sb_process->WaitForProcessToStop (NULL); 243 if (state == eStateStopped) 244 { 245 // resume the process to skip the entry point 246 error.SetError (sb_process->Resume()); 247 if (error.Success()) 248 { 249 // If we are doing synchronous mode, then wait for the 250 // process to stop yet again! 251 if (m_opaque_sp->GetDebugger().GetAsyncExecution () == false) 252 sb_process->WaitForProcessToStop (NULL); 253 } 254 } 255 } 256 } 257 else 258 { 259 error.SetErrorString ("unable to create lldb_private::Process"); 260 } 261 } 262 else 263 { 264 error.SetErrorString ("SBTarget is invalid"); 265 } 266 267 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API); 268 if (log) 269 { 270 log->Printf ("SBTarget(%p)::Launch (...) => SBProceess(%p)", 271 m_opaque_sp.get(), sb_process.get()); 272 } 273 274 return sb_process; 275 } 276 277 278 lldb::SBProcess 279 SBTarget::AttachToProcessWithID 280 ( 281 SBListener &listener, 282 lldb::pid_t pid,// The process ID to attach to 283 SBError& error // An error explaining what went wrong if attach fails 284 ) 285 { 286 SBProcess sb_process; 287 if (m_opaque_sp) 288 { 289 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 290 291 StateType state = eStateInvalid; 292 sb_process.SetProcess (m_opaque_sp->GetProcessSP()); 293 if (sb_process.IsValid()) 294 { 295 state = sb_process->GetState(); 296 297 if (sb_process->IsAlive() && state != eStateConnected) 298 { 299 if (state == eStateAttaching) 300 error.SetErrorString ("process attach is in progress"); 301 else 302 error.SetErrorString ("a process is already being debugged"); 303 sb_process.Clear(); 304 return sb_process; 305 } 306 } 307 308 if (state == eStateConnected) 309 { 310 // If we are already connected, then we have already specified the 311 // listener, so if a valid listener is supplied, we need to error out 312 // to let the client know. 313 if (listener.IsValid()) 314 { 315 error.SetErrorString ("process is connected and already has a listener, pass empty listener"); 316 sb_process.Clear(); 317 return sb_process; 318 } 319 } 320 else 321 { 322 if (listener.IsValid()) 323 sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref())); 324 else 325 sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener())); 326 } 327 328 if (sb_process.IsValid()) 329 { 330 error.SetError (sb_process->Attach (pid)); 331 // If we are doing synchronous mode, then wait for the 332 // process to stop! 333 if (m_opaque_sp->GetDebugger().GetAsyncExecution () == false) 334 sb_process->WaitForProcessToStop (NULL); 335 } 336 else 337 { 338 error.SetErrorString ("unable to create lldb_private::Process"); 339 } 340 } 341 else 342 { 343 error.SetErrorString ("SBTarget is invalid"); 344 } 345 return sb_process; 346 347 } 348 349 lldb::SBProcess 350 SBTarget::AttachToProcessWithName 351 ( 352 SBListener &listener, 353 const char *name, // basename of process to attach to 354 bool wait_for, // if true wait for a new instance of "name" to be launched 355 SBError& error // An error explaining what went wrong if attach fails 356 ) 357 { 358 SBProcess sb_process; 359 if (m_opaque_sp) 360 { 361 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 362 363 StateType state = eStateInvalid; 364 sb_process.SetProcess (m_opaque_sp->GetProcessSP()); 365 if (sb_process.IsValid()) 366 { 367 state = sb_process->GetState(); 368 369 if (sb_process->IsAlive() && state != eStateConnected) 370 { 371 if (state == eStateAttaching) 372 error.SetErrorString ("process attach is in progress"); 373 else 374 error.SetErrorString ("a process is already being debugged"); 375 sb_process.Clear(); 376 return sb_process; 377 } 378 } 379 380 if (state == eStateConnected) 381 { 382 // If we are already connected, then we have already specified the 383 // listener, so if a valid listener is supplied, we need to error out 384 // to let the client know. 385 if (listener.IsValid()) 386 { 387 error.SetErrorString ("process is connected and already has a listener, pass empty listener"); 388 sb_process.Clear(); 389 return sb_process; 390 } 391 } 392 else 393 { 394 if (listener.IsValid()) 395 sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref())); 396 else 397 sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener())); 398 } 399 400 if (sb_process.IsValid()) 401 { 402 error.SetError (sb_process->Attach (name, wait_for)); 403 // If we are doing synchronous mode, then wait for the 404 // process to stop! 405 if (m_opaque_sp->GetDebugger().GetAsyncExecution () == false) 406 sb_process->WaitForProcessToStop (NULL); 407 } 408 else 409 { 410 error.SetErrorString ("unable to create lldb_private::Process"); 411 } 412 } 413 else 414 { 415 error.SetErrorString ("SBTarget is invalid"); 416 } 417 return sb_process; 418 419 } 420 421 lldb::SBProcess 422 SBTarget::ConnectRemote 423 ( 424 SBListener &listener, 425 const char *url, 426 const char *plugin_name, 427 SBError& error 428 ) 429 { 430 SBProcess sb_process; 431 if (m_opaque_sp) 432 { 433 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 434 if (listener.IsValid()) 435 sb_process.SetProcess (m_opaque_sp->CreateProcess (listener.ref(), plugin_name)); 436 else 437 sb_process.SetProcess (m_opaque_sp->CreateProcess (m_opaque_sp->GetDebugger().GetListener(), plugin_name)); 438 439 440 if (sb_process.IsValid()) 441 { 442 error.SetError (sb_process->ConnectRemote (url)); 443 } 444 else 445 { 446 error.SetErrorString ("unable to create lldb_private::Process"); 447 } 448 } 449 else 450 { 451 error.SetErrorString ("SBTarget is invalid"); 452 } 453 return sb_process; 454 } 455 456 SBFileSpec 457 SBTarget::GetExecutable () 458 { 459 460 SBFileSpec exe_file_spec; 461 if (m_opaque_sp) 462 { 463 Module *exe_module = m_opaque_sp->GetExecutableModulePointer(); 464 if (exe_module) 465 exe_file_spec.SetFileSpec (exe_module->GetFileSpec()); 466 } 467 468 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 469 if (log) 470 { 471 log->Printf ("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)", 472 m_opaque_sp.get(), exe_file_spec.get()); 473 } 474 475 return exe_file_spec; 476 } 477 478 bool 479 SBTarget::operator == (const SBTarget &rhs) const 480 { 481 return m_opaque_sp.get() == rhs.m_opaque_sp.get(); 482 } 483 484 bool 485 SBTarget::operator != (const SBTarget &rhs) const 486 { 487 return m_opaque_sp.get() != rhs.m_opaque_sp.get(); 488 } 489 490 lldb_private::Target * 491 SBTarget::operator ->() const 492 { 493 return m_opaque_sp.get(); 494 } 495 496 lldb_private::Target * 497 SBTarget::get() const 498 { 499 return m_opaque_sp.get(); 500 } 501 502 const lldb::TargetSP & 503 SBTarget::get_sp () const 504 { 505 return m_opaque_sp; 506 } 507 508 void 509 SBTarget::reset (const lldb::TargetSP& target_sp) 510 { 511 m_opaque_sp = target_sp; 512 } 513 514 lldb::SBAddress 515 SBTarget::ResolveLoadAddress (lldb::addr_t vm_addr) 516 { 517 lldb::SBAddress sb_addr; 518 Address &addr = sb_addr.ref(); 519 if (m_opaque_sp) 520 { 521 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 522 if (m_opaque_sp->GetSectionLoadList().ResolveLoadAddress (vm_addr, addr)) 523 return sb_addr; 524 } 525 526 // We have a load address that isn't in a section, just return an address 527 // with the offset filled in (the address) and the section set to NULL 528 addr.SetSection(NULL); 529 addr.SetOffset(vm_addr); 530 return sb_addr; 531 } 532 533 SBSymbolContext 534 SBTarget::ResolveSymbolContextForAddress (const SBAddress& addr, uint32_t resolve_scope) 535 { 536 SBSymbolContext sc; 537 if (m_opaque_sp && addr.IsValid()) 538 m_opaque_sp->GetImages().ResolveSymbolContextForAddress (addr.ref(), resolve_scope, sc.ref()); 539 return sc; 540 } 541 542 543 SBBreakpoint 544 SBTarget::BreakpointCreateByLocation (const char *file, uint32_t line) 545 { 546 return SBBreakpoint(BreakpointCreateByLocation (SBFileSpec (file, false), line)); 547 } 548 549 SBBreakpoint 550 SBTarget::BreakpointCreateByLocation (const SBFileSpec &sb_file_spec, uint32_t line) 551 { 552 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 553 554 SBBreakpoint sb_bp; 555 if (m_opaque_sp.get() && line != 0) 556 { 557 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 558 *sb_bp = m_opaque_sp->CreateBreakpoint (NULL, *sb_file_spec, line, true, false); 559 } 560 561 if (log) 562 { 563 SBStream sstr; 564 sb_bp.GetDescription (sstr); 565 char path[PATH_MAX]; 566 sb_file_spec->GetPath (path, sizeof(path)); 567 log->Printf ("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => SBBreakpoint(%p): %s", 568 m_opaque_sp.get(), 569 path, 570 line, 571 sb_bp.get(), 572 sstr.GetData()); 573 } 574 575 return sb_bp; 576 } 577 578 SBBreakpoint 579 SBTarget::BreakpointCreateByName (const char *symbol_name, const char *module_name) 580 { 581 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 582 583 SBBreakpoint sb_bp; 584 if (m_opaque_sp.get()) 585 { 586 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 587 if (module_name && module_name[0]) 588 { 589 FileSpecList module_spec_list; 590 module_spec_list.Append (FileSpec (module_name, false)); 591 *sb_bp = m_opaque_sp->CreateBreakpoint (&module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, false); 592 } 593 else 594 { 595 *sb_bp = m_opaque_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, false); 596 } 597 } 598 599 if (log) 600 { 601 log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", module=\"%s\") => SBBreakpoint(%p)", 602 m_opaque_sp.get(), symbol_name, module_name, sb_bp.get()); 603 } 604 605 return sb_bp; 606 } 607 608 lldb::SBBreakpoint 609 SBTarget::BreakpointCreateByName (const char *symbol_name, 610 const SBFileSpecList &module_list, 611 const SBFileSpecList &comp_unit_list) 612 { 613 uint32_t name_type_mask = eFunctionNameTypeAuto; 614 return BreakpointCreateByName (symbol_name, name_type_mask, module_list, comp_unit_list); 615 } 616 617 lldb::SBBreakpoint 618 SBTarget::BreakpointCreateByName (const char *symbol_name, 619 uint32_t name_type_mask, 620 const SBFileSpecList &module_list, 621 const SBFileSpecList &comp_unit_list) 622 { 623 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 624 625 SBBreakpoint sb_bp; 626 if (m_opaque_sp.get() && symbol_name && symbol_name[0]) 627 { 628 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 629 *sb_bp = m_opaque_sp->CreateBreakpoint (module_list.get(), 630 comp_unit_list.get(), 631 symbol_name, 632 name_type_mask, 633 false); 634 } 635 636 if (log) 637 { 638 log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)", 639 m_opaque_sp.get(), symbol_name, name_type_mask, sb_bp.get()); 640 } 641 642 return sb_bp; 643 } 644 645 646 SBBreakpoint 647 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name) 648 { 649 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 650 651 SBBreakpoint sb_bp; 652 if (m_opaque_sp.get() && symbol_name_regex && symbol_name_regex[0]) 653 { 654 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 655 RegularExpression regexp(symbol_name_regex); 656 657 if (module_name && module_name[0]) 658 { 659 FileSpecList module_spec_list; 660 module_spec_list.Append (FileSpec (module_name, false)); 661 662 *sb_bp = m_opaque_sp->CreateFuncRegexBreakpoint (&module_spec_list, NULL, regexp, false); 663 } 664 else 665 { 666 *sb_bp = m_opaque_sp->CreateFuncRegexBreakpoint (NULL, NULL, regexp, false); 667 } 668 } 669 670 if (log) 671 { 672 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)", 673 m_opaque_sp.get(), symbol_name_regex, module_name, sb_bp.get()); 674 } 675 676 return sb_bp; 677 } 678 679 lldb::SBBreakpoint 680 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, 681 const SBFileSpecList &module_list, 682 const SBFileSpecList &comp_unit_list) 683 { 684 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 685 686 SBBreakpoint sb_bp; 687 if (m_opaque_sp.get() && symbol_name_regex && symbol_name_regex[0]) 688 { 689 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 690 RegularExpression regexp(symbol_name_regex); 691 692 *sb_bp = m_opaque_sp->CreateFuncRegexBreakpoint (module_list.get(), comp_unit_list.get(), regexp, false); 693 } 694 695 if (log) 696 { 697 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") => SBBreakpoint(%p)", 698 m_opaque_sp.get(), symbol_name_regex, sb_bp.get()); 699 } 700 701 return sb_bp; 702 } 703 704 SBBreakpoint 705 SBTarget::BreakpointCreateByAddress (addr_t address) 706 { 707 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 708 709 SBBreakpoint sb_bp; 710 if (m_opaque_sp.get()) 711 { 712 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 713 *sb_bp = m_opaque_sp->CreateBreakpoint (address, false); 714 } 715 716 if (log) 717 { 718 log->Printf ("SBTarget(%p)::BreakpointCreateByAddress (address=%llu) => SBBreakpoint(%p)", m_opaque_sp.get(), (uint64_t) address, sb_bp.get()); 719 } 720 721 return sb_bp; 722 } 723 724 lldb::SBBreakpoint 725 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name) 726 { 727 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 728 729 SBBreakpoint sb_bp; 730 if (m_opaque_sp.get() && source_regex && source_regex[0]) 731 { 732 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 733 RegularExpression regexp(source_regex); 734 FileSpecList source_file_spec_list; 735 source_file_spec_list.Append (source_file.ref()); 736 737 if (module_name && module_name[0]) 738 { 739 FileSpecList module_spec_list; 740 module_spec_list.Append (FileSpec (module_name, false)); 741 742 *sb_bp = m_opaque_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false); 743 } 744 else 745 { 746 *sb_bp = m_opaque_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false); 747 } 748 } 749 750 if (log) 751 { 752 char path[PATH_MAX]; 753 source_file->GetPath (path, sizeof(path)); 754 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\", file=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)", 755 m_opaque_sp.get(), source_regex, path, module_name, sb_bp.get()); 756 } 757 758 return sb_bp; 759 } 760 761 lldb::SBBreakpoint 762 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, 763 const SBFileSpecList &module_list, 764 const lldb::SBFileSpecList &source_file_list) 765 { 766 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 767 768 SBBreakpoint sb_bp; 769 if (m_opaque_sp.get() && source_regex && source_regex[0]) 770 { 771 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 772 RegularExpression regexp(source_regex); 773 *sb_bp = m_opaque_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false); 774 } 775 776 if (log) 777 { 778 log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)", 779 m_opaque_sp.get(), source_regex, sb_bp.get()); 780 } 781 782 return sb_bp; 783 } 784 785 uint32_t 786 SBTarget::GetNumBreakpoints () const 787 { 788 if (m_opaque_sp) 789 { 790 // The breakpoint list is thread safe, no need to lock 791 return m_opaque_sp->GetBreakpointList().GetSize(); 792 } 793 return 0; 794 } 795 796 SBBreakpoint 797 SBTarget::GetBreakpointAtIndex (uint32_t idx) const 798 { 799 SBBreakpoint sb_breakpoint; 800 if (m_opaque_sp) 801 { 802 // The breakpoint list is thread safe, no need to lock 803 *sb_breakpoint = m_opaque_sp->GetBreakpointList().GetBreakpointAtIndex(idx); 804 } 805 return sb_breakpoint; 806 } 807 808 bool 809 SBTarget::BreakpointDelete (break_id_t bp_id) 810 { 811 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 812 813 bool result = false; 814 if (m_opaque_sp) 815 { 816 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 817 result = m_opaque_sp->RemoveBreakpointByID (bp_id); 818 } 819 820 if (log) 821 { 822 log->Printf ("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", m_opaque_sp.get(), (uint32_t) bp_id, result); 823 } 824 825 return result; 826 } 827 828 SBBreakpoint 829 SBTarget::FindBreakpointByID (break_id_t bp_id) 830 { 831 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 832 833 SBBreakpoint sb_breakpoint; 834 if (m_opaque_sp && bp_id != LLDB_INVALID_BREAK_ID) 835 { 836 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 837 *sb_breakpoint = m_opaque_sp->GetBreakpointByID (bp_id); 838 } 839 840 if (log) 841 { 842 log->Printf ("SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)", 843 m_opaque_sp.get(), (uint32_t) bp_id, sb_breakpoint.get()); 844 } 845 846 return sb_breakpoint; 847 } 848 849 bool 850 SBTarget::EnableAllBreakpoints () 851 { 852 if (m_opaque_sp) 853 { 854 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 855 m_opaque_sp->EnableAllBreakpoints (); 856 return true; 857 } 858 return false; 859 } 860 861 bool 862 SBTarget::DisableAllBreakpoints () 863 { 864 if (m_opaque_sp) 865 { 866 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 867 m_opaque_sp->DisableAllBreakpoints (); 868 return true; 869 } 870 return false; 871 } 872 873 bool 874 SBTarget::DeleteAllBreakpoints () 875 { 876 if (m_opaque_sp) 877 { 878 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 879 m_opaque_sp->RemoveAllBreakpoints (); 880 return true; 881 } 882 return false; 883 } 884 885 uint32_t 886 SBTarget::GetNumWatchpointLocations () const 887 { 888 if (m_opaque_sp) 889 { 890 // The watchpoint location list is thread safe, no need to lock 891 return m_opaque_sp->GetWatchpointLocationList().GetSize(); 892 } 893 return 0; 894 } 895 896 SBWatchpointLocation 897 SBTarget::GetLastCreatedWatchpointLocation () 898 { 899 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 900 901 SBWatchpointLocation sb_watchpoint_location; 902 if (m_opaque_sp) 903 { 904 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 905 sb_watchpoint_location = m_opaque_sp->GetLastCreatedWatchpointLocation(); 906 } 907 908 if (log) 909 { 910 log->Printf ("SBTarget(%p)::GetLastCreateWatchpointLocation () => SBWatchpointLocation(%p)", 911 m_opaque_sp.get(), sb_watchpoint_location.get()); 912 } 913 914 return sb_watchpoint_location; 915 } 916 917 SBWatchpointLocation 918 SBTarget::GetWatchpointLocationAtIndex (uint32_t idx) const 919 { 920 SBWatchpointLocation sb_watchpoint_location; 921 if (m_opaque_sp) 922 { 923 // The watchpoint location list is thread safe, no need to lock 924 *sb_watchpoint_location = m_opaque_sp->GetWatchpointLocationList().GetByIndex(idx); 925 } 926 return sb_watchpoint_location; 927 } 928 929 bool 930 SBTarget::WatchpointLocationDelete (watch_id_t wp_id) 931 { 932 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 933 934 bool result = false; 935 if (m_opaque_sp) 936 { 937 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 938 result = m_opaque_sp->RemoveWatchpointLocationByID (wp_id); 939 } 940 941 if (log) 942 { 943 log->Printf ("SBTarget(%p)::WatchpointLocationDelete (wp_id=%d) => %i", m_opaque_sp.get(), (uint32_t) wp_id, result); 944 } 945 946 return result; 947 } 948 949 SBWatchpointLocation 950 SBTarget::FindWatchpointLocationByID (watch_id_t wp_id) 951 { 952 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 953 954 SBWatchpointLocation sb_watchpoint_location; 955 if (m_opaque_sp && wp_id != LLDB_INVALID_WATCH_ID) 956 { 957 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 958 *sb_watchpoint_location = m_opaque_sp->GetWatchpointLocationList().FindByID(wp_id); 959 } 960 961 if (log) 962 { 963 log->Printf ("SBTarget(%p)::FindWatchpointLocationByID (bp_id=%d) => SBWatchpointLocation(%p)", 964 m_opaque_sp.get(), (uint32_t) wp_id, sb_watchpoint_location.get()); 965 } 966 967 return sb_watchpoint_location; 968 } 969 970 bool 971 SBTarget::EnableAllWatchpointLocations () 972 { 973 if (m_opaque_sp) 974 { 975 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 976 m_opaque_sp->EnableAllWatchpointLocations (); 977 return true; 978 } 979 return false; 980 } 981 982 bool 983 SBTarget::DisableAllWatchpointLocations () 984 { 985 if (m_opaque_sp) 986 { 987 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 988 m_opaque_sp->DisableAllWatchpointLocations (); 989 return true; 990 } 991 return false; 992 } 993 994 bool 995 SBTarget::DeleteAllWatchpointLocations () 996 { 997 if (m_opaque_sp) 998 { 999 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 1000 m_opaque_sp->RemoveAllWatchpointLocations (); 1001 return true; 1002 } 1003 return false; 1004 } 1005 1006 1007 lldb::SBModule 1008 SBTarget::AddModule (const char *path, 1009 const char *triple, 1010 const char *uuid_cstr) 1011 { 1012 lldb::SBModule sb_module; 1013 if (m_opaque_sp) 1014 { 1015 FileSpec module_file_spec; 1016 UUID module_uuid; 1017 ArchSpec module_arch; 1018 1019 if (path) 1020 module_file_spec.SetFile(path, false); 1021 1022 if (uuid_cstr) 1023 module_uuid.SetfromCString(uuid_cstr); 1024 1025 if (triple) 1026 module_arch.SetTriple (triple, m_opaque_sp->GetPlatform ().get()); 1027 1028 sb_module.SetModule(m_opaque_sp->GetSharedModule (module_file_spec, 1029 module_arch, 1030 uuid_cstr ? &module_uuid : NULL)); 1031 } 1032 return sb_module; 1033 } 1034 1035 bool 1036 SBTarget::AddModule (lldb::SBModule &module) 1037 { 1038 if (m_opaque_sp) 1039 { 1040 m_opaque_sp->GetImages().AppendIfNeeded (module.get_sp()); 1041 return true; 1042 } 1043 return false; 1044 } 1045 1046 lldb::SBModule 1047 AddModule (const char *path, 1048 const char *triple, 1049 const char *uuid); 1050 1051 1052 1053 uint32_t 1054 SBTarget::GetNumModules () const 1055 { 1056 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1057 1058 uint32_t num = 0; 1059 if (m_opaque_sp) 1060 { 1061 // The module list is thread safe, no need to lock 1062 num = m_opaque_sp->GetImages().GetSize(); 1063 } 1064 1065 if (log) 1066 log->Printf ("SBTarget(%p)::GetNumModules () => %d", m_opaque_sp.get(), num); 1067 1068 return num; 1069 } 1070 1071 void 1072 SBTarget::Clear () 1073 { 1074 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1075 1076 if (log) 1077 log->Printf ("SBTarget(%p)::Clear ()", m_opaque_sp.get()); 1078 1079 m_opaque_sp.reset(); 1080 } 1081 1082 1083 SBModule 1084 SBTarget::FindModule (const SBFileSpec &sb_file_spec) 1085 { 1086 SBModule sb_module; 1087 if (m_opaque_sp && sb_file_spec.IsValid()) 1088 { 1089 // The module list is thread safe, no need to lock 1090 sb_module.SetModule (m_opaque_sp->GetImages().FindFirstModuleForFileSpec (*sb_file_spec, NULL, NULL)); 1091 } 1092 return sb_module; 1093 } 1094 1095 SBModule 1096 SBTarget::GetModuleAtIndex (uint32_t idx) 1097 { 1098 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1099 1100 SBModule sb_module; 1101 if (m_opaque_sp) 1102 { 1103 // The module list is thread safe, no need to lock 1104 sb_module.SetModule(m_opaque_sp->GetImages().GetModuleAtIndex(idx)); 1105 } 1106 1107 if (log) 1108 { 1109 log->Printf ("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)", 1110 m_opaque_sp.get(), idx, sb_module.get()); 1111 } 1112 1113 return sb_module; 1114 } 1115 1116 bool 1117 SBTarget::RemoveModule (lldb::SBModule module) 1118 { 1119 if (m_opaque_sp) 1120 return m_opaque_sp->GetImages().Remove(module.get_sp()); 1121 return false; 1122 } 1123 1124 1125 SBBroadcaster 1126 SBTarget::GetBroadcaster () const 1127 { 1128 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1129 1130 SBBroadcaster broadcaster(m_opaque_sp.get(), false); 1131 1132 if (log) 1133 log->Printf ("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)", 1134 m_opaque_sp.get(), broadcaster.get()); 1135 1136 return broadcaster; 1137 } 1138 1139 1140 bool 1141 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) 1142 { 1143 if (m_opaque_sp) 1144 { 1145 description.ref(); 1146 m_opaque_sp->Dump (description.get(), description_level); 1147 } 1148 else 1149 description.Printf ("No value"); 1150 1151 return true; 1152 } 1153 1154 bool 1155 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) const 1156 { 1157 if (m_opaque_sp) 1158 { 1159 description.ref(); 1160 m_opaque_sp->Dump (description.get(), description_level); 1161 } 1162 else 1163 description.Printf ("No value"); 1164 1165 return true; 1166 } 1167 1168 1169 uint32_t 1170 SBTarget::FindFunctions (const char *name, 1171 uint32_t name_type_mask, 1172 bool append, 1173 lldb::SBSymbolContextList& sc_list) 1174 { 1175 if (!append) 1176 sc_list.Clear(); 1177 if (m_opaque_sp) 1178 { 1179 const bool symbols_ok = true; 1180 return m_opaque_sp->GetImages().FindFunctions (ConstString(name), 1181 name_type_mask, 1182 symbols_ok, 1183 append, 1184 *sc_list); 1185 } 1186 return 0; 1187 } 1188 1189 lldb::SBType 1190 SBTarget::FindFirstType (const char* type) 1191 { 1192 if (m_opaque_sp) 1193 { 1194 size_t count = m_opaque_sp->GetImages().GetSize(); 1195 for (size_t idx = 0; idx < count; idx++) 1196 { 1197 SBType found_at_idx = GetModuleAtIndex(idx).FindFirstType(type); 1198 1199 if (found_at_idx.IsValid()) 1200 return found_at_idx; 1201 } 1202 } 1203 return SBType(); 1204 } 1205 1206 lldb::SBTypeList 1207 SBTarget::FindTypes (const char* type) 1208 { 1209 1210 SBTypeList retval; 1211 1212 if (m_opaque_sp) 1213 { 1214 ModuleList& images = m_opaque_sp->GetImages(); 1215 ConstString name_const(type); 1216 SymbolContext sc; 1217 TypeList type_list; 1218 1219 uint32_t num_matches = images.FindTypes(sc, 1220 name_const, 1221 true, 1222 UINT32_MAX, 1223 type_list); 1224 1225 for (size_t idx = 0; idx < num_matches; idx++) 1226 { 1227 TypeSP type_sp (type_list.GetTypeAtIndex(idx)); 1228 if (type_sp) 1229 retval.Append(SBType(type_sp)); 1230 } 1231 } 1232 return retval; 1233 } 1234 1235 SBValueList 1236 SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches) 1237 { 1238 SBValueList sb_value_list; 1239 1240 if (m_opaque_sp) 1241 { 1242 VariableList variable_list; 1243 const bool append = true; 1244 const uint32_t match_count = m_opaque_sp->GetImages().FindGlobalVariables (ConstString (name), 1245 append, 1246 max_matches, 1247 variable_list); 1248 1249 if (match_count > 0) 1250 { 1251 ExecutionContextScope *exe_scope = m_opaque_sp->GetProcessSP().get(); 1252 if (exe_scope == NULL) 1253 exe_scope = m_opaque_sp.get(); 1254 ValueObjectList &value_object_list = sb_value_list.ref(); 1255 for (uint32_t i=0; i<match_count; ++i) 1256 { 1257 lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i))); 1258 if (valobj_sp) 1259 value_object_list.Append(valobj_sp); 1260 } 1261 } 1262 } 1263 1264 return sb_value_list; 1265 } 1266 1267 SBSourceManager 1268 SBTarget::GetSourceManager() 1269 { 1270 SBSourceManager source_manager (*this); 1271 return source_manager; 1272 } 1273 1274 1275 SBError 1276 SBTarget::SetSectionLoadAddress (lldb::SBSection section, 1277 lldb::addr_t section_base_addr) 1278 { 1279 SBError sb_error; 1280 1281 if (IsValid()) 1282 { 1283 if (!section.IsValid()) 1284 { 1285 sb_error.SetErrorStringWithFormat ("invalid section"); 1286 } 1287 else 1288 { 1289 m_opaque_sp->GetSectionLoadList().SetSectionLoadAddress (section.GetSection(), section_base_addr); 1290 } 1291 } 1292 else 1293 { 1294 sb_error.SetErrorStringWithFormat ("invalid target"); 1295 } 1296 return sb_error; 1297 } 1298 1299 SBError 1300 SBTarget::ClearSectionLoadAddress (lldb::SBSection section) 1301 { 1302 SBError sb_error; 1303 1304 if (IsValid()) 1305 { 1306 if (!section.IsValid()) 1307 { 1308 sb_error.SetErrorStringWithFormat ("invalid section"); 1309 } 1310 else 1311 { 1312 m_opaque_sp->GetSectionLoadList().SetSectionUnloaded (section.GetSection()); 1313 } 1314 } 1315 else 1316 { 1317 sb_error.SetErrorStringWithFormat ("invalid target"); 1318 } 1319 return sb_error; 1320 } 1321 1322 SBError 1323 SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset) 1324 { 1325 SBError sb_error; 1326 1327 char path[PATH_MAX]; 1328 if (IsValid()) 1329 { 1330 if (!module.IsValid()) 1331 { 1332 sb_error.SetErrorStringWithFormat ("invalid module"); 1333 } 1334 else 1335 { 1336 ObjectFile *objfile = module->GetObjectFile(); 1337 if (objfile) 1338 { 1339 SectionList *section_list = objfile->GetSectionList(); 1340 if (section_list) 1341 { 1342 const size_t num_sections = section_list->GetSize(); 1343 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) 1344 { 1345 SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx)); 1346 if (section_sp) 1347 m_opaque_sp->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), section_sp->GetFileAddress() + slide_offset); 1348 } 1349 } 1350 else 1351 { 1352 module->GetFileSpec().GetPath (path, sizeof(path)); 1353 sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path); 1354 } 1355 } 1356 else 1357 { 1358 module->GetFileSpec().GetPath (path, sizeof(path)); 1359 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path); 1360 } 1361 } 1362 } 1363 else 1364 { 1365 sb_error.SetErrorStringWithFormat ("invalid target"); 1366 } 1367 return sb_error; 1368 } 1369 1370 SBError 1371 SBTarget::ClearModuleLoadAddress (lldb::SBModule module) 1372 { 1373 SBError sb_error; 1374 1375 char path[PATH_MAX]; 1376 if (IsValid()) 1377 { 1378 if (!module.IsValid()) 1379 { 1380 sb_error.SetErrorStringWithFormat ("invalid module"); 1381 } 1382 else 1383 { 1384 ObjectFile *objfile = module->GetObjectFile(); 1385 if (objfile) 1386 { 1387 SectionList *section_list = objfile->GetSectionList(); 1388 if (section_list) 1389 { 1390 const size_t num_sections = section_list->GetSize(); 1391 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) 1392 { 1393 SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx)); 1394 if (section_sp) 1395 m_opaque_sp->GetSectionLoadList().SetSectionUnloaded (section_sp.get()); 1396 } 1397 } 1398 else 1399 { 1400 module->GetFileSpec().GetPath (path, sizeof(path)); 1401 sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path); 1402 } 1403 } 1404 else 1405 { 1406 module->GetFileSpec().GetPath (path, sizeof(path)); 1407 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path); 1408 } 1409 } 1410 } 1411 else 1412 { 1413 sb_error.SetErrorStringWithFormat ("invalid target"); 1414 } 1415 return sb_error; 1416 } 1417 1418 1419