Extend FindTypes w/ CompilerContext to allow filtering by language

[aprantl]

Summary

This patch is also motivated by the Swift branch and is effectively NFC for the single-TypeSystem llvm.org branch.

In multi-language projects it is extremely common to have, e.g., a Clang type and a similarly-named rendition of that same type in another language. When searching for a type It is much cheaper to pass a set of supported languages to the SymbolFile than having it materialize every result and then rejecting the materialized types that have the wrong language.

[JDevlieghere]

I think the functionality is fine.

I know this is a little ironic, given that we just had this discussion, but I would propose wrapping the SmallBitVector here. That way you can abstracting away the details about the underlying enum values, the size, and make the whole thing type safe. Although I agree with Pavel's earlier comment, I think subclassing might even be a good fit, so that you don't have to wrap the operator and set methods, but either having the SmallBitVector as a member is fine with me too.

lldb/source/Symbol/ClangASTContext.cpp

806

Let's add a comment why you choose 64-8 and why we can't use those last 8 bits.

[aprantl]

I also just discovered void ClangASTContext::EnumerateSupportedLanguages() and will incorporate that into the next revision, too.

[aprantl]

Address review feedback.

(This was quite a trip down the rabbit hole, but on the plus side I got to remove a few (now) completely useless callback APIs).

[JDevlieghere]

This looks like a great improvement. Thanks for working on this!

lldb/include/lldb/Core/PluginManager.h

400

🤔

423

🙄

lldb/source/Core/Debugger.cpp

1628–1630

Let's wrap this check and the find_first call into a method that returns an llvm::Optional< LanguageType>?

[aprantl]

More feedback from Jonas.

[JDevlieghere]

This LGTM, unless Pavel has comments.

[labath]

The functionality seems fine, and I like how you got rid of the extra callbacks in the plugin manager in favour of passing the sets explicitly. I'm not really a fan of inheriting from standard containers. And though the motivation here is stronger than in the previous case, it is not without its problems -- for instance half of this patch uses the new LanguageSet type, whereas the other (SymbolFile::FindTypes) still uses llvm::SmallBitVector. This also nicely demonstrates the main problem with inheriting from classes which aren't meant to be inherited (that they can be accidentally sliced) and means that this isn't as type safe as one might hope..

Now, I am not sure what all of that means here. This functionality is not so widespread that it makes sense to develop a full-blown class to do what you need here, so it may be best to just go with what you have here, and possibly rework this if it becomes more widespread in the future.... It's a pitty that std::bitset does not have a richer interface for accessing the bits. Otherwise, you could just do typedef std::bitset<eNumLanguages> LanguageSet and be done with it..

lldb/source/Symbol/TypeSystem.cpp

36–37

Will this work correctly on big endian too?

[aprantl]

Here's an improved version:

• got rid of the completely unnecessary optimization that use memcpy
• made the struct have a SmallBitVector member instead of inheriting from it.

The new struct has an LLVM-like interface for many use-cases, and still exposes the bitvector where necessary, but is explicit about it.

[clayborg]

Looks good overall. Just a question of it we want to return "const LanguageSet &" to avoid copies. Also switch static functions that currently return "LanguageSet" over to use static variables and llvm::once to init them and then return "const LanguageSet &".

lldb/include/lldb/Target/Language.h

269–271

return a "const LanguageSet &" to avoid copies?

lldb/source/Core/Debugger.cpp

1626

"const LanguageSet &" to avoid copies?

lldb/source/Core/PluginManager.cpp

2172

Add a LanguageSet method to do this? We are playing with internals here. Maybe:

all.Merge(instances[i]);

2265–2266

This function is static. Should we return a "const LanguageSet &" here? Also use std::once/llvm::once?:

static LanguageSet g_langs;
std::once once(...) {
  ... do work to populate
});
return g_langs;

lldb/source/Interpreter/OptionValueLanguage.cpp

43

"const LanguageSet &"?

lldb/source/Symbol/ClangASTContext.cpp

737

return "const LanguageSet &"? Then make "static LanguageSet g_languages;" and use llvm::once to control one time init?

754

return "const LanguageSet &"? Then make "static LanguageSet g_languages;" and use llvm::once to control one time init?

[aprantl]

Looks good overall. Just a question of it we want to return "const LanguageSet &" to avoid copies. Also switch static functions that currently return "LanguageSet" over to use static variables and llvm::once to init them and then return "const LanguageSet &".

The point of the static_assert in TypeSystem.cpp is to make sure that a LanguageSet is exactly 64 bits in size so it is cheap to pass it by value.

[aprantl]

In D66546#1641435, @aprantl wrote:

Looks good overall. Just a question of it we want to return "const LanguageSet &" to avoid copies. Also switch static functions that currently return "LanguageSet" over to use static variables and llvm::once to init them and then return "const LanguageSet &".

The point of the static_assert in TypeSystem.cpp is to make sure that a LanguageSet is exactly 64 bits in size so it is cheap to pass it by value.

Actually, on a 64-bit system it is *always* 64 bits in size, but the static_assert guarantees that no memory is allocated.

[clayborg]

Sounds good about LanguageSet being cheap to pass by value. Are there any paths that will call this over and over where we still will be calculating the LangaugeSet over and over in a type system? We might benefit from using llvm::once and a static LanguageSet in the static functions that return LanguageSets if that is the case?

[aprantl]

In D66546#1641492, @clayborg wrote:

Sounds good about LanguageSet being cheap to pass by value. Are there any paths that will call this over and over where we still will be calculating the LangaugeSet over and over in a type system? We might benefit from using llvm::once and a static LanguageSet in the static functions that return LanguageSets if that is the case?

No, the most "expensive" function is ClangASTContext::GetSupportedLanguagesForTypes() which is called once by the ClangASTContext constructor.

[aprantl]

In D66546#1641534, @aprantl wrote:

