1 files changed, 1043 insertions, 0 deletions

diff --git a/contrib/llvm-project/lldb/source/DataFormatters/FormatManager.cpp b/contrib/llvm-project/lldb/source/DataFormatters/FormatManager.cpp
new file mode 100644
index 000000000000..dd2808a7cf7c
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/DataFormatters/FormatManager.cpp
@@ -0,0 +1,1043 @@
+//===-- FormatManager.cpp ----------------------------------------*- C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/DataFormatters/FormatManager.h"
+
+#include "llvm/ADT/STLExtras.h"
+
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+#include "lldb/DataFormatters/LanguageCategory.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Language.h"
+#include "lldb/Utility/Log.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+struct FormatInfo {
+  Format format;
+  const char format_char;  // One or more format characters that can be used for
+                           // this format.
+  const char *format_name; // Long format name that can be used to specify the
+                           // current format
+};
+
+static FormatInfo g_format_infos[] = {
+    {eFormatDefault, '\0', "default"},
+    {eFormatBoolean, 'B', "boolean"},
+    {eFormatBinary, 'b', "binary"},
+    {eFormatBytes, 'y', "bytes"},
+    {eFormatBytesWithASCII, 'Y', "bytes with ASCII"},
+    {eFormatChar, 'c', "character"},
+    {eFormatCharPrintable, 'C', "printable character"},
+    {eFormatComplexFloat, 'F', "complex float"},
+    {eFormatCString, 's', "c-string"},
+    {eFormatDecimal, 'd', "decimal"},
+    {eFormatEnum, 'E', "enumeration"},
+    {eFormatHex, 'x', "hex"},
+    {eFormatHexUppercase, 'X', "uppercase hex"},
+    {eFormatFloat, 'f', "float"},
+    {eFormatOctal, 'o', "octal"},
+    {eFormatOSType, 'O', "OSType"},
+    {eFormatUnicode16, 'U', "unicode16"},
+    {eFormatUnicode32, '\0', "unicode32"},
+    {eFormatUnsigned, 'u', "unsigned decimal"},
+    {eFormatPointer, 'p', "pointer"},
+    {eFormatVectorOfChar, '\0', "char[]"},
+    {eFormatVectorOfSInt8, '\0', "int8_t[]"},
+    {eFormatVectorOfUInt8, '\0', "uint8_t[]"},
+    {eFormatVectorOfSInt16, '\0', "int16_t[]"},
+    {eFormatVectorOfUInt16, '\0', "uint16_t[]"},
+    {eFormatVectorOfSInt32, '\0', "int32_t[]"},
+    {eFormatVectorOfUInt32, '\0', "uint32_t[]"},
+    {eFormatVectorOfSInt64, '\0', "int64_t[]"},
+    {eFormatVectorOfUInt64, '\0', "uint64_t[]"},
+    {eFormatVectorOfFloat16, '\0', "float16[]"},
+    {eFormatVectorOfFloat32, '\0', "float32[]"},
+    {eFormatVectorOfFloat64, '\0', "float64[]"},
+    {eFormatVectorOfUInt128, '\0', "uint128_t[]"},
+    {eFormatComplexInteger, 'I', "complex integer"},
+    {eFormatCharArray, 'a', "character array"},
+    {eFormatAddressInfo, 'A', "address"},
+    {eFormatHexFloat, '\0', "hex float"},
+    {eFormatInstruction, 'i', "instruction"},
+    {eFormatVoid, 'v', "void"}};
+
+static uint32_t g_num_format_infos = llvm::array_lengthof(g_format_infos);
+
+static bool GetFormatFromFormatChar(char format_char, Format &format) {
+  for (uint32_t i = 0; i < g_num_format_infos; ++i) {
+    if (g_format_infos[i].format_char == format_char) {
+      format = g_format_infos[i].format;
+      return true;
+    }
+  }
+  format = eFormatInvalid;
+  return false;
+}
+
+static bool GetFormatFromFormatName(const char *format_name,
+                                    bool partial_match_ok, Format &format) {
+  uint32_t i;
+  for (i = 0; i < g_num_format_infos; ++i) {
+    if (strcasecmp(g_format_infos[i].format_name, format_name) == 0) {
+      format = g_format_infos[i].format;
+      return true;
+    }
+  }
+
+  if (partial_match_ok) {
+    for (i = 0; i < g_num_format_infos; ++i) {
+      if (strcasestr(g_format_infos[i].format_name, format_name) ==
+          g_format_infos[i].format_name) {
+        format = g_format_infos[i].format;
+        return true;
+      }
+    }
+  }
+  format = eFormatInvalid;
+  return false;
+}
+
+void FormatManager::Changed() {
+  ++m_last_revision;
+  m_format_cache.Clear();
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (auto &iter : m_language_categories_map) {
+    if (iter.second)
+      iter.second->GetFormatCache().Clear();
+  }
+}
+
+bool FormatManager::GetFormatFromCString(const char *format_cstr,
+                                         bool partial_match_ok,
+                                         lldb::Format &format) {
+  bool success = false;
+  if (format_cstr && format_cstr[0]) {
+    if (format_cstr[1] == '\0') {
+      success = GetFormatFromFormatChar(format_cstr[0], format);
+      if (success)
+        return true;
+    }
+
+    success = GetFormatFromFormatName(format_cstr, partial_match_ok, format);
+  }
+  if (!success)
+    format = eFormatInvalid;
+  return success;
+}
+
+char FormatManager::GetFormatAsFormatChar(lldb::Format format) {
+  for (uint32_t i = 0; i < g_num_format_infos; ++i) {
+    if (g_format_infos[i].format == format)
+      return g_format_infos[i].format_char;
+  }
+  return '\0';
+}
+
+const char *FormatManager::GetFormatAsCString(Format format) {
+  if (format >= eFormatDefault && format < kNumFormats)
+    return g_format_infos[format].format_name;
+  return nullptr;
+}
+
+void FormatManager::EnableAllCategories() {
+  m_categories_map.EnableAllCategories();
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (auto &iter : m_language_categories_map) {
+    if (iter.second)
+      iter.second->Enable();
+  }
+}
+
+void FormatManager::DisableAllCategories() {
+  m_categories_map.DisableAllCategories();
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (auto &iter : m_language_categories_map) {
+    if (iter.second)
+      iter.second->Disable();
+  }
+}
+
+void FormatManager::GetPossibleMatches(
+    ValueObject &valobj, CompilerType compiler_type, uint32_t reason,
+    lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
+    bool did_strip_ptr, bool did_strip_ref, bool did_strip_typedef,
+    bool root_level) {
+  compiler_type = compiler_type.GetTypeForFormatters();
+  ConstString type_name(compiler_type.GetConstTypeName());
+  if (valobj.GetBitfieldBitSize() > 0) {
+    StreamString sstring;
+    sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
+    ConstString bitfieldname(sstring.GetString());
+    entries.push_back(
+        {bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef});
+    reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
+  }
+
+  if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
+    entries.push_back(
+        {type_name, reason, did_strip_ptr, did_strip_ref, did_strip_typedef});
+
+    ConstString display_type_name(compiler_type.GetDisplayTypeName());
+    if (display_type_name != type_name)
+      entries.push_back({display_type_name, reason, did_strip_ptr,
+                         did_strip_ref, did_strip_typedef});
+  }
+
+  for (bool is_rvalue_ref = true, j = true;
+       j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
+    CompilerType non_ref_type = compiler_type.GetNonReferenceType();
+    GetPossibleMatches(
+        valobj, non_ref_type,
+        reason |
+            lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
+        use_dynamic, entries, did_strip_ptr, true, did_strip_typedef);
+    if (non_ref_type.IsTypedefType()) {
+      CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
+      deffed_referenced_type =
+          is_rvalue_ref ? deffed_referenced_type.GetRValueReferenceType()
+                        : deffed_referenced_type.GetLValueReferenceType();
+      GetPossibleMatches(
+          valobj, deffed_referenced_type,
+          reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
+          use_dynamic, entries, did_strip_ptr, did_strip_ref,
+          true); // this is not exactly the usual meaning of stripping typedefs
+    }
+  }
+
+  if (compiler_type.IsPointerType()) {
+    CompilerType non_ptr_type = compiler_type.GetPointeeType();
+    GetPossibleMatches(
+        valobj, non_ptr_type,
+        reason |
+            lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
+        use_dynamic, entries, true, did_strip_ref, did_strip_typedef);
+    if (non_ptr_type.IsTypedefType()) {
+      CompilerType deffed_pointed_type =
+          non_ptr_type.GetTypedefedType().GetPointerType();
+      GetPossibleMatches(
+          valobj, deffed_pointed_type,
+          reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
+          use_dynamic, entries, did_strip_ptr, did_strip_ref,
+          true); // this is not exactly the usual meaning of stripping typedefs
+    }
+  }
+
+  for (lldb::LanguageType language_type : GetCandidateLanguages(valobj)) {
+    if (Language *language = Language::FindPlugin(language_type)) {
+      for (ConstString candidate :
+           language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
+        entries.push_back(
+            {candidate,
+             reason | lldb_private::eFormatterChoiceCriterionLanguagePlugin,
+             did_strip_ptr, did_strip_ref, did_strip_typedef});
+      }
+    }
+  }
+
+  // try to strip typedef chains
+  if (compiler_type.IsTypedefType()) {
+    CompilerType deffed_type = compiler_type.GetTypedefedType();
+    GetPossibleMatches(
+        valobj, deffed_type,
+        reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
+        use_dynamic, entries, did_strip_ptr, did_strip_ref, true);
+  }
+
+  if (root_level) {
+    do {
+      if (!compiler_type.IsValid())
+        break;
+
+      CompilerType unqual_compiler_ast_type =
+          compiler_type.GetFullyUnqualifiedType();
+      if (!unqual_compiler_ast_type.IsValid())
+        break;
+      if (unqual_compiler_ast_type.GetOpaqueQualType() !=
+          compiler_type.GetOpaqueQualType())
+        GetPossibleMatches(valobj, unqual_compiler_ast_type, reason,
+                           use_dynamic, entries, did_strip_ptr, did_strip_ref,
+                           did_strip_typedef);
+    } while (false);
+
+    // if all else fails, go to static type
+    if (valobj.IsDynamic()) {
+      lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
+      if (static_value_sp)
+        GetPossibleMatches(
+            *static_value_sp.get(), static_value_sp->GetCompilerType(),
+            reason | lldb_private::eFormatterChoiceCriterionWentToStaticValue,
+            use_dynamic, entries, did_strip_ptr, did_strip_ref,
+            did_strip_typedef, true);
+    }
+  }
+}
+
+lldb::TypeFormatImplSP
+FormatManager::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeFormatImplSP();
+  lldb::TypeFormatImplSP format_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (!category_sp->IsEnabled())
+      continue;
+    lldb::TypeFormatImplSP format_current_sp =
+        category_sp->GetFormatForType(type_sp);
+    if (format_current_sp &&
+        (format_chosen_sp.get() == nullptr ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      format_chosen_sp = format_current_sp;
+    }
+  }
+  return format_chosen_sp;
+}
+
+lldb::TypeSummaryImplSP
+FormatManager::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeSummaryImplSP();
+  lldb::TypeSummaryImplSP summary_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (!category_sp->IsEnabled())
+      continue;
+    lldb::TypeSummaryImplSP summary_current_sp =
+        category_sp->GetSummaryForType(type_sp);
+    if (summary_current_sp &&
+        (summary_chosen_sp.get() == nullptr ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      summary_chosen_sp = summary_current_sp;
+    }
+  }
+  return summary_chosen_sp;
+}
+
+lldb::TypeFilterImplSP
+FormatManager::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeFilterImplSP();
+  lldb::TypeFilterImplSP filter_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (!category_sp->IsEnabled())
+      continue;
+    lldb::TypeFilterImplSP filter_current_sp(
+        (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
+    if (filter_current_sp &&
+        (filter_chosen_sp.get() == nullptr ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      filter_chosen_sp = filter_current_sp;
+    }
+  }
+  return filter_chosen_sp;
+}
+
+lldb::ScriptedSyntheticChildrenSP
+FormatManager::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::ScriptedSyntheticChildrenSP();
+  lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (!category_sp->IsEnabled())
+      continue;
+    lldb::ScriptedSyntheticChildrenSP synth_current_sp(
+        (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
+            .get());
+    if (synth_current_sp &&
+        (synth_chosen_sp.get() == nullptr ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      synth_chosen_sp = synth_current_sp;
+    }
+  }
+  return synth_chosen_sp;
+}
+
+lldb::TypeValidatorImplSP
+FormatManager::GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeValidatorImplSP();
+  lldb::TypeValidatorImplSP validator_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (!category_sp->IsEnabled())
+      continue;
+    lldb::TypeValidatorImplSP validator_current_sp(
+        category_sp->GetValidatorForType(type_sp).get());
+    if (validator_current_sp &&
+        (validator_chosen_sp.get() == nullptr ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      validator_chosen_sp = validator_current_sp;
+    }
+  }
+  return validator_chosen_sp;
+}
+
+void FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback) {
+  m_categories_map.ForEach(callback);
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (const auto &entry : m_language_categories_map) {
+    if (auto category_sp = entry.second->GetCategory()) {
+      if (!callback(category_sp))
+        break;
+    }
+  }
+}
+
+lldb::TypeCategoryImplSP
+FormatManager::GetCategory(ConstString category_name, bool can_create) {
+  if (!category_name)
+    return GetCategory(m_default_category_name);
+  lldb::TypeCategoryImplSP category;
+  if (m_categories_map.Get(category_name, category))
+    return category;
+
+  if (!can_create)
+    return lldb::TypeCategoryImplSP();
+
+  m_categories_map.Add(
+      category_name,
+      lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
+  return GetCategory(category_name);
+}
+
+lldb::Format FormatManager::GetSingleItemFormat(lldb::Format vector_format) {
+  switch (vector_format) {
+  case eFormatVectorOfChar:
+    return eFormatCharArray;
+
+  case eFormatVectorOfSInt8:
+  case eFormatVectorOfSInt16:
+  case eFormatVectorOfSInt32:
+  case eFormatVectorOfSInt64:
+    return eFormatDecimal;
+
+  case eFormatVectorOfUInt8:
+  case eFormatVectorOfUInt16:
+  case eFormatVectorOfUInt32:
+  case eFormatVectorOfUInt64:
+  case eFormatVectorOfUInt128:
+    return eFormatHex;
+
+  case eFormatVectorOfFloat16:
+  case eFormatVectorOfFloat32:
+  case eFormatVectorOfFloat64:
+    return eFormatFloat;
+
+  default:
+    return lldb::eFormatInvalid;
+  }
+}
+
+bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) {
+  // if settings say no oneline whatsoever
+  if (valobj.GetTargetSP().get() &&
+      !valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries())
+    return false; // then don't oneline
+
+  // if this object has a summary, then ask the summary
+  if (valobj.GetSummaryFormat().get() != nullptr)
+    return valobj.GetSummaryFormat()->IsOneLiner();
+
+  // no children, no party
+  if (valobj.GetNumChildren() == 0)
+    return false;
+
+  // ask the type if it has any opinion about this eLazyBoolCalculate == no
+  // opinion; other values should be self explanatory
+  CompilerType compiler_type(valobj.GetCompilerType());
+  if (compiler_type.IsValid()) {
+    switch (compiler_type.ShouldPrintAsOneLiner(&valobj)) {
+    case eLazyBoolNo:
+      return false;
+    case eLazyBoolYes:
+      return true;
+    case eLazyBoolCalculate:
+      break;
+    }
+  }
+
+  size_t total_children_name_len = 0;
+
+  for (size_t idx = 0; idx < valobj.GetNumChildren(); idx++) {
+    bool is_synth_val = false;
+    ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true));
+    // something is wrong here - bail out
+    if (!child_sp)
+      return false;
+
+    // also ask the child's type if it has any opinion
+    CompilerType child_compiler_type(child_sp->GetCompilerType());
+    if (child_compiler_type.IsValid()) {
+      switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get())) {
+      case eLazyBoolYes:
+      // an opinion of yes is only binding for the child, so keep going
+      case eLazyBoolCalculate:
+        break;
+      case eLazyBoolNo:
+        // but if the child says no, then it's a veto on the whole thing
+        return false;
+      }
+    }
+
+    // if we decided to define synthetic children for a type, we probably care
+    // enough to show them, but avoid nesting children in children
+    if (child_sp->GetSyntheticChildren().get() != nullptr) {
+      ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
+      // wait.. wat? just get out of here..
+      if (!synth_sp)
+        return false;
+      // but if we only have them to provide a value, keep going
+      if (!synth_sp->MightHaveChildren() &&
+          synth_sp->DoesProvideSyntheticValue())
+        is_synth_val = true;
+      else
+        return false;
+    }
+
+    total_children_name_len += child_sp->GetName().GetLength();
+
+    // 50 itself is a "randomly" chosen number - the idea is that
+    // overly long structs should not get this treatment
+    // FIXME: maybe make this a user-tweakable setting?
+    if (total_children_name_len > 50)
+      return false;
+
+    // if a summary is there..
+    if (child_sp->GetSummaryFormat()) {
+      // and it wants children, then bail out
+      if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
+        return false;
+    }
+
+    // if this child has children..
+    if (child_sp->GetNumChildren()) {
+      // ...and no summary...
+      // (if it had a summary and the summary wanted children, we would have
+      // bailed out anyway
+      //  so this only makes us bail out if this has no summary and we would
+      //  then print children)
+      if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do
+                                                          // that if not a
+                                                          // synthetic valued
+                                                          // child
+        return false;                                     // then bail out
+    }
+  }
+  return true;
+}
+
+ConstString FormatManager::GetValidTypeName(ConstString type) {
+  return ::GetValidTypeName_Impl(type);
+}
+
+ConstString FormatManager::GetTypeForCache(ValueObject &valobj,
+                                           lldb::DynamicValueType use_dynamic) {
+  ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(
+      use_dynamic, valobj.IsSynthetic());
+  if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) {
+    if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
+      return valobj_sp->GetQualifiedTypeName();
+  }
+  return ConstString();
+}
+
+std::vector<lldb::LanguageType>
+FormatManager::GetCandidateLanguages(ValueObject &valobj) {
+  lldb::LanguageType lang_type = valobj.GetObjectRuntimeLanguage();
+  return GetCandidateLanguages(lang_type);
+}
+
+std::vector<lldb::LanguageType>
+FormatManager::GetCandidateLanguages(lldb::LanguageType lang_type) {
+  switch (lang_type) {
+  case lldb::eLanguageTypeC:
+  case lldb::eLanguageTypeC89:
+  case lldb::eLanguageTypeC99:
+  case lldb::eLanguageTypeC11:
+  case lldb::eLanguageTypeC_plus_plus:
+  case lldb::eLanguageTypeC_plus_plus_03:
+  case lldb::eLanguageTypeC_plus_plus_11:
+  case lldb::eLanguageTypeC_plus_plus_14:
+    return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
+  default:
+    return {lang_type};
+  }
+}
+
+LanguageCategory *
+FormatManager::GetCategoryForLanguage(lldb::LanguageType lang_type) {
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  auto iter = m_language_categories_map.find(lang_type),
+       end = m_language_categories_map.end();
+  if (iter != end)
+    return iter->second.get();
+  LanguageCategory *lang_category = new LanguageCategory(lang_type);
+  m_language_categories_map[lang_type] =
+      LanguageCategory::UniquePointer(lang_category);
+  return lang_category;
+}
+
+lldb::TypeFormatImplSP
+FormatManager::GetHardcodedFormat(FormattersMatchData &match_data) {
+  TypeFormatImplSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
+    }
+  }
+
+  return retval_sp;
+}
+
+lldb::TypeFormatImplSP
+FormatManager::GetFormat(ValueObject &valobj,
+                         lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  TypeFormatImplSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf(
+          "\n\n[FormatManager::GetFormat] Looking into cache for type %s",
+          match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetFormat(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf(
+            "[FormatManager::GetFormat] Cache search success. Returning.");
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+                  m_format_cache.GetCacheHits(),
+                  m_format_cache.GetCacheMisses());
+      }
+      return retval;
+    }
+    if (log)
+      log->Printf(
+          "[FormatManager::GetFormat] Cache search failed. Going normal route");
+  }
+
+  retval = m_categories_map.GetFormat(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetFormat] Search failed. Giving language a "
+                  "chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
+    }
+    if (retval) {
+      if (log)
+        log->Printf(
+            "[FormatManager::GetFormat] Language search success. Returning.");
+      return retval;
+    }
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetFormat] Search failed. Giving hardcoded "
+                  "a chance.");
+    retval = GetHardcodedFormat(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf("[FormatManager::GetFormat] Caching %p for type %s",
+                  static_cast<void *>(retval.get()),
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetFormat(match_data.GetTypeForCache(), retval);
+  }
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+            m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
+}
+
+lldb::TypeSummaryImplSP
+FormatManager::GetHardcodedSummaryFormat(FormattersMatchData &match_data) {
+  TypeSummaryImplSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
+    }
+  }
+
+  return retval_sp;
+}
+
+lldb::TypeSummaryImplSP
+FormatManager::GetSummaryFormat(ValueObject &valobj,
+                                lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  TypeSummaryImplSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf("\n\n[FormatManager::GetSummaryFormat] Looking into cache "
+                  "for type %s",
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetSummary(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf("[FormatManager::GetSummaryFormat] Cache search success. "
+                    "Returning.");
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+                  m_format_cache.GetCacheHits(),
+                  m_format_cache.GetCacheMisses());
+      }
+      return retval;
+    }
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Cache search failed. "
+                  "Going normal route");
+  }
+
+  retval = m_categories_map.GetSummaryFormat(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving "
+                  "language a chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
+    }
+    if (retval) {
+      if (log)
+        log->Printf("[FormatManager::GetSummaryFormat] Language search "
+                    "success. Returning.");
+      return retval;
+    }
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving "
+                  "hardcoded a chance.");
+    retval = GetHardcodedSummaryFormat(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Caching %p for type %s",
+                  static_cast<void *>(retval.get()),
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetSummary(match_data.GetTypeForCache(), retval);
+  }
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+            m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
+}
+
+lldb::SyntheticChildrenSP
+FormatManager::GetHardcodedSyntheticChildren(FormattersMatchData &match_data) {
+  SyntheticChildrenSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
+    }
+  }
+
+  return retval_sp;
+}
+
+lldb::SyntheticChildrenSP
+FormatManager::GetSyntheticChildren(ValueObject &valobj,
+                                    lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  SyntheticChildrenSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf("\n\n[FormatManager::GetSyntheticChildren] Looking into "
+                  "cache for type %s",
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf("[FormatManager::GetSyntheticChildren] Cache search "
+                    "success. Returning.");
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+                  m_format_cache.GetCacheHits(),
+                  m_format_cache.GetCacheMisses());
+      }
+      return retval;
+    }
+    if (log)
+      log->Printf("[FormatManager::GetSyntheticChildren] Cache search failed. "
+                  "Going normal route");
+  }
+
+  retval = m_categories_map.GetSyntheticChildren(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving "
+                  "language a chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
+    }
+    if (retval) {
+      if (log)
+        log->Printf("[FormatManager::GetSyntheticChildren] Language search "
+                    "success. Returning.");
+      return retval;
+    }
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving "
+                  "hardcoded a chance.");
+    retval = GetHardcodedSyntheticChildren(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf(
+          "[FormatManager::GetSyntheticChildren] Caching %p for type %s",
+          static_cast<void *>(retval.get()),
+          match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetSynthetic(match_data.GetTypeForCache(), retval);
+  }
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+            m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
+}
+
+lldb::TypeValidatorImplSP
+FormatManager::GetValidator(ValueObject &valobj,
+                            lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  TypeValidatorImplSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf(
+          "\n\n[FormatManager::GetValidator] Looking into cache for type %s",
+          match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetValidator(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf(
+            "[FormatManager::GetValidator] Cache search success. Returning.");
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+                  m_format_cache.GetCacheHits(),
+                  m_format_cache.GetCacheMisses());
+      }
+      return retval;
+    }
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Cache search failed. Going "
+                  "normal route");
+  }
+
+  retval = m_categories_map.GetValidator(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Search failed. Giving "
+                  "language a chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
+    }
+    if (retval) {
+      if (log)
+        log->Printf("[FormatManager::GetValidator] Language search success. "
+                    "Returning.");
+      return retval;
+    }
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Search failed. Giving "
+                  "hardcoded a chance.");
+    retval = GetHardcodedValidator(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Caching %p for type %s",
+                  static_cast<void *>(retval.get()),
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetValidator(match_data.GetTypeForCache(), retval);
+  }
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+            m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
+}
+
+lldb::TypeValidatorImplSP
+FormatManager::GetHardcodedValidator(FormattersMatchData &match_data) {
+  TypeValidatorImplSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
+    }
+  }
+
+  return retval_sp;
+}
+
+FormatManager::FormatManager()
+    : m_last_revision(0), m_format_cache(), m_language_categories_mutex(),
+      m_language_categories_map(), m_named_summaries_map(this),
+      m_categories_map(this), m_default_category_name(ConstString("default")),
+      m_system_category_name(ConstString("system")),
+      m_vectortypes_category_name(ConstString("VectorTypes")) {
+  LoadSystemFormatters();
+  LoadVectorFormatters();
+
+  EnableCategory(m_vectortypes_category_name, TypeCategoryMap::Last,
+                 lldb::eLanguageTypeObjC_plus_plus);
+  EnableCategory(m_system_category_name, TypeCategoryMap::Last,
+                 lldb::eLanguageTypeObjC_plus_plus);
+}
+
+void FormatManager::LoadSystemFormatters() {
+  TypeSummaryImpl::Flags string_flags;
+  string_flags.SetCascades(true)
+      .SetSkipPointers(true)
+      .SetSkipReferences(false)
+      .SetDontShowChildren(true)
+      .SetDontShowValue(false)
+      .SetShowMembersOneLiner(false)
+      .SetHideItemNames(false);
+
+  TypeSummaryImpl::Flags string_array_flags;
+  string_array_flags.SetCascades(true)
+      .SetSkipPointers(true)
+      .SetSkipReferences(false)
+      .SetDontShowChildren(true)
+      .SetDontShowValue(true)
+      .SetShowMembersOneLiner(false)
+      .SetHideItemNames(false);
+
+  lldb::TypeSummaryImplSP string_format(
+      new StringSummaryFormat(string_flags, "${var%s}"));
+
+  lldb::TypeSummaryImplSP string_array_format(
+      new StringSummaryFormat(string_array_flags, "${var%s}"));
+
+  lldb::RegularExpressionSP any_size_char_arr(
+      new RegularExpression(llvm::StringRef("char \\[[0-9]+\\]")));
+  lldb::RegularExpressionSP any_size_wchar_arr(
+      new RegularExpression(llvm::StringRef("wchar_t \\[[0-9]+\\]")));
+
+  TypeCategoryImpl::SharedPointer sys_category_sp =
+      GetCategory(m_system_category_name);
+
+  sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"),
+                                                    string_format);
+  sys_category_sp->GetTypeSummariesContainer()->Add(
+      ConstString("unsigned char *"), string_format);
+  sys_category_sp->GetRegexTypeSummariesContainer()->Add(any_size_char_arr,
+                                                         string_array_format);
+
+  lldb::TypeSummaryImplSP ostype_summary(
+      new StringSummaryFormat(TypeSummaryImpl::Flags()
+                                  .SetCascades(false)
+                                  .SetSkipPointers(true)
+                                  .SetSkipReferences(true)
+                                  .SetDontShowChildren(true)
+                                  .SetDontShowValue(false)
+                                  .SetShowMembersOneLiner(false)
+                                  .SetHideItemNames(false),
+                              "${var%O}"));
+
+  sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"),
+                                                    ostype_summary);
+
+  TypeFormatImpl::Flags fourchar_flags;
+  fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(
+      true);
+
+  AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"),
+            fourchar_flags);
+}
+
+void FormatManager::LoadVectorFormatters() {
+  TypeCategoryImpl::SharedPointer vectors_category_sp =
+      GetCategory(m_vectortypes_category_name);
+
+  TypeSummaryImpl::Flags vector_flags;
+  vector_flags.SetCascades(true)
+      .SetSkipPointers(true)
+      .SetSkipReferences(false)
+      .SetDontShowChildren(true)
+      .SetDontShowValue(false)
+      .SetShowMembersOneLiner(true)
+      .SetHideItemNames(true);
+
+  AddStringSummary(vectors_category_sp, "${var.uint128}",
+                   ConstString("builtin_type_vec128"), vector_flags);
+
+  AddStringSummary(vectors_category_sp, "", ConstString("float [4]"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("int32_t [4]"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("int16_t [8]"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vDouble"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vFloat"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vSInt8"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vSInt16"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vSInt32"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vUInt8"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vUInt32"),
+                   vector_flags);
+  AddStringSummary(vectors_category_sp, "", ConstString("vBool32"),
+                   vector_flags);
+}