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