This is an archive of the discontinued LLVM Phabricator instance.

Differential D71296

Replace redundant code in LanguageCategory with templates (NFC)
ClosedPublic

Authored by aprantl on Dec 10 2019, 1:20 PM.

Details

Reviewers
jingham
davide
Commits
rGb3801de7c50f: Replace redundant code in LanguageCategory with templates (NFC)
Summary

This is a cleanup similar to https://reviews.llvm.org/D71231.

Diff Detail

Event Timeline

aprantl created this revision.Dec 10 2019, 1:20 PM
aprantl added a child revision: D71297: Remove unsound caching in LanguageCategory.Dec 10 2019, 1:28 PM
davide accepted this revision.Dec 10 2019, 4:06 PM

LGTM, in the same vein as D71231.

This revision is now accepted and ready to land.Dec 10 2019, 4:06 PM
Closed by commit rGb3801de7c50f: Replace redundant code in LanguageCategory with templates (NFC) (authored by aprantl). · Explain WhyDec 10 2019, 4:18 PM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptDec 10 2019, 4:18 PM

Revision Contents

PathSize
lldb/
include/
lldb/
DataFormatters/
27 lines
source/
DataFormatters/
187 lines

Diff 233222

lldb/include/lldb/DataFormatters/LanguageCategory.h

Show All 19 Lines
namespace lldb_private { namespace lldb_private {
class LanguageCategory { class LanguageCategory {
public: public:
typedef std::unique_ptr<LanguageCategory> UniquePointer; typedef std::unique_ptr<LanguageCategory> UniquePointer;
LanguageCategory(lldb::LanguageType lang_type); LanguageCategory(lldb::LanguageType lang_type);
bool Get(FormattersMatchData &match_data, lldb::TypeFormatImplSP &format_sp); template <typename ImplSP>
bool Get(FormattersMatchData &match_data, ImplSP &format_sp);
bool Get(FormattersMatchData &match_data, lldb::TypeSummaryImplSP &format_sp); template <typename ImplSP>
bool Get(FormattersMatchData &match_data,
lldb::SyntheticChildrenSP &format_sp);
bool Get(FormattersMatchData &match_data,
lldb::TypeValidatorImplSP &format_sp);
bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
lldb::TypeFormatImplSP &format_sp);
bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data, bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
lldb::TypeSummaryImplSP &format_sp); ImplSP &format_sp);
bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
lldb::SyntheticChildrenSP &format_sp);
bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
lldb::TypeValidatorImplSP &format_sp);
lldb::TypeCategoryImplSP GetCategory() const; lldb::TypeCategoryImplSP GetCategory() const;
FormatCache &GetFormatCache(); FormatCache &GetFormatCache();
void Enable(); void Enable();
void Disable(); void Disable();
bool IsEnabled(); bool IsEnabled();
private: private:
lldb::TypeCategoryImplSP m_category_sp; lldb::TypeCategoryImplSP m_category_sp;
HardcodedFormatters::HardcodedFormatFinder m_hardcoded_formats; HardcodedFormatters::HardcodedFormatFinder m_hardcoded_formats;
HardcodedFormatters::HardcodedSummaryFinder m_hardcoded_summaries; HardcodedFormatters::HardcodedSummaryFinder m_hardcoded_summaries;
HardcodedFormatters::HardcodedSyntheticFinder m_hardcoded_synthetics; HardcodedFormatters::HardcodedSyntheticFinder m_hardcoded_synthetics;
HardcodedFormatters::HardcodedValidatorFinder m_hardcoded_validators; HardcodedFormatters::HardcodedValidatorFinder m_hardcoded_validators;
template <typename ImplSP>
auto &GetHardcodedFinder();
lldb_private::FormatCache m_format_cache; lldb_private::FormatCache m_format_cache;
bool m_enabled; bool m_enabled;
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // lldb_LanguageCategory_h_ #endif // lldb_LanguageCategory_h_

lldb/source/DataFormatters/LanguageCategory.cpp

