diff options
Diffstat (limited to 'contrib/llvm/tools/lldb/source/API')
49 files changed, 905 insertions, 635 deletions
diff --git a/contrib/llvm/tools/lldb/source/API/SBAddress.cpp b/contrib/llvm/tools/lldb/source/API/SBAddress.cpp index 0ef374f..a3493d7 100644 --- a/contrib/llvm/tools/lldb/source/API/SBAddress.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBAddress.cpp @@ -12,11 +12,11 @@ #include "lldb/API/SBSection.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Address.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" -#include "lldb/Core/StreamString.h" #include "lldb/Symbol/LineEntry.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/StreamString.h" using namespace lldb; using namespace lldb_private; @@ -55,6 +55,12 @@ const SBAddress &SBAddress::operator=(const SBAddress &rhs) { return *this; } +bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) { + if (lhs.IsValid() && rhs.IsValid()) + return lhs.ref() == rhs.ref(); + return false; +} + bool SBAddress::IsValid() const { return m_opaque_ap.get() != NULL && m_opaque_ap->IsValid(); } diff --git a/contrib/llvm/tools/lldb/source/API/SBBlock.cpp b/contrib/llvm/tools/lldb/source/API/SBBlock.cpp index 471b7fb..cd45387 100644 --- a/contrib/llvm/tools/lldb/source/API/SBBlock.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBBlock.cpp @@ -14,7 +14,6 @@ #include "lldb/API/SBStream.h" #include "lldb/API/SBValue.h" #include "lldb/Core/AddressRange.h" -#include "lldb/Core/Log.h" #include "lldb/Core/ValueObjectVariable.h" #include "lldb/Symbol/Block.h" #include "lldb/Symbol/Function.h" @@ -22,6 +21,7 @@ #include "lldb/Symbol/VariableList.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBBreakpoint.cpp b/contrib/llvm/tools/lldb/source/API/SBBreakpoint.cpp index 0eab2c2..bf96032 100644 --- a/contrib/llvm/tools/lldb/source/API/SBBreakpoint.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBBreakpoint.cpp @@ -26,8 +26,6 @@ #include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Core/Address.h" #include "lldb/Core/Debugger.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h" @@ -36,6 +34,8 @@ #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" #include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include "lldb/lldb-enumerations.h" @@ -59,83 +59,74 @@ public: } }; -SBBreakpoint::SBBreakpoint() : m_opaque_sp() {} +SBBreakpoint::SBBreakpoint() {} SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_wp(rhs.m_opaque_wp) {} SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp) - : m_opaque_sp(bp_sp) {} + : m_opaque_wp(bp_sp) {} SBBreakpoint::~SBBreakpoint() = default; const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) { - if (this != &rhs) - m_opaque_sp = rhs.m_opaque_sp; + m_opaque_wp = rhs.m_opaque_wp; return *this; } bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) { - if (m_opaque_sp && rhs.m_opaque_sp) - return m_opaque_sp.get() == rhs.m_opaque_sp.get(); - return false; + return m_opaque_wp.lock() == rhs.m_opaque_wp.lock(); } bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) { - if (m_opaque_sp && rhs.m_opaque_sp) - return m_opaque_sp.get() != rhs.m_opaque_sp.get(); - return (m_opaque_sp && !rhs.m_opaque_sp) || (rhs.m_opaque_sp && !m_opaque_sp); + return m_opaque_wp.lock() != rhs.m_opaque_wp.lock(); } break_id_t SBBreakpoint::GetID() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); break_id_t break_id = LLDB_INVALID_BREAK_ID; - if (m_opaque_sp) - break_id = m_opaque_sp->GetID(); - - if (log) { - if (break_id == LLDB_INVALID_BREAK_ID) - log->Printf("SBBreakpoint(%p)::GetID () => LLDB_INVALID_BREAK_ID", - static_cast<void *>(m_opaque_sp.get())); - else - log->Printf("SBBreakpoint(%p)::GetID () => %u", - static_cast<void *>(m_opaque_sp.get()), break_id); - } + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) + break_id = bkpt_sp->GetID(); + LLDB_LOG(log, "breakpoint = {0}, id = {1}", bkpt_sp.get(), break_id); return break_id; } bool SBBreakpoint::IsValid() const { - if (!m_opaque_sp) + BreakpointSP bkpt_sp = GetSP(); + if (!bkpt_sp) return false; - else if (m_opaque_sp->GetTarget().GetBreakpointByID(m_opaque_sp->GetID())) + else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID())) return true; else return false; } void SBBreakpoint::ClearAllBreakpointSites() { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->ClearAllBreakpointSites(); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->ClearAllBreakpointSites(); } } SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) { SBBreakpointLocation sb_bp_location; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { if (vm_addr != LLDB_INVALID_ADDRESS) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); Address address; - Target &target = m_opaque_sp->GetTarget(); + Target &target = bkpt_sp->GetTarget(); if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) { address.SetRawAddress(vm_addr); } - sb_bp_location.SetLocation(m_opaque_sp->FindLocationByAddress(address)); + sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address)); } } return sb_bp_location; @@ -143,16 +134,17 @@ SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) { break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) { break_id_t break_id = LLDB_INVALID_BREAK_ID; + BreakpointSP bkpt_sp = GetSP(); - if (m_opaque_sp && vm_addr != LLDB_INVALID_ADDRESS) { + if (bkpt_sp && vm_addr != LLDB_INVALID_ADDRESS) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); Address address; - Target &target = m_opaque_sp->GetTarget(); + Target &target = bkpt_sp->GetTarget(); if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) { address.SetRawAddress(vm_addr); } - break_id = m_opaque_sp->FindLocationIDByAddress(address); + break_id = bkpt_sp->FindLocationIDByAddress(address); } return break_id; @@ -160,11 +152,12 @@ break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) { SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) { SBBreakpointLocation sb_bp_location; + BreakpointSP bkpt_sp = GetSP(); - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - sb_bp_location.SetLocation(m_opaque_sp->FindLocationByID(bp_loc_id)); + bkpt_sp->GetTarget().GetAPIMutex()); + sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id)); } return sb_bp_location; @@ -172,11 +165,12 @@ SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) { SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) { SBBreakpointLocation sb_bp_location; + BreakpointSP bkpt_sp = GetSP(); - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - sb_bp_location.SetLocation(m_opaque_sp->GetLocationAtIndex(index)); + bkpt_sp->GetTarget().GetAPIMutex()); + sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index)); } return sb_bp_location; @@ -184,290 +178,282 @@ SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) { void SBBreakpoint::SetEnabled(bool enable) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); - if (log) - log->Printf("SBBreakpoint(%p)::SetEnabled (enabled=%i)", - static_cast<void *>(m_opaque_sp.get()), enable); + LLDB_LOG(log, "breakpoint = {0}, enable = {1}", bkpt_sp.get(), enable); - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetEnabled(enable); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetEnabled(enable); } } bool SBBreakpoint::IsEnabled() { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->IsEnabled(); + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->IsEnabled(); } else return false; } void SBBreakpoint::SetOneShot(bool one_shot) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); - if (log) - log->Printf("SBBreakpoint(%p)::SetOneShot (one_shot=%i)", - static_cast<void *>(m_opaque_sp.get()), one_shot); + LLDB_LOG(log, "breakpoint = {0}, one_shot = {1}", bkpt_sp.get(), one_shot); - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetOneShot(one_shot); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetOneShot(one_shot); } } bool SBBreakpoint::IsOneShot() const { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->IsOneShot(); + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->IsOneShot(); } else return false; } bool SBBreakpoint::IsInternal() { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->IsInternal(); + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->IsInternal(); } else return false; } void SBBreakpoint::SetIgnoreCount(uint32_t count) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); - if (log) - log->Printf("SBBreakpoint(%p)::SetIgnoreCount (count=%u)", - static_cast<void *>(m_opaque_sp.get()), count); + LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count); - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetIgnoreCount(count); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetIgnoreCount(count); } } void SBBreakpoint::SetCondition(const char *condition) { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetCondition(condition); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetCondition(condition); } } const char *SBBreakpoint::GetCondition() { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->GetConditionText(); + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->GetConditionText(); } return nullptr; } uint32_t SBBreakpoint::GetHitCount() const { uint32_t count = 0; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - count = m_opaque_sp->GetHitCount(); + bkpt_sp->GetTarget().GetAPIMutex()); + count = bkpt_sp->GetHitCount(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetHitCount () => %u", - static_cast<void *>(m_opaque_sp.get()), count); + LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count); return count; } uint32_t SBBreakpoint::GetIgnoreCount() const { uint32_t count = 0; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - count = m_opaque_sp->GetIgnoreCount(); + bkpt_sp->GetTarget().GetAPIMutex()); + count = bkpt_sp->GetIgnoreCount(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetIgnoreCount () => %u", - static_cast<void *>(m_opaque_sp.get()), count); + LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count); return count; } void SBBreakpoint::SetThreadID(tid_t tid) { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetThreadID(tid); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetThreadID(tid); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::SetThreadID (tid=0x%4.4" PRIx64 ")", - static_cast<void *>(m_opaque_sp.get()), tid); + LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid); } tid_t SBBreakpoint::GetThreadID() { tid_t tid = LLDB_INVALID_THREAD_ID; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - tid = m_opaque_sp->GetThreadID(); + bkpt_sp->GetTarget().GetAPIMutex()); + tid = bkpt_sp->GetThreadID(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetThreadID () => 0x%4.4" PRIx64, - static_cast<void *>(m_opaque_sp.get()), tid); + LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid); return tid; } void SBBreakpoint::SetThreadIndex(uint32_t index) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::SetThreadIndex (%u)", - static_cast<void *>(m_opaque_sp.get()), index); - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), index); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->GetOptions()->GetThreadSpec()->SetIndex(index); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetOptions()->GetThreadSpec()->SetIndex(index); } } uint32_t SBBreakpoint::GetThreadIndex() const { uint32_t thread_idx = UINT32_MAX; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); const ThreadSpec *thread_spec = - m_opaque_sp->GetOptions()->GetThreadSpecNoCreate(); + bkpt_sp->GetOptions()->GetThreadSpecNoCreate(); if (thread_spec != nullptr) thread_idx = thread_spec->GetIndex(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetThreadIndex () => %u", - static_cast<void *>(m_opaque_sp.get()), thread_idx); + LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), thread_idx); return thread_idx; } void SBBreakpoint::SetThreadName(const char *thread_name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::SetThreadName (%s)", - static_cast<void *>(m_opaque_sp.get()), thread_name); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), thread_name); - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->GetOptions()->GetThreadSpec()->SetName(thread_name); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetOptions()->GetThreadSpec()->SetName(thread_name); } } const char *SBBreakpoint::GetThreadName() const { const char *name = nullptr; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); const ThreadSpec *thread_spec = - m_opaque_sp->GetOptions()->GetThreadSpecNoCreate(); + bkpt_sp->GetOptions()->GetThreadSpecNoCreate(); if (thread_spec != nullptr) name = thread_spec->GetName(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetThreadName () => %s", - static_cast<void *>(m_opaque_sp.get()), name); + LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name); return name; } void SBBreakpoint::SetQueueName(const char *queue_name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::SetQueueName (%s)", - static_cast<void *>(m_opaque_sp.get()), queue_name); - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, queue_name = {1}", bkpt_sp.get(), + queue_name); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->GetOptions()->GetThreadSpec()->SetQueueName(queue_name); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetOptions()->GetThreadSpec()->SetQueueName(queue_name); } } const char *SBBreakpoint::GetQueueName() const { const char *name = nullptr; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); const ThreadSpec *thread_spec = - m_opaque_sp->GetOptions()->GetThreadSpecNoCreate(); + bkpt_sp->GetOptions()->GetThreadSpecNoCreate(); if (thread_spec) name = thread_spec->GetQueueName(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetQueueName () => %s", - static_cast<void *>(m_opaque_sp.get()), name); + LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name); return name; } size_t SBBreakpoint::GetNumResolvedLocations() const { size_t num_resolved = 0; - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - num_resolved = m_opaque_sp->GetNumResolvedLocations(); + bkpt_sp->GetTarget().GetAPIMutex()); + num_resolved = bkpt_sp->GetNumResolvedLocations(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetNumResolvedLocations () => %" PRIu64, - static_cast<void *>(m_opaque_sp.get()), - static_cast<uint64_t>(num_resolved)); + LLDB_LOG(log, "breakpoint = {0}, num_resolved = {1}", bkpt_sp.get(), + num_resolved); return num_resolved; } size_t SBBreakpoint::GetNumLocations() const { + BreakpointSP bkpt_sp = GetSP(); size_t num_locs = 0; - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - num_locs = m_opaque_sp->GetNumLocations(); + bkpt_sp->GetTarget().GetAPIMutex()); + num_locs = bkpt_sp->GetNumLocations(); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBBreakpoint(%p)::GetNumLocations () => %" PRIu64, - static_cast<void *>(m_opaque_sp.get()), - static_cast<uint64_t>(num_locs)); + LLDB_LOG(log, "breakpoint = {0}, num_locs = {1}", bkpt_sp.get(), num_locs); return num_locs; } void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) { - if (!m_opaque_sp) + BreakpointSP bkpt_sp = GetSP(); + if (!bkpt_sp) return; if (commands.GetSize() == 0) return; std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up( new BreakpointOptions::CommandData(*commands, eScriptLanguageNone)); - m_opaque_sp->GetOptions()->SetCommandDataCallback(cmd_data_up); + bkpt_sp->GetOptions()->SetCommandDataCallback(cmd_data_up); } bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) { - if (!m_opaque_sp) + BreakpointSP bkpt_sp = GetSP(); + if (!bkpt_sp) return false; StringList command_list; bool has_commands = - m_opaque_sp->GetOptions()->GetCommandLineCallbacks(command_list); + bkpt_sp->GetOptions()->GetCommandLineCallbacks(command_list); if (has_commands) commands.AppendList(command_list); return has_commands; @@ -478,14 +464,15 @@ bool SBBreakpoint::GetDescription(SBStream &s) { } bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) { - if (m_opaque_sp) { + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - s.Printf("SBBreakpoint: id = %i, ", m_opaque_sp->GetID()); - m_opaque_sp->GetResolverDescription(s.get()); - m_opaque_sp->GetFilterDescription(s.get()); + bkpt_sp->GetTarget().GetAPIMutex()); + s.Printf("SBBreakpoint: id = %i, ", bkpt_sp->GetID()); + bkpt_sp->GetResolverDescription(s.get()); + bkpt_sp->GetFilterDescription(s.get()); if (include_locations) { - const size_t num_locations = m_opaque_sp->GetNumLocations(); + const size_t num_locations = bkpt_sp->GetNumLocations(); s.Printf(", locations = %" PRIu64, (uint64_t)num_locations); } return true; @@ -526,36 +513,31 @@ bool SBBreakpoint::PrivateBreakpointHitCallback(void *baton, void SBBreakpoint::SetCallback(BreakpointHitCallback callback, void *baton) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, callback = {1}, baton = {2}", bkpt_sp.get(), + callback, baton); - if (log) { - void *pointer = &callback; - log->Printf("SBBreakpoint(%p)::SetCallback (callback=%p, baton=%p)", - static_cast<void *>(m_opaque_sp.get()), - *static_cast<void **>(&pointer), static_cast<void *>(baton)); - } - - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton)); - m_opaque_sp->SetCallback(SBBreakpoint::PrivateBreakpointHitCallback, - baton_sp, false); + bkpt_sp->SetCallback(SBBreakpoint::PrivateBreakpointHitCallback, baton_sp, + false); } } void SBBreakpoint::SetScriptCallbackFunction( const char *callback_function_name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, callback = {1}", bkpt_sp.get(), + callback_function_name); - if (log) - log->Printf("SBBreakpoint(%p)::SetScriptCallbackFunction (callback=%s)", - static_cast<void *>(m_opaque_sp.get()), callback_function_name); - - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - BreakpointOptions *bp_options = m_opaque_sp->GetOptions(); - m_opaque_sp->GetTarget() + bkpt_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = bkpt_sp->GetOptions(); + bkpt_sp->GetTarget() .GetDebugger() .GetCommandInterpreter() .GetScriptInterpreter() @@ -566,18 +548,17 @@ void SBBreakpoint::SetScriptCallbackFunction( SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - - if (log) - log->Printf("SBBreakpoint(%p)::SetScriptCallbackBody: callback body:\n%s)", - static_cast<void *>(m_opaque_sp.get()), callback_body_text); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, callback body:\n{1}", bkpt_sp.get(), + callback_body_text); SBError sb_error; - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - BreakpointOptions *bp_options = m_opaque_sp->GetOptions(); - Error error = - m_opaque_sp->GetTarget() + bkpt_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = bkpt_sp->GetOptions(); + Status error = + bkpt_sp->GetTarget() .GetDebugger() .GetCommandInterpreter() .GetScriptInterpreter() @@ -591,17 +572,15 @@ SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) { bool SBBreakpoint::AddName(const char *new_name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), new_name); - if (log) - log->Printf("SBBreakpoint(%p)::AddName (name=%s)", - static_cast<void *>(m_opaque_sp.get()), new_name); - - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - Error error; // Think I'm just going to swallow the error here, it's - // probably more annoying to have to provide it. - return m_opaque_sp->AddName(new_name, error); + bkpt_sp->GetTarget().GetAPIMutex()); + Status error; // Think I'm just going to swallow the error here, it's + // probably more annoying to have to provide it. + return bkpt_sp->AddName(new_name, error); } return false; @@ -609,29 +588,25 @@ bool SBBreakpoint::AddName(const char *new_name) { void SBBreakpoint::RemoveName(const char *name_to_remove) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name_to_remove); - if (log) - log->Printf("SBBreakpoint(%p)::RemoveName (name=%s)", - static_cast<void *>(m_opaque_sp.get()), name_to_remove); - - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->RemoveName(name_to_remove); + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->RemoveName(name_to_remove); } } bool SBBreakpoint::MatchesName(const char *name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name); - if (log) - log->Printf("SBBreakpoint(%p)::MatchesName (name=%s)", - static_cast<void *>(m_opaque_sp.get()), name); - - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->MatchesName(name); + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->MatchesName(name); } return false; @@ -639,36 +614,20 @@ bool SBBreakpoint::MatchesName(const char *name) { void SBBreakpoint::GetNames(SBStringList &names) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointSP bkpt_sp = GetSP(); + LLDB_LOG(log, "breakpoint = {0}", bkpt_sp.get()); - if (log) - log->Printf("SBBreakpoint(%p)::GetNames ()", - static_cast<void *>(m_opaque_sp.get())); - - if (m_opaque_sp) { + if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().GetAPIMutex()); std::vector<std::string> names_vec; - m_opaque_sp->GetNames(names_vec); + bkpt_sp->GetNames(names_vec); for (std::string name : names_vec) { names.AppendString(name.c_str()); } } } -lldb_private::Breakpoint *SBBreakpoint::operator->() const { - return m_opaque_sp.get(); -} - -lldb_private::Breakpoint *SBBreakpoint::get() const { - return m_opaque_sp.get(); -} - -lldb::BreakpointSP &SBBreakpoint::operator*() { return m_opaque_sp; } - -const lldb::BreakpointSP &SBBreakpoint::operator*() const { - return m_opaque_sp; -} - bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) { return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) != nullptr; @@ -683,11 +642,10 @@ SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) { } SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) { - SBBreakpoint sb_breakpoint; if (event.IsValid()) - sb_breakpoint.m_opaque_sp = - Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP()); - return sb_breakpoint; + return SBBreakpoint( + Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP())); + return SBBreakpoint(); } SBBreakpointLocation @@ -711,6 +669,8 @@ SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) { return num_locations; } +BreakpointSP SBBreakpoint::GetSP() const { return m_opaque_wp.lock(); } + // This is simple collection of breakpoint id's and their target. class SBBreakpointListImpl { public: @@ -745,28 +705,28 @@ public: return BreakpointSP(); } - bool Append(Breakpoint &bkpt) { + bool Append(BreakpointSP bkpt) { TargetSP target_sp = m_target_wp.lock(); - if (!target_sp) + if (!target_sp || !bkpt) return false; - if (bkpt.GetTargetSP() != target_sp) + if (bkpt->GetTargetSP() != target_sp) return false; - m_break_ids.push_back(bkpt.GetID()); + m_break_ids.push_back(bkpt->GetID()); return true; } - bool AppendIfUnique(Breakpoint &bkpt) { + bool AppendIfUnique(BreakpointSP bkpt) { TargetSP target_sp = m_target_wp.lock(); - if (!target_sp) + if (!target_sp || !bkpt) return false; - if (bkpt.GetTargetSP() != target_sp) + if (bkpt->GetTargetSP() != target_sp) return false; - lldb::break_id_t bp_id = bkpt.GetID(); + lldb::break_id_t bp_id = bkpt->GetID(); if (find(m_break_ids.begin(), m_break_ids.end(), bp_id) == m_break_ids.end()) return false; - m_break_ids.push_back(bkpt.GetID()); + m_break_ids.push_back(bkpt->GetID()); return true; } @@ -827,7 +787,7 @@ void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) { return; if (!m_opaque_sp) return; - m_opaque_sp->Append(*sb_bkpt.get()); + m_opaque_sp->Append(sb_bkpt.m_opaque_wp.lock()); } void SBBreakpointList::AppendByID(lldb::break_id_t id) { @@ -841,7 +801,7 @@ bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) { return false; if (!m_opaque_sp) return false; - return m_opaque_sp->AppendIfUnique(*sb_bkpt.get()); + return m_opaque_sp->AppendIfUnique(sb_bkpt.GetSP()); } void SBBreakpointList::Clear() { diff --git a/contrib/llvm/tools/lldb/source/API/SBBreakpointLocation.cpp b/contrib/llvm/tools/lldb/source/API/SBBreakpointLocation.cpp index c7fac76..dc9c00d 100644 --- a/contrib/llvm/tools/lldb/source/API/SBBreakpointLocation.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBBreakpointLocation.cpp @@ -16,118 +16,124 @@ #include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Core/Debugger.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Target/Target.h" #include "lldb/Target/ThreadSpec.h" -#include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include "lldb/lldb-defines.h" #include "lldb/lldb-types.h" using namespace lldb; using namespace lldb_private; -SBBreakpointLocation::SBBreakpointLocation() : m_opaque_sp() {} +SBBreakpointLocation::SBBreakpointLocation() {} SBBreakpointLocation::SBBreakpointLocation( const lldb::BreakpointLocationSP &break_loc_sp) - : m_opaque_sp(break_loc_sp) { + : m_opaque_wp(break_loc_sp) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { SBStream sstr; GetDescription(sstr, lldb::eDescriptionLevelBrief); - log->Printf("SBBreakpointLocation::SBBreakpointLocaiton (const " - "lldb::BreakpointLocationsSP &break_loc_sp" - "=%p) => this.sp = %p (%s)", - static_cast<void *>(break_loc_sp.get()), - static_cast<void *>(m_opaque_sp.get()), sstr.GetData()); + LLDB_LOG(log, "location = {0} ({1})", break_loc_sp.get(), sstr.GetData()); } } SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_wp(rhs.m_opaque_wp) {} const SBBreakpointLocation &SBBreakpointLocation:: operator=(const SBBreakpointLocation &rhs) { - if (this != &rhs) - m_opaque_sp = rhs.m_opaque_sp; + m_opaque_wp = rhs.m_opaque_wp; return *this; } SBBreakpointLocation::~SBBreakpointLocation() {} -bool SBBreakpointLocation::IsValid() const { return m_opaque_sp.get() != NULL; } +BreakpointLocationSP SBBreakpointLocation::GetSP() const { + return m_opaque_wp.lock(); +} + +bool SBBreakpointLocation::IsValid() const { return bool(GetSP()); } SBAddress SBBreakpointLocation::GetAddress() { - if (m_opaque_sp) - return SBAddress(&m_opaque_sp->GetAddress()); + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) + return SBAddress(&loc_sp->GetAddress()); else return SBAddress(); } addr_t SBBreakpointLocation::GetLoadAddress() { addr_t ret_addr = LLDB_INVALID_ADDRESS; + BreakpointLocationSP loc_sp = GetSP(); - if (m_opaque_sp) { + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - ret_addr = m_opaque_sp->GetLoadAddress(); + loc_sp->GetTarget().GetAPIMutex()); + ret_addr = loc_sp->GetLoadAddress(); } return ret_addr; } void SBBreakpointLocation::SetEnabled(bool enabled) { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetEnabled(enabled); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetEnabled(enabled); } } bool SBBreakpointLocation::IsEnabled() { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->IsEnabled(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->IsEnabled(); } else return false; } uint32_t SBBreakpointLocation::GetIgnoreCount() { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->GetIgnoreCount(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetIgnoreCount(); } else return 0; } void SBBreakpointLocation::SetIgnoreCount(uint32_t n) { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetIgnoreCount(n); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetIgnoreCount(n); } } void SBBreakpointLocation::SetCondition(const char *condition) { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetCondition(condition); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetCondition(condition); } } const char *SBBreakpointLocation::GetCondition() { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->GetConditionText(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetConditionText(); } return NULL; } @@ -135,17 +141,15 @@ const char *SBBreakpointLocation::GetCondition() { void SBBreakpointLocation::SetScriptCallbackFunction( const char *callback_function_name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + BreakpointLocationSP loc_sp = GetSP(); + LLDB_LOG(log, "location = {0}, callback = {1}", loc_sp.get(), + callback_function_name); - if (log) - log->Printf( - "SBBreakpointLocation(%p)::SetScriptCallbackFunction (callback=%s)", - static_cast<void *>(m_opaque_sp.get()), callback_function_name); - - if (m_opaque_sp) { + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions(); - m_opaque_sp->GetBreakpoint() + loc_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = loc_sp->GetLocationOptions(); + loc_sp->GetBreakpoint() .GetTarget() .GetDebugger() .GetCommandInterpreter() @@ -158,18 +162,17 @@ void SBBreakpointLocation::SetScriptCallbackFunction( SBError SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - - if (log) - log->Printf("SBBreakpoint(%p)::SetScriptCallbackBody: callback body:\n%s)", - static_cast<void *>(m_opaque_sp.get()), callback_body_text); + BreakpointLocationSP loc_sp = GetSP(); + LLDB_LOG(log, "location = {0}: callback body:\n{1}", loc_sp.get(), + callback_body_text); SBError sb_error; - if (m_opaque_sp) { + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions(); - Error error = - m_opaque_sp->GetBreakpoint() + loc_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = loc_sp->GetLocationOptions(); + Status error = + loc_sp->GetBreakpoint() .GetTarget() .GetDebugger() .GetCommandInterpreter() @@ -183,80 +186,89 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { } void SBBreakpointLocation::SetThreadID(tid_t thread_id) { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetThreadID(thread_id); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetThreadID(thread_id); } } tid_t SBBreakpointLocation::GetThreadID() { tid_t tid = LLDB_INVALID_THREAD_ID; - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->GetThreadID(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetThreadID(); } return tid; } void SBBreakpointLocation::SetThreadIndex(uint32_t index) { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetThreadIndex(index); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetThreadIndex(index); } } uint32_t SBBreakpointLocation::GetThreadIndex() const { uint32_t thread_idx = UINT32_MAX; - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->GetThreadIndex(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetThreadIndex(); } return thread_idx; } void SBBreakpointLocation::SetThreadName(const char *thread_name) { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetThreadName(thread_name); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetThreadName(thread_name); } } const char *SBBreakpointLocation::GetThreadName() const { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->GetThreadName(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetThreadName(); } return NULL; } void SBBreakpointLocation::SetQueueName(const char *queue_name) { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->SetQueueName(queue_name); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetQueueName(queue_name); } } const char *SBBreakpointLocation::GetQueueName() const { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->GetQueueName(); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->GetQueueName(); } return NULL; } bool SBBreakpointLocation::IsResolved() { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->IsResolved(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->IsResolved(); } return false; } @@ -264,17 +276,18 @@ bool SBBreakpointLocation::IsResolved() { void SBBreakpointLocation::SetLocation( const lldb::BreakpointLocationSP &break_loc_sp) { // Uninstall the callbacks? - m_opaque_sp = break_loc_sp; + m_opaque_wp = break_loc_sp; } bool SBBreakpointLocation::GetDescription(SBStream &description, DescriptionLevel level) { Stream &strm = description.ref(); + BreakpointLocationSP loc_sp = GetSP(); - if (m_opaque_sp) { + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - m_opaque_sp->GetDescription(&strm, level); + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->GetDescription(&strm, level); strm.EOL(); } else strm.PutCString("No value"); @@ -283,34 +296,31 @@ bool SBBreakpointLocation::GetDescription(SBStream &description, } break_id_t SBBreakpointLocation::GetID() { - if (m_opaque_sp) { + BreakpointLocationSP loc_sp = GetSP(); + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - return m_opaque_sp->GetID(); + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetID(); } else return LLDB_INVALID_BREAK_ID; } SBBreakpoint SBBreakpointLocation::GetBreakpoint() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - - // if (log) - // log->Printf ("SBBreakpointLocation::GetBreakpoint ()"); + BreakpointLocationSP loc_sp = GetSP(); SBBreakpoint sb_bp; - if (m_opaque_sp) { + if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( - m_opaque_sp->GetTarget().GetAPIMutex()); - *sb_bp = m_opaque_sp->GetBreakpoint().shared_from_this(); + loc_sp->GetTarget().GetAPIMutex()); + sb_bp = loc_sp->GetBreakpoint().shared_from_this(); } if (log) { SBStream sstr; sb_bp.GetDescription(sstr); - log->Printf( - "SBBreakpointLocation(%p)::GetBreakpoint () => SBBreakpoint(%p) %s", - static_cast<void *>(m_opaque_sp.get()), - static_cast<void *>(sb_bp.get()), sstr.GetData()); + LLDB_LOG(log, "location = {0}, breakpoint = {1} ({2})", loc_sp.get(), + sb_bp.GetSP().get(), sstr.GetData()); } return sb_bp; } diff --git a/contrib/llvm/tools/lldb/source/API/SBBroadcaster.cpp b/contrib/llvm/tools/lldb/source/API/SBBroadcaster.cpp index 5189dd7..278576b 100644 --- a/contrib/llvm/tools/lldb/source/API/SBBroadcaster.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBBroadcaster.cpp @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/Core/Broadcaster.h" -#include "lldb/Core/Log.h" +#include "lldb/Utility/Log.h" #include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBEvent.h" @@ -22,25 +22,15 @@ SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {} SBBroadcaster::SBBroadcaster(const char *name) : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) { m_opaque_ptr = m_opaque_sp.get(); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API | - LIBLLDB_LOG_VERBOSE)); - - if (log) - log->Printf( - "SBBroadcaster::SBBroadcaster (name=\"%s\") => SBBroadcaster(%p)", name, - static_cast<void *>(m_opaque_ptr)); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr); } SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns) : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API | - LIBLLDB_LOG_VERBOSE)); - - if (log) - log->Printf("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) " - "=> SBBroadcaster(%p)", - static_cast<void *>(broadcaster), owns, - static_cast<void *>(m_opaque_ptr)); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGV(log, "(broadcaster={0}, owns={1}) => SBBroadcaster({2})", + broadcaster, owns, m_opaque_ptr); } SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs) diff --git a/contrib/llvm/tools/lldb/source/API/SBCommandReturnObject.cpp b/contrib/llvm/tools/lldb/source/API/SBCommandReturnObject.cpp index 41d5147..5a8909b 100644 --- a/contrib/llvm/tools/lldb/source/API/SBCommandReturnObject.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBCommandReturnObject.cpp @@ -15,9 +15,10 @@ #include "lldb/API/SBError.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Error.h" -#include "lldb/Core/Log.h" #include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Status.h" using namespace lldb; using namespace lldb_private; @@ -181,7 +182,7 @@ bool SBCommandReturnObject::GetDescription(SBStream &description) { Stream &strm = description.ref(); if (m_opaque_ap) { - description.Printf("Status: "); + description.Printf("Error: "); lldb::ReturnStatus status = m_opaque_ap->GetStatus(); if (status == lldb::eReturnStatusStarted) strm.PutCString("Started"); @@ -270,7 +271,7 @@ void SBCommandReturnObject::SetError(lldb::SBError &error, if (error.IsValid()) m_opaque_ap->SetError(error.ref(), fallback_error_cstr); else if (fallback_error_cstr) - m_opaque_ap->SetError(Error(), fallback_error_cstr); + m_opaque_ap->SetError(Status(), fallback_error_cstr); } } diff --git a/contrib/llvm/tools/lldb/source/API/SBCommunication.cpp b/contrib/llvm/tools/lldb/source/API/SBCommunication.cpp index 9519c02..63b672e 100644 --- a/contrib/llvm/tools/lldb/source/API/SBCommunication.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBCommunication.cpp @@ -10,8 +10,9 @@ #include "lldb/API/SBCommunication.h" #include "lldb/API/SBBroadcaster.h" #include "lldb/Core/Communication.h" -#include "lldb/Core/Log.h" #include "lldb/Host/ConnectionFileDescriptor.h" +#include "lldb/Host/Host.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; @@ -51,7 +52,7 @@ void SBCommunication::SetCloseOnEOF(bool b) { ConnectionStatus SBCommunication::Connect(const char *url) { if (m_opaque) { if (!m_opaque->HasConnection()) - m_opaque->SetConnection(Connection::CreateDefaultConnection(url)); + m_opaque->SetConnection(Host::CreateDefaultConnection(url).release()); return m_opaque->Connect(url, NULL); } return eConnectionStatusNoConnection; diff --git a/contrib/llvm/tools/lldb/source/API/SBCompileUnit.cpp b/contrib/llvm/tools/lldb/source/API/SBCompileUnit.cpp index 12aed59..149d587 100644 --- a/contrib/llvm/tools/lldb/source/API/SBCompileUnit.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBCompileUnit.cpp @@ -10,13 +10,13 @@ #include "lldb/API/SBCompileUnit.h" #include "lldb/API/SBLineEntry.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/LineEntry.h" #include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/Type.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBData.cpp b/contrib/llvm/tools/lldb/source/API/SBData.cpp index d905d3f..a8ba580 100644 --- a/contrib/llvm/tools/lldb/source/API/SBData.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBData.cpp @@ -13,10 +13,11 @@ #include "lldb/API/SBError.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/DataBufferHeap.h" -#include "lldb/Core/DataExtractor.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" +#include "lldb/Core/DumpDataExtractor.h" +#include "lldb/Utility/DataBufferHeap.h" +#include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" using namespace lldb; using namespace lldb_private; @@ -347,7 +348,7 @@ bool SBData::GetDescription(lldb::SBStream &description, Stream &strm = description.ref(); if (m_opaque_sp) { - m_opaque_sp->Dump(&strm, 0, lldb::eFormatBytesWithASCII, 1, + DumpDataExtractor(*m_opaque_sp, &strm, 0, lldb::eFormatBytesWithASCII, 1, m_opaque_sp->GetByteSize(), 16, base_addr, 0, 0); } else strm.PutCString("No value"); @@ -383,7 +384,11 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size, if (!m_opaque_sp.get()) m_opaque_sp.reset(new DataExtractor(buf, size, endian, addr_size)); else + { m_opaque_sp->SetData(buf, size, endian); + m_opaque_sp->SetAddressByteSize(addr_size); + } + if (log) log->Printf("SBData::SetData (error=%p,buf=%p,size=%" PRIu64 ",endian=%d,addr_size=%c) => " diff --git a/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp b/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp index 97e6f7b..3cdb6bb 100644 --- a/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp @@ -57,7 +57,7 @@ using namespace lldb_private; static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp, const FileSpec &spec, - Error &error) { + Status &error) { llvm::sys::DynamicLibrary dynlib = llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str()); if (dynlib.isValid()) { @@ -551,7 +551,7 @@ SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, TargetSP target_sp; if (m_opaque_sp) { const bool add_dependent_modules = true; - Error error(m_opaque_sp->GetTargetList().CreateTarget( + Status error(m_opaque_sp->GetTargetList().CreateTarget( *m_opaque_sp, filename, target_triple, add_dependent_modules, nullptr, target_sp)); sb_target.SetSP(target_sp); @@ -574,7 +574,7 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, SBTarget sb_target; TargetSP target_sp; if (m_opaque_sp) { - Error error; + Status error; const bool add_dependent_modules = true; error = m_opaque_sp->GetTargetList().CreateTarget( @@ -600,7 +600,7 @@ SBTarget SBDebugger::CreateTarget(const char *filename) { SBTarget sb_target; TargetSP target_sp; if (m_opaque_sp) { - Error error; + Status error; const bool add_dependent_modules = true; error = m_opaque_sp->GetTargetList().CreateTarget( *m_opaque_sp, filename, "", add_dependent_modules, nullptr, target_sp); @@ -873,7 +873,7 @@ SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, SBError sb_error; DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( ConstString(debugger_instance_name))); - Error error; + Status error; if (debugger_sp) { ExecutionContext exe_ctx( debugger_sp->GetCommandInterpreter().GetExecutionContext()); @@ -894,7 +894,7 @@ SBDebugger::GetInternalVariableValue(const char *var_name, SBStringList ret_value; DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( ConstString(debugger_instance_name))); - Error error; + Status error; if (debugger_sp) { ExecutionContext exe_ctx( debugger_sp->GetCommandInterpreter().GetExecutionContext()); @@ -1120,13 +1120,23 @@ SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { } #endif // LLDB_DISABLE_PYTHON +static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { + if (categories == nullptr) + return {}; + size_t len = 0; + while (categories[len] != nullptr) + ++len; + return llvm::makeArrayRef(categories, len); +} + bool SBDebugger::EnableLog(const char *channel, const char **categories) { if (m_opaque_sp) { uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; - StreamString errors; - return m_opaque_sp->EnableLog(channel, categories, nullptr, log_options, - errors); + std::string error; + llvm::raw_string_ostream error_stream(error); + return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "", + log_options, error_stream); } else return false; } diff --git a/contrib/llvm/tools/lldb/source/API/SBDeclaration.cpp b/contrib/llvm/tools/lldb/source/API/SBDeclaration.cpp index fc21f83..d6e61e3 100644 --- a/contrib/llvm/tools/lldb/source/API/SBDeclaration.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBDeclaration.cpp @@ -1,5 +1,4 @@ -//===-- SBDeclaration.cpp -----------------------------------------*- C++ -//-*-===// +//===-- SBDeclaration.cpp ----------------------------------------*- C++-*-===// // // The LLVM Compiler Infrastructure // @@ -10,9 +9,10 @@ #include "lldb/API/SBDeclaration.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" +#include "lldb/Host/PosixApi.h" #include "lldb/Symbol/Declaration.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include <limits.h> diff --git a/contrib/llvm/tools/lldb/source/API/SBError.cpp b/contrib/llvm/tools/lldb/source/API/SBError.cpp index 451c0a7..b2811d0 100644 --- a/contrib/llvm/tools/lldb/source/API/SBError.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBError.cpp @@ -9,8 +9,8 @@ #include "lldb/API/SBError.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Error.h" -#include "lldb/Core/Log.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Status.h" #include <stdarg.h> @@ -21,7 +21,7 @@ SBError::SBError() : m_opaque_ap() {} SBError::SBError(const SBError &rhs) : m_opaque_ap() { if (rhs.IsValid()) - m_opaque_ap.reset(new Error(*rhs)); + m_opaque_ap.reset(new Status(*rhs)); } SBError::~SBError() {} @@ -31,7 +31,7 @@ const SBError &SBError::operator=(const SBError &rhs) { if (m_opaque_ap.get()) *m_opaque_ap = *rhs; else - m_opaque_ap.reset(new Error(*rhs)); + m_opaque_ap.reset(new Status(*rhs)); } else m_opaque_ap.reset(); @@ -108,7 +108,7 @@ void SBError::SetError(uint32_t err, ErrorType type) { m_opaque_ap->SetError(err, type); } -void SBError::SetError(const Error &lldb_error) { +void SBError::SetError(const Status &lldb_error) { CreateIfNeeded(); *m_opaque_ap = lldb_error; } @@ -141,19 +141,19 @@ bool SBError::IsValid() const { return m_opaque_ap.get() != NULL; } void SBError::CreateIfNeeded() { if (m_opaque_ap.get() == NULL) - m_opaque_ap.reset(new Error()); + m_opaque_ap.reset(new Status()); } -lldb_private::Error *SBError::operator->() { return m_opaque_ap.get(); } +lldb_private::Status *SBError::operator->() { return m_opaque_ap.get(); } -lldb_private::Error *SBError::get() { return m_opaque_ap.get(); } +lldb_private::Status *SBError::get() { return m_opaque_ap.get(); } -lldb_private::Error &SBError::ref() { +lldb_private::Status &SBError::ref() { CreateIfNeeded(); return *m_opaque_ap; } -const lldb_private::Error &SBError::operator*() const { +const lldb_private::Status &SBError::operator*() const { // Be sure to call "IsValid()" before calling this function or it will crash return *m_opaque_ap; } diff --git a/contrib/llvm/tools/lldb/source/API/SBEvent.cpp b/contrib/llvm/tools/lldb/source/API/SBEvent.cpp index e0bb68c..17a16ff 100644 --- a/contrib/llvm/tools/lldb/source/API/SBEvent.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBEvent.cpp @@ -12,12 +12,12 @@ #include "lldb/API/SBStream.h" #include "lldb/Breakpoint/Breakpoint.h" -#include "lldb/Core/ConstString.h" #include "lldb/Core/Event.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Target/Process.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Stream.h" using namespace lldb; using namespace lldb_private; @@ -109,13 +109,9 @@ bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) { // For logging, this gets a little chatty so only enable this when verbose // logging is on - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API | - LIBLLDB_LOG_VERBOSE)); - if (log) - log->Printf( - "SBEvent(%p)::BroadcasterMatchesRef (SBBroadcaster(%p): %s) => %i", - static_cast<void *>(get()), static_cast<void *>(broadcaster.get()), - broadcaster.GetName(), success); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGV(log, "({0}) (SBBroadcaster({1}): {2}) => {3}", get(), + broadcaster.get(), broadcaster.GetName(), success); return success; } diff --git a/contrib/llvm/tools/lldb/source/API/SBFileSpec.cpp b/contrib/llvm/tools/lldb/source/API/SBFileSpec.cpp index 88baf3b..011b882 100644 --- a/contrib/llvm/tools/lldb/source/API/SBFileSpec.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBFileSpec.cpp @@ -12,9 +12,10 @@ #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" -#include "lldb/Host/FileSpec.h" +#include "lldb/Host/PosixApi.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include "llvm/ADT/SmallString.h" diff --git a/contrib/llvm/tools/lldb/source/API/SBFileSpecList.cpp b/contrib/llvm/tools/lldb/source/API/SBFileSpecList.cpp index 8ed3f6f..67d28dc 100644 --- a/contrib/llvm/tools/lldb/source/API/SBFileSpecList.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBFileSpecList.cpp @@ -13,9 +13,10 @@ #include "lldb/API/SBFileSpecList.h" #include "lldb/API/SBStream.h" #include "lldb/Core/FileSpecList.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" -#include "lldb/Host/FileSpec.h" +#include "lldb/Host/PosixApi.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBFrame.cpp b/contrib/llvm/tools/lldb/source/API/SBFrame.cpp index 8d8cb48..684a707 100644 --- a/contrib/llvm/tools/lldb/source/API/SBFrame.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBFrame.cpp @@ -21,9 +21,6 @@ #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "lldb/Core/Address.h" -#include "lldb/Core/ConstString.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" #include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectVariable.h" @@ -42,6 +39,9 @@ #include "lldb/Target/StackID.h" #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBDebugger.h" @@ -606,7 +606,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, frame = exe_ctx.GetFramePtr(); if (frame) { VariableSP var_sp; - Error error; + Status error; ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath( var_path, eNoDynamicValues, StackFrame::eExpressionPathOptionCheckPtrVsMember | @@ -1370,6 +1370,25 @@ const char *SBFrame::GetFunctionName() { return static_cast<const SBFrame *>(this)->GetFunctionName(); } +lldb::LanguageType SBFrame::GuessLanguage() const { + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + return frame->GuessLanguage(); + } + } + } + return eLanguageTypeUnknown; +} + const char *SBFrame::GetFunctionName() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *name = nullptr; diff --git a/contrib/llvm/tools/lldb/source/API/SBFunction.cpp b/contrib/llvm/tools/lldb/source/API/SBFunction.cpp index 9065cc3..6a24f64 100644 --- a/contrib/llvm/tools/lldb/source/API/SBFunction.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBFunction.cpp @@ -11,7 +11,6 @@ #include "lldb/API/SBProcess.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Disassembler.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/Function.h" @@ -19,6 +18,7 @@ #include "lldb/Symbol/VariableList.h" #include "lldb/Target/ExecutionContext.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBHostOS.cpp b/contrib/llvm/tools/lldb/source/API/SBHostOS.cpp index 8df74d9..90b75a6 100644 --- a/contrib/llvm/tools/lldb/source/API/SBHostOS.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBHostOS.cpp @@ -9,13 +9,13 @@ #include "lldb/API/SBHostOS.h" #include "lldb/API/SBError.h" -#include "lldb/Core/Log.h" -#include "lldb/Host/FileSpec.h" #include "lldb/Host/Host.h" #include "lldb/Host/HostInfo.h" #include "lldb/Host/HostNativeThread.h" #include "lldb/Host/HostThread.h" #include "lldb/Host/ThreadLauncher.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Log.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/Path.h" @@ -80,7 +80,7 @@ lldb::thread_t SBHostOS::ThreadCreate(const char *name, void SBHostOS::ThreadCreated(const char *name) {} bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) { - Error error; + Status error; HostThread host_thread(thread); error = host_thread.Cancel(); if (error_ptr) @@ -90,7 +90,7 @@ bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) { } bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) { - Error error; + Status error; #if defined(_WIN32) if (error_ptr) error_ptr->SetErrorString("ThreadDetach is not supported on this platform"); @@ -106,7 +106,7 @@ bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) { bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result, SBError *error_ptr) { - Error error; + Status error; HostThread host_thread(thread); error = host_thread.Join(result); if (error_ptr) diff --git a/contrib/llvm/tools/lldb/source/API/SBInstruction.cpp b/contrib/llvm/tools/lldb/source/API/SBInstruction.cpp index 8c616da..8b7deb7 100644 --- a/contrib/llvm/tools/lldb/source/API/SBInstruction.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBInstruction.cpp @@ -16,8 +16,6 @@ #include "lldb/API/SBTarget.h" #include "lldb/Core/ArchSpec.h" -#include "lldb/Core/DataBufferHeap.h" -#include "lldb/Core/DataExtractor.h" #include "lldb/Core/Disassembler.h" #include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/Module.h" @@ -25,6 +23,8 @@ #include "lldb/Target/ExecutionContext.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/DataBufferHeap.h" +#include "lldb/Utility/DataExtractor.h" //---------------------------------------------------------------------- // We recently fixed a leak in one of the Instruction subclasses where @@ -176,6 +176,13 @@ bool SBInstruction::HasDelaySlot() { return false; } +bool SBInstruction::CanSetBreakpoint () { + lldb::InstructionSP inst_sp(GetOpaque()); + if (inst_sp) + return inst_sp->CanSetBreakpoint(); + return false; +} + lldb::InstructionSP SBInstruction::GetOpaque() { if (m_opaque_sp) return m_opaque_sp->GetSP(); diff --git a/contrib/llvm/tools/lldb/source/API/SBInstructionList.cpp b/contrib/llvm/tools/lldb/source/API/SBInstructionList.cpp index 8ab3aca..3edb9ea 100644 --- a/contrib/llvm/tools/lldb/source/API/SBInstructionList.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBInstructionList.cpp @@ -9,11 +9,12 @@ #include "lldb/API/SBInstructionList.h" #include "lldb/API/SBInstruction.h" +#include "lldb/API/SBAddress.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Disassembler.h" #include "lldb/Core/Module.h" -#include "lldb/Core/Stream.h" #include "lldb/Symbol/SymbolContext.h" +#include "lldb/Utility/Stream.h" using namespace lldb; using namespace lldb_private; @@ -49,6 +50,31 @@ SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) { return inst; } +size_t SBInstructionList::GetInstructionsCount(const SBAddress &start, + const SBAddress &end, + bool canSetBreakpoint) { + size_t num_instructions = GetSize(); + size_t i = 0; + SBAddress addr; + size_t lower_index = 0; + size_t upper_index = 0; + size_t instructions_to_skip = 0; + for (i = 0; i < num_instructions; ++i) { + addr = GetInstructionAtIndex(i).GetAddress(); + if (start == addr) + lower_index = i; + if (end == addr) + upper_index = i; + } + if (canSetBreakpoint) + for (i = lower_index; i <= upper_index; ++i) { + SBInstruction insn = GetInstructionAtIndex(i); + if (!insn.CanSetBreakpoint()) + ++instructions_to_skip; + } + return upper_index - lower_index - instructions_to_skip; +} + void SBInstructionList::Clear() { m_opaque_sp.reset(); } void SBInstructionList::AppendInstruction(SBInstruction insn) {} diff --git a/contrib/llvm/tools/lldb/source/API/SBLineEntry.cpp b/contrib/llvm/tools/lldb/source/API/SBLineEntry.cpp index 3469cec..7341d36 100644 --- a/contrib/llvm/tools/lldb/source/API/SBLineEntry.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBLineEntry.cpp @@ -11,9 +11,10 @@ #include "lldb/API/SBLineEntry.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/StreamString.h" +#include "lldb/Host/PosixApi.h" #include "lldb/Symbol/LineEntry.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/StreamString.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBListener.cpp b/contrib/llvm/tools/lldb/source/API/SBListener.cpp index 501535a..50fed4e 100644 --- a/contrib/llvm/tools/lldb/source/API/SBListener.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBListener.cpp @@ -15,8 +15,8 @@ #include "lldb/Core/Broadcaster.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Listener.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/StreamString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/StreamString.h" using namespace lldb; using namespace lldb_private; @@ -302,6 +302,8 @@ bool SBListener::HandleBroadcastEvent(const SBEvent &event) { return false; } +lldb::ListenerSP SBListener::GetSP() { return m_opaque_sp; } + Listener *SBListener::operator->() const { return m_opaque_sp.get(); } Listener *SBListener::get() const { return m_opaque_sp.get(); } diff --git a/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfo.cpp b/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfo.cpp index 3e72276..c4dbaec 100644 --- a/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfo.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfo.cpp @@ -11,8 +11,8 @@ #include "lldb/API/SBDefines.h" #include "lldb/API/SBError.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/StreamString.h" #include "lldb/Target/MemoryRegionInfo.h" +#include "lldb/Utility/StreamString.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfoList.cpp b/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfoList.cpp index f7ce81a..fff4044 100644 --- a/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfoList.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBMemoryRegionInfoList.cpp @@ -7,11 +7,11 @@ // //===----------------------------------------------------------------------===// -#include "lldb/API/SBMemoryRegionInfo.h" #include "lldb/API/SBMemoryRegionInfoList.h" +#include "lldb/API/SBMemoryRegionInfo.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Log.h" #include "lldb/Target/MemoryRegionInfo.h" +#include "lldb/Utility/Log.h" #include <vector> diff --git a/contrib/llvm/tools/lldb/source/API/SBModule.cpp b/contrib/llvm/tools/lldb/source/API/SBModule.cpp index 8964303..17f3dcc 100644 --- a/contrib/llvm/tools/lldb/source/API/SBModule.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBModule.cpp @@ -14,10 +14,8 @@ #include "lldb/API/SBProcess.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBSymbolContextList.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Core/Section.h" -#include "lldb/Core/StreamString.h" #include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectVariable.h" #include "lldb/Symbol/ObjectFile.h" @@ -27,6 +25,8 @@ #include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/VariableList.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/StreamString.h" using namespace lldb; using namespace lldb_private; @@ -37,8 +37,8 @@ SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {} SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() { ModuleSP module_sp; - Error error = ModuleList::GetSharedModule(*module_spec.m_opaque_ap, module_sp, - NULL, NULL, NULL); + Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_ap, + module_sp, NULL, NULL, NULL); if (module_sp) SetSP(module_sp); } diff --git a/contrib/llvm/tools/lldb/source/API/SBModuleSpec.cpp b/contrib/llvm/tools/lldb/source/API/SBModuleSpec.cpp index b82b822..a1c0886 100644 --- a/contrib/llvm/tools/lldb/source/API/SBModuleSpec.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBModuleSpec.cpp @@ -11,9 +11,9 @@ #include "lldb/API/SBStream.h" #include "lldb/Core/Module.h" #include "lldb/Core/ModuleSpec.h" -#include "lldb/Core/Stream.h" #include "lldb/Host/Host.h" #include "lldb/Symbol/ObjectFile.h" +#include "lldb/Utility/Stream.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBPlatform.cpp b/contrib/llvm/tools/lldb/source/API/SBPlatform.cpp index 6085cef..87cbc45 100644 --- a/contrib/llvm/tools/lldb/source/API/SBPlatform.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBPlatform.cpp @@ -13,11 +13,13 @@ #include "lldb/API/SBLaunchInfo.h" #include "lldb/API/SBUnixSignals.h" #include "lldb/Core/ArchSpec.h" -#include "lldb/Core/Error.h" #include "lldb/Host/File.h" #include "lldb/Interpreter/Args.h" #include "lldb/Target/Platform.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/Status.h" + +#include "llvm/Support/FileSystem.h" #include <functional> @@ -203,7 +205,7 @@ const char *SBPlatformShellCommand::GetOutput() { SBPlatform::SBPlatform() : m_opaque_sp() {} SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() { - Error error; + Status error; if (platform_name && platform_name[0]) m_opaque_sp = Platform::Create(ConstString(platform_name), error); } @@ -363,7 +365,7 @@ SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) { if (src.Exists()) { uint32_t permissions = src.ref().GetPermissions(); if (permissions == 0) { - if (src.ref().GetFileType() == FileSpec::eFileTypeDirectory) + if (llvm::sys::fs::is_directory(src.ref().GetPath())) permissions = eFilePermissionsDirectoryDefault; else permissions = eFilePermissionsFileDefault; @@ -372,7 +374,7 @@ SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) { return platform_sp->PutFile(src.ref(), dst.ref(), permissions); } - Error error; + Status error; error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str()); return error; @@ -384,7 +386,7 @@ SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) { if (src.Exists()) return platform_sp->Install(src.ref(), dst.ref()); - Error error; + Status error; error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str()); return error; @@ -395,7 +397,7 @@ SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) { return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { const char *command = shell_command.GetCommand(); if (!command) - return Error("invalid shell command (empty)"); + return Status("invalid shell command (empty)"); const char *working_dir = shell_command.GetWorkingDirectory(); if (working_dir == NULL) { @@ -425,7 +427,7 @@ SBError SBPlatform::Kill(const lldb::pid_t pid) { } SBError SBPlatform::ExecuteConnected( - const std::function<Error(const lldb::PlatformSP &)> &func) { + const std::function<Status(const lldb::PlatformSP &)> &func) { SBError sb_error; const auto platform_sp(GetSP()); if (platform_sp) { diff --git a/contrib/llvm/tools/lldb/source/API/SBProcess.cpp b/contrib/llvm/tools/lldb/source/API/SBProcess.cpp index 59dd569..caf07db 100644 --- a/contrib/llvm/tools/lldb/source/API/SBProcess.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBProcess.cpp @@ -16,11 +16,9 @@ #include "lldb/lldb-types.h" #include "lldb/Core/Debugger.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Core/PluginManager.h" #include "lldb/Core/State.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" #include "lldb/Interpreter/Args.h" #include "lldb/Target/MemoryRegionInfo.h" @@ -29,6 +27,8 @@ #include "lldb/Target/SystemRuntime.h" #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" // Project includes @@ -44,6 +44,8 @@ #include "lldb/API/SBStructuredData.h" #include "lldb/API/SBThread.h" #include "lldb/API/SBThreadCollection.h" +#include "lldb/API/SBTrace.h" +#include "lldb/API/SBTraceOptions.h" #include "lldb/API/SBUnixSignals.h" using namespace lldb; @@ -279,7 +281,7 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) { size_t ret_val = 0; ProcessSP process_sp(GetSP()); if (process_sp) { - Error error; + Status error; ret_val = process_sp->PutSTDIN(src, src_len, error); } @@ -296,7 +298,7 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (process_sp) { - Error error; + Status error; bytes_read = process_sp->GetSTDOUT(dst, dst_len, error); } @@ -315,7 +317,7 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (process_sp) { - Error error; + Status error; bytes_read = process_sp->GetSTDERR(dst, dst_len, error); } @@ -334,7 +336,7 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (process_sp) { - Error error; + Status error; bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error); } @@ -349,6 +351,25 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { return bytes_read; } +lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, + lldb::SBError &error) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + ProcessSP process_sp(GetSP()); + error.Clear(); + SBTrace trace_instance; + trace_instance.SetSP(process_sp); + lldb::user_id_t uid = LLDB_INVALID_UID; + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref()); + trace_instance.SetTraceUID(uid); + LLDB_LOG(log, "SBProcess::returned uid - {0}", uid); + } + return trace_instance; +} + void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { if (out == NULL) return; @@ -1135,22 +1156,34 @@ uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec, uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec, const lldb::SBFileSpec &sb_remote_image_spec, lldb::SBError &sb_error) { + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ProcessSP process_sp(GetSP()); if (process_sp) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&process_sp->GetRunLock())) { + if (log) + log->Printf("SBProcess(%p)::LoadImage() => calling Platform::LoadImage" + "for: %s", + static_cast<void *>(process_sp.get()), + sb_local_image_spec.GetFilename()); + std::lock_guard<std::recursive_mutex> guard( - process_sp->GetTarget().GetAPIMutex()); + process_sp->GetTarget().GetAPIMutex()); PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec, *sb_remote_image_spec, sb_error.ref()); } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBProcess(%p)::LoadImage() => error: process is running", static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } + } else { + if (log) + log->Printf("SBProcess(%p)::LoadImage() => error: called with invalid" + " process", + static_cast<void *>(process_sp.get())); + sb_error.SetErrorString("process is invalid"); } return LLDB_INVALID_IMAGE_TOKEN; } diff --git a/contrib/llvm/tools/lldb/source/API/SBQueue.cpp b/contrib/llvm/tools/lldb/source/API/SBQueue.cpp index c6f5305..5f85211 100644 --- a/contrib/llvm/tools/lldb/source/API/SBQueue.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBQueue.cpp @@ -15,11 +15,11 @@ #include "lldb/API/SBQueueItem.h" #include "lldb/API/SBThread.h" -#include "lldb/Core/Log.h" #include "lldb/Target/Process.h" #include "lldb/Target/Queue.h" #include "lldb/Target/QueueItem.h" #include "lldb/Target/Thread.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBQueueItem.cpp b/contrib/llvm/tools/lldb/source/API/SBQueueItem.cpp index 2e06bc8..87ba73f9 100644 --- a/contrib/llvm/tools/lldb/source/API/SBQueueItem.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBQueueItem.cpp @@ -13,10 +13,10 @@ #include "lldb/API/SBQueueItem.h" #include "lldb/API/SBThread.h" #include "lldb/Core/Address.h" -#include "lldb/Core/Log.h" #include "lldb/Target/Process.h" #include "lldb/Target/QueueItem.h" #include "lldb/Target/Thread.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBSection.cpp b/contrib/llvm/tools/lldb/source/API/SBSection.cpp index 8124fe9..9da5d17 100644 --- a/contrib/llvm/tools/lldb/source/API/SBSection.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBSection.cpp @@ -10,13 +10,14 @@ #include "lldb/API/SBSection.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBTarget.h" -#include "lldb/Core/DataBuffer.h" -#include "lldb/Core/DataExtractor.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Core/Section.h" -#include "lldb/Core/StreamString.h" #include "lldb/Symbol/ObjectFile.h" +#include "lldb/Utility/DataBuffer.h" +#include "lldb/Utility/DataBufferLLVM.h" +#include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/StreamString.h" using namespace lldb; using namespace lldb_private; @@ -165,8 +166,8 @@ SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) { else file_size = 0; } - DataBufferSP data_buffer_sp( - objfile->GetFileSpec().ReadFileContents(file_offset, file_size)); + auto data_buffer_sp = DataBufferLLVM::CreateSliceFromPath( + objfile->GetFileSpec().GetPath(), file_size, file_offset); if (data_buffer_sp && data_buffer_sp->GetByteSize() > 0) { DataExtractorSP data_extractor_sp( new DataExtractor(data_buffer_sp, objfile->GetByteOrder(), diff --git a/contrib/llvm/tools/lldb/source/API/SBSourceManager.cpp b/contrib/llvm/tools/lldb/source/API/SBSourceManager.cpp index ecf532c..5804c22 100644 --- a/contrib/llvm/tools/lldb/source/API/SBSourceManager.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBSourceManager.cpp @@ -15,8 +15,8 @@ #include "lldb/API/SBFileSpec.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/SourceManager.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" +#include "lldb/Utility/Stream.h" #include "lldb/Target/Target.h" diff --git a/contrib/llvm/tools/lldb/source/API/SBStream.cpp b/contrib/llvm/tools/lldb/source/API/SBStream.cpp index 858e949..159ec07 100644 --- a/contrib/llvm/tools/lldb/source/API/SBStream.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBStream.cpp @@ -9,10 +9,10 @@ #include "lldb/API/SBStream.h" -#include "lldb/Core/Error.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" -#include "lldb/Core/StreamString.h" +#include "lldb/Utility/Status.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StreamString.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBStringList.cpp b/contrib/llvm/tools/lldb/source/API/SBStringList.cpp index 075ee0d..9ac69b1 100644 --- a/contrib/llvm/tools/lldb/source/API/SBStringList.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBStringList.cpp @@ -9,7 +9,7 @@ #include "lldb/API/SBStringList.h" -#include "lldb/Core/StringList.h" +#include "lldb/Utility/StringList.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBStructuredData.cpp b/contrib/llvm/tools/lldb/source/API/SBStructuredData.cpp index d9ea072..d506410 100644 --- a/contrib/llvm/tools/lldb/source/API/SBStructuredData.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBStructuredData.cpp @@ -10,80 +10,17 @@ #include "lldb/API/SBStructuredData.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Error.h" #include "lldb/Core/Event.h" -#include "lldb/Core/Stream.h" -#include "lldb/Core/StructuredData.h" +#include "lldb/Core/StructuredDataImpl.h" #include "lldb/Target/StructuredDataPlugin.h" +#include "lldb/Utility/Status.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StructuredData.h" using namespace lldb; using namespace lldb_private; #pragma mark-- -#pragma mark StructuredDataImpl - -class StructuredDataImpl { -public: - StructuredDataImpl() : m_plugin_wp(), m_data_sp() {} - - StructuredDataImpl(const StructuredDataImpl &rhs) = default; - - StructuredDataImpl(const EventSP &event_sp) - : m_plugin_wp( - EventDataStructuredData::GetPluginFromEvent(event_sp.get())), - m_data_sp(EventDataStructuredData::GetObjectFromEvent(event_sp.get())) { - } - - ~StructuredDataImpl() = default; - - StructuredDataImpl &operator=(const StructuredDataImpl &rhs) = default; - - bool IsValid() const { return m_data_sp.get() != nullptr; } - - void Clear() { - m_plugin_wp.reset(); - m_data_sp.reset(); - } - - SBError GetAsJSON(lldb_private::Stream &stream) const { - SBError sb_error; - - if (!m_data_sp) { - sb_error.SetErrorString("No structured data."); - return sb_error; - } - - m_data_sp->Dump(stream); - return sb_error; - } - - Error GetDescription(lldb_private::Stream &stream) const { - Error error; - - if (!m_data_sp) { - error.SetErrorString("Cannot pretty print structured data: " - "no data to print."); - return error; - } - - // Grab the plugin. - auto plugin_sp = StructuredDataPluginSP(m_plugin_wp); - if (!plugin_sp) { - error.SetErrorString("Cannot pretty print structured data: " - "plugin doesn't exist."); - return error; - } - - // Get the data's description. - return plugin_sp->GetDescription(m_data_sp, stream); - } - -private: - StructuredDataPluginWP m_plugin_wp; - StructuredData::ObjectSP m_data_sp; -}; - -#pragma mark-- #pragma mark SBStructuredData SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {} @@ -102,17 +39,73 @@ operator=(const lldb::SBStructuredData &rhs) { return *this; } +lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) { + lldb::SBError error; + std::string json_str(stream.GetData()); + + StructuredData::ObjectSP json_obj = StructuredData::ParseJSON(json_str); + m_impl_up->SetObjectSP(json_obj); + + if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary) + error.SetErrorString("Invalid Syntax"); + return error; +} + bool SBStructuredData::IsValid() const { return m_impl_up->IsValid(); } void SBStructuredData::Clear() { m_impl_up->Clear(); } SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const { - return m_impl_up->GetAsJSON(stream.ref()); + SBError error; + error.SetError(m_impl_up->GetAsJSON(stream.ref())); + return error; } lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const { - Error error = m_impl_up->GetDescription(stream.ref()); + Status error = m_impl_up->GetDescription(stream.ref()); SBError sb_error; sb_error.SetError(error); return sb_error; } + +StructuredDataType SBStructuredData::GetType() const { + return (m_impl_up ? m_impl_up->GetType() : eStructuredDataTypeInvalid); +} + +size_t SBStructuredData::GetSize() const { + return (m_impl_up ? m_impl_up->GetSize() : 0); +} + +lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const { + if (!m_impl_up) + return SBStructuredData(); + + SBStructuredData result; + result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key)); + return result; +} + +lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const { + if (!m_impl_up) + return SBStructuredData(); + + SBStructuredData result; + result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx)); + return result; +} + +uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const { + return (m_impl_up ? m_impl_up->GetIntegerValue(fail_value) : fail_value); +} + +double SBStructuredData::GetFloatValue(double fail_value) const { + return (m_impl_up ? m_impl_up->GetFloatValue(fail_value) : fail_value); +} + +bool SBStructuredData::GetBooleanValue(bool fail_value) const { + return (m_impl_up ? m_impl_up->GetBooleanValue(fail_value) : fail_value); +} + +size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const { + return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0); +} diff --git a/contrib/llvm/tools/lldb/source/API/SBSymbol.cpp b/contrib/llvm/tools/lldb/source/API/SBSymbol.cpp index a4cc525..5be20a1 100644 --- a/contrib/llvm/tools/lldb/source/API/SBSymbol.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBSymbol.cpp @@ -10,11 +10,11 @@ #include "lldb/API/SBSymbol.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Disassembler.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Symbol/Symbol.h" #include "lldb/Target/ExecutionContext.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBSymbolContext.cpp b/contrib/llvm/tools/lldb/source/API/SBSymbolContext.cpp index 4748836..45dfffd 100644 --- a/contrib/llvm/tools/lldb/source/API/SBSymbolContext.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBSymbolContext.cpp @@ -9,11 +9,11 @@ #include "lldb/API/SBSymbolContext.h" #include "lldb/API/SBStream.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Symbol/Function.h" #include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/SymbolContext.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBTarget.cpp b/contrib/llvm/tools/lldb/source/API/SBTarget.cpp index c000bf9..c706344 100644 --- a/contrib/llvm/tools/lldb/source/API/SBTarget.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBTarget.cpp @@ -34,17 +34,14 @@ #include "lldb/Core/ArchSpec.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Disassembler.h" -#include "lldb/Core/Log.h" #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/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectVariable.h" -#include "lldb/Host/FileSpec.h" #include "lldb/Host/Host.h" #include "lldb/Interpreter/Args.h" #include "lldb/Symbol/ClangASTContext.h" @@ -61,6 +58,9 @@ #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" #include "lldb/Target/TargetList.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/RegularExpression.h" #include "../source/Commands/CommandObjectBreakpoint.h" #include "lldb/Interpreter/CommandReturnObject.h" @@ -74,7 +74,7 @@ using namespace lldb_private; namespace { -Error AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { +Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex()); auto process_sp = target.GetProcessSP(); @@ -85,8 +85,8 @@ Error AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { // 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 Status("process is connected and already has a listener, pass " + "empty listener"); } } @@ -686,7 +686,7 @@ SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, if (sb_module_list.GetSize() > 0) { module_list = sb_module_list.get(); } - *sb_bp = target_sp->CreateBreakpoint( + sb_bp = target_sp->CreateBreakpoint( module_list, *sb_file_spec, line, offset, check_inlines, skip_prologue, internal, hardware, move_to_nearest_code); } @@ -699,7 +699,7 @@ SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, 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()); + static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData()); } return sb_bp; @@ -721,11 +721,11 @@ SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, if (module_name && module_name[0]) { FileSpecList module_spec_list; module_spec_list.Append(FileSpec(module_name, false)); - *sb_bp = target_sp->CreateBreakpoint( + sb_bp = target_sp->CreateBreakpoint( &module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); } else { - *sb_bp = target_sp->CreateBreakpoint( + sb_bp = target_sp->CreateBreakpoint( NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); } @@ -735,7 +735,7 @@ SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, 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())); + static_cast<void *>(sb_bp.GetSP().get())); return sb_bp; } @@ -771,7 +771,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const bool hardware = false; const LazyBool skip_prologue = eLazyBoolCalculate; std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - *sb_bp = target_sp->CreateBreakpoint( + sb_bp = target_sp->CreateBreakpoint( module_list.get(), comp_unit_list.get(), symbol_name, name_type_mask, symbol_language, 0, skip_prologue, internal, hardware); } @@ -780,7 +780,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName( 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())); + name_type_mask, static_cast<void *>(sb_bp.GetSP().get())); return sb_bp; } @@ -815,7 +815,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const bool internal = false; const bool hardware = false; const LazyBool skip_prologue = eLazyBoolCalculate; - *sb_bp = target_sp->CreateBreakpoint( + 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); @@ -836,7 +836,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( log->Printf("\"<NULL>\"%c ", sep); } log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask, - static_cast<void *>(sb_bp.get())); + static_cast<void *>(sb_bp.GetSP().get())); } return sb_bp; @@ -875,7 +875,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( const bool hardware = false; const LazyBool skip_prologue = eLazyBoolCalculate; - *sb_bp = target_sp->CreateFuncRegexBreakpoint( + sb_bp = target_sp->CreateFuncRegexBreakpoint( module_list.get(), comp_unit_list.get(), regexp, symbol_language, skip_prologue, internal, hardware); } @@ -884,7 +884,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( 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())); + static_cast<void *>(sb_bp.GetSP().get())); return sb_bp; } @@ -897,7 +897,7 @@ SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { 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); + sb_bp = target_sp->CreateBreakpoint(address, false, hardware); } if (log) @@ -905,7 +905,7 @@ SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { ") => SBBreakpoint(%p)", static_cast<void *>(target_sp.get()), static_cast<uint64_t>(address), - static_cast<void *>(sb_bp.get())); + static_cast<void *>(sb_bp.GetSP().get())); return sb_bp; } @@ -926,7 +926,7 @@ SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { 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); + sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware); } if (log) { @@ -935,7 +935,7 @@ SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => " "SBBreakpoint(%p)", static_cast<void *>(target_sp.get()), s.GetData(), - static_cast<void *>(sb_bp.get())); + static_cast<void *>(sb_bp.GetSP().get())); } return sb_bp; @@ -985,7 +985,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( func_names_set.insert(func_names.GetStringAtIndex(i)); } - *sb_bp = target_sp->CreateSourceRegexBreakpoint( + sb_bp = target_sp->CreateSourceRegexBreakpoint( module_list.get(), source_file_list.get(), func_names_set, regexp, false, hardware, move_to_nearest_code); } @@ -994,7 +994,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( log->Printf("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") " "=> SBBreakpoint(%p)", static_cast<void *>(target_sp.get()), source_regex, - static_cast<void *>(sb_bp.get())); + static_cast<void *>(sb_bp.GetSP().get())); return sb_bp; } @@ -1009,7 +1009,7 @@ SBTarget::BreakpointCreateForException(lldb::LanguageType language, 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, + sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp, hardware); } @@ -1019,7 +1019,7 @@ SBTarget::BreakpointCreateForException(lldb::LanguageType language, static_cast<void *>(target_sp.get()), Language::GetNameForLanguageType(language), catch_bp ? "on" : "off", throw_bp ? "on" : "off", - static_cast<void *>(sb_bp.get())); + static_cast<void *>(sb_bp.GetSP().get())); return sb_bp; } @@ -1038,7 +1038,7 @@ SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { TargetSP target_sp(GetSP()); if (target_sp) { // The breakpoint list is thread safe, no need to lock - *sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); + sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); } return sb_breakpoint; } @@ -1068,14 +1068,14 @@ SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { 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); + 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())); + static_cast<void *>(sb_breakpoint.GetSP().get())); return sb_breakpoint; } @@ -1279,7 +1279,7 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, } // Target::CreateWatchpoint() is thread safe. - Error cw_error; + Status cw_error; // This API doesn't take in a type, so we can't figure out what it is. CompilerType *type = NULL; watchpoint_sp = @@ -1863,7 +1863,7 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, DataBufferHeap data( target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0); bool prefer_file_cache = false; - lldb_private::Error error; + lldb_private::Status error; lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; const size_t bytes_read = target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(), @@ -2170,7 +2170,7 @@ lldb::addr_t SBTarget::GetStackRedZoneSize() { if (process_sp) abi_sp = process_sp->GetABI(); else - abi_sp = ABI::FindPlugin(target_sp->GetArchitecture()); + abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture()); if (abi_sp) return abi_sp->GetRedZoneSize(); } diff --git a/contrib/llvm/tools/lldb/source/API/SBThread.cpp b/contrib/llvm/tools/lldb/source/API/SBThread.cpp index fbde6dd..b344896 100644 --- a/contrib/llvm/tools/lldb/source/API/SBThread.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBThread.cpp @@ -15,9 +15,7 @@ #include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/State.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" -#include "lldb/Core/StructuredData.h" #include "lldb/Core/ValueObject.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Symbol/CompileUnit.h" @@ -34,6 +32,8 @@ #include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepRange.h" #include "lldb/Target/UnixSignals.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StructuredData.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBDebugger.h" @@ -43,6 +43,7 @@ #include "lldb/API/SBThreadCollection.h" #include "lldb/API/SBThreadPlan.h" #include "lldb/API/SBValue.h" +#include "lldb/lldb-enumerations.h" using namespace lldb; using namespace lldb_private; @@ -292,10 +293,6 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { ThreadCollectionSP threads; threads.reset(new ThreadCollection()); - // We currently only support ThreadSanitizer. - if (type != eInstrumentationRuntimeTypeThreadSanitizer) - return threads; - std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -561,26 +558,26 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { StructuredData::ObjectSP node = info_root_sp->GetObjectForDotSeparatedPath(path); if (node) { - if (node->GetType() == StructuredData::Type::eTypeString) { - strm.Printf("%s", node->GetAsString()->GetValue().c_str()); + if (node->GetType() == eStructuredDataTypeString) { + strm.Printf("%s", node->GetAsString()->GetValue().str().c_str()); success = true; } - if (node->GetType() == StructuredData::Type::eTypeInteger) { + if (node->GetType() == eStructuredDataTypeInteger) { strm.Printf("0x%" PRIx64, node->GetAsInteger()->GetValue()); success = true; } - if (node->GetType() == StructuredData::Type::eTypeFloat) { + if (node->GetType() == eStructuredDataTypeFloat) { strm.Printf("0x%f", node->GetAsFloat()->GetValue()); success = true; } - if (node->GetType() == StructuredData::Type::eTypeBoolean) { + if (node->GetType() == eStructuredDataTypeBoolean) { if (node->GetAsBoolean()->GetValue() == true) strm.Printf("true"); else strm.Printf("false"); success = true; } - if (node->GetType() == StructuredData::Type::eTypeNull) { + if (node->GetType() == eStructuredDataTypeNull) { strm.Printf("null"); success = true; } @@ -595,8 +592,8 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { } if (log) - log->Printf("SBThread(%p)::GetInfoItemByPathAsString () => %s", - static_cast<void *>(exe_ctx.GetThreadPtr()), strm.GetData()); + log->Printf("SBThread(%p)::GetInfoItemByPathAsString (\"%s\") => \"%s\"", + static_cast<void *>(exe_ctx.GetThreadPtr()), path, strm.GetData()); return success; } @@ -1037,7 +1034,7 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { Thread *thread = exe_ctx.GetThreadPtr(); - Error err = thread->JumpToLine(file_spec.get(), line, true); + Status err = thread->JumpToLine(file_spec.get(), line, true); sb_error.SetError(err); return sb_error; } diff --git a/contrib/llvm/tools/lldb/source/API/SBThreadPlan.cpp b/contrib/llvm/tools/lldb/source/API/SBThreadPlan.cpp index 74cabf7..a19023f 100644 --- a/contrib/llvm/tools/lldb/source/API/SBThreadPlan.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBThreadPlan.cpp @@ -15,9 +15,7 @@ #include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/State.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" -#include "lldb/Core/StructuredData.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/SymbolContext.h" @@ -28,12 +26,13 @@ #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" #include "lldb/Target/ThreadPlan.h" -#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlanPython.h" #include "lldb/Target/ThreadPlanStepInRange.h" #include "lldb/Target/ThreadPlanStepInstruction.h" #include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepRange.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StructuredData.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBDebugger.h" diff --git a/contrib/llvm/tools/lldb/source/API/SBTrace.cpp b/contrib/llvm/tools/lldb/source/API/SBTrace.cpp new file mode 100644 index 0000000..9a5fa4e --- /dev/null +++ b/contrib/llvm/tools/lldb/source/API/SBTrace.cpp @@ -0,0 +1,109 @@ +//===-- SBTrace.cpp ---------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "lldb/Target/Process.h" +#include "lldb/Utility/Log.h" + +#include "lldb/API/SBTrace.h" +#include "lldb/API/SBTraceOptions.h" + +using namespace lldb; +using namespace lldb_private; + +class TraceImpl { +public: + lldb::user_id_t uid; +}; + +lldb::ProcessSP SBTrace::GetSP() const { return m_opaque_wp.lock(); } + +size_t SBTrace::GetTraceData(SBError &error, void *buf, size_t size, + size_t offset, lldb::tid_t thread_id) { + ProcessSP process_sp(GetSP()); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size); + error.Clear(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + error.SetError( + process_sp->GetData(GetTraceUID(), thread_id, buffer, offset)); + LLDB_LOG(log, "SBTrace::bytes_read - {0}", buffer.size()); + } + return buffer.size(); +} + +size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size, + size_t offset, lldb::tid_t thread_id) { + ProcessSP process_sp(GetSP()); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size); + error.Clear(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + + error.SetError( + process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset)); + LLDB_LOG(log, "SBTrace::bytes_read - {0}", buffer.size()); + } + return buffer.size(); +} + +void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) { + ProcessSP process_sp(GetSP()); + error.Clear(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + return; + } + error.SetError(process_sp->StopTrace(GetTraceUID(), thread_id)); +} + +void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) { + ProcessSP process_sp(GetSP()); + error.Clear(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + error.SetError(process_sp->GetTraceConfig(GetTraceUID(), + *(options.m_traceoptions_sp))); + } +} + +lldb::user_id_t SBTrace::GetTraceUID() { + if (m_trace_impl_sp) + return m_trace_impl_sp->uid; + return LLDB_INVALID_UID; +} + +void SBTrace::SetTraceUID(lldb::user_id_t uid) { + if (m_trace_impl_sp) + m_trace_impl_sp->uid = uid; +} + +SBTrace::SBTrace() { + m_trace_impl_sp.reset(new TraceImpl); + if (m_trace_impl_sp) + m_trace_impl_sp->uid = LLDB_INVALID_UID; +} + +void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } + +bool SBTrace::IsValid() { + if (!m_trace_impl_sp) + return false; + if (!GetSP()) + return false; + return true; +} diff --git a/contrib/llvm/tools/lldb/source/API/SBTraceOptions.cpp b/contrib/llvm/tools/lldb/source/API/SBTraceOptions.cpp new file mode 100644 index 0000000..20a8f25 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/API/SBTraceOptions.cpp @@ -0,0 +1,94 @@ +//===-- SBTraceOptions.cpp --------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTraceOptions.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/TraceOptions.h" + +using namespace lldb; +using namespace lldb_private; + +SBTraceOptions::SBTraceOptions() { + m_traceoptions_sp.reset(new TraceOptions()); +} + +lldb::TraceType SBTraceOptions::getType() const { + if (m_traceoptions_sp) + return m_traceoptions_sp->getType(); + return lldb::TraceType::eTraceTypeNone; +} + +uint64_t SBTraceOptions::getTraceBufferSize() const { + if (m_traceoptions_sp) + return m_traceoptions_sp->getTraceBufferSize(); + return 0; +} + +lldb::SBStructuredData SBTraceOptions::getTraceParams(lldb::SBError &error) { + error.Clear(); + const lldb_private::StructuredData::DictionarySP dict_obj = + m_traceoptions_sp->getTraceParams(); + lldb::SBStructuredData structData; + if (dict_obj && structData.m_impl_up) + structData.m_impl_up->SetObjectSP(dict_obj->shared_from_this()); + else + error.SetErrorString("Empty trace params"); + return structData; +} + +uint64_t SBTraceOptions::getMetaDataBufferSize() const { + if (m_traceoptions_sp) + return m_traceoptions_sp->getTraceBufferSize(); + return 0; +} + +void SBTraceOptions::setTraceParams(lldb::SBStructuredData ¶ms) { + if (m_traceoptions_sp && params.m_impl_up) { + StructuredData::ObjectSP obj_sp = params.m_impl_up->GetObjectSP(); + if (obj_sp && obj_sp->GetAsDictionary() != nullptr) + m_traceoptions_sp->setTraceParams( + std::static_pointer_cast<StructuredData::Dictionary>(obj_sp)); + } + return; +} + +void SBTraceOptions::setType(lldb::TraceType type) { + if (m_traceoptions_sp) + m_traceoptions_sp->setType(type); +} + +void SBTraceOptions::setTraceBufferSize(uint64_t size) { + if (m_traceoptions_sp) + m_traceoptions_sp->setTraceBufferSize(size); +} + +void SBTraceOptions::setMetaDataBufferSize(uint64_t size) { + if (m_traceoptions_sp) + m_traceoptions_sp->setMetaDataBufferSize(size); +} + +bool SBTraceOptions::IsValid() { + if (m_traceoptions_sp) + return true; + return false; +} + +void SBTraceOptions::setThreadID(lldb::tid_t thread_id) { + if (m_traceoptions_sp) + m_traceoptions_sp->setThreadID(thread_id); +} + +lldb::tid_t SBTraceOptions::getThreadID() { + if (m_traceoptions_sp) + return m_traceoptions_sp->getThreadID(); + return LLDB_INVALID_THREAD_ID; +} diff --git a/contrib/llvm/tools/lldb/source/API/SBType.cpp b/contrib/llvm/tools/lldb/source/API/SBType.cpp index ca63a87..e2ef07c 100644 --- a/contrib/llvm/tools/lldb/source/API/SBType.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBType.cpp @@ -11,13 +11,13 @@ #include "lldb/API/SBDefines.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBTypeEnumMember.h" -#include "lldb/Core/ConstString.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Mangled.h" -#include "lldb/Core/Stream.h" #include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/Type.h" #include "lldb/Symbol/TypeSystem.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include "llvm/ADT/APSInt.h" diff --git a/contrib/llvm/tools/lldb/source/API/SBTypeEnumMember.cpp b/contrib/llvm/tools/lldb/source/API/SBTypeEnumMember.cpp index 787a46b..5ca9db7 100644 --- a/contrib/llvm/tools/lldb/source/API/SBTypeEnumMember.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBTypeEnumMember.cpp @@ -7,13 +7,13 @@ // //===----------------------------------------------------------------------===// -#include "lldb/API/SBType.h" +#include "lldb/API/SBTypeEnumMember.h" #include "lldb/API/SBDefines.h" #include "lldb/API/SBStream.h" -#include "lldb/API/SBTypeEnumMember.h" -#include "lldb/Core/Stream.h" +#include "lldb/API/SBType.h" #include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/Type.h" +#include "lldb/Utility/Stream.h" using namespace lldb; using namespace lldb_private; diff --git a/contrib/llvm/tools/lldb/source/API/SBUnixSignals.cpp b/contrib/llvm/tools/lldb/source/API/SBUnixSignals.cpp index bb85912..14bdd39 100644 --- a/contrib/llvm/tools/lldb/source/API/SBUnixSignals.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBUnixSignals.cpp @@ -8,10 +8,10 @@ // //===----------------------------------------------------------------------===// -#include "lldb/Core/Log.h" #include "lldb/Target/Platform.h" #include "lldb/Target/Process.h" #include "lldb/Target/UnixSignals.h" +#include "lldb/Utility/Log.h" #include "lldb/lldb-defines.h" #include "lldb/API/SBUnixSignals.h" diff --git a/contrib/llvm/tools/lldb/source/API/SBValue.cpp b/contrib/llvm/tools/lldb/source/API/SBValue.cpp index 0531a3f..b6f044c 100644 --- a/contrib/llvm/tools/lldb/source/API/SBValue.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBValue.cpp @@ -17,12 +17,9 @@ #include "lldb/API/SBTypeSynthetic.h" #include "lldb/Breakpoint/Watchpoint.h" -#include "lldb/Core/DataExtractor.h" -#include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Core/Scalar.h" #include "lldb/Core/Section.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" #include "lldb/Core/Value.h" #include "lldb/Core/ValueObject.h" @@ -39,6 +36,9 @@ #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" +#include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBExpressionOptions.h" @@ -112,7 +112,7 @@ public: lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker, std::unique_lock<std::recursive_mutex> &lock, - Error &error) { + Status &error) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!m_valobj_sp) { error.SetErrorString("invalid value object"); @@ -218,12 +218,12 @@ public: return in_value.GetSP(m_stop_locker, m_lock, m_lock_error); } - Error &GetError() { return m_lock_error; } + Status &GetError() { return m_lock_error; } private: Process::StopLocker m_stop_locker; std::unique_lock<std::recursive_mutex> m_lock; - Error m_lock_error; + Status m_lock_error; }; SBValue::SBValue() : m_opaque_sp() {} @@ -1112,7 +1112,7 @@ SBValue SBValue::Dereference() { ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { - Error error; + Status error; sb_value = value_sp->Dereference(error); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1336,7 +1336,7 @@ lldb::SBValue SBValue::AddressOf() { ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { - Error error; + Status error; sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(), GetPreferSyntheticValue()); } @@ -1445,7 +1445,7 @@ lldb::SBData SBValue::GetData() { lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { DataExtractorSP data_sp(new DataExtractor()); - Error error; + Status error; value_sp->GetData(*data_sp, error); if (error.Success()) *sb_data = data_sp; @@ -1475,7 +1475,7 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) { error.SetErrorString("No data to set"); ret = false; } else { - Error set_error; + Status set_error; value_sp->SetData(*data_extractor, set_error); @@ -1541,7 +1541,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, if (write) watch_type |= LLDB_WATCH_TYPE_WRITE; - Error rc; + Status rc; CompilerType type(value_sp->GetCompilerType()); WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc); diff --git a/contrib/llvm/tools/lldb/source/API/SBValueList.cpp b/contrib/llvm/tools/lldb/source/API/SBValueList.cpp index 16289d9..0adf3bb 100644 --- a/contrib/llvm/tools/lldb/source/API/SBValueList.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBValueList.cpp @@ -10,8 +10,8 @@ #include "lldb/API/SBValueList.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBValue.h" -#include "lldb/Core/Log.h" #include "lldb/Core/ValueObjectList.h" +#include "lldb/Utility/Log.h" #include <vector> diff --git a/contrib/llvm/tools/lldb/source/API/SBWatchpoint.cpp b/contrib/llvm/tools/lldb/source/API/SBWatchpoint.cpp index 50153c8..b775537 100644 --- a/contrib/llvm/tools/lldb/source/API/SBWatchpoint.cpp +++ b/contrib/llvm/tools/lldb/source/API/SBWatchpoint.cpp @@ -16,39 +16,35 @@ #include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/WatchpointList.h" -#include "lldb/Core/Log.h" -#include "lldb/Core/Stream.h" #include "lldb/Core/StreamFile.h" #include "lldb/Target/Process.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" #include "lldb/lldb-defines.h" #include "lldb/lldb-types.h" using namespace lldb; using namespace lldb_private; -SBWatchpoint::SBWatchpoint() : m_opaque_sp() {} +SBWatchpoint::SBWatchpoint() {} SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp) - : m_opaque_sp(wp_sp) { + : m_opaque_wp(wp_sp) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { SBStream sstr; GetDescription(sstr, lldb::eDescriptionLevelBrief); - log->Printf("SBWatchpoint::SBWatchpoint (const lldb::WatchpointSP &wp_sp" - "=%p) => this.sp = %p (%s)", - static_cast<void *>(wp_sp.get()), - static_cast<void *>(m_opaque_sp.get()), sstr.GetData()); + LLDB_LOG(log, "watchpoint = {0} ({1})", wp_sp.get(), sstr.GetData()); } } SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_wp(rhs.m_opaque_wp) {} const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) { - if (this != &rhs) - m_opaque_sp = rhs.m_opaque_sp; + m_opaque_wp = rhs.m_opaque_wp; return *this; } @@ -74,7 +70,7 @@ watch_id_t SBWatchpoint::GetID() { return watch_id; } -bool SBWatchpoint::IsValid() const { return (bool)m_opaque_sp; } +bool SBWatchpoint::IsValid() const { return bool(m_opaque_wp.lock()); } SBError SBWatchpoint::GetError() { SBError sb_error; @@ -223,11 +219,11 @@ bool SBWatchpoint::GetDescription(SBStream &description, return true; } -void SBWatchpoint::Clear() { m_opaque_sp.reset(); } +void SBWatchpoint::Clear() { m_opaque_wp.reset(); } -lldb::WatchpointSP SBWatchpoint::GetSP() const { return m_opaque_sp; } +lldb::WatchpointSP SBWatchpoint::GetSP() const { return m_opaque_wp.lock(); } -void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_sp = sp; } +void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_wp = sp; } bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) { return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) != @@ -245,7 +241,7 @@ SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) { SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) { SBWatchpoint sb_watchpoint; if (event.IsValid()) - sb_watchpoint.m_opaque_sp = + sb_watchpoint = Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP()); return sb_watchpoint; } diff --git a/contrib/llvm/tools/lldb/source/API/SystemInitializerFull.cpp b/contrib/llvm/tools/lldb/source/API/SystemInitializerFull.cpp index e7faac5..eb1bc2f 100644 --- a/contrib/llvm/tools/lldb/source/API/SystemInitializerFull.cpp +++ b/contrib/llvm/tools/lldb/source/API/SystemInitializerFull.cpp @@ -20,7 +20,6 @@ #endif #include "lldb/Core/Debugger.h" -#include "lldb/Core/Timer.h" #include "lldb/Host/Host.h" #include "lldb/Initialization/SystemInitializerCommon.h" #include "lldb/Interpreter/CommandInterpreter.h" @@ -28,6 +27,7 @@ #include "lldb/Symbol/GoASTContext.h" //#include "lldb/Symbol/JavaASTContext.h" #include "lldb/Symbol/OCamlASTContext.h" +#include "lldb/Utility/Timer.h" //#include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h" //#include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h" @@ -49,8 +49,10 @@ #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h" //#include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h" #include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h" -#include "Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h" -//#include "Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.h" +#include "Plugins/InstrumentationRuntime/ASan/ASanRuntime.h" +//#include "Plugins/InstrumentationRuntime/TSan/TSanRuntime.h" +#include "Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h" +#include "Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.h" #include "Plugins/JITLoader/GDB/JITLoaderGDB.h" #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" //#include "Plugins/Language/Go/GoLanguage.h" @@ -74,6 +76,7 @@ //#include "Plugins/Platform/MacOSX/PlatformMacOSX.h" //#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h" //#include "Plugins/Platform/NetBSD/PlatformNetBSD.h" +//#include "Plugins/Platform/OpenBSD/PlatformOpenBSD.h" //#include "Plugins/Platform/Windows/PlatformWindows.h" #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h" #include "Plugins/Process/elf-core/ProcessElfCore.h" @@ -266,6 +269,7 @@ void SystemInitializerFull::Initialize() { platform_freebsd::PlatformFreeBSD::Initialize(); //platform_linux::PlatformLinux::Initialize(); //platform_netbsd::PlatformNetBSD::Initialize(); +//platform_openbsd::PlatformOpenBSD::Initialize(); //PlatformWindows::Initialize(); //PlatformKalimba::Initialize(); //platform_android::PlatformAndroid::Initialize(); @@ -308,6 +312,8 @@ void SystemInitializerFull::Initialize() { MemoryHistoryASan::Initialize(); AddressSanitizerRuntime::Initialize(); //ThreadSanitizerRuntime::Initialize(); + UndefinedBehaviorSanitizerRuntime::Initialize(); + MainThreadCheckerRuntime::Initialize(); SymbolVendorELF::Initialize(); SymbolFileDWARF::Initialize(); @@ -398,7 +404,8 @@ void SystemInitializerFull::InitializeSWIG() { } void SystemInitializerFull::Terminate() { - Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION); + static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); + Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION); Debugger::SettingsTerminate(); @@ -431,6 +438,8 @@ void SystemInitializerFull::Terminate() { MemoryHistoryASan::Terminate(); AddressSanitizerRuntime::Terminate(); //ThreadSanitizerRuntime::Terminate(); + UndefinedBehaviorSanitizerRuntime::Terminate(); + MainThreadCheckerRuntime::Terminate(); SymbolVendorELF::Terminate(); SymbolFileDWARF::Terminate(); //SymbolFilePDB::Terminate(); @@ -485,13 +494,14 @@ void SystemInitializerFull::Terminate() { //OperatingSystemGo::Terminate(); platform_freebsd::PlatformFreeBSD::Terminate(); -// platform_linux::PlatformLinux::Terminate(); -// platform_netbsd::PlatformNetBSD::Terminate(); -// PlatformWindows::Terminate(); -// PlatformKalimba::Terminate(); -// platform_android::PlatformAndroid::Terminate(); -// PlatformMacOSX::Terminate(); -// PlatformRemoteiOS::Terminate(); +//platform_linux::PlatformLinux::Terminate(); +//platform_netbsd::PlatformNetBSD::Terminate(); +//platform_openbsd::PlatformOpenBSD::Terminate(); +//PlatformWindows::Terminate(); +//PlatformKalimba::Terminate(); +//platform_android::PlatformAndroid::Terminate(); +//PlatformMacOSX::Terminate(); +//PlatformRemoteiOS::Terminate(); #if defined(__APPLE__) PlatformiOSSimulator::Terminate(); PlatformDarwinKernel::Terminate(); |
