Files
llvm-tms34010/lldb/source/Core/DebuggerEvents.cpp
T
Jonas Devlieghere 0ac8dfd058 [lldb] Add an SB API to get progress events as SBStructuredData
This is a preparatory patch to add an SB API to get the progress data as
SBStructuredData. The advantage of using SBStructuredData is that the
dictionary can grow over time with more fields.

This approach is identical to the way this is implemented for diagnostic
events.

Differential revision: https://reviews.llvm.org/D143687
2023-02-10 17:18:00 -08:00

156 lines
5.2 KiB
C++

//===-- DebuggerEvents.cpp ------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/DebuggerEvents.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "llvm/Support/WithColor.h"
using namespace lldb_private;
using namespace lldb;
template <typename T>
static const T *GetEventDataFromEventImpl(const Event *event_ptr) {
if (event_ptr)
if (const EventData *event_data = event_ptr->GetData())
if (event_data->GetFlavor() == T::GetFlavorString())
return static_cast<const T *>(event_ptr->GetData());
return nullptr;
}
ConstString ProgressEventData::GetFlavorString() {
static ConstString g_flavor("ProgressEventData");
return g_flavor;
}
ConstString ProgressEventData::GetFlavor() const {
return ProgressEventData::GetFlavorString();
}
void ProgressEventData::Dump(Stream *s) const {
s->Printf(" id = %" PRIu64 ", message = \"%s\"", m_id, m_message.c_str());
if (m_completed == 0 || m_completed == m_total)
s->Printf(", type = %s", m_completed == 0 ? "start" : "end");
else
s->PutCString(", type = update");
// If m_total is UINT64_MAX, there is no progress to report, just "start"
// and "end". If it isn't we will show the completed and total amounts.
if (m_total != UINT64_MAX)
s->Printf(", progress = %" PRIu64 " of %" PRIu64, m_completed, m_total);
}
const ProgressEventData *
ProgressEventData::GetEventDataFromEvent(const Event *event_ptr) {
return GetEventDataFromEventImpl<ProgressEventData>(event_ptr);
}
StructuredData::DictionarySP
ProgressEventData::GetAsStructuredData(const Event *event_ptr) {
const ProgressEventData *progress_data =
ProgressEventData::GetEventDataFromEvent(event_ptr);
if (!progress_data)
return {};
auto dictionary_sp = std::make_shared<StructuredData::Dictionary>();
dictionary_sp->AddStringItem("message", progress_data->GetMessage());
dictionary_sp->AddIntegerItem("progress_id", progress_data->GetID());
dictionary_sp->AddIntegerItem("completed", progress_data->GetCompleted());
dictionary_sp->AddIntegerItem("total", progress_data->GetTotal());
dictionary_sp->AddBooleanItem("debugger_specific",
progress_data->IsDebuggerSpecific());
return dictionary_sp;
}
llvm::StringRef DiagnosticEventData::GetPrefix() const {
switch (m_type) {
case Type::Info:
return "info";
case Type::Warning:
return "warning";
case Type::Error:
return "error";
}
llvm_unreachable("Fully covered switch above!");
}
void DiagnosticEventData::Dump(Stream *s) const {
llvm::HighlightColor color = m_type == Type::Warning
? llvm::HighlightColor::Warning
: llvm::HighlightColor::Error;
llvm::WithColor(s->AsRawOstream(), color, llvm::ColorMode::Enable)
<< GetPrefix();
*s << ": " << GetMessage() << '\n';
s->Flush();
}
ConstString DiagnosticEventData::GetFlavorString() {
static ConstString g_flavor("DiagnosticEventData");
return g_flavor;
}
ConstString DiagnosticEventData::GetFlavor() const {
return DiagnosticEventData::GetFlavorString();
}
const DiagnosticEventData *
DiagnosticEventData::GetEventDataFromEvent(const Event *event_ptr) {
return GetEventDataFromEventImpl<DiagnosticEventData>(event_ptr);
}
StructuredData::DictionarySP
DiagnosticEventData::GetAsStructuredData(const Event *event_ptr) {
const DiagnosticEventData *diagnostic_data =
DiagnosticEventData::GetEventDataFromEvent(event_ptr);
if (!diagnostic_data)
return {};
auto dictionary_sp = std::make_shared<StructuredData::Dictionary>();
dictionary_sp->AddStringItem("message", diagnostic_data->GetMessage());
dictionary_sp->AddStringItem("type", diagnostic_data->GetPrefix());
dictionary_sp->AddBooleanItem("debugger_specific",
diagnostic_data->IsDebuggerSpecific());
return dictionary_sp;
}
ConstString SymbolChangeEventData::GetFlavorString() {
static ConstString g_flavor("SymbolChangeEventData");
return g_flavor;
}
ConstString SymbolChangeEventData::GetFlavor() const {
return SymbolChangeEventData::GetFlavorString();
}
const SymbolChangeEventData *
SymbolChangeEventData::GetEventDataFromEvent(const Event *event_ptr) {
return GetEventDataFromEventImpl<SymbolChangeEventData>(event_ptr);
}
void SymbolChangeEventData::DoOnRemoval(Event *event_ptr) {
DebuggerSP debugger_sp(m_debugger_wp.lock());
if (!debugger_sp)
return;
for (TargetSP target_sp : debugger_sp->GetTargetList().Targets()) {
if (ModuleSP module_sp =
target_sp->GetImages().FindModule(m_module_spec.GetUUID())) {
{
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
if (!module_sp->GetSymbolFileFileSpec())
module_sp->SetSymbolFileFileSpec(m_module_spec.GetSymbolFileSpec());
}
ModuleList module_list;
module_list.Append(module_sp);
target_sp->SymbolsDidLoad(module_list);
}
}
}