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