lldb/source/DataFormatters/FormatManager.cpp

   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
   9 #include "lldb/DataFormatters/FormatManager.h"
  10
  11 #include "lldb/Core/Debugger.h"
  12 #include "lldb/DataFormatters/FormattersHelpers.h"
  13 #include "lldb/DataFormatters/LanguageCategory.h"
  14 #include "lldb/Interpreter/ScriptInterpreter.h"
  15 #include "lldb/Target/ExecutionContext.h"
  16 #include "lldb/Target/Language.h"
  17 #include "lldb/Utility/LLDBLog.h"
  18 #include "lldb/Utility/Log.h"
  19 #include "llvm/ADT/STLExtras.h"
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23 using namespace lldb_private::formatters;
  24
  25 struct FormatInfo {
  26   Format format;
  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])) ==
  77                   kNumFormats,
  78               "All formats must have a corresponding info entry.");
  79
  80 static uint32_t g_num_format_infos = std::size(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(llvm::StringRef 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 (format_name.equals_insensitive(g_format_infos[i].format_name)) {
  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 (llvm::StringRef(g_format_infos[i].format_name)
 106               .starts_with_insensitive(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     FormattersMatchCandidate::Flags current_flags, bool root_level) {
 180   compiler_type = compiler_type.GetTypeForFormatters();
 181   ConstString type_name(compiler_type.GetTypeName());
 182   ScriptInterpreter *script_interpreter =
 183       valobj.GetTargetSP()->GetDebugger().GetScriptInterpreter();
 184   if (valobj.GetBitfieldBitSize() > 0) {
 185     StreamString sstring;
 186     sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
 187     ConstString bitfieldname(sstring.GetString());
 188     entries.push_back({bitfieldname, script_interpreter,
 189                        TypeImpl(compiler_type), current_flags});
 190   }
 191
 192   if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
 193     entries.push_back({type_name, script_interpreter, TypeImpl(compiler_type),
 194                        current_flags});
 195
 196     ConstString display_type_name(compiler_type.GetTypeName());
 197     if (display_type_name != type_name)
 198       entries.push_back({display_type_name, script_interpreter,
 199                          TypeImpl(compiler_type), current_flags});
 200   }
 201
 202   for (bool is_rvalue_ref = true, j = true;
 203        j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
 204     CompilerType non_ref_type = compiler_type.GetNonReferenceType();
 205     GetPossibleMatches(valobj, non_ref_type, use_dynamic, entries,
 206                        current_flags.WithStrippedReference());
 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       // this is not exactly the usual meaning of stripping typedefs
 213       GetPossibleMatches(
 214           valobj, deffed_referenced_type,
 215           use_dynamic, entries, current_flags.WithStrippedTypedef());
 216     }
 217   }
 218
 219   if (compiler_type.IsPointerType()) {
 220     CompilerType non_ptr_type = compiler_type.GetPointeeType();
 221     GetPossibleMatches(valobj, non_ptr_type, use_dynamic, entries,
 222                        current_flags.WithStrippedPointer());
 223     if (non_ptr_type.IsTypedefType()) {
 224       CompilerType deffed_pointed_type =
 225           non_ptr_type.GetTypedefedType().GetPointerType();
 226       // this is not exactly the usual meaning of stripping typedefs
 227       GetPossibleMatches(valobj, deffed_pointed_type, use_dynamic, entries,
 228                          current_flags.WithStrippedTypedef());
 229     }
 230   }
 231
 232   // For arrays with typedef-ed elements, we add a candidate with the typedef
 233   // stripped.
 234   uint64_t array_size;
 235   if (compiler_type.IsArrayType(nullptr, &array_size, nullptr)) {
 236     ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
 237     CompilerType element_type = compiler_type.GetArrayElementType(
 238         exe_ctx.GetBestExecutionContextScope());
 239     if (element_type.IsTypedefType()) {
 240       // Get the stripped element type and compute the stripped array type
 241       // from it.
 242       CompilerType deffed_array_type =
 243           element_type.GetTypedefedType().GetArrayType(array_size);
 244       // this is not exactly the usual meaning of stripping typedefs
 245       GetPossibleMatches(
 246           valobj, deffed_array_type,
 247           use_dynamic, entries, current_flags.WithStrippedTypedef());
 248     }
 249   }
 250
 251   for (lldb::LanguageType language_type :
 252        GetCandidateLanguages(valobj.GetObjectRuntimeLanguage())) {
 253     if (Language *language = Language::FindPlugin(language_type)) {
 254       for (const FormattersMatchCandidate& candidate :
 255            language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
 256         entries.push_back(candidate);
 257       }
 258     }
 259   }
 260
 261   // try to strip typedef chains
 262   if (compiler_type.IsTypedefType()) {
 263     CompilerType deffed_type = compiler_type.GetTypedefedType();
 264     GetPossibleMatches(valobj, deffed_type, use_dynamic, entries,
 265                        current_flags.WithStrippedTypedef());
 266   }
 267
 268   if (root_level) {
 269     do {
 270       if (!compiler_type.IsValid())
 271         break;
 272
 273       CompilerType unqual_compiler_ast_type =
 274           compiler_type.GetFullyUnqualifiedType();
 275       if (!unqual_compiler_ast_type.IsValid())
 276         break;
 277       if (unqual_compiler_ast_type.GetOpaqueQualType() !=
 278           compiler_type.GetOpaqueQualType())
 279         GetPossibleMatches(valobj, unqual_compiler_ast_type, use_dynamic,
 280                            entries, current_flags);
 281     } while (false);
 282
 283     // if all else fails, go to static type
 284     if (valobj.IsDynamic()) {
 285       lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
 286       if (static_value_sp)
 287         GetPossibleMatches(*static_value_sp.get(),
 288                            static_value_sp->GetCompilerType(), use_dynamic,
 289                            entries, current_flags, true);
 290     }
 291   }
 292 }
 293
 294 lldb::TypeFormatImplSP
 295 FormatManager::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
 296   if (!type_sp)
 297     return lldb::TypeFormatImplSP();
 298   lldb::TypeFormatImplSP format_chosen_sp;
 299   uint32_t num_categories = m_categories_map.GetCount();
 300   lldb::TypeCategoryImplSP category_sp;
 301   uint32_t prio_category = UINT32_MAX;
 302   for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
 303     category_sp = GetCategoryAtIndex(category_id);
 304     if (!category_sp->IsEnabled())
 305       continue;
 306     lldb::TypeFormatImplSP format_current_sp =
 307         category_sp->GetFormatForType(type_sp);
 308     if (format_current_sp &&
 309         (format_chosen_sp.get() == nullptr ||
 310          (prio_category > category_sp->GetEnabledPosition()))) {
 311       prio_category = category_sp->GetEnabledPosition();
 312       format_chosen_sp = format_current_sp;
 313     }
 314   }
 315   return format_chosen_sp;
 316 }
 317
 318 lldb::TypeSummaryImplSP
 319 FormatManager::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
 320   if (!type_sp)
 321     return lldb::TypeSummaryImplSP();
 322   lldb::TypeSummaryImplSP summary_chosen_sp;
 323   uint32_t num_categories = m_categories_map.GetCount();
 324   lldb::TypeCategoryImplSP category_sp;
 325   uint32_t prio_category = UINT32_MAX;
 326   for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
 327     category_sp = GetCategoryAtIndex(category_id);
 328     if (!category_sp->IsEnabled())
 329       continue;
 330     lldb::TypeSummaryImplSP summary_current_sp =
 331         category_sp->GetSummaryForType(type_sp);
 332     if (summary_current_sp &&
 333         (summary_chosen_sp.get() == nullptr ||
 334          (prio_category > category_sp->GetEnabledPosition()))) {
 335       prio_category = category_sp->GetEnabledPosition();
 336       summary_chosen_sp = summary_current_sp;
 337     }
 338   }
 339   return summary_chosen_sp;
 340 }
 341
 342 lldb::TypeFilterImplSP
 343 FormatManager::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
 344   if (!type_sp)
 345     return lldb::TypeFilterImplSP();
 346   lldb::TypeFilterImplSP filter_chosen_sp;
 347   uint32_t num_categories = m_categories_map.GetCount();
 348   lldb::TypeCategoryImplSP category_sp;
 349   uint32_t prio_category = UINT32_MAX;
 350   for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
 351     category_sp = GetCategoryAtIndex(category_id);
 352     if (!category_sp->IsEnabled())
 353       continue;
 354     lldb::TypeFilterImplSP filter_current_sp(
 355         (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
 356     if (filter_current_sp &&
 357         (filter_chosen_sp.get() == nullptr ||
 358          (prio_category > category_sp->GetEnabledPosition()))) {
 359       prio_category = category_sp->GetEnabledPosition();
 360       filter_chosen_sp = filter_current_sp;
 361     }
 362   }
 363   return filter_chosen_sp;
 364 }
 365
 366 lldb::ScriptedSyntheticChildrenSP
 367 FormatManager::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
 368   if (!type_sp)
 369     return lldb::ScriptedSyntheticChildrenSP();
 370   lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
 371   uint32_t num_categories = m_categories_map.GetCount();
 372   lldb::TypeCategoryImplSP category_sp;
 373   uint32_t prio_category = UINT32_MAX;
 374   for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
 375     category_sp = GetCategoryAtIndex(category_id);
 376     if (!category_sp->IsEnabled())
 377       continue;
 378     lldb::ScriptedSyntheticChildrenSP synth_current_sp(
 379         (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
 380             .get());
 381     if (synth_current_sp &&
 382         (synth_chosen_sp.get() == nullptr ||
 383          (prio_category > category_sp->GetEnabledPosition()))) {
 384       prio_category = category_sp->GetEnabledPosition();
 385       synth_chosen_sp = synth_current_sp;
 386     }
 387   }
 388   return synth_chosen_sp;
 389 }
 390
 391 void FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback) {
 392   m_categories_map.ForEach(callback);
 393   std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
 394   for (const auto &entry : m_language_categories_map) {
 395     if (auto category_sp = entry.second->GetCategory()) {
 396       if (!callback(category_sp))
 397         break;
 398     }
 399   }
 400 }
 401
 402 lldb::TypeCategoryImplSP
 403 FormatManager::GetCategory(ConstString category_name, bool can_create) {
 404   if (!category_name)
 405     return GetCategory(m_default_category_name);
 406   lldb::TypeCategoryImplSP category;
 407   if (m_categories_map.Get(category_name, category))
 408     return category;
 409
 410   if (!can_create)
 411     return lldb::TypeCategoryImplSP();
 412
 413   m_categories_map.Add(
 414       category_name,
 415       lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
 416   return GetCategory(category_name);
 417 }
 418
 419 lldb::Format FormatManager::GetSingleItemFormat(lldb::Format vector_format) {
 420   switch (vector_format) {
 421   case eFormatVectorOfChar:
 422     return eFormatCharArray;
 423
 424   case eFormatVectorOfSInt8:
 425   case eFormatVectorOfSInt16:
 426   case eFormatVectorOfSInt32:
 427   case eFormatVectorOfSInt64:
 428     return eFormatDecimal;
 429
 430   case eFormatVectorOfUInt8:
 431   case eFormatVectorOfUInt16:
 432   case eFormatVectorOfUInt32:
 433   case eFormatVectorOfUInt64:
 434   case eFormatVectorOfUInt128:
 435     return eFormatHex;
 436
 437   case eFormatVectorOfFloat16:
 438   case eFormatVectorOfFloat32:
 439   case eFormatVectorOfFloat64:
 440     return eFormatFloat;
 441
 442   default:
 443     return lldb::eFormatInvalid;
 444   }
 445 }
 446
 447 bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) {
 448   // if settings say no oneline whatsoever
 449   if (valobj.GetTargetSP().get() &&
 450       !valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries())
 451     return false; // then don't oneline
 452
 453   // if this object has a summary, then ask the summary
 454   if (valobj.GetSummaryFormat().get() != nullptr)
 455     return valobj.GetSummaryFormat()->IsOneLiner();
 456
 457   // no children, no party
 458   if (valobj.GetNumChildren() == 0)
 459     return false;
 460
 461   // ask the type if it has any opinion about this eLazyBoolCalculate == no
 462   // opinion; other values should be self explanatory
 463   CompilerType compiler_type(valobj.GetCompilerType());
 464   if (compiler_type.IsValid()) {
 465     switch (compiler_type.ShouldPrintAsOneLiner(&valobj)) {
 466     case eLazyBoolNo:
 467       return false;
 468     case eLazyBoolYes:
 469       return true;
 470     case eLazyBoolCalculate:
 471       break;
 472     }
 473   }
 474
 475   size_t total_children_name_len = 0;
 476
 477   for (size_t idx = 0; idx < valobj.GetNumChildren(); idx++) {
 478     bool is_synth_val = false;
 479     ValueObjectSP child_sp(valobj.GetChildAtIndex(idx));
 480     // something is wrong here - bail out
 481     if (!child_sp)
 482       return false;
 483
 484     // also ask the child's type if it has any opinion
 485     CompilerType child_compiler_type(child_sp->GetCompilerType());
 486     if (child_compiler_type.IsValid()) {
 487       switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get())) {
 488       case eLazyBoolYes:
 489       // an opinion of yes is only binding for the child, so keep going
 490       case eLazyBoolCalculate:
 491         break;
 492       case eLazyBoolNo:
 493         // but if the child says no, then it's a veto on the whole thing
 494         return false;
 495       }
 496     }
 497
 498     // if we decided to define synthetic children for a type, we probably care
 499     // enough to show them, but avoid nesting children in children
 500     if (child_sp->GetSyntheticChildren().get() != nullptr) {
 501       ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
 502       // wait.. wat? just get out of here..
 503       if (!synth_sp)
 504         return false;
 505       // but if we only have them to provide a value, keep going
 506       if (!synth_sp->MightHaveChildren() &&
 507           synth_sp->DoesProvideSyntheticValue())
 508         is_synth_val = true;
 509       else
 510         return false;
 511     }
 512
 513     total_children_name_len += child_sp->GetName().GetLength();
 514
 515     // 50 itself is a "randomly" chosen number - the idea is that
 516     // overly long structs should not get this treatment
 517     // FIXME: maybe make this a user-tweakable setting?
 518     if (total_children_name_len > 50)
 519       return false;
 520
 521     // if a summary is there..
 522     if (child_sp->GetSummaryFormat()) {
 523       // and it wants children, then bail out
 524       if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
 525         return false;
 526     }
 527
 528     // if this child has children..
 529     if (child_sp->GetNumChildren()) {
 530       // ...and no summary...
 531       // (if it had a summary and the summary wanted children, we would have
 532       // bailed out anyway
 533       //  so this only makes us bail out if this has no summary and we would
 534       //  then print children)
 535       if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do
 536                                                           // that if not a
 537                                                           // synthetic valued
 538                                                           // child
 539         return false;                                     // then bail out
 540     }
 541   }
 542   return true;
 543 }
 544
 545 ConstString FormatManager::GetTypeForCache(ValueObject &valobj,
 546                                            lldb::DynamicValueType use_dynamic) {
 547   ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(
 548       use_dynamic, valobj.IsSynthetic());
 549   if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) {
 550     if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
 551       return valobj_sp->GetQualifiedTypeName();
 552   }
 553   return ConstString();
 554 }
 555
 556 std::vector<lldb::LanguageType>
 557 FormatManager::GetCandidateLanguages(lldb::LanguageType lang_type) {
 558   switch (lang_type) {
 559   case lldb::eLanguageTypeC:
 560   case lldb::eLanguageTypeC89:
 561   case lldb::eLanguageTypeC99:
 562   case lldb::eLanguageTypeC11:
 563   case lldb::eLanguageTypeC_plus_plus:
 564   case lldb::eLanguageTypeC_plus_plus_03:
 565   case lldb::eLanguageTypeC_plus_plus_11:
 566   case lldb::eLanguageTypeC_plus_plus_14:
 567     return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
 568   default:
 569     return {lang_type};
 570   }
 571   llvm_unreachable("Fully covered switch");
 572 }
 573
 574 LanguageCategory *
 575 FormatManager::GetCategoryForLanguage(lldb::LanguageType lang_type) {
 576   std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
 577   auto iter = m_language_categories_map.find(lang_type),
 578        end = m_language_categories_map.end();
 579   if (iter != end)
 580     return iter->second.get();
 581   LanguageCategory *lang_category = new LanguageCategory(lang_type);
 582   m_language_categories_map[lang_type] =
 583       LanguageCategory::UniquePointer(lang_category);
 584   return lang_category;
 585 }
 586
 587 template <typename ImplSP>
 588 ImplSP FormatManager::GetHardcoded(FormattersMatchData &match_data) {
 589   ImplSP retval_sp;
 590   for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
 591     if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
 592       if (lang_category->GetHardcoded(*this, match_data, retval_sp))
 593         return retval_sp;
 594     }
 595   }
 596   return retval_sp;
 597 }
 598
 599 namespace {
 600 template <typename ImplSP> const char *FormatterKind;
 601 template <> const char *FormatterKind<lldb::TypeFormatImplSP> = "format";
 602 template <> const char *FormatterKind<lldb::TypeSummaryImplSP> = "summary";
 603 template <> const char *FormatterKind<lldb::SyntheticChildrenSP> = "synthetic";
 604 } // namespace
 605
 606 #define FORMAT_LOG(Message) "[%s] " Message, FormatterKind<ImplSP>
 607
 608 template <typename ImplSP>
 609 ImplSP FormatManager::Get(ValueObject &valobj,
 610                           lldb::DynamicValueType use_dynamic) {
 611   FormattersMatchData match_data(valobj, use_dynamic);
 612   if (ImplSP retval_sp = GetCached<ImplSP>(match_data))
 613     return retval_sp;
 614
 615   Log *log = GetLog(LLDBLog::DataFormatters);
 616
 617   LLDB_LOGF(log, FORMAT_LOG("Search failed. Giving language a chance."));
 618   for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
 619     if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
 620       ImplSP retval_sp;
 621       if (lang_category->Get(match_data, retval_sp))
 622         if (retval_sp) {
 623           LLDB_LOGF(log, FORMAT_LOG("Language search success. Returning."));
 624           return retval_sp;
 625         }
 626     }
 627   }
 628
 629   LLDB_LOGF(log, FORMAT_LOG("Search failed. Giving hardcoded a chance."));
 630   return GetHardcoded<ImplSP>(match_data);
 631 }
 632
 633 template <typename ImplSP>
 634 ImplSP FormatManager::GetCached(FormattersMatchData &match_data) {
 635   ImplSP retval_sp;
 636   Log *log = GetLog(LLDBLog::DataFormatters);
 637   if (match_data.GetTypeForCache()) {
 638     LLDB_LOGF(log, "\n\n" FORMAT_LOG("Looking into cache for type %s"),
 639               match_data.GetTypeForCache().AsCString("<invalid>"));
 640     if (m_format_cache.Get(match_data.GetTypeForCache(), retval_sp)) {
 641       if (log) {
 642         LLDB_LOGF(log, FORMAT_LOG("Cache search success. Returning."));
 643         LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
 644                   m_format_cache.GetCacheHits(),
 645                   m_format_cache.GetCacheMisses());
 646       }
 647       return retval_sp;
 648     }
 649     LLDB_LOGF(log, FORMAT_LOG("Cache search failed. Going normal route"));
 650   }
 651
 652   m_categories_map.Get(match_data, retval_sp);
 653   if (match_data.GetTypeForCache() && (!retval_sp || !retval_sp->NonCacheable())) {
 654     LLDB_LOGF(log, FORMAT_LOG("Caching %p for type %s"),
 655               static_cast<void *>(retval_sp.get()),
 656               match_data.GetTypeForCache().AsCString("<invalid>"));
 657     m_format_cache.Set(match_data.GetTypeForCache(), retval_sp);
 658   }
 659   LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
 660             m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
 661   return retval_sp;
 662 }
 663
 664 #undef FORMAT_LOG
 665
 666 lldb::TypeFormatImplSP
 667 FormatManager::GetFormat(ValueObject &valobj,
 668                          lldb::DynamicValueType use_dynamic) {
 669   return Get<lldb::TypeFormatImplSP>(valobj, use_dynamic);
 670 }
 671
 672 lldb::TypeSummaryImplSP
 673 FormatManager::GetSummaryFormat(ValueObject &valobj,
 674                                 lldb::DynamicValueType use_dynamic) {
 675   return Get<lldb::TypeSummaryImplSP>(valobj, use_dynamic);
 676 }
 677
 678 lldb::SyntheticChildrenSP
 679 FormatManager::GetSyntheticChildren(ValueObject &valobj,
 680                                     lldb::DynamicValueType use_dynamic) {
 681   return Get<lldb::SyntheticChildrenSP>(valobj, use_dynamic);
 682 }
 683
 684 FormatManager::FormatManager()
 685     : m_last_revision(0), m_format_cache(), m_language_categories_mutex(),
 686       m_language_categories_map(), m_named_summaries_map(this),
 687       m_categories_map(this), m_default_category_name(ConstString("default")),
 688       m_system_category_name(ConstString("system")),
 689       m_vectortypes_category_name(ConstString("VectorTypes")) {
 690   LoadSystemFormatters();
 691   LoadVectorFormatters();
 692
 693   EnableCategory(m_vectortypes_category_name, TypeCategoryMap::Last,
 694                  lldb::eLanguageTypeObjC_plus_plus);
 695   EnableCategory(m_system_category_name, TypeCategoryMap::Last,
 696                  lldb::eLanguageTypeObjC_plus_plus);
 697 }
 698
 699 void FormatManager::LoadSystemFormatters() {
 700   TypeSummaryImpl::Flags string_flags;
 701   string_flags.SetCascades(true)
 702       .SetSkipPointers(true)
 703       .SetSkipReferences(false)
 704       .SetDontShowChildren(true)
 705       .SetDontShowValue(false)
 706       .SetShowMembersOneLiner(false)
 707       .SetHideItemNames(false);
 708
 709   TypeSummaryImpl::Flags string_array_flags;
 710   string_array_flags.SetCascades(true)
 711       .SetSkipPointers(true)
 712       .SetSkipReferences(false)
 713       .SetDontShowChildren(true)
 714       .SetDontShowValue(true)
 715       .SetShowMembersOneLiner(false)
 716       .SetHideItemNames(false);
 717
 718   lldb::TypeSummaryImplSP string_format(
 719       new StringSummaryFormat(string_flags, "${var%s}"));
 720
 721   lldb::TypeSummaryImplSP string_array_format(
 722       new StringSummaryFormat(string_array_flags, "${var%char[]}"));
 723
 724   TypeCategoryImpl::SharedPointer sys_category_sp =
 725       GetCategory(m_system_category_name);
 726
 727   sys_category_sp->AddTypeSummary(R"(^(unsigned )?char ?(\*|\[\])$)",
 728                                   eFormatterMatchRegex, string_format);
 729
 730   sys_category_sp->AddTypeSummary(R"(^((un)?signed )?char ?\[[0-9]+\]$)",
 731                                   eFormatterMatchRegex, string_array_format);
 732
 733   lldb::TypeSummaryImplSP ostype_summary(
 734       new StringSummaryFormat(TypeSummaryImpl::Flags()
 735                                   .SetCascades(false)
 736                                   .SetSkipPointers(true)
 737                                   .SetSkipReferences(true)
 738                                   .SetDontShowChildren(true)
 739                                   .SetDontShowValue(false)
 740                                   .SetShowMembersOneLiner(false)
 741                                   .SetHideItemNames(false),
 742                               "${var%O}"));
 743
 744   sys_category_sp->AddTypeSummary("OSType", eFormatterMatchExact,
 745                                   ostype_summary);
 746
 747   TypeFormatImpl::Flags fourchar_flags;
 748   fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(
 749       true);
 750
 751   AddFormat(sys_category_sp, lldb::eFormatOSType, "FourCharCode",
 752             fourchar_flags);
 753 }
 754
 755 void FormatManager::LoadVectorFormatters() {
 756   TypeCategoryImpl::SharedPointer vectors_category_sp =
 757       GetCategory(m_vectortypes_category_name);
 758
 759   TypeSummaryImpl::Flags vector_flags;
 760   vector_flags.SetCascades(true)
 761       .SetSkipPointers(true)
 762       .SetSkipReferences(false)
 763       .SetDontShowChildren(true)
 764       .SetDontShowValue(false)
 765       .SetShowMembersOneLiner(true)
 766       .SetHideItemNames(true);
 767
 768   AddStringSummary(vectors_category_sp, "${var.uint128}", "builtin_type_vec128",
 769                    vector_flags);
 770   AddStringSummary(vectors_category_sp, "", "float[4]", vector_flags);
 771   AddStringSummary(vectors_category_sp, "", "int32_t[4]", vector_flags);
 772   AddStringSummary(vectors_category_sp, "", "int16_t[8]", vector_flags);
 773   AddStringSummary(vectors_category_sp, "", "vDouble", vector_flags);
 774   AddStringSummary(vectors_category_sp, "", "vFloat", vector_flags);
 775   AddStringSummary(vectors_category_sp, "", "vSInt8", vector_flags);
 776   AddStringSummary(vectors_category_sp, "", "vSInt16", vector_flags);
 777   AddStringSummary(vectors_category_sp, "", "vSInt32", vector_flags);
 778   AddStringSummary(vectors_category_sp, "", "vUInt16", vector_flags);
 779   AddStringSummary(vectors_category_sp, "", "vUInt8", vector_flags);
 780   AddStringSummary(vectors_category_sp, "", "vUInt16", vector_flags);
 781   AddStringSummary(vectors_category_sp, "", "vUInt32", vector_flags);
 782   AddStringSummary(vectors_category_sp, "", "vBool32", vector_flags);
 783 }