No, the most "expensive" function is ClangASTContext::GetSupportedLanguagesForTypes() which is called once by the ClangASTContext constructor.

... "expensive" in quotes, because a sufficiently smart compiler should optimize it into returning a 64-bit constant.

[labath]

This sounds like a good compromise.

lldb/include/lldb/Symbol/SymbolFile.h

197

Is there a reason for using a SmallBitVector instead of the LanguageSet type here?

[aprantl]

lldb/include/lldb/Symbol/SymbolFile.h

197

No! Thanks. That's a leftover.

[stella.stamenova]

It looks like this broke the windows build bot:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/8120

[aprantl]

Yeah, I'm trying to get behind what happened there, but I may need some help later on.

[aprantl]

Looks like this also broke other platforms, which is good because I can debug it! I reverted the patch for now.

[aprantl]

Turns out I accidentally deleted the constructor of LanguageSet in my very last refactoring.

lldb/include/lldb/Core/PluginManager.h

public:
 
   static InstrumentationRuntimeCreateInstance
   GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx);
 
   static InstrumentationRuntimeCreateInstance
   GetInstrumentationRuntimeCreateCallbackForPluginName(ConstString name);
 
   // TypeSystem
-  static bool RegisterPlugin(
-      ConstString name, const char *description,
+  static bool RegisterPlugin(ConstString name, const char *description,
                              TypeSystemCreateInstance create_callback,
-      TypeSystemEnumerateSupportedLanguages enumerate_languages_callback);
+                             LanguageSet supported_languages_for_types,
+                             LanguageSet supported_languages_for_expressions);
 
   static bool UnregisterPlugin(TypeSystemCreateInstance create_callback);
 
   static TypeSystemCreateInstance
   GetTypeSystemCreateCallbackAtIndex(uint32_t idx);
 
   static TypeSystemCreateInstance
   GetTypeSystemCreateCallbackForPluginName(ConstString name);
 
-  static TypeSystemEnumerateSupportedLanguages
-  GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx);
+  static LanguageSet GetAllTypeSystemSupportedLanguagesForTypes();
 
-  static TypeSystemEnumerateSupportedLanguages
-  GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName(
-      ConstString name);
+  static LanguageSet GetAllTypeSystemSupportedLanguagesForExpressions();
 
   // REPL
-  static bool
-  RegisterPlugin(ConstString name, const char *description,
+  static bool RegisterPlugin(ConstString name, const char *description,
                              REPLCreateInstance create_callback,
-                 REPLEnumerateSupportedLanguages enumerate_languages_callback);
+                             LanguageSet supported_languages);
 
   static bool UnregisterPlugin(REPLCreateInstance create_callback);
 
   static REPLCreateInstance GetREPLCreateCallbackAtIndex(uint32_t idx);
 
   static REPLCreateInstance
   GetREPLCreateCallbackForPluginName(ConstString name);
 
-  static REPLEnumerateSupportedLanguages
-  GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx);
-
-  static REPLEnumerateSupportedLanguages
-  GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName(
-      ConstString name);
+  static LanguageSet GetREPLAllTypeSystemSupportedLanguages();
 
   // Some plug-ins might register a DebuggerInitializeCallback callback when
   // registering the plug-in. After a new Debugger instance is created, this
   // DebuggerInitialize function will get called. This allows plug-ins to
   // install Properties and do any other initialization that requires a
   // debugger instance.
   static void DebuggerInitialize(Debugger &debugger);
 
   static lldb::OptionValuePropertiesSP
   GetSettingForDynamicLoaderPlugin(Debugger &debugger,
                                    ConstString setting_name);
 
   static bool CreateSettingForDynamicLoaderPlugin(
       Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
       ConstString description, bool is_global_property);
 
   static lldb::OptionValuePropertiesSP
-  GetSettingForPlatformPlugin(Debugger &debugger,
-                              ConstString setting_name);
+  GetSettingForPlatformPlugin(Debugger &debugger, ConstString setting_name);
 
   static bool CreateSettingForPlatformPlugin(
       Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
       ConstString description, bool is_global_property);
 
   static lldb::OptionValuePropertiesSP
-  GetSettingForProcessPlugin(Debugger &debugger,
-                             ConstString setting_name);
+  GetSettingForProcessPlugin(Debugger &debugger, ConstString setting_name);
 
   static bool CreateSettingForProcessPlugin(
       Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
       ConstString description, bool is_global_property);
 
   static lldb::OptionValuePropertiesSP
-  GetSettingForSymbolFilePlugin(Debugger &debugger,
-                                ConstString setting_name);
+  GetSettingForSymbolFilePlugin(Debugger &debugger, ConstString setting_name);
 
   static bool CreateSettingForSymbolFilePlugin(
       Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
       ConstString description, bool is_global_property);
 
   static lldb::OptionValuePropertiesSP
-  GetSettingForJITLoaderPlugin(Debugger &debugger,
-                               ConstString setting_name);
+  GetSettingForJITLoaderPlugin(Debugger &debugger, ConstString setting_name);
 
   static bool CreateSettingForJITLoaderPlugin(
       Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
       ConstString description, bool is_global_property);
 
   static lldb::OptionValuePropertiesSP
   GetSettingForOperatingSystemPlugin(Debugger &debugger,
                                      ConstString setting_name);

lldb/include/lldb/Symbol/ClangASTContext.h

public:
 
   uint32_t GetPluginVersion() override;
 
   static ConstString GetPluginNameStatic();
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Module *module, Target *target);
 
-  static void EnumerateSupportedLanguages(
-      std::set<lldb::LanguageType> &languages_for_types,
-      std::set<lldb::LanguageType> &languages_for_expressions);
+  static LanguageSet GetSupportedLanguagesForTypes();
+  static LanguageSet GetSupportedLanguagesForExpressions();
 
   static void Initialize();
 
   static void Terminate();
 
   static ClangASTContext *GetASTContext(clang::ASTContext *ast_ctx);
 
   clang::ASTContext *getASTContext();

