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