Don't type-erase the FunctionNameType or TypeClass enums

[zturner]

Summary

This is a followup to D53597, with 2 more enums. Assuming that patch is good, I see no reason why this wasn't isn't good as well, but I'm throwing it out here for review anyway if nothing else as an FYI. I'll wait for a final LGTM on D53597, but assuming that's good, I'll probably submit both of these unless someone has a comment or comments on this one first.

I think this is the last of the type-erased enums, so after this, all of our flags enums should be strongly typed through the system.

lldb/trunk/include/lldb/Breakpoint/BreakpointResolverName.h

 /// @class BreakpointResolverName BreakpointResolverName.h
 /// "lldb/Breakpoint/BreakpointResolverName.h" This class sets breakpoints on
 /// a given function name, either by exact match or by regular expression.
 //----------------------------------------------------------------------
 
 class BreakpointResolverName : public BreakpointResolver {
 public:
   BreakpointResolverName(Breakpoint *bkpt, const char *name,
-                         uint32_t name_type_mask, lldb::LanguageType language,
+                         lldb::FunctionNameType name_type_mask,
+                         lldb::LanguageType language,
                          Breakpoint::MatchType type, lldb::addr_t offset,
                          bool skip_prologue);
 
   // This one takes an array of names.  It is always MatchType = Exact.
   BreakpointResolverName(Breakpoint *bkpt, const char *names[],
-                         size_t num_names, uint32_t name_type_mask,
+                         size_t num_names,
+                         lldb::FunctionNameType name_type_mask,
                          lldb::LanguageType language, lldb::addr_t offset,
                          bool skip_prologue);
 
   // This one takes a C++ array of names.  It is always MatchType = Exact.
   BreakpointResolverName(Breakpoint *bkpt, std::vector<std::string> names,
-                         uint32_t name_type_mask, lldb::LanguageType language,
-                         lldb::addr_t offset, bool skip_prologue);
+                         lldb::FunctionNameType name_type_mask,
+                         lldb::LanguageType language, lldb::addr_t offset,
+                         bool skip_prologue);
 
   // Creates a function breakpoint by regular expression.  Takes over control
   // of the lifespan of func_regex.
   BreakpointResolverName(Breakpoint *bkpt, RegularExpression &func_regex,
                          lldb::LanguageType language, lldb::addr_t offset,
                          bool skip_prologue);
 
   static BreakpointResolver *
protected:
 
   std::vector<Module::LookupInfo> m_lookups;
   ConstString m_class_name;
   RegularExpression m_regex;
   Breakpoint::MatchType m_match_type;
   lldb::LanguageType m_language;
   bool m_skip_prologue;
 
-  void AddNameLookup(const ConstString &name, uint32_t name_type_mask);
+  void AddNameLookup(const ConstString &name,
+                     lldb::FunctionNameType name_type_mask);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_BreakpointResolverName_h_

lldb/trunk/include/lldb/Core/Module.h

public:
   ///     A symbol context list that gets filled in with all of the
   ///     matches.
   ///
   /// @return
   ///     The number of matches added to \a sc_list.
   //------------------------------------------------------------------
   size_t FindFunctions(const ConstString &name,
                        const CompilerDeclContext *parent_decl_ctx,
-                       uint32_t name_type_mask, bool symbols_ok,
+                       lldb::FunctionNameType name_type_mask, bool symbols_ok,
                        bool inlines_ok, bool append,
                        SymbolContextList &sc_list);
 
   //------------------------------------------------------------------
   /// Find functions by name.
   ///
   /// If the function is an inlined function, it will have a block,
   /// representing the inlined function, and the function will be the
