summaryrefslogtreecommitdiff
path: root/source/DataFormatters/FormatManager.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/DataFormatters/FormatManager.cpp')
-rw-r--r--source/DataFormatters/FormatManager.cpp1031
1 files changed, 0 insertions, 1031 deletions
diff --git a/source/DataFormatters/FormatManager.cpp b/source/DataFormatters/FormatManager.cpp
deleted file mode 100644
index 1eac372d79ec..000000000000
--- a/source/DataFormatters/FormatManager.cpp
+++ /dev/null
@@ -1,1031 +0,0 @@
-//===-- FormatManager.cpp ----------------------------------------*- C++-*-===//
-//
-// 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/DataFormatters/FormatManager.h"
-
-#include "llvm/ADT/STLExtras.h"
-
-
-#include "lldb/Core/Debugger.h"
-#include "lldb/DataFormatters/FormattersHelpers.h"
-#include "lldb/DataFormatters/LanguageCategory.h"
-#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/Language.h"
-#include "lldb/Utility/Log.h"
-
-using namespace lldb;
-using namespace lldb_private;
-using namespace lldb_private::formatters;
-
-struct FormatInfo {
- Format format;
- const char format_char; // One or more format characters that can be used for
- // this format.
- const char *format_name; // Long format name that can be used to specify the
- // current format
-};
-
-static constexpr FormatInfo g_format_infos[] = {
- {eFormatDefault, '\0', "default"},
- {eFormatBoolean, 'B', "boolean"},
- {eFormatBinary, 'b', "binary"},
- {eFormatBytes, 'y', "bytes"},
- {eFormatBytesWithASCII, 'Y', "bytes with ASCII"},
- {eFormatChar, 'c', "character"},
- {eFormatCharPrintable, 'C', "printable character"},
- {eFormatComplexFloat, 'F', "complex float"},
- {eFormatCString, 's', "c-string"},
- {eFormatDecimal, 'd', "decimal"},
- {eFormatEnum, 'E', "enumeration"},
- {eFormatHex, 'x', "hex"},
- {eFormatHexUppercase, 'X', "uppercase hex"},
- {eFormatFloat, 'f', "float"},
- {eFormatOctal, 'o', "octal"},
- {eFormatOSType, 'O', "OSType"},
- {eFormatUnicode16, 'U', "unicode16"},
- {eFormatUnicode32, '\0', "unicode32"},
- {eFormatUnsigned, 'u', "unsigned decimal"},
- {eFormatPointer, 'p', "pointer"},
- {eFormatVectorOfChar, '\0', "char[]"},
- {eFormatVectorOfSInt8, '\0', "int8_t[]"},
- {eFormatVectorOfUInt8, '\0', "uint8_t[]"},
- {eFormatVectorOfSInt16, '\0', "int16_t[]"},
- {eFormatVectorOfUInt16, '\0', "uint16_t[]"},
- {eFormatVectorOfSInt32, '\0', "int32_t[]"},
- {eFormatVectorOfUInt32, '\0', "uint32_t[]"},
- {eFormatVectorOfSInt64, '\0', "int64_t[]"},
- {eFormatVectorOfUInt64, '\0', "uint64_t[]"},
- {eFormatVectorOfFloat16, '\0', "float16[]"},
- {eFormatVectorOfFloat32, '\0', "float32[]"},
- {eFormatVectorOfFloat64, '\0', "float64[]"},
- {eFormatVectorOfUInt128, '\0', "uint128_t[]"},
- {eFormatComplexInteger, 'I', "complex integer"},
- {eFormatCharArray, 'a', "character array"},
- {eFormatAddressInfo, 'A', "address"},
- {eFormatHexFloat, '\0', "hex float"},
- {eFormatInstruction, 'i', "instruction"},
- {eFormatVoid, 'v', "void"},
- {eFormatUnicode8, 'u', "unicode8"},
-};
-
-static_assert((sizeof(g_format_infos) / sizeof(g_format_infos[0])) ==
- kNumFormats,
- "All formats must have a corresponding info entry.");
-
-static uint32_t g_num_format_infos = llvm::array_lengthof(g_format_infos);
-
-static bool GetFormatFromFormatChar(char format_char, Format &format) {
- for (uint32_t i = 0; i < g_num_format_infos; ++i) {
- if (g_format_infos[i].format_char == format_char) {
- format = g_format_infos[i].format;
- return true;
- }
- }
- format = eFormatInvalid;
- return false;
-}
-
-static bool GetFormatFromFormatName(const char *format_name,
- bool partial_match_ok, Format &format) {
- uint32_t i;
- for (i = 0; i < g_num_format_infos; ++i) {
- if (strcasecmp(g_format_infos[i].format_name, format_name) == 0) {
- format = g_format_infos[i].format;
- return true;
- }
- }
-
- if (partial_match_ok) {
- for (i = 0; i < g_num_format_infos; ++i) {
- if (strcasestr(g_format_infos[i].format_name, format_name) ==
- g_format_infos[i].format_name) {
- format = g_format_infos[i].format;
- return true;
- }
- }
- }
- format = eFormatInvalid;
- return false;
-}
-
-void FormatManager::Changed() {
- ++m_last_revision;
- m_format_cache.Clear();
- std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
- for (auto &iter : m_language_categories_map) {
- if (iter.second)
- iter.second->GetFormatCache().Clear();
- }
-}
-
-bool FormatManager::GetFormatFromCString(const char *format_cstr,
- bool partial_match_ok,
- lldb::Format &format) {
- bool success = false;
- if (format_cstr && format_cstr[0]) {
- if (format_cstr[1] == '\0') {
- success = GetFormatFromFormatChar(format_cstr[0], format);
- if (success)
- return true;
- }
-
- success = GetFormatFromFormatName(format_cstr, partial_match_ok, format);
- }
- if (!success)
- format = eFormatInvalid;
- return success;
-}
-
-char FormatManager::GetFormatAsFormatChar(lldb::Format format) {
- for (uint32_t i = 0; i < g_num_format_infos; ++i) {
- if (g_format_infos[i].format == format)
- return g_format_infos[i].format_char;
- }
- return '\0';
-}
-
-const char *FormatManager::GetFormatAsCString(Format format) {
- if (format >= eFormatDefault && format < kNumFormats)
- return g_format_infos[format].format_name;
- return nullptr;
-}
-
-void FormatManager::EnableAllCategories() {
- m_categories_map.EnableAllCategories();
- std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
- for (auto &iter : m_language_categories_map) {
- if (iter.second)
- iter.second->Enable();
- }
-}
-
-void FormatManager::DisableAllCategories() {
- m_categories_map.DisableAllCategories();
- std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
- for (auto &iter : m_language_categories_map) {
- if (iter.second)
- iter.second->Disable();
- }
-}
-
-void FormatManager::GetPossibleMatches(
- ValueObject &valobj, CompilerType compiler_type, uint32_t reason,
- lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
- bool did_strip_ptr, bool did_strip_ref, bool did_strip_typedef,
- bool root_level) {
- compiler_type = compiler_type.GetTypeForFormatters();
- ConstString type_name(compiler_type.GetConstTypeName());
- if (valobj.GetBitfieldBitSize() > 0) {
- StreamString sstring;
- sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
- ConstString bitfieldname(sstring.GetString());
- entries.push_back(
- {bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef});
- reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
- }
-
- if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
- entries.push_back(
- {type_name, reason, did_strip_ptr, did_strip_ref, did_strip_typedef});
-
- ConstString display_type_name(compiler_type.GetDisplayTypeName());
- if (display_type_name != type_name)
- entries.push_back({display_type_name, reason, did_strip_ptr,
- did_strip_ref, did_strip_typedef});
- }
-
- for (bool is_rvalue_ref = true, j = true;
- j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
- CompilerType non_ref_type = compiler_type.GetNonReferenceType();
- GetPossibleMatches(
- valobj, non_ref_type,
- reason |
- lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
- use_dynamic, entries, did_strip_ptr, true, did_strip_typedef);
- if (non_ref_type.IsTypedefType()) {
- CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
- deffed_referenced_type =
- is_rvalue_ref ? deffed_referenced_type.GetRValueReferenceType()
- : deffed_referenced_type.GetLValueReferenceType();
- GetPossibleMatches(
- valobj, deffed_referenced_type,
- reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
- use_dynamic, entries, did_strip_ptr, did_strip_ref,
- true); // this is not exactly the usual meaning of stripping typedefs
- }
- }
-
- if (compiler_type.IsPointerType()) {
- CompilerType non_ptr_type = compiler_type.GetPointeeType();
- GetPossibleMatches(
- valobj, non_ptr_type,
- reason |
- lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
- use_dynamic, entries, true, did_strip_ref, did_strip_typedef);
- if (non_ptr_type.IsTypedefType()) {
- CompilerType deffed_pointed_type =
- non_ptr_type.GetTypedefedType().GetPointerType();
- GetPossibleMatches(
- valobj, deffed_pointed_type,
- reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
- use_dynamic, entries, did_strip_ptr, did_strip_ref,
- true); // this is not exactly the usual meaning of stripping typedefs
- }
- }
-
- for (lldb::LanguageType language_type : GetCandidateLanguages(valobj)) {
- if (Language *language = Language::FindPlugin(language_type)) {
- for (ConstString candidate :
- language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
- entries.push_back(
- {candidate,
- reason | lldb_private::eFormatterChoiceCriterionLanguagePlugin,
- did_strip_ptr, did_strip_ref, did_strip_typedef});
- }
- }
- }
-
- // try to strip typedef chains
- if (compiler_type.IsTypedefType()) {
- CompilerType deffed_type = compiler_type.GetTypedefedType();
- GetPossibleMatches(
- valobj, deffed_type,
- reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
- use_dynamic, entries, did_strip_ptr, did_strip_ref, true);
- }
-
- if (root_level) {
- do {
- if (!compiler_type.IsValid())
- break;
-
- CompilerType unqual_compiler_ast_type =
- compiler_type.GetFullyUnqualifiedType();
- if (!unqual_compiler_ast_type.IsValid())
- break;
- if (unqual_compiler_ast_type.GetOpaqueQualType() !=
- compiler_type.GetOpaqueQualType())
- GetPossibleMatches(valobj, unqual_compiler_ast_type, reason,
- use_dynamic, entries, did_strip_ptr, did_strip_ref,
- did_strip_typedef);
- } while (false);
-
- // if all else fails, go to static type
- if (valobj.IsDynamic()) {
- lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
- if (static_value_sp)
- GetPossibleMatches(
- *static_value_sp.get(), static_value_sp->GetCompilerType(),
- reason | lldb_private::eFormatterChoiceCriterionWentToStaticValue,
- use_dynamic, entries, did_strip_ptr, did_strip_ref,
- did_strip_typedef, true);
- }
- }
-}
-
-lldb::TypeFormatImplSP
-FormatManager::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
- if (!type_sp)
- return lldb::TypeFormatImplSP();
- lldb::TypeFormatImplSP format_chosen_sp;
- uint32_t num_categories = m_categories_map.GetCount();
- lldb::TypeCategoryImplSP category_sp;
- uint32_t prio_category = UINT32_MAX;
- for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
- category_sp = GetCategoryAtIndex(category_id);
- if (!category_sp->IsEnabled())
- continue;
- lldb::TypeFormatImplSP format_current_sp =
- category_sp->GetFormatForType(type_sp);
- if (format_current_sp &&
- (format_chosen_sp.get() == nullptr ||
- (prio_category > category_sp->GetEnabledPosition()))) {
- prio_category = category_sp->GetEnabledPosition();
- format_chosen_sp = format_current_sp;
- }
- }
- return format_chosen_sp;
-}
-
-lldb::TypeSummaryImplSP
-FormatManager::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
- if (!type_sp)
- return lldb::TypeSummaryImplSP();
- lldb::TypeSummaryImplSP summary_chosen_sp;
- uint32_t num_categories = m_categories_map.GetCount();
- lldb::TypeCategoryImplSP category_sp;
- uint32_t prio_category = UINT32_MAX;
- for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
- category_sp = GetCategoryAtIndex(category_id);
- if (!category_sp->IsEnabled())
- continue;
- lldb::TypeSummaryImplSP summary_current_sp =
- category_sp->GetSummaryForType(type_sp);
- if (summary_current_sp &&
- (summary_chosen_sp.get() == nullptr ||
- (prio_category > category_sp->GetEnabledPosition()))) {
- prio_category = category_sp->GetEnabledPosition();
- summary_chosen_sp = summary_current_sp;
- }
- }
- return summary_chosen_sp;
-}
-
-lldb::TypeFilterImplSP
-FormatManager::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
- if (!type_sp)
- return lldb::TypeFilterImplSP();
- lldb::TypeFilterImplSP filter_chosen_sp;
- uint32_t num_categories = m_categories_map.GetCount();
- lldb::TypeCategoryImplSP category_sp;
- uint32_t prio_category = UINT32_MAX;
- for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
- category_sp = GetCategoryAtIndex(category_id);
- if (!category_sp->IsEnabled())
- continue;
- lldb::TypeFilterImplSP filter_current_sp(
- (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
- if (filter_current_sp &&
- (filter_chosen_sp.get() == nullptr ||
- (prio_category > category_sp->GetEnabledPosition()))) {
- prio_category = category_sp->GetEnabledPosition();
- filter_chosen_sp = filter_current_sp;
- }
- }
- return filter_chosen_sp;
-}
-
-lldb::ScriptedSyntheticChildrenSP
-FormatManager::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
- if (!type_sp)
- return lldb::ScriptedSyntheticChildrenSP();
- lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
- uint32_t num_categories = m_categories_map.GetCount();
- lldb::TypeCategoryImplSP category_sp;
- uint32_t prio_category = UINT32_MAX;
- for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
- category_sp = GetCategoryAtIndex(category_id);
- if (!category_sp->IsEnabled())
- continue;
- lldb::ScriptedSyntheticChildrenSP synth_current_sp(
- (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
- .get());
- if (synth_current_sp &&
- (synth_chosen_sp.get() == nullptr ||
- (prio_category > category_sp->GetEnabledPosition()))) {
- prio_category = category_sp->GetEnabledPosition();
- synth_chosen_sp = synth_current_sp;
- }
- }
- return synth_chosen_sp;
-}
-
-lldb::TypeValidatorImplSP
-FormatManager::GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp) {
- if (!type_sp)
- return lldb::TypeValidatorImplSP();
- lldb::TypeValidatorImplSP validator_chosen_sp;
- uint32_t num_categories = m_categories_map.GetCount();
- lldb::TypeCategoryImplSP category_sp;
- uint32_t prio_category = UINT32_MAX;
- for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
- category_sp = GetCategoryAtIndex(category_id);
- if (!category_sp->IsEnabled())
- continue;
- lldb::TypeValidatorImplSP validator_current_sp(
- category_sp->GetValidatorForType(type_sp).get());
- if (validator_current_sp &&
- (validator_chosen_sp.get() == nullptr ||
- (prio_category > category_sp->GetEnabledPosition()))) {
- prio_category = category_sp->GetEnabledPosition();
- validator_chosen_sp = validator_current_sp;
- }
- }
- return validator_chosen_sp;
-}
-
-void FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback) {
- m_categories_map.ForEach(callback);
- std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
- for (const auto &entry : m_language_categories_map) {
- if (auto category_sp = entry.second->GetCategory()) {
- if (!callback(category_sp))
- break;
- }
- }
-}
-
-lldb::TypeCategoryImplSP
-FormatManager::GetCategory(ConstString category_name, bool can_create) {
- if (!category_name)
- return GetCategory(m_default_category_name);
- lldb::TypeCategoryImplSP category;
- if (m_categories_map.Get(category_name, category))
- return category;
-
- if (!can_create)
- return lldb::TypeCategoryImplSP();
-
- m_categories_map.Add(
- category_name,
- lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
- return GetCategory(category_name);
-}
-
-lldb::Format FormatManager::GetSingleItemFormat(lldb::Format vector_format) {
- switch (vector_format) {
- case eFormatVectorOfChar:
- return eFormatCharArray;
-
- case eFormatVectorOfSInt8:
- case eFormatVectorOfSInt16:
- case eFormatVectorOfSInt32:
- case eFormatVectorOfSInt64:
- return eFormatDecimal;
-
- case eFormatVectorOfUInt8:
- case eFormatVectorOfUInt16:
- case eFormatVectorOfUInt32:
- case eFormatVectorOfUInt64:
- case eFormatVectorOfUInt128:
- return eFormatHex;
-
- case eFormatVectorOfFloat16:
- case eFormatVectorOfFloat32:
- case eFormatVectorOfFloat64:
- return eFormatFloat;
-
- default:
- return lldb::eFormatInvalid;
- }
-}
-
-bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) {
- // if settings say no oneline whatsoever
- if (valobj.GetTargetSP().get() &&
- !valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries())
- return false; // then don't oneline
-
- // if this object has a summary, then ask the summary
- if (valobj.GetSummaryFormat().get() != nullptr)
- return valobj.GetSummaryFormat()->IsOneLiner();
-
- // no children, no party
- if (valobj.GetNumChildren() == 0)
- return false;
-
- // ask the type if it has any opinion about this eLazyBoolCalculate == no
- // opinion; other values should be self explanatory
- CompilerType compiler_type(valobj.GetCompilerType());
- if (compiler_type.IsValid()) {
- switch (compiler_type.ShouldPrintAsOneLiner(&valobj)) {
- case eLazyBoolNo:
- return false;
- case eLazyBoolYes:
- return true;
- case eLazyBoolCalculate:
- break;
- }
- }
-
- size_t total_children_name_len = 0;
-
- for (size_t idx = 0; idx < valobj.GetNumChildren(); idx++) {
- bool is_synth_val = false;
- ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true));
- // something is wrong here - bail out
- if (!child_sp)
- return false;
-
- // also ask the child's type if it has any opinion
- CompilerType child_compiler_type(child_sp->GetCompilerType());
- if (child_compiler_type.IsValid()) {
- switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get())) {
- case eLazyBoolYes:
- // an opinion of yes is only binding for the child, so keep going
- case eLazyBoolCalculate:
- break;
- case eLazyBoolNo:
- // but if the child says no, then it's a veto on the whole thing
- return false;
- }
- }
-
- // if we decided to define synthetic children for a type, we probably care
- // enough to show them, but avoid nesting children in children
- if (child_sp->GetSyntheticChildren().get() != nullptr) {
- ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
- // wait.. wat? just get out of here..
- if (!synth_sp)
- return false;
- // but if we only have them to provide a value, keep going
- if (!synth_sp->MightHaveChildren() &&
- synth_sp->DoesProvideSyntheticValue())
- is_synth_val = true;
- else
- return false;
- }
-
- total_children_name_len += child_sp->GetName().GetLength();
-
- // 50 itself is a "randomly" chosen number - the idea is that
- // overly long structs should not get this treatment
- // FIXME: maybe make this a user-tweakable setting?
- if (total_children_name_len > 50)
- return false;
-
- // if a summary is there..
- if (child_sp->GetSummaryFormat()) {
- // and it wants children, then bail out
- if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
- return false;
- }
-
- // if this child has children..
- if (child_sp->GetNumChildren()) {
- // ...and no summary...
- // (if it had a summary and the summary wanted children, we would have
- // bailed out anyway
- // so this only makes us bail out if this has no summary and we would
- // then print children)
- if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do
- // that if not a
- // synthetic valued
- // child
- return false; // then bail out
- }
- }
- return true;
-}
-
-ConstString FormatManager::GetValidTypeName(ConstString type) {
- return ::GetValidTypeName_Impl(type);
-}
-
-ConstString FormatManager::GetTypeForCache(ValueObject &valobj,
- lldb::DynamicValueType use_dynamic) {
- ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(
- use_dynamic, valobj.IsSynthetic());
- if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) {
- if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
- return valobj_sp->GetQualifiedTypeName();
- }
- return ConstString();
-}
-
-std::vector<lldb::LanguageType>
-FormatManager::GetCandidateLanguages(ValueObject &valobj) {
- lldb::LanguageType lang_type = valobj.GetObjectRuntimeLanguage();
- return GetCandidateLanguages(lang_type);
-}
-
-std::vector<lldb::LanguageType>
-FormatManager::GetCandidateLanguages(lldb::LanguageType lang_type) {
- switch (lang_type) {
- case lldb::eLanguageTypeC:
- case lldb::eLanguageTypeC89:
- case lldb::eLanguageTypeC99:
- case lldb::eLanguageTypeC11:
- case lldb::eLanguageTypeC_plus_plus:
- case lldb::eLanguageTypeC_plus_plus_03:
- case lldb::eLanguageTypeC_plus_plus_11:
- case lldb::eLanguageTypeC_plus_plus_14:
- return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
- default:
- return {lang_type};
- }
-}
-
-LanguageCategory *
-FormatManager::GetCategoryForLanguage(lldb::LanguageType lang_type) {
- std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
- auto iter = m_language_categories_map.find(lang_type),
- end = m_language_categories_map.end();
- if (iter != end)
- return iter->second.get();
- LanguageCategory *lang_category = new LanguageCategory(lang_type);
- m_language_categories_map[lang_type] =
- LanguageCategory::UniquePointer(lang_category);
- return lang_category;
-}
-
-lldb::TypeFormatImplSP
-FormatManager::GetHardcodedFormat(FormattersMatchData &match_data) {
- TypeFormatImplSP retval_sp;
-
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->GetHardcoded(*this, match_data, retval_sp))
- break;
- }
- }
-
- return retval_sp;
-}
-
-lldb::TypeFormatImplSP
-FormatManager::GetFormat(ValueObject &valobj,
- lldb::DynamicValueType use_dynamic) {
- FormattersMatchData match_data(valobj, use_dynamic);
-
- TypeFormatImplSP retval;
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
- if (match_data.GetTypeForCache()) {
- LLDB_LOGF(log,
- "\n\n[FormatManager::GetFormat] Looking into cache for type %s",
- match_data.GetTypeForCache().AsCString("<invalid>"));
- if (m_format_cache.GetFormat(match_data.GetTypeForCache(), retval)) {
- if (log) {
- LLDB_LOGF(
- log, "[FormatManager::GetFormat] Cache search success. Returning.");
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(),
- m_format_cache.GetCacheMisses());
- }
- return retval;
- }
- LLDB_LOGF(
- log,
- "[FormatManager::GetFormat] Cache search failed. Going normal route");
- }
-
- retval = m_categories_map.GetFormat(match_data);
- if (!retval) {
- LLDB_LOGF(log,
- "[FormatManager::GetFormat] Search failed. Giving language a "
- "chance.");
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->Get(match_data, retval))
- break;
- }
- }
- if (retval) {
- LLDB_LOGF(
- log,
- "[FormatManager::GetFormat] Language search success. Returning.");
- return retval;
- }
- }
- if (!retval) {
- LLDB_LOGF(log, "[FormatManager::GetFormat] Search failed. Giving hardcoded "
- "a chance.");
- retval = GetHardcodedFormat(match_data);
- }
-
- if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
- LLDB_LOGF(log, "[FormatManager::GetFormat] Caching %p for type %s",
- static_cast<void *>(retval.get()),
- match_data.GetTypeForCache().AsCString("<invalid>"));
- m_format_cache.SetFormat(match_data.GetTypeForCache(), retval);
- }
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
- return retval;
-}
-
-lldb::TypeSummaryImplSP
-FormatManager::GetHardcodedSummaryFormat(FormattersMatchData &match_data) {
- TypeSummaryImplSP retval_sp;
-
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->GetHardcoded(*this, match_data, retval_sp))
- break;
- }
- }
-
- return retval_sp;
-}
-
-lldb::TypeSummaryImplSP
-FormatManager::GetSummaryFormat(ValueObject &valobj,
- lldb::DynamicValueType use_dynamic) {
- FormattersMatchData match_data(valobj, use_dynamic);
-
- TypeSummaryImplSP retval;
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
- if (match_data.GetTypeForCache()) {
- LLDB_LOGF(log,
- "\n\n[FormatManager::GetSummaryFormat] Looking into cache "
- "for type %s",
- match_data.GetTypeForCache().AsCString("<invalid>"));
- if (m_format_cache.GetSummary(match_data.GetTypeForCache(), retval)) {
- if (log) {
- LLDB_LOGF(log,
- "[FormatManager::GetSummaryFormat] Cache search success. "
- "Returning.");
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(),
- m_format_cache.GetCacheMisses());
- }
- return retval;
- }
- LLDB_LOGF(log, "[FormatManager::GetSummaryFormat] Cache search failed. "
- "Going normal route");
- }
-
- retval = m_categories_map.GetSummaryFormat(match_data);
- if (!retval) {
- LLDB_LOGF(log, "[FormatManager::GetSummaryFormat] Search failed. Giving "
- "language a chance.");
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->Get(match_data, retval))
- break;
- }
- }
- if (retval) {
- LLDB_LOGF(log, "[FormatManager::GetSummaryFormat] Language search "
- "success. Returning.");
- return retval;
- }
- }
- if (!retval) {
- LLDB_LOGF(log, "[FormatManager::GetSummaryFormat] Search failed. Giving "
- "hardcoded a chance.");
- retval = GetHardcodedSummaryFormat(match_data);
- }
-
- if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
- LLDB_LOGF(log, "[FormatManager::GetSummaryFormat] Caching %p for type %s",
- static_cast<void *>(retval.get()),
- match_data.GetTypeForCache().AsCString("<invalid>"));
- m_format_cache.SetSummary(match_data.GetTypeForCache(), retval);
- }
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
- return retval;
-}
-
-lldb::SyntheticChildrenSP
-FormatManager::GetHardcodedSyntheticChildren(FormattersMatchData &match_data) {
- SyntheticChildrenSP retval_sp;
-
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->GetHardcoded(*this, match_data, retval_sp))
- break;
- }
- }
-
- return retval_sp;
-}
-
-lldb::SyntheticChildrenSP
-FormatManager::GetSyntheticChildren(ValueObject &valobj,
- lldb::DynamicValueType use_dynamic) {
- FormattersMatchData match_data(valobj, use_dynamic);
-
- SyntheticChildrenSP retval;
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
- if (match_data.GetTypeForCache()) {
- LLDB_LOGF(log,
- "\n\n[FormatManager::GetSyntheticChildren] Looking into "
- "cache for type %s",
- match_data.GetTypeForCache().AsCString("<invalid>"));
- if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(), retval)) {
- if (log) {
- LLDB_LOGF(log, "[FormatManager::GetSyntheticChildren] Cache search "
- "success. Returning.");
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(),
- m_format_cache.GetCacheMisses());
- }
- return retval;
- }
- LLDB_LOGF(log, "[FormatManager::GetSyntheticChildren] Cache search failed. "
- "Going normal route");
- }
-
- retval = m_categories_map.GetSyntheticChildren(match_data);
- if (!retval) {
- LLDB_LOGF(log,
- "[FormatManager::GetSyntheticChildren] Search failed. Giving "
- "language a chance.");
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->Get(match_data, retval))
- break;
- }
- }
- if (retval) {
- LLDB_LOGF(log, "[FormatManager::GetSyntheticChildren] Language search "
- "success. Returning.");
- return retval;
- }
- }
- if (!retval) {
- LLDB_LOGF(log,
- "[FormatManager::GetSyntheticChildren] Search failed. Giving "
- "hardcoded a chance.");
- retval = GetHardcodedSyntheticChildren(match_data);
- }
-
- if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
- LLDB_LOGF(log,
- "[FormatManager::GetSyntheticChildren] Caching %p for type %s",
- static_cast<void *>(retval.get()),
- match_data.GetTypeForCache().AsCString("<invalid>"));
- m_format_cache.SetSynthetic(match_data.GetTypeForCache(), retval);
- }
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
- return retval;
-}
-
-lldb::TypeValidatorImplSP
-FormatManager::GetValidator(ValueObject &valobj,
- lldb::DynamicValueType use_dynamic) {
- FormattersMatchData match_data(valobj, use_dynamic);
-
- TypeValidatorImplSP retval;
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
- if (match_data.GetTypeForCache()) {
- LLDB_LOGF(
- log, "\n\n[FormatManager::GetValidator] Looking into cache for type %s",
- match_data.GetTypeForCache().AsCString("<invalid>"));
- if (m_format_cache.GetValidator(match_data.GetTypeForCache(), retval)) {
- if (log) {
- LLDB_LOGF(
- log,
- "[FormatManager::GetValidator] Cache search success. Returning.");
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(),
- m_format_cache.GetCacheMisses());
- }
- return retval;
- }
- LLDB_LOGF(log, "[FormatManager::GetValidator] Cache search failed. Going "
- "normal route");
- }
-
- retval = m_categories_map.GetValidator(match_data);
- if (!retval) {
- LLDB_LOGF(log, "[FormatManager::GetValidator] Search failed. Giving "
- "language a chance.");
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->Get(match_data, retval))
- break;
- }
- }
- if (retval) {
- LLDB_LOGF(log, "[FormatManager::GetValidator] Language search success. "
- "Returning.");
- return retval;
- }
- }
- if (!retval) {
- LLDB_LOGF(log, "[FormatManager::GetValidator] Search failed. Giving "
- "hardcoded a chance.");
- retval = GetHardcodedValidator(match_data);
- }
-
- if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
- LLDB_LOGF(log, "[FormatManager::GetValidator] Caching %p for type %s",
- static_cast<void *>(retval.get()),
- match_data.GetTypeForCache().AsCString("<invalid>"));
- m_format_cache.SetValidator(match_data.GetTypeForCache(), retval);
- }
- LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
- m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
- return retval;
-}
-
-lldb::TypeValidatorImplSP
-FormatManager::GetHardcodedValidator(FormattersMatchData &match_data) {
- TypeValidatorImplSP retval_sp;
-
- for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
- if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
- if (lang_category->GetHardcoded(*this, match_data, retval_sp))
- break;
- }
- }
-
- return retval_sp;
-}
-
-FormatManager::FormatManager()
- : m_last_revision(0), m_format_cache(), m_language_categories_mutex(),
- m_language_categories_map(), m_named_summaries_map(this),
- m_categories_map(this), m_default_category_name(ConstString("default")),
- m_system_category_name(ConstString("system")),
- m_vectortypes_category_name(ConstString("VectorTypes")) {
- LoadSystemFormatters();
- LoadVectorFormatters();
-
- EnableCategory(m_vectortypes_category_name, TypeCategoryMap::Last,
- lldb::eLanguageTypeObjC_plus_plus);
- EnableCategory(m_system_category_name, TypeCategoryMap::Last,
- lldb::eLanguageTypeObjC_plus_plus);
-}
-
-void FormatManager::LoadSystemFormatters() {
- TypeSummaryImpl::Flags string_flags;
- string_flags.SetCascades(true)
- .SetSkipPointers(true)
- .SetSkipReferences(false)
- .SetDontShowChildren(true)
- .SetDontShowValue(false)
- .SetShowMembersOneLiner(false)
- .SetHideItemNames(false);
-
- TypeSummaryImpl::Flags string_array_flags;
- string_array_flags.SetCascades(true)
- .SetSkipPointers(true)
- .SetSkipReferences(false)
- .SetDontShowChildren(true)
- .SetDontShowValue(true)
- .SetShowMembersOneLiner(false)
- .SetHideItemNames(false);
-
- lldb::TypeSummaryImplSP string_format(
- new StringSummaryFormat(string_flags, "${var%s}"));
-
- lldb::TypeSummaryImplSP string_array_format(
- new StringSummaryFormat(string_array_flags, "${var%s}"));
-
- RegularExpression any_size_char_arr(llvm::StringRef("char \\[[0-9]+\\]"));
-
- TypeCategoryImpl::SharedPointer sys_category_sp =
- GetCategory(m_system_category_name);
-
- sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"),
- string_format);
- sys_category_sp->GetTypeSummariesContainer()->Add(
- ConstString("unsigned char *"), string_format);
- sys_category_sp->GetRegexTypeSummariesContainer()->Add(
- std::move(any_size_char_arr), string_array_format);
-
- lldb::TypeSummaryImplSP ostype_summary(
- new StringSummaryFormat(TypeSummaryImpl::Flags()
- .SetCascades(false)
- .SetSkipPointers(true)
- .SetSkipReferences(true)
- .SetDontShowChildren(true)
- .SetDontShowValue(false)
- .SetShowMembersOneLiner(false)
- .SetHideItemNames(false),
- "${var%O}"));
-
- sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"),
- ostype_summary);
-
- TypeFormatImpl::Flags fourchar_flags;
- fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(
- true);
-
- AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"),
- fourchar_flags);
-}
-
-void FormatManager::LoadVectorFormatters() {
- TypeCategoryImpl::SharedPointer vectors_category_sp =
- GetCategory(m_vectortypes_category_name);
-
- TypeSummaryImpl::Flags vector_flags;
- vector_flags.SetCascades(true)
- .SetSkipPointers(true)
- .SetSkipReferences(false)
- .SetDontShowChildren(true)
- .SetDontShowValue(false)
- .SetShowMembersOneLiner(true)
- .SetHideItemNames(true);
-
- AddStringSummary(vectors_category_sp, "${var.uint128}",
- ConstString("builtin_type_vec128"), vector_flags);
-
- AddStringSummary(vectors_category_sp, "", ConstString("float [4]"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("int32_t [4]"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("int16_t [8]"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vDouble"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vFloat"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vSInt8"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vSInt16"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vSInt32"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vUInt8"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vUInt32"),
- vector_flags);
- AddStringSummary(vectors_category_sp, "", ConstString("vBool32"),
- vector_flags);
-}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-25 17:07:30 +0000