maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Don't type-erase the FunctionNameType or TypeClass enums. 

This is similar to D53597, but following up with 2 more enums.
After this, all flag enums should be strongly typed all the way
through to the symbol files plugins.

Differential Revision: https://reviews.llvm.org/D53616

llvm-svn: 345314
This commit is contained in:
Zachary Turner 2018-10-25 20:45:40 +00:00
parent 991e44534a
commit 117b1fa19a
28 changed files with 186 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
lldb/include/lldb/Breakpoint/BreakpointResolverName.h
View File

@ -31,20 +31,23 @@ namespace lldb_private {
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.
@ -89,7 +92,8 @@ protected:
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

40
lldb/include/lldb/Core/Module.h
View File

@ -380,7 +380,7 @@ public:
//------------------------------------------------------------------
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);
@ -1028,9 +1028,10 @@ public:
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; }
@ -1041,24 +1042,31 @@ public:
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:

6
lldb/include/lldb/Core/ModuleList.h
View File

@ -300,14 +300,16 @@ public:
//------------------------------------------------------------------
/// @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);
//------------------------------------------------------------------

7
lldb/include/lldb/Symbol/SymbolFile.h
View File

@ -170,8 +170,9 @@ public:
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);
@ -192,7 +193,7 @@ public:
// 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();

9
lldb/include/lldb/Symbol/SymbolVendor.h
View File

@ -90,8 +90,9 @@ public:
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,
@ -122,8 +123,8 @@ public:
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(); }

32
lldb/include/lldb/Target/Target.h
View File

@ -608,14 +608,12 @@ public:
// 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,
bool request_hardware);
lldb::BreakpointSP
CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp,
@ -637,20 +635,20 @@ public:
// 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:

2
lldb/include/lldb/lldb-enumerations.h
View File

@ -735,6 +735,7 @@ FLAGS_ENUM(FunctionNameType){
eFunctionNameTypeAny =
eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
};
LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType)
//----------------------------------------------------------------------
// Basic types enumeration for the public API SBType::GetBasicType()
@ -809,6 +810,7 @@ FLAGS_ENUM(TypeClass){
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,

26
lldb/source/API/SBCompileUnit.cpp
View File

@ -135,17 +135,21 @@ uint32_t SBCompileUnit::GetNumSupportFiles() const {
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;
ModuleSP module_sp(m_opaque_ptr->GetModule());
if (!module_sp)
return sb_type_list;
SymbolVendor *vendor = module_sp->GetSymbolVendor();
if (!vendor)
return sb_type_list;
TypeClass type_class = static_cast<TypeClass>(type_mask);
TypeList type_list;
vendor->GetTypes(m_opaque_ptr, type_class, type_list);
sb_type_list.m_opaque_ap->Append(type_list);
return sb_type_list;
}

23
lldb/source/API/SBModule.cpp
View File

@ -365,8 +365,9 @@ lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
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;
}
@ -484,14 +485,16 @@ 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;
SymbolVendor *vendor = module_sp->GetSymbolVendor();
if (!vendor)
return sb_type_list;
TypeClass type_class = static_cast<TypeClass>(type_mask);
TypeList type_list;
vendor->GetTypes(NULL, type_class, type_list);
sb_type_list.m_opaque_ap->Append(type_list);
return sb_type_list;
}

39
lldb/source/API/SBTarget.cpp
View File

