diff options
Diffstat (limited to 'source/API/SBTarget.cpp')
| -rw-r--r-- | source/API/SBTarget.cpp | 4087 |
1 files changed, 1881 insertions, 2206 deletions
diff --git a/source/API/SBTarget.cpp b/source/API/SBTarget.cpp index 6a5301b06053..c000bf94c234 100644 --- a/source/API/SBTarget.cpp +++ b/source/API/SBTarget.cpp @@ -19,8 +19,8 @@ #include "lldb/API/SBListener.h" #include "lldb/API/SBModule.h" #include "lldb/API/SBModuleSpec.h" -#include "lldb/API/SBSourceManager.h" #include "lldb/API/SBProcess.h" +#include "lldb/API/SBSourceManager.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBStringList.h" #include "lldb/API/SBSymbolContextList.h" @@ -38,9 +38,9 @@ #include "lldb/Core/Module.h" #include "lldb/Core/ModuleSpec.h" #include "lldb/Core/RegularExpression.h" +#include "lldb/Core/STLUtils.h" #include "lldb/Core/SearchFilter.h" #include "lldb/Core/Section.h" -#include "lldb/Core/STLUtils.h" #include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectVariable.h" @@ -62,11 +62,11 @@ #include "lldb/Target/Target.h" #include "lldb/Target/TargetList.h" -#include "lldb/Interpreter/CommandReturnObject.h" #include "../source/Commands/CommandObjectBreakpoint.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/Regex.h" - using namespace lldb; using namespace lldb_private; @@ -74,2444 +74,2119 @@ using namespace lldb_private; namespace { -Error -AttachToProcess (ProcessAttachInfo &attach_info, Target &target) -{ - std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex()); +Error AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { + std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex()); - auto process_sp = target.GetProcessSP (); - if (process_sp) - { - const auto state = process_sp->GetState (); - if (process_sp->IsAlive () && state == eStateConnected) - { - // If we are already connected, then we have already specified the - // listener, so if a valid listener is supplied, we need to error out - // to let the client know. - if (attach_info.GetListener ()) - return Error ("process is connected and already has a listener, pass empty listener"); - } + auto process_sp = target.GetProcessSP(); + if (process_sp) { + const auto state = process_sp->GetState(); + if (process_sp->IsAlive() && state == eStateConnected) { + // If we are already connected, then we have already specified the + // listener, so if a valid listener is supplied, we need to error out + // to let the client know. + if (attach_info.GetListener()) + return Error("process is connected and already has a listener, pass " + "empty listener"); } + } - return target.Attach (attach_info, nullptr); + return target.Attach(attach_info, nullptr); } -} // namespace +} // namespace //---------------------------------------------------------------------- // SBTarget constructor //---------------------------------------------------------------------- -SBTarget::SBTarget () : - m_opaque_sp () -{ -} +SBTarget::SBTarget() : m_opaque_sp() {} -SBTarget::SBTarget (const SBTarget& rhs) : - m_opaque_sp (rhs.m_opaque_sp) -{ -} +SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {} -SBTarget::SBTarget(const TargetSP& target_sp) : - m_opaque_sp (target_sp) -{ -} +SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {} -const SBTarget& -SBTarget::operator = (const SBTarget& rhs) -{ - if (this != &rhs) - m_opaque_sp = rhs.m_opaque_sp; - return *this; +const SBTarget &SBTarget::operator=(const SBTarget &rhs) { + if (this != &rhs) + m_opaque_sp = rhs.m_opaque_sp; + return *this; } //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- -SBTarget::~SBTarget() -{ -} +SBTarget::~SBTarget() {} -bool -SBTarget::EventIsTargetEvent (const SBEvent &event) -{ - return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL; +bool SBTarget::EventIsTargetEvent(const SBEvent &event) { + return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL; } -SBTarget -SBTarget::GetTargetFromEvent (const SBEvent &event) -{ - return Target::TargetEventData::GetTargetFromEvent (event.get()); +SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) { + return Target::TargetEventData::GetTargetFromEvent(event.get()); } -uint32_t -SBTarget::GetNumModulesFromEvent (const SBEvent &event) -{ - const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent (event.get()); - return module_list.GetSize(); +uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { + const ModuleList module_list = + Target::TargetEventData::GetModuleListFromEvent(event.get()); + return module_list.GetSize(); } -SBModule -SBTarget::GetModuleAtIndexFromEvent (const uint32_t idx, const SBEvent &event) -{ - const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent (event.get()); - return SBModule(module_list.GetModuleAtIndex(idx)); +SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx, + const SBEvent &event) { + const ModuleList module_list = + Target::TargetEventData::GetModuleListFromEvent(event.get()); + return SBModule(module_list.GetModuleAtIndex(idx)); } -const char * -SBTarget::GetBroadcasterClassName () -{ - return Target::GetStaticBroadcasterClass().AsCString(); +const char *SBTarget::GetBroadcasterClassName() { + return Target::GetStaticBroadcasterClass().AsCString(); } -bool -SBTarget::IsValid () const -{ - return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid(); +bool SBTarget::IsValid() const { + return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid(); } -SBProcess -SBTarget::GetProcess () -{ - SBProcess sb_process; - ProcessSP process_sp; - TargetSP target_sp(GetSP()); - if (target_sp) - { - process_sp = target_sp->GetProcessSP(); - sb_process.SetSP (process_sp); - } +SBProcess SBTarget::GetProcess() { + SBProcess sb_process; + ProcessSP process_sp; + TargetSP target_sp(GetSP()); + if (target_sp) { + process_sp = target_sp->GetProcessSP(); + sb_process.SetSP(process_sp); + } - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - if (log) - log->Printf ("SBTarget(%p)::GetProcess () => SBProcess(%p)", - static_cast<void*>(target_sp.get()), - static_cast<void*>(process_sp.get())); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + if (log) + log->Printf("SBTarget(%p)::GetProcess () => SBProcess(%p)", + static_cast<void *>(target_sp.get()), + static_cast<void *>(process_sp.get())); - return sb_process; + return sb_process; } -SBPlatform -SBTarget::GetPlatform () -{ - TargetSP target_sp(GetSP()); - if (!target_sp) - return SBPlatform(); +SBPlatform SBTarget::GetPlatform() { + TargetSP target_sp(GetSP()); + if (!target_sp) + return SBPlatform(); - SBPlatform platform; - platform.m_opaque_sp = target_sp->GetPlatform(); + SBPlatform platform; + platform.m_opaque_sp = target_sp->GetPlatform(); - return platform; + return platform; } -SBDebugger -SBTarget::GetDebugger () const -{ - SBDebugger debugger; - TargetSP target_sp(GetSP()); - if (target_sp) - debugger.reset (target_sp->GetDebugger().shared_from_this()); - return debugger; +SBDebugger SBTarget::GetDebugger() const { + SBDebugger debugger; + TargetSP target_sp(GetSP()); + if (target_sp) + debugger.reset(target_sp->GetDebugger().shared_from_this()); + return debugger; } -SBProcess -SBTarget::LoadCore (const char *core_file) -{ - SBProcess sb_process; - TargetSP target_sp(GetSP()); - if (target_sp) - { - FileSpec filespec(core_file, true); - ProcessSP process_sp (target_sp->CreateProcess(target_sp->GetDebugger().GetListener(), - NULL, - &filespec)); - if (process_sp) - { - process_sp->LoadCore(); - sb_process.SetSP (process_sp); - } - } - return sb_process; -} - -SBProcess -SBTarget::LaunchSimple -( - char const **argv, - char const **envp, - const char *working_directory -) -{ - char *stdin_path = NULL; - char *stdout_path = NULL; - char *stderr_path = NULL; - uint32_t launch_flags = 0; - bool stop_at_entry = false; - SBError error; - SBListener listener = GetDebugger().GetListener(); - return Launch (listener, - argv, - envp, - stdin_path, - stdout_path, - stderr_path, - working_directory, - launch_flags, - stop_at_entry, - error); -} - -SBError -SBTarget::Install() -{ - SBError sb_error; - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - sb_error.ref() = target_sp->Install(NULL); +SBProcess SBTarget::LoadCore(const char *core_file) { + SBProcess sb_process; + TargetSP target_sp(GetSP()); + if (target_sp) { + FileSpec filespec(core_file, true); + ProcessSP process_sp(target_sp->CreateProcess( + target_sp->GetDebugger().GetListener(), "", &filespec)); + if (process_sp) { + process_sp->LoadCore(); + sb_process.SetSP(process_sp); } - return sb_error; -} - -SBProcess -SBTarget::Launch -( - SBListener &listener, - char const **argv, - char const **envp, - const char *stdin_path, - const char *stdout_path, - const char *stderr_path, - const char *working_directory, - uint32_t launch_flags, // See LaunchFlags - bool stop_at_entry, - lldb::SBError& error -) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBProcess sb_process; - ProcessSP process_sp; - TargetSP target_sp(GetSP()); - - if (log) - 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))...", - static_cast<void*>(target_sp.get()), - static_cast<void*>(argv), static_cast<void*>(envp), - stdin_path ? stdin_path : "NULL", - stdout_path ? stdout_path : "NULL", - stderr_path ? stderr_path : "NULL", - working_directory ? working_directory : "NULL", - launch_flags, stop_at_entry, - static_cast<void*>(error.get())); - - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - - if (stop_at_entry) - launch_flags |= eLaunchFlagStopAtEntry; - - if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) - launch_flags |= eLaunchFlagDisableASLR; - - StateType state = eStateInvalid; - process_sp = target_sp->GetProcessSP(); - if (process_sp) - { - state = process_sp->GetState(); - - if (process_sp->IsAlive() && state != eStateConnected) - { - if (state == eStateAttaching) - error.SetErrorString ("process attach is in progress"); - else - error.SetErrorString ("a process is already being debugged"); - return sb_process; - } - } - - if (state == eStateConnected) - { - // If we are already connected, then we have already specified the - // listener, so if a valid listener is supplied, we need to error out - // to let the client know. - if (listener.IsValid()) - { - error.SetErrorString ("process is connected and already has a listener, pass empty listener"); - return sb_process; - } - } - - if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) - launch_flags |= eLaunchFlagDisableSTDIO; - - ProcessLaunchInfo launch_info(FileSpec{stdin_path, false}, - FileSpec{stdout_path, false}, - FileSpec{stderr_path, false}, - FileSpec{working_directory, false}, - launch_flags); - - Module *exe_module = target_sp->GetExecutableModulePointer(); - if (exe_module) - launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); - if (argv) - launch_info.GetArguments().AppendArguments (argv); - if (envp) - launch_info.GetEnvironmentEntries ().SetArguments (envp); - - if (listener.IsValid()) - launch_info.SetListener(listener.GetSP()); - - error.SetError (target_sp->Launch(launch_info, NULL)); - - sb_process.SetSP(target_sp->GetProcessSP()); - } - else - { - error.SetErrorString ("SBTarget is invalid"); - } - - log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API); - if (log) - log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p), SBError(%s)", static_cast<void *>(target_sp.get()), - static_cast<void *>(sb_process.GetSP().get()), error.GetCString()); - - return sb_process; + } + return sb_process; } -SBProcess -SBTarget::Launch (SBLaunchInfo &sb_launch_info, SBError& error) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBProcess sb_process; - TargetSP target_sp(GetSP()); +SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, + const char *working_directory) { + char *stdin_path = NULL; + char *stdout_path = NULL; + char *stderr_path = NULL; + uint32_t launch_flags = 0; + bool stop_at_entry = false; + SBError error; + SBListener listener = GetDebugger().GetListener(); + return Launch(listener, argv, envp, stdin_path, stdout_path, stderr_path, + working_directory, launch_flags, stop_at_entry, error); +} - if (log) - log->Printf ("SBTarget(%p)::Launch (launch_info, error)...", - static_cast<void*>(target_sp.get())); +SBError SBTarget::Install() { + SBError sb_error; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + sb_error.ref() = target_sp->Install(NULL); + } + return sb_error; +} - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - StateType state = eStateInvalid; - { - ProcessSP process_sp = target_sp->GetProcessSP(); - if (process_sp) - { - state = process_sp->GetState(); - - if (process_sp->IsAlive() && state != eStateConnected) - { - if (state == eStateAttaching) - error.SetErrorString ("process attach is in progress"); - else - error.SetErrorString ("a process is already being debugged"); - return sb_process; - } - } +SBProcess SBTarget::Launch(SBListener &listener, char const **argv, + char const **envp, const char *stdin_path, + const char *stdout_path, const char *stderr_path, + const char *working_directory, + uint32_t launch_flags, // See LaunchFlags + bool stop_at_entry, lldb::SBError &error) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBProcess sb_process; + ProcessSP process_sp; + TargetSP target_sp(GetSP()); + + if (log) + 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))...", + static_cast<void *>(target_sp.get()), static_cast<void *>(argv), + static_cast<void *>(envp), stdin_path ? stdin_path : "NULL", + stdout_path ? stdout_path : "NULL", + stderr_path ? stderr_path : "NULL", + working_directory ? working_directory : "NULL", launch_flags, + stop_at_entry, static_cast<void *>(error.get())); + + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + if (stop_at_entry) + launch_flags |= eLaunchFlagStopAtEntry; + + if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) + launch_flags |= eLaunchFlagDisableASLR; + + StateType state = eStateInvalid; + process_sp = target_sp->GetProcessSP(); + if (process_sp) { + state = process_sp->GetState(); + + if (process_sp->IsAlive() && state != eStateConnected) { + if (state == eStateAttaching) + error.SetErrorString("process attach is in progress"); + else + error.SetErrorString("a process is already being debugged"); + return sb_process; + } + } + + if (state == eStateConnected) { + // If we are already connected, then we have already specified the + // listener, so if a valid listener is supplied, we need to error out + // to let the client know. + if (listener.IsValid()) { + error.SetErrorString("process is connected and already has a listener, " + "pass empty listener"); + return sb_process; + } + } + + if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) + launch_flags |= eLaunchFlagDisableSTDIO; + + ProcessLaunchInfo launch_info( + FileSpec{stdin_path, false}, FileSpec{stdout_path, false}, + FileSpec{stderr_path, false}, FileSpec{working_directory, false}, + launch_flags); + + Module *exe_module = target_sp->GetExecutableModulePointer(); + if (exe_module) + launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); + if (argv) + launch_info.GetArguments().AppendArguments(argv); + if (envp) + launch_info.GetEnvironmentEntries().SetArguments(envp); + + if (listener.IsValid()) + launch_info.SetListener(listener.GetSP()); + + error.SetError(target_sp->Launch(launch_info, NULL)); + + sb_process.SetSP(target_sp->GetProcessSP()); + } else { + error.SetErrorString("SBTarget is invalid"); + } + + log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API); + if (log) + log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p), SBError(%s)", + static_cast<void *>(target_sp.get()), + static_cast<void *>(sb_process.GetSP().get()), + error.GetCString()); + + return sb_process; +} + +SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + + if (log) + log->Printf("SBTarget(%p)::Launch (launch_info, error)...", + static_cast<void *>(target_sp.get())); + + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + StateType state = eStateInvalid; + { + ProcessSP process_sp = target_sp->GetProcessSP(); + if (process_sp) { + state = process_sp->GetState(); + + if (process_sp->IsAlive() && state != eStateConnected) { + if (state == eStateAttaching) + error.SetErrorString("process attach is in progress"); + else + error.SetErrorString("a process is already being debugged"); + return sb_process; } + } + } - lldb_private::ProcessLaunchInfo &launch_info = sb_launch_info.ref(); + lldb_private::ProcessLaunchInfo &launch_info = sb_launch_info.ref(); - if (!launch_info.GetExecutableFile()) - { - Module *exe_module = target_sp->GetExecutableModulePointer(); - if (exe_module) - launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); - } + if (!launch_info.GetExecutableFile()) { + Module *exe_module = target_sp->GetExecutableModulePointer(); + if (exe_module) + launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); + } - const ArchSpec &arch_spec = target_sp->GetArchitecture(); - if (arch_spec.IsValid()) - launch_info.GetArchitecture () = arch_spec; + const ArchSpec &arch_spec = target_sp->GetArchitecture(); + if (arch_spec.IsValid()) + launch_info.GetArchitecture() = arch_spec; - error.SetError (target_sp->Launch (launch_info, NULL)); - sb_process.SetSP(target_sp->GetProcessSP()); - } - else - { - error.SetErrorString ("SBTarget is invalid"); - } + error.SetError(target_sp->Launch(launch_info, NULL)); + sb_process.SetSP(target_sp->GetProcessSP()); + } else { + error.SetErrorString("SBTarget is invalid"); + } - log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API); - if (log) - log->Printf ("SBTarget(%p)::Launch (...) => SBProcess(%p)", - static_cast<void*>(target_sp.get()), - static_cast<void*>(sb_process.GetSP().get())); + log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API); + if (log) + log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p)", + static_cast<void *>(target_sp.get()), + static_cast<void *>(sb_process.GetSP().get())); - return sb_process; + return sb_process; } -lldb::SBProcess -SBTarget::Attach (SBAttachInfo &sb_attach_info, SBError& error) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); +lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - SBProcess sb_process; - TargetSP target_sp(GetSP()); + SBProcess sb_process; + TargetSP target_sp(GetSP()); - if (log) - log->Printf ("SBTarget(%p)::Attach (sb_attach_info, error)...", - static_cast<void*>(target_sp.get())); + if (log) + log->Printf("SBTarget(%p)::Attach (sb_attach_info, error)...", + static_cast<void *>(target_sp.get())); - if (target_sp) - { - ProcessAttachInfo &attach_info = sb_attach_info.ref(); - if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) - { - PlatformSP platform_sp = target_sp->GetPlatform(); - // See if we can pre-verify if a process exists or not - if (platform_sp && platform_sp->IsConnected()) - { - lldb::pid_t attach_pid = attach_info.GetProcessID(); - ProcessInstanceInfo instance_info; - if (platform_sp->GetProcessInfo(attach_pid, instance_info)) - { - attach_info.SetUserID(instance_info.GetEffectiveUserID()); - } - else - { - error.ref().SetErrorStringWithFormat("no process found with process ID %" PRIu64, attach_pid); - if (log) - { - log->Printf ("SBTarget(%p)::Attach (...) => error %s", - static_cast<void*>(target_sp.get()), error.GetCString()); - } - return sb_process; - } - } + if (target_sp) { + ProcessAttachInfo &attach_info = sb_attach_info.ref(); + if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) { + PlatformSP platform_sp = target_sp->GetPlatform(); + // See if we can pre-verify if a process exists or not + if (platform_sp && platform_sp->IsConnected()) { + lldb::pid_t attach_pid = attach_info.GetProcessID(); + ProcessInstanceInfo instance_info; + if (platform_sp->GetProcessInfo(attach_pid, instance_info)) { + attach_info.SetUserID(instance_info.GetEffectiveUserID()); + } else { + error.ref().SetErrorStringWithFormat( + "no process found with process ID %" PRIu64, attach_pid); + if (log) { + log->Printf("SBTarget(%p)::Attach (...) => error %s", + static_cast<void *>(target_sp.get()), + error.GetCString()); + } + return sb_process; } - error.SetError(AttachToProcess(attach_info, *target_sp)); - if (error.Success()) - sb_process.SetSP(target_sp->GetProcessSP()); - } - else - { - error.SetErrorString ("SBTarget is invalid"); + } } + error.SetError(AttachToProcess(attach_info, *target_sp)); + if (error.Success()) + sb_process.SetSP(target_sp->GetProcessSP()); + } else { + error.SetErrorString("SBTarget is invalid"); + } - if (log) - log->Printf ("SBTarget(%p)::Attach (...) => SBProcess(%p)", - static_cast<void*>(target_sp.get()), - static_cast<void*>(sb_process.GetSP().get())); + if (log) + log->Printf("SBTarget(%p)::Attach (...) => SBProcess(%p)", + static_cast<void *>(target_sp.get()), + static_cast<void *>(sb_process.GetSP().get())); - return sb_process; + return sb_process; } - #if defined(__APPLE__) -lldb::SBProcess -SBTarget::AttachToProcessWithID (SBListener &listener, - ::pid_t pid, - lldb::SBError& error) -{ - return AttachToProcessWithID (listener, (lldb::pid_t)pid, error); +lldb::SBProcess SBTarget::AttachToProcessWithID(SBListener &listener, + ::pid_t pid, + lldb::SBError &error) { + return AttachToProcessWithID(listener, (lldb::pid_t)pid, error); } #endif // #if defined(__APPLE__) -lldb::SBProcess -SBTarget::AttachToProcessWithID -( - SBListener &listener, - lldb::pid_t pid,// The process ID to attach to - SBError& error // An error explaining what went wrong if attach fails -) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBProcess sb_process; - TargetSP target_sp(GetSP()); - - if (log) - log->Printf ("SBTarget(%p)::%s (listener, pid=%" PRId64 ", error)...", - static_cast<void*>(target_sp.get()), - __FUNCTION__, - pid); - - if (target_sp) - { - ProcessAttachInfo attach_info; - attach_info.SetProcessID (pid); - if (listener.IsValid()) - attach_info.SetListener(listener.GetSP()); - - ProcessInstanceInfo instance_info; - if (target_sp->GetPlatform ()->GetProcessInfo (pid, instance_info)) - attach_info.SetUserID (instance_info.GetEffectiveUserID ()); - - error.SetError (AttachToProcess (attach_info, *target_sp)); - if (error.Success ()) - sb_process.SetSP (target_sp->GetProcessSP ()); - } +lldb::SBProcess SBTarget::AttachToProcessWithID( + SBListener &listener, + lldb::pid_t pid, // The process ID to attach to + SBError &error // An error explaining what went wrong if attach fails + ) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + + if (log) + log->Printf("SBTarget(%p)::%s (listener, pid=%" PRId64 ", error)...", + static_cast<void *>(target_sp.get()), __FUNCTION__, pid); + + if (target_sp) { + ProcessAttachInfo attach_info; + attach_info.SetProcessID(pid); + if (listener.IsValid()) + attach_info.SetListener(listener.GetSP()); + + ProcessInstanceInfo instance_info; + if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info)) + attach_info.SetUserID(instance_info.GetEffectiveUserID()); + + error.SetError(AttachToProcess(attach_info, *target_sp)); + if (error.Success()) + sb_process.SetSP(target_sp->GetProcessSP()); + } else + error.SetErrorString("SBTarget is invalid"); + + if (log) + log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", + static_cast<void *>(target_sp.get()), __FUNCTION__, + static_cast<void *>(sb_process.GetSP().get())); + return sb_process; +} + +lldb::SBProcess SBTarget::AttachToProcessWithName( + SBListener &listener, + const char *name, // basename of process to attach to + bool wait_for, // if true wait for a new instance of "name" to be launched + SBError &error // An error explaining what went wrong if attach fails + ) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + + if (log) + log->Printf("SBTarget(%p)::%s (listener, name=%s, wait_for=%s, error)...", + static_cast<void *>(target_sp.get()), __FUNCTION__, name, + wait_for ? "true" : "false"); + + if (name && target_sp) { + ProcessAttachInfo attach_info; + attach_info.GetExecutableFile().SetFile(name, false); + attach_info.SetWaitForLaunch(wait_for); + if (listener.IsValid()) + attach_info.SetListener(listener.GetSP()); + + error.SetError(AttachToProcess(attach_info, *target_sp)); + if (error.Success()) + sb_process.SetSP(target_sp->GetProcessSP()); + } else + error.SetErrorString("SBTarget is invalid"); + + if (log) + log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", + static_cast<void *>(target_sp.get()), __FUNCTION__, + static_cast<void *>(sb_process.GetSP().get())); + return sb_process; +} + +lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, + const char *plugin_name, + SBError &error) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBProcess sb_process; + ProcessSP process_sp; + TargetSP target_sp(GetSP()); + + if (log) + log->Printf("SBTarget(%p)::ConnectRemote (listener, url=%s, " + "plugin_name=%s, error)...", + static_cast<void *>(target_sp.get()), url, plugin_name); + + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (listener.IsValid()) + process_sp = + target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, NULL); else - error.SetErrorString ("SBTarget is invalid"); + process_sp = target_sp->CreateProcess( + target_sp->GetDebugger().GetListener(), plugin_name, NULL); - if (log) - log->Printf ("SBTarget(%p)::%s (...) => SBProcess(%p)", - static_cast<void*>(target_sp.get ()), - __FUNCTION__, - static_cast<void*>(sb_process.GetSP().get ())); - return sb_process; -} - -lldb::SBProcess -SBTarget::AttachToProcessWithName -( - SBListener &listener, - const char *name, // basename of process to attach to - bool wait_for, // if true wait for a new instance of "name" to be launched - SBError& error // An error explaining what went wrong if attach fails -) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBProcess sb_process; - TargetSP target_sp(GetSP()); - - if (log) - log->Printf ("SBTarget(%p)::%s (listener, name=%s, wait_for=%s, error)...", - static_cast<void*>(target_sp.get()), - __FUNCTION__, - name, - wait_for ? "true" : "false"); - - if (name && target_sp) - { - ProcessAttachInfo attach_info; - attach_info.GetExecutableFile().SetFile(name, false); - attach_info.SetWaitForLaunch(wait_for); - if (listener.IsValid()) - attach_info.SetListener(listener.GetSP()); - - error.SetError (AttachToProcess (attach_info, *target_sp)); - if (error.Success ()) - sb_process.SetSP (target_sp->GetProcessSP ()); + if (process_sp) { + sb_process.SetSP(process_sp); + error.SetError(process_sp->ConnectRemote(NULL, url)); + } else { + error.SetErrorString("unable to create lldb_private::Process"); } - else - error.SetErrorString ("SBTarget is invalid"); + } else { + error.SetErrorString("SBTarget is invalid"); + } - if (log) - log->Printf ("SBTarget(%p)::%s (...) => SBProcess(%p)", - static_cast<void*>(target_sp.get()), - __FUNCTION__, - static_cast<void*>(sb_process.GetSP().get())); - return sb_process; + if (log) + log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)", + static_cast<void *>(target_sp.get()), + static_cast<void *>(process_sp.get())); + return sb_process; } -lldb::SBProcess -SBTarget::ConnectRemote -( - SBListener &listener, - const char *url, - const char *plugin_name, - SBError& error -) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBProcess sb_process; - ProcessSP process_sp; - TargetSP target_sp(GetSP()); +SBFileSpec SBTarget::GetExecutable() { - if (log) - log->Printf ("SBTarget(%p)::ConnectRemote (listener, url=%s, plugin_name=%s, error)...", - static_cast<void*>(target_sp.get()), url, plugin_name); + SBFileSpec exe_file_spec; + TargetSP target_sp(GetSP()); + if (target_sp) { + Module *exe_module = target_sp->GetExecutableModulePointer(); + if (exe_module) + exe_file_spec.SetFileSpec(exe_module->GetFileSpec()); + } - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - if (listener.IsValid()) - process_sp = target_sp->CreateProcess (listener.m_opaque_sp, plugin_name, NULL); - else - process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), plugin_name, NULL); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + if (log) { + log->Printf("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)", + static_cast<void *>(target_sp.get()), + static_cast<const void *>(exe_file_spec.get())); + } - if (process_sp) - { - sb_process.SetSP (process_sp); - error.SetError (process_sp->ConnectRemote (NULL, url)); - } - else - { - error.SetErrorString ("unable to create lldb_private::Process"); - } - } - else - { - error.SetErrorString ("SBTarget is invalid"); - } - - if (log) - log->Printf ("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)", - static_cast<void*>(target_sp.get()), - static_cast<void*>(process_sp.get())); - return sb_process; + return exe_file_spec; } -SBFileSpec -SBTarget::GetExecutable () -{ - - SBFileSpec exe_file_spec; - TargetSP target_sp(GetSP()); - if (target_sp) - { - Module *exe_module = target_sp->GetExecutableModulePointer(); - if (exe_module) - exe_file_spec.SetFileSpec (exe_module->GetFileSpec()); - } - - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - if (log) - { - log->Printf ("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)", - static_cast<void*>(target_sp.get()), - static_cast<const void*>(exe_file_spec.get())); - } - - return exe_file_spec; +bool SBTarget::operator==(const SBTarget &rhs) const { + return m_opaque_sp.get() == rhs.m_opaque_sp.get(); } -bool -SBTarget::operator == (const SBTarget &rhs) const -{ - return m_opaque_sp.get() == rhs.m_opaque_sp.get(); +bool SBTarget::operator!=(const SBTarget &rhs) const { + return m_opaque_sp.get() != rhs.m_opaque_sp.get(); } -bool -SBTarget::operator != (const SBTarget &rhs) const -{ - return m_opaque_sp.get() != rhs.m_opaque_sp.get(); -} +lldb::TargetSP SBTarget::GetSP() const { return m_opaque_sp; } -lldb::TargetSP -SBTarget::GetSP () const -{ - return m_opaque_sp; +void SBTarget::SetSP(const lldb::TargetSP &target_sp) { + m_opaque_sp = target_sp; } -void -SBTarget::SetSP (const lldb::TargetSP& target_sp) -{ - m_opaque_sp = target_sp; +lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { + lldb::SBAddress sb_addr; + Address &addr = sb_addr.ref(); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (target_sp->ResolveLoadAddress(vm_addr, addr)) + return sb_addr; + } + + // We have a load address that isn't in a section, just return an address + // with the offset filled in (the address) and the section set to NULL + addr.SetRawAddress(vm_addr); + return sb_addr; } -lldb::SBAddress -SBTarget::ResolveLoadAddress (lldb::addr_t vm_addr) -{ - lldb::SBAddress sb_addr; - Address &addr = sb_addr.ref(); - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - if (target_sp->ResolveLoadAddress (vm_addr, addr)) - return sb_addr; - } +lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { + lldb::SBAddress sb_addr; + Address &addr = sb_addr.ref(); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (target_sp->ResolveFileAddress(file_addr, addr)) + return sb_addr; + } - // We have a load address that isn't in a section, just return an address - // with the offset filled in (the address) and the section set to NULL - addr.SetRawAddress(vm_addr); - return sb_addr; + addr.SetRawAddress(file_addr); + return sb_addr; } -lldb::SBAddress -SBTarget::ResolveFileAddress (lldb::addr_t file_addr) -{ - lldb::SBAddress sb_addr; - Address &addr = sb_addr.ref(); - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - if (target_sp->ResolveFileAddress (file_addr, addr)) - return sb_addr; - } +lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, + lldb::addr_t vm_addr) { + lldb::SBAddress sb_addr; + Address &addr = sb_addr.ref(); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (target_sp->ResolveLoadAddress(vm_addr, addr)) + return sb_addr; + } - addr.SetRawAddress(file_addr); - return sb_addr; + // We have a load address that isn't in a section, just return an address + // with the offset filled in (the address) and the section set to NULL + addr.SetRawAddress(vm_addr); + return sb_addr; } -lldb::SBAddress -SBTarget::ResolvePastLoadAddress (uint32_t stop_id, lldb::addr_t vm_addr) -{ - lldb::SBAddress sb_addr; - Address &addr = sb_addr.ref(); +SBSymbolContext +SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, + uint32_t resolve_scope) { + SBSymbolContext sc; + if (addr.IsValid()) { TargetSP target_sp(GetSP()); if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - if (target_sp->ResolveLoadAddress (vm_addr, addr)) - return sb_addr; - } - - // We have a load address that isn't in a section, just return an address - // with the offset filled in (the address) and the section set to NULL - addr.SetRawAddress(vm_addr); - return sb_addr; + target_sp->GetImages().ResolveSymbolContextForAddress( + addr.ref(), resolve_scope, sc.ref()); + } + return sc; } -SBSymbolContext -SBTarget::ResolveSymbolContextForAddress (const SBAddress& addr, - uint32_t resolve_scope) -{ - SBSymbolContext sc; - if (addr.IsValid()) - { - TargetSP target_sp(GetSP()); - if (target_sp) - target_sp->GetImages().ResolveSymbolContextForAddress (addr.ref(), resolve_scope, sc.ref()); - } - return sc; -} +size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, + lldb::SBError &error) { + SBError sb_error; + size_t bytes_read = 0; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + bytes_read = + target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref()); + } else { + sb_error.SetErrorString("invalid target"); + } -size_t -SBTarget::ReadMemory (const SBAddress addr, - void *buf, - size_t size, - lldb::SBError &error) -{ - SBError sb_error; - size_t bytes_read = 0; - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - bytes_read = target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref()); - } - else - { - sb_error.SetErrorString("invalid target"); - } - - return bytes_read; + return bytes_read; } -SBBreakpoint -SBTarget::BreakpointCreateByLocation (const char *file, - uint32_t line) -{ - return SBBreakpoint(BreakpointCreateByLocation (SBFileSpec (file, false), line)); +SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, + uint32_t line) { + return SBBreakpoint( + BreakpointCreateByLocation(SBFileSpec(file, false), line)); } SBBreakpoint -SBTarget::BreakpointCreateByLocation (const SBFileSpec &sb_file_spec, - uint32_t line) -{ - return BreakpointCreateByLocation(sb_file_spec, line, 0); +SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, + uint32_t line) { + return BreakpointCreateByLocation(sb_file_spec, line, 0); } SBBreakpoint -SBTarget::BreakpointCreateByLocation (const SBFileSpec &sb_file_spec, - uint32_t line, - lldb::addr_t offset) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp && line != 0) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - - const LazyBool check_inlines = eLazyBoolCalculate; - const LazyBool skip_prologue = eLazyBoolCalculate; - const bool internal = false; - const bool hardware = false; - const LazyBool move_to_nearest_code = eLazyBoolCalculate; - *sb_bp = target_sp->CreateBreakpoint (NULL, - *sb_file_spec, - line, - offset, - check_inlines, - skip_prologue, - internal, - hardware, - move_to_nearest_code); - } - - if (log) - { - SBStream sstr; - sb_bp.GetDescription (sstr); - char path[PATH_MAX]; - sb_file_spec->GetPath (path, sizeof(path)); - log->Printf ("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => SBBreakpoint(%p): %s", - static_cast<void*>(target_sp.get()), path, line, - static_cast<void*>(sb_bp.get()), sstr.GetData()); - } - - return sb_bp; +SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, + uint32_t line, lldb::addr_t offset) { + SBFileSpecList empty_list; + return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list); } SBBreakpoint -SBTarget::BreakpointCreateByName (const char *symbol_name, - const char *module_name) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp.get()) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - - const bool internal = false; - const bool hardware = false; - const LazyBool skip_prologue = eLazyBoolCalculate; - const lldb::addr_t offset = 0; - if (module_name && module_name[0]) - { - FileSpecList module_spec_list; - module_spec_list.Append (FileSpec (module_name, false)); - *sb_bp = target_sp->CreateBreakpoint (&module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); - } - else - { - *sb_bp = target_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); - } - } - - if (log) - log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", module=\"%s\") => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), symbol_name, - module_name, static_cast<void*>(sb_bp.get())); - - return sb_bp; -} - -lldb::SBBreakpoint -SBTarget::BreakpointCreateByName (const char *symbol_name, - const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - uint32_t name_type_mask = eFunctionNameTypeAuto; - return BreakpointCreateByName (symbol_name, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list); +SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, + uint32_t line, lldb::addr_t offset, + SBFileSpecList &sb_module_list) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && line != 0) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + const LazyBool check_inlines = eLazyBoolCalculate; + const LazyBool skip_prologue = eLazyBoolCalculate; + const bool internal = false; + const bool hardware = false; + const LazyBool move_to_nearest_code = eLazyBoolCalculate; + const FileSpecList *module_list = nullptr; + if (sb_module_list.GetSize() > 0) { + module_list = sb_module_list.get(); + } + *sb_bp = target_sp->CreateBreakpoint( + module_list, *sb_file_spec, line, offset, check_inlines, skip_prologue, + internal, hardware, move_to_nearest_code); + } + + if (log) { + SBStream sstr; + sb_bp.GetDescription(sstr); + char path[PATH_MAX]; + sb_file_spec->GetPath(path, sizeof(path)); + log->Printf("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => " + "SBBreakpoint(%p): %s", + static_cast<void *>(target_sp.get()), path, line, + static_cast<void *>(sb_bp.get()), sstr.GetData()); + } + + return sb_bp; +} + +SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, + const char *module_name) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp.get()) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + const bool internal = false; + const bool hardware = false; + const LazyBool skip_prologue = eLazyBoolCalculate; + const lldb::addr_t offset = 0; + if (module_name && module_name[0]) { + FileSpecList module_spec_list; + module_spec_list.Append(FileSpec(module_name, false)); + *sb_bp = target_sp->CreateBreakpoint( + &module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, + eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); + } else { + *sb_bp = target_sp->CreateBreakpoint( + NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, + offset, skip_prologue, internal, hardware); + } + } + + if (log) + log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", " + "module=\"%s\") => SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), symbol_name, module_name, + static_cast<void *>(sb_bp.get())); + + return sb_bp; } lldb::SBBreakpoint -SBTarget::BreakpointCreateByName (const char *symbol_name, - uint32_t name_type_mask, - const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - return BreakpointCreateByName (symbol_name, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list); +SBTarget::BreakpointCreateByName(const char *symbol_name, + const SBFileSpecList &module_list, + const SBFileSpecList &comp_unit_list) { + uint32_t name_type_mask = eFunctionNameTypeAuto; + return BreakpointCreateByName(symbol_name, name_type_mask, + eLanguageTypeUnknown, module_list, + comp_unit_list); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByName( + const char *symbol_name, uint32_t name_type_mask, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + return BreakpointCreateByName(symbol_name, name_type_mask, + eLanguageTypeUnknown, module_list, + comp_unit_list); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByName( + const char *symbol_name, uint32_t name_type_mask, + LanguageType symbol_language, const SBFileSpecList &module_list, + const SBFileSpecList &comp_unit_list) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && symbol_name && symbol_name[0]) { + const bool internal = false; + const bool hardware = false; + const LazyBool skip_prologue = eLazyBoolCalculate; + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + *sb_bp = target_sp->CreateBreakpoint( + module_list.get(), comp_unit_list.get(), symbol_name, name_type_mask, + symbol_language, 0, skip_prologue, internal, hardware); + } + + if (log) + log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", " + "name_type: %d) => SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), symbol_name, + name_type_mask, static_cast<void *>(sb_bp.get())); + + return sb_bp; +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( + const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, + eLanguageTypeUnknown, module_list, + comp_unit_list); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( + const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, + LanguageType symbol_language, const SBFileSpecList &module_list, + const SBFileSpecList &comp_unit_list) { + return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, + eLanguageTypeUnknown, 0, module_list, + comp_unit_list); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( + const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, + LanguageType symbol_language, lldb::addr_t offset, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && num_names > 0) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool internal = false; + const bool hardware = false; + const LazyBool skip_prologue = eLazyBoolCalculate; + *sb_bp = target_sp->CreateBreakpoint( + module_list.get(), comp_unit_list.get(), symbol_names, num_names, + name_type_mask, symbol_language, offset, skip_prologue, internal, + hardware); + } + + if (log) { + log->Printf("SBTarget(%p)::BreakpointCreateByName (symbols={", + static_cast<void *>(target_sp.get())); + for (uint32_t i = 0; i < num_names; i++) { + char sep; + if (i < num_names - 1) + sep = ','; + else + sep = '}'; + if (symbol_names[i] != NULL) + log->Printf("\"%s\"%c ", symbol_names[i], sep); + else + log->Printf("\"<NULL>\"%c ", sep); + } + log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask, + static_cast<void *>(sb_bp.get())); + } + + return sb_bp; +} + +SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, + const char *module_name) { + SBFileSpecList module_spec_list; + SBFileSpecList comp_unit_list; + if (module_name && module_name[0]) { + module_spec_list.Append(FileSpec(module_name, false)); + } + return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, + module_spec_list, comp_unit_list); } lldb::SBBreakpoint -SBTarget::BreakpointCreateByName (const char *symbol_name, - uint32_t name_type_mask, - LanguageType symbol_language, +SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp && symbol_name && symbol_name[0]) - { - const bool internal = false; - const bool hardware = false; - const LazyBool skip_prologue = eLazyBoolCalculate; - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - *sb_bp = target_sp->CreateBreakpoint (module_list.get(), - comp_unit_list.get(), - symbol_name, - name_type_mask, - symbol_language, - 0, - skip_prologue, - internal, - hardware); - } - + const SBFileSpecList &comp_unit_list) { + return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, + module_list, comp_unit_list); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( + const char *symbol_name_regex, LanguageType symbol_language, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && symbol_name_regex && symbol_name_regex[0]) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + RegularExpression regexp((llvm::StringRef(symbol_name_regex))); + const bool internal = false; + const bool hardware = false; + const LazyBool skip_prologue = eLazyBoolCalculate; + + *sb_bp = target_sp->CreateFuncRegexBreakpoint( + module_list.get(), comp_unit_list.get(), regexp, symbol_language, + skip_prologue, internal, hardware); + } + + if (log) + log->Printf("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") " + "=> SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), symbol_name_regex, + static_cast<void *>(sb_bp.get())); + + return sb_bp; +} + +SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + *sb_bp = target_sp->CreateBreakpoint(address, false, hardware); + } + + if (log) + log->Printf("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64 + ") => SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), + static_cast<uint64_t>(address), + static_cast<void *>(sb_bp.get())); + + return sb_bp; +} + +SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (!sb_address.IsValid()) { if (log) - log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), symbol_name, - name_type_mask, static_cast<void*>(sb_bp.get())); - + log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with " + "invalid address", + static_cast<void *>(target_sp.get())); return sb_bp; -} - -lldb::SBBreakpoint -SBTarget::BreakpointCreateByNames (const char *symbol_names[], - uint32_t num_names, - uint32_t name_type_mask, - const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list); -} - -lldb::SBBreakpoint -SBTarget::BreakpointCreateByNames (const char *symbol_names[], - uint32_t num_names, - uint32_t name_type_mask, - LanguageType symbol_language, - const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0, module_list, comp_unit_list); -} - -lldb::SBBreakpoint -SBTarget::BreakpointCreateByNames (const char *symbol_names[], - uint32_t num_names, - uint32_t name_type_mask, - LanguageType symbol_language, - lldb::addr_t offset, - const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp && num_names > 0) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - const bool internal = false; - const bool hardware = false; - const LazyBool skip_prologue = eLazyBoolCalculate; - *sb_bp = target_sp->CreateBreakpoint (module_list.get(), - comp_unit_list.get(), - symbol_names, - num_names, - name_type_mask, - symbol_language, - offset, - skip_prologue, - internal, - hardware); - } + } - if (log) - { - log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbols={", - static_cast<void*>(target_sp.get())); - for (uint32_t i = 0 ; i < num_names; i++) - { - char sep; - if (i < num_names - 1) - sep = ','; - else - sep = '}'; - if (symbol_names[i] != NULL) - log->Printf ("\"%s\"%c ", symbol_names[i], sep); - else - log->Printf ("\"<NULL>\"%c ", sep); - } - log->Printf ("name_type: %d) => SBBreakpoint(%p)", name_type_mask, - static_cast<void*>(sb_bp.get())); - } + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + *sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware); + } - return sb_bp; -} + if (log) { + SBStream s; + sb_address.GetDescription(s); + log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => " + "SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), s.GetData(), + static_cast<void *>(sb_bp.get())); + } -SBBreakpoint -SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, - const char *module_name) -{ - SBFileSpecList module_spec_list; - SBFileSpecList comp_unit_list; - if (module_name && module_name[0]) - { - module_spec_list.Append (FileSpec (module_name, false)); - - } - return BreakpointCreateByRegex (symbol_name_regex, eLanguageTypeUnknown, module_spec_list, comp_unit_list); + return sb_bp; } lldb::SBBreakpoint -SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, - const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - return BreakpointCreateByRegex (symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list); -} +SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, + const lldb::SBFileSpec &source_file, + const char *module_name) { + SBFileSpecList module_spec_list; -lldb::SBBreakpoint -SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, - LanguageType symbol_language, - const SBFileSpecList &module_list, - const SBFileSpecList &comp_unit_list) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp && symbol_name_regex && symbol_name_regex[0]) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - RegularExpression regexp(symbol_name_regex); - const bool internal = false; - const bool hardware = false; - const LazyBool skip_prologue = eLazyBoolCalculate; - - *sb_bp = target_sp->CreateFuncRegexBreakpoint (module_list.get(), comp_unit_list.get(), regexp, symbol_language, skip_prologue, internal, hardware); - } + if (module_name && module_name[0]) { + module_spec_list.Append(FileSpec(module_name, false)); + } - if (log) - log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), symbol_name_regex, - static_cast<void*>(sb_bp.get())); + SBFileSpecList source_file_list; + if (source_file.IsValid()) { + source_file_list.Append(source_file); + } - return sb_bp; + return BreakpointCreateBySourceRegex(source_regex, module_spec_list, + source_file_list); } -SBBreakpoint -SBTarget::BreakpointCreateByAddress (addr_t address) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - const bool hardware = false; - *sb_bp = target_sp->CreateBreakpoint (address, false, hardware); - } - - if (log) - log->Printf ("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64 ") => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), - static_cast<uint64_t>(address), - static_cast<void*>(sb_bp.get())); - - return sb_bp; +lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( + const char *source_regex, const SBFileSpecList &module_list, + const lldb::SBFileSpecList &source_file_list) { + return BreakpointCreateBySourceRegex(source_regex, module_list, + source_file_list, SBStringList()); } -SBBreakpoint -SBTarget::BreakpointCreateBySBAddress (SBAddress &sb_address) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); +lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( + const char *source_regex, const SBFileSpecList &module_list, + const lldb::SBFileSpecList &source_file_list, + const SBStringList &func_names) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (!sb_address.IsValid()) - { - if (log) - log->Printf ("SBTarget(%p)::BreakpointCreateBySBAddress called with invalid address", - static_cast<void*>(target_sp.get())); - return sb_bp; - } - - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - const bool hardware = false; - *sb_bp = target_sp->CreateBreakpoint (sb_address.ref(), false, hardware); - } - - if (log) - { - SBStream s; - sb_address.GetDescription(s); - log->Printf ("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), - s.GetData(), - static_cast<void*>(sb_bp.get())); + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && source_regex && source_regex[0]) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + const LazyBool move_to_nearest_code = eLazyBoolCalculate; + RegularExpression regexp((llvm::StringRef(source_regex))); + std::unordered_set<std::string> func_names_set; + for (size_t i = 0; i < func_names.GetSize(); i++) { + func_names_set.insert(func_names.GetStringAtIndex(i)); } - return sb_bp; -} - -lldb::SBBreakpoint -SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, - const lldb::SBFileSpec &source_file, - const char *module_name) -{ - SBFileSpecList module_spec_list; - - if (module_name && module_name[0]) - { - module_spec_list.Append (FileSpec (module_name, false)); - } - - SBFileSpecList source_file_list; - if (source_file.IsValid()) - { - source_file_list.Append(source_file); - } - - return BreakpointCreateBySourceRegex (source_regex, module_spec_list, source_file_list); - -} - -lldb::SBBreakpoint -SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, - const SBFileSpecList &module_list, - const lldb::SBFileSpecList &source_file_list) -{ - return BreakpointCreateBySourceRegex(source_regex, module_list, source_file_list, SBStringList()); -} - -lldb::SBBreakpoint -SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, - const SBFileSpecList &module_list, - const lldb::SBFileSpecList &source_file_list, - const SBStringList &func_names) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp && source_regex && source_regex[0]) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - const bool hardware = false; - const LazyBool move_to_nearest_code = eLazyBoolCalculate; - RegularExpression regexp(source_regex); - std::unordered_set<std::string> func_names_set; - for (size_t i = 0; i < func_names.GetSize(); i++) - { - func_names_set.insert(func_names.GetStringAtIndex(i)); - } - - *sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), - source_file_list.get(), - func_names_set, - regexp, - false, - hardware, - move_to_nearest_code); - } + *sb_bp = target_sp->CreateSourceRegexBreakpoint( + module_list.get(), source_file_list.get(), func_names_set, regexp, + false, hardware, move_to_nearest_code); + } - if (log) - log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), source_regex, - static_cast<void*>(sb_bp.get())); + if (log) + log->Printf("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") " + "=> SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), source_regex, + static_cast<void *>(sb_bp.get())); - return sb_bp; + return sb_bp; } lldb::SBBreakpoint -SBTarget::BreakpointCreateForException (lldb::LanguageType language, - bool catch_bp, - bool throw_bp) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_bp; - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - const bool hardware = false; - *sb_bp = target_sp->CreateExceptionBreakpoint (language, catch_bp, throw_bp, hardware); - } - - if (log) - log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: %s throw: %s) => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), - Language::GetNameForLanguageType(language), - catch_bp ? "on" : "off", throw_bp ? "on" : "off", - static_cast<void*>(sb_bp.get())); - - return sb_bp; -} - -uint32_t -SBTarget::GetNumBreakpoints () const -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - // The breakpoint list is thread safe, no need to lock - return target_sp->GetBreakpointList().GetSize(); - } - return 0; -} - -SBBreakpoint -SBTarget::GetBreakpointAtIndex (uint32_t idx) const -{ - SBBreakpoint sb_breakpoint; - TargetSP target_sp(GetSP()); - if (target_sp) - { - // The breakpoint list is thread safe, no need to lock - *sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); - } - return sb_breakpoint; -} - -bool -SBTarget::BreakpointDelete (break_id_t bp_id) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - bool result = false; - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - result = target_sp->RemoveBreakpointByID (bp_id); - } - - if (log) - log->Printf ("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", - static_cast<void*>(target_sp.get()), - static_cast<uint32_t>(bp_id), result); - - return result; -} - -SBBreakpoint -SBTarget::FindBreakpointByID (break_id_t bp_id) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBBreakpoint sb_breakpoint; - TargetSP target_sp(GetSP()); - if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - *sb_breakpoint = target_sp->GetBreakpointByID (bp_id); - } - - if (log) - log->Printf ("SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)", - static_cast<void*>(target_sp.get()), - static_cast<uint32_t>(bp_id), - static_cast<void*>(sb_breakpoint.get())); - - return sb_breakpoint; -} - -bool -SBTarget::EnableAllBreakpoints () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - target_sp->EnableAllBreakpoints (); - return true; - } - return false; -} - -bool -SBTarget::DisableAllBreakpoints () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - target_sp->DisableAllBreakpoints (); - return true; - } - return false; -} - -bool -SBTarget::DeleteAllBreakpoints () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - target_sp->RemoveAllBreakpoints (); - return true; - } - return false; -} - -uint32_t -SBTarget::GetNumWatchpoints () const -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - // The watchpoint list is thread safe, no need to lock - return target_sp->GetWatchpointList().GetSize(); - } - return 0; -} - -SBWatchpoint -SBTarget::GetWatchpointAtIndex (uint32_t idx) const -{ - SBWatchpoint sb_watchpoint; - TargetSP target_sp(GetSP()); - if (target_sp) - { - // The watchpoint list is thread safe, no need to lock - sb_watchpoint.SetSP (target_sp->GetWatchpointList().GetByIndex(idx)); - } - return sb_watchpoint; -} - -bool -SBTarget::DeleteWatchpoint (watch_id_t wp_id) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - bool result = false; - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - std::unique_lock<std::recursive_mutex> lock; - target_sp->GetWatchpointList().GetListMutex(lock); - result = target_sp->RemoveWatchpointByID (wp_id); - } - - if (log) - log->Printf ("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", - static_cast<void*>(target_sp.get()), - static_cast<uint32_t>(wp_id), result); - - return result; -} - -SBWatchpoint -SBTarget::FindWatchpointByID (lldb::watch_id_t wp_id) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBWatchpoint sb_watchpoint; - lldb::WatchpointSP watchpoint_sp; - TargetSP target_sp(GetSP()); - if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - std::unique_lock<std::recursive_mutex> lock; - target_sp->GetWatchpointList().GetListMutex(lock); - watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id); - sb_watchpoint.SetSP (watchpoint_sp); - } - - if (log) - log->Printf ("SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)", - static_cast<void*>(target_sp.get()), - static_cast<uint32_t>(wp_id), - static_cast<void*>(watchpoint_sp.get())); - - return sb_watchpoint; -} - -lldb::SBWatchpoint -SBTarget::WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write, SBError &error) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBWatchpoint sb_watchpoint; - lldb::WatchpointSP watchpoint_sp; - TargetSP target_sp(GetSP()); - if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && size > 0) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - uint32_t watch_type = 0; - if (read) - watch_type |= LLDB_WATCH_TYPE_READ; - if (write) - watch_type |= LLDB_WATCH_TYPE_WRITE; - if (watch_type == 0) - { - error.SetErrorString("Can't create a watchpoint that is neither read nor write."); - return sb_watchpoint; - } - - // Target::CreateWatchpoint() is thread safe. - Error cw_error; - // This API doesn't take in a type, so we can't figure out what it is. - CompilerType *type = NULL; - watchpoint_sp = target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error); - error.SetError(cw_error); - sb_watchpoint.SetSP (watchpoint_sp); - } - - if (log) - log->Printf ("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64 ", 0x%u) => SBWatchpoint(%p)", - static_cast<void*>(target_sp.get()), addr, - static_cast<uint32_t>(size), - static_cast<void*>(watchpoint_sp.get())); - - return sb_watchpoint; -} - -bool -SBTarget::EnableAllWatchpoints () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - std::unique_lock<std::recursive_mutex> lock; - target_sp->GetWatchpointList().GetListMutex(lock); - target_sp->EnableAllWatchpoints (); - return true; - } - return false; -} - -bool -SBTarget::DisableAllWatchpoints () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - std::unique_lock<std::recursive_mutex> lock; - target_sp->GetWatchpointList().GetListMutex(lock); - target_sp->DisableAllWatchpoints (); - return true; - } - return false; -} - -SBValue -SBTarget::CreateValueFromAddress (const char *name, SBAddress addr, SBType type) -{ - SBValue sb_value; - lldb::ValueObjectSP new_value_sp; - if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) - { - lldb::addr_t load_addr(addr.GetLoadAddress(*this)); - ExecutionContext exe_ctx (ExecutionContextRef(ExecutionContext(m_opaque_sp.get(),false))); - CompilerType ast_type(type.GetSP()->GetCompilerType(true)); - new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr, exe_ctx, ast_type); - } - sb_value.SetSP(new_value_sp); - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - if (log) - { - if (new_value_sp) - log->Printf ("SBTarget(%p)::CreateValueFromAddress => \"%s\"", - static_cast<void*>(m_opaque_sp.get()), - new_value_sp->GetName().AsCString()); - else - log->Printf ("SBTarget(%p)::CreateValueFromAddress => NULL", - static_cast<void*>(m_opaque_sp.get())); - } - return sb_value; -} - -lldb::SBValue -SBTarget::CreateValueFromData (const char *name, lldb::SBData data, lldb::SBType type) -{ - SBValue sb_value; - lldb::ValueObjectSP new_value_sp; - if (IsValid() && name && *name && data.IsValid() && type.IsValid()) - { - DataExtractorSP extractor(*data); - ExecutionContext exe_ctx (ExecutionContextRef(ExecutionContext(m_opaque_sp.get(),false))); - CompilerType ast_type(type.GetSP()->GetCompilerType(true)); - new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor, exe_ctx, ast_type); - } - sb_value.SetSP(new_value_sp); - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - if (log) - { - if (new_value_sp) - log->Printf ("SBTarget(%p)::CreateValueFromData => \"%s\"", - static_cast<void*>(m_opaque_sp.get()), - new_value_sp->GetName().AsCString()); - else - log->Printf ("SBTarget(%p)::CreateValueFromData => NULL", - static_cast<void*>(m_opaque_sp.get())); - } - return sb_value; -} - -lldb::SBValue -SBTarget::CreateValueFromExpression (const char *name, const char* expr) -{ - SBValue sb_value; - lldb::ValueObjectSP new_value_sp; - if (IsValid() && name && *name && expr && *expr) - { - ExecutionContext exe_ctx (ExecutionContextRef(ExecutionContext(m_opaque_sp.get(),false))); - new_value_sp = ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx); - } - sb_value.SetSP(new_value_sp); - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - if (log) - { - if (new_value_sp) - log->Printf ("SBTarget(%p)::CreateValueFromExpression => \"%s\"", - static_cast<void*>(m_opaque_sp.get()), - new_value_sp->GetName().AsCString()); - else - log->Printf ("SBTarget(%p)::CreateValueFromExpression => NULL", - static_cast<void*>(m_opaque_sp.get())); - } - return sb_value; -} - -bool -SBTarget::DeleteAllWatchpoints () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - std::unique_lock<std::recursive_mutex> lock; - target_sp->GetWatchpointList().GetListMutex(lock); - target_sp->RemoveAllWatchpoints (); - return true; - } - return false; +SBTarget::BreakpointCreateForException(lldb::LanguageType language, + bool catch_bp, bool throw_bp) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + *sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp, + hardware); + } + + if (log) + log->Printf("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: " + "%s throw: %s) => SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), + Language::GetNameForLanguageType(language), + catch_bp ? "on" : "off", throw_bp ? "on" : "off", + static_cast<void *>(sb_bp.get())); + + return sb_bp; +} + +uint32_t SBTarget::GetNumBreakpoints() const { + TargetSP target_sp(GetSP()); + if (target_sp) { + // The breakpoint list is thread safe, no need to lock + return target_sp->GetBreakpointList().GetSize(); + } + return 0; +} + +SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { + SBBreakpoint sb_breakpoint; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The breakpoint list is thread safe, no need to lock + *sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); + } + return sb_breakpoint; +} + +bool SBTarget::BreakpointDelete(break_id_t bp_id) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + bool result = false; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + result = target_sp->RemoveBreakpointByID(bp_id); + } + + if (log) + log->Printf("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", + static_cast<void *>(target_sp.get()), + static_cast<uint32_t>(bp_id), result); + + return result; +} + +SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBBreakpoint sb_breakpoint; + TargetSP target_sp(GetSP()); + if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + *sb_breakpoint = target_sp->GetBreakpointByID(bp_id); + } + + if (log) + log->Printf( + "SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)", + static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id), + static_cast<void *>(sb_breakpoint.get())); + + return sb_breakpoint; +} + +bool SBTarget::FindBreakpointsByName(const char *name, + SBBreakpointList &bkpts) { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + BreakpointList bkpt_list(false); + bool is_valid = + target_sp->GetBreakpointList().FindBreakpointsByName(name, bkpt_list); + if (!is_valid) + return false; + for (BreakpointSP bkpt_sp : bkpt_list.Breakpoints()) { + bkpts.AppendByID(bkpt_sp->GetID()); + } + } + return true; +} + +bool SBTarget::EnableAllBreakpoints() { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + target_sp->EnableAllBreakpoints(); + return true; + } + return false; } - -lldb::SBModule -SBTarget::AddModule (const char *path, - const char *triple, - const char *uuid_cstr) -{ - return AddModule (path, triple, uuid_cstr, NULL); +bool SBTarget::DisableAllBreakpoints() { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + target_sp->DisableAllBreakpoints(); + return true; + } + return false; } -lldb::SBModule -SBTarget::AddModule (const char *path, - const char *triple, - const char *uuid_cstr, - const char *symfile) -{ - lldb::SBModule sb_module; - TargetSP target_sp(GetSP()); - if (target_sp) - { - ModuleSpec module_spec; - if (path) - module_spec.GetFileSpec().SetFile(path, false); - - if (uuid_cstr) - module_spec.GetUUID().SetFromCString(uuid_cstr); - - if (triple) - module_spec.GetArchitecture().SetTriple (triple, target_sp->GetPlatform ().get()); - else - module_spec.GetArchitecture() = target_sp->GetArchitecture(); - - if (symfile) - module_spec.GetSymbolFileSpec ().SetFile(symfile, false); - - sb_module.SetSP(target_sp->GetSharedModule (module_spec)); - } - return sb_module; +bool SBTarget::DeleteAllBreakpoints() { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + target_sp->RemoveAllBreakpoints(); + return true; + } + return false; +} + +lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, + SBBreakpointList &new_bps) { + SBStringList empty_name_list; + return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps); +} + +lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, + SBStringList &matching_names, + SBBreakpointList &new_bps) { + SBError sberr; + TargetSP target_sp(GetSP()); + if (!target_sp) { + sberr.SetErrorString( + "BreakpointCreateFromFile called with invalid target."); + return sberr; + } + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + BreakpointIDList bp_ids; + + std::vector<std::string> name_vector; + size_t num_names = matching_names.GetSize(); + for (size_t i = 0; i < num_names; i++) + name_vector.push_back(matching_names.GetStringAtIndex(i)); + + sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(), + name_vector, bp_ids); + if (sberr.Fail()) + return sberr; + + size_t num_bkpts = bp_ids.GetSize(); + for (size_t i = 0; i < num_bkpts; i++) { + BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i); + new_bps.AppendByID(bp_id.GetBreakpointID()); + } + return sberr; +} + +lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { + SBError sberr; + TargetSP target_sp(GetSP()); + if (!target_sp) { + sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); + return sberr; + } + SBBreakpointList bkpt_list(*this); + return BreakpointsWriteToFile(dest_file, bkpt_list); +} + +lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, + SBBreakpointList &bkpt_list, + bool append) { + SBError sberr; + TargetSP target_sp(GetSP()); + if (!target_sp) { + sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); + return sberr; + } + + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + BreakpointIDList bp_id_list; + bkpt_list.CopyToBreakpointIDList(bp_id_list); + sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(), + bp_id_list, append); + return sberr; +} + +uint32_t SBTarget::GetNumWatchpoints() const { + TargetSP target_sp(GetSP()); + if (target_sp) { + // The watchpoint list is thread safe, no need to lock + return target_sp->GetWatchpointList().GetSize(); + } + return 0; +} + +SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { + SBWatchpoint sb_watchpoint; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The watchpoint list is thread safe, no need to lock + sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx)); + } + return sb_watchpoint; +} + +bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + bool result = false; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + result = target_sp->RemoveWatchpointByID(wp_id); + } + + if (log) + log->Printf("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", + static_cast<void *>(target_sp.get()), + static_cast<uint32_t>(wp_id), result); + + return result; +} + +SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBWatchpoint sb_watchpoint; + lldb::WatchpointSP watchpoint_sp; + TargetSP target_sp(GetSP()); + if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id); + sb_watchpoint.SetSP(watchpoint_sp); + } + + if (log) + log->Printf( + "SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)", + static_cast<void *>(target_sp.get()), static_cast<uint32_t>(wp_id), + static_cast<void *>(watchpoint_sp.get())); + + return sb_watchpoint; +} + +lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, + bool read, bool write, + SBError &error) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBWatchpoint sb_watchpoint; + lldb::WatchpointSP watchpoint_sp; + TargetSP target_sp(GetSP()); + if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && + size > 0) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + uint32_t watch_type = 0; + if (read) + watch_type |= LLDB_WATCH_TYPE_READ; + if (write) + watch_type |= LLDB_WATCH_TYPE_WRITE; + if (watch_type == 0) { + error.SetErrorString( + "Can't create a watchpoint that is neither read nor write."); + return sb_watchpoint; + } + + // Target::CreateWatchpoint() is thread safe. + Error cw_error; + // This API doesn't take in a type, so we can't figure out what it is. + CompilerType *type = NULL; + watchpoint_sp = + target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error); + error.SetError(cw_error); + sb_watchpoint.SetSP(watchpoint_sp); + } + + if (log) + log->Printf("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64 + ", 0x%u) => SBWatchpoint(%p)", + static_cast<void *>(target_sp.get()), addr, + static_cast<uint32_t>(size), + static_cast<void *>(watchpoint_sp.get())); + + return sb_watchpoint; +} + +bool SBTarget::EnableAllWatchpoints() { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + target_sp->EnableAllWatchpoints(); + return true; + } + return false; } -lldb::SBModule -SBTarget::AddModule (const SBModuleSpec &module_spec) -{ - lldb::SBModule sb_module; - TargetSP target_sp(GetSP()); - if (target_sp) - sb_module.SetSP(target_sp->GetSharedModule (*module_spec.m_opaque_ap)); - return sb_module; +bool SBTarget::DisableAllWatchpoints() { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + target_sp->DisableAllWatchpoints(); + return true; + } + return false; +} + +SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, + SBType type) { + SBValue sb_value; + lldb::ValueObjectSP new_value_sp; + if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) { + lldb::addr_t load_addr(addr.GetLoadAddress(*this)); + ExecutionContext exe_ctx( + ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); + CompilerType ast_type(type.GetSP()->GetCompilerType(true)); + new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr, + exe_ctx, ast_type); + } + sb_value.SetSP(new_value_sp); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + if (log) { + if (new_value_sp) + log->Printf("SBTarget(%p)::CreateValueFromAddress => \"%s\"", + static_cast<void *>(m_opaque_sp.get()), + new_value_sp->GetName().AsCString()); + else + log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL", + static_cast<void *>(m_opaque_sp.get())); + } + return sb_value; +} + +lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, + lldb::SBType type) { + SBValue sb_value; + lldb::ValueObjectSP new_value_sp; + if (IsValid() && name && *name && data.IsValid() && type.IsValid()) { + DataExtractorSP extractor(*data); + ExecutionContext exe_ctx( + ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); + CompilerType ast_type(type.GetSP()->GetCompilerType(true)); + new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor, + exe_ctx, ast_type); + } + sb_value.SetSP(new_value_sp); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + if (log) { + if (new_value_sp) + log->Printf("SBTarget(%p)::CreateValueFromData => \"%s\"", + static_cast<void *>(m_opaque_sp.get()), + new_value_sp->GetName().AsCString()); + else + log->Printf("SBTarget(%p)::CreateValueFromData => NULL", + static_cast<void *>(m_opaque_sp.get())); + } + return sb_value; +} + +lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, + const char *expr) { + SBValue sb_value; + lldb::ValueObjectSP new_value_sp; + if (IsValid() && name && *name && expr && *expr) { + ExecutionContext exe_ctx( + ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); + new_value_sp = + ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx); + } + sb_value.SetSP(new_value_sp); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + if (log) { + if (new_value_sp) + log->Printf("SBTarget(%p)::CreateValueFromExpression => \"%s\"", + static_cast<void *>(m_opaque_sp.get()), + new_value_sp->GetName().AsCString()); + else + log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL", + static_cast<void *>(m_opaque_sp.get())); + } + return sb_value; +} + +bool SBTarget::DeleteAllWatchpoints() { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + target_sp->RemoveAllWatchpoints(); + return true; + } + return false; } -bool -SBTarget::AddModule (lldb::SBModule &module) -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - target_sp->GetImages().AppendIfNeeded (module.GetSP()); - return true; - } - return false; +lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, + const char *uuid_cstr) { + return AddModule(path, triple, uuid_cstr, NULL); } -uint32_t -SBTarget::GetNumModules () const -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); +lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, + const char *uuid_cstr, const char *symfile) { + lldb::SBModule sb_module; + TargetSP target_sp(GetSP()); + if (target_sp) { + ModuleSpec module_spec; + if (path) + module_spec.GetFileSpec().SetFile(path, false); - uint32_t num = 0; - TargetSP target_sp(GetSP()); - if (target_sp) - { - // The module list is thread safe, no need to lock - num = target_sp->GetImages().GetSize(); - } - - if (log) - log->Printf ("SBTarget(%p)::GetNumModules () => %d", - static_cast<void*>(target_sp.get()), num); + if (uuid_cstr) + module_spec.GetUUID().SetFromCString(uuid_cstr); - return num; -} - -void -SBTarget::Clear () -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); + if (triple) + module_spec.GetArchitecture().SetTriple(triple, + target_sp->GetPlatform().get()); + else + module_spec.GetArchitecture() = target_sp->GetArchitecture(); - if (log) - log->Printf ("SBTarget(%p)::Clear ()", - static_cast<void*>(m_opaque_sp.get())); + if (symfile) + module_spec.GetSymbolFileSpec().SetFile(symfile, false); - m_opaque_sp.reset(); + sb_module.SetSP(target_sp->GetSharedModule(module_spec)); + } + return sb_module; } - -SBModule -SBTarget::FindModule (const SBFileSpec &sb_file_spec) -{ - SBModule sb_module; - TargetSP target_sp(GetSP()); - if (target_sp && sb_file_spec.IsValid()) - { - ModuleSpec module_spec(*sb_file_spec); - // The module list is thread safe, no need to lock - sb_module.SetSP (target_sp->GetImages().FindFirstModule (module_spec)); - } - return sb_module; +lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { + lldb::SBModule sb_module; + TargetSP target_sp(GetSP()); + if (target_sp) + sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_ap)); + return sb_module; } -lldb::ByteOrder -SBTarget::GetByteOrder () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - return target_sp->GetArchitecture().GetByteOrder(); - return eByteOrderInvalid; +bool SBTarget::AddModule(lldb::SBModule &module) { + TargetSP target_sp(GetSP()); + if (target_sp) { + target_sp->GetImages().AppendIfNeeded(module.GetSP()); + return true; + } + return false; } -const char * -SBTarget::GetTriple () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::string triple (target_sp->GetArchitecture().GetTriple().str()); - // Unique the string so we don't run into ownership issues since - // the const strings put the string into the string pool once and - // the strings never comes out - ConstString const_triple (triple.c_str()); - return const_triple.GetCString(); - } - return NULL; -} +uint32_t SBTarget::GetNumModules() const { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); -uint32_t -SBTarget::GetDataByteSize () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - return target_sp->GetArchitecture().GetDataByteSize() ; - } - return 0; -} + uint32_t num = 0; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The module list is thread safe, no need to lock + num = target_sp->GetImages().GetSize(); + } -uint32_t -SBTarget::GetCodeByteSize () -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - return target_sp->GetArchitecture().GetCodeByteSize() ; - } - return 0; -} + if (log) + log->Printf("SBTarget(%p)::GetNumModules () => %d", + static_cast<void *>(target_sp.get()), num); -uint32_t -SBTarget::GetAddressByteSize() -{ - TargetSP target_sp(GetSP()); - if (target_sp) - return target_sp->GetArchitecture().GetAddressByteSize(); - return sizeof(void*); + return num; } +void SBTarget::Clear() { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); -SBModule -SBTarget::GetModuleAtIndex (uint32_t idx) -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - SBModule sb_module; - ModuleSP module_sp; - TargetSP target_sp(GetSP()); - if (target_sp) - { - // The module list is thread safe, no need to lock - module_sp = target_sp->GetImages().GetModuleAtIndex(idx); - sb_module.SetSP (module_sp); - } + if (log) + log->Printf("SBTarget(%p)::Clear ()", + static_cast<void *>(m_opaque_sp.get())); - if (log) - log->Printf ("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)", - static_cast<void*>(target_sp.get()), idx, - static_cast<void*>(module_sp.get())); - - return sb_module; + m_opaque_sp.reset(); } -bool -SBTarget::RemoveModule (lldb::SBModule module) -{ - TargetSP target_sp(GetSP()); - if (target_sp) - return target_sp->GetImages().Remove(module.GetSP()); - return false; +SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { + SBModule sb_module; + TargetSP target_sp(GetSP()); + if (target_sp && sb_file_spec.IsValid()) { + ModuleSpec module_spec(*sb_file_spec); + // The module list is thread safe, no need to lock + sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec)); + } + return sb_module; } - -SBBroadcaster -SBTarget::GetBroadcaster () const -{ - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); - - TargetSP target_sp(GetSP()); - SBBroadcaster broadcaster(target_sp.get(), false); - - if (log) - log->Printf ("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)", - static_cast<void*>(target_sp.get()), - static_cast<void*>(broadcaster.get())); - - return broadcaster; +lldb::ByteOrder SBTarget::GetByteOrder() { + TargetSP target_sp(GetSP()); + if (target_sp) + return target_sp->GetArchitecture().GetByteOrder(); + return eByteOrderInvalid; } -bool -SBTarget::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) -{ - Stream &strm = description.ref(); - - TargetSP target_sp(GetSP()); - if (target_sp) - { - target_sp->Dump (&strm, description_level); - } - else - strm.PutCString ("No value"); - - return true; +const char *SBTarget::GetTriple() { + TargetSP target_sp(GetSP()); + if (target_sp) { + std::string triple(target_sp->GetArchitecture().GetTriple().str()); + // Unique the string so we don't run into ownership issues since + // the const strings put the string into the string pool once and + // the strings never comes out + ConstString const_triple(triple.c_str()); + return const_triple.GetCString(); + } + return NULL; } -lldb::SBSymbolContextList -SBTarget::FindFunctions (const char *name, uint32_t name_type_mask) -{ - lldb::SBSymbolContextList sb_sc_list; - if (name && name[0]) - { - TargetSP target_sp(GetSP()); - if (target_sp) - { - const bool symbols_ok = true; - const bool inlines_ok = true; - const bool append = true; - target_sp->GetImages().FindFunctions (ConstString(name), - name_type_mask, - symbols_ok, - inlines_ok, - append, - *sb_sc_list); - } - } - return sb_sc_list; +uint32_t SBTarget::GetDataByteSize() { + TargetSP target_sp(GetSP()); + if (target_sp) { + return target_sp->GetArchitecture().GetDataByteSize(); + } + return 0; } -lldb::SBSymbolContextList -SBTarget::FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype) -{ - lldb::SBSymbolContextList sb_sc_list; - if (name && name[0]) - { - TargetSP target_sp(GetSP()); - if (target_sp) - { - std::string regexstr; - switch (matchtype) - { - case eMatchTypeRegex: - target_sp->GetImages().FindFunctions(RegularExpression(name), true, true, true, *sb_sc_list); - break; - case eMatchTypeStartsWith: - regexstr = llvm::Regex::escape(name) + ".*"; - target_sp->GetImages().FindFunctions(RegularExpression(regexstr.c_str()), true, true, true, *sb_sc_list); - break; - default: - target_sp->GetImages().FindFunctions(ConstString(name), eFunctionNameTypeAny, true, true, true, *sb_sc_list); - break; - } - } - } - return sb_sc_list; +uint32_t SBTarget::GetCodeByteSize() { + TargetSP target_sp(GetSP()); + if (target_sp) { + return target_sp->GetArchitecture().GetCodeByteSize(); + } + return 0; } -lldb::SBType -SBTarget::FindFirstType (const char* typename_cstr) -{ - TargetSP target_sp(GetSP()); - if (typename_cstr && typename_cstr[0] && target_sp) - { - ConstString const_typename(typename_cstr); - SymbolContext sc; - const bool exact_match = false; - - const ModuleList &module_list = target_sp->GetImages(); - size_t count = module_list.GetSize(); - for (size_t idx = 0; idx < count; idx++) - { - ModuleSP module_sp (module_list.GetModuleAtIndex(idx)); - if (module_sp) - { - TypeSP type_sp (module_sp->FindFirstType(sc, const_typename, exact_match)); - if (type_sp) - return SBType(type_sp); - } - } - - // Didn't find the type in the symbols; try the Objective-C runtime - // if one is installed - - ProcessSP process_sp(target_sp->GetProcessSP()); - - if (process_sp) - { - ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime(); - - if (objc_language_runtime) - { - DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); - - if (objc_decl_vendor) - { - std::vector <clang::NamedDecl *> decls; - - if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) - { - if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0])) - { - return SBType(type); - } - } - } - } - } +uint32_t SBTarget::GetAddressByteSize() { + TargetSP target_sp(GetSP()); + if (target_sp) + return target_sp->GetArchitecture().GetAddressByteSize(); + return sizeof(void *); +} - // No matches, search for basic typename matches - ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); - if (clang_ast) - return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename)); - } - return SBType(); -} - -SBType -SBTarget::GetBasicType(lldb::BasicType type) -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); - if (clang_ast) - return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), type)); - } - return SBType(); -} +SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + SBModule sb_module; + ModuleSP module_sp; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The module list is thread safe, no need to lock + module_sp = target_sp->GetImages().GetModuleAtIndex(idx); + sb_module.SetSP(module_sp); + } + + if (log) + log->Printf("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)", + static_cast<void *>(target_sp.get()), idx, + static_cast<void *>(module_sp.get())); + + return sb_module; +} + +bool SBTarget::RemoveModule(lldb::SBModule module) { + TargetSP target_sp(GetSP()); + if (target_sp) + return target_sp->GetImages().Remove(module.GetSP()); + return false; +} + +SBBroadcaster SBTarget::GetBroadcaster() const { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + TargetSP target_sp(GetSP()); + SBBroadcaster broadcaster(target_sp.get(), false); -lldb::SBTypeList -SBTarget::FindTypes (const char* typename_cstr) -{ - SBTypeList sb_type_list; - TargetSP target_sp(GetSP()); - if (typename_cstr && typename_cstr[0] && target_sp) - { - ModuleList& images = target_sp->GetImages(); - ConstString const_typename(typename_cstr); - bool exact_match = false; - SymbolContext sc; - TypeList type_list; - llvm::DenseSet<SymbolFile *> searched_symbol_files; - uint32_t num_matches = images.FindTypes (sc, - const_typename, - exact_match, - UINT32_MAX, - searched_symbol_files, - type_list); - - if (num_matches > 0) - { - for (size_t idx = 0; idx < num_matches; idx++) - { - TypeSP type_sp (type_list.GetTypeAtIndex(idx)); - if (type_sp) - sb_type_list.Append(SBType(type_sp)); + if (log) + log->Printf("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)", + static_cast<void *>(target_sp.get()), + static_cast<void *>(broadcaster.get())); + + return broadcaster; +} + +bool SBTarget::GetDescription(SBStream &description, + lldb::DescriptionLevel description_level) { + Stream &strm = description.ref(); + + TargetSP target_sp(GetSP()); + if (target_sp) { + target_sp->Dump(&strm, description_level); + } else + strm.PutCString("No value"); + + return true; +} + +lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, + uint32_t name_type_mask) { + lldb::SBSymbolContextList sb_sc_list; + if (name && name[0]) { + TargetSP target_sp(GetSP()); + if (target_sp) { + const bool symbols_ok = true; + const bool inlines_ok = true; + const bool append = true; + target_sp->GetImages().FindFunctions(ConstString(name), name_type_mask, + symbols_ok, inlines_ok, append, + *sb_sc_list); + } + } + return sb_sc_list; +} + +lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, + uint32_t max_matches, + MatchType matchtype) { + lldb::SBSymbolContextList sb_sc_list; + if (name && name[0]) { + llvm::StringRef name_ref(name); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::string regexstr; + switch (matchtype) { + case eMatchTypeRegex: + target_sp->GetImages().FindFunctions(RegularExpression(name_ref), true, + true, true, *sb_sc_list); + break; + case eMatchTypeStartsWith: + regexstr = llvm::Regex::escape(name) + ".*"; + target_sp->GetImages().FindFunctions(RegularExpression(regexstr), true, + true, true, *sb_sc_list); + break; + default: + target_sp->GetImages().FindFunctions(ConstString(name), + eFunctionNameTypeAny, true, true, + true, *sb_sc_list); + break; + } + } + } + return sb_sc_list; +} + +lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { + TargetSP target_sp(GetSP()); + if (typename_cstr && typename_cstr[0] && target_sp) { + ConstString const_typename(typename_cstr); + SymbolContext sc; + const bool exact_match = false; + + const ModuleList &module_list = target_sp->GetImages(); + size_t count = module_list.GetSize(); + for (size_t idx = 0; idx < count; idx++) { + ModuleSP module_sp(module_list.GetModuleAtIndex(idx)); + if (module_sp) { + TypeSP type_sp( + module_sp->FindFirstType(sc, const_typename, exact_match)); + if (type_sp) + return SBType(type_sp); + } + } + + // Didn't find the type in the symbols; try the Objective-C runtime + // if one is installed + + ProcessSP process_sp(target_sp->GetProcessSP()); + + if (process_sp) { + ObjCLanguageRuntime *objc_language_runtime = + process_sp->GetObjCLanguageRuntime(); + + if (objc_language_runtime) { + DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); + + if (objc_decl_vendor) { + std::vector<clang::NamedDecl *> decls; + + if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) { + if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0])) { + return SBType(type); } + } } - - // Try the Objective-C runtime if one is installed - - ProcessSP process_sp(target_sp->GetProcessSP()); - - if (process_sp) - { - ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime(); - - if (objc_language_runtime) - { - DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); - - if (objc_decl_vendor) - { - std::vector <clang::NamedDecl *> decls; - - if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) - { - for (clang::NamedDecl *decl : decls) - { - if (CompilerType type = ClangASTContext::GetTypeForDecl(decl)) - { - sb_type_list.Append(SBType(type)); - } - } - } - } + } + } + + // No matches, search for basic typename matches + ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); + if (clang_ast) + return SBType(ClangASTContext::GetBasicType(clang_ast->getASTContext(), + const_typename)); + } + return SBType(); +} + +SBType SBTarget::GetBasicType(lldb::BasicType type) { + TargetSP target_sp(GetSP()); + if (target_sp) { + ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); + if (clang_ast) + return SBType( + ClangASTContext::GetBasicType(clang_ast->getASTContext(), type)); + } + return SBType(); +} + +lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { + SBTypeList sb_type_list; + TargetSP target_sp(GetSP()); + if (typename_cstr && typename_cstr[0] && target_sp) { + ModuleList &images = target_sp->GetImages(); + ConstString const_typename(typename_cstr); + bool exact_match = false; + SymbolContext sc; + TypeList type_list; + llvm::DenseSet<SymbolFile *> searched_symbol_files; + uint32_t num_matches = + images.FindTypes(sc, const_typename, exact_match, UINT32_MAX, + searched_symbol_files, type_list); + + if (num_matches > 0) { + for (size_t idx = 0; idx < num_matches; idx++) { + TypeSP type_sp(type_list.GetTypeAtIndex(idx)); + if (type_sp) + sb_type_list.Append(SBType(type_sp)); + } + } + + // Try the Objective-C runtime if one is installed + + ProcessSP process_sp(target_sp->GetProcessSP()); + + if (process_sp) { + ObjCLanguageRuntime *objc_language_runtime = + process_sp->GetObjCLanguageRuntime(); + + if (objc_language_runtime) { + DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); + + if (objc_decl_vendor) { + std::vector<clang::NamedDecl *> decls; + + if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) { + for (clang::NamedDecl *decl : decls) { + if (CompilerType type = ClangASTContext::GetTypeForDecl(decl)) { + sb_type_list.Append(SBType(type)); + } } + } } - - if (sb_type_list.GetSize() == 0) - { - // No matches, search for basic typename matches - ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); - if (clang_ast) - sb_type_list.Append (SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename))); - } - } - return sb_type_list; -} + } + } -SBValueList -SBTarget::FindGlobalVariables (const char *name, uint32_t max_matches) -{ - SBValueList sb_value_list; - - TargetSP target_sp(GetSP()); - if (name && target_sp) - { - VariableList variable_list; - const bool append = true; - const uint32_t match_count = target_sp->GetImages().FindGlobalVariables (ConstString (name), - append, - max_matches, - variable_list); - - if (match_count > 0) - { - ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); - if (exe_scope == NULL) - exe_scope = target_sp.get(); - for (uint32_t i=0; i<match_count; ++i) - { - lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i))); - if (valobj_sp) - sb_value_list.Append(SBValue(valobj_sp)); - } - } - } + if (sb_type_list.GetSize() == 0) { + // No matches, search for basic typename matches + ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); + if (clang_ast) + sb_type_list.Append(SBType(ClangASTContext::GetBasicType( + clang_ast->getASTContext(), const_typename))); + } + } + return sb_type_list; +} + +SBValueList SBTarget::FindGlobalVariables(const char *name, + uint32_t max_matches) { + SBValueList sb_value_list; + + TargetSP target_sp(GetSP()); + if (name && target_sp) { + VariableList variable_list; + const bool append = true; + const uint32_t match_count = target_sp->GetImages().FindGlobalVariables( + ConstString(name), append, max_matches, variable_list); + + if (match_count > 0) { + ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); + if (exe_scope == NULL) + exe_scope = target_sp.get(); + for (uint32_t i = 0; i < match_count; ++i) { + lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create( + exe_scope, variable_list.GetVariableAtIndex(i))); + if (valobj_sp) + sb_value_list.Append(SBValue(valobj_sp)); + } + } + } + + return sb_value_list; +} + +SBValueList SBTarget::FindGlobalVariables(const char *name, + uint32_t max_matches, + MatchType matchtype) { + SBValueList sb_value_list; + + TargetSP target_sp(GetSP()); + if (name && target_sp) { + llvm::StringRef name_ref(name); + VariableList variable_list; + const bool append = true; + + std::string regexstr; + uint32_t match_count; + switch (matchtype) { + case eMatchTypeNormal: + match_count = target_sp->GetImages().FindGlobalVariables( + ConstString(name), append, max_matches, variable_list); + break; + case eMatchTypeRegex: + match_count = target_sp->GetImages().FindGlobalVariables( + RegularExpression(name_ref), append, max_matches, variable_list); + break; + case eMatchTypeStartsWith: + regexstr = llvm::Regex::escape(name) + ".*"; + match_count = target_sp->GetImages().FindGlobalVariables( + RegularExpression(regexstr), append, max_matches, variable_list); + break; + } + + if (match_count > 0) { + ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); + if (exe_scope == NULL) + exe_scope = target_sp.get(); + for (uint32_t i = 0; i < match_count; ++i) { + lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create( + exe_scope, variable_list.GetVariableAtIndex(i))); + if (valobj_sp) + sb_value_list.Append(SBValue(valobj_sp)); + } + } + } + + return sb_value_list; +} + +lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { + SBValueList sb_value_list(FindGlobalVariables(name, 1)); + if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) + return sb_value_list.GetValueAtIndex(0); + return SBValue(); +} + +SBSourceManager SBTarget::GetSourceManager() { + SBSourceManager source_manager(*this); + return source_manager; +} + +lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, + uint32_t count) { + return ReadInstructions(base_addr, count, NULL); +} + +lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, + uint32_t count, + const char *flavor_string) { + SBInstructionList sb_instructions; + + TargetSP target_sp(GetSP()); + if (target_sp) { + Address *addr_ptr = base_addr.get(); + + if (addr_ptr) { + DataBufferHeap data( + target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0); + bool prefer_file_cache = false; + lldb_private::Error error; + lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; + const size_t bytes_read = + target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(), + data.GetByteSize(), error, &load_addr); + const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; + sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( + target_sp->GetArchitecture(), NULL, flavor_string, *addr_ptr, + data.GetBytes(), bytes_read, count, data_from_file)); + } + } + + return sb_instructions; +} - return sb_value_list; +lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr, + const void *buf, + size_t size) { + return GetInstructionsWithFlavor(base_addr, NULL, buf, size); } -SBValueList -SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches, MatchType matchtype) -{ - SBValueList sb_value_list; - - TargetSP target_sp(GetSP()); - if (name && target_sp) - { - VariableList variable_list; - const bool append = true; - - std::string regexstr; - uint32_t match_count; - switch (matchtype) - { - case eMatchTypeNormal: - match_count = target_sp->GetImages().FindGlobalVariables(ConstString(name), - append, - max_matches, - variable_list); - break; - case eMatchTypeRegex: - match_count = target_sp->GetImages().FindGlobalVariables(RegularExpression(name), - append, - max_matches, - variable_list); - break; - case eMatchTypeStartsWith: - regexstr = llvm::Regex::escape(name) + ".*"; - match_count = target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr.c_str()), - append, - max_matches, - variable_list); - break; - } - +lldb::SBInstructionList +SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr, + const char *flavor_string, const void *buf, + size_t size) { + SBInstructionList sb_instructions; - if (match_count > 0) - { - ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); - if (exe_scope == NULL) - exe_scope = target_sp.get(); - for (uint32_t i = 0; i<match_count; ++i) - { - lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create(exe_scope, variable_list.GetVariableAtIndex(i))); - if (valobj_sp) - sb_value_list.Append(SBValue(valobj_sp)); - } - } - } + TargetSP target_sp(GetSP()); + if (target_sp) { + Address addr; - return sb_value_list; -} + if (base_addr.get()) + addr = *base_addr.get(); + const bool data_from_file = true; -lldb::SBValue -SBTarget::FindFirstGlobalVariable (const char* name) -{ - SBValueList sb_value_list(FindGlobalVariables(name, 1)); - if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) - return sb_value_list.GetValueAtIndex(0); - return SBValue(); -} + sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( + target_sp->GetArchitecture(), NULL, flavor_string, addr, buf, size, + UINT32_MAX, data_from_file)); + } -SBSourceManager -SBTarget::GetSourceManager() -{ - SBSourceManager source_manager (*this); - return source_manager; + return sb_instructions; } -lldb::SBInstructionList -SBTarget::ReadInstructions (lldb::SBAddress base_addr, uint32_t count) -{ - return ReadInstructions (base_addr, count, NULL); +lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr, + const void *buf, + size_t size) { + return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), NULL, buf, + size); } lldb::SBInstructionList -SBTarget::ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string) -{ - SBInstructionList sb_instructions; - - TargetSP target_sp(GetSP()); - if (target_sp) - { - Address *addr_ptr = base_addr.get(); - - if (addr_ptr) - { - DataBufferHeap data (target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0); - bool prefer_file_cache = false; - lldb_private::Error error; - lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; - const size_t bytes_read = target_sp->ReadMemory(*addr_ptr, - prefer_file_cache, - data.GetBytes(), - data.GetByteSize(), - error, - &load_addr); - const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; - sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(), - NULL, - flavor_string, - *addr_ptr, - data.GetBytes(), - bytes_read, - count, - data_from_file)); +SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr, + const char *flavor_string, const void *buf, + size_t size) { + return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string, + buf, size); +} + +SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, + lldb::addr_t section_base_addr) { + SBError sb_error; + TargetSP target_sp(GetSP()); + if (target_sp) { + if (!section.IsValid()) { + sb_error.SetErrorStringWithFormat("invalid section"); + } else { + SectionSP section_sp(section.GetSP()); + if (section_sp) { + if (section_sp->IsThreadSpecific()) { + sb_error.SetErrorString( + "thread specific sections are not yet supported"); + } else { + ProcessSP process_sp(target_sp->GetProcessSP()); + if (target_sp->SetSectionLoadAddress(section_sp, section_base_addr)) { + ModuleSP module_sp(section_sp->GetModule()); + if (module_sp) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidLoad(module_list); + } + // Flush info in the process (stack frames, etc) + if (process_sp) + process_sp->Flush(); + } } + } } - - return sb_instructions; - + } else { + sb_error.SetErrorString("invalid target"); + } + return sb_error; } -lldb::SBInstructionList -SBTarget::GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size) -{ - return GetInstructionsWithFlavor (base_addr, NULL, buf, size); -} - -lldb::SBInstructionList -SBTarget::GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size) -{ - SBInstructionList sb_instructions; - - TargetSP target_sp(GetSP()); - if (target_sp) - { - Address addr; - - if (base_addr.get()) - addr = *base_addr.get(); - - const bool data_from_file = true; - - sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(), - NULL, - flavor_string, - addr, - buf, - size, - UINT32_MAX, - data_from_file)); - } +SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { + SBError sb_error; - return sb_instructions; -} - -lldb::SBInstructionList -SBTarget::GetInstructions (lldb::addr_t base_addr, const void *buf, size_t size) -{ - return GetInstructionsWithFlavor (ResolveLoadAddress(base_addr), NULL, buf, size); -} - -lldb::SBInstructionList -SBTarget::GetInstructionsWithFlavor (lldb::addr_t base_addr, const char *flavor_string, const void *buf, size_t size) -{ - return GetInstructionsWithFlavor (ResolveLoadAddress(base_addr), flavor_string, buf, size); -} - -SBError -SBTarget::SetSectionLoadAddress (lldb::SBSection section, - lldb::addr_t section_base_addr) -{ - SBError sb_error; - TargetSP target_sp(GetSP()); - if (target_sp) - { - if (!section.IsValid()) - { - sb_error.SetErrorStringWithFormat ("invalid section"); - } - else - { - SectionSP section_sp (section.GetSP()); - if (section_sp) - { - if (section_sp->IsThreadSpecific()) - { - sb_error.SetErrorString ("thread specific sections are not yet supported"); - } - else - { - ProcessSP process_sp (target_sp->GetProcessSP()); - if (target_sp->SetSectionLoadAddress (section_sp, section_base_addr)) - { - ModuleSP module_sp(section_sp->GetModule()); - if (module_sp) - { - ModuleList module_list; - module_list.Append(module_sp); - target_sp->ModulesDidLoad (module_list); - } - // Flush info in the process (stack frames, etc) - if (process_sp) - process_sp->Flush(); - } - } - } + TargetSP target_sp(GetSP()); + if (target_sp) { + if (!section.IsValid()) { + sb_error.SetErrorStringWithFormat("invalid section"); + } else { + SectionSP section_sp(section.GetSP()); + if (section_sp) { + ProcessSP process_sp(target_sp->GetProcessSP()); + if (target_sp->SetSectionUnloaded(section_sp)) { + ModuleSP module_sp(section_sp->GetModule()); + if (module_sp) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidUnload(module_list, false); + } + // Flush info in the process (stack frames, etc) + if (process_sp) + process_sp->Flush(); } - } - else - { - sb_error.SetErrorString ("invalid target"); - } - return sb_error; -} - -SBError -SBTarget::ClearSectionLoadAddress (lldb::SBSection section) -{ - SBError sb_error; - - TargetSP target_sp(GetSP()); - if (target_sp) - { - if (!section.IsValid()) - { - sb_error.SetErrorStringWithFormat ("invalid section"); + } else { + sb_error.SetErrorStringWithFormat("invalid section"); + } + } + } else { + sb_error.SetErrorStringWithFormat("invalid target"); + } + return sb_error; +} + +SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, + int64_t slide_offset) { + SBError sb_error; + + TargetSP target_sp(GetSP()); + if (target_sp) { + ModuleSP module_sp(module.GetSP()); + if (module_sp) { + bool changed = false; + if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) { + // The load was successful, make sure that at least some sections + // changed before we notify that our module was loaded. + if (changed) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidLoad(module_list); + // Flush info in the process (stack frames, etc) + ProcessSP process_sp(target_sp->GetProcessSP()); + if (process_sp) + process_sp->Flush(); } - else - { - SectionSP section_sp (section.GetSP()); + } + } else { + sb_error.SetErrorStringWithFormat("invalid module"); + } + + } else { + sb_error.SetErrorStringWithFormat("invalid target"); + } + return sb_error; +} + +SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { + SBError sb_error; + + char path[PATH_MAX]; + TargetSP target_sp(GetSP()); + if (target_sp) { + ModuleSP module_sp(module.GetSP()); + if (module_sp) { + ObjectFile *objfile = module_sp->GetObjectFile(); + if (objfile) { + SectionList *section_list = objfile->GetSectionList(); + if (section_list) { + ProcessSP process_sp(target_sp->GetProcessSP()); + + bool changed = false; + const size_t num_sections = section_list->GetSize(); + for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) { + SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx)); if (section_sp) - { - ProcessSP process_sp (target_sp->GetProcessSP()); - if (target_sp->SetSectionUnloaded(section_sp)) - { - ModuleSP module_sp(section_sp->GetModule()); - if (module_sp) - { - ModuleList module_list; - module_list.Append(module_sp); - target_sp->ModulesDidUnload(module_list, false); - } - // Flush info in the process (stack frames, etc) - if (process_sp) - process_sp->Flush(); - } - } - else - { - sb_error.SetErrorStringWithFormat ("invalid section"); - } - } - } - else - { - sb_error.SetErrorStringWithFormat ("invalid target"); - } - return sb_error; -} - -SBError -SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset) -{ - SBError sb_error; - - TargetSP target_sp(GetSP()); - if (target_sp) - { - ModuleSP module_sp (module.GetSP()); - if (module_sp) - { - bool changed = false; - if (module_sp->SetLoadAddress (*target_sp, slide_offset, true, changed)) - { - // The load was successful, make sure that at least some sections - // changed before we notify that our module was loaded. - if (changed) - { - ModuleList module_list; - module_list.Append(module_sp); - target_sp->ModulesDidLoad (module_list); - // Flush info in the process (stack frames, etc) - ProcessSP process_sp (target_sp->GetProcessSP()); - if (process_sp) - process_sp->Flush(); - } - } - } - else - { - sb_error.SetErrorStringWithFormat ("invalid module"); + changed |= target_sp->SetSectionUnloaded(section_sp); + } + if (changed) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidUnload(module_list, false); + // Flush info in the process (stack frames, etc) + ProcessSP process_sp(target_sp->GetProcessSP()); + if (process_sp) + process_sp->Flush(); + } + } else { + module_sp->GetFileSpec().GetPath(path, sizeof(path)); + sb_error.SetErrorStringWithFormat("no sections in object file '%s'", + path); } - + } else { + module_sp->GetFileSpec().GetPath(path, sizeof(path)); + sb_error.SetErrorStringWithFormat("no object file for module '%s'", + path); + } + } else { + sb_error.SetErrorStringWithFormat("invalid module"); } - else - { - sb_error.SetErrorStringWithFormat ("invalid target"); - } - return sb_error; + } else { + sb_error.SetErrorStringWithFormat("invalid target"); + } + return sb_error; } -SBError -SBTarget::ClearModuleLoadAddress (lldb::SBModule module) -{ - SBError sb_error; - - char path[PATH_MAX]; +lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, + lldb::SymbolType symbol_type) { + SBSymbolContextList sb_sc_list; + if (name && name[0]) { TargetSP target_sp(GetSP()); - if (target_sp) - { - ModuleSP module_sp (module.GetSP()); - if (module_sp) - { - ObjectFile *objfile = module_sp->GetObjectFile(); - if (objfile) - { - SectionList *section_list = objfile->GetSectionList(); - if (section_list) - { - ProcessSP process_sp (target_sp->GetProcessSP()); - - bool changed = false; - const size_t num_sections = section_list->GetSize(); - for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) - { - SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx)); - if (section_sp) - changed |= target_sp->SetSectionUnloaded (section_sp); - } - if (changed) - { - ModuleList module_list; - module_list.Append(module_sp); - target_sp->ModulesDidUnload(module_list, false); - // Flush info in the process (stack frames, etc) - ProcessSP process_sp (target_sp->GetProcessSP()); - if (process_sp) - process_sp->Flush(); - } - } - else - { - module_sp->GetFileSpec().GetPath (path, sizeof(path)); - sb_error.SetErrorStringWithFormat ("no sections in object file '%s'", path); - } - } - else - { - module_sp->GetFileSpec().GetPath (path, sizeof(path)); - sb_error.SetErrorStringWithFormat ("no object file for module '%s'", path); - } - } - else - { - sb_error.SetErrorStringWithFormat ("invalid module"); - } - } - else - { - sb_error.SetErrorStringWithFormat ("invalid target"); - } - return sb_error; -} - - -lldb::SBSymbolContextList -SBTarget::FindSymbols (const char *name, lldb::SymbolType symbol_type) -{ - SBSymbolContextList sb_sc_list; - if (name && name[0]) - { - TargetSP target_sp(GetSP()); - if (target_sp) - { - bool append = true; - target_sp->GetImages().FindSymbolsWithNameAndType (ConstString(name), - symbol_type, - *sb_sc_list, - append); - } + if (target_sp) { + bool append = true; + target_sp->GetImages().FindSymbolsWithNameAndType( + ConstString(name), symbol_type, *sb_sc_list, append); } - return sb_sc_list; - + } + return sb_sc_list; } -lldb::SBValue -SBTarget::EvaluateExpression (const char *expr) -{ - TargetSP target_sp(GetSP()); - if (!target_sp) - return SBValue(); +lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { + TargetSP target_sp(GetSP()); + if (!target_sp) + return SBValue(); - SBExpressionOptions options; - lldb::DynamicValueType fetch_dynamic_value = target_sp->GetPreferDynamicValue(); - options.SetFetchDynamicValue (fetch_dynamic_value); - options.SetUnwindOnError (true); - return EvaluateExpression(expr, options); + SBExpressionOptions options; + lldb::DynamicValueType fetch_dynamic_value = + target_sp->GetPreferDynamicValue(); + options.SetFetchDynamicValue(fetch_dynamic_value); + options.SetUnwindOnError(true); + return EvaluateExpression(expr, options); } -lldb::SBValue -SBTarget::EvaluateExpression (const char *expr, const SBExpressionOptions &options) -{ - Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); +lldb::SBValue SBTarget::EvaluateExpression(const char *expr, + const SBExpressionOptions &options) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); #if !defined(LLDB_DISABLE_PYTHON) - Log * expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); + Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); #endif - SBValue expr_result; - ExpressionResults exe_results = eExpressionSetupError; - ValueObjectSP expr_value_sp; - TargetSP target_sp(GetSP()); - StackFrame *frame = NULL; - if (target_sp) - { - if (expr == NULL || expr[0] == '\0') - { - if (log) - log->Printf ("SBTarget::EvaluateExpression called with an empty expression"); - return expr_result; - } + SBValue expr_result; + ExpressionResults exe_results = eExpressionSetupError; + ValueObjectSP expr_value_sp; + TargetSP target_sp(GetSP()); + StackFrame *frame = NULL; + if (target_sp) { + if (expr == NULL || expr[0] == '\0') { + if (log) + log->Printf( + "SBTarget::EvaluateExpression called with an empty expression"); + return expr_result; + } + + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + ExecutionContext exe_ctx(m_opaque_sp.get()); - std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - ExecutionContext exe_ctx (m_opaque_sp.get()); - - if (log) - log->Printf ("SBTarget()::EvaluateExpression (expr=\"%s\")...", expr); + if (log) + log->Printf("SBTarget()::EvaluateExpression (expr=\"%s\")...", expr); - frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); + frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); - if (target) - { + if (target) { #ifdef LLDB_CONFIGURATION_DEBUG - StreamString frame_description; - if (frame) - frame->DumpUsingSettingsFormat (&frame_description); - Host::SetCrashDescriptionWithFormat ("SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s", - expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str()); + StreamString frame_description; + if (frame) + frame->DumpUsingSettingsFormat(&frame_description); + llvm::PrettyStackTraceFormat stack_trace( + "SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = " + "%u) %s", + expr, options.GetFetchDynamicValue(), + frame_description.GetString().str().c_str()); #endif - exe_results = target->EvaluateExpression (expr, - frame, - expr_value_sp, - options.ref()); + exe_results = + target->EvaluateExpression(expr, frame, expr_value_sp, options.ref()); - expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); -#ifdef LLDB_CONFIGURATION_DEBUG - Host::SetCrashDescription (NULL); -#endif - } - else - { - if (log) - log->Printf ("SBTarget::EvaluateExpression () => error: could not reconstruct frame object for this SBTarget."); - } + expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); + } else { + if (log) + log->Printf("SBTarget::EvaluateExpression () => error: could not " + "reconstruct frame object for this SBTarget."); } + } #ifndef LLDB_DISABLE_PYTHON - if (expr_log) - expr_log->Printf("** [SBTarget::EvaluateExpression] Expression result is %s, summary %s **", - expr_result.GetValue(), expr_result.GetSummary()); - - if (log) - log->Printf ("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) (execution result=%d)", - static_cast<void*>(frame), expr, - static_cast<void*>(expr_value_sp.get()), exe_results); + if (expr_log) + expr_log->Printf("** [SBTarget::EvaluateExpression] Expression result is " + "%s, summary %s **", + expr_result.GetValue(), expr_result.GetSummary()); + + if (log) + log->Printf("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) " + "(execution result=%d)", + static_cast<void *>(frame), expr, + static_cast<void *>(expr_value_sp.get()), exe_results); #endif - return expr_result; + return expr_result; } - -lldb::addr_t -SBTarget::GetStackRedZoneSize() -{ - TargetSP target_sp(GetSP()); - if (target_sp) - { - ABISP abi_sp; - ProcessSP process_sp (target_sp->GetProcessSP()); - if (process_sp) - abi_sp = process_sp->GetABI(); - else - abi_sp = ABI::FindPlugin(target_sp->GetArchitecture()); - if (abi_sp) - return abi_sp->GetRedZoneSize(); - } - return 0; +lldb::addr_t SBTarget::GetStackRedZoneSize() { + TargetSP target_sp(GetSP()); + if (target_sp) { + ABISP abi_sp; + ProcessSP process_sp(target_sp->GetProcessSP()); + if (process_sp) + abi_sp = process_sp->GetABI(); + else + abi_sp = ABI::FindPlugin(target_sp->GetArchitecture()); + if (abi_sp) + return abi_sp->GetRedZoneSize(); + } + return 0; } -lldb::SBLaunchInfo -SBTarget::GetLaunchInfo () const -{ - lldb::SBLaunchInfo launch_info(NULL); - TargetSP target_sp(GetSP()); - if (target_sp) - launch_info.ref() = m_opaque_sp->GetProcessLaunchInfo(); - return launch_info; +lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { + lldb::SBLaunchInfo launch_info(NULL); + TargetSP target_sp(GetSP()); + if (target_sp) + launch_info.ref() = m_opaque_sp->GetProcessLaunchInfo(); + return launch_info; } -void -SBTarget::SetLaunchInfo (const lldb::SBLaunchInfo &launch_info) -{ - TargetSP target_sp(GetSP()); - if (target_sp) - m_opaque_sp->SetProcessLaunchInfo(launch_info.ref()); +void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { + TargetSP target_sp(GetSP()); + if (target_sp) + m_opaque_sp->SetProcessLaunchInfo(launch_info.ref()); } |