blob: 0f1b29f1b4768eec09c4f1dfee813200c7f4a244 [file] [log] [blame]
//===-- FormatCache.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
// Other libraries and framework includes
// Project includes
#include "lldb/DataFormatters/FormatCache.h"
using namespace lldb;
using namespace lldb_private;
FormatCache::Entry::Entry()
: m_format_cached(false), m_summary_cached(false),
m_synthetic_cached(false), m_validator_cached(false), m_format_sp(),
m_summary_sp(), m_synthetic_sp(), m_validator_sp() {}
FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp)
: m_summary_cached(false), m_synthetic_cached(false),
m_validator_cached(false), m_summary_sp(), m_synthetic_sp(),
m_validator_sp() {
SetFormat(format_sp);
}
FormatCache::Entry::Entry(lldb::TypeSummaryImplSP summary_sp)
: m_format_cached(false), m_synthetic_cached(false),
m_validator_cached(false), m_format_sp(), m_synthetic_sp(),
m_validator_sp() {
SetSummary(summary_sp);
}
FormatCache::Entry::Entry(lldb::SyntheticChildrenSP synthetic_sp)
: m_format_cached(false), m_summary_cached(false),
m_validator_cached(false), m_format_sp(), m_summary_sp(),
m_validator_sp() {
SetSynthetic(synthetic_sp);
}
FormatCache::Entry::Entry(lldb::TypeValidatorImplSP validator_sp)
: m_format_cached(false), m_summary_cached(false),
m_synthetic_cached(false), m_format_sp(), m_summary_sp(),
m_synthetic_sp() {
SetValidator(validator_sp);
}
FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp,
lldb::TypeSummaryImplSP summary_sp,
lldb::SyntheticChildrenSP synthetic_sp,
lldb::TypeValidatorImplSP validator_sp) {
SetFormat(format_sp);
SetSummary(summary_sp);
SetSynthetic(synthetic_sp);
SetValidator(validator_sp);
}
bool FormatCache::Entry::IsFormatCached() { return m_format_cached; }
bool FormatCache::Entry::IsSummaryCached() { return m_summary_cached; }
bool FormatCache::Entry::IsSyntheticCached() { return m_synthetic_cached; }
bool FormatCache::Entry::IsValidatorCached() { return m_validator_cached; }
lldb::TypeFormatImplSP FormatCache::Entry::GetFormat() { return m_format_sp; }
lldb::TypeSummaryImplSP FormatCache::Entry::GetSummary() {
return m_summary_sp;
}
lldb::SyntheticChildrenSP FormatCache::Entry::GetSynthetic() {
return m_synthetic_sp;
}
lldb::TypeValidatorImplSP FormatCache::Entry::GetValidator() {
return m_validator_sp;
}
void FormatCache::Entry::SetFormat(lldb::TypeFormatImplSP format_sp) {
m_format_cached = true;
m_format_sp = format_sp;
}
void FormatCache::Entry::SetSummary(lldb::TypeSummaryImplSP summary_sp) {
m_summary_cached = true;
m_summary_sp = summary_sp;
}
void FormatCache::Entry::SetSynthetic(lldb::SyntheticChildrenSP synthetic_sp) {
m_synthetic_cached = true;
m_synthetic_sp = synthetic_sp;
}
void FormatCache::Entry::SetValidator(lldb::TypeValidatorImplSP validator_sp) {
m_validator_cached = true;
m_validator_sp = validator_sp;
}
FormatCache::FormatCache()
: m_map(), m_mutex()
#ifdef LLDB_CONFIGURATION_DEBUG
,
m_cache_hits(0), m_cache_misses(0)
#endif
{
}
FormatCache::Entry &FormatCache::GetEntry(const ConstString &type) {
auto i = m_map.find(type), e = m_map.end();
if (i != e)
return i->second;
m_map[type] = FormatCache::Entry();
return m_map[type];
}
bool FormatCache::GetFormat(const ConstString &type,
lldb::TypeFormatImplSP &format_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
if (entry.IsFormatCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++;
#endif
format_sp = entry.GetFormat();
return true;
}
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++;
#endif
format_sp.reset();
return false;
}
bool FormatCache::GetSummary(const ConstString &type,
lldb::TypeSummaryImplSP &summary_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
if (entry.IsSummaryCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++;
#endif
summary_sp = entry.GetSummary();
return true;
}
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++;
#endif
summary_sp.reset();
return false;
}
bool FormatCache::GetSynthetic(const ConstString &type,
lldb::SyntheticChildrenSP &synthetic_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
if (entry.IsSyntheticCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++;
#endif
synthetic_sp = entry.GetSynthetic();
return true;
}
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++;
#endif
synthetic_sp.reset();
return false;
}
bool FormatCache::GetValidator(const ConstString &type,
lldb::TypeValidatorImplSP &validator_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
if (entry.IsValidatorCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++;
#endif
validator_sp = entry.GetValidator();
return true;
}
#ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++;
#endif
validator_sp.reset();
return false;
}
void FormatCache::SetFormat(const ConstString &type,
lldb::TypeFormatImplSP &format_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetFormat(format_sp);
}
void FormatCache::SetSummary(const ConstString &type,
lldb::TypeSummaryImplSP &summary_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetSummary(summary_sp);
}
void FormatCache::SetSynthetic(const ConstString &type,
lldb::SyntheticChildrenSP &synthetic_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetSynthetic(synthetic_sp);
}
void FormatCache::SetValidator(const ConstString &type,
lldb::TypeValidatorImplSP &validator_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetValidator(validator_sp);
}
void FormatCache::Clear() {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
m_map.clear();
}