lldb/include/lldb/Symbol/SymbolFile.h

 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SmallBitVector.h"
 
 #include <mutex>
 
 #if defined(LLDB_CONFIGURATION_DEBUG)
 #define ASSERT_MODULE_LOCK(expr) (expr->AssertModuleLock())
 #else
 #define ASSERT_MODULE_LOCK(expr) ((void)0)
 #endif
public:
   virtual uint32_t FindFunctions(const RegularExpression &regex,
                                  bool include_inlines, bool append,
                                  SymbolContextList &sc_list);
   virtual uint32_t
   FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             TypeMap &types);
-  virtual size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern, bool append,
+
+  /// Find types specified by a CompilerContextPattern.
+  /// \param languages    Only return results in these languages.
+  virtual size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern,
+                           llvm::SmallBitVector languages, bool append,
                            TypeMap &types);
 
   virtual void
   GetMangledNamesForFunction(const std::string &scope_qualified_name,
                              std::vector<ConstString> &mangled_names);
 
   virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                           lldb::TypeClass type_mask,

lldb/include/lldb/Symbol/TypeSystem.h

 #define liblldb_TypeSystem_h_
 
 #include <functional>
 #include <map>
 #include <mutex>
 #include <string>
 
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/SmallBitVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-private.h"
 
 class DWARFDIE;
 class DWARFASTParser;
 class PDBASTParser;
 
 namespace lldb_private {
 
-// Interface for representing the Type Systems in different languages.
+/// A SmallBitVector that represents a set of source languages (\p
+/// lldb::LanguageType).  Each lldb::LanguageType is represented by
+/// the bit with the position of its enumerator. The largest
+/// LanguageType is < 64, so this is space-efficient and on 64-bit
+/// architectures a LanguageSet can be completely stack-allocated.
+struct LanguageSet {
+  llvm::SmallBitVector bitvector;
+  LanguageSet() = default;
+
+  /// If the set contains a single language only, return it.
+  llvm::Optional<lldb::LanguageType> GetSingularLanguage();
+  void Insert(lldb::LanguageType language);
+  bool Empty() const;
+  size_t Size() const;
+  bool operator[](unsigned i) const;
+};
+
+/// Interface for representing the Type Systems in different languages.
 class TypeSystem : public PluginInterface {
 public:
   // Intrusive type system that allows us to use llvm casting.
   //
   // To add a new type system:
   //
   // 1 - Add a new enumeration for llvm casting below for your TypeSystem
   //     subclass, here we will use eKindFoo

lldb/include/lldb/Target/Language.h

public:
   static bool LanguageIsPascal(lldb::LanguageType language);
 
   // return the primary language, so if LanguageIsC(l), return eLanguageTypeC,
   // etc.
   static lldb::LanguageType GetPrimaryLanguage(lldb::LanguageType language);
 
   static std::set<lldb::LanguageType> GetSupportedLanguages();
 
-  static void GetLanguagesSupportingTypeSystems(
-      std::set<lldb::LanguageType> &languages,
-      std::set<lldb::LanguageType> &languages_for_expressions);
-
-  static void
-  GetLanguagesSupportingREPLs(std::set<lldb::LanguageType> &languages);
+  static LanguageSet GetLanguagesSupportingTypeSystems();
+  static LanguageSet GetLanguagesSupportingTypeSystemsForExpressions();
+  static LanguageSet GetLanguagesSupportingREPLs();
 
 protected:
   // Classes that inherit from Language can see and modify these
 
   Language();
 
 private:
   DISALLOW_COPY_AND_ASSIGN(Language);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Language_h_

lldb/include/lldb/lldb-private-interfaces.h

 typedef lldb::InstrumentationRuntimeSP (*InstrumentationRuntimeCreateInstance)(
     const lldb::ProcessSP &process_sp);
 typedef lldb::TypeSystemSP (*TypeSystemCreateInstance)(
     lldb::LanguageType language, Module *module, Target *target);
 typedef lldb::REPLSP (*REPLCreateInstance)(Status &error,
                                            lldb::LanguageType language,
                                            Debugger *debugger, Target *target,
                                            const char *repl_options);
-typedef void (*TypeSystemEnumerateSupportedLanguages)(
-    std::set<lldb::LanguageType> &languages_for_types,
-    std::set<lldb::LanguageType> &languages_for_expressions);
-typedef void (*REPLEnumerateSupportedLanguages)(
-    std::set<lldb::LanguageType> &languages);
 typedef int (*ComparisonFunction)(const void *, const void *);
 typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // liblldb_lldb_private_interfaces_h_

lldb/lit/SymbolFile/DWARF/compilercontext.ll

 ; Test finding types by CompilerContext.
 ; RUN: llc %s -filetype=obj -o %t.o
-; RUN: lldb-test symbols %t.o -find=type \
+; RUN: lldb-test symbols %t.o -find=type --language=C99 \
 ; RUN:   -compiler-context="Module:CModule,Module:SubModule,Struct:FromSubmoduleX" \
 ; RUN:   | FileCheck %s --check-prefix=NORESULTS
-; RUN: lldb-test symbols %t.o -find=type \
+; RUN: lldb-test symbols %t.o -find=type --language=C++ \
+; RUN:   -compiler-context="Module:CModule,Module:SubModule,Struct:FromSubmodule" \
+; RUN:   | FileCheck %s --check-prefix=NORESULTS
+; RUN: lldb-test symbols %t.o -find=type --language=C99 \
 ; RUN:   -compiler-context="Module:CModule,Module:SubModule,Struct:FromSubmodule" \
 ; RUN:   | FileCheck %s
-; RUN: lldb-test symbols %t.o -find=type \
+; RUN: lldb-test symbols %t.o -find=type --language=C99 \
 ; RUN:   -compiler-context="Module:CModule,AnyModule:*,Struct:FromSubmodule" \
 ; RUN:   | FileCheck %s
-; RUN: lldb-test symbols %t.o -find=type \
+; RUN: lldb-test symbols %t.o -find=type --language=C99 \
 ; RUN:   -compiler-context="AnyModule:*,Struct:FromSubmodule" \
 ; RUN:   | FileCheck %s
-; RUN: lldb-test symbols %t.o -find=type \
+; RUN: lldb-test symbols %t.o -find=type --language=C99 \
 ; RUN:   -compiler-context="Module:CModule,Module:SubModule,AnyType:FromSubmodule" \
 ; RUN:   | FileCheck %s
 ;
 ; NORESULTS: Found 0 types
 ; CHECK: Found 1 types:
 ; CHECK: struct FromSubmodule {
 ; CHECK-NEXT:     unsigned int x;
 ; CHECK-NEXT:     unsigned int y;

lldb/source/Core/Debugger.cpp

Target *Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) {
   return GetDummyTarget();
 }
 
 Status Debugger::RunREPL(LanguageType language, const char *repl_options) {
   Status err;
   FileSpec repl_executable;
 
   if (language == eLanguageTypeUnknown) {
-    std::set<LanguageType> repl_languages;
+    LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();
 
-    Language::GetLanguagesSupportingREPLs(repl_languages);
-
-    if (repl_languages.size() == 1) {
-      language = *repl_languages.begin();
-    } else if (repl_languages.empty()) {
+    if (auto single_lang = repl_languages.GetSingularLanguage()) {
+      language = *single_lang;
+    } else if (repl_languages.Empty()) {
       err.SetErrorStringWithFormat(
           "LLDB isn't configured with REPL support for any languages.");
       return err;
     } else {
       err.SetErrorStringWithFormat(
           "Multiple possible REPL languages.  Please specify a language.");
       return err;
     }

lldb/source/Core/PluginManager.cpp

if (name) {
     }
   }
   return nullptr;
 }
 
 #pragma mark TypeSystem
 
 struct TypeSystemInstance {
-  TypeSystemInstance() : name(), description(), create_callback(nullptr) {}
-
   ConstString name;
   std::string description;
   TypeSystemCreateInstance create_callback;
-  TypeSystemEnumerateSupportedLanguages enumerate_callback;
+  LanguageSet supported_languages_for_types;
+  LanguageSet supported_languages_for_expressions;
 };
 
 typedef std::vector<TypeSystemInstance> TypeSystemInstances;
 
 static std::recursive_mutex &GetTypeSystemMutex() {
   static std::recursive_mutex g_instances_mutex;
   return g_instances_mutex;
 }
 
 static TypeSystemInstances &GetTypeSystemInstances() {
   static TypeSystemInstances g_instances;
   return g_instances;
 }
 
-bool PluginManager::RegisterPlugin(ConstString name,
-                                   const char *description,
-                                   TypeSystemCreateInstance create_callback,
-                                   TypeSystemEnumerateSupportedLanguages
-                                       enumerate_supported_languages_callback) {
+bool PluginManager::RegisterPlugin(
+    ConstString name, const char *description,
+    LanguageSet supported_languages_for_types,
+    LanguageSet supported_languages_for_expressions) {
   if (create_callback) {
     TypeSystemInstance instance;
     assert((bool)name);
     instance.name = name;
     if (description && description[0])
       instance.description = description;
     instance.create_callback = create_callback;
-    instance.enumerate_callback = enumerate_supported_languages_callback;
+    instance.supported_languages_for_types = supported_languages_for_types;
+    instance.supported_languages_for_expressions = supported_languages_for_expressions;
     std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
     GetTypeSystemInstances().push_back(instance);
   }
   return false;
 }
 
 bool PluginManager::UnregisterPlugin(TypeSystemCreateInstance create_callback) {
   if (create_callback) {
if (name) {
     for (pos = instances.begin(); pos != end; ++pos) {
       if (name == pos->name)
         return pos->create_callback;
     }
   }
   return nullptr;
 }
 
-TypeSystemEnumerateSupportedLanguages
-PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(
-    uint32_t idx) {
+LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForTypes() {
   std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
+  LanguageSet all;
   TypeSystemInstances &instances = GetTypeSystemInstances();
-  if (idx < instances.size())
-    return instances[idx].enumerate_callback;
-  return nullptr;
+  for (unsigned i = 0; i < instances.size(); ++i)
+    all.bitvector |= instances[i].supported_languages_for_types.bitvector;
+  return all;
 }
 
-TypeSystemEnumerateSupportedLanguages
-PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName(
-    ConstString name) {
-  if (name) {
-    std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
-    TypeSystemInstances &instances = GetTypeSystemInstances();
-
-    TypeSystemInstances::iterator pos, end = instances.end();
-    for (pos = instances.begin(); pos != end; ++pos) {
-      if (name == pos->name)
-        return pos->enumerate_callback;
-    }
-  }
-  return nullptr;
+LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions() {
+  LanguageSet all;
+  for (unsigned i = 0; i < instances.size(); ++i)
+    all.bitvector |= instances[i].supported_languages_for_expressions.bitvector;
+  return all;
 }
 
 #pragma mark REPL
 
 struct REPLInstance {
   REPLInstance() : name(), description(), create_callback(nullptr) {}
 
   ConstString name;
   std::string description;
   REPLCreateInstance create_callback;
-  REPLEnumerateSupportedLanguages enumerate_languages_callback;
+  LanguageSet supported_languages;
 };
 
 typedef std::vector<REPLInstance> REPLInstances;
 
 static std::recursive_mutex &GetREPLMutex() {
   static std::recursive_mutex g_instances_mutex;
   return g_instances_mutex;
 }
 
 static REPLInstances &GetREPLInstances() {
   static REPLInstances g_instances;
   return g_instances;
 }
 
-bool PluginManager::RegisterPlugin(
-    ConstString name, const char *description,
+bool PluginManager::RegisterPlugin(ConstString name, const char *description,
                                    REPLCreateInstance create_callback,
-    REPLEnumerateSupportedLanguages enumerate_languages_callback) {
+                                   LanguageSet supported_languages) {
   if (create_callback) {
     REPLInstance instance;
     assert((bool)name);
     instance.name = name;
     if (description && description[0])
       instance.description = description;
     instance.create_callback = create_callback;
-    instance.enumerate_languages_callback = enumerate_languages_callback;
+    instance.supported_languages = supported_languages;
     std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
     GetREPLInstances().push_back(instance);
   }
   return false;
 }
 
 bool PluginManager::UnregisterPlugin(REPLCreateInstance create_callback) {
   if (create_callback) {
if (name) {
     for (pos = instances.begin(); pos != end; ++pos) {
       if (name == pos->name)
         return pos->create_callback;
     }
   }
   return nullptr;
 }
 
-REPLEnumerateSupportedLanguages
-PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx) {
+LanguageSet PluginManager::GetREPLAllTypeSystemSupportedLanguages() {
   std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
+  LanguageSet all;
   REPLInstances &instances = GetREPLInstances();
-  if (idx < instances.size())
-    return instances[idx].enumerate_languages_callback;
-  return nullptr;
-}
-
-REPLEnumerateSupportedLanguages
-PluginManager::GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName(
-    ConstString name) {
-  if (name) {
-    std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
-    REPLInstances &instances = GetREPLInstances();
-
-    REPLInstances::iterator pos, end = instances.end();
-    for (pos = instances.begin(); pos != end; ++pos) {
-      if (name == pos->name)
-        return pos->enumerate_languages_callback;
-    }
-  }
-  return nullptr;
+  for (unsigned i = 0; i < instances.size(); ++i)
+    all.bitvector |= instances[i].supported_languages.bitvector;
+  return all;
 }
 
 #pragma mark PluginManager
 
 void PluginManager::DebuggerInitialize(Debugger &debugger) {
   // Initialize the DynamicLoader plugins
   {
     std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());

lldb/source/Interpreter/OptionValueLanguage.cpp

 //===-- OptionValueLanguage.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/Interpreter/OptionValueLanguage.h"
 
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Target/Language.h"
+#include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueLanguage::DumpValue(const ExecutionContext *exe_ctx,
                                     Stream &strm, uint32_t dump_mask) {
Status OptionValueLanguage::SetValueFromString(llvm::StringRef value,
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
     ConstString lang_name(value.trim());
-    std::set<lldb::LanguageType> languages_for_types;
-    std::set<lldb::LanguageType> languages_for_expressions;
-    Language::GetLanguagesSupportingTypeSystems(languages_for_types,
-                                                languages_for_expressions);
-
+    LanguageSet languages_for_types = Language::GetLanguagesSupportingTypeSystems();
     LanguageType new_type =
         Language::GetLanguageTypeFromString(lang_name.GetStringRef());
-    if (new_type && languages_for_types.count(new_type)) {
+    if (new_type && languages_for_types[new_type]) {
       m_value_was_set = true;
       m_current_value = new_type;
     } else {
       StreamString error_strm;
       error_strm.Printf("invalid language type '%s', ", value.str().c_str());
       error_strm.Printf("valid values are:\n");
-      for (lldb::LanguageType language : languages_for_types) {
-        error_strm.Printf("%s%s%s", "    ",
-                          Language::GetNameForLanguageType(language), "\n");
+      for (int bit : languages_for_types.bitvector.set_bits()) {
+        auto language = (LanguageType)bit;
+        error_strm.Printf("    %s\n",
+                          Language::GetNameForLanguageType(language));
       }
       error.SetErrorString(error_strm.GetString());
     }
   } break;
 
   case eVarSetOperationInsertBefore:
   case eVarSetOperationInsertAfter:
   case eVarSetOperationRemove:

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
                          bool append, SymbolContextList &sc_list) override;
 
   uint32_t FindTypes(ConstString name,
                      const CompilerDeclContext *parent_decl_ctx, bool append,
                      uint32_t max_matches,
                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                      TypeMap &types) override;
 
-  size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern, bool append,
+  size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern,
+                   llvm::SmallBitVector languages, bool append,
                    TypeMap &types) override;
 
   llvm::Expected<TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override {
     return llvm::make_error<llvm::StringError>(
         "SymbolFileBreakpad does not support GetTypeSystemForLanguage",
         llvm::inconvertibleErrorCode());
   }

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

uint32_t SymbolFileBreakpad::FindTypes(
     bool append, uint32_t max_matches,
     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
   if (!append)
     types.Clear();
   return types.GetSize();
 }
 
 size_t SymbolFileBreakpad::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
+                                     llvm::SmallBitVector languages,
                                      bool append, TypeMap &types) {
   if (!append)
     types.Clear();
   return types.GetSize();
 }
 
 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

TypeSP DWARFASTParserClang::ParseTypeFromDWO(const DWARFDIE &die, Log *log) {
 
   // If this type comes from a Clang module, look in the DWARF section
   // of the pcm file in the module cache. Clang generates DWO skeleton
   // units as breadcrumbs to find them.
   llvm::SmallVector<CompilerContext, 4> decl_context;
   die.GetDeclContext(decl_context);
   TypeMap dwo_types;
 
-  if (!dwo_module_sp->GetSymbolFile()->FindTypes({decl_context}, true,
+  // The type in the Clang module must have the same langage as the current CU.
+  llvm::SmallBitVector languages(eNumLanguageTypes);
+  languages.set(die.GetCU()->GetLanguageType());
+  if (!dwo_module_sp->GetSymbolFile()->FindTypes(decl_context, languages, true,
                                                  dwo_types)) {
     if (!IsClangModuleFwdDecl(die))
       return TypeSP();
 
     // Since this this type is defined in one of the Clang modules imported by
     // this symbol file, search all of them.
     auto &sym_file = die.GetCU()->GetSymbolFileDWARF();
     for (const auto &name_module : sym_file.getExternalTypeModules()) {
       if (!name_module.second)
         continue;
-      if (name_module.second->GetSymbolFile()->FindTypes({decl_context}, true,
-                                                         dwo_types))
+      if (name_module.second->GetSymbolFile()->FindTypes(
+              decl_context, languages, true, dwo_types))
         break;
     }
   }
 
   if (dwo_types.GetSize() != 1)
     return TypeSP();
 
   // We found a real definition for this type in the Clang module, so lets use

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   uint32_t
   FindTypes(lldb_private::ConstString name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
 
   size_t FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern,
-                   bool append, lldb_private::TypeMap &types) override;
+                   llvm::SmallBitVector languages, bool append,
+                   lldb_private::TypeMap &types) override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

for (const auto &pair : m_external_type_modules) {
       }
     }
   }
 
   return num_die_matches;
 }
 
 size_t SymbolFileDWARF::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
-                                  bool append, TypeMap &types) {
+                                  llvm::SmallBitVector languages, bool append,
+                                  TypeMap &types) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     types.Clear();
 
   if (pattern.empty())
     return 0;
 
   ConstString name = pattern.back().name;
 
   if (!name)
     return 0;
 
   DIEArray die_offsets;
   m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   size_t num_matches = 0;
   for (size_t i = 0; i < num_die_matches; ++i) {
     const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
 
     if (die) {
+      if (!languages[die.GetCU()->GetLanguageType()])
+        continue;
+
       llvm::SmallVector<CompilerContext, 4> die_context;
       die.GetDeclContext(die_context);
       if (!contextMatches(die_context, pattern))
         continue;
 
       Type *matching_type = ResolveType(die, true, true);
       if (matching_type) {
         // We found a type pointer, now find the shared pointer form our type

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
                          bool append, SymbolContextList &sc_list) override;
 
   uint32_t FindTypes(ConstString name,
                      const CompilerDeclContext *parent_decl_ctx, bool append,
                      uint32_t max_matches,
                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                      TypeMap &types) override;
 
-  size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern, bool append,
+  size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern,
+                   llvm::SmallBitVector languages, bool append,
                    TypeMap &types) override;
 
   llvm::Expected<TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext *parent_decl_ctx) override;

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

uint32_t SymbolFileNativePDB::FindTypes(
 
   // There is an assumption 'name' is not a regex
   size_t match_count = FindTypesByName(name.GetStringRef(), max_matches, types);
 
   return match_count;
 }
 
 size_t SymbolFileNativePDB::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
+                                      llvm::SmallBitVector languages,
                                       bool append, TypeMap &types) {
   return 0;
 }
 
 size_t SymbolFileNativePDB::FindTypesByName(llvm::StringRef name,
                                             uint32_t max_matches,
                                             TypeMap &types) {
 

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
   uint32_t
   FindTypes(lldb_private::ConstString name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
 
   size_t FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern,
-                   bool append, lldb_private::TypeMap &types) override;
+                   llvm::SmallBitVector languages, bool append,
+                   lldb_private::TypeMap &types) override;
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches, lldb_private::TypeMap &types);
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

while (auto result = results->getNext()) {
     if (iter == m_types.end())
       continue;
     types.Insert(iter->second);
     ++matches;
   }
 }
 
 size_t SymbolFilePDB::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
-                                bool append, lldb_private::TypeMap &types) {
+                                llvm::SmallBitVector languages, bool append,
+                                lldb_private::TypeMap &types) {
   return 0;
 }
 
 void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
                                          uint32_t type_mask,
                                          TypeCollection &type_collection) {
   bool can_parse = false;
   switch (pdb_symbol.getSymTag()) {

lldb/source/Symbol/ClangASTContext.cpp

if (arch.IsValid()) {
           return ast_sp;
         }
       }
     }
   }
   return lldb::TypeSystemSP();
 }
 
