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