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

802

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 ↗

(On Diff #216508)

🤔

423 ↗

(On Diff #216508)

🙄

lldb/source/Core/Debugger.cpp

1628 ↗

(On Diff #216508)

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 ↗

(On Diff #216518)

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 ↗

(On Diff #216644)

return a "const LanguageSet &" to avoid copies?

lldb/source/Core/Debugger.cpp

1626 ↗

(On Diff #216644)

"const LanguageSet &" to avoid copies?

lldb/source/Core/PluginManager.cpp

2172 ↗

(On Diff #216644)

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

all.Merge(instances[i]);

2265–2266 ↗

(On Diff #216644)

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 ↗

(On Diff #216644)

"const LanguageSet &"?

lldb/source/Symbol/ClangASTContext.cpp

756

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

773

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/Symbol/ClangASTContext.h

public:
 
   // Constructors and Destructors
   ClangASTContext(const char *triple = nullptr);
 
   ~ClangASTContext() override;
 
   void Finalize() override;
 
+  llvm::SmallBitVector GetSupportedLanguages() const override;
+
   // PluginInterface functions
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   static ConstString GetPluginNameStatic();
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,

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.
+/// 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
public:
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Target *target);
 
   // Free up any resources associated with this TypeSystem.  Done before
   // removing all the TypeSystems from the TypeSystemMap.
   virtual void Finalize() {}
 
+  /// Returns a bitvector of \p LanguageType entries this type system
+  /// supports. Each lldb::LanguageType is represented by the bit with
+  /// its number. The largest LanguageType is < 64, so this is very
+  /// space-efficient.
+  virtual llvm::SmallBitVector GetSupportedLanguages() const { return {}; }
+
   virtual DWARFASTParser *GetDWARFParser() { return nullptr; }
   virtual PDBASTParser *GetPDBParser() { return nullptr; }
 
   virtual SymbolFile *GetSymbolFile() const { return m_sym_file; }
 
   // Returns true if the symbol file changed during the set accessor.
   virtual void SetSymbolFile(SymbolFile *sym_file) { m_sym_file = sym_file; }
 

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/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

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());
 }
 
 void ClangASTContext::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 "clang base AST context plug-in",
                                 CreateInstance, EnumerateSupportedLanguages);
 }
 
 void ClangASTContext::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 void ClangASTContext::Finalize() {
   if (m_ast_up) {
     GetASTMap().Erase(m_ast_up.get());
     if (!m_ast_owned)
       m_ast_up.release();
   }
 
   m_builtins_up.reset();
   m_selector_table_up.reset();
   m_identifier_table_up.reset();
   m_target_info_up.reset();
   m_target_options_rp.reset();
   m_diagnostics_engine_up.reset();
void ClangASTContext::Clear() {
   m_target_options_rp.reset();
   m_target_info_up.reset();
   m_identifier_table_up.reset();
   m_selector_table_up.reset();
   m_builtins_up.reset();
   m_pointer_byte_size = 0;
 }
 
+llvm::SmallBitVector ClangASTContext::GetSupportedLanguages() const {
+  llvm::SmallBitVector languages(64-8, 0);
+  static_assert(eNumLanguageTypes < 64-8,
+                "Languages bit vector is no longer small on 64 bit systems");
+  uint64_t mask =
+    1 << eLanguageTypeC89 |
+    1 << eLanguageTypeC |
+    1 << eLanguageTypeC_plus_plus |
+    1 << eLanguageTypeC99 |
+    1 << eLanguageTypeObjC |
+    1 << eLanguageTypeObjC_plus_plus |
+    1 << eLanguageTypeUPC |
+    1 << eLanguageTypeC_plus_plus_03 |
+    1 << eLanguageTypeC_plus_plus_11 |
+    1 << eLanguageTypeC11 |
+    1 << eLanguageTypeC_plus_plus_14;
+  uint32_t mask32[2];
+  memcpy(mask32, &mask, 8);
+  languages.setBitsInMask(mask32, 7);
+  return languages;
+}
+
 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/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 DWARF language 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();
 }