public:
   /// Function lookups are done in Module.cpp, ModuleList.cpp and in
   /// BreakpointResolverName.cpp and they all now use this class to do lookups
   /// correctly.
   //----------------------------------------------------------------------
   class LookupInfo {
   public:
     LookupInfo()
         : m_name(), m_lookup_name(), m_language(lldb::eLanguageTypeUnknown),
-          m_name_type_mask(0), m_match_name_after_lookup(false) {}
+          m_name_type_mask(lldb::eFunctionNameTypeNone),
+          m_match_name_after_lookup(false) {}
 
-    LookupInfo(const ConstString &name, uint32_t name_type_mask,
+    LookupInfo(const ConstString &name, lldb::FunctionNameType name_type_mask,
                lldb::LanguageType language);
 
     const ConstString &GetName() const { return m_name; }
 
     void SetName(const ConstString &name) { m_name = name; }
 
     const ConstString &GetLookupName() const { return m_lookup_name; }
 
     void SetLookupName(const ConstString &name) { m_lookup_name = name; }
 
-    uint32_t GetNameTypeMask() const { return m_name_type_mask; }
+    lldb::FunctionNameType GetNameTypeMask() const { return m_name_type_mask; }
 
-    void SetNameTypeMask(uint32_t mask) { m_name_type_mask = mask; }
+    void SetNameTypeMask(lldb::FunctionNameType mask) {
+      m_name_type_mask = mask;
+    }
 
     void Prune(SymbolContextList &sc_list, size_t start_idx) const;
 
   protected:
-    ConstString m_name;        ///< What the user originally typed
-    ConstString m_lookup_name; ///< The actual name will lookup when calling in
-                               ///the object or symbol file
-    lldb::LanguageType
-        m_language;            ///< Limit matches to only be for this language
-    uint32_t m_name_type_mask; ///< One or more bits from lldb::FunctionNameType
-                               ///that indicate what kind of names we are
-                               ///looking for
-    bool m_match_name_after_lookup; ///< If \b true, then demangled names that
-                                    ///match will need to contain "m_name" in
-                                    ///order to be considered a match
+    /// What the user originally typed
+    ConstString m_name;
+
+    /// The actual name will lookup when calling in the object or symbol file
+    ConstString m_lookup_name;
+
+    /// Limit matches to only be for this language
+    lldb::LanguageType m_language;
+
+    /// One or more bits from lldb::FunctionNameType that indicate what kind of
+    /// names we are looking for
+    lldb::FunctionNameType m_name_type_mask;
+
+    ///< If \b true, then demangled names that match will need to contain
+    ///< "m_name" in order to be considered a match
+    bool m_match_name_after_lookup;
   };
 
 protected:
   //------------------------------------------------------------------
   // Member Variables
   //------------------------------------------------------------------
   mutable std::recursive_mutex m_mutex; ///< A mutex to keep this object happy
                                         ///in multi-threaded environments.

lldb/trunk/include/lldb/Core/ModuleList.h

public:
   ///     The number of matches added to \a sc_list.
   //------------------------------------------------------------------
   size_t FindCompileUnits(const FileSpec &path, bool append,
                           SymbolContextList &sc_list) const;
 
   //------------------------------------------------------------------
   /// @see Module::FindFunctions ()
   //------------------------------------------------------------------
-  size_t FindFunctions(const ConstString &name, uint32_t name_type_mask,
+  size_t FindFunctions(const ConstString &name,
+                       lldb::FunctionNameType name_type_mask,
                        bool include_symbols, bool include_inlines, bool append,
                        SymbolContextList &sc_list) const;
 
   //------------------------------------------------------------------
   /// @see Module::FindFunctionSymbols ()
   //------------------------------------------------------------------
-  size_t FindFunctionSymbols(const ConstString &name, uint32_t name_type_mask,
+  size_t FindFunctionSymbols(const ConstString &name,
+                             lldb::FunctionNameType name_type_mask,
                              SymbolContextList &sc_list);
 
   //------------------------------------------------------------------
   /// @see Module::FindFunctions ()
   //------------------------------------------------------------------
   size_t FindFunctions(const RegularExpression &name, bool include_symbols,
                        bool include_inlines, bool append,
                        SymbolContextList &sc_list);

lldb/trunk/include/lldb/Symbol/SymbolFile.h

public:
   FindGlobalVariables(const ConstString &name,
                       const CompilerDeclContext *parent_decl_ctx,
                       uint32_t max_matches, VariableList &variables);
   virtual uint32_t FindGlobalVariables(const RegularExpression &regex,
                                        uint32_t max_matches,
                                        VariableList &variables);
   virtual uint32_t FindFunctions(const ConstString &name,
                                  const CompilerDeclContext *parent_decl_ctx,
-                                 uint32_t name_type_mask, bool include_inlines,
-                                 bool append, SymbolContextList &sc_list);
+                                 lldb::FunctionNameType name_type_mask,
+                                 bool include_inlines, bool append,
+                                 SymbolContextList &sc_list);
   virtual uint32_t FindFunctions(const RegularExpression &regex,
                                  bool include_inlines, bool append,
                                  SymbolContextList &sc_list);
   virtual uint32_t
   FindTypes(const SymbolContext &sc, const 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(const std::vector<CompilerContext> &context,
                            bool append, TypeMap &types);
 
   virtual void
   GetMangledNamesForFunction(const std::string &scope_qualified_name,
                              std::vector<ConstString> &mangled_names);
   //  virtual uint32_t        FindTypes (const SymbolContext& sc, const
   //  RegularExpression& regex, bool append, uint32_t max_matches, TypeList&
   //  types) = 0;
   virtual TypeList *GetTypeList();
   virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
-                          uint32_t type_mask,
+                          lldb::TypeClass type_mask,
                           lldb_private::TypeList &type_list) = 0;
 
   virtual void PreloadSymbols();
 
   virtual lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language);
 
   virtual CompilerDeclContext

lldb/trunk/include/lldb/Symbol/SymbolVendor.h

virtual size_t FindGlobalVariables(const ConstString &name,
                                      VariableList &variables);
 
   virtual size_t FindGlobalVariables(const RegularExpression &regex,
                                      size_t max_matches,
                                      VariableList &variables);
 
   virtual size_t FindFunctions(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx,
-                               uint32_t name_type_mask, bool include_inlines,
-                               bool append, SymbolContextList &sc_list);
+                               lldb::FunctionNameType name_type_mask,
+                               bool include_inlines, bool append,
+                               SymbolContextList &sc_list);
 
   virtual size_t FindFunctions(const RegularExpression &regex,
                                bool include_inlines, bool append,
                                SymbolContextList &sc_list);
 
   virtual size_t
   FindTypes(const SymbolContext &sc, const ConstString &name,
             const CompilerDeclContext *parent_decl_ctx, bool append,
virtual bool SetCompileUnitAtIndex(size_t cu_idx,
                                      const lldb::CompUnitSP &cu_sp);
 
   virtual lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx);
 
   TypeList &GetTypeList() { return m_type_list; }
 
   const TypeList &GetTypeList() const { return m_type_list; }
 
-  virtual size_t GetTypes(SymbolContextScope *sc_scope, uint32_t type_mask,
-                          TypeList &type_list);
+  virtual size_t GetTypes(SymbolContextScope *sc_scope,
+                          lldb::TypeClass type_mask, TypeList &type_list);
 
   SymbolFile *GetSymbolFile() { return m_sym_file_ap.get(); }
 
   FileSpec GetMainFileSpec() const;
 
   // Get module unified section list symbol table.
   virtual Symtab *GetSymtab();
 

lldb/trunk/include/lldb/Target/Target.h

lldb::BreakpointSP CreateFuncRegexBreakpoint(
       lldb::LanguageType requested_language, LazyBool skip_prologue,
       bool internal, bool request_hardware);
 
   // Use this to create a function breakpoint by name in containingModule, or
   // all modules if it is nullptr When "skip_prologue is set to
   // eLazyBoolCalculate, we use the current target setting, else we use the
   // values passed in. func_name_type_mask is or'ed values from the
   // FunctionNameType enum.