Show All 28 Lines if (Language *language_plugin = Language::FindPlugin(lang_type)) {
m_hardcoded_formats = language_plugin->GetHardcodedFormats(); m_hardcoded_formats = language_plugin->GetHardcodedFormats();
m_hardcoded_summaries = language_plugin->GetHardcodedSummaries(); m_hardcoded_summaries = language_plugin->GetHardcodedSummaries();
m_hardcoded_synthetics = language_plugin->GetHardcodedSynthetics(); m_hardcoded_synthetics = language_plugin->GetHardcodedSynthetics();
m_hardcoded_validators = language_plugin->GetHardcodedValidators(); m_hardcoded_validators = language_plugin->GetHardcodedValidators();
} }
Enable(); Enable();
} }
template<typename ImplSP>
bool LanguageCategory::Get(FormattersMatchData &match_data, bool LanguageCategory::Get(FormattersMatchData &match_data,
lldb::TypeFormatImplSP &format_sp) { ImplSP &retval_sp) {
if (!m_category_sp) if (!m_category_sp)
return false; return false;
if (!IsEnabled()) if (!IsEnabled())
return false; return false;
if (match_data.GetTypeForCache()) { if (match_data.GetTypeForCache()) {
if (m_format_cache.Get(match_data.GetTypeForCache(), format_sp)) if (m_format_cache.Get(match_data.GetTypeForCache(), retval_sp))
return format_sp.get() != nullptr; return (bool)retval_sp;
} }
ValueObject &valobj(match_data.GetValueObject()); ValueObject &valobj(match_data.GetValueObject());
bool result = m_category_sp->Get(valobj.GetObjectRuntimeLanguage(), bool result = m_category_sp->Get(valobj.GetObjectRuntimeLanguage(),
match_data.GetMatchesVector(), format_sp); match_data.GetMatchesVector(), retval_sp);
if (match_data.GetTypeForCache() && if (match_data.GetTypeForCache() &&
(!format_sp || !format_sp->NonCacheable())) { (!retval_sp || !retval_sp->NonCacheable())) {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp); m_format_cache.Set(match_data.GetTypeForCache(), retval_sp);
} }
return result; return result;
} }
bool LanguageCategory::Get(FormattersMatchData &match_data, /// Explicit instantiations for the four types.
lldb::TypeSummaryImplSP &format_sp) { /// \{
if (!m_category_sp) template bool
return false; LanguageCategory::Get<lldb::TypeValidatorImplSP>(FormattersMatchData &,
lldb::TypeValidatorImplSP &);
if (!IsEnabled()) template bool
return false; LanguageCategory::Get<lldb::TypeFormatImplSP>(FormattersMatchData &,
lldb::TypeFormatImplSP &);
if (match_data.GetTypeForCache()) { template bool
if (m_format_cache.Get(match_data.GetTypeForCache(), format_sp)) LanguageCategory::Get<lldb::TypeSummaryImplSP>(FormattersMatchData &,
return format_sp.get() != nullptr; lldb::TypeSummaryImplSP &);
} template bool
LanguageCategory::Get<lldb::SyntheticChildrenSP>(FormattersMatchData &,
ValueObject &valobj(match_data.GetValueObject()); lldb::SyntheticChildrenSP &);
bool result = m_category_sp->Get(valobj.GetObjectRuntimeLanguage(), /// \}
match_data.GetMatchesVector(), format_sp);
if (match_data.GetTypeForCache() && template <>
(!format_sp || !format_sp->NonCacheable())) { auto &LanguageCategory::GetHardcodedFinder<lldb::TypeFormatImplSP>() {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp); return m_hardcoded_formats;
} }
return result;
} template <>
auto &LanguageCategory::GetHardcodedFinder<lldb::TypeSummaryImplSP>() {
bool LanguageCategory::Get(FormattersMatchData &match_data, return m_hardcoded_summaries;
lldb::SyntheticChildrenSP &format_sp) { }
if (!m_category_sp)
return false; template <>
auto &LanguageCategory::GetHardcodedFinder<lldb::SyntheticChildrenSP>() {
if (!IsEnabled()) return m_hardcoded_synthetics;
return false; }
if (match_data.GetTypeForCache()) { template <>
if (m_format_cache.Get(match_data.GetTypeForCache(), format_sp)) auto &LanguageCategory::GetHardcodedFinder<lldb::TypeValidatorImplSP>() {
return format_sp.get() != nullptr; return m_hardcoded_validators;
}
ValueObject &valobj(match_data.GetValueObject());
bool result = m_category_sp->Get(valobj.GetObjectRuntimeLanguage(),
match_data.GetMatchesVector(), format_sp);
if (match_data.GetTypeForCache() &&
(!format_sp || !format_sp->NonCacheable())) {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp);
}
return result;
}
bool LanguageCategory::Get(FormattersMatchData &match_data,
lldb::TypeValidatorImplSP &format_sp) {
if (!m_category_sp)
return false;
if (!IsEnabled())
return false;
if (match_data.GetTypeForCache()) {
if (m_format_cache.Get(match_data.GetTypeForCache(), format_sp))
return format_sp.get() != nullptr;
}
ValueObject &valobj(match_data.GetValueObject());
bool result = m_category_sp->Get(valobj.GetObjectRuntimeLanguage(),
match_data.GetMatchesVector(), format_sp);
if (match_data.GetTypeForCache() &&
(!format_sp || !format_sp->NonCacheable())) {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp);
}
return result;
}
bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
FormattersMatchData &match_data,
lldb::TypeFormatImplSP &format_sp) {
if (!IsEnabled())
return false;
ValueObject &valobj(match_data.GetValueObject());
lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
for (auto &candidate : m_hardcoded_formats) {
if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
break;
}
if (match_data.GetTypeForCache() &&
(!format_sp || !format_sp->NonCacheable())) {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp);
}
return format_sp.get() != nullptr;
} }
template <typename ImplSP>
bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr, bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
FormattersMatchData &match_data, FormattersMatchData &match_data,
lldb::TypeSummaryImplSP &format_sp) { ImplSP &retval_sp) {
if (!IsEnabled()) if (!IsEnabled())
return false; return false;
ValueObject &valobj(match_data.GetValueObject()); ValueObject &valobj(match_data.GetValueObject());
lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType()); lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
for (auto &candidate : m_hardcoded_summaries) { for (auto &candidate : GetHardcodedFinder<ImplSP>()) {
if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr))) if (auto result = candidate(valobj, use_dynamic, fmt_mgr)) {
retval_sp = result;
break; break;
} }
if (match_data.GetTypeForCache() &&
(!format_sp || !format_sp->NonCacheable())) {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp);
}
return format_sp.get() != nullptr;
}
bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
FormattersMatchData &match_data,
lldb::SyntheticChildrenSP &format_sp) {
if (!IsEnabled())
return false;
ValueObject &valobj(match_data.GetValueObject());
lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
for (auto &candidate : m_hardcoded_synthetics) {
if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
break;
} }
if (match_data.GetTypeForCache() && if (match_data.GetTypeForCache() &&
(!format_sp || !format_sp->NonCacheable())) { (!retval_sp || !retval_sp->NonCacheable())) {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp); m_format_cache.Set(match_data.GetTypeForCache(), retval_sp);
} }
return format_sp.get() != nullptr; return (bool)retval_sp;
} }
bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr, /// Explicit instantiations for the four types.
FormattersMatchData &match_data, /// \{
lldb::TypeValidatorImplSP &format_sp) { template bool LanguageCategory::GetHardcoded<lldb::TypeValidatorImplSP>(
if (!IsEnabled()) FormatManager &, FormattersMatchData &, lldb::TypeValidatorImplSP &);
return false; template bool LanguageCategory::GetHardcoded<lldb::TypeFormatImplSP>(
FormatManager &, FormattersMatchData &, lldb::TypeFormatImplSP &);
ValueObject &valobj(match_data.GetValueObject()); template bool LanguageCategory::GetHardcoded<lldb::TypeSummaryImplSP>(
lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType()); FormatManager &, FormattersMatchData &, lldb::TypeSummaryImplSP &);
template bool LanguageCategory::GetHardcoded<lldb::SyntheticChildrenSP>(
for (auto &candidate : m_hardcoded_validators) { FormatManager &, FormattersMatchData &, lldb::SyntheticChildrenSP &);
if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr))) /// \}
break;
}
if (match_data.GetTypeForCache() &&
(!format_sp || !format_sp->NonCacheable())) {
m_format_cache.Set(match_data.GetTypeForCache(), format_sp);
}
return format_sp.get() != nullptr;
}
lldb::TypeCategoryImplSP LanguageCategory::GetCategory() const { lldb::TypeCategoryImplSP LanguageCategory::GetCategory() const {
return m_category_sp; return m_category_sp;
} }
FormatCache &LanguageCategory::GetFormatCache() { return m_format_cache; } FormatCache &LanguageCategory::GetFormatCache() { return m_format_cache; }
void LanguageCategory::Enable() { void LanguageCategory::Enable() {
Show All 12 Lines