contrib/llvm/tools/lldb/source/API/SBTarget.cpp

   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, eLanguageTypeUnknown, 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     return BreakpointCreateByName (symbol_name, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list);
 883 }
 884
 885 lldb::SBBreakpoint
 886 SBTarget::BreakpointCreateByName (const char *symbol_name,
 887                                   uint32_t name_type_mask,
 888                                   LanguageType symbol_language,
 889                                   const SBFileSpecList &module_list,
 890                                   const SBFileSpecList &comp_unit_list)
 891 {
 892     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 893
 894     SBBreakpoint sb_bp;
 895     TargetSP target_sp(GetSP());
 896     if (target_sp && symbol_name && symbol_name[0])
 897     {
 898         const bool internal = false;
 899         const bool hardware = false;
 900         const LazyBool skip_prologue = eLazyBoolCalculate;
 901         Mutex::Locker api_locker (target_sp->GetAPIMutex());
 902         *sb_bp = target_sp->CreateBreakpoint (module_list.get(),
 903                                               comp_unit_list.get(),
 904                                               symbol_name,
 905                                               name_type_mask,
 906                                               symbol_language,
 907                                               skip_prologue,
 908                                               internal,
 909                                               hardware);
 910     }
 911
 912     if (log)
 913         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)",
 914                      static_cast<void*>(target_sp.get()), symbol_name,
 915                      name_type_mask, static_cast<void*>(sb_bp.get()));
 916
 917     return sb_bp;
 918 }
 919
 920 lldb::SBBreakpoint
 921 SBTarget::BreakpointCreateByNames (const char *symbol_names[],
 922                                    uint32_t num_names,
 923                                    uint32_t name_type_mask,
 924                                    const SBFileSpecList &module_list,
 925                                    const SBFileSpecList &comp_unit_list)
 926 {
 927     return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list);
 928 }
 929
 930 lldb::SBBreakpoint
 931 SBTarget::BreakpointCreateByNames (const char *symbol_names[],
 932                                    uint32_t num_names,
 933                                    uint32_t name_type_mask,
 934                                    LanguageType symbol_language,
 935                                    const SBFileSpecList &module_list,
 936                                    const SBFileSpecList &comp_unit_list)
 937 {
 938     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 939
 940     SBBreakpoint sb_bp;
 941     TargetSP target_sp(GetSP());
 942     if (target_sp && num_names > 0)
 943     {
 944         Mutex::Locker api_locker (target_sp->GetAPIMutex());
 945         const bool internal = false;
 946         const bool hardware = false;
 947         const LazyBool skip_prologue = eLazyBoolCalculate;
 948         *sb_bp = target_sp->CreateBreakpoint (module_list.get(),
 949                                               comp_unit_list.get(),
 950                                               symbol_names,
 951                                               num_names,
 952                                               name_type_mask,
 953                                               symbol_language,
 954                                               skip_prologue,
 955                                               internal,
 956                                               hardware);
 957     }
 958
 959     if (log)
 960     {
 961         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbols={",
 962                      static_cast<void*>(target_sp.get()));
 963         for (uint32_t i = 0 ; i < num_names; i++)
 964         {
 965             char sep;
 966             if (i < num_names - 1)
 967                 sep = ',';
 968             else
 969                 sep = '}';
 970             if (symbol_names[i] != NULL)
 971                 log->Printf ("\"%s\"%c ", symbol_names[i], sep);
 972             else
 973                 log->Printf ("\"<NULL>\"%c ", sep);
 974         }
 975         log->Printf ("name_type: %d) => SBBreakpoint(%p)", name_type_mask,
 976                      static_cast<void*>(sb_bp.get()));
 977     }
 978
 979     return sb_bp;
 980 }
 981
 982 SBBreakpoint
 983 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex,
 984                                    const char *module_name)
 985 {
 986     SBFileSpecList module_spec_list;
 987     SBFileSpecList comp_unit_list;
 988     if (module_name && module_name[0])
 989     {
 990         module_spec_list.Append (FileSpec (module_name, false));
 991
 992     }
 993     return BreakpointCreateByRegex (symbol_name_regex, eLanguageTypeUnknown, module_spec_list, comp_unit_list);
 994 }
 995
 996 lldb::SBBreakpoint
 997 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex,
 998                                    const SBFileSpecList &module_list,
 999                                    const SBFileSpecList &comp_unit_list)