-  lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules,
-                                      const FileSpecList *containingSourceFiles,
-                                      const char *func_name,
-                                      uint32_t func_name_type_mask,
-                                      lldb::LanguageType language,
-                                      lldb::addr_t offset,
-                                      LazyBool skip_prologue, bool internal,
-                                      bool request_hardware);
+  lldb::BreakpointSP CreateBreakpoint(
+      const FileSpecList *containingModules,
+      const FileSpecList *containingSourceFiles, const char *func_name,
+      lldb::FunctionNameType func_name_type_mask, lldb::LanguageType language,
+      lldb::addr_t offset, LazyBool skip_prologue, bool internal,
 
   lldb::BreakpointSP
   CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp,
                             bool throw_bp, bool internal,
                             Args *additional_args = nullptr,
                             Status *additional_args_error = nullptr);
 
   lldb::BreakpointSP
   CreateScriptedBreakpoint(const llvm::StringRef class_name,
                            const FileSpecList *containingModules,
                            const FileSpecList *containingSourceFiles,
                            bool internal,
                            bool request_hardware,
                            StructuredData::ObjectSP extra_args_sp,
                            Status *creation_error = nullptr);
 
   // This is the same as the func_name breakpoint except that you can specify a
   // vector of names.  This is cheaper than a regular expression breakpoint in
   // the case where you just want to set a breakpoint on a set of names you
   // already know. func_name_type_mask is or'ed values from the
   // FunctionNameType enum.
-  lldb::BreakpointSP
-  CreateBreakpoint(const FileSpecList *containingModules,
-                   const FileSpecList *containingSourceFiles,
-                   const char *func_names[], size_t num_names,
-                   uint32_t func_name_type_mask, lldb::LanguageType language,
-                   lldb::addr_t offset, LazyBool skip_prologue, bool internal,
-                   bool request_hardware);
+  lldb::BreakpointSP CreateBreakpoint(
+      const FileSpecList *containingModules,
+      const FileSpecList *containingSourceFiles, const char *func_names[],
+      size_t num_names, lldb::FunctionNameType func_name_type_mask,
+      lldb::LanguageType language, lldb::addr_t offset, LazyBool skip_prologue,
+      bool internal, bool request_hardware);
 
   lldb::BreakpointSP
   CreateBreakpoint(const FileSpecList *containingModules,
                    const FileSpecList *containingSourceFiles,
                    const std::vector<std::string> &func_names,
-                   uint32_t func_name_type_mask, lldb::LanguageType language,
-                   lldb::addr_t m_offset, LazyBool skip_prologue, bool internal,
+                   lldb::FunctionNameType func_name_type_mask,
+                   lldb::LanguageType language, lldb::addr_t m_offset,
+                   LazyBool skip_prologue, bool internal,
                    bool request_hardware);
 
   // Use this to create a general breakpoint:
   lldb::BreakpointSP CreateBreakpoint(lldb::SearchFilterSP &filter_sp,
                                       lldb::BreakpointResolverSP &resolver_sp,
                                       bool internal, bool request_hardware,
                                       bool resolve_indirect_symbols);
 

lldb/trunk/include/lldb/lldb-enumerations.h

eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces
                                        // methods or selectors will be searched.
     eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++)
                                          // with no namespace or arguments
     eFunctionNameTypeSelector =
         (1u << 5), // Find function by selector name (ObjC) names
     eFunctionNameTypeAny =
         eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
 };
+LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType)
 
 //----------------------------------------------------------------------
 // Basic types enumeration for the public API SBType::GetBasicType()
 //----------------------------------------------------------------------
 enum BasicType {
   eBasicTypeInvalid = 0,
   eBasicTypeVoid = 1,
   eBasicTypeChar,
FLAGS_ENUM(TypeClass){
     eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12),
     eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14),
     eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16),
     eTypeClassVector = (1u << 17),
     // Define the last type class as the MSBit of a 32 bit value
     eTypeClassOther = (1u << 31),
     // Define a mask that can be used for any type when finding types
     eTypeClassAny = (0xffffffffu)};
+LLDB_MARK_AS_BITMASK_ENUM(TypeClass)
 
 enum TemplateArgumentKind {
   eTemplateArgumentKindNull = 0,
   eTemplateArgumentKindType,
   eTemplateArgumentKindDeclaration,
   eTemplateArgumentKindIntegral,
   eTemplateArgumentKindTemplate,
   eTemplateArgumentKindTemplateExpansion,

lldb/trunk/source/API/SBCompileUnit.cpp

if (m_opaque_ptr) {
     return support_files.GetSize();
   }
   return 0;
 }
 
 lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
   SBTypeList sb_type_list;
 
-  if (m_opaque_ptr) {
-    ModuleSP module_sp(m_opaque_ptr->GetModule());
-    if (module_sp) {
-      SymbolVendor *vendor = module_sp->GetSymbolVendor();
-      if (vendor) {
-        TypeList type_list;
-        vendor->GetTypes(m_opaque_ptr, type_mask, type_list);
-        sb_type_list.m_opaque_ap->Append(type_list);
-      }
-    }
-  }
+  if (!m_opaque_ptr)
+    return sb_type_list;
+
+  if (!module_sp)
+    return sb_type_list;
+
+  if (!vendor)
+    return sb_type_list;
+
+  TypeClass type_class = static_cast<TypeClass>(type_mask);
+  vendor->GetTypes(m_opaque_ptr, type_class, type_list);
   return sb_type_list;
 }
 
 SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec sb_file_spec;
   if (m_opaque_ptr) {

lldb/trunk/source/API/SBModule.cpp

 lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
                                                   uint32_t name_type_mask) {
   lldb::SBSymbolContextList sb_sc_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {
     const bool append = true;
     const bool symbols_ok = true;
     const bool inlines_ok = true;
-    module_sp->FindFunctions(ConstString(name), NULL, name_type_mask,
-                             symbols_ok, inlines_ok, append, *sb_sc_list);
+    FunctionNameType type = static_cast<FunctionNameType>(name_type_mask);
+    module_sp->FindFunctions(ConstString(name), NULL, type, symbols_ok,
+                             inlines_ok, append, *sb_sc_list);
   }
   return sb_sc_list;
 }
 
 SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
                                           uint32_t max_matches) {
   SBValueList sb_value_list;
   ModuleSP module_sp(GetSP());
lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
   }
   return SBType();
 }
 
 lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
   SBTypeList sb_type_list;
 
   ModuleSP module_sp(GetSP());
