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::GetNumWatchpoints () 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 SBWatchpoint 897 SBTarget::GetWatchpointAtIndex (uint32_t idx) const 898 { 899 SBWatchpoint sb_watchpoint_location; 900 if (m_opaque_sp) 901 { 902 // The watchpoint location list is thread safe, no need to lock 903 *sb_watchpoint_location = m_opaque_sp->GetWatchpointLocationList().GetByIndex(idx); 904 } 905 return sb_watchpoint_location; 906 } 907 908 bool 909 SBTarget::DeleteWatchpoint (watch_id_t wp_id) 910 { 911 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 912 913 bool result = false; 914 if (m_opaque_sp) 915 { 916 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 917 result = m_opaque_sp->RemoveWatchpointLocationByID (wp_id); 918 } 919 920 if (log) 921 { 922 log->Printf ("SBTarget(%p)::WatchpointLocationDelete (wp_id=%d) => %i", m_opaque_sp.get(), (uint32_t) wp_id, result); 923 } 924 925 return result; 926 } 927 928 SBWatchpoint 929 SBTarget::FindWatchpointByID (lldb::watch_id_t wp_id) 930 { 931 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 932 933 SBWatchpoint sb_watchpoint; 934 if (m_opaque_sp && wp_id != LLDB_INVALID_WATCH_ID) 935 { 936 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 937 *sb_watchpoint = m_opaque_sp->GetWatchpointLocationList().FindByID(wp_id); 938 } 939 940 if (log) 941 { 942 log->Printf ("SBTarget(%p)::FindWatchpointLocationByID (bp_id=%d) => SBWatchpoint(%p)", 943 m_opaque_sp.get(), (uint32_t) wp_id, sb_watchpoint.get()); 944 } 945 946 return sb_watchpoint; 947 } 948 949 lldb::SBWatchpoint 950 SBTarget::WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write) 951 { 952 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 953 954 SBWatchpoint sb_watchpoint; 955 if (m_opaque_sp) 956 { 957 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 958 // TODO: Johnny fill this in 959 //*sb_watchpoint = m_opaque_sp->GetWatchpointLocationList().FindByID(wp_id); 960 } 961 962 if (log) 963 { 964 log->Printf ("SBTarget(%p)::WatchAddress (addr=0x%llx, 0x%u) => SBWatchpoint(%p)", 965 m_opaque_sp.get(), addr, (uint32_t) size, sb_watchpoint.get()); 966 } 967 968 return sb_watchpoint; 969 } 970 971 bool 972 SBTarget::EnableAllWatchpoints () 973 { 974 if (m_opaque_sp) 975 { 976 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 977 m_opaque_sp->EnableAllWatchpointLocations (); 978 return true; 979 } 980 return false; 981 } 982 983 bool 984 SBTarget::DisableAllWatchpoints () 985 { 986 if (m_opaque_sp) 987 { 988 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 989 m_opaque_sp->DisableAllWatchpointLocations (); 990 return true; 991 } 992 return false; 993 } 994 995 bool 996 SBTarget::DeleteAllWatchpoints () 997 { 998 if (m_opaque_sp) 999 { 1000 Mutex::Locker api_locker (m_opaque_sp->GetAPIMutex()); 1001 m_opaque_sp->RemoveAllWatchpointLocations (); 1002 return true; 1003 } 1004 return false; 1005 } 1006 1007 1008 lldb::SBModule 1009 SBTarget::AddModule (const char *path, 1010 const char *triple, 1011 const char *uuid_cstr) 1012 { 1013 lldb::SBModule sb_module; 1014 if (m_opaque_sp) 1015 { 1016 FileSpec module_file_spec; 1017 UUID module_uuid; 1018 ArchSpec module_arch; 1019 1020 if (path) 1021 module_file_spec.SetFile(path, false); 1022 1023 if (uuid_cstr) 1024 module_uuid.SetfromCString(uuid_cstr); 1025 1026 if (triple) 1027 module_arch.SetTriple (triple, m_opaque_sp->GetPlatform ().get()); 1028 1029 sb_module.SetModule(m_opaque_sp->GetSharedModule (module_file_spec, 1030 module_arch, 1031 uuid_cstr ? &module_uuid : NULL)); 1032 } 1033 return sb_module; 1034 } 1035 1036 bool 1037 SBTarget::AddModule (lldb::SBModule &module) 1038 { 1039 if (m_opaque_sp) 1040 { 1041 m_opaque_sp->GetImages().AppendIfNeeded (module.get_sp()); 1042 return true; 1043 } 1044 return false; 1045 } 1046 1047 lldb::SBModule 1048 AddModule (const char *path, 1049 const char *triple, 1050 const char *uuid); 1051 1052 1053 1054 uint32_t 1055 SBTarget::GetNumModules () const 1056 { 1057 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1058 1059 uint32_t num = 0; 1060 if (m_opaque_sp) 1061 { 1062 // The module list is thread safe, no need to lock 1063 num = m_opaque_sp->GetImages().GetSize(); 1064 } 1065 1066 if (log) 1067 log->Printf ("SBTarget(%p)::GetNumModules () => %d", m_opaque_sp.get(), num); 1068 1069 return num; 1070 } 1071 1072 void 1073 SBTarget::Clear () 1074 { 1075 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1076 1077 if (log) 1078 log->Printf ("SBTarget(%p)::Clear ()", m_opaque_sp.get()); 1079 1080 m_opaque_sp.reset(); 1081 } 1082 1083 1084 SBModule 1085 SBTarget::FindModule (const SBFileSpec &sb_file_spec) 1086 { 1087 SBModule sb_module; 1088 if (m_opaque_sp && sb_file_spec.IsValid()) 1089 { 1090 // The module list is thread safe, no need to lock 1091 sb_module.SetModule (m_opaque_sp->GetImages().FindFirstModuleForFileSpec (*sb_file_spec, NULL, NULL)); 1092 } 1093 return sb_module; 1094 } 1095 1096 SBModule 1097 SBTarget::GetModuleAtIndex (uint32_t idx) 1098 { 1099 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1100 1101 SBModule sb_module; 1102 if (m_opaque_sp) 1103 { 1104 // The module list is thread safe, no need to lock 1105 sb_module.SetModule(m_opaque_sp->GetImages().GetModuleAtIndex(idx)); 1106 } 1107 1108 if (log) 1109 { 1110 log->Printf ("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)", 1111 m_opaque_sp.get(), idx, sb_module.get()); 1112 } 1113 1114 return sb_module; 1115 } 1116 1117 bool 1118 SBTarget::RemoveModule (lldb::SBModule module) 1119 { 1120 if (m_opaque_sp) 1121 return m_opaque_sp->GetImages().Remove(module.get_sp()); 1122 return false; 1123 } 1124 1125 1126 SBBroadcaster 1127 SBTarget::GetBroadcaster () const 1128 { 1129 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1130 1131 SBBroadcaster broadcaster(m_opaque_sp.get(), false); 1132 1133 if (log) 1134 log->Printf ("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)", 1135 m_opaque_sp.get(), broadcaster.get()); 1136 1137 return broadcaster; 1138 } 1139 1140 1141 bool 1142 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) 1143 { 1144 if (m_opaque_sp) 1145 { 1146 description.ref(); 1147 m_opaque_sp->Dump (description.get(), description_level); 1148 } 1149 else 1150 description.Printf ("No value"); 1151 1152 return true; 1153 } 1154 1155 bool 1156 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) const 1157 { 1158 if (m_opaque_sp) 1159 { 1160 description.ref(); 1161 m_opaque_sp->Dump (description.get(), description_level); 1162 } 1163 else 1164 description.Printf ("No value"); 1165 1166 return true; 1167 } 1168 1169 1170 uint32_t 1171 SBTarget::FindFunctions (const char *name, 1172 uint32_t name_type_mask, 1173 bool append, 1174 lldb::SBSymbolContextList& sc_list) 1175 { 1176 if (!append) 1177 sc_list.Clear(); 1178 if (m_opaque_sp) 1179 { 1180 const bool symbols_ok = true; 1181 return m_opaque_sp->GetImages().FindFunctions (ConstString(name), 1182 name_type_mask, 1183 symbols_ok, 1184 append, 1185 *sc_list); 1186 } 1187 return 0; 1188 } 1189 1190 lldb::SBType 1191 SBTarget::FindFirstType (const char* type) 1192 { 1193 if (m_opaque_sp) 1194 { 1195 size_t count = m_opaque_sp->GetImages().GetSize(); 1196 for (size_t idx = 0; idx < count; idx++) 1197 { 1198 SBType found_at_idx = GetModuleAtIndex(idx).FindFirstType(type); 1199 1200 if (found_at_idx.IsValid()) 1201 return found_at_idx; 1202 } 1203 } 1204 return SBType(); 1205 } 1206 1207 lldb::SBTypeList 1208 SBTarget::FindTypes (const char* type) 1209 { 1210 1211 SBTypeList retval; 1212 1213 if (m_opaque_sp) 1214 { 1215 ModuleList& images = m_opaque_sp->GetImages(); 1216 ConstString name_const(type); 1217 SymbolContext sc; 1218 TypeList type_list; 1219 1220 uint32_t num_matches = images.FindTypes(sc, 1221 name_const, 1222 true, 1223 UINT32_MAX, 1224 type_list); 1225 1226 for (size_t idx = 0; idx < num_matches; idx++) 1227 { 1228 TypeSP type_sp (type_list.GetTypeAtIndex(idx)); 1229 if (type_sp) 1230 retval.Append(SBType(type_sp)); 1231 } 1232 } 1233 return retval; 1234 } 1235 1236 SBValueList 1237 SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches) 1238 { 1239 SBValueList sb_value_list; 1240 1241 if (m_opaque_sp) 1242 { 1243 VariableList variable_list; 1244 const bool append = true; 1245 const uint32_t match_count = m_opaque_sp->GetImages().FindGlobalVariables (ConstString (name), 1246 append, 1247 max_matches, 1248 variable_list); 1249 1250 if (match_count > 0) 1251 { 1252 ExecutionContextScope *exe_scope = m_opaque_sp->GetProcessSP().get(); 1253 if (exe_scope == NULL) 1254 exe_scope = m_opaque_sp.get(); 1255 ValueObjectList &value_object_list = sb_value_list.ref(); 1256 for (uint32_t i=0; i<match_count; ++i) 1257 { 1258 lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i))); 1259 if (valobj_sp) 1260 value_object_list.Append(valobj_sp); 1261 } 1262 } 1263 } 1264 1265 return sb_value_list; 1266 } 1267 1268 SBSourceManager 1269 SBTarget::GetSourceManager() 1270 { 1271 SBSourceManager source_manager (*this); 1272 return source_manager; 1273 } 1274 1275 1276 SBError 1277 SBTarget::SetSectionLoadAddress (lldb::SBSection section, 1278 lldb::addr_t section_base_addr) 1279 { 1280 SBError sb_error; 1281 1282 if (IsValid()) 1283 { 1284 if (!section.IsValid()) 1285 { 1286 sb_error.SetErrorStringWithFormat ("invalid section"); 1287 } 1288 else 1289 { 1290 m_opaque_sp->GetSectionLoadList().SetSectionLoadAddress (section.GetSection(), section_base_addr); 1291 } 1292 } 1293 else 1294 { 1295 sb_error.SetErrorStringWithFormat ("invalid target"); 1296 } 1297 return sb_error; 1298 } 1299 1300 SBError 1301 SBTarget::ClearSectionLoadAddress (lldb::SBSection section) 1302 { 1303 SBError sb_error; 1304 1305 if (IsValid()) 1306 { 1307 if (!section.IsValid()) 1308 { 1309 sb_error.SetErrorStringWithFormat ("invalid section"); 1310 } 1311 else 1312 { 1313 m_opaque_sp->GetSectionLoadList().SetSectionUnloaded (section.GetSection()); 1314 } 1315 } 1316 else 1317 { 1318 sb_error.SetErrorStringWithFormat ("invalid target"); 1319 } 1320 return sb_error; 1321 } 1322 1323 SBError 1324 SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset) 1325 { 1326 SBError sb_error; 1327 1328 char path[PATH_MAX]; 1329 if (IsValid()) 1330 { 1331 if (!module.IsValid()) 1332 { 1333 sb_error.SetErrorStringWithFormat ("invalid module"); 1334 } 1335 else 1336 { 1337 ObjectFile *objfile = module->GetObjectFile(); 1338 if (objfile) 1339 { 1340 SectionList *section_list = objfile->GetSectionList(); 1341 if (section_list) 1342 { 1343 const size_t num_sections = section_list->GetSize(); 1344 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) 1345 { 1346 SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx)); 1347 if (section_sp) 1348 m_opaque_sp->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), section_sp->GetFileAddress() + slide_offset); 1349 } 1350 } 1351 else 1352 { 1353 module->GetFileSpec().GetPath (path, sizeof(path)); 1354 sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path); 1355 } 1356 } 1357 else 1358 { 1359 module->GetFileSpec().GetPath (path, sizeof(path)); 1360 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path); 1361 } 1362 } 1363 } 1364 else 1365 { 1366 sb_error.SetErrorStringWithFormat ("invalid target"); 1367 } 1368 return sb_error; 1369 } 1370 1371 SBError 1372 SBTarget::ClearModuleLoadAddress (lldb::SBModule module) 1373 { 1374 SBError sb_error; 1375 1376 char path[PATH_MAX]; 1377 if (IsValid()) 1378 { 1379 if (!module.IsValid()) 1380 { 1381 sb_error.SetErrorStringWithFormat ("invalid module"); 1382 } 1383 else 1384 { 1385 ObjectFile *objfile = module->GetObjectFile(); 1386 if (objfile) 1387 { 1388 SectionList *section_list = objfile->GetSectionList(); 1389 if (section_list) 1390 { 1391 const size_t num_sections = section_list->GetSize(); 1392 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) 1393 { 1394 SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx)); 1395 if (section_sp) 1396 m_opaque_sp->GetSectionLoadList().SetSectionUnloaded (section_sp.get()); 1397 } 1398 } 1399 else 1400 { 1401 module->GetFileSpec().GetPath (path, sizeof(path)); 1402 sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path); 1403 } 1404 } 1405 else 1406 { 1407 module->GetFileSpec().GetPath (path, sizeof(path)); 1408 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path); 1409 } 1410 } 1411 } 1412 else 1413 { 1414 sb_error.SetErrorStringWithFormat ("invalid target"); 1415 } 1416 return sb_error; 1417 } 1418 1419 1420