LLDB  mainline
FormatManager.cpp
Go to the documentation of this file.
1 //===-- FormatManager.cpp -------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 
11 #include "lldb/Core/Debugger.h"
15 #include "lldb/Target/Language.h"
16 #include "lldb/Utility/LLDBLog.h"
17 #include "lldb/Utility/Log.h"
18 #include "llvm/ADT/STLExtras.h"
19 
20 using namespace lldb;
21 using namespace lldb_private;
22 using namespace lldb_private::formatters;
23 
24 struct FormatInfo {
26  const char format_char; // One or more format characters that can be used for
27  // this format.
28  const char *format_name; // Long format name that can be used to specify the
29  // current format
30 };
31 
32 static constexpr FormatInfo g_format_infos[] = {
33  {eFormatDefault, '\0', "default"},
34  {eFormatBoolean, 'B', "boolean"},
35  {eFormatBinary, 'b', "binary"},
36  {eFormatBytes, 'y', "bytes"},
37  {eFormatBytesWithASCII, 'Y', "bytes with ASCII"},
38  {eFormatChar, 'c', "character"},
39  {eFormatCharPrintable, 'C', "printable character"},
40  {eFormatComplexFloat, 'F', "complex float"},
41  {eFormatCString, 's', "c-string"},
42  {eFormatDecimal, 'd', "decimal"},
43  {eFormatEnum, 'E', "enumeration"},
44  {eFormatHex, 'x', "hex"},
45  {eFormatHexUppercase, 'X', "uppercase hex"},
46  {eFormatFloat, 'f', "float"},
47  {eFormatOctal, 'o', "octal"},
48  {eFormatOSType, 'O', "OSType"},
49  {eFormatUnicode16, 'U', "unicode16"},
50  {eFormatUnicode32, '\0', "unicode32"},
51  {eFormatUnsigned, 'u', "unsigned decimal"},
52  {eFormatPointer, 'p', "pointer"},
53  {eFormatVectorOfChar, '\0', "char[]"},
54  {eFormatVectorOfSInt8, '\0', "int8_t[]"},
55  {eFormatVectorOfUInt8, '\0', "uint8_t[]"},
56  {eFormatVectorOfSInt16, '\0', "int16_t[]"},
57  {eFormatVectorOfUInt16, '\0', "uint16_t[]"},
58  {eFormatVectorOfSInt32, '\0', "int32_t[]"},
59  {eFormatVectorOfUInt32, '\0', "uint32_t[]"},
60  {eFormatVectorOfSInt64, '\0', "int64_t[]"},
61  {eFormatVectorOfUInt64, '\0', "uint64_t[]"},
62  {eFormatVectorOfFloat16, '\0', "float16[]"},
63  {eFormatVectorOfFloat32, '\0', "float32[]"},
64  {eFormatVectorOfFloat64, '\0', "float64[]"},
65  {eFormatVectorOfUInt128, '\0', "uint128_t[]"},
66  {eFormatComplexInteger, 'I', "complex integer"},
67  {eFormatCharArray, 'a', "character array"},
68  {eFormatAddressInfo, 'A', "address"},
69  {eFormatHexFloat, '\0', "hex float"},
70  {eFormatInstruction, 'i', "instruction"},
71  {eFormatVoid, 'v', "void"},
72  {eFormatUnicode8, 'u', "unicode8"},
73 };
74 
75 static_assert((sizeof(g_format_infos) / sizeof(g_format_infos[0])) ==
77  "All formats must have a corresponding info entry.");
78 
79 static uint32_t g_num_format_infos = llvm::array_lengthof(g_format_infos);
80 
81 static bool GetFormatFromFormatChar(char format_char, Format &format) {
82  for (uint32_t i = 0; i < g_num_format_infos; ++i) {
83  if (g_format_infos[i].format_char == format_char) {
84  format = g_format_infos[i].format;
85  return true;
86  }
87  }
88  format = eFormatInvalid;
89  return false;
90 }
91 
92 static bool GetFormatFromFormatName(llvm::StringRef format_name,
93  bool partial_match_ok, Format &format) {
94  uint32_t i;
95  for (i = 0; i < g_num_format_infos; ++i) {
96  if (format_name.equals_insensitive(g_format_infos[i].format_name)) {
97  format = g_format_infos[i].format;
98  return true;
99  }
100  }
101 
102  if (partial_match_ok) {
103  for (i = 0; i < g_num_format_infos; ++i) {
104  if (llvm::StringRef(g_format_infos[i].format_name)
105  .startswith_insensitive(format_name)) {
106  format = g_format_infos[i].format;
107  return true;
108  }
109  }
110  }
111  format = eFormatInvalid;
112  return false;
113 }
114 
115 void FormatManager::Changed() {
116  ++m_last_revision;
117  m_format_cache.Clear();
118  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
119  for (auto &iter : m_language_categories_map) {
120  if (iter.second)
121  iter.second->GetFormatCache().Clear();
122  }
123 }
124 
125 bool FormatManager::GetFormatFromCString(const char *format_cstr,
126  bool partial_match_ok,
127  lldb::Format &format) {
128  bool success = false;
129  if (format_cstr && format_cstr[0]) {
130  if (format_cstr[1] == '\0') {
131  success = GetFormatFromFormatChar(format_cstr[0], format);
132  if (success)
133  return true;
134  }
135 
136  success = GetFormatFromFormatName(format_cstr, partial_match_ok, format);
137  }
138  if (!success)
139  format = eFormatInvalid;
140  return success;
141 }
142 
143 char FormatManager::GetFormatAsFormatChar(lldb::Format format) {
144  for (uint32_t i = 0; i < g_num_format_infos; ++i) {
145  if (g_format_infos[i].format == format)
146  return g_format_infos[i].format_char;
147  }
148  return '\0';
149 }
150 
151 const char *FormatManager::GetFormatAsCString(Format format) {
152  if (format >= eFormatDefault && format < kNumFormats)
153  return g_format_infos[format].format_name;
154  return nullptr;
155 }
156 
157 void FormatManager::EnableAllCategories() {
158  m_categories_map.EnableAllCategories();
159  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
160  for (auto &iter : m_language_categories_map) {
161  if (iter.second)
162  iter.second->Enable();
163  }
164 }
165 
166 void FormatManager::DisableAllCategories() {
167  m_categories_map.DisableAllCategories();
168  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
169  for (auto &iter : m_language_categories_map) {
170  if (iter.second)
171  iter.second->Disable();
172  }
173 }
174 
175 void FormatManager::GetPossibleMatches(
176  ValueObject &valobj, CompilerType compiler_type,
177  lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
178  FormattersMatchCandidate::Flags current_flags, bool root_level) {
179  compiler_type = compiler_type.GetTypeForFormatters();
180  ConstString type_name(compiler_type.GetTypeName());
181  if (valobj.GetBitfieldBitSize() > 0) {
182  StreamString sstring;
183  sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
184  ConstString bitfieldname(sstring.GetString());
185  entries.push_back({bitfieldname, current_flags});
186  }
187 
188  if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
189  entries.push_back({type_name, current_flags});
190 
191  ConstString display_type_name(compiler_type.GetTypeName());
192  if (display_type_name != type_name)
193  entries.push_back({display_type_name, current_flags});
194  }
195 
196  for (bool is_rvalue_ref = true, j = true;
197  j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
198  CompilerType non_ref_type = compiler_type.GetNonReferenceType();
199  GetPossibleMatches(valobj, non_ref_type, use_dynamic, entries,
200  current_flags.WithStrippedReference());
201  if (non_ref_type.IsTypedefType()) {
202  CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
203  deffed_referenced_type =
204  is_rvalue_ref ? deffed_referenced_type.GetRValueReferenceType()
205  : deffed_referenced_type.GetLValueReferenceType();
206  // this is not exactly the usual meaning of stripping typedefs
207  GetPossibleMatches(
208  valobj, deffed_referenced_type,
209  use_dynamic, entries, current_flags.WithStrippedTypedef());
210  }
211  }
212 
213  if (compiler_type.IsPointerType()) {
214  CompilerType non_ptr_type = compiler_type.GetPointeeType();
215  GetPossibleMatches(valobj, non_ptr_type, use_dynamic, entries,
216  current_flags.WithStrippedPointer());
217  if (non_ptr_type.IsTypedefType()) {
218  CompilerType deffed_pointed_type =
219  non_ptr_type.GetTypedefedType().GetPointerType();
220  // this is not exactly the usual meaning of stripping typedefs
221  GetPossibleMatches(valobj, deffed_pointed_type, use_dynamic, entries,
222  current_flags.WithStrippedTypedef());
223  }
224  }
225 
226  // For arrays with typedef-ed elements, we add a candidate with the typedef
227  // stripped.
228  uint64_t array_size;
229  if (compiler_type.IsArrayType(nullptr, &array_size, nullptr)) {
230  ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
231  CompilerType element_type = compiler_type.GetArrayElementType(
232  exe_ctx.GetBestExecutionContextScope());
233  if (element_type.IsTypedefType()) {
234  // Get the stripped element type and compute the stripped array type
235  // from it.
236  CompilerType deffed_array_type =
237  element_type.GetTypedefedType().GetArrayType(array_size);
238  // this is not exactly the usual meaning of stripping typedefs
239  GetPossibleMatches(
240  valobj, deffed_array_type,
241  use_dynamic, entries, current_flags.WithStrippedTypedef());
242  }
243  }
244 
245  for (lldb::LanguageType language_type :
246  GetCandidateLanguages(valobj.GetObjectRuntimeLanguage())) {
247  if (Language *language = Language::FindPlugin(language_type)) {
248  for (ConstString candidate :
249  language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
250  entries.push_back({candidate, current_flags});
251  }
252  }
253  }
254 
255  // try to strip typedef chains
256  if (compiler_type.IsTypedefType()) {
257  CompilerType deffed_type = compiler_type.GetTypedefedType();
258  GetPossibleMatches(valobj, deffed_type, use_dynamic, entries,
259  current_flags.WithStrippedTypedef());
260  }
261 
262  if (root_level) {
263  do {
264  if (!compiler_type.IsValid())
265  break;
266 
267  CompilerType unqual_compiler_ast_type =
268  compiler_type.GetFullyUnqualifiedType();
269  if (!unqual_compiler_ast_type.IsValid())
270  break;
271  if (unqual_compiler_ast_type.GetOpaqueQualType() !=
272  compiler_type.GetOpaqueQualType())
273  GetPossibleMatches(valobj, unqual_compiler_ast_type, use_dynamic,
274  entries, current_flags);
275  } while (false);
276 
277  // if all else fails, go to static type
278  if (valobj.IsDynamic()) {
279  lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
280  if (static_value_sp)
281  GetPossibleMatches(*static_value_sp.get(),
282  static_value_sp->GetCompilerType(), use_dynamic,
283  entries, current_flags, true);
284  }
285  }
286 }
287 
288 lldb::TypeFormatImplSP
289 FormatManager::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
290  if (!type_sp)
291  return lldb::TypeFormatImplSP();
292  lldb::TypeFormatImplSP format_chosen_sp;
293  uint32_t num_categories = m_categories_map.GetCount();
294  lldb::TypeCategoryImplSP category_sp;
295  uint32_t prio_category = UINT32_MAX;
296  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
297  category_sp = GetCategoryAtIndex(category_id);
298  if (!category_sp->IsEnabled())
299  continue;
300  lldb::TypeFormatImplSP format_current_sp =
301  category_sp->GetFormatForType(type_sp);
302  if (format_current_sp &&
303  (format_chosen_sp.get() == nullptr ||
304  (prio_category > category_sp->GetEnabledPosition()))) {
305  prio_category = category_sp->GetEnabledPosition();
306  format_chosen_sp = format_current_sp;
307  }
308  }
309  return format_chosen_sp;
310 }
311 
312 lldb::TypeSummaryImplSP
313 FormatManager::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
314  if (!type_sp)
315  return lldb::TypeSummaryImplSP();
316  lldb::TypeSummaryImplSP summary_chosen_sp;
317  uint32_t num_categories = m_categories_map.GetCount();
318  lldb::TypeCategoryImplSP category_sp;
319  uint32_t prio_category = UINT32_MAX;
320  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
321  category_sp = GetCategoryAtIndex(category_id);
322  if (!category_sp->IsEnabled())
323  continue;
324  lldb::TypeSummaryImplSP summary_current_sp =
325  category_sp->GetSummaryForType(type_sp);
326  if (summary_current_sp &&
327  (summary_chosen_sp.get() == nullptr ||
328  (prio_category > category_sp->GetEnabledPosition()))) {
329  prio_category = category_sp->GetEnabledPosition();
330  summary_chosen_sp = summary_current_sp;
331  }
332  }
333  return summary_chosen_sp;
334 }
335 
336 lldb::TypeFilterImplSP
337 FormatManager::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
338  if (!type_sp)
339  return lldb::TypeFilterImplSP();
340  lldb::TypeFilterImplSP filter_chosen_sp;
341  uint32_t num_categories = m_categories_map.GetCount();
342  lldb::TypeCategoryImplSP category_sp;
343  uint32_t prio_category = UINT32_MAX;
344  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
345  category_sp = GetCategoryAtIndex(category_id);
346  if (!category_sp->IsEnabled())
347  continue;
348  lldb::TypeFilterImplSP filter_current_sp(
349  (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
350  if (filter_current_sp &&
351  (filter_chosen_sp.get() == nullptr ||
352  (prio_category > category_sp->GetEnabledPosition()))) {
353  prio_category = category_sp->GetEnabledPosition();
354  filter_chosen_sp = filter_current_sp;
355  }
356  }
357  return filter_chosen_sp;
358 }
359 
360 lldb::ScriptedSyntheticChildrenSP
361 FormatManager::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
362  if (!type_sp)
363  return lldb::ScriptedSyntheticChildrenSP();
364  lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
365  uint32_t num_categories = m_categories_map.GetCount();
366  lldb::TypeCategoryImplSP category_sp;
367  uint32_t prio_category = UINT32_MAX;
368  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
369  category_sp = GetCategoryAtIndex(category_id);
370  if (!category_sp->IsEnabled())
371  continue;
372  lldb::ScriptedSyntheticChildrenSP synth_current_sp(
373  (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
374  .get());
375  if (synth_current_sp &&
376  (synth_chosen_sp.get() == nullptr ||
377  (prio_category > category_sp->GetEnabledPosition()))) {
378  prio_category = category_sp->GetEnabledPosition();
379  synth_chosen_sp = synth_current_sp;
380  }
381  }
382  return synth_chosen_sp;
383 }
384 
385 void FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback) {
386  m_categories_map.ForEach(callback);
387  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
388  for (const auto &entry : m_language_categories_map) {
389  if (auto category_sp = entry.second->GetCategory()) {
390  if (!callback(category_sp))
391  break;
392  }
393  }
394 }
395 
396 lldb::TypeCategoryImplSP
397 FormatManager::GetCategory(ConstString category_name, bool can_create) {
398  if (!category_name)
399  return GetCategory(m_default_category_name);
400  lldb::TypeCategoryImplSP category;
401  if (m_categories_map.Get(category_name, category))
402  return category;
403 
404  if (!can_create)
405  return lldb::TypeCategoryImplSP();
406 
407  m_categories_map.Add(
408  category_name,
409  lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
410  return GetCategory(category_name);
411 }
412 
413 lldb::Format FormatManager::GetSingleItemFormat(lldb::Format vector_format) {
414  switch (vector_format) {
415  case eFormatVectorOfChar:
416  return eFormatCharArray;
417 
422  return eFormatDecimal;
423 
429  return eFormatHex;
430 
434  return eFormatFloat;
435 
436  default:
437  return lldb::eFormatInvalid;
438  }
439 }
440 
441 bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) {
442  // if settings say no oneline whatsoever
443  if (valobj.GetTargetSP().get() &&
444  !valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries())
445  return false; // then don't oneline
446 
447  // if this object has a summary, then ask the summary
448  if (valobj.GetSummaryFormat().get() != nullptr)
449  return valobj.GetSummaryFormat()->IsOneLiner();
450 
451  // no children, no party
452  if (valobj.GetNumChildren() == 0)
453  return false;
454 
455  // ask the type if it has any opinion about this eLazyBoolCalculate == no
456  // opinion; other values should be self explanatory
457  CompilerType compiler_type(valobj.GetCompilerType());
458  if (compiler_type.IsValid()) {
459  switch (compiler_type.ShouldPrintAsOneLiner(&valobj)) {
460  case eLazyBoolNo:
461  return false;
462  case eLazyBoolYes:
463  return true;
464  case eLazyBoolCalculate:
465  break;
466  }
467  }
468 
469  size_t total_children_name_len = 0;
470 
471  for (size_t idx = 0; idx < valobj.GetNumChildren(); idx++) {
472  bool is_synth_val = false;
473  ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true));
474  // something is wrong here - bail out
475  if (!child_sp)
476  return false;
477 
478  // also ask the child's type if it has any opinion
479  CompilerType child_compiler_type(child_sp->GetCompilerType());
480  if (child_compiler_type.IsValid()) {
481  switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get())) {
482  case eLazyBoolYes:
483  // an opinion of yes is only binding for the child, so keep going
484  case eLazyBoolCalculate:
485  break;
486  case eLazyBoolNo:
487  // but if the child says no, then it's a veto on the whole thing
488  return false;
489  }
490  }
491 
492  // if we decided to define synthetic children for a type, we probably care
493  // enough to show them, but avoid nesting children in children
494  if (child_sp->GetSyntheticChildren().get() != nullptr) {
495  ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
496  // wait.. wat? just get out of here..
497  if (!synth_sp)
498  return false;
499  // but if we only have them to provide a value, keep going
500  if (!synth_sp->MightHaveChildren() &&
501  synth_sp->DoesProvideSyntheticValue())
502  is_synth_val = true;
503  else
504  return false;
505  }
506 
507  total_children_name_len += child_sp->GetName().GetLength();
508 
509  // 50 itself is a "randomly" chosen number - the idea is that
510  // overly long structs should not get this treatment
511  // FIXME: maybe make this a user-tweakable setting?
512  if (total_children_name_len > 50)
513  return false;
514 
515  // if a summary is there..
516  if (child_sp->GetSummaryFormat()) {
517  // and it wants children, then bail out
518  if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
519  return false;
520  }
521 
522  // if this child has children..
523  if (child_sp->GetNumChildren()) {
524  // ...and no summary...
525  // (if it had a summary and the summary wanted children, we would have
526  // bailed out anyway
527  // so this only makes us bail out if this has no summary and we would
528  // then print children)
529  if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do
530  // that if not a
531  // synthetic valued
532  // child
533  return false; // then bail out
534  }
535  }
536  return true;
537 }
538 
539 ConstString FormatManager::GetTypeForCache(ValueObject &valobj,
540  lldb::DynamicValueType use_dynamic) {
541  ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(
542  use_dynamic, valobj.IsSynthetic());
543  if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) {
544  if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
545  return valobj_sp->GetQualifiedTypeName();
546  }
547  return ConstString();
548 }
549 
550 std::vector<lldb::LanguageType>
551 FormatManager::GetCandidateLanguages(lldb::LanguageType lang_type) {
552  switch (lang_type) {
562  default:
563  return {lang_type};
564  }
565  llvm_unreachable("Fully covered switch");
566 }
567 
569 FormatManager::GetCategoryForLanguage(lldb::LanguageType lang_type) {
570  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
571  auto iter = m_language_categories_map.find(lang_type),
572  end = m_language_categories_map.end();
573  if (iter != end)
574  return iter->second.get();
575  LanguageCategory *lang_category = new LanguageCategory(lang_type);
576  m_language_categories_map[lang_type] =
577  LanguageCategory::UniquePointer(lang_category);
578  return lang_category;
579 }
580 
581 template <typename ImplSP>
582 ImplSP FormatManager::GetHardcoded(FormattersMatchData &match_data) {
583  ImplSP retval_sp;
584  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
585  if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
586  if (lang_category->GetHardcoded(*this, match_data, retval_sp))
587  return retval_sp;
588  }
589  }
590  return retval_sp;
591 }
592 
593 template <typename ImplSP>
594 ImplSP FormatManager::Get(ValueObject &valobj,
595  lldb::DynamicValueType use_dynamic) {
596  FormattersMatchData match_data(valobj, use_dynamic);
597  if (ImplSP retval_sp = GetCached<ImplSP>(match_data))
598  return retval_sp;
599 
600  Log *log = GetLog(LLDBLog::DataFormatters);
601 
602  LLDB_LOGF(log, "[%s] Search failed. Giving language a chance.", __FUNCTION__);
603  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
604  if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
605  ImplSP retval_sp;
606  if (lang_category->Get(match_data, retval_sp))
607  if (retval_sp) {
608  LLDB_LOGF(log, "[%s] Language search success. Returning.",
609  __FUNCTION__);
610  return retval_sp;
611  }
612  }
613  }
614 
615  LLDB_LOGF(log, "[%s] Search failed. Giving hardcoded a chance.",
616  __FUNCTION__);
617  return GetHardcoded<ImplSP>(match_data);
618 }
619 
620 template <typename ImplSP>
621 ImplSP FormatManager::GetCached(FormattersMatchData &match_data) {
622  ImplSP retval_sp;
623  Log *log = GetLog(LLDBLog::DataFormatters);
624  if (match_data.GetTypeForCache()) {
625  LLDB_LOGF(log, "\n\n[%s] Looking into cache for type %s", __FUNCTION__,
626  match_data.GetTypeForCache().AsCString("<invalid>"));
627  if (m_format_cache.Get(match_data.GetTypeForCache(), retval_sp)) {
628  if (log) {
629  LLDB_LOGF(log, "[%s] Cache search success. Returning.", __FUNCTION__);
630  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
631  m_format_cache.GetCacheHits(),
632  m_format_cache.GetCacheMisses());
633  }
634  return retval_sp;
635  }
636  LLDB_LOGF(log, "[%s] Cache search failed. Going normal route",
637  __FUNCTION__);
638  }
639 
640  m_categories_map.Get(match_data, retval_sp);
641  if (match_data.GetTypeForCache() && (!retval_sp || !retval_sp->NonCacheable())) {
642  LLDB_LOGF(log, "[%s] Caching %p for type %s", __FUNCTION__,
643  static_cast<void *>(retval_sp.get()),
644  match_data.GetTypeForCache().AsCString("<invalid>"));
645  m_format_cache.Set(match_data.GetTypeForCache(), retval_sp);
646  }
647  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
648  m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
649  return retval_sp;
650 }
651 
652 lldb::TypeFormatImplSP
653 FormatManager::GetFormat(ValueObject &valobj,
654  lldb::DynamicValueType use_dynamic) {
655  return Get<lldb::TypeFormatImplSP>(valobj, use_dynamic);
656 }
657 
658 lldb::TypeSummaryImplSP
659 FormatManager::GetSummaryFormat(ValueObject &valobj,
660  lldb::DynamicValueType use_dynamic) {
661  return Get<lldb::TypeSummaryImplSP>(valobj, use_dynamic);
662 }
663 
664 lldb::SyntheticChildrenSP
665 FormatManager::GetSyntheticChildren(ValueObject &valobj,
666  lldb::DynamicValueType use_dynamic) {
667  return Get<lldb::SyntheticChildrenSP>(valobj, use_dynamic);
668 }
669 
670 FormatManager::FormatManager()
671  : m_last_revision(0), m_format_cache(), m_language_categories_mutex(),
672  m_language_categories_map(), m_named_summaries_map(this),
673  m_categories_map(this), m_default_category_name(ConstString("default")),
674  m_system_category_name(ConstString("system")),
675  m_vectortypes_category_name(ConstString("VectorTypes")) {
678 
683 }
684 
686  TypeSummaryImpl::Flags string_flags;
687  string_flags.SetCascades(true)
688  .SetSkipPointers(true)
689  .SetSkipReferences(false)
690  .SetDontShowChildren(true)
691  .SetDontShowValue(false)
692  .SetShowMembersOneLiner(false)
693  .SetHideItemNames(false);
694 
695  TypeSummaryImpl::Flags string_array_flags;
696  string_array_flags.SetCascades(true)
697  .SetSkipPointers(true)
698  .SetSkipReferences(false)
699  .SetDontShowChildren(true)
700  .SetDontShowValue(true)
701  .SetShowMembersOneLiner(false)
702  .SetHideItemNames(false);
703 
704  lldb::TypeSummaryImplSP string_format(
705  new StringSummaryFormat(string_flags, "${var%s}"));
706 
707  lldb::TypeSummaryImplSP string_array_format(
708  new StringSummaryFormat(string_array_flags, "${var%char[]}"));
709 
710  RegularExpression any_size_char_arr(R"(^((un)?signed )?char ?\[[0-9]+\]$)");
711 
712  TypeCategoryImpl::SharedPointer sys_category_sp =
714 
715  sys_category_sp->GetRegexTypeSummariesContainer()->Add(
716  RegularExpression(R"(^(unsigned )?char ?(\*|\[\])$)"), string_format);
717 
718  sys_category_sp->GetRegexTypeSummariesContainer()->Add(
719  std::move(any_size_char_arr), string_array_format);
720 
721  lldb::TypeSummaryImplSP ostype_summary(
723  .SetCascades(false)
724  .SetSkipPointers(true)
725  .SetSkipReferences(true)
726  .SetDontShowChildren(true)
727  .SetDontShowValue(false)
728  .SetShowMembersOneLiner(false)
729  .SetHideItemNames(false),
730  "${var%O}"));
731 
732  sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"),
733  ostype_summary);
734 
735  TypeFormatImpl::Flags fourchar_flags;
736  fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(
737  true);
738 
739  AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"),
740  fourchar_flags);
741 }
742 
744  TypeCategoryImpl::SharedPointer vectors_category_sp =
746 
747  TypeSummaryImpl::Flags vector_flags;
748  vector_flags.SetCascades(true)
749  .SetSkipPointers(true)
750  .SetSkipReferences(false)
751  .SetDontShowChildren(true)
752  .SetDontShowValue(false)
754  .SetHideItemNames(true);
755 
756  AddStringSummary(vectors_category_sp, "${var.uint128}",
757  ConstString("builtin_type_vec128"), vector_flags);
758  AddStringSummary(vectors_category_sp, "", ConstString("float[4]"),
759  vector_flags);
760  AddStringSummary(vectors_category_sp, "", ConstString("int32_t[4]"),
761  vector_flags);
762  AddStringSummary(vectors_category_sp, "", ConstString("int16_t[8]"),
763  vector_flags);
764  AddStringSummary(vectors_category_sp, "", ConstString("vDouble"),
765  vector_flags);
766  AddStringSummary(vectors_category_sp, "", ConstString("vFloat"),
767  vector_flags);
768  AddStringSummary(vectors_category_sp, "", ConstString("vSInt8"),
769  vector_flags);
770  AddStringSummary(vectors_category_sp, "", ConstString("vSInt16"),
771  vector_flags);
772  AddStringSummary(vectors_category_sp, "", ConstString("vSInt32"),
773  vector_flags);
774  AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
775  vector_flags);
776  AddStringSummary(vectors_category_sp, "", ConstString("vUInt8"),
777  vector_flags);
778  AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
779  vector_flags);
780  AddStringSummary(vectors_category_sp, "", ConstString("vUInt32"),
781  vector_flags);
782  AddStringSummary(vectors_category_sp, "", ConstString("vBool32"),
783  vector_flags);
784 }
lldb_private::FormattersMatchData
Definition: FormatClasses.h:110
lldb_private::CompilerType::GetNonReferenceType
CompilerType GetNonReferenceType() const
If this type is a reference to a type (L value or R value reference), return a new type with the refe...
Definition: CompilerType.cpp:394
lldb::eFormatVectorOfUInt64
@ eFormatVectorOfUInt64
Definition: lldb-enumerations.h:187
lldb::eFormatOSType
@ eFormatOSType
OS character codes encoded into an integer 'PICT' 'text' etc...
Definition: lldb-enumerations.h:173
lldb_private::ScriptedSyntheticChildren
Definition: TypeSynthetic.h:387
lldb::eFormatPointer
@ eFormatPointer
Definition: lldb-enumerations.h:178
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
g_format_infos
static constexpr FormatInfo g_format_infos[]
Definition: FormatManager.cpp:32
lldb_private::FormatManager::LoadVectorFormatters
void LoadVectorFormatters()
Definition: FormatManager.cpp:743
lldb_private::RegularExpression
Definition: RegularExpression.h:18
lldb::eFormatVectorOfChar
@ eFormatVectorOfChar
Definition: lldb-enumerations.h:179
lldb::eFormatVectorOfUInt128
@ eFormatVectorOfUInt128
Definition: lldb-enumerations.h:191
lldb::Format
Format
Display format definitions.
Definition: lldb-enumerations.h:155
lldb_private::ValueObject::IsDynamic
virtual bool IsDynamic()
Definition: ValueObject.h:637
lldb_private::FormattersMatchCandidate::Flags::WithStrippedReference
Flags WithStrippedReference()
Definition: FormatClasses.h:62
lldb_private::TypeSummaryImpl::Flags::SetDontShowChildren
Flags & SetDontShowChildren(bool value=true)
Definition: TypeSummary.h:121
lldb_private::ValueObject::IsSynthetic
virtual bool IsSynthetic()
Definition: ValueObject.h:598
FormatManager.h
lldb::eLanguageTypeC99
@ eLanguageTypeC99
ISO C:1999.
Definition: lldb-enumerations.h:449
lldb_private::TypeSummaryImpl::Flags
Definition: TypeSummary.h:53
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:343
lldb::eFormatInstruction
@ eFormatInstruction
Disassemble an opcode.
Definition: lldb-enumerations.h:199
lldb_private::FormattersMatchCandidate::Flags::WithStrippedTypedef
Flags WithStrippedTypedef()
Definition: FormatClasses.h:69
lldb::eFormatVectorOfSInt16
@ eFormatVectorOfSInt16
Definition: lldb-enumerations.h:182
lldb::eFormatVectorOfSInt32
@ eFormatVectorOfSInt32
Definition: lldb-enumerations.h:184
lldb_private::formatters::AddFormat
void AddFormat(TypeCategoryImpl::SharedPointer category_sp, lldb::Format format, ConstString type_name, TypeFormatImpl::Flags flags, bool regex=false)
Definition: FormattersHelpers.cpp:24
lldb_private::ValueObject::GetQualifiedRepresentationIfAvailable
lldb::ValueObjectSP GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue, bool synthValue)
Definition: ValueObject.cpp:2598
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::TypeFilterImpl
Definition: TypeSynthetic.h:277
lldb::eFormatBoolean
@ eFormatBoolean
Definition: lldb-enumerations.h:158
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb_private::CompilerType::GetOpaqueQualType
lldb::opaque_compiler_type_t GetOpaqueQualType() const
Definition: CompilerType.h:173
lldb_private::ValueObject::GetBitfieldBitSize
virtual uint32_t GetBitfieldBitSize()
Definition: ValueObject.h:424
lldb_private::FormatManager::GetCategory
lldb::TypeCategoryImplSP GetCategory(const char *category_name=nullptr, bool can_create=true)
Definition: FormatManager.h:99
lldb::eFormatBytesWithASCII
@ eFormatBytesWithASCII
Definition: lldb-enumerations.h:161
Language.h
Debugger.h
LLDB_LOGV
#define LLDB_LOGV(log,...)
Definition: Log.h:350
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb::eLanguageTypeC_plus_plus_11
@ eLanguageTypeC_plus_plus_11
ISO C++:2011.
Definition: lldb-enumerations.h:465
lldb::eFormatVectorOfSInt8
@ eFormatVectorOfSInt8
Definition: lldb-enumerations.h:180
lldb_private::formatters::AddStringSummary
void AddStringSummary(TypeCategoryImpl::SharedPointer category_sp, const char *string, ConstString type_name, TypeSummaryImpl::Flags flags, bool regex=false)
Definition: FormattersHelpers.cpp:48
lldb_private::ValueObject::GetChildAtIndex
virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create)
Definition: ValueObject.cpp:375
lldb::eFormatBytes
@ eFormatBytes
Definition: lldb-enumerations.h:160
lldb_private::CompilerType::GetPointeeType
CompilerType GetPointeeType() const
If this type is a pointer type, return the type that the pointer points to, else return an invalid ty...
Definition: CompilerType.cpp:400
lldb_private::CompilerType::IsMeaninglessWithoutDynamicResolution
bool IsMeaninglessWithoutDynamicResolution() const
Definition: CompilerType.cpp:701
lldb::eFormatVectorOfFloat64
@ eFormatVectorOfFloat64
Definition: lldb-enumerations.h:190
lldb_private::ValueObject::GetSummaryFormat
lldb::TypeSummaryImplSP GetSummaryFormat()
Definition: ValueObject.h:717
lldb_private::TypeFormatImpl::Flags::SetSkipReferences
Flags & SetSkipReferences(bool value=true)
Definition: TypeFormat.h:81
lldb::eFormatUnicode8
@ eFormatUnicode8
Definition: lldb-enumerations.h:201
lldb::eFormatVectorOfUInt32
@ eFormatVectorOfUInt32
Definition: lldb-enumerations.h:185
lldb::eLanguageTypeC_plus_plus_03
@ eLanguageTypeC_plus_plus_03
ISO C++:2003.
Definition: lldb-enumerations.h:464
lldb_private::LanguageCategory::UniquePointer
std::unique_ptr< LanguageCategory > UniquePointer
Definition: LanguageCategory.h:23
lldb_private::FormatManager::m_vectortypes_category_name
ConstString m_vectortypes_category_name
Definition: FormatManager.h:194
lldb_private::TypeCategoryMap::ForEachCallback
std::function< bool(const ValueSP &)> ForEachCallback
Definition: TypeCategoryMap.h:35
lldb_private::ValueObject::GetStaticValue
virtual lldb::ValueObjectSP GetStaticValue()
Definition: ValueObject.h:590
Log.h
lldb_private::TypeSummaryImpl::Flags::SetShowMembersOneLiner
Flags & SetShowMembersOneLiner(bool value=true)
Definition: TypeSummary.h:160
lldb_private::FormattersMatchVector
std::vector< FormattersMatchCandidate > FormattersMatchVector
Definition: FormatClasses.h:107
lldb_private::FormattersMatchData::GetTypeForCache
ConstString GetTypeForCache()
Definition: FormatClasses.cpp:39
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::StreamString
Definition: StreamString.h:23
lldb::eLanguageTypeC89
@ eLanguageTypeC89
ISO C:1989.
Definition: lldb-enumerations.h:438
lldb_private::FormattersMatchData::GetCandidateLanguages
CandidateLanguagesVector GetCandidateLanguages()
Definition: FormatClasses.cpp:41
lldb_private::CompilerType::GetArrayElementType
CompilerType GetArrayElementType(ExecutionContextScope *exe_scope) const
Creating related types.
Definition: CompilerType.cpp:327
lldb::eFormatDecimal
@ eFormatDecimal
Definition: lldb-enumerations.h:167
lldb::eLanguageTypeC11
@ eLanguageTypeC11
ISO C:2011.
Definition: lldb-enumerations.h:468
lldb_private::CompilerType::IsReferenceType
bool IsReferenceType(CompilerType *pointee_type=nullptr, bool *is_rvalue=nullptr) const
Definition: CompilerType.cpp:175
lldb::DynamicValueType
DynamicValueType
Definition: lldb-enumerations.h:494
lldb_private::ValueObject::GetExecutionContextRef
const ExecutionContextRef & GetExecutionContextRef() const
Definition: ValueObject.h:330
lldb_private::CompilerType::IsTypedefType
bool IsTypedefType() const
Definition: CompilerType.cpp:230
lldb::eFormatVectorOfUInt16
@ eFormatVectorOfUInt16
Definition: lldb-enumerations.h:183
lldb::eLanguageTypeObjC
@ eLanguageTypeObjC
Objective-C.
Definition: lldb-enumerations.h:453
lldb::kNumFormats
@ kNumFormats
Definition: lldb-enumerations.h:202
lldb::eLanguageTypeObjC_plus_plus
@ eLanguageTypeObjC_plus_plus
Objective-C++.
Definition: lldb-enumerations.h:454
lldb_private::LanguageCategory
Definition: LanguageCategory.h:21
lldb_private::TypeCategoryImpl::SharedPointer
std::shared_ptr< TypeCategoryImpl > SharedPointer
Definition: TypeCategory.h:316
lldb_private::CompilerType::IsValid
bool IsValid() const
Definition: CompilerType.h:72
lldb_private::CompilerType::GetLValueReferenceType
CompilerType GetLValueReferenceType() const
Return a new CompilerType that is a L value reference to this type if this type is valid and the type...
Definition: CompilerType.cpp:414
lldb_private::TypeSummaryImpl::Flags::SetCascades
Flags & SetCascades(bool value=true)
Definition: TypeSummary.h:82
lldb::eFormatVectorOfFloat16
@ eFormatVectorOfFloat16
Definition: lldb-enumerations.h:188
lldb::eFormatChar
@ eFormatChar
Definition: lldb-enumerations.h:162
GetFormatFromFormatName
static bool GetFormatFromFormatName(llvm::StringRef format_name, bool partial_match_ok, Format &format)
Definition: FormatManager.cpp:92
lldb::eFormatHexFloat
@ eFormatHexFloat
ISO C99 hex float string.
Definition: lldb-enumerations.h:198
lldb::eFormatVoid
@ eFormatVoid
Do not print this.
Definition: lldb-enumerations.h:200
lldb_private::ValueObject::GetNumChildren
size_t GetNumChildren(uint32_t max=UINT32_MAX)
Definition: ValueObject.cpp:496
lldb_private::TypeSummaryImpl::Flags::SetSkipPointers
Flags & SetSkipPointers(bool value=true)
Definition: TypeSummary.h:95
lldb_private::TypeSummaryImpl::Flags::SetDontShowValue
Flags & SetDontShowValue(bool value=true)
Definition: TypeSummary.h:147
lldb::eFormatUnicode16
@ eFormatUnicode16
Definition: lldb-enumerations.h:175
lldb::eFormatUnsigned
@ eFormatUnsigned
Definition: lldb-enumerations.h:177
FormatInfo::format
Format format
Definition: FormatManager.cpp:25
lldb_private::CompilerType::ShouldPrintAsOneLiner
LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const
Definition: CompilerType.cpp:695
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::CompilerType::GetPointerType
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
Definition: CompilerType.cpp:407
LanguageCategory.h
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
lldb_private::TypeFormatImpl::Flags
Definition: TypeFormat.h:26
lldb_private::FormatManager::LoadSystemFormatters
void LoadSystemFormatters()
Definition: FormatManager.cpp:685
lldb_private::ExecutionContext::GetBestExecutionContextScope
ExecutionContextScope * GetBestExecutionContextScope() const
Definition: ExecutionContext.cpp:214
lldb_private::Language
Definition: Language.h:29
lldb_private::CompilerType::IsPointerType
bool IsPointerType(CompilerType *pointee_type=nullptr) const
Definition: CompilerType.cpp:157
lldb::eFormatCString
@ eFormatCString
NULL terminated C strings.
Definition: lldb-enumerations.h:166
lldb_private::CompilerType::GetTypeName
ConstString GetTypeName() const
Definition: CompilerType.cpp:277
lldb::eFormatVectorOfSInt64
@ eFormatVectorOfSInt64
Definition: lldb-enumerations.h:186
lldb_private::CompilerType::IsArrayType
bool IsArrayType(CompilerType *element_type=nullptr, uint64_t *size=nullptr, bool *is_incomplete=nullptr) const
Definition: CompilerType.cpp:49
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::ValueObject::GetCompilerType
CompilerType GetCompilerType()
Definition: ValueObject.h:352
lldb::eFormatCharPrintable
@ eFormatCharPrintable
Only printable characters, '.' if not printable.
Definition: lldb-enumerations.h:163
lldb::eLanguageTypeC_plus_plus_14
@ eLanguageTypeC_plus_plus_14
ISO C++:2014.
Definition: lldb-enumerations.h:472
GetFormatFromFormatChar
static bool GetFormatFromFormatChar(char format_char, Format &format)
Definition: FormatManager.cpp:81
lldb::eFormatCharArray
@ eFormatCharArray
Print characters with no single quotes, used for character arrays that can contain non printable char...
Definition: lldb-enumerations.h:193
lldb_private::CompilerType::GetTypedefedType
CompilerType GetTypedefedType() const
If the current object represents a typedef type, get the underlying type.
Definition: CompilerType.cpp:464
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::FormatManager::m_system_category_name
ConstString m_system_category_name
Definition: FormatManager.h:193
lldb::eFormatBinary
@ eFormatBinary
Definition: lldb-enumerations.h:159
g_num_format_infos
static uint32_t g_num_format_infos
Definition: FormatManager.cpp:79
lldb::eFormatComplexInteger
@ eFormatComplexInteger
Integer complex type.
Definition: lldb-enumerations.h:192
FormatInfo::format_char
const char format_char
Definition: FormatManager.cpp:26
lldb_private::formatters
Definition: CXXFunctionPointer.h:15
lldb::eLanguageTypeC
@ eLanguageTypeC
Non-standardized C, such as K&R.
Definition: lldb-enumerations.h:439
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::eFormatHex
@ eFormatHex
Definition: lldb-enumerations.h:169
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb::eFormatUnicode32
@ eFormatUnicode32
Definition: lldb-enumerations.h:176
lldb::eFormatEnum
@ eFormatEnum
Definition: lldb-enumerations.h:168
lldb_private::TypeCategoryMap::Last
static const Position Last
Definition: TypeCategoryMap.h:41
lldb_private::ValueObject::GetTargetSP
lldb::TargetSP GetTargetSP() const
Definition: ValueObject.h:334
FormatInfo::format_name
const char * format_name
Definition: FormatManager.cpp:28
lldb_private::TypeFormatImpl::Flags::SetCascades
Flags & SetCascades(bool value=true)
Definition: TypeFormat.h:55
lldb_private::StringSummaryFormat
Definition: TypeSummary.h:278
lldb_private::TypeCategoryImpl
Definition: TypeCategory.h:63
lldb_private::FormattersMatchCandidate::Flags
Definition: FormatClasses.h:49
lldb_private::Log
Definition: Log.h:115
lldb::eFormatVectorOfFloat32
@ eFormatVectorOfFloat32
Definition: lldb-enumerations.h:189
lldb::eFormatComplexFloat
@ eFormatComplexFloat
Definition: lldb-enumerations.h:165
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:308
lldb::eFormatFloat
@ eFormatFloat
Definition: lldb-enumerations.h:171
lldb_private::TypeSummaryImpl::Flags::SetHideItemNames
Flags & SetHideItemNames(bool value=true)
Definition: TypeSummary.h:173
lldb_private::TypeFormatImpl::Flags::SetSkipPointers
Flags & SetSkipPointers(bool value=true)
Definition: TypeFormat.h:68
FormattersHelpers.h
lldb_private::CompilerType::GetTypeForFormatters
CompilerType GetTypeForFormatters() const
Definition: CompilerType.cpp:689
lldb
Definition: SBAddress.h:15
FormatInfo
Definition: FormatManager.cpp:24
lldb::eFormatAddressInfo
@ eFormatAddressInfo
Describe what an address points to (func + offset.
Definition: lldb-enumerations.h:196
LLDBLog.h
lldb::eFormatVectorOfUInt8
@ eFormatVectorOfUInt8
Definition: lldb-enumerations.h:181
lldb::eFormatDefault
@ eFormatDefault
Definition: lldb-enumerations.h:156
lldb_private::FormatManager::EnableCategory
void EnableCategory(ConstString category_name, TypeCategoryMap::Position pos=TypeCategoryMap::Default)
Definition: FormatManager.h:53
ExecutionContext.h
lldb_private::CompilerType::GetRValueReferenceType
CompilerType GetRValueReferenceType() const
Return a new CompilerType that is a R value reference to this type if this type is valid and the type...
Definition: CompilerType.cpp:421
lldb_private::CompilerType::GetFullyUnqualifiedType
CompilerType GetFullyUnqualifiedType() const
Definition: CompilerType.cpp:347
lldb::eFormatOctal
@ eFormatOctal
Definition: lldb-enumerations.h:172
lldb_private::FormattersMatchCandidate::Flags::WithStrippedPointer
Flags WithStrippedPointer()
Definition: FormatClasses.h:55
lldb_private::ValueObject::GetObjectRuntimeLanguage
virtual lldb::LanguageType GetObjectRuntimeLanguage()
Definition: ValueObject.h:373
lldb::eFormatHexUppercase
@ eFormatHexUppercase
Definition: lldb-enumerations.h:170
lldb_private::CompilerType::GetArrayType
CompilerType GetArrayType(uint64_t size) const
Definition: CompilerType.cpp:334
lldb::eFormatInvalid
@ eFormatInvalid
Definition: lldb-enumerations.h:157
lldb_private::TypeSummaryImpl::Flags::SetSkipReferences
Flags & SetSkipReferences(bool value=true)
Definition: TypeSummary.h:108
lldb::eLanguageTypeC_plus_plus
@ eLanguageTypeC_plus_plus
ISO C++:1998.
Definition: lldb-enumerations.h:441