-  if (module_sp) {
-    SymbolVendor *vendor = module_sp->GetSymbolVendor();
-    if (vendor) {
-      TypeList type_list;
-      vendor->GetTypes(NULL, type_mask, type_list);
-      sb_type_list.m_opaque_ap->Append(type_list);
-    }
-  }
+  if (!module_sp)
+    return sb_type_list;
+  if (!vendor)
+    return sb_type_list;
+
+  TypeClass type_class = static_cast<TypeClass>(type_mask);
+  vendor->GetTypes(NULL, type_class, type_list);
   return sb_type_list;
 }
 
 SBSection SBModule::FindSection(const char *sect_name) {
   SBSection sb_section;
 
   ModuleSP module_sp(GetSP());
   if (sect_name && module_sp) {

lldb/trunk/source/API/SBTarget.cpp

SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByName(const char *symbol_name,
                                  const SBFileSpecList &module_list,
                                  const SBFileSpecList &comp_unit_list) {
-  uint32_t name_type_mask = eFunctionNameTypeAuto;
+  lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
   return BreakpointCreateByName(symbol_name, name_type_mask,
                                 eLanguageTypeUnknown, module_list,
                                 comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
     const char *symbol_name, uint32_t name_type_mask,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && symbol_name && symbol_name[0]) {
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
-    sb_bp = target_sp->CreateBreakpoint(
-        module_list.get(), comp_unit_list.get(), symbol_name, name_type_mask,
-        symbol_language, 0, skip_prologue, internal, hardware);
+    FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
+    sb_bp = target_sp->CreateBreakpoint(module_list.get(), comp_unit_list.get(),
+                                        symbol_name, mask, symbol_language, 0,
+                                        skip_prologue, internal, hardware);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", "
                 "name_type: %d) => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()), symbol_name,
                 name_type_mask, static_cast<void *>(sb_bp.GetSP().get()));
 
lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && num_names > 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool internal = false;
     const bool hardware = false;
+    FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
     const LazyBool skip_prologue = eLazyBoolCalculate;
     sb_bp = target_sp->CreateBreakpoint(
-        module_list.get(), comp_unit_list.get(), symbol_names, num_names,
-        name_type_mask, symbol_language, offset, skip_prologue, internal,
-        hardware);
+        module_list.get(), comp_unit_list.get(), symbol_names, num_names, mask,
+        symbol_language, offset, skip_prologue, internal, hardware);
   }
 
   if (log) {
     log->Printf("SBTarget(%p)::BreakpointCreateByName (symbols={",
                 static_cast<void *>(target_sp.get()));
     for (uint32_t i = 0; i < num_names; i++) {
       char sep;
       if (i < num_names - 1)
if (target_sp) {
     strm.PutCString("No value");
 
   return true;
 }
 
 lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
                                                   uint32_t name_type_mask) {
   lldb::SBSymbolContextList sb_sc_list;
-  if (name && name[0]) {
-    TargetSP target_sp(GetSP());
-    if (target_sp) {
-      const bool symbols_ok = true;
-      const bool inlines_ok = true;
-      const bool append = true;
-      target_sp->GetImages().FindFunctions(ConstString(name), name_type_mask,
-                                           symbols_ok, inlines_ok, append,
-                                           *sb_sc_list);
-    }
-  }
+  if (!name | !name[0])
+    return sb_sc_list;
+
+  if (!target_sp)
+    return sb_sc_list;
+
+  FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
+  target_sp->GetImages().FindFunctions(ConstString(name), mask, symbols_ok,
+                                       inlines_ok, append, *sb_sc_list);
   return sb_sc_list;
 }
 
 lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
                                                         uint32_t max_matches,
                                                         MatchType matchtype) {
   lldb::SBSymbolContextList sb_sc_list;
   if (name && name[0]) {

lldb/trunk/source/Breakpoint/BreakpointResolverName.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 BreakpointResolverName::BreakpointResolverName(
-    Breakpoint *bkpt, const char *name_cstr, uint32_t name_type_mask,
+    Breakpoint *bkpt, const char *name_cstr, FunctionNameType name_type_mask,
     LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset,
     bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_class_name(), m_regex(), m_match_type(type), m_language(language),
       m_skip_prologue(skip_prologue) {
   if (m_match_type == Breakpoint::Regexp) {
     if (!m_regex.Compile(llvm::StringRef::withNullAsEmpty(name_cstr))) {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
       if (log)
         log->Warning("function name regexp: \"%s\" did not compile.",
                      name_cstr);
     }
   } else {
     AddNameLookup(ConstString(name_cstr), name_type_mask);
   }
 }
 
 BreakpointResolverName::BreakpointResolverName(
     Breakpoint *bkpt, const char *names[], size_t num_names,
-    uint32_t name_type_mask, LanguageType language, lldb::addr_t offset,
+    FunctionNameType name_type_mask, LanguageType language, lldb::addr_t offset,
     bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_match_type(Breakpoint::Exact), m_language(language),
       m_skip_prologue(skip_prologue) {
   for (size_t i = 0; i < num_names; i++) {
     AddNameLookup(ConstString(names[i]), name_type_mask);
   }
 }
 
-BreakpointResolverName::BreakpointResolverName(
-    Breakpoint *bkpt, std::vector<std::string> names, uint32_t name_type_mask,
-    LanguageType language, lldb::addr_t offset, bool skip_prologue)
+BreakpointResolverName::BreakpointResolverName(Breakpoint *bkpt,
+                                               std::vector<std::string> names,
+                                               FunctionNameType name_type_mask,
+                                               LanguageType language,
+                                               lldb::addr_t offset,
+                                               bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_match_type(Breakpoint::Exact), m_language(language),
       m_skip_prologue(skip_prologue) {
   for (const std::string &name : names) {
     AddNameLookup(ConstString(name.c_str(), name.size()), name_type_mask);
   }
 }
 
if (success) {
     }
 
     if (num_elem == 0) {
       error.SetErrorString(
           "BRN::CFSD: no name entry in a breakpoint by name breakpoint.");
       return nullptr;
     }
     std::vector<std::string> names;
-    std::vector<uint32_t> name_masks;
+    std::vector<FunctionNameType> name_masks;
     for (size_t i = 0; i < num_elem; i++) {
-      uint32_t name_mask;
       llvm::StringRef name;
 
       success = names_array->GetItemAtIndexAsString(i, name);
       if (!success) {
         error.SetErrorString("BRN::CFSD: name entry is not a string.");
         return nullptr;
       }
-      success = names_mask_array->GetItemAtIndexAsInteger(i, name_mask);
+      std::underlying_type<FunctionNameType>::type fnt;
+      success = names_mask_array->GetItemAtIndexAsInteger(i, fnt);
       if (!success) {
         error.SetErrorString("BRN::CFSD: name mask entry is not an integer.");
         return nullptr;
       }
       names.push_back(name);
-      name_masks.push_back(name_mask);
+      name_masks.push_back(static_cast<FunctionNameType>(fnt));
     }
 
     BreakpointResolverName *resolver = new BreakpointResolverName(
         bkpt, names[0].c_str(), name_masks[0], language,
         Breakpoint::MatchType::Exact, offset, skip_prologue);
     for (size_t i = 1; i < num_elem; i++) {
       resolver->AddNameLookup(ConstString(names[i]), name_masks[i]);
     }
options_dict_sp->AddStringItem(
         Language::GetNameForLanguageType(m_language));
   options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
                                   m_skip_prologue);
 
   return WrapOptionsDict(options_dict_sp);
 }
 
 void BreakpointResolverName::AddNameLookup(const ConstString &name,
-                                           uint32_t name_type_mask) {
+                                           FunctionNameType name_type_mask) {
   ObjCLanguage::MethodName objc_method(name.GetCString(), false);
   if (objc_method.IsValid(false)) {
     std::vector<ConstString> objc_names;
     objc_method.GetFullNames(objc_names, true);
     for (ConstString objc_name : objc_names) {
       Module::LookupInfo lookup;
       lookup.SetName(name);
       lookup.SetLookupName(objc_name);

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

public:
     // Instance variables to hold the values for command options.
 
     std::string m_condition;
     FileSpecList m_filenames;
     uint32_t m_line_num;
     uint32_t m_column;
     std::vector<std::string> m_func_names;
     std::vector<std::string> m_breakpoint_names;
-    uint32_t m_func_name_type_mask;
+    lldb::FunctionNameType m_func_name_type_mask;
     std::string m_func_regexp;
     std::string m_source_text_regexp;
     FileSpecList m_modules;
     lldb::addr_t m_load_addr;
     lldb::addr_t m_offset_addr;
     bool m_catch_bp;
     bool m_throw_bp;
     bool m_hardware; // Request to use hardware breakpoints
case eSetTypeAddress: // Breakpoint by address
                            "address breakpoints.");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
       break;
     }
     case eSetTypeFunctionName: // Breakpoint by function name
     {
-      uint32_t name_type_mask = m_options.m_func_name_type_mask;
+      FunctionNameType name_type_mask = m_options.m_func_name_type_mask;
 
       if (name_type_mask == 0)
         name_type_mask = eFunctionNameTypeAuto;
 
       bp_sp = target->CreateBreakpoint(&(m_options.m_modules), 
                                        &(m_options.m_filenames),
                                        m_options.m_func_names, 
                                        name_type_mask, 

lldb/trunk/source/Core/Module.cpp

for (size_t i = 0; i < num_compile_units; ++i) {
     if (sc.comp_unit) {
       if (FileSpec::Equal(*sc.comp_unit, path, compare_directory))
         sc_list.Append(sc);
     }
   }
   return sc_list.GetSize() - start_size;
 }
 
-Module::LookupInfo::LookupInfo(const ConstString &name, uint32_t name_type_mask,
-                               lldb::LanguageType language)
-    : m_name(name), m_lookup_name(), m_language(language), m_name_type_mask(0),
+Module::LookupInfo::LookupInfo(const ConstString &name,
+                               FunctionNameType name_type_mask,
+                               LanguageType language)
+    : m_name(name), m_lookup_name(), m_language(language),
+      m_name_type_mask(eFunctionNameTypeNone),
       m_match_name_after_lookup(false) {
   const char *name_cstr = name.GetCString();
   llvm::StringRef basename;
   llvm::StringRef context;
 
   if (name_type_mask & eFunctionNameTypeAuto) {
     if (CPlusPlusLanguage::IsCPPMangledName(name_cstr))
       m_name_type_mask = eFunctionNameTypeFull;
while (i < sc_list.GetSize()) {
       }
       ++i;
     }
   }
 }
 
 size_t Module::FindFunctions(const ConstString &name,
                              const CompilerDeclContext *parent_decl_ctx,
-                             uint32_t name_type_mask, bool include_symbols,
-                             bool include_inlines, bool append,
-                             SymbolContextList &sc_list) {
+                             FunctionNameType name_type_mask,
+                             bool include_symbols, bool include_inlines,
+                             bool append, SymbolContextList &sc_list) {
   if (!append)
     sc_list.Clear();
 
   const size_t old_size = sc_list.GetSize();
 
   // Find all the functions (not symbols, but debug information functions...
   SymbolVendor *symbols = GetSymbolVendor();
 

lldb/trunk/source/Core/ModuleList.cpp

 ModuleSP ModuleList::GetModuleAtIndexUnlocked(size_t idx) const {
   ModuleSP module_sp;
   if (idx < m_modules.size())
     module_sp = m_modules[idx];
   return module_sp;
 }
 
 size_t ModuleList::FindFunctions(const ConstString &name,
-                                 uint32_t name_type_mask, bool include_symbols,
-                                 bool include_inlines, bool append,
+                                 FunctionNameType name_type_mask,
+                                 bool include_symbols, bool include_inlines,
+                                 bool append,
                                  SymbolContextList &sc_list) const {
   if (!append)
     sc_list.Clear();
 
   const size_t old_size = sc_list.GetSize();
 
   if (name_type_mask & eFunctionNameTypeAuto) {
     Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
for (pos = m_modules.begin(); pos != end; ++pos) {
       (*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols,
                             include_inlines, true, sc_list);
     }
   }
   return sc_list.GetSize() - old_size;
 }
 
 size_t ModuleList::FindFunctionSymbols(const ConstString &name,
-                                       uint32_t name_type_mask,
+                                       lldb::FunctionNameType name_type_mask,
                                        SymbolContextList &sc_list) {
   const size_t old_size = sc_list.GetSize();
 
   if (name_type_mask & eFunctionNameTypeAuto) {
     Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();

lldb/trunk/source/Expression/IRExecutionUnit.cpp

FindBestAlternateMangledName(const ConstString &demangled,
   else if (param_matches.size())
     return param_matches[0]; // Return one of them as a best match
   else
     return ConstString();
 }
 
 struct IRExecutionUnit::SearchSpec {
   ConstString name;
-  uint32_t mask;
+  lldb::FunctionNameType mask;
 
-  SearchSpec(ConstString n, uint32_t m = lldb::eFunctionNameTypeFull)
+  SearchSpec(ConstString n,
+             lldb::FunctionNameType m = lldb::eFunctionNameTypeFull)
       : name(n), mask(m) {}
 };
 
 void IRExecutionUnit::CollectCandidateCNames(
     std::vector<IRExecutionUnit::SearchSpec> &C_specs,
     const ConstString &name) {
   if (m_strip_underscore && name.AsCString()[0] == '_')
     C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1]));

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

public:
 
   uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
                                uint32_t max_matches,
                                lldb_private::VariableList &variables) override;
 
   uint32_t
   FindFunctions(const lldb_private::ConstString &name,
                 const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                uint32_t name_type_mask, bool include_inlines, bool append,
-                lldb_private::SymbolContextList &sc_list) override;
+                lldb::FunctionNameType name_type_mask, bool include_inlines,
+                bool append, lldb_private::SymbolContextList &sc_list) override;
 
   uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
                          bool include_inlines, bool append,
                          lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(
       const std::string &scope_qualified_name,
       std::vector<lldb_private::ConstString> &mangled_names) override;
 
   uint32_t
   FindTypes(const lldb_private::SymbolContext &sc,
             const 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(const std::vector<lldb_private::CompilerContext> &context,
                    bool append, lldb_private::TypeMap &types) override;
 
   lldb_private::TypeList *GetTypeList() override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
-                  uint32_t type_mask,
+                  lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
       const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,

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

if (die) {
     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
          child_die = child_die.GetSibling()) {
       GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
     }
   }
 }
 
 size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
-                                 uint32_t type_mask, TypeList &type_list)
+                                 TypeClass type_mask, TypeList &type_list)
 
 {
   ASSERT_MODULE_LOCK(this);
   TypeSet type_set;
 
   CompileUnit *comp_unit = NULL;
   DWARFUnit *dwarf_cu = NULL;
   if (sc_scope)
if (dwarf_ast) {
           dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
       if (actual_decl_ctx)
         return actual_decl_ctx == *decl_ctx;
     }
   }
   return false;
 }
 
