1dda28197Spatrick //===-- FormatManager.cpp -------------------------------------------------===//
2061da546Spatrick //
3061da546Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4061da546Spatrick // See https://llvm.org/LICENSE.txt for license information.
5061da546Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6061da546Spatrick //
7061da546Spatrick //===----------------------------------------------------------------------===//
8061da546Spatrick
9061da546Spatrick #include "lldb/DataFormatters/FormatManager.h"
10061da546Spatrick
11061da546Spatrick #include "lldb/Core/Debugger.h"
12061da546Spatrick #include "lldb/DataFormatters/FormattersHelpers.h"
13061da546Spatrick #include "lldb/DataFormatters/LanguageCategory.h"
14*f6aab3d8Srobert #include "lldb/Interpreter/ScriptInterpreter.h"
15061da546Spatrick #include "lldb/Target/ExecutionContext.h"
16061da546Spatrick #include "lldb/Target/Language.h"
17*f6aab3d8Srobert #include "lldb/Utility/LLDBLog.h"
18061da546Spatrick #include "lldb/Utility/Log.h"
19*f6aab3d8Srobert #include "llvm/ADT/STLExtras.h"
20061da546Spatrick
21061da546Spatrick using namespace lldb;
22061da546Spatrick using namespace lldb_private;
23061da546Spatrick using namespace lldb_private::formatters;
24061da546Spatrick
25061da546Spatrick struct FormatInfo {
26061da546Spatrick Format format;
27061da546Spatrick const char format_char; // One or more format characters that can be used for
28061da546Spatrick // this format.
29061da546Spatrick const char *format_name; // Long format name that can be used to specify the
30061da546Spatrick // current format
31061da546Spatrick };
32061da546Spatrick
33061da546Spatrick static constexpr FormatInfo g_format_infos[] = {
34061da546Spatrick {eFormatDefault, '\0', "default"},
35061da546Spatrick {eFormatBoolean, 'B', "boolean"},
36061da546Spatrick {eFormatBinary, 'b', "binary"},
37061da546Spatrick {eFormatBytes, 'y', "bytes"},
38061da546Spatrick {eFormatBytesWithASCII, 'Y', "bytes with ASCII"},
39061da546Spatrick {eFormatChar, 'c', "character"},
40061da546Spatrick {eFormatCharPrintable, 'C', "printable character"},
41061da546Spatrick {eFormatComplexFloat, 'F', "complex float"},
42061da546Spatrick {eFormatCString, 's', "c-string"},
43061da546Spatrick {eFormatDecimal, 'd', "decimal"},
44061da546Spatrick {eFormatEnum, 'E', "enumeration"},
45061da546Spatrick {eFormatHex, 'x', "hex"},
46061da546Spatrick {eFormatHexUppercase, 'X', "uppercase hex"},
47061da546Spatrick {eFormatFloat, 'f', "float"},
48061da546Spatrick {eFormatOctal, 'o', "octal"},
49061da546Spatrick {eFormatOSType, 'O', "OSType"},
50061da546Spatrick {eFormatUnicode16, 'U', "unicode16"},
51061da546Spatrick {eFormatUnicode32, '\0', "unicode32"},
52061da546Spatrick {eFormatUnsigned, 'u', "unsigned decimal"},
53061da546Spatrick {eFormatPointer, 'p', "pointer"},
54061da546Spatrick {eFormatVectorOfChar, '\0', "char[]"},
55061da546Spatrick {eFormatVectorOfSInt8, '\0', "int8_t[]"},
56061da546Spatrick {eFormatVectorOfUInt8, '\0', "uint8_t[]"},
57061da546Spatrick {eFormatVectorOfSInt16, '\0', "int16_t[]"},
58061da546Spatrick {eFormatVectorOfUInt16, '\0', "uint16_t[]"},
59061da546Spatrick {eFormatVectorOfSInt32, '\0', "int32_t[]"},
60061da546Spatrick {eFormatVectorOfUInt32, '\0', "uint32_t[]"},
61061da546Spatrick {eFormatVectorOfSInt64, '\0', "int64_t[]"},
62061da546Spatrick {eFormatVectorOfUInt64, '\0', "uint64_t[]"},
63061da546Spatrick {eFormatVectorOfFloat16, '\0', "float16[]"},
64061da546Spatrick {eFormatVectorOfFloat32, '\0', "float32[]"},
65061da546Spatrick {eFormatVectorOfFloat64, '\0', "float64[]"},
66061da546Spatrick {eFormatVectorOfUInt128, '\0', "uint128_t[]"},
67061da546Spatrick {eFormatComplexInteger, 'I', "complex integer"},
68061da546Spatrick {eFormatCharArray, 'a', "character array"},
69061da546Spatrick {eFormatAddressInfo, 'A', "address"},
70061da546Spatrick {eFormatHexFloat, '\0', "hex float"},
71061da546Spatrick {eFormatInstruction, 'i', "instruction"},
72061da546Spatrick {eFormatVoid, 'v', "void"},
73061da546Spatrick {eFormatUnicode8, 'u', "unicode8"},
74061da546Spatrick };
75061da546Spatrick
76061da546Spatrick static_assert((sizeof(g_format_infos) / sizeof(g_format_infos[0])) ==
77061da546Spatrick kNumFormats,
78061da546Spatrick "All formats must have a corresponding info entry.");
79061da546Spatrick
80*f6aab3d8Srobert static uint32_t g_num_format_infos = std::size(g_format_infos);
81061da546Spatrick
GetFormatFromFormatChar(char format_char,Format & format)82061da546Spatrick static bool GetFormatFromFormatChar(char format_char, Format &format) {
83061da546Spatrick for (uint32_t i = 0; i < g_num_format_infos; ++i) {
84061da546Spatrick if (g_format_infos[i].format_char == format_char) {
85061da546Spatrick format = g_format_infos[i].format;
86061da546Spatrick return true;
87061da546Spatrick }
88061da546Spatrick }
89061da546Spatrick format = eFormatInvalid;
90061da546Spatrick return false;
91061da546Spatrick }
92061da546Spatrick
GetFormatFromFormatName(llvm::StringRef format_name,bool partial_match_ok,Format & format)93*f6aab3d8Srobert static bool GetFormatFromFormatName(llvm::StringRef format_name,
94061da546Spatrick bool partial_match_ok, Format &format) {
95061da546Spatrick uint32_t i;
96061da546Spatrick for (i = 0; i < g_num_format_infos; ++i) {
97*f6aab3d8Srobert if (format_name.equals_insensitive(g_format_infos[i].format_name)) {
98061da546Spatrick format = g_format_infos[i].format;
99061da546Spatrick return true;
100061da546Spatrick }
101061da546Spatrick }
102061da546Spatrick
103061da546Spatrick if (partial_match_ok) {
104061da546Spatrick for (i = 0; i < g_num_format_infos; ++i) {
105*f6aab3d8Srobert if (llvm::StringRef(g_format_infos[i].format_name)
106*f6aab3d8Srobert .startswith_insensitive(format_name)) {
107061da546Spatrick format = g_format_infos[i].format;
108061da546Spatrick return true;
109061da546Spatrick }
110061da546Spatrick }
111061da546Spatrick }
112061da546Spatrick format = eFormatInvalid;
113061da546Spatrick return false;
114061da546Spatrick }
115061da546Spatrick
Changed()116061da546Spatrick void FormatManager::Changed() {
117061da546Spatrick ++m_last_revision;
118061da546Spatrick m_format_cache.Clear();
119061da546Spatrick std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
120061da546Spatrick for (auto &iter : m_language_categories_map) {
121061da546Spatrick if (iter.second)
122061da546Spatrick iter.second->GetFormatCache().Clear();
123061da546Spatrick }
124061da546Spatrick }
125061da546Spatrick
GetFormatFromCString(const char * format_cstr,bool partial_match_ok,lldb::Format & format)126061da546Spatrick bool FormatManager::GetFormatFromCString(const char *format_cstr,
127061da546Spatrick bool partial_match_ok,
128061da546Spatrick lldb::Format &format) {
129061da546Spatrick bool success = false;
130061da546Spatrick if (format_cstr && format_cstr[0]) {
131061da546Spatrick if (format_cstr[1] == '\0') {
132061da546Spatrick success = GetFormatFromFormatChar(format_cstr[0], format);
133061da546Spatrick if (success)
134061da546Spatrick return true;
135061da546Spatrick }
136061da546Spatrick
137061da546Spatrick success = GetFormatFromFormatName(format_cstr, partial_match_ok, format);
138061da546Spatrick }
139061da546Spatrick if (!success)
140061da546Spatrick format = eFormatInvalid;
141061da546Spatrick return success;
142061da546Spatrick }
143061da546Spatrick
GetFormatAsFormatChar(lldb::Format format)144061da546Spatrick char FormatManager::GetFormatAsFormatChar(lldb::Format format) {
145061da546Spatrick for (uint32_t i = 0; i < g_num_format_infos; ++i) {
146061da546Spatrick if (g_format_infos[i].format == format)
147061da546Spatrick return g_format_infos[i].format_char;
148061da546Spatrick }
149061da546Spatrick return '\0';
150061da546Spatrick }
151061da546Spatrick
GetFormatAsCString(Format format)152061da546Spatrick const char *FormatManager::GetFormatAsCString(Format format) {
153061da546Spatrick if (format >= eFormatDefault && format < kNumFormats)
154061da546Spatrick return g_format_infos[format].format_name;
155061da546Spatrick return nullptr;
156061da546Spatrick }
157061da546Spatrick
EnableAllCategories()158061da546Spatrick void FormatManager::EnableAllCategories() {
159061da546Spatrick m_categories_map.EnableAllCategories();
160061da546Spatrick std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
161061da546Spatrick for (auto &iter : m_language_categories_map) {
162061da546Spatrick if (iter.second)
163061da546Spatrick iter.second->Enable();
164061da546Spatrick }
165061da546Spatrick }
166061da546Spatrick
DisableAllCategories()167061da546Spatrick void FormatManager::DisableAllCategories() {
168061da546Spatrick m_categories_map.DisableAllCategories();
169061da546Spatrick std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
170061da546Spatrick for (auto &iter : m_language_categories_map) {
171061da546Spatrick if (iter.second)
172061da546Spatrick iter.second->Disable();
173061da546Spatrick }
174061da546Spatrick }
175061da546Spatrick
GetPossibleMatches(ValueObject & valobj,CompilerType compiler_type,lldb::DynamicValueType use_dynamic,FormattersMatchVector & entries,FormattersMatchCandidate::Flags current_flags,bool root_level)176061da546Spatrick void FormatManager::GetPossibleMatches(
177dda28197Spatrick ValueObject &valobj, CompilerType compiler_type,
178061da546Spatrick lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
179*f6aab3d8Srobert FormattersMatchCandidate::Flags current_flags, bool root_level) {
180061da546Spatrick compiler_type = compiler_type.GetTypeForFormatters();
181dda28197Spatrick ConstString type_name(compiler_type.GetTypeName());
182*f6aab3d8Srobert ScriptInterpreter *script_interpreter =
183*f6aab3d8Srobert valobj.GetTargetSP()->GetDebugger().GetScriptInterpreter();
184061da546Spatrick if (valobj.GetBitfieldBitSize() > 0) {
185061da546Spatrick StreamString sstring;
186061da546Spatrick sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
187061da546Spatrick ConstString bitfieldname(sstring.GetString());
188*f6aab3d8Srobert entries.push_back({bitfieldname, script_interpreter,
189*f6aab3d8Srobert TypeImpl(compiler_type), current_flags});
190061da546Spatrick }
191061da546Spatrick
192061da546Spatrick if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
193*f6aab3d8Srobert entries.push_back({type_name, script_interpreter, TypeImpl(compiler_type),
194*f6aab3d8Srobert current_flags});
195061da546Spatrick
196dda28197Spatrick ConstString display_type_name(compiler_type.GetTypeName());
197061da546Spatrick if (display_type_name != type_name)
198*f6aab3d8Srobert entries.push_back({display_type_name, script_interpreter,
199*f6aab3d8Srobert TypeImpl(compiler_type), current_flags});
200061da546Spatrick }
201061da546Spatrick
202061da546Spatrick for (bool is_rvalue_ref = true, j = true;
203061da546Spatrick j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
204061da546Spatrick CompilerType non_ref_type = compiler_type.GetNonReferenceType();
205*f6aab3d8Srobert GetPossibleMatches(valobj, non_ref_type, use_dynamic, entries,
206*f6aab3d8Srobert current_flags.WithStrippedReference());
207061da546Spatrick if (non_ref_type.IsTypedefType()) {
208061da546Spatrick CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
209061da546Spatrick deffed_referenced_type =
210061da546Spatrick is_rvalue_ref ? deffed_referenced_type.GetRValueReferenceType()
211061da546Spatrick : deffed_referenced_type.GetLValueReferenceType();
212*f6aab3d8Srobert // this is not exactly the usual meaning of stripping typedefs
213061da546Spatrick GetPossibleMatches(
214061da546Spatrick valobj, deffed_referenced_type,
215*f6aab3d8Srobert use_dynamic, entries, current_flags.WithStrippedTypedef());
216061da546Spatrick }
217061da546Spatrick }
218061da546Spatrick
219061da546Spatrick if (compiler_type.IsPointerType()) {
220061da546Spatrick CompilerType non_ptr_type = compiler_type.GetPointeeType();
221*f6aab3d8Srobert GetPossibleMatches(valobj, non_ptr_type, use_dynamic, entries,
222*f6aab3d8Srobert current_flags.WithStrippedPointer());
223061da546Spatrick if (non_ptr_type.IsTypedefType()) {
224061da546Spatrick CompilerType deffed_pointed_type =
225061da546Spatrick non_ptr_type.GetTypedefedType().GetPointerType();
226*f6aab3d8Srobert // this is not exactly the usual meaning of stripping typedefs
227*f6aab3d8Srobert GetPossibleMatches(valobj, deffed_pointed_type, use_dynamic, entries,
228*f6aab3d8Srobert current_flags.WithStrippedTypedef());
229061da546Spatrick }
230061da546Spatrick }
231061da546Spatrick
232061da546Spatrick // For arrays with typedef-ed elements, we add a candidate with the typedef
233061da546Spatrick // stripped.
234061da546Spatrick uint64_t array_size;
235061da546Spatrick if (compiler_type.IsArrayType(nullptr, &array_size, nullptr)) {
236be691f3bSpatrick ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
237be691f3bSpatrick CompilerType element_type = compiler_type.GetArrayElementType(
238be691f3bSpatrick exe_ctx.GetBestExecutionContextScope());
239061da546Spatrick if (element_type.IsTypedefType()) {
240061da546Spatrick // Get the stripped element type and compute the stripped array type
241061da546Spatrick // from it.
242061da546Spatrick CompilerType deffed_array_type =
243061da546Spatrick element_type.GetTypedefedType().GetArrayType(array_size);
244*f6aab3d8Srobert // this is not exactly the usual meaning of stripping typedefs
245061da546Spatrick GetPossibleMatches(
246061da546Spatrick valobj, deffed_array_type,
247*f6aab3d8Srobert use_dynamic, entries, current_flags.WithStrippedTypedef());
248061da546Spatrick }
249061da546Spatrick }
250061da546Spatrick
251061da546Spatrick for (lldb::LanguageType language_type :
252061da546Spatrick GetCandidateLanguages(valobj.GetObjectRuntimeLanguage())) {
253061da546Spatrick if (Language *language = Language::FindPlugin(language_type)) {
254*f6aab3d8Srobert for (const FormattersMatchCandidate& candidate :
255061da546Spatrick language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
256*f6aab3d8Srobert entries.push_back(candidate);
257061da546Spatrick }
258061da546Spatrick }
259061da546Spatrick }
260061da546Spatrick
261061da546Spatrick // try to strip typedef chains
262061da546Spatrick if (compiler_type.IsTypedefType()) {
263061da546Spatrick CompilerType deffed_type = compiler_type.GetTypedefedType();
264*f6aab3d8Srobert GetPossibleMatches(valobj, deffed_type, use_dynamic, entries,
265*f6aab3d8Srobert current_flags.WithStrippedTypedef());
266061da546Spatrick }
267061da546Spatrick
268061da546Spatrick if (root_level) {
269061da546Spatrick do {
270061da546Spatrick if (!compiler_type.IsValid())
271061da546Spatrick break;
272061da546Spatrick
273061da546Spatrick CompilerType unqual_compiler_ast_type =
274061da546Spatrick compiler_type.GetFullyUnqualifiedType();
275061da546Spatrick if (!unqual_compiler_ast_type.IsValid())
276061da546Spatrick break;
277061da546Spatrick if (unqual_compiler_ast_type.GetOpaqueQualType() !=
278061da546Spatrick compiler_type.GetOpaqueQualType())
279*f6aab3d8Srobert GetPossibleMatches(valobj, unqual_compiler_ast_type, use_dynamic,
280*f6aab3d8Srobert entries, current_flags);
281061da546Spatrick } while (false);
282061da546Spatrick
283061da546Spatrick // if all else fails, go to static type
284061da546Spatrick if (valobj.IsDynamic()) {
285061da546Spatrick lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
286061da546Spatrick if (static_value_sp)
287*f6aab3d8Srobert GetPossibleMatches(*static_value_sp.get(),
288*f6aab3d8Srobert static_value_sp->GetCompilerType(), use_dynamic,
289*f6aab3d8Srobert entries, current_flags, true);
290061da546Spatrick }
291061da546Spatrick }
292061da546Spatrick }
293061da546Spatrick
294061da546Spatrick lldb::TypeFormatImplSP
GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp)295061da546Spatrick FormatManager::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
296061da546Spatrick if (!type_sp)
297061da546Spatrick return lldb::TypeFormatImplSP();
298061da546Spatrick lldb::TypeFormatImplSP format_chosen_sp;
299061da546Spatrick uint32_t num_categories = m_categories_map.GetCount();
300061da546Spatrick lldb::TypeCategoryImplSP category_sp;
301061da546Spatrick uint32_t prio_category = UINT32_MAX;
302061da546Spatrick for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
303061da546Spatrick category_sp = GetCategoryAtIndex(category_id);
304061da546Spatrick if (!category_sp->IsEnabled())
305061da546Spatrick continue;
306061da546Spatrick lldb::TypeFormatImplSP format_current_sp =
307061da546Spatrick category_sp->GetFormatForType(type_sp);
308061da546Spatrick if (format_current_sp &&
309061da546Spatrick (format_chosen_sp.get() == nullptr ||
310061da546Spatrick (prio_category > category_sp->GetEnabledPosition()))) {
311061da546Spatrick prio_category = category_sp->GetEnabledPosition();
312061da546Spatrick format_chosen_sp = format_current_sp;
313061da546Spatrick }
314061da546Spatrick }
315061da546Spatrick return format_chosen_sp;
316061da546Spatrick }
317061da546Spatrick
318061da546Spatrick lldb::TypeSummaryImplSP
GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp)319061da546Spatrick FormatManager::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
320061da546Spatrick if (!type_sp)
321061da546Spatrick return lldb::TypeSummaryImplSP();
322061da546Spatrick lldb::TypeSummaryImplSP summary_chosen_sp;
323061da546Spatrick uint32_t num_categories = m_categories_map.GetCount();
324061da546Spatrick lldb::TypeCategoryImplSP category_sp;
325061da546Spatrick uint32_t prio_category = UINT32_MAX;
326061da546Spatrick for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
327061da546Spatrick category_sp = GetCategoryAtIndex(category_id);
328061da546Spatrick if (!category_sp->IsEnabled())
329061da546Spatrick continue;
330061da546Spatrick lldb::TypeSummaryImplSP summary_current_sp =
331061da546Spatrick category_sp->GetSummaryForType(type_sp);
332061da546Spatrick if (summary_current_sp &&
333061da546Spatrick (summary_chosen_sp.get() == nullptr ||
334061da546Spatrick (prio_category > category_sp->GetEnabledPosition()))) {
335061da546Spatrick prio_category = category_sp->GetEnabledPosition();
336061da546Spatrick summary_chosen_sp = summary_current_sp;
337061da546Spatrick }
338061da546Spatrick }
339061da546Spatrick return summary_chosen_sp;
340061da546Spatrick }
341061da546Spatrick
342061da546Spatrick lldb::TypeFilterImplSP
GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp)343061da546Spatrick FormatManager::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
344061da546Spatrick if (!type_sp)
345061da546Spatrick return lldb::TypeFilterImplSP();
346061da546Spatrick lldb::TypeFilterImplSP filter_chosen_sp;
347061da546Spatrick uint32_t num_categories = m_categories_map.GetCount();
348061da546Spatrick lldb::TypeCategoryImplSP category_sp;
349061da546Spatrick uint32_t prio_category = UINT32_MAX;
350061da546Spatrick for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
351061da546Spatrick category_sp = GetCategoryAtIndex(category_id);
352061da546Spatrick if (!category_sp->IsEnabled())
353061da546Spatrick continue;
354061da546Spatrick lldb::TypeFilterImplSP filter_current_sp(
355061da546Spatrick (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
356061da546Spatrick if (filter_current_sp &&
357061da546Spatrick (filter_chosen_sp.get() == nullptr ||
358061da546Spatrick (prio_category > category_sp->GetEnabledPosition()))) {
359061da546Spatrick prio_category = category_sp->GetEnabledPosition();
360061da546Spatrick filter_chosen_sp = filter_current_sp;
361061da546Spatrick }
362061da546Spatrick }
363061da546Spatrick return filter_chosen_sp;
364061da546Spatrick }
365061da546Spatrick
366061da546Spatrick lldb::ScriptedSyntheticChildrenSP
GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp)367061da546Spatrick FormatManager::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
368061da546Spatrick if (!type_sp)
369061da546Spatrick return lldb::ScriptedSyntheticChildrenSP();
370061da546Spatrick lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
371061da546Spatrick uint32_t num_categories = m_categories_map.GetCount();
372061da546Spatrick lldb::TypeCategoryImplSP category_sp;
373061da546Spatrick uint32_t prio_category = UINT32_MAX;
374061da546Spatrick for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
375061da546Spatrick category_sp = GetCategoryAtIndex(category_id);
376061da546Spatrick if (!category_sp->IsEnabled())
377061da546Spatrick continue;
378061da546Spatrick lldb::ScriptedSyntheticChildrenSP synth_current_sp(
379061da546Spatrick (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
380061da546Spatrick .get());
381061da546Spatrick if (synth_current_sp &&
382061da546Spatrick (synth_chosen_sp.get() == nullptr ||
383061da546Spatrick (prio_category > category_sp->GetEnabledPosition()))) {
384061da546Spatrick prio_category = category_sp->GetEnabledPosition();
385061da546Spatrick synth_chosen_sp = synth_current_sp;
386061da546Spatrick }
387061da546Spatrick }
388061da546Spatrick return synth_chosen_sp;
389061da546Spatrick }
390061da546Spatrick
ForEachCategory(TypeCategoryMap::ForEachCallback callback)391061da546Spatrick void FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback) {
392061da546Spatrick m_categories_map.ForEach(callback);
393061da546Spatrick std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
394061da546Spatrick for (const auto &entry : m_language_categories_map) {
395061da546Spatrick if (auto category_sp = entry.second->GetCategory()) {
396061da546Spatrick if (!callback(category_sp))
397061da546Spatrick break;
398061da546Spatrick }
399061da546Spatrick }
400061da546Spatrick }
401061da546Spatrick
402061da546Spatrick lldb::TypeCategoryImplSP
GetCategory(ConstString category_name,bool can_create)403061da546Spatrick FormatManager::GetCategory(ConstString category_name, bool can_create) {
404061da546Spatrick if (!category_name)
405061da546Spatrick return GetCategory(m_default_category_name);
406061da546Spatrick lldb::TypeCategoryImplSP category;
407061da546Spatrick if (m_categories_map.Get(category_name, category))
408061da546Spatrick return category;
409061da546Spatrick
410061da546Spatrick if (!can_create)
411061da546Spatrick return lldb::TypeCategoryImplSP();
412061da546Spatrick
413061da546Spatrick m_categories_map.Add(
414061da546Spatrick category_name,
415061da546Spatrick lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
416061da546Spatrick return GetCategory(category_name);
417061da546Spatrick }
418061da546Spatrick
GetSingleItemFormat(lldb::Format vector_format)419061da546Spatrick lldb::Format FormatManager::GetSingleItemFormat(lldb::Format vector_format) {
420061da546Spatrick switch (vector_format) {
421061da546Spatrick case eFormatVectorOfChar:
422061da546Spatrick return eFormatCharArray;
423061da546Spatrick
424061da546Spatrick case eFormatVectorOfSInt8:
425061da546Spatrick case eFormatVectorOfSInt16:
426061da546Spatrick case eFormatVectorOfSInt32:
427061da546Spatrick case eFormatVectorOfSInt64:
428061da546Spatrick return eFormatDecimal;
429061da546Spatrick
430061da546Spatrick case eFormatVectorOfUInt8:
431061da546Spatrick case eFormatVectorOfUInt16:
432061da546Spatrick case eFormatVectorOfUInt32:
433061da546Spatrick case eFormatVectorOfUInt64:
434061da546Spatrick case eFormatVectorOfUInt128:
435061da546Spatrick return eFormatHex;
436061da546Spatrick
437061da546Spatrick case eFormatVectorOfFloat16:
438061da546Spatrick case eFormatVectorOfFloat32:
439061da546Spatrick case eFormatVectorOfFloat64:
440061da546Spatrick return eFormatFloat;
441061da546Spatrick
442061da546Spatrick default:
443061da546Spatrick return lldb::eFormatInvalid;
444061da546Spatrick }
445061da546Spatrick }
446061da546Spatrick
ShouldPrintAsOneLiner(ValueObject & valobj)447061da546Spatrick bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) {
448061da546Spatrick // if settings say no oneline whatsoever
449061da546Spatrick if (valobj.GetTargetSP().get() &&
450061da546Spatrick !valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries())
451061da546Spatrick return false; // then don't oneline
452061da546Spatrick
453061da546Spatrick // if this object has a summary, then ask the summary
454061da546Spatrick if (valobj.GetSummaryFormat().get() != nullptr)
455061da546Spatrick return valobj.GetSummaryFormat()->IsOneLiner();
456061da546Spatrick
457061da546Spatrick // no children, no party
458061da546Spatrick if (valobj.GetNumChildren() == 0)
459061da546Spatrick return false;
460061da546Spatrick
461061da546Spatrick // ask the type if it has any opinion about this eLazyBoolCalculate == no
462061da546Spatrick // opinion; other values should be self explanatory
463061da546Spatrick CompilerType compiler_type(valobj.GetCompilerType());
464061da546Spatrick if (compiler_type.IsValid()) {
465061da546Spatrick switch (compiler_type.ShouldPrintAsOneLiner(&valobj)) {
466061da546Spatrick case eLazyBoolNo:
467061da546Spatrick return false;
468061da546Spatrick case eLazyBoolYes:
469061da546Spatrick return true;
470061da546Spatrick case eLazyBoolCalculate:
471061da546Spatrick break;
472061da546Spatrick }
473061da546Spatrick }
474061da546Spatrick
475061da546Spatrick size_t total_children_name_len = 0;
476061da546Spatrick
477061da546Spatrick for (size_t idx = 0; idx < valobj.GetNumChildren(); idx++) {
478061da546Spatrick bool is_synth_val = false;
479061da546Spatrick ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true));
480061da546Spatrick // something is wrong here - bail out
481061da546Spatrick if (!child_sp)
482061da546Spatrick return false;
483061da546Spatrick
484061da546Spatrick // also ask the child's type if it has any opinion
485061da546Spatrick CompilerType child_compiler_type(child_sp->GetCompilerType());
486061da546Spatrick if (child_compiler_type.IsValid()) {
487061da546Spatrick switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get())) {
488061da546Spatrick case eLazyBoolYes:
489061da546Spatrick // an opinion of yes is only binding for the child, so keep going
490061da546Spatrick case eLazyBoolCalculate:
491061da546Spatrick break;
492061da546Spatrick case eLazyBoolNo:
493061da546Spatrick // but if the child says no, then it's a veto on the whole thing
494061da546Spatrick return false;
495061da546Spatrick }
496061da546Spatrick }
497061da546Spatrick
498061da546Spatrick // if we decided to define synthetic children for a type, we probably care
499061da546Spatrick // enough to show them, but avoid nesting children in children
500061da546Spatrick if (child_sp->GetSyntheticChildren().get() != nullptr) {
501061da546Spatrick ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
502061da546Spatrick // wait.. wat? just get out of here..
503061da546Spatrick if (!synth_sp)
504061da546Spatrick return false;
505061da546Spatrick // but if we only have them to provide a value, keep going
506061da546Spatrick if (!synth_sp->MightHaveChildren() &&
507061da546Spatrick synth_sp->DoesProvideSyntheticValue())
508061da546Spatrick is_synth_val = true;
509061da546Spatrick else
510061da546Spatrick return false;
511061da546Spatrick }
512061da546Spatrick
513061da546Spatrick total_children_name_len += child_sp->GetName().GetLength();
514061da546Spatrick
515061da546Spatrick // 50 itself is a "randomly" chosen number - the idea is that
516061da546Spatrick // overly long structs should not get this treatment
517061da546Spatrick // FIXME: maybe make this a user-tweakable setting?
518061da546Spatrick if (total_children_name_len > 50)
519061da546Spatrick return false;
520061da546Spatrick
521061da546Spatrick // if a summary is there..
522061da546Spatrick if (child_sp->GetSummaryFormat()) {
523061da546Spatrick // and it wants children, then bail out
524061da546Spatrick if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
525061da546Spatrick return false;
526061da546Spatrick }
527061da546Spatrick
528061da546Spatrick // if this child has children..
529061da546Spatrick if (child_sp->GetNumChildren()) {
530061da546Spatrick // ...and no summary...
531061da546Spatrick // (if it had a summary and the summary wanted children, we would have
532061da546Spatrick // bailed out anyway
533061da546Spatrick // so this only makes us bail out if this has no summary and we would
534061da546Spatrick // then print children)
535061da546Spatrick if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do
536061da546Spatrick // that if not a
537061da546Spatrick // synthetic valued
538061da546Spatrick // child
539061da546Spatrick return false; // then bail out
540061da546Spatrick }
541061da546Spatrick }
542061da546Spatrick return true;
543061da546Spatrick }
544061da546Spatrick
GetTypeForCache(ValueObject & valobj,lldb::DynamicValueType use_dynamic)545061da546Spatrick ConstString FormatManager::GetTypeForCache(ValueObject &valobj,
546061da546Spatrick lldb::DynamicValueType use_dynamic) {
547061da546Spatrick ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(
548061da546Spatrick use_dynamic, valobj.IsSynthetic());
549061da546Spatrick if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) {
550061da546Spatrick if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
551061da546Spatrick return valobj_sp->GetQualifiedTypeName();
552061da546Spatrick }
553061da546Spatrick return ConstString();
554061da546Spatrick }
555061da546Spatrick
556061da546Spatrick std::vector<lldb::LanguageType>
GetCandidateLanguages(lldb::LanguageType lang_type)557061da546Spatrick FormatManager::GetCandidateLanguages(lldb::LanguageType lang_type) {
558061da546Spatrick switch (lang_type) {
559061da546Spatrick case lldb::eLanguageTypeC:
560061da546Spatrick case lldb::eLanguageTypeC89:
561061da546Spatrick case lldb::eLanguageTypeC99:
562061da546Spatrick case lldb::eLanguageTypeC11:
563061da546Spatrick case lldb::eLanguageTypeC_plus_plus:
564061da546Spatrick case lldb::eLanguageTypeC_plus_plus_03:
565061da546Spatrick case lldb::eLanguageTypeC_plus_plus_11:
566061da546Spatrick case lldb::eLanguageTypeC_plus_plus_14:
567061da546Spatrick return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
568061da546Spatrick default:
569061da546Spatrick return {lang_type};
570061da546Spatrick }
571061da546Spatrick llvm_unreachable("Fully covered switch");
572061da546Spatrick }
573061da546Spatrick
574061da546Spatrick LanguageCategory *
GetCategoryForLanguage(lldb::LanguageType lang_type)575061da546Spatrick FormatManager::GetCategoryForLanguage(lldb::LanguageType lang_type) {
576061da546Spatrick std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
577061da546Spatrick auto iter = m_language_categories_map.find(lang_type),
578061da546Spatrick end = m_language_categories_map.end();
579061da546Spatrick if (iter != end)
580061da546Spatrick return iter->second.get();
581061da546Spatrick LanguageCategory *lang_category = new LanguageCategory(lang_type);
582061da546Spatrick m_language_categories_map[lang_type] =
583061da546Spatrick LanguageCategory::UniquePointer(lang_category);
584061da546Spatrick return lang_category;
585061da546Spatrick }
586061da546Spatrick
587061da546Spatrick template <typename ImplSP>
GetHardcoded(FormattersMatchData & match_data)588061da546Spatrick ImplSP FormatManager::GetHardcoded(FormattersMatchData &match_data) {
589061da546Spatrick ImplSP retval_sp;
590061da546Spatrick for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
591061da546Spatrick if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
592061da546Spatrick if (lang_category->GetHardcoded(*this, match_data, retval_sp))
593061da546Spatrick return retval_sp;
594061da546Spatrick }
595061da546Spatrick }
596061da546Spatrick return retval_sp;
597061da546Spatrick }
598061da546Spatrick
599061da546Spatrick template <typename ImplSP>
Get(ValueObject & valobj,lldb::DynamicValueType use_dynamic)600061da546Spatrick ImplSP FormatManager::Get(ValueObject &valobj,
601061da546Spatrick lldb::DynamicValueType use_dynamic) {
602061da546Spatrick FormattersMatchData match_data(valobj, use_dynamic);
603061da546Spatrick if (ImplSP retval_sp = GetCached<ImplSP>(match_data))
604061da546Spatrick return retval_sp;
605061da546Spatrick
606*f6aab3d8Srobert Log *log = GetLog(LLDBLog::DataFormatters);
607061da546Spatrick
608061da546Spatrick LLDB_LOGF(log, "[%s] Search failed. Giving language a chance.", __FUNCTION__);
609061da546Spatrick for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
610061da546Spatrick if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
611061da546Spatrick ImplSP retval_sp;
612061da546Spatrick if (lang_category->Get(match_data, retval_sp))
613061da546Spatrick if (retval_sp) {
614061da546Spatrick LLDB_LOGF(log, "[%s] Language search success. Returning.",
615061da546Spatrick __FUNCTION__);
616061da546Spatrick return retval_sp;
617061da546Spatrick }
618061da546Spatrick }
619061da546Spatrick }
620061da546Spatrick
621061da546Spatrick LLDB_LOGF(log, "[%s] Search failed. Giving hardcoded a chance.",
622061da546Spatrick __FUNCTION__);
623061da546Spatrick return GetHardcoded<ImplSP>(match_data);
624061da546Spatrick }
625061da546Spatrick
626061da546Spatrick template <typename ImplSP>
GetCached(FormattersMatchData & match_data)627061da546Spatrick ImplSP FormatManager::GetCached(FormattersMatchData &match_data) {
628061da546Spatrick ImplSP retval_sp;
629*f6aab3d8Srobert Log *log = GetLog(LLDBLog::DataFormatters);
630061da546Spatrick if (match_data.GetTypeForCache()) {
631061da546Spatrick LLDB_LOGF(log, "\n\n[%s] Looking into cache for type %s", __FUNCTION__,
632061da546Spatrick match_data.GetTypeForCache().AsCString("<invalid>"));
633061da546Spatrick if (m_format_cache.Get(match_data.GetTypeForCache(), retval_sp)) {
634061da546Spatrick if (log) {
635061da546Spatrick LLDB_LOGF(log, "[%s] Cache search success. Returning.", __FUNCTION__);
636061da546Spatrick LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
637061da546Spatrick m_format_cache.GetCacheHits(),
638061da546Spatrick m_format_cache.GetCacheMisses());
639061da546Spatrick }
640061da546Spatrick return retval_sp;
641061da546Spatrick }
642061da546Spatrick LLDB_LOGF(log, "[%s] Cache search failed. Going normal route",
643061da546Spatrick __FUNCTION__);
644061da546Spatrick }
645061da546Spatrick
646061da546Spatrick m_categories_map.Get(match_data, retval_sp);
647061da546Spatrick if (match_data.GetTypeForCache() && (!retval_sp || !retval_sp->NonCacheable())) {
648061da546Spatrick LLDB_LOGF(log, "[%s] Caching %p for type %s", __FUNCTION__,
649061da546Spatrick static_cast<void *>(retval_sp.get()),
650061da546Spatrick match_data.GetTypeForCache().AsCString("<invalid>"));
651061da546Spatrick m_format_cache.Set(match_data.GetTypeForCache(), retval_sp);
652061da546Spatrick }
653061da546Spatrick LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
654061da546Spatrick m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
655061da546Spatrick return retval_sp;
656061da546Spatrick }
657061da546Spatrick
658061da546Spatrick lldb::TypeFormatImplSP
GetFormat(ValueObject & valobj,lldb::DynamicValueType use_dynamic)659061da546Spatrick FormatManager::GetFormat(ValueObject &valobj,
660061da546Spatrick lldb::DynamicValueType use_dynamic) {
661061da546Spatrick return Get<lldb::TypeFormatImplSP>(valobj, use_dynamic);
662061da546Spatrick }
663061da546Spatrick
664061da546Spatrick lldb::TypeSummaryImplSP
GetSummaryFormat(ValueObject & valobj,lldb::DynamicValueType use_dynamic)665061da546Spatrick FormatManager::GetSummaryFormat(ValueObject &valobj,
666061da546Spatrick lldb::DynamicValueType use_dynamic) {
667061da546Spatrick return Get<lldb::TypeSummaryImplSP>(valobj, use_dynamic);
668061da546Spatrick }
669061da546Spatrick
670061da546Spatrick lldb::SyntheticChildrenSP
GetSyntheticChildren(ValueObject & valobj,lldb::DynamicValueType use_dynamic)671061da546Spatrick FormatManager::GetSyntheticChildren(ValueObject &valobj,
672061da546Spatrick lldb::DynamicValueType use_dynamic) {
673061da546Spatrick return Get<lldb::SyntheticChildrenSP>(valobj, use_dynamic);
674061da546Spatrick }
675061da546Spatrick
FormatManager()676061da546Spatrick FormatManager::FormatManager()
677061da546Spatrick : m_last_revision(0), m_format_cache(), m_language_categories_mutex(),
678061da546Spatrick m_language_categories_map(), m_named_summaries_map(this),
679061da546Spatrick m_categories_map(this), m_default_category_name(ConstString("default")),
680061da546Spatrick m_system_category_name(ConstString("system")),
681061da546Spatrick m_vectortypes_category_name(ConstString("VectorTypes")) {
682061da546Spatrick LoadSystemFormatters();
683061da546Spatrick LoadVectorFormatters();
684061da546Spatrick
685061da546Spatrick EnableCategory(m_vectortypes_category_name, TypeCategoryMap::Last,
686061da546Spatrick lldb::eLanguageTypeObjC_plus_plus);
687061da546Spatrick EnableCategory(m_system_category_name, TypeCategoryMap::Last,
688061da546Spatrick lldb::eLanguageTypeObjC_plus_plus);
689061da546Spatrick }
690061da546Spatrick
LoadSystemFormatters()691061da546Spatrick void FormatManager::LoadSystemFormatters() {
692061da546Spatrick TypeSummaryImpl::Flags string_flags;
693061da546Spatrick string_flags.SetCascades(true)
694061da546Spatrick .SetSkipPointers(true)
695061da546Spatrick .SetSkipReferences(false)
696061da546Spatrick .SetDontShowChildren(true)
697061da546Spatrick .SetDontShowValue(false)
698061da546Spatrick .SetShowMembersOneLiner(false)
699061da546Spatrick .SetHideItemNames(false);
700061da546Spatrick
701061da546Spatrick TypeSummaryImpl::Flags string_array_flags;
702061da546Spatrick string_array_flags.SetCascades(true)
703061da546Spatrick .SetSkipPointers(true)
704061da546Spatrick .SetSkipReferences(false)
705061da546Spatrick .SetDontShowChildren(true)
706061da546Spatrick .SetDontShowValue(true)
707061da546Spatrick .SetShowMembersOneLiner(false)
708061da546Spatrick .SetHideItemNames(false);
709061da546Spatrick
710061da546Spatrick lldb::TypeSummaryImplSP string_format(
711061da546Spatrick new StringSummaryFormat(string_flags, "${var%s}"));
712061da546Spatrick
713061da546Spatrick lldb::TypeSummaryImplSP string_array_format(
714*f6aab3d8Srobert new StringSummaryFormat(string_array_flags, "${var%char[]}"));
715061da546Spatrick
716061da546Spatrick TypeCategoryImpl::SharedPointer sys_category_sp =
717061da546Spatrick GetCategory(m_system_category_name);
718061da546Spatrick
719*f6aab3d8Srobert sys_category_sp->AddTypeSummary(R"(^(unsigned )?char ?(\*|\[\])$)",
720*f6aab3d8Srobert eFormatterMatchRegex, string_format);
721*f6aab3d8Srobert
722*f6aab3d8Srobert sys_category_sp->AddTypeSummary(R"(^((un)?signed )?char ?\[[0-9]+\]$)",
723*f6aab3d8Srobert eFormatterMatchRegex, string_array_format);
724061da546Spatrick
725061da546Spatrick lldb::TypeSummaryImplSP ostype_summary(
726061da546Spatrick new StringSummaryFormat(TypeSummaryImpl::Flags()
727061da546Spatrick .SetCascades(false)
728061da546Spatrick .SetSkipPointers(true)
729061da546Spatrick .SetSkipReferences(true)
730061da546Spatrick .SetDontShowChildren(true)
731061da546Spatrick .SetDontShowValue(false)
732061da546Spatrick .SetShowMembersOneLiner(false)
733061da546Spatrick .SetHideItemNames(false),
734061da546Spatrick "${var%O}"));
735061da546Spatrick
736*f6aab3d8Srobert sys_category_sp->AddTypeSummary("OSType", eFormatterMatchExact,
737061da546Spatrick ostype_summary);
738061da546Spatrick
739061da546Spatrick TypeFormatImpl::Flags fourchar_flags;
740061da546Spatrick fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(
741061da546Spatrick true);
742061da546Spatrick
743061da546Spatrick AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"),
744061da546Spatrick fourchar_flags);
745061da546Spatrick }
746061da546Spatrick
LoadVectorFormatters()747061da546Spatrick void FormatManager::LoadVectorFormatters() {
748061da546Spatrick TypeCategoryImpl::SharedPointer vectors_category_sp =
749061da546Spatrick GetCategory(m_vectortypes_category_name);
750061da546Spatrick
751061da546Spatrick TypeSummaryImpl::Flags vector_flags;
752061da546Spatrick vector_flags.SetCascades(true)
753061da546Spatrick .SetSkipPointers(true)
754061da546Spatrick .SetSkipReferences(false)
755061da546Spatrick .SetDontShowChildren(true)
756061da546Spatrick .SetDontShowValue(false)
757061da546Spatrick .SetShowMembersOneLiner(true)
758061da546Spatrick .SetHideItemNames(true);
759061da546Spatrick
760061da546Spatrick AddStringSummary(vectors_category_sp, "${var.uint128}",
761061da546Spatrick ConstString("builtin_type_vec128"), vector_flags);
762061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("float[4]"),
763061da546Spatrick vector_flags);
764061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("int32_t[4]"),
765061da546Spatrick vector_flags);
766061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("int16_t[8]"),
767061da546Spatrick vector_flags);
768061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vDouble"),
769061da546Spatrick vector_flags);
770061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vFloat"),
771061da546Spatrick vector_flags);
772061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vSInt8"),
773061da546Spatrick vector_flags);
774061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vSInt16"),
775061da546Spatrick vector_flags);
776061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vSInt32"),
777061da546Spatrick vector_flags);
778061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
779061da546Spatrick vector_flags);
780061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vUInt8"),
781061da546Spatrick vector_flags);
782061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
783061da546Spatrick vector_flags);
784061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vUInt32"),
785061da546Spatrick vector_flags);
786061da546Spatrick AddStringSummary(vectors_category_sp, "", ConstString("vBool32"),
787061da546Spatrick vector_flags);
788061da546Spatrick }
789