1000 {
1001     return BreakpointCreateByRegex (symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list);
1002 }
1003
1004 lldb::SBBreakpoint
1005 SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex,
1006                                    LanguageType symbol_language,
1007                                    const SBFileSpecList &module_list,
1008                                    const SBFileSpecList &comp_unit_list)
1009 {
1010     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1011
1012     SBBreakpoint sb_bp;
1013     TargetSP target_sp(GetSP());
1014     if (target_sp && symbol_name_regex && symbol_name_regex[0])
1015     {
1016         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1017         RegularExpression regexp(symbol_name_regex);
1018         const bool internal = false;
1019         const bool hardware = false;
1020         const LazyBool skip_prologue = eLazyBoolCalculate;
1021
1022         *sb_bp = target_sp->CreateFuncRegexBreakpoint (module_list.get(), comp_unit_list.get(), regexp, symbol_language, skip_prologue, internal, hardware);
1023     }
1024
1025     if (log)
1026         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") => SBBreakpoint(%p)",
1027                      static_cast<void*>(target_sp.get()), symbol_name_regex,
1028                      static_cast<void*>(sb_bp.get()));
1029
1030     return sb_bp;
1031 }
1032
1033 SBBreakpoint
1034 SBTarget::BreakpointCreateByAddress (addr_t address)
1035 {
1036     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1037
1038     SBBreakpoint sb_bp;
1039     TargetSP target_sp(GetSP());
1040     if (target_sp)
1041     {
1042         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1043         const bool hardware = false;
1044         *sb_bp = target_sp->CreateBreakpoint (address, false, hardware);
1045     }
1046
1047     if (log)
1048         log->Printf ("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64 ") => SBBreakpoint(%p)",
1049                      static_cast<void*>(target_sp.get()),
1050                      static_cast<uint64_t>(address),
1051                      static_cast<void*>(sb_bp.get()));
1052
1053     return sb_bp;
1054 }
1055
1056 SBBreakpoint
1057 SBTarget::BreakpointCreateBySBAddress (SBAddress &sb_address)
1058 {
1059     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1060
1061     SBBreakpoint sb_bp;
1062     TargetSP target_sp(GetSP());
1063     if (!sb_address.IsValid())
1064     {
1065         if (log)
1066             log->Printf ("SBTarget(%p)::BreakpointCreateBySBAddress called with invalid address",
1067                          static_cast<void*>(target_sp.get()));
1068         return sb_bp;
1069     }
1070
1071     if (target_sp)
1072     {
1073         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1074         const bool hardware = false;
1075         *sb_bp = target_sp->CreateBreakpoint (sb_address.ref(), false, hardware);
1076     }
1077
1078     if (log)
1079     {
1080         SBStream s;
1081         sb_address.GetDescription(s);
1082         log->Printf ("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => SBBreakpoint(%p)",
1083                      static_cast<void*>(target_sp.get()),
1084                      s.GetData(),
1085                      static_cast<void*>(sb_bp.get()));
1086     }
1087
1088     return sb_bp;
1089 }
1090
1091 lldb::SBBreakpoint
1092 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
1093                                          const lldb::SBFileSpec &source_file,
1094                                          const char *module_name)
1095 {
1096     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1097
1098     SBBreakpoint sb_bp;
1099     TargetSP target_sp(GetSP());
1100     if (target_sp && source_regex && source_regex[0])
1101     {
1102         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1103         RegularExpression regexp(source_regex);
1104         FileSpecList source_file_spec_list;
1105         const bool hardware = false;
1106         const LazyBool move_to_nearest_code = eLazyBoolCalculate;
1107         source_file_spec_list.Append (source_file.ref());
1108
1109         if (module_name && module_name[0])
1110         {
1111             FileSpecList module_spec_list;
1112             module_spec_list.Append (FileSpec (module_name, false));
1113
1114             *sb_bp = target_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false, hardware, move_to_nearest_code);
1115         }
1116         else
1117         {
1118             *sb_bp = target_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false, hardware, move_to_nearest_code);
1119         }
1120     }
1121
1122     if (log)
1123     {
1124         char path[PATH_MAX];
1125         source_file->GetPath (path, sizeof(path));
1126         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\", file=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
1127                      static_cast<void*>(target_sp.get()), source_regex, path,
1128                      module_name, static_cast<void*>(sb_bp.get()));
1129     }
1130
1131     return sb_bp;
1132 }
1133
1134 lldb::SBBreakpoint
1135 SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
1136                                                  const SBFileSpecList &module_list,
1137                                                  const lldb::SBFileSpecList &source_file_list)
1138 {
1139     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1140
1141     SBBreakpoint sb_bp;
1142     TargetSP target_sp(GetSP());
1143     if (target_sp && source_regex && source_regex[0])
1144     {
1145         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1146         const bool hardware = false;
1147         const LazyBool move_to_nearest_code = eLazyBoolCalculate;
1148         RegularExpression regexp(source_regex);
1149         *sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false, hardware, move_to_nearest_code);
1150     }
1151
1152     if (log)
1153         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)",
1154                      static_cast<void*>(target_sp.get()), source_regex,
1155                      static_cast<void*>(sb_bp.get()));
1156
1157     return sb_bp;
1158 }
1159
1160 lldb::SBBreakpoint
1161 SBTarget::BreakpointCreateForException  (lldb::LanguageType language,
1162                                          bool catch_bp,
1163                                          bool throw_bp)
1164 {
1165     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1166
1167     SBBreakpoint sb_bp;
1168     TargetSP target_sp(GetSP());
1169     if (target_sp)
1170     {
1171         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1172         const bool hardware = false;
1173         *sb_bp = target_sp->CreateExceptionBreakpoint (language, catch_bp, throw_bp, hardware);
1174     }
1175
1176     if (log)
1177         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: %s throw: %s) => SBBreakpoint(%p)",
1178                      static_cast<void*>(target_sp.get()),
1179                      Language::GetNameForLanguageType(language),
1180                      catch_bp ? "on" : "off", throw_bp ? "on" : "off",
1181                      static_cast<void*>(sb_bp.get()));
1182
1183     return sb_bp;
1184 }
1185
1186 uint32_t
1187 SBTarget::GetNumBreakpoints () const
1188 {
1189     TargetSP target_sp(GetSP());
1190     if (target_sp)
1191     {
1192         // The breakpoint list is thread safe, no need to lock
1193         return target_sp->GetBreakpointList().GetSize();
1194     }
1195     return 0;
1196 }
1197
1198 SBBreakpoint
1199 SBTarget::GetBreakpointAtIndex (uint32_t idx) const
1200 {
1201     SBBreakpoint sb_breakpoint;
1202     TargetSP target_sp(GetSP());
1203     if (target_sp)
1204     {
1205         // The breakpoint list is thread safe, no need to lock
1206         *sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
1207     }
1208     return sb_breakpoint;
1209 }
1210
1211 bool
1212 SBTarget::BreakpointDelete (break_id_t bp_id)
1213 {
1214     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1215
1216     bool result = false;
1217     TargetSP target_sp(GetSP());
1218     if (target_sp)
1219     {
1220         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1221         result = target_sp->RemoveBreakpointByID (bp_id);
1222     }
1223
1224     if (log)
1225         log->Printf ("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i",
1226                      static_cast<void*>(target_sp.get()),
1227                      static_cast<uint32_t>(bp_id), result);
1228
1229     return result;
1230 }
1231
1232 SBBreakpoint
1233 SBTarget::FindBreakpointByID (break_id_t bp_id)
1234 {
1235     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1236
1237     SBBreakpoint sb_breakpoint;
1238     TargetSP target_sp(GetSP());
1239     if (target_sp && bp_id != LLDB_INVALID_BREAK_ID)
1240     {
1241         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1242         *sb_breakpoint = target_sp->GetBreakpointByID (bp_id);
1243     }
1244
1245     if (log)
1246         log->Printf ("SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)",
1247                      static_cast<void*>(target_sp.get()),
1248                      static_cast<uint32_t>(bp_id),
1249                      static_cast<void*>(sb_breakpoint.get()));
1250
1251     return sb_breakpoint;
1252 }
1253
1254 bool
1255 SBTarget::EnableAllBreakpoints ()
1256 {
1257     TargetSP target_sp(GetSP());
1258     if (target_sp)
1259     {
1260         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1261         target_sp->EnableAllBreakpoints ();
1262         return true;
1263     }
1264     return false;
1265 }
1266
1267 bool
1268 SBTarget::DisableAllBreakpoints ()
1269 {
1270     TargetSP target_sp(GetSP());
1271     if (target_sp)
1272     {
1273         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1274         target_sp->DisableAllBreakpoints ();
1275         return true;
1276     }
1277     return false;
1278 }
1279
1280 bool
1281 SBTarget::DeleteAllBreakpoints ()
1282 {
1283     TargetSP target_sp(GetSP());
1284     if (target_sp)
1285     {
1286         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1287         target_sp->RemoveAllBreakpoints ();
1288         return true;
1289     }
1290     return false;
1291 }
1292
1293 uint32_t
1294 SBTarget::GetNumWatchpoints () const
1295 {
1296     TargetSP target_sp(GetSP());
1297     if (target_sp)
1298     {
1299         // The watchpoint list is thread safe, no need to lock
1300         return target_sp->GetWatchpointList().GetSize();
1301     }
1302     return 0;
1303 }
1304
1305 SBWatchpoint
1306 SBTarget::GetWatchpointAtIndex (uint32_t idx) const
1307 {
1308     SBWatchpoint sb_watchpoint;
1309     TargetSP target_sp(GetSP());
1310     if (target_sp)
1311     {
1312         // The watchpoint list is thread safe, no need to lock
1313         sb_watchpoint.SetSP (target_sp->GetWatchpointList().GetByIndex(idx));
1314     }
1315     return sb_watchpoint;
1316 }
1317
1318 bool
1319 SBTarget::DeleteWatchpoint (watch_id_t wp_id)
1320 {
1321     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1322
1323     bool result = false;
1324     TargetSP target_sp(GetSP());
1325     if (target_sp)
1326     {
1327         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1328         Mutex::Locker locker;
1329         target_sp->GetWatchpointList().GetListMutex(locker);
1330         result = target_sp->RemoveWatchpointByID (wp_id);
1331     }
1332
1333     if (log)
1334         log->Printf ("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i",
1335                      static_cast<void*>(target_sp.get()),
1336                      static_cast<uint32_t>(wp_id), result);
1337
1338     return result;
1339 }
1340
1341 SBWatchpoint
1342 SBTarget::FindWatchpointByID (lldb::watch_id_t wp_id)
1343 {
1344     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1345
1346     SBWatchpoint sb_watchpoint;
1347     lldb::WatchpointSP watchpoint_sp;
1348     TargetSP target_sp(GetSP());
1349     if (target_sp && wp_id != LLDB_INVALID_WATCH_ID)
1350     {
1351         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1352         Mutex::Locker locker;
1353         target_sp->GetWatchpointList().GetListMutex(locker);
1354         watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id);
1355         sb_watchpoint.SetSP (watchpoint_sp);
1356     }
1357
1358     if (log)
1359         log->Printf ("SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)",
1360                      static_cast<void*>(target_sp.get()),
1361                      static_cast<uint32_t>(wp_id),
1362                      static_cast<void*>(watchpoint_sp.get()));
1363
1364     return sb_watchpoint;
1365 }
1366
1367 lldb::SBWatchpoint
1368 SBTarget::WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write, SBError &error)
1369 {
1370     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1371
1372     SBWatchpoint sb_watchpoint;
1373     lldb::WatchpointSP watchpoint_sp;
1374     TargetSP target_sp(GetSP());
1375     if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && size > 0)
1376     {
1377         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1378         uint32_t watch_type = 0;
1379         if (read)
1380             watch_type |= LLDB_WATCH_TYPE_READ;
1381         if (write)
1382             watch_type |= LLDB_WATCH_TYPE_WRITE;
1383         if (watch_type == 0)
1384         {
1385             error.SetErrorString("Can't create a watchpoint that is neither read nor write.");
1386             return sb_watchpoint;
1387         }
1388
1389         // Target::CreateWatchpoint() is thread safe.
1390         Error cw_error;
1391         // This API doesn't take in a type, so we can't figure out what it is.
1392         CompilerType *type = NULL;
1393         watchpoint_sp = target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error);
1394         error.SetError(cw_error);
1395         sb_watchpoint.SetSP (watchpoint_sp);
1396     }
1397
1398     if (log)
1399         log->Printf ("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64 ", 0x%u) => SBWatchpoint(%p)",
1400                      static_cast<void*>(target_sp.get()), addr,
1401                      static_cast<uint32_t>(size),
1402                      static_cast<void*>(watchpoint_sp.get()));
1403
1404     return sb_watchpoint;
1405 }
1406
1407 bool
1408 SBTarget::EnableAllWatchpoints ()
1409 {
1410     TargetSP target_sp(GetSP());
1411     if (target_sp)
1412     {
1413         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1414         Mutex::Locker locker;
1415         target_sp->GetWatchpointList().GetListMutex(locker);
1416         target_sp->EnableAllWatchpoints ();
1417         return true;
1418     }
1419     return false;
1420 }
1421
1422 bool
1423 SBTarget::DisableAllWatchpoints ()
1424 {
1425     TargetSP target_sp(GetSP());
1426     if (target_sp)
1427     {
1428         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1429         Mutex::Locker locker;
1430         target_sp->GetWatchpointList().GetListMutex(locker);
1431         target_sp->DisableAllWatchpoints ();
1432         return true;
1433     }
1434     return false;
1435 }
1436
1437 SBValue
1438 SBTarget::CreateValueFromAddress (const char *name, SBAddress addr, SBType type)
1439 {
1440     SBValue sb_value;
1441     lldb::ValueObjectSP new_value_sp;
1442     if (IsValid() && name && *name && addr.IsValid() && type.IsValid())
1443     {
1444         lldb::addr_t load_addr(addr.GetLoadAddress(*this));
1445         ExecutionContext exe_ctx (ExecutionContextRef(ExecutionContext(m_opaque_sp.get(),false)));
1446         CompilerType ast_type(type.GetSP()->GetCompilerType(true));
1447         new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr, exe_ctx, ast_type);
1448     }
1449     sb_value.SetSP(new_value_sp);
1450     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1451     if (log)
1452     {
1453         if (new_value_sp)
1454             log->Printf ("SBTarget(%p)::CreateValueFromAddress => \"%s\"",
1455                          static_cast<void*>(m_opaque_sp.get()),
1456                          new_value_sp->GetName().AsCString());
1457         else
1458             log->Printf ("SBTarget(%p)::CreateValueFromAddress => NULL",
1459                          static_cast<void*>(m_opaque_sp.get()));
1460     }
1461     return sb_value;
1462 }
1463
1464 lldb::SBValue
1465 SBTarget::CreateValueFromData (const char *name, lldb::SBData data, lldb::SBType type)
1466 {
1467     SBValue sb_value;
1468     lldb::ValueObjectSP new_value_sp;
1469     if (IsValid() && name && *name && data.IsValid() && type.IsValid())
1470     {
1471         DataExtractorSP extractor(*data);
1472         ExecutionContext exe_ctx (ExecutionContextRef(ExecutionContext(m_opaque_sp.get(),false)));
1473         CompilerType ast_type(type.GetSP()->GetCompilerType(true));
1474         new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor, exe_ctx, ast_type);
1475     }
1476     sb_value.SetSP(new_value_sp);
1477     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1478     if (log)
1479     {
1480         if (new_value_sp)
1481             log->Printf ("SBTarget(%p)::CreateValueFromData => \"%s\"",
1482                          static_cast<void*>(m_opaque_sp.get()),
1483                          new_value_sp->GetName().AsCString());
1484         else
1485             log->Printf ("SBTarget(%p)::CreateValueFromData => NULL",
1486                          static_cast<void*>(m_opaque_sp.get()));
1487     }
1488     return sb_value;
1489 }
1490
1491 lldb::SBValue
1492 SBTarget::CreateValueFromExpression (const char *name, const char* expr)
1493 {
1494     SBValue sb_value;
1495     lldb::ValueObjectSP new_value_sp;
1496     if (IsValid() && name && *name && expr && *expr)
1497     {
1498         ExecutionContext exe_ctx (ExecutionContextRef(ExecutionContext(m_opaque_sp.get(),false)));
1499         new_value_sp = ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx);
1500     }
1501     sb_value.SetSP(new_value_sp);
1502     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1503     if (log)
1504     {
1505         if (new_value_sp)
1506             log->Printf ("SBTarget(%p)::CreateValueFromExpression => \"%s\"",
1507                          static_cast<void*>(m_opaque_sp.get()),
1508                          new_value_sp->GetName().AsCString());
1509         else
1510             log->Printf ("SBTarget(%p)::CreateValueFromExpression => NULL",
1511                          static_cast<void*>(m_opaque_sp.get()));
1512     }
1513     return sb_value;
1514 }
1515
1516 bool
1517 SBTarget::DeleteAllWatchpoints ()
1518 {
1519     TargetSP target_sp(GetSP());
1520     if (target_sp)
1521     {
1522         Mutex::Locker api_locker (target_sp->GetAPIMutex());
1523         Mutex::Locker locker;
1524         target_sp->GetWatchpointList().GetListMutex(locker);
1525         target_sp->RemoveAllWatchpoints ();
1526         return true;
1527     }
1528     return false;
1529 }
1530
1531
1532 lldb::SBModule
1533 SBTarget::AddModule (const char *path,
1534                      const char *triple,
1535                      const char *uuid_cstr)
1536 {
1537     return AddModule (path, triple, uuid_cstr, NULL);
1538 }
1539
1540 lldb::SBModule
1541 SBTarget::AddModule (const char *path,
1542                      const char *triple,
1543                      const char *uuid_cstr,
1544                      const char *symfile)
1545 {
1546     lldb::SBModule sb_module;
1547     TargetSP target_sp(GetSP());
1548     if (target_sp)
1549     {
1550         ModuleSpec module_spec;
1551         if (path)
1552             module_spec.GetFileSpec().SetFile(path, false);
1553
1554         if (uuid_cstr)
1555             module_spec.GetUUID().SetFromCString(uuid_cstr);
1556
1557         if (triple)
1558             module_spec.GetArchitecture().SetTriple (triple, target_sp->GetPlatform ().get());
1559         else
1560             module_spec.GetArchitecture() = target_sp->GetArchitecture();
1561
1562         if (symfile)
1563             module_spec.GetSymbolFileSpec ().SetFile(symfile, false);
1564
1565         sb_module.SetSP(target_sp->GetSharedModule (module_spec));
1566     }
1567     return sb_module;
1568 }
1569
1570 lldb::SBModule
1571 SBTarget::AddModule (const SBModuleSpec &module_spec)
1572 {
1573     lldb::SBModule sb_module;
1574     TargetSP target_sp(GetSP());
1575     if (target_sp)
1576         sb_module.SetSP(target_sp->GetSharedModule (*module_spec.m_opaque_ap));
1577     return sb_module;
1578 }
1579
1580 bool
1581 SBTarget::AddModule (lldb::SBModule &module)
1582 {
1583     TargetSP target_sp(GetSP());
1584     if (target_sp)
1585     {
1586         target_sp->GetImages().AppendIfNeeded (module.GetSP());
1587         return true;
1588     }
1589     return false;
1590 }
1591
1592 uint32_t
1593 SBTarget::GetNumModules () const
1594 {
1595     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1596
1597     uint32_t num = 0;
1598     TargetSP target_sp(GetSP());
1599     if (target_sp)
1600     {
1601         // The module list is thread safe, no need to lock
1602         num = target_sp->GetImages().GetSize();
1603     }
1604
1605     if (log)
1606         log->Printf ("SBTarget(%p)::GetNumModules () => %d",
1607                      static_cast<void*>(target_sp.get()), num);
1608
1609     return num;
1610 }
1611
1612 void
1613 SBTarget::Clear ()
1614 {
1615     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1616
1617     if (log)
1618         log->Printf ("SBTarget(%p)::Clear ()",
1619                      static_cast<void*>(m_opaque_sp.get()));
1620
1621     m_opaque_sp.reset();
1622 }
1623
1624
1625 SBModule
1626 SBTarget::FindModule (const SBFileSpec &sb_file_spec)
1627 {
1628     SBModule sb_module;
1629     TargetSP target_sp(GetSP());
1630     if (target_sp && sb_file_spec.IsValid())
1631     {
1632         ModuleSpec module_spec(*sb_file_spec);
1633         // The module list is thread safe, no need to lock
1634         sb_module.SetSP (target_sp->GetImages().FindFirstModule (module_spec));
1635     }
1636     return sb_module;
1637 }
1638
1639 lldb::ByteOrder
1640 SBTarget::GetByteOrder ()
1641 {
1642     TargetSP target_sp(GetSP());
1643     if (target_sp)
1644         return target_sp->GetArchitecture().GetByteOrder();
1645     return eByteOrderInvalid;
1646 }
1647
1648 const char *
1649 SBTarget::GetTriple ()
1650 {
1651     TargetSP target_sp(GetSP());
1652     if (target_sp)
1653     {
1654         std::string triple (target_sp->GetArchitecture().GetTriple().str());
1655         // Unique the string so we don't run into ownership issues since
1656         // the const strings put the string into the string pool once and
1657         // the strings never comes out
1658         ConstString const_triple (triple.c_str());
1659         return const_triple.GetCString();
1660     }
1661     return NULL;
1662 }
1663
1664 uint32_t
1665 SBTarget::GetDataByteSize ()
1666 {
1667     TargetSP target_sp(GetSP());
1668     if (target_sp)
1669     {
1670         return target_sp->GetArchitecture().GetDataByteSize() ;
1671     }
1672     return 0;
1673 }
1674
1675 uint32_t
1676 SBTarget::GetCodeByteSize ()
1677 {
1678     TargetSP target_sp(GetSP());
1679     if (target_sp)
1680     {
1681         return target_sp->GetArchitecture().GetCodeByteSize() ;
1682     }
1683     return 0;
1684 }
1685
1686 uint32_t
1687 SBTarget::GetAddressByteSize()
1688 {
1689     TargetSP target_sp(GetSP());
1690     if (target_sp)
1691         return target_sp->GetArchitecture().GetAddressByteSize();
1692     return sizeof(void*);
1693 }
1694
1695
1696 SBModule
1697 SBTarget::GetModuleAtIndex (uint32_t idx)
1698 {
1699     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1700
1701     SBModule sb_module;
1702     ModuleSP module_sp;
1703     TargetSP target_sp(GetSP());
1704     if (target_sp)
1705     {
1706         // The module list is thread safe, no need to lock
1707         module_sp = target_sp->GetImages().GetModuleAtIndex(idx);
1708         sb_module.SetSP (module_sp);
1709     }
1710
1711     if (log)
1712         log->Printf ("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)",
1713                      static_cast<void*>(target_sp.get()), idx,
1714                      static_cast<void*>(module_sp.get()));
1715
1716     return sb_module;
1717 }
1718
1719 bool
1720 SBTarget::RemoveModule (lldb::SBModule module)
1721 {
1722     TargetSP target_sp(GetSP());
1723     if (target_sp)
1724         return target_sp->GetImages().Remove(module.GetSP());
1725     return false;
1726 }
1727
1728
1729 SBBroadcaster
1730 SBTarget::GetBroadcaster () const
1731 {
1732     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1733
1734     TargetSP target_sp(GetSP());
1735     SBBroadcaster broadcaster(target_sp.get(), false);
1736
1737     if (log)
1738         log->Printf ("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)",
1739                      static_cast<void*>(target_sp.get()),
1740                      static_cast<void*>(broadcaster.get()));
1741
1742     return broadcaster;
1743 }
1744
1745 bool
1746 SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level)
1747 {
1748     Stream &strm = description.ref();
1749
1750     TargetSP target_sp(GetSP());
1751     if (target_sp)
1752     {
1753         target_sp->Dump (&strm, description_level);
1754     }
1755     else
1756         strm.PutCString ("No value");
1757
1758     return true;
1759 }
1760
1761 lldb::SBSymbolContextList
1762 SBTarget::FindFunctions (const char *name, uint32_t name_type_mask)
1763 {
1764     lldb::SBSymbolContextList sb_sc_list;
1765     if (name && name[0])
1766     {
1767         TargetSP target_sp(GetSP());
1768         if (target_sp)
1769         {
1770             const bool symbols_ok = true;
1771             const bool inlines_ok = true;
1772             const bool append = true;
1773             target_sp->GetImages().FindFunctions (ConstString(name),
1774                                                   name_type_mask,
1775                                                   symbols_ok,
1776                                                   inlines_ok,
1777                                                   append,
1778                                                   *sb_sc_list);
1779         }
1780     }
1781     return sb_sc_list;
1782 }
1783
1784 lldb::SBSymbolContextList
1785 SBTarget::FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype)
1786 {
1787     lldb::SBSymbolContextList sb_sc_list;
1788     if (name && name[0])
1789     {
1790         TargetSP target_sp(GetSP());
1791         if (target_sp)
1792         {
1793             std::string regexstr;
1794             switch (matchtype)
1795             {
1796             case eMatchTypeRegex:
1797                 target_sp->GetImages().FindFunctions(RegularExpression(name), true, true, true, *sb_sc_list);
1798                 break;
1799             case eMatchTypeStartsWith:
1800                 regexstr = llvm::Regex::escape(name) + ".*";
1801                 target_sp->GetImages().FindFunctions(RegularExpression(regexstr.c_str()), true, true, true, *sb_sc_list);
1802                 break;
1803             default:
1804                 target_sp->GetImages().FindFunctions(ConstString(name), eFunctionNameTypeAny, true, true, true, *sb_sc_list);
1805                 break;
1806             }
1807         }
1808     }
1809     return sb_sc_list;
1810 }
1811
1812 lldb::SBType
1813 SBTarget::FindFirstType (const char* typename_cstr)
1814 {
1815     TargetSP target_sp(GetSP());
1816     if (typename_cstr && typename_cstr[0] && target_sp)
1817     {
1818         ConstString const_typename(typename_cstr);
1819         SymbolContext sc;
1820         const bool exact_match = false;
1821
1822         const ModuleList &module_list = target_sp->GetImages();
1823         size_t count = module_list.GetSize();
1824         for (size_t idx = 0; idx < count; idx++)
1825         {
1826             ModuleSP module_sp (module_list.GetModuleAtIndex(idx));
1827             if (module_sp)
1828             {
1829                 TypeSP type_sp (module_sp->FindFirstType(sc, const_typename, exact_match));
1830                 if (type_sp)
1831                     return SBType(type_sp);
1832             }
1833         }
1834
1835         // Didn't find the type in the symbols; try the Objective-C runtime
1836         // if one is installed
1837
1838         ProcessSP process_sp(target_sp->GetProcessSP());
1839
1840         if (process_sp)
1841         {
1842             ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime();
1843
1844             if (objc_language_runtime)
1845             {
1846                 DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor();
1847
1848                 if (objc_decl_vendor)
1849                 {
1850                     std::vector <clang::NamedDecl *> decls;
1851
1852                     if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0)
1853                     {
1854                         if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0]))
1855                         {
1856                             return SBType(type);
1857                         }
1858                     }
1859                 }
1860             }
1861         }
1862
1863         // No matches, search for basic typename matches
1864         ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
1865         if (clang_ast)
1866             return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename));
1867     }
1868     return SBType();
1869 }
1870
1871 SBType
1872 SBTarget::GetBasicType(lldb::BasicType type)
1873 {
1874     TargetSP target_sp(GetSP());
1875     if (target_sp)
1876     {
1877         ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
1878         if (clang_ast)
1879             return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), type));
1880     }
1881     return SBType();
1882 }
1883
1884
1885 lldb::SBTypeList
1886 SBTarget::FindTypes (const char* typename_cstr)
1887 {
1888     SBTypeList sb_type_list;
1889     TargetSP target_sp(GetSP());
1890     if (typename_cstr && typename_cstr[0] && target_sp)
1891     {
1892         ModuleList& images = target_sp->GetImages();
1893         ConstString const_typename(typename_cstr);
1894         bool exact_match = false;
1895         SymbolContext sc;
1896         TypeList type_list;
1897
1898         uint32_t num_matches = images.FindTypes (sc,
1899                                                  const_typename,
1900                                                  exact_match,
1901                                                  UINT32_MAX,
1902                                                  type_list);
1903
1904         if (num_matches > 0)
1905         {
1906             for (size_t idx = 0; idx < num_matches; idx++)
1907             {
1908                 TypeSP type_sp (type_list.GetTypeAtIndex(idx));
1909                 if (type_sp)
1910                     sb_type_list.Append(SBType(type_sp));
1911             }
1912         }
1913
1914         // Try the Objective-C runtime if one is installed
1915
1916         ProcessSP process_sp(target_sp->GetProcessSP());
1917
1918         if (process_sp)
1919         {
1920             ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime();
1921
1922             if (objc_language_runtime)
1923             {
1924                 DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor();
1925
1926                 if (objc_decl_vendor)
1927                 {
1928                     std::vector <clang::NamedDecl *> decls;
1929
1930                     if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0)
1931                     {
1932                         for (clang::NamedDecl *decl : decls)
1933                         {
1934                             if (CompilerType type = ClangASTContext::GetTypeForDecl(decl))
1935                             {
1936                                 sb_type_list.Append(SBType(type));
1937                             }
1938                         }
1939                     }
1940                 }
1941             }
1942         }
1943
1944         if (sb_type_list.GetSize() == 0)
1945         {
1946             // No matches, search for basic typename matches
1947             ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
1948             if (clang_ast)
1949                 sb_type_list.Append (SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename)));
1950         }
1951     }
1952     return sb_type_list;
1953 }
1954
1955 SBValueList
1956 SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches)
1957 {
1958     SBValueList sb_value_list;
1959
1960     TargetSP target_sp(GetSP());
1961     if (name && target_sp)
1962     {
1963         VariableList variable_list;
1964         const bool append = true;
1965         const uint32_t match_count = target_sp->GetImages().FindGlobalVariables (ConstString (name),
1966                                                                                  append,
1967                                                                                  max_matches,
1968                                                                                  variable_list);
1969
1970         if (match_count > 0)
1971         {
1972             ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
1973             if (exe_scope == NULL)
1974                 exe_scope = target_sp.get();
1975             for (uint32_t i=0; i<match_count; ++i)
1976             {
1977                 lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i)));
1978                 if (valobj_sp)
1979                     sb_value_list.Append(SBValue(valobj_sp));
1980             }
1981         }
1982     }
1983
1984     return sb_value_list;
1985 }
1986
1987 SBValueList
1988 SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches, MatchType matchtype)
1989 {
1990     SBValueList sb_value_list;
1991
1992     TargetSP target_sp(GetSP());
1993     if (name && target_sp)
1994     {
1995         VariableList variable_list;
1996         const bool append = true;
1997
1998         std::string regexstr;
1999         uint32_t match_count;
2000         switch (matchtype)
2001         {
2002         case eMatchTypeNormal:
2003             match_count = target_sp->GetImages().FindGlobalVariables(ConstString(name),
2004                 append,
2005                 max_matches,
2006                 variable_list);
2007             break;
2008         case eMatchTypeRegex:
2009             match_count = target_sp->GetImages().FindGlobalVariables(RegularExpression(name),
2010                 append,
2011                 max_matches,
2012                 variable_list);
2013             break;
2014         case eMatchTypeStartsWith:
2015             regexstr = llvm::Regex::escape(name) + ".*";
2016             match_count = target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr.c_str()),
2017                 append,
2018                 max_matches,
2019                 variable_list);
2020             break;
2021         }
2022
2023
2024         if (match_count > 0)
2025         {
2026             ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
2027             if (exe_scope == NULL)
2028                 exe_scope = target_sp.get();
2029             for (uint32_t i = 0; i<match_count; ++i)
2030             {
2031                 lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create(exe_scope, variable_list.GetVariableAtIndex(i)));
2032                 if (valobj_sp)
2033                     sb_value_list.Append(SBValue(valobj_sp));
2034             }
2035         }
2036     }
2037
2038     return sb_value_list;
2039 }
2040
2041
2042 lldb::SBValue
2043 SBTarget::FindFirstGlobalVariable (const char* name)
2044 {
2045     SBValueList sb_value_list(FindGlobalVariables(name, 1));
2046     if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
2047         return sb_value_list.GetValueAtIndex(0);
2048     return SBValue();
2049 }
2050
2051 SBSourceManager
2052 SBTarget::GetSourceManager()
2053 {
2054     SBSourceManager source_manager (*this);
2055     return source_manager;
2056 }
2057
2058 lldb::SBInstructionList
2059 SBTarget::ReadInstructions (lldb::SBAddress base_addr, uint32_t count)
2060 {
2061     return ReadInstructions (base_addr, count, NULL);
2062 }
2063
2064 lldb::SBInstructionList
2065 SBTarget::ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string)
2066 {
2067     SBInstructionList sb_instructions;
2068
2069     TargetSP target_sp(GetSP());
2070     if (target_sp)
2071     {
2072         Address *addr_ptr = base_addr.get();
2073
2074         if (addr_ptr)
2075         {
2076             DataBufferHeap data (target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
2077             bool prefer_file_cache = false;
2078             lldb_private::Error error;
2079             lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
2080             const size_t bytes_read = target_sp->ReadMemory(*addr_ptr,
2081                                                             prefer_file_cache,
2082                                                             data.GetBytes(),
2083                                                             data.GetByteSize(),
2084                                                             error,
2085                                                             &load_addr);
2086             const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
2087             sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(),
2088                                                                              NULL,
2089                                                                              flavor_string,
2090                                                                              *addr_ptr,
2091                                                                              data.GetBytes(),
2092                                                                              bytes_read,
2093                                                                              count,
2094                                                                              data_from_file));
2095         }
2096     }
2097
2098     return sb_instructions;
2099
2100 }
2101
2102 lldb::SBInstructionList
2103 SBTarget::GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size)
2104 {
2105     return GetInstructionsWithFlavor (base_addr, NULL, buf, size);
2106 }
2107
2108 lldb::SBInstructionList
2109 SBTarget::GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size)
2110 {
2111     SBInstructionList sb_instructions;
2112
2113     TargetSP target_sp(GetSP());
2114     if (target_sp)
2115     {
2116         Address addr;
2117
2118         if (base_addr.get())
2119             addr = *base_addr.get();
2120
2121         const bool data_from_file = true;
2122
2123         sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(),
2124                                                                          NULL,
2125                                                                          flavor_string,
2126                                                                          addr,
2127                                                                          buf,
2128                                                                          size,
2129                                                                          UINT32_MAX,
2130                                                                          data_from_file));
2131     }
2132
2133     return sb_instructions;
2134 }
2135
2136 lldb::SBInstructionList
2137 SBTarget::GetInstructions (lldb::addr_t base_addr, const void *buf, size_t size)
2138 {
2139     return GetInstructionsWithFlavor (ResolveLoadAddress(base_addr), NULL, buf, size);
2140 }
2141
2142 lldb::SBInstructionList
2143 SBTarget::GetInstructionsWithFlavor (lldb::addr_t base_addr, const char *flavor_string, const void *buf, size_t size)
2144 {
2145     return GetInstructionsWithFlavor (ResolveLoadAddress(base_addr), flavor_string, buf, size);
2146 }
2147
2148 SBError
2149 SBTarget::SetSectionLoadAddress (lldb::SBSection section,
2150                                  lldb::addr_t section_base_addr)
2151 {
2152     SBError sb_error;
2153     TargetSP target_sp(GetSP());
2154     if (target_sp)
2155     {
2156         if (!section.IsValid())
2157         {
2158             sb_error.SetErrorStringWithFormat ("invalid section");
2159         }
2160         else
2161         {
2162             SectionSP section_sp (section.GetSP());
2163             if (section_sp)
2164             {
2165                 if (section_sp->IsThreadSpecific())
2166                 {
2167                     sb_error.SetErrorString ("thread specific sections are not yet supported");
2168                 }
2169                 else
2170                 {
2171                     ProcessSP process_sp (target_sp->GetProcessSP());
2172                     if (target_sp->SetSectionLoadAddress (section_sp, section_base_addr))
2173                     {
2174                         // Flush info in the process (stack frames, etc)
2175                         if (process_sp)
2176                             process_sp->Flush();
2177                     }
2178                 }
2179             }
2180         }
2181     }
2182     else
2183     {
2184         sb_error.SetErrorString ("invalid target");
2185     }
2186     return sb_error;
2187 }
2188
2189 SBError
2190 SBTarget::ClearSectionLoadAddress (lldb::SBSection section)
2191 {
2192     SBError sb_error;
2193
2194     TargetSP target_sp(GetSP());
2195     if (target_sp)
2196     {
2197         if (!section.IsValid())
2198         {
2199             sb_error.SetErrorStringWithFormat ("invalid section");
2200         }
2201         else
2202         {
2203             ProcessSP process_sp (target_sp->GetProcessSP());
2204             if (target_sp->SetSectionUnloaded (section.GetSP()))
2205             {
2206                 // Flush info in the process (stack frames, etc)
2207                 if (process_sp)
2208                     process_sp->Flush();
2209             }
2210         }
2211     }
2212     else
2213     {
2214         sb_error.SetErrorStringWithFormat ("invalid target");
2215     }
2216     return sb_error;
2217 }
2218
2219 SBError
2220 SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset)
2221 {
2222     SBError sb_error;
2223
2224     TargetSP target_sp(GetSP());
2225     if (target_sp)
2226     {
2227         ModuleSP module_sp (module.GetSP());
2228         if (module_sp)
2229         {
2230             bool changed = false;
2231             if (module_sp->SetLoadAddress (*target_sp, slide_offset, true, changed))
2232             {
2233                 // The load was successful, make sure that at least some sections
2234                 // changed before we notify that our module was loaded.
2235                 if (changed)
2236                 {
2237                     ModuleList module_list;
2238                     module_list.Append(module_sp);
2239                     target_sp->ModulesDidLoad (module_list);
2240                     // Flush info in the process (stack frames, etc)
2241                     ProcessSP process_sp (target_sp->GetProcessSP());
2242                     if (process_sp)
2243                         process_sp->Flush();
2244                 }
2245             }
2246         }
2247         else
2248         {
2249             sb_error.SetErrorStringWithFormat ("invalid module");
2250         }
2251
2252     }
2253     else
2254     {
2255         sb_error.SetErrorStringWithFormat ("invalid target");
2256     }
2257     return sb_error;
2258 }
2259
2260 SBError
2261 SBTarget::ClearModuleLoadAddress (lldb::SBModule module)
2262 {
2263     SBError sb_error;
2264
2265     char path[PATH_MAX];
2266     TargetSP target_sp(GetSP());
2267     if (target_sp)
2268     {
2269         ModuleSP module_sp (module.GetSP());
2270         if (module_sp)
2271         {
2272             ObjectFile *objfile = module_sp->GetObjectFile();
2273             if (objfile)
2274             {
2275                 SectionList *section_list = objfile->GetSectionList();
2276                 if (section_list)
2277                 {
2278                     ProcessSP process_sp (target_sp->GetProcessSP());
2279
2280                     bool changed = false;
2281                     const size_t num_sections = section_list->GetSize();
2282                     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
2283                     {
2284                         SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx));
2285                         if (section_sp)
2286                             changed |= target_sp->SetSectionUnloaded (section_sp);
2287                     }
2288                     if (changed)
2289                     {
2290                         // Flush info in the process (stack frames, etc)
2291                         ProcessSP process_sp (target_sp->GetProcessSP());
2292                         if (process_sp)
2293                             process_sp->Flush();
2294                     }
2295                 }
2296                 else
2297                 {
2298                     module_sp->GetFileSpec().GetPath (path, sizeof(path));
2299                     sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path);
2300                 }
2301             }
2302             else
2303             {
2304                 module_sp->GetFileSpec().GetPath (path, sizeof(path));
2305                 sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path);
2306             }
2307         }
2308         else
2309         {
2310             sb_error.SetErrorStringWithFormat ("invalid module");
2311         }
2312     }
2313     else
2314     {
2315         sb_error.SetErrorStringWithFormat ("invalid target");
2316     }
2317     return sb_error;
2318 }
2319
2320
2321 lldb::SBSymbolContextList
2322 SBTarget::FindSymbols (const char *name, lldb::SymbolType symbol_type)
2323 {
2324     SBSymbolContextList sb_sc_list;
2325     if (name && name[0])
2326     {
2327         TargetSP target_sp(GetSP());
2328         if (target_sp)
2329         {
2330             bool append = true;
2331             target_sp->GetImages().FindSymbolsWithNameAndType (ConstString(name),
2332                                                                symbol_type,
2333                                                                *sb_sc_list,
2334                                                                append);
2335         }
2336     }
2337     return sb_sc_list;
2338
2339 }
2340
2341 lldb::SBValue
2342 SBTarget::EvaluateExpression (const char *expr)
2343 {
2344     TargetSP target_sp(GetSP());
2345     if (!target_sp)
2346         return SBValue();
2347
2348     SBExpressionOptions options;
2349     lldb::DynamicValueType fetch_dynamic_value = target_sp->GetPreferDynamicValue();
2350     options.SetFetchDynamicValue (fetch_dynamic_value);
2351     options.SetUnwindOnError (true);
2352     return EvaluateExpression(expr, options);
2353 }
2354
2355 lldb::SBValue
2356 SBTarget::EvaluateExpression (const char *expr, const SBExpressionOptions &options)
2357 {
2358     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
2359     Log * expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2360     SBValue expr_result;
2361     ExpressionResults exe_results = eExpressionSetupError;
2362     ValueObjectSP expr_value_sp;
2363     TargetSP target_sp(GetSP());
2364     StackFrame *frame = NULL;
2365     if (target_sp)
2366     {
2367         if (expr == NULL || expr[0] == '\0')
2368         {
2369             if (log)
2370                 log->Printf ("SBTarget::EvaluateExpression called with an empty expression");
2371             return expr_result;
2372         }
2373
2374         Mutex::Locker api_locker (target_sp->GetAPIMutex());
2375         ExecutionContext exe_ctx (m_opaque_sp.get());
2376
2377         if (log)
2378             log->Printf ("SBTarget()::EvaluateExpression (expr=\"%s\")...", expr);
2379
2380         frame = exe_ctx.GetFramePtr();
2381         Target *target = exe_ctx.GetTargetPtr();
2382
2383         if (target)
2384         {
2385 #ifdef LLDB_CONFIGURATION_DEBUG
2386             StreamString frame_description;
2387             if (frame)
2388                 frame->DumpUsingSettingsFormat (&frame_description);
2389             Host::SetCrashDescriptionWithFormat ("SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s",
2390                                                  expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str());
2391 #endif
2392             exe_results = target->EvaluateExpression (expr,
2393                                                       frame,
2394                                                       expr_value_sp,
2395                                                       options.ref());
2396
2397             expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
2398 #ifdef LLDB_CONFIGURATION_DEBUG
2399             Host::SetCrashDescription (NULL);
2400 #endif
2401         }
2402         else
2403         {
2404             if (log)
2405                 log->Printf ("SBTarget::EvaluateExpression () => error: could not reconstruct frame object for this SBTarget.");
2406         }
2407     }
2408 #ifndef LLDB_DISABLE_PYTHON
2409     if (expr_log)
2410         expr_log->Printf("** [SBTarget::EvaluateExpression] Expression result is %s, summary %s **",
2411                          expr_result.GetValue(), expr_result.GetSummary());
2412
2413     if (log)
2414         log->Printf ("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) (execution result=%d)",
2415                      static_cast<void*>(frame), expr,
2416                      static_cast<void*>(expr_value_sp.get()), exe_results);
2417 #endif
2418
2419     return expr_result;
2420 }
2421
2422
2423 lldb::addr_t
2424 SBTarget::GetStackRedZoneSize()
2425 {
2426     TargetSP target_sp(GetSP());
2427     if (target_sp)
2428     {
2429         ABISP abi_sp;
2430         ProcessSP process_sp (target_sp->GetProcessSP());
2431         if (process_sp)
2432             abi_sp = process_sp->GetABI();
2433         else
2434             abi_sp = ABI::FindPlugin(target_sp->GetArchitecture());
2435         if (abi_sp)
2436             return abi_sp->GetRedZoneSize();
2437     }
2438     return 0;
2439 }
2440
2441 lldb::SBLaunchInfo
2442 SBTarget::GetLaunchInfo () const
2443 {
2444     lldb::SBLaunchInfo launch_info(NULL);
2445     TargetSP target_sp(GetSP());
2446     if (target_sp)
2447         launch_info.ref() = m_opaque_sp->GetProcessLaunchInfo();
2448     return launch_info;
2449 }
2450
2451 void
2452 SBTarget::SetLaunchInfo (const lldb::SBLaunchInfo &launch_info)
2453 {
2454     TargetSP target_sp(GetSP());
2455     if (target_sp)
2456         m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
2457 }