-uint32_t
-SymbolFileDWARF::FindFunctions(const ConstString &name,
-                               const CompilerDeclContext *parent_decl_ctx,
-                               uint32_t name_type_mask, bool include_inlines,
-                               bool append, SymbolContextList &sc_list) {
+uint32_t SymbolFileDWARF::FindFunctions(
+    const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+    FunctionNameType name_type_mask, bool include_inlines, bool append,
+    SymbolContextList &sc_list) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
                      name.AsCString());
 
   // eFunctionNameTypeAuto should be pre-resolved by a call to
   // Module::LookupInfo::LookupInfo()
   assert((name_type_mask & eFunctionNameTypeAuto) == 0);
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

FindGlobalVariables(const lldb_private::ConstString &name,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
   uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
                                uint32_t max_matches,
                                lldb_private::VariableList &variables) override;
   uint32_t
   FindFunctions(const lldb_private::ConstString &name,
                 const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                uint32_t name_type_mask, bool include_inlines, bool append,
-                lldb_private::SymbolContextList &sc_list) override;
+                lldb::FunctionNameType name_type_mask, bool include_inlines,
+                bool append, lldb_private::SymbolContextList &sc_list) override;
   uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
                          bool include_inlines, bool append,
                          lldb_private::SymbolContextList &sc_list) override;
   uint32_t
   FindTypes(const lldb_private::SymbolContext &sc,
             const 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;
   lldb_private::CompilerDeclContext FindNamespace(
       const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
-                  uint32_t type_mask,
+                  lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
   std::vector<lldb_private::CallEdge>
   ParseCallEdgesInFunction(lldb_private::UserID func_id) override;
 
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
   lldb_private::ConstString GetPluginName() override;

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (sc.function) {
       }
     }
     ++i;
   }
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindFunctions(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
-    uint32_t name_type_mask, bool include_inlines, bool append,
+    FunctionNameType name_type_mask, bool include_inlines, bool append,
     SymbolContextList &sc_list) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
                      name.GetCString());
 
   uint32_t initial_size = 0;
   if (append)
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     }
     return false;
   });
 
   return sc_list.GetSize() - initial_size;
 }
 
 size_t SymbolFileDWARFDebugMap::GetTypes(SymbolContextScope *sc_scope,
-                                         uint32_t type_mask,
+                                         lldb::TypeClass type_mask,
                                          TypeList &type_list) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::GetTypes (type_mask = 0x%8.8x)",
                      type_mask);
 
   uint32_t initial_size = type_list.GetSize();
   SymbolFileDWARF *oso_dwarf = NULL;

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

