759300192a
Take 2, with missing cmake line fixed. Build tested on Ubuntu 14.04 with clang-3.6. See docs/structured_data/StructuredDataPlugins.md for details. differential review: https://reviews.llvm.org/D22976 reviewers: clayborg, jingham llvm-svn: 279202
396 lines
9.6 KiB
C++
396 lines
9.6 KiB
C++
//===-- Event.cpp -----------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <algorithm>
|
|
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/Event.h"
|
|
#include "lldb/Core/Broadcaster.h"
|
|
#include "lldb/Core/DataExtractor.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/State.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Host/Endian.h"
|
|
#include "lldb/Target/Process.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
#pragma mark -
|
|
#pragma mark Event
|
|
|
|
//------------------------------------------------------------------
|
|
// Event functions
|
|
//------------------------------------------------------------------
|
|
|
|
Event::Event (Broadcaster *broadcaster, uint32_t event_type, EventData *data) :
|
|
m_broadcaster_wp(broadcaster->GetBroadcasterImpl()),
|
|
m_type(event_type),
|
|
m_data_sp(data)
|
|
{
|
|
}
|
|
|
|
Event::Event (Broadcaster *broadcaster, uint32_t event_type, const EventDataSP &event_data_sp) :
|
|
m_broadcaster_wp(broadcaster->GetBroadcasterImpl()),
|
|
m_type(event_type),
|
|
m_data_sp(event_data_sp)
|
|
{
|
|
}
|
|
|
|
Event::Event(uint32_t event_type, EventData *data) :
|
|
m_broadcaster_wp(),
|
|
m_type(event_type),
|
|
m_data_sp(data)
|
|
{
|
|
}
|
|
|
|
Event::Event(uint32_t event_type, const EventDataSP &event_data_sp) :
|
|
m_broadcaster_wp(),
|
|
m_type(event_type),
|
|
m_data_sp(event_data_sp)
|
|
{
|
|
}
|
|
|
|
Event::~Event() = default;
|
|
|
|
void
|
|
Event::Dump (Stream *s) const
|
|
{
|
|
Broadcaster *broadcaster;
|
|
Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock());
|
|
if (broadcaster_impl_sp)
|
|
broadcaster = broadcaster_impl_sp->GetBroadcaster();
|
|
else
|
|
broadcaster = nullptr;
|
|
|
|
if (broadcaster)
|
|
{
|
|
StreamString event_name;
|
|
if (broadcaster->GetEventNames (event_name, m_type, false))
|
|
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
|
|
static_cast<const void*>(this),
|
|
static_cast<void*>(broadcaster),
|
|
broadcaster->GetBroadcasterName().GetCString(),
|
|
m_type, event_name.GetString().c_str());
|
|
else
|
|
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
|
|
static_cast<const void*>(this),
|
|
static_cast<void*>(broadcaster),
|
|
broadcaster->GetBroadcasterName().GetCString(), m_type);
|
|
}
|
|
else
|
|
s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
|
|
static_cast<const void*>(this), m_type);
|
|
|
|
if (m_data_sp)
|
|
{
|
|
s->PutChar('{');
|
|
m_data_sp->Dump (s);
|
|
s->PutChar('}');
|
|
}
|
|
else
|
|
s->Printf ("<NULL>");
|
|
}
|
|
|
|
void
|
|
Event::DoOnRemoval ()
|
|
{
|
|
if (m_data_sp)
|
|
m_data_sp->DoOnRemoval (this);
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark EventData
|
|
|
|
//------------------------------------------------------------------
|
|
// EventData functions
|
|
//------------------------------------------------------------------
|
|
|
|
EventData::EventData() = default;
|
|
|
|
EventData::~EventData() = default;
|
|
|
|
void
|
|
EventData::Dump (Stream *s) const
|
|
{
|
|
s->PutCString ("Generic Event Data");
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark EventDataBytes
|
|
|
|
//------------------------------------------------------------------
|
|
// EventDataBytes functions
|
|
//------------------------------------------------------------------
|
|
|
|
|
|
EventDataBytes::EventDataBytes () :
|
|
m_bytes()
|
|
{
|
|
}
|
|
|
|
EventDataBytes::EventDataBytes (const char *cstr) :
|
|
m_bytes()
|
|
{
|
|
SetBytesFromCString (cstr);
|
|
}
|
|
|
|
EventDataBytes::EventDataBytes (const void *src, size_t src_len) :
|
|
m_bytes()
|
|
{
|
|
SetBytes (src, src_len);
|
|
}
|
|
|
|
EventDataBytes::~EventDataBytes() = default;
|
|
|
|
const ConstString &
|
|
EventDataBytes::GetFlavorString ()
|
|
{
|
|
static ConstString g_flavor ("EventDataBytes");
|
|
return g_flavor;
|
|
}
|
|
|
|
const ConstString &
|
|
EventDataBytes::GetFlavor () const
|
|
{
|
|
return EventDataBytes::GetFlavorString ();
|
|
}
|
|
|
|
void
|
|
EventDataBytes::Dump (Stream *s) const
|
|
{
|
|
size_t num_printable_chars = std::count_if (m_bytes.begin(), m_bytes.end(), isprint);
|
|
if (num_printable_chars == m_bytes.size())
|
|
{
|
|
s->Printf("\"%s\"", m_bytes.c_str());
|
|
}
|
|
else if (!m_bytes.empty())
|
|
{
|
|
DataExtractor data;
|
|
data.SetData(m_bytes.data(), m_bytes.size(), endian::InlHostByteOrder());
|
|
data.Dump(s, 0, eFormatBytes, 1, m_bytes.size(), 32, LLDB_INVALID_ADDRESS, 0, 0);
|
|
}
|
|
}
|
|
|
|
const void *
|
|
EventDataBytes::GetBytes() const
|
|
{
|
|
return (m_bytes.empty() ? nullptr : m_bytes.data());
|
|
}
|
|
|
|
size_t
|
|
EventDataBytes::GetByteSize() const
|
|
{
|
|
return m_bytes.size ();
|
|
}
|
|
|
|
void
|
|
EventDataBytes::SetBytes (const void *src, size_t src_len)
|
|
{
|
|
if (src != nullptr && src_len > 0)
|
|
m_bytes.assign ((const char *)src, src_len);
|
|
else
|
|
m_bytes.clear();
|
|
}
|
|
|
|
void
|
|
EventDataBytes::SetBytesFromCString (const char *cstr)
|
|
{
|
|
if (cstr != nullptr && cstr[0])
|
|
m_bytes.assign (cstr);
|
|
else
|
|
m_bytes.clear();
|
|
}
|
|
|
|
const void *
|
|
EventDataBytes::GetBytesFromEvent (const Event *event_ptr)
|
|
{
|
|
const EventDataBytes *e = GetEventDataFromEvent (event_ptr);
|
|
if (e != nullptr)
|
|
return e->GetBytes();
|
|
return nullptr;
|
|
}
|
|
|
|
size_t
|
|
EventDataBytes::GetByteSizeFromEvent (const Event *event_ptr)
|
|
{
|
|
const EventDataBytes *e = GetEventDataFromEvent (event_ptr);
|
|
if (e != nullptr)
|
|
return e->GetByteSize();
|
|
return 0;
|
|
}
|
|
|
|
const EventDataBytes *
|
|
EventDataBytes::GetEventDataFromEvent (const Event *event_ptr)
|
|
{
|
|
if (event_ptr != nullptr)
|
|
{
|
|
const EventData *event_data = event_ptr->GetData();
|
|
if (event_data && event_data->GetFlavor() == EventDataBytes::GetFlavorString())
|
|
return static_cast <const EventDataBytes *> (event_data);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
EventDataBytes::SwapBytes (std::string &new_bytes)
|
|
{
|
|
m_bytes.swap (new_bytes);
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark EventStructuredData
|
|
|
|
//------------------------------------------------------------------
|
|
// EventDataStructuredData definitions
|
|
//------------------------------------------------------------------
|
|
|
|
EventDataStructuredData::EventDataStructuredData() :
|
|
EventData(),
|
|
m_process_sp(),
|
|
m_object_sp(),
|
|
m_plugin_sp()
|
|
{
|
|
}
|
|
|
|
EventDataStructuredData::EventDataStructuredData(const ProcessSP &process_sp,
|
|
const StructuredData::ObjectSP
|
|
&object_sp,
|
|
const
|
|
lldb::StructuredDataPluginSP
|
|
&plugin_sp) :
|
|
EventData(),
|
|
m_process_sp(process_sp),
|
|
m_object_sp(object_sp),
|
|
m_plugin_sp(plugin_sp)
|
|
{
|
|
}
|
|
|
|
EventDataStructuredData::~EventDataStructuredData()
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// EventDataStructuredData member functions
|
|
//------------------------------------------------------------------
|
|
|
|
const ConstString &
|
|
EventDataStructuredData::GetFlavor() const
|
|
{
|
|
return EventDataStructuredData::GetFlavorString();
|
|
}
|
|
|
|
void
|
|
EventDataStructuredData::Dump(Stream *s) const
|
|
{
|
|
if (!s)
|
|
return;
|
|
|
|
if (m_object_sp)
|
|
m_object_sp->Dump(*s);
|
|
}
|
|
|
|
const ProcessSP&
|
|
EventDataStructuredData::GetProcess() const
|
|
{
|
|
return m_process_sp;
|
|
}
|
|
|
|
const StructuredData::ObjectSP&
|
|
EventDataStructuredData::GetObject() const
|
|
{
|
|
return m_object_sp;
|
|
}
|
|
|
|
const lldb::StructuredDataPluginSP&
|
|
EventDataStructuredData::GetStructuredDataPlugin() const
|
|
{
|
|
return m_plugin_sp;
|
|
}
|
|
|
|
void
|
|
EventDataStructuredData::SetProcess(const ProcessSP &process_sp)
|
|
{
|
|
m_process_sp = process_sp;
|
|
}
|
|
|
|
void
|
|
EventDataStructuredData::SetObject(const StructuredData::ObjectSP &object_sp)
|
|
{
|
|
m_object_sp = object_sp;
|
|
}
|
|
|
|
void
|
|
EventDataStructuredData::SetStructuredDataPlugin(const
|
|
lldb::StructuredDataPluginSP
|
|
&plugin_sp)
|
|
{
|
|
m_plugin_sp = plugin_sp;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// EventDataStructuredData static functions
|
|
//------------------------------------------------------------------
|
|
|
|
const EventDataStructuredData*
|
|
EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr)
|
|
{
|
|
if (event_ptr == nullptr)
|
|
return nullptr;
|
|
|
|
const EventData *event_data = event_ptr->GetData();
|
|
if (!event_data || event_data->GetFlavor() !=
|
|
EventDataStructuredData::GetFlavorString())
|
|
return nullptr;
|
|
|
|
return static_cast<const EventDataStructuredData*>(event_data);
|
|
}
|
|
|
|
ProcessSP
|
|
EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr)
|
|
{
|
|
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
|
|
if (event_data)
|
|
return event_data->GetProcess();
|
|
else
|
|
return ProcessSP();
|
|
}
|
|
|
|
StructuredData::ObjectSP
|
|
EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr)
|
|
{
|
|
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
|
|
if (event_data)
|
|
return event_data->GetObject();
|
|
else
|
|
return StructuredData::ObjectSP();
|
|
}
|
|
|
|
lldb::StructuredDataPluginSP
|
|
EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr)
|
|
{
|
|
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
|
|
if (event_data)
|
|
return event_data->GetStructuredDataPlugin();
|
|
else
|
|
return StructuredDataPluginSP();
|
|
}
|
|
|
|
const ConstString &
|
|
EventDataStructuredData::GetFlavorString ()
|
|
{
|
|
static ConstString s_flavor("EventDataStructuredData");
|
|
return s_flavor;
|
|
}
|
|
|
|
|