@ -790,7 +790,7 @@ 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);
@ -817,9 +817,10 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
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)
@ -860,11 +861,11 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
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) {
@ -1735,17 +1736,19 @@ bool SBTarget::GetDescription(SBStream &description,
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;
TargetSP target_sp(GetSP());
if (!target_sp)
return sb_sc_list;
const bool symbols_ok = true;
const bool inlines_ok = true;
const bool append = true;
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;
}

23
lldb/source/Breakpoint/BreakpointResolverName.cpp
View File

@ -30,7 +30,7 @@ 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),
@ -51,7 +51,7 @@ BreakpointResolverName::BreakpointResolverName(
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),
@ -61,9 +61,12 @@ BreakpointResolverName::BreakpointResolverName(
}
}
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) {
@ -161,9 +164,8 @@ BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
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);
@ -171,13 +173,14 @@ BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
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(
@ -220,7 +223,7 @@ StructuredData::ObjectSP BreakpointResolverName::SerializeToStructuredData() {
}
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;

4
lldb/source/Commands/CommandObjectBreakpoint.cpp
View File

@ -636,7 +636,7 @@ public:
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;
@ -765,7 +765,7 @@ protected:
}
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;

14
lldb/source/Core/Module.cpp
View File

@ -635,9 +635,11 @@ size_t Module::FindCompileUnits(const FileSpec &path, bool append,
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;
@ -795,9 +797,9 @@ void Module::LookupInfo::Prune(SymbolContextList &sc_list,
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();

7
lldb/source/Core/ModuleList.cpp
View File

@ -338,8 +338,9 @@ ModuleSP ModuleList::GetModuleAtIndexUnlocked(size_t idx) const {
}
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();
@ -373,7 +374,7 @@ size_t ModuleList::FindFunctions(const ConstString &name,
}
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();

5
lldb/source/Expression/IRExecutionUnit.cpp
View File

@ -709,9 +709,10 @@ FindBestAlternateMangledName(const ConstString &demangled,
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) {}
};

11
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
View File

@ -341,7 +341,7 @@ void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
}
size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
uint32_t type_mask, TypeList &type_list)
TypeClass type_mask, TypeList &type_list)
{
ASSERT_MODULE_LOCK(this);
@ -2288,11 +2288,10 @@ bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *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());

6
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
View File

@ -190,8 +190,8 @@ public:
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,
@ -215,7 +215,7 @@ public:
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 *

4
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
View File

@ -979,7 +979,7 @@ static void RemoveFunctionsWithModuleNotEqualTo(const ModuleSP &module_sp,
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,
@ -1034,7 +1034,7 @@ uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression &regex,
}
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,

6
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
View File

@ -104,8 +104,8 @@ public:
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;
@ -121,7 +121,7 @@ public:
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;

4
lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
View File

@ -1148,7 +1148,7 @@ size_t SymbolFileNativePDB::ParseFunctionBlocks(const SymbolContext &sc) {
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))
@ -1307,7 +1307,7 @@ bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
}
size_t SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
uint32_t type_mask,
TypeClass type_mask,
lldb_private::TypeList &type_list) {
return 0;
}

7
lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h
View File

@ -113,13 +113,14 @@ public:
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;

4
lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
View File

@ -1252,7 +1252,7 @@ void SymbolFilePDB::CacheFunctionNames() {
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();
@ -1524,7 +1524,7 @@ void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
}
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();

6
lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h
View File

@ -122,8 +122,8 @@ public:
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,
@ -150,7 +150,7 @@ public:
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 *

2
lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
View File

@ -46,7 +46,7 @@ SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFile *obj_file) {
}
size_t SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
uint32_t type_mask,
TypeClass type_mask,
lldb_private::TypeList &type_list) {
return 0;
}

2
lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h
View File

@ -88,7 +88,7 @@ public:
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;
//------------------------------------------------------------------

2
lldb/source/Symbol/SymbolFile.cpp
View File

@ -117,7 +117,7 @@ uint32_t SymbolFile::FindGlobalVariables(const RegularExpression &regex,
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)

4
lldb/source/Symbol/SymbolVendor.cpp
View File

@ -288,7 +288,7 @@ size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex,
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());
@ -345,7 +345,7 @@ size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context,
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) {

29
lldb/source/Target/Target.cpp
View File

@ -415,12 +415,11 @@ Target::CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal,
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(
@ -443,9 +442,9 @@ 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) {
@ -465,11 +464,13 @@ Target::CreateBreakpoint(const FileSpecList *containingModules,
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(