size_t ParseVariablesForContext(const SymbolContext &sc) override {
     return 0;
   }
   Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   bool CompleteType(CompilerType &compiler_type) override;
   uint32_t ResolveSymbolContext(const Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContext &sc) override;
 
-  size_t GetTypes(SymbolContextScope *sc_scope, uint32_t type_mask,
+  size_t GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                   TypeList &type_list) override;
 
   uint32_t FindFunctions(const ConstString &name,
                          const CompilerDeclContext *parent_decl_ctx,
-                         uint32_t name_type_mask, bool include_inlines,
-                         bool append, SymbolContextList &sc_list) override;
+                         lldb::FunctionNameType name_type_mask,
+                         bool include_inlines, bool append,
+                         SymbolContextList &sc_list) override;
 
   uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
                          bool append, SymbolContextList &sc_list) override;
 
   uint32_t FindTypes(const SymbolContext &sc, const ConstString &name,
                      const CompilerDeclContext *parent_decl_ctx, bool append,
                      uint32_t max_matches,
                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,

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

 
 size_t SymbolFileNativePDB::ParseFunctionBlocks(const SymbolContext &sc) {
   lldbassert(sc.comp_unit && sc.function);
   return 0;
 }
 
 uint32_t SymbolFileNativePDB::FindFunctions(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
-    uint32_t name_type_mask, bool include_inlines, bool append,
+    FunctionNameType name_type_mask, bool include_inlines, bool append,
     SymbolContextList &sc_list) {
   // For now we only support lookup by method name.
   if (!(name_type_mask & eFunctionNameTypeMethod))
     return 0;
 
   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
 
   std::vector<SymbolAndOffset> matches = m_index->globals().findRecordsByName(
bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
   if (!error)
     return true;
 
   llvm::consumeError(std::move(error));
   return false;
 }
 
 size_t SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
-                                     uint32_t type_mask,
+                                     TypeClass type_mask,
                                      lldb_private::TypeList &type_list) {
   return 0;
 }
 
 CompilerDeclContext
 SymbolFileNativePDB::FindNamespace(const SymbolContext &sc,
                                    const ConstString &name,
                                    const CompilerDeclContext *parent_decl_ctx) {

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

public:
 
   uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
                                uint32_t max_matches,
                                lldb_private::VariableList &variables) override;
 
   uint32_t
   FindFunctions(const lldb_private::ConstString &name,
                 const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                uint32_t name_type_mask, bool include_inlines, bool append,
-                lldb_private::SymbolContextList &sc_list) override;
+                lldb::FunctionNameType name_type_mask, bool include_inlines,
+                bool append, lldb_private::SymbolContextList &sc_list) override;
 
   uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
                          bool include_inlines, bool append,
                          lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(
       const std::string &scope_qualified_name,
       std::vector<lldb_private::ConstString> &mangled_names) override;