-void ClangASTContext::EnumerateSupportedLanguages(
-    std::set<lldb::LanguageType> &languages_for_types,
-    std::set<lldb::LanguageType> &languages_for_expressions) {
-  static std::vector<lldb::LanguageType> s_supported_languages_for_types(
-      {lldb::eLanguageTypeC89, lldb::eLanguageTypeC, lldb::eLanguageTypeC11,
-       lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeC99,
-       lldb::eLanguageTypeObjC, lldb::eLanguageTypeObjC_plus_plus,
-       lldb::eLanguageTypeC_plus_plus_03, lldb::eLanguageTypeC_plus_plus_11,
-       lldb::eLanguageTypeC11, lldb::eLanguageTypeC_plus_plus_14});
-
-  static std::vector<lldb::LanguageType> s_supported_languages_for_expressions(
-      {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC_plus_plus,
-       lldb::eLanguageTypeC_plus_plus_03, lldb::eLanguageTypeC_plus_plus_11,
-       lldb::eLanguageTypeC_plus_plus_14});
-
-  languages_for_types.insert(s_supported_languages_for_types.begin(),
-                             s_supported_languages_for_types.end());
-  languages_for_expressions.insert(
-      s_supported_languages_for_expressions.begin(),
-      s_supported_languages_for_expressions.end());
+LanguageSet ClangASTContext::GetSupportedLanguagesForTypes() {
+  LanguageSet languages;
+  languages.Insert(lldb::eLanguageTypeC89);
+  languages.Insert(lldb::eLanguageTypeC);
+  languages.Insert(lldb::eLanguageTypeC11);
+  languages.Insert(lldb::eLanguageTypeC_plus_plus);
+  languages.Insert(lldb::eLanguageTypeC99);
+  languages.Insert(lldb::eLanguageTypeObjC);
+  languages.Insert(lldb::eLanguageTypeObjC_plus_plus);
+  languages.Insert(lldb::eLanguageTypeC_plus_plus_03);
+  languages.Insert(lldb::eLanguageTypeC_plus_plus_11);
+  languages.Insert(lldb::eLanguageTypeC11);
+  languages.Insert(lldb::eLanguageTypeC_plus_plus_14);
+  return languages;
+}
+
+LanguageSet ClangASTContext::GetSupportedLanguagesForExpressions() {
+  LanguageSet languages;
+  languages.Insert(lldb::eLanguageTypeC_plus_plus);
+  languages.Insert(lldb::eLanguageTypeObjC_plus_plus);
+  languages.Insert(lldb::eLanguageTypeC_plus_plus_03);
+  languages.Insert(lldb::eLanguageTypeC_plus_plus_11);
+  languages.Insert(lldb::eLanguageTypeC_plus_plus_14);
+  return languages;
 }
 
 void ClangASTContext::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                "clang base AST context plug-in",
-                                CreateInstance, EnumerateSupportedLanguages);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), "clang base AST context plug-in", CreateInstance,
+      GetSupportedLanguagesForTypes(), GetSupportedLanguagesForExpressions());
 }
 
 void ClangASTContext::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 void ClangASTContext::Finalize() {
   if (m_ast_up) {
void ClangASTContext::Clear() {
   m_target_info_up.reset();
   m_identifier_table_up.reset();
   m_selector_table_up.reset();
   m_builtins_up.reset();
   m_pointer_byte_size = 0;
 }
 
 void ClangASTContext::setSema(Sema *s) {
   // Ensure that the new sema actually belongs to our ASTContext.
   assert(s == nullptr || &s->getASTContext() == m_ast_up.get());
   m_sema = s;
 }
 
 const char *ClangASTContext::GetTargetTriple() {
   return m_target_triple.c_str();
 }
 

lldb/source/Symbol/SymbolFile.cpp

uint32_t SymbolFile::FindTypes(
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   if (!append)
     types.Clear();
   return 0;
 }
 
 size_t SymbolFile::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
-                             bool append, TypeMap &types) {
+                             llvm::SmallBitVector languages, bool append,
+                             TypeMap &types) {
   if (!append)
     types.Clear();
   return 0;
 }
 
 void SymbolFile::AssertModuleLock() {
   // The code below is too expensive to leave enabled in release builds. It's
   // enabled in debug builds or when the correct macro is set.

lldb/source/Symbol/TypeSystem.cpp

 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Language.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
+/// A 64-bit SmallBitVector is only small up to 64-7 bits, and the
+/// setBitsInMask interface wants to write full bytes.
+static const size_t num_small_bitvector_bits = 64 - 8;
+static_assert(eNumLanguageTypes < num_small_bitvector_bits,
+              "Languages bit vector is no longer small on 64 bit systems");
+
+llvm::Optional<LanguageType> LanguageSet::GetSingularLanguage() {
+  if (bitvector.count() == 1)
+    return (LanguageType)bitvector.find_first();
+  return {};
+}
+
+void LanguageSet::Insert(LanguageType language) { bitvector.set(language); }
+size_t LanguageSet::Size() const { return bitvector.count(); }
+bool LanguageSet::Empty() const { return bitvector.none(); }
+bool LanguageSet::operator[](unsigned i) const { return bitvector[i]; }
+
 TypeSystem::TypeSystem(LLVMCastKind kind) : m_kind(kind), m_sym_file(nullptr) {}
 
 TypeSystem::~TypeSystem() {}
 
 static lldb::TypeSystemSP CreateInstanceHelper(lldb::LanguageType language,
                                                Module *module, Target *target) {
   uint32_t i = 0;
   TypeSystemCreateInstance create_callback;

lldb/source/Target/Language.cpp

std::set<lldb::LanguageType> Language::GetSupportedLanguages() {
   std::set<lldb::LanguageType> supported_languages;
   ForEach([&](Language *lang) {
     supported_languages.emplace(lang->GetLanguageType());
     return true;
   });
   return supported_languages;
 }
 
-void Language::GetLanguagesSupportingTypeSystems(
-    std::set<lldb::LanguageType> &languages,
-    std::set<lldb::LanguageType> &languages_for_expressions) {
-  uint32_t idx = 0;
-
-  while (TypeSystemEnumerateSupportedLanguages enumerate = PluginManager::
-             GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(idx++)) {
-    (*enumerate)(languages, languages_for_expressions);
-  }
+LanguageSet Language::GetLanguagesSupportingTypeSystems() {
+  return PluginManager::GetAllTypeSystemSupportedLanguagesForTypes();
 }
 
-void Language::GetLanguagesSupportingREPLs(
-    std::set<lldb::LanguageType> &languages) {
-  uint32_t idx = 0;
-
-  while (REPLEnumerateSupportedLanguages enumerate =
-             PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(
-                 idx++)) {
-    (*enumerate)(languages);
-  }
+LanguageSet Language::GetLanguagesSupportingTypeSystemsForExpressions() {
+  return PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions();
+
+LanguageSet Language::GetLanguagesSupportingREPLs() {
+  return PluginManager::GetREPLAllTypeSystemSupportedLanguages();
 }
 
 std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() {
   return nullptr;
 }
 
 const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; }
 

lldb/source/Target/Target.cpp

const lldb::ProcessSP &Target::CreateProcess(ListenerSP listener_sp,
   return m_process_sp;
 }
 
 const lldb::ProcessSP &Target::GetProcessSP() const { return m_process_sp; }
 
 lldb::REPLSP Target::GetREPL(Status &err, lldb::LanguageType language,
                              const char *repl_options, bool can_create) {
   if (language == eLanguageTypeUnknown) {
-    std::set<LanguageType> repl_languages;
+    LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();
 
-    Language::GetLanguagesSupportingREPLs(repl_languages);
-
-    if (repl_languages.size() == 1) {
-      language = *repl_languages.begin();
-    } else if (repl_languages.size() == 0) {
+    if (auto single_lang = repl_languages.GetSingularLanguage()) {
+      language = *single_lang;
+    } else if (repl_languages.Empty()) {
       err.SetErrorStringWithFormat(
           "LLDB isn't configured with REPL support for any languages.");
       return REPLSP();
     } else {
       err.SetErrorStringWithFormat(
           "Multiple possible REPL languages.  Please specify a language.");
       return REPLSP();
     }
Target::GetScratchTypeSystemForLanguage(lldb::LanguageType language,
                                         bool create_on_demand) {
   if (!m_valid)
     return llvm::make_error<llvm::StringError>("Invalid Target",
                                                llvm::inconvertibleErrorCode());
 
   if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all
                                              // assembly code
       || language == eLanguageTypeUnknown) {
-    std::set<lldb::LanguageType> languages_for_types;
-    std::set<lldb::LanguageType> languages_for_expressions;
-
-    Language::GetLanguagesSupportingTypeSystems(languages_for_types,
-                                                languages_for_expressions);
+    LanguageSet languages_for_expressions =
+        Language::GetLanguagesSupportingTypeSystemsForExpressions();
 
-    if (languages_for_expressions.count(eLanguageTypeC)) {
+    if (languages_for_expressions[eLanguageTypeC]) {
       language = eLanguageTypeC; // LLDB's default.  Override by setting the
                                  // target language.
     } else {
-      if (languages_for_expressions.empty()) {
+      if (languages_for_expressions.Empty())
         return llvm::make_error<llvm::StringError>(
             "No expression support for any languages",
             llvm::inconvertibleErrorCode());
-      } else {
-        language = *languages_for_expressions.begin();
-      }
+      language = (LanguageType)languages_for_expressions.bitvector.find_first();
     }
   }
 
   return m_scratch_type_system_map.GetTypeSystemForLanguage(language, this,
                                                             create_on_demand);
 }
 
 std::vector<TypeSystem *> Target::GetScratchTypeSystems(bool create_on_demand) {
   if (!m_valid)
     return {};
 
   std::vector<TypeSystem *> scratch_type_systems;
 
-  std::set<lldb::LanguageType> languages_for_types;
-  std::set<lldb::LanguageType> languages_for_expressions;
-
-  Language::GetLanguagesSupportingTypeSystems(languages_for_types,
-                                              languages_for_expressions);
+  LanguageSet languages_for_expressions =
+      Language::GetLanguagesSupportingTypeSystemsForExpressions();
 
-  for (auto lang : languages_for_expressions) {
+  for (auto bit : languages_for_expressions.bitvector.set_bits()) {
+    auto language = (LanguageType)bit;
     auto type_system_or_err =
-        GetScratchTypeSystemForLanguage(lang, create_on_demand);
+        GetScratchTypeSystemForLanguage(language, create_on_demand);
     if (!type_system_or_err)
       LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
                      type_system_or_err.takeError(),
                      "Language '{}' has expression support but no scratch type "
                      "system available",
-                     Language::GetNameForLanguageType(lang));
+                     Language::GetNameForLanguageType(language));
     else
       scratch_type_systems.emplace_back(&type_system_or_err.get());
   }
 
   return scratch_type_systems;
 }
 
 PersistentExpressionState *

lldb/tools/lldb-test/lldb-test.cpp

 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/ADT/IntervalMap.h"
Context("context",
             cl::desc("Restrict search to the context of the given variable."),
             cl::value_desc("variable"), cl::sub(SymbolsSubcommand));
 
 static cl::opt<std::string> CompilerContext(
     "compiler-context",
     cl::desc("Specify a compiler context as \"kind:name,...\"."),
     cl::value_desc("context"), cl::sub(SymbolsSubcommand));
 
+static cl::opt<std::string>
+    Language("language", cl::desc("Specify a language type, like C99."),
+             cl::value_desc("language"), cl::sub(SymbolsSubcommand));
+
 static cl::list<FunctionNameType> FunctionNameFlags(
     "function-flags", cl::desc("Function search flags:"),
     cl::values(clEnumValN(eFunctionNameTypeAuto, "auto",
                           "Automatically deduce flags based on name."),
                clEnumValN(eFunctionNameTypeFull, "full", "Full function name."),
                clEnumValN(eFunctionNameTypeBase, "base", "Base name."),
                clEnumValN(eFunctionNameTypeMethod, "method", "Method name."),
                clEnumValN(eFunctionNameTypeSelector, "selector",

 Error opts::symbols::findTypes(lldb_private::Module &Module) {
   SymbolFile &Symfile = *Module.GetSymbolFile();
   Expected<CompilerDeclContext> ContextOr = getDeclContext(Symfile);
   if (!ContextOr)
     return ContextOr.takeError();
   CompilerDeclContext *ContextPtr =
       ContextOr->IsValid() ? &*ContextOr : nullptr;
 
+  SmallBitVector languages(eNumLanguageTypes);
+  if (!Language.empty())
+    languages.set(Language::GetLanguageTypeFromString(Language));
+  
   DenseSet<SymbolFile *> SearchedFiles;
   TypeMap Map;
   if (!Name.empty())
     Symfile.FindTypes(ConstString(Name), ContextPtr, true, UINT32_MAX,
                       SearchedFiles, Map);
   else
-    Symfile.FindTypes({parseCompilerContext()}, true, Map);
+    Symfile.FindTypes({parseCompilerContext()}, languages, true, Map);
 
   outs() << formatv("Found {0} types:\n", Map.GetSize());
   StreamString Stream;
   Map.Dump(&Stream, false);
   outs() << Stream.GetData() << "\n";
   return Error::success();
 }