size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
                    bool append, lldb_private::TypeMap &types) override;
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches, lldb_private::TypeMap &types);
 
   lldb_private::TypeList *GetTypeList() override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
-                  uint32_t type_mask,
+                  lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
       const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,

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

void SymbolFilePDB::CacheFunctionNames() {
   m_func_method_names.SizeToFit();
   m_func_base_names.Sort();
   m_func_base_names.SizeToFit();
 }
 
 uint32_t SymbolFilePDB::FindFunctions(
     const lldb_private::ConstString &name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx,
-    uint32_t name_type_mask, bool include_inlines, bool append,
+    FunctionNameType name_type_mask, bool include_inlines, bool append,
     lldb_private::SymbolContextList &sc_list) {
   if (!append)
     sc_list.Clear();
   lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
   if (name_type_mask == eFunctionNameTypeNone)
     return 0;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
   }
 
   auto results_up = pdb_symbol.findAllChildren();
   while (auto symbol_up = results_up->getNext())
     GetTypesForPDBSymbol(*symbol_up, type_mask, type_collection);
 }
 
 size_t SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
-                               uint32_t type_mask,
+                               TypeClass type_mask,
                                lldb_private::TypeList &type_list) {
   TypeCollection type_collection;
   uint32_t old_size = type_list.GetSize();
   CompileUnit *cu =
       sc_scope ? sc_scope->CalculateSymbolContextCompileUnit() : nullptr;
   if (cu) {
     auto compiland_up = GetPDBCompilandByUID(cu->GetID());
     if (!compiland_up)

lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
-                  uint32_t type_mask,
+                  lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;

lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

const char *SymbolFileSymtab::GetPluginDescriptionStatic() {
   return "Reads debug symbols from an object file's symbol table.";
 }
 
 SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFile *obj_file) {
   return new SymbolFileSymtab(obj_file);
 }
 
 size_t SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
-                                  uint32_t type_mask,
+                                  TypeClass type_mask,
                                   lldb_private::TypeList &type_list) {
   return 0;
 }
 
 SymbolFileSymtab::SymbolFileSymtab(ObjectFile *obj_file)
     : SymbolFile(obj_file), m_source_indexes(), m_func_indexes(),
       m_code_indexes(), m_objc_class_name_to_index() {}
 

lldb/trunk/source/Symbol/SymbolFile.cpp

 uint32_t SymbolFile::FindGlobalVariables(const RegularExpression &regex,
                                          uint32_t max_matches,
                                          VariableList &variables) {
   return 0;
 }
 
 uint32_t SymbolFile::FindFunctions(const ConstString &name,
                                    const CompilerDeclContext *parent_decl_ctx,
-                                   uint32_t name_type_mask,
+                                   lldb::FunctionNameType name_type_mask,
                                    bool include_inlines, bool append,
                                    SymbolContextList &sc_list) {
   if (!append)
     sc_list.Clear();
   return 0;
 }
 
 uint32_t SymbolFile::FindFunctions(const RegularExpression &regex,

lldb/trunk/source/Symbol/SymbolVendor.cpp

if (module_sp) {
     if (m_sym_file_ap.get())
       return m_sym_file_ap->FindGlobalVariables(regex, max_matches, variables);
   }
   return 0;
 }
 
 size_t SymbolVendor::FindFunctions(const ConstString &name,
                                    const CompilerDeclContext *parent_decl_ctx,
-                                   uint32_t name_type_mask,
+                                   FunctionNameType name_type_mask,
                                    bool include_inlines, bool append,
                                    SymbolContextList &sc_list) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->FindFunctions(name, parent_decl_ctx, name_type_mask,
                                           include_inlines, append, sc_list);
if (module_sp) {
     if (m_sym_file_ap.get())
       return m_sym_file_ap->FindTypes(context, append, types);
   }
   if (!append)
     types.Clear();
   return 0;
 }
 
-size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, uint32_t type_mask,
+size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, TypeClass type_mask,
                               lldb_private::TypeList &type_list) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->GetTypes(sc_scope, type_mask, type_list);
   }
   return 0;

lldb/trunk/source/Target/Target.cpp

Target::CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal,
   SearchFilterSP filter_sp(
       new SearchFilterForUnconstrainedSearches(shared_from_this()));
   BreakpointResolverSP resolver_sp(
       new BreakpointResolverAddress(nullptr, file_addr, file_spec));
   return CreateBreakpoint(filter_sp, resolver_sp, internal, request_hardware,
                           false);
 }
 
-BreakpointSP
-Target::CreateBreakpoint(const FileSpecList *containingModules,
-                         const FileSpecList *containingSourceFiles,
-                         const char *func_name, uint32_t func_name_type_mask,
-                         LanguageType language, lldb::addr_t offset,
-                         LazyBool skip_prologue, bool internal, bool hardware) {
+BreakpointSP Target::CreateBreakpoint(
+    const FileSpecList *containingModules,
+    const FileSpecList *containingSourceFiles, const char *func_name,
+    FunctionNameType func_name_type_mask, LanguageType language,
+    lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool hardware) {
   BreakpointSP bp_sp;
   if (func_name) {
     SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
         containingModules, containingSourceFiles));
 
     if (skip_prologue == eLazyBoolCalculate)
       skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
     if (language == lldb::eLanguageTypeUnknown)
       language = GetLanguage();
 
     BreakpointResolverSP resolver_sp(new BreakpointResolverName(
         nullptr, func_name, func_name_type_mask, language, Breakpoint::Exact,
         offset, skip_prologue));
     bp_sp = CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
   }
   return bp_sp;
 }
 
 lldb::BreakpointSP
 Target::CreateBreakpoint(const FileSpecList *containingModules,
                          const FileSpecList *containingSourceFiles,
                          const std::vector<std::string> &func_names,
-                         uint32_t func_name_type_mask, LanguageType language,
-                         lldb::addr_t offset, LazyBool skip_prologue,
-                         bool internal, bool hardware) {
+                         FunctionNameType func_name_type_mask,
+                         LanguageType language, lldb::addr_t offset,
+                         LazyBool skip_prologue, bool internal, bool hardware) {
   BreakpointSP bp_sp;
   size_t num_names = func_names.size();
   if (num_names > 0) {
     SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
         containingModules, containingSourceFiles));
 
     if (skip_prologue == eLazyBoolCalculate)
       skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
     if (language == lldb::eLanguageTypeUnknown)
       language = GetLanguage();
 
     BreakpointResolverSP resolver_sp(
         new BreakpointResolverName(nullptr, func_names, func_name_type_mask,
                                    language, offset, skip_prologue));
     bp_sp = CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
   }
   return bp_sp;
 }
 
-BreakpointSP Target::CreateBreakpoint(
-    const FileSpecList *containingModules,
-    const FileSpecList *containingSourceFiles, const char *func_names[],
-    size_t num_names, uint32_t func_name_type_mask, LanguageType language,
-    lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool hardware) {
+BreakpointSP
+Target::CreateBreakpoint(const FileSpecList *containingModules,
+                         const FileSpecList *containingSourceFiles,
+                         const char *func_names[], size_t num_names,
+                         FunctionNameType func_name_type_mask,
+                         LanguageType language, lldb::addr_t offset,
+                         LazyBool skip_prologue, bool internal, bool hardware) {
   BreakpointSP bp_sp;
   if (num_names > 0) {
     SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
         containingModules, containingSourceFiles));
 
     if (skip_prologue == eLazyBoolCalculate) {
       if (offset == 0)
         skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;