ConstString name,
lldb::SymbolType symbol_type = lldb::eSymbolTypeAny);
- size_t FindSymbolsWithNameAndType(ConstString name,
- lldb::SymbolType symbol_type,
- SymbolContextList &sc_list);
+ void FindSymbolsWithNameAndType(ConstString name,
+ lldb::SymbolType symbol_type,
+ SymbolContextList &sc_list);
- size_t FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
- lldb::SymbolType symbol_type,
- SymbolContextList &sc_list);
+ void FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
+ lldb::SymbolType symbol_type,
+ SymbolContextList &sc_list);
/// Find a function symbols in the object file's symbol table.
///
///
/// \param[out] sc_list
/// A list to append any matching symbol contexts to.
- ///
- /// \return
- /// The number of symbol contexts that were added to \a sc_list
- size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
- SymbolContextList &sc_list);
+ void FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
+ SymbolContextList &sc_list);
/// Find compile units by partial or full path.
///
/// \param[in] path
/// The name of the function we are looking for.
///
- /// \param[in] append
- /// If \b true, then append any compile units that were found
- /// to \a sc_list. If \b false, then the \a sc_list is cleared
- /// and the contents of \a sc_list are replaced.
- ///
/// \param[out] sc_list
/// 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 FindCompileUnits(const FileSpec &path, bool append,
- SymbolContextList &sc_list);
+ void FindCompileUnits(const FileSpec &path, SymbolContextList &sc_list);
/// Find functions by name.
///
/// names, base names, C++ methods, or ObjC selectors.
/// See FunctionNameType for more details.
///
- /// \param[in] append
- /// If \b true, any matches will be appended to \a sc_list, else
- /// matches replace the contents of \a sc_list.
- ///
/// \param[out] sc_list
/// 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(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- lldb::FunctionNameType name_type_mask, bool symbols_ok,
- bool inlines_ok, bool append,
- SymbolContextList &sc_list);
+ void FindFunctions(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask, bool symbols_ok,
+ bool inlines_ok, SymbolContextList &sc_list);
/// Find functions by name.
///
/// \param[out] sc_list
/// 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 RegularExpression ®ex, bool symbols_ok,
- bool inlines_ok, bool append,
- SymbolContextList &sc_list);
+ void FindFunctions(const RegularExpression ®ex, bool symbols_ok,
+ bool inlines_ok, SymbolContextList &sc_list);
/// Find addresses by file/line
///
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
///
- /// \return
- /// The number of matches added to \a variable_list.
- size_t FindGlobalVariables(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- size_t max_matches, VariableList &variable_list);
+ void FindGlobalVariables(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ size_t max_matches, VariableList &variable_list);
/// Find global and static variables by regular expression.
///
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
///
- /// \return
- /// The number of matches added to \a variable_list.
- size_t FindGlobalVariables(const RegularExpression ®ex, size_t max_matches,
- VariableList &variable_list);
+ void FindGlobalVariables(const RegularExpression ®ex, size_t max_matches,
+ VariableList &variable_list);
/// Find types by name.
///
/// \param[in] path
/// The name of the compile unit we are looking for.
///
- /// \param[in] append
- /// If \b true, then append any compile units that were found
- /// to \a sc_list. If \b false, then the \a sc_list is cleared
- /// and the contents of \a sc_list are replaced.
- ///
/// \param[out] sc_list
/// 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 FindCompileUnits(const FileSpec &path, bool append,
- SymbolContextList &sc_list) const;
+ void FindCompileUnits(const FileSpec &path, SymbolContextList &sc_list) const;
/// \see Module::FindFunctions ()
- size_t FindFunctions(ConstString name,
- lldb::FunctionNameType name_type_mask,
- bool include_symbols, bool include_inlines, bool append,
- SymbolContextList &sc_list) const;
+ void FindFunctions(ConstString name, lldb::FunctionNameType name_type_mask,
+ bool include_symbols, bool include_inlines,
+ SymbolContextList &sc_list) const;
/// \see Module::FindFunctionSymbols ()
- size_t FindFunctionSymbols(ConstString name,
- lldb::FunctionNameType name_type_mask,
- SymbolContextList &sc_list);
+ void FindFunctionSymbols(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);
+ void FindFunctions(const RegularExpression &name, bool include_symbols,
+ bool include_inlines, SymbolContextList &sc_list);
/// Find global and static variables by name.
///
///
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
- ///
- /// \return
- /// The number of matches added to \a variable_list.
- size_t FindGlobalVariables(ConstString name, size_t max_matches,
- VariableList &variable_list) const;
+ void FindGlobalVariables(ConstString name, size_t max_matches,
+ VariableList &variable_list) const;
/// Find global and static variables by regular expression.
///
///
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
- ///
- /// \return
- /// The number of matches added to \a variable_list.
- size_t FindGlobalVariables(const RegularExpression ®ex, size_t max_matches,
- VariableList &variable_list) const;
+ void FindGlobalVariables(const RegularExpression ®ex, size_t max_matches,
+ VariableList &variable_list) const;
/// Finds the first module whose file specification matches \a file_spec.
///
/// \param[out] matching_module_list
/// A module list that gets filled in with any modules that
/// match the search criteria.
- ///
- /// \return
- /// The number of matching modules found by the search.
- size_t FindModules(const ModuleSpec &module_spec,
- ModuleList &matching_module_list) const;
+ void FindModules(const ModuleSpec &module_spec,
+ ModuleList &matching_module_list) const;
lldb::ModuleSP FindModule(const Module *module_ptr) const;
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const;
- size_t FindSymbolsWithNameAndType(ConstString name,
- lldb::SymbolType symbol_type,
- SymbolContextList &sc_list,
- bool append = false) const;
+ void FindSymbolsWithNameAndType(ConstString name,
+ lldb::SymbolType symbol_type,
+ SymbolContextList &sc_list) const;
- size_t FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
- lldb::SymbolType symbol_type,
- SymbolContextList &sc_list,
- bool append = false) const;
+ void FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
+ lldb::SymbolType symbol_type,
+ SymbolContextList &sc_list) const;
/// Find types by name.
///
/// \return
/// The number of modules in the module list.
size_t GetSize() const;
+ bool IsEmpty() const { return !GetSize(); }
bool LoadScriptingResourcesInTarget(Target *target, std::list<Status> &errors,
Stream *feedback_stream = nullptr,
static bool RemoveSharedModule(lldb::ModuleSP &module_sp);
- static size_t FindSharedModules(const ModuleSpec &module_spec,
- ModuleList &matching_module_list);
+ static void FindSharedModules(const ModuleSpec &module_spec,
+ ModuleList &matching_module_list);
static size_t RemoveOrphanSharedModules(bool mandatory);
return false;
}
- size_t FindMatchingModuleSpecs(const ModuleSpec &module_spec,
- ModuleSpecList &matching_list) const {
+ void FindMatchingModuleSpecs(const ModuleSpec &module_spec,
+ ModuleSpecList &matching_list) const {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
bool exact_arch_match = true;
const size_t initial_match_count = matching_list.GetSize();
matching_list.Append(spec);
}
}
- return matching_list.GetSize() - initial_match_count;
}
void Dump(Stream &strm) {
SymbolContextList &sc_list);
virtual void DumpClangAST(Stream &s) {}
- virtual uint32_t
+ virtual void
FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables);
- virtual uint32_t FindGlobalVariables(const RegularExpression ®ex,
- uint32_t max_matches,
- VariableList &variables);
- virtual uint32_t FindFunctions(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- lldb::FunctionNameType name_type_mask,
- bool include_inlines, bool append,
- SymbolContextList &sc_list);
- virtual uint32_t FindFunctions(const RegularExpression ®ex,
- bool include_inlines, bool append,
- SymbolContextList &sc_list);
+ virtual void FindGlobalVariables(const RegularExpression ®ex,
+ uint32_t max_matches,
+ VariableList &variables);
+ virtual void FindFunctions(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask,
+ bool include_inlines, SymbolContextList &sc_list);
+ virtual void FindFunctions(const RegularExpression ®ex,
+ bool include_inlines, SymbolContextList &sc_list);
virtual void
FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
const RegularExpression ®ex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &indexes);
- size_t FindAllSymbolsWithNameAndType(ConstString name,
- lldb::SymbolType symbol_type,
- std::vector<uint32_t> &symbol_indexes);
- size_t FindAllSymbolsWithNameAndType(ConstString name,
- lldb::SymbolType symbol_type,
- Debug symbol_debug_type,
- Visibility symbol_visibility,
- std::vector<uint32_t> &symbol_indexes);
- size_t FindAllSymbolsMatchingRexExAndType(
+ void FindAllSymbolsWithNameAndType(ConstString name,
+ lldb::SymbolType symbol_type,
+ std::vector<uint32_t> &symbol_indexes);
+ void FindAllSymbolsWithNameAndType(ConstString name,
+ lldb::SymbolType symbol_type,
+ Debug symbol_debug_type,
+ Visibility symbol_visibility,
+ std::vector<uint32_t> &symbol_indexes);
+ void FindAllSymbolsMatchingRexExAndType(
const RegularExpression ®ex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &symbol_indexes);
Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr);
void ForEachSymbolContainingFileAddress(
lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
- size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
- SymbolContextList &sc_list);
+ void FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
+ SymbolContextList &sc_list);
void CalculateSymbolSizes();
void SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
/// The equivalent symbol list - any equivalent symbols found are appended
/// to this list.
///
- /// \return
- /// Number of equivalent symbols found.
- virtual size_t FindEquivalentSymbols(Symbol *original_symbol,
- ModuleList &module_list,
- SymbolContextList &equivalent_symbols) {
- return 0;
- }
+ virtual void FindEquivalentSymbols(Symbol *original_symbol,
+ ModuleList &module_list,
+ SymbolContextList &equivalent_symbols) {}
/// Ask if it is ok to try and load or unload an shared library (image).
///
SBSymbolContextList sb_sc_list;
const ModuleSP module_sp(GetSP());
if (sb_file_spec.IsValid() && module_sp) {
- const bool append = true;
- module_sp->FindCompileUnits(*sb_file_spec, append, *sb_sc_list);
+ module_sp->FindCompileUnits(*sb_file_spec, *sb_sc_list);
}
return LLDB_RECORD_RESULT(sb_sc_list);
}
Symtab *symtab = GetUnifiedSymbolTable(module_sp);
if (symtab) {
std::vector<uint32_t> matching_symbol_indexes;
- const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(
- ConstString(name), symbol_type, matching_symbol_indexes);
+ symtab->FindAllSymbolsWithNameAndType(ConstString(name), symbol_type,
+ matching_symbol_indexes);
+ const size_t num_matches = matching_symbol_indexes.size();
if (num_matches) {
SymbolContext sc;
sc.module_sp = module_sp;
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;
FunctionNameType type = static_cast<FunctionNameType>(name_type_mask);
module_sp->FindFunctions(ConstString(name), nullptr, type, symbols_ok,
- inlines_ok, append, *sb_sc_list);
+ inlines_ok, *sb_sc_list);
}
return LLDB_RECORD_RESULT(sb_sc_list);
}
ModuleSP module_sp(GetSP());
if (name && module_sp) {
VariableList variable_list;
- const uint32_t match_count = module_sp->FindGlobalVariables(
- ConstString(name), nullptr, max_matches, variable_list);
-
+ module_sp->FindGlobalVariables(ConstString(name), nullptr, max_matches,
+ variable_list);
+ const uint32_t match_count = variable_list.GetSize();
if (match_count > 0) {
for (uint32_t i = 0; i < match_count; ++i) {
lldb::ValueObjectSP valobj_sp;
SBSymbolContextList sb_sc_list;
const TargetSP target_sp(GetSP());
- if (target_sp && sb_file_spec.IsValid()) {
- const bool append = true;
- target_sp->GetImages().FindCompileUnits(*sb_file_spec,
- append, *sb_sc_list);
- }
+ if (target_sp && sb_file_spec.IsValid())
+ target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list);
return LLDB_RECORD_RESULT(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);
+ inlines_ok, *sb_sc_list);
return LLDB_RECORD_RESULT(sb_sc_list);
}
switch (matchtype) {
case eMatchTypeRegex:
target_sp->GetImages().FindFunctions(RegularExpression(name_ref), true,
- true, true, *sb_sc_list);
+ true, *sb_sc_list);
break;
case eMatchTypeStartsWith:
regexstr = llvm::Regex::escape(name) + ".*";
target_sp->GetImages().FindFunctions(RegularExpression(regexstr), true,
- true, true, *sb_sc_list);
+ true, *sb_sc_list);
break;
default:
- target_sp->GetImages().FindFunctions(ConstString(name),
- eFunctionNameTypeAny, true, true,
- true, *sb_sc_list);
+ target_sp->GetImages().FindFunctions(
+ ConstString(name), eFunctionNameTypeAny, true, true, *sb_sc_list);
break;
}
}
TargetSP target_sp(GetSP());
if (name && target_sp) {
VariableList variable_list;
- const uint32_t match_count = target_sp->GetImages().FindGlobalVariables(
- ConstString(name), max_matches, variable_list);
-
+ target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
+ variable_list);
+ const uint32_t match_count = variable_list.GetSize();
if (match_count > 0) {
ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
if (exe_scope == nullptr)
uint32_t match_count;
switch (matchtype) {
case eMatchTypeNormal:
- match_count = target_sp->GetImages().FindGlobalVariables(
- ConstString(name), max_matches, variable_list);
+ target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
+ variable_list);
break;
case eMatchTypeRegex:
- match_count = target_sp->GetImages().FindGlobalVariables(
- RegularExpression(name_ref), max_matches, variable_list);
+ target_sp->GetImages().FindGlobalVariables(RegularExpression(name_ref),
+ max_matches, variable_list);
break;
case eMatchTypeStartsWith:
regexstr = llvm::Regex::escape(name) + ".*";
- match_count = target_sp->GetImages().FindGlobalVariables(
- RegularExpression(regexstr), max_matches, variable_list);
+ target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr),
+ max_matches, variable_list);
break;
}
-
+ match_count = variable_list.GetSize();
if (match_count > 0) {
ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
if (exe_scope == nullptr)
SBSymbolContextList sb_sc_list;
if (name && name[0]) {
TargetSP target_sp(GetSP());
- if (target_sp) {
- bool append = true;
+ if (target_sp)
target_sp->GetImages().FindSymbolsWithNameAndType(
- ConstString(name), symbol_type, *sb_sc_list, append);
- }
+ ConstString(name), symbol_type, *sb_sc_list);
}
return LLDB_RECORD_RESULT(sb_sc_list);
}
bool filter_by_language = (m_language != eLanguageTypeUnknown);
const bool include_symbols = !filter_by_cu;
const bool include_inlines = true;
- const bool append = true;
switch (m_match_type) {
case Breakpoint::Exact:
const size_t start_func_idx = func_list.GetSize();
context.module_sp->FindFunctions(
lookup.GetLookupName(), nullptr, lookup.GetNameTypeMask(),
- include_symbols, include_inlines, append, func_list);
+ include_symbols, include_inlines, func_list);
const size_t end_func_idx = func_list.GetSize();
context.module_sp->FindFunctions(
m_regex,
!filter_by_cu, // include symbols only if we aren't filtering by CU
- include_inlines, append, func_list);
+ include_inlines, func_list);
}
break;
case Breakpoint::Glob:
SymbolContextList sc_list;
const bool include_symbols = true;
const bool include_inlines = true;
- const bool append = true;
context.module_sp->FindFunctions(m_regex, include_symbols, include_inlines,
- append, sc_list);
+ sc_list);
SymbolContext sc;
// Now add the functions & symbols to the list - only add if unique:
// const.
ModuleList module_list =
(m_module_list.GetSize() > 0) ? m_module_list : target->GetImages();
- size_t num_matches =
- module_list.FindFunctions(name, eFunctionNameTypeAuto,
- /*include_symbols=*/false,
- /*include_inlines=*/true,
- /*append=*/true, sc_list_funcs);
+ module_list.FindFunctions(name, eFunctionNameTypeAuto,
+ /*include_symbols=*/false,
+ /*include_inlines=*/true, sc_list_funcs);
+ size_t num_matches = sc_list_funcs.GetSize();
+
if (!num_matches) {
// If we didn't find any functions with that name, try searching for
// symbols that line up exactly with function addresses.
SymbolContextList sc_list_symbols;
- size_t num_symbol_matches = module_list.FindFunctionSymbols(
+ module_list.FindFunctionSymbols(
name, eFunctionNameTypeAuto, sc_list_symbols);
+ size_t num_symbol_matches = sc_list_symbols.GetSize();
for (size_t i = 0; i < num_symbol_matches; i++) {
SymbolContext sc;
sc_list_symbols.GetContextAtIndex(i, sc);
FileSpec module_file_spec(m_options.modules[i]);
if (module_file_spec) {
ModuleSpec module_spec(module_file_spec);
- if (target->GetImages().FindModules(module_spec, m_module_list) == 0)
+ target->GetImages().FindModules(module_spec, m_module_list);
+ if (m_module_list.IsEmpty())
result.AppendWarningWithFormat("No module found for '%s'.\n",
m_options.modules[i].c_str());
}
// these somewhere, there should probably be a module-filter-list that can be
// passed to the various ModuleList::Find* calls, which would either be a
// vector of string names or a ModuleSpecList.
- size_t FindMatchingFunctions(Target *target, ConstString name,
+ void FindMatchingFunctions(Target *target, ConstString name,
SymbolContextList &sc_list) {
// Displaying the source for a symbol:
bool include_inlines = true;
- bool append = true;
bool include_symbols = false;
- size_t num_matches = 0;
if (m_options.num_lines == 0)
m_options.num_lines = 10;
ModuleSpec module_spec(module_file_spec);
matching_modules.Clear();
target->GetImages().FindModules(module_spec, matching_modules);
- num_matches += matching_modules.FindFunctions(
+ matching_modules.FindFunctions(
name, eFunctionNameTypeAuto, include_symbols, include_inlines,
- append, sc_list);
+ sc_list);
}
}
} else {
- num_matches = target->GetImages().FindFunctions(
- name, eFunctionNameTypeAuto, include_symbols, include_inlines, append,
- sc_list);
+ target->GetImages().FindFunctions(name, eFunctionNameTypeAuto,
+ include_symbols, include_inlines,
+ sc_list);
}
- return num_matches;
}
- size_t FindMatchingFunctionSymbols(Target *target, ConstString name,
- SymbolContextList &sc_list) {
- size_t num_matches = 0;
+ void FindMatchingFunctionSymbols(Target *target, ConstString name,
+ SymbolContextList &sc_list) {
const size_t num_modules = m_options.modules.size();
if (num_modules > 0) {
ModuleList matching_modules;
ModuleSpec module_spec(module_file_spec);
matching_modules.Clear();
target->GetImages().FindModules(module_spec, matching_modules);
- num_matches += matching_modules.FindFunctionSymbols(
- name, eFunctionNameTypeAuto, sc_list);
+ matching_modules.FindFunctionSymbols(name, eFunctionNameTypeAuto,
+ sc_list);
}
}
} else {
- num_matches = target->GetImages().FindFunctionSymbols(
- name, eFunctionNameTypeAuto, sc_list);
+ target->GetImages().FindFunctionSymbols(name, eFunctionNameTypeAuto,
+ sc_list);
}
- return num_matches;
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
ConstString name(m_options.symbol_name.c_str());
// Displaying the source for a symbol. Search for function named name.
- size_t num_matches = FindMatchingFunctions(target, name, sc_list);
+ FindMatchingFunctions(target, name, sc_list);
+ size_t num_matches = sc_list.GetSize();
if (!num_matches) {
// If we didn't find any functions with that name, try searching for
// symbols that line up exactly with function addresses.
SymbolContextList sc_list_symbols;
- size_t num_symbol_matches =
- FindMatchingFunctionSymbols(target, name, sc_list_symbols);
+ FindMatchingFunctionSymbols(target, name, sc_list_symbols);
+ size_t num_symbol_matches =sc_list_symbols.GetSize();
+
for (size_t i = 0; i < num_symbol_matches; i++) {
SymbolContext sc;
sc_list_symbols.GetContextAtIndex(i, sc);
static size_t GetVariableCallback(void *baton, const char *name,
VariableList &variable_list) {
+ size_t old_size = variable_list.GetSize();
Target *target = static_cast<Target *>(baton);
- if (target) {
- return target->GetImages().FindGlobalVariables(ConstString(name),
- UINT32_MAX, variable_list);
- }
- return 0;
+ if (target)
+ target->GetImages().FindGlobalVariables(ConstString(name), UINT32_MAX,
+ variable_list);
+ return variable_list.GetSize() - old_size;
}
Options *GetOptions() override { return &m_option_group; }
return false;
}
use_var_name = true;
- matches = target->GetImages().FindGlobalVariables(regex, UINT32_MAX,
- variable_list);
+ target->GetImages().FindGlobalVariables(regex, UINT32_MAX,
+ variable_list);
+ matches = variable_list.GetSize();
} else {
Status error(Variable::GetValuesForVariableExpressionPath(
arg, m_exe_ctx.GetBestExecutionContextScope(),
}
} else {
SymbolContextList sc_list;
- const bool append = true;
// We have one or more compile unit or shlib
if (num_shlibs > 0) {
for (size_t shlib_idx = 0; shlib_idx < num_shlibs; ++shlib_idx) {
if (num_compile_units > 0) {
for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
module_sp->FindCompileUnits(
- compile_units.GetFileSpecAtIndex(cu_idx), append,
- sc_list);
+ compile_units.GetFileSpecAtIndex(cu_idx), sc_list);
} else {
SymbolContext sc;
sc.module_sp = module_sp;
// units files that were specified
for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
target->GetImages().FindCompileUnits(
- compile_units.GetFileSpecAtIndex(cu_idx), append, sc_list);
+ compile_units.GetFileSpecAtIndex(cu_idx), sc_list);
}
const uint32_t num_scs = sc_list.GetSize();
bool verbose) {
if (module && name && name[0]) {
SymbolContextList sc_list;
- const bool append = true;
size_t num_matches = 0;
if (name_is_regex) {
RegularExpression function_name_regex((llvm::StringRef(name)));
- num_matches = module->FindFunctions(function_name_regex, include_symbols,
- include_inlines, append, sc_list);
+ module->FindFunctions(function_name_regex, include_symbols,
+ include_inlines, sc_list);
} else {
ConstString function_name(name);
- num_matches = module->FindFunctions(
- function_name, nullptr, eFunctionNameTypeAuto, include_symbols,
- include_inlines, append, sc_list);
+ module->FindFunctions(function_name, nullptr, eFunctionNameTypeAuto,
+ include_symbols, include_inlines, sc_list);
}
-
+ num_matches = sc_list.GetSize();
if (num_matches) {
strm.Indent();
strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches,
}
} else {
if (target) {
- const size_t num_matches =
- target->GetImages().FindModules(module_spec, module_list);
+ target->GetImages().FindModules(module_spec, module_list);
+ const size_t num_matches = module_list.GetSize();
// Not found in our module list for our target, check the main shared
// module list in case it is a extra file used somewhere else
if (search_using_module_spec) {
ModuleList matching_modules;
- const size_t num_matches =
- target->GetImages().FindModules(module_spec, matching_modules);
+ target->GetImages().FindModules(module_spec, matching_modules);
+ const size_t num_matches = matching_modules.GetSize();
char path[PATH_MAX];
if (num_matches == 1) {
if (m_options.m_type == eLookupTypeFunctionOrSymbol) {
ConstString function_name(m_options.m_str.c_str());
target->GetImages().FindFunctions(function_name, eFunctionNameTypeAuto,
- true, false, true, sc_list);
+ true, false, sc_list);
} else if (m_options.m_type == eLookupTypeAddress && target) {
Address addr;
if (target->GetSectionLoadList().ResolveLoadAddress(m_options.m_addr,
// It has a UUID, look for this UUID in the target modules
ModuleSpec symfile_uuid_module_spec;
symfile_uuid_module_spec.GetUUID() = symfile_module_spec.GetUUID();
- num_matches = target->GetImages().FindModules(
- symfile_uuid_module_spec, matching_module_list);
+ target->GetImages().FindModules(symfile_uuid_module_spec,
+ matching_module_list);
+ num_matches = matching_module_list.GetSize();
}
}
ModuleSpec symfile_uuid_module_spec;
symfile_uuid_module_spec.GetUUID() =
symfile_module_spec.GetUUID();
- num_matches = target->GetImages().FindModules(
- symfile_uuid_module_spec, matching_module_list);
+ target->GetImages().FindModules(symfile_uuid_module_spec,
+ matching_module_list);
+ num_matches = matching_module_list.GetSize();
}
}
}
// Just try to match up the file by basename if we have no matches at
// this point
- if (num_matches == 0)
- num_matches =
- target->GetImages().FindModules(module_spec, matching_module_list);
+ if (num_matches == 0) {
+ target->GetImages().FindModules(module_spec, matching_module_list);
+ num_matches = matching_module_list.GetSize();
+ }
while (num_matches == 0) {
ConstString filename_no_extension(
// Replace basename with one less extension
module_spec.GetFileSpec().GetFilename() = filename_no_extension;
- num_matches =
- target->GetImages().FindModules(module_spec, matching_module_list);
+ target->GetImages().FindModules(module_spec, matching_module_list);
+ num_matches = matching_module_list.GetSize();
}
if (num_matches > 1) {
protected:
static size_t GetVariableCallback(void *baton, const char *name,
VariableList &variable_list) {
+ size_t old_size = variable_list.GetSize();
Target *target = static_cast<Target *>(baton);
- if (target) {
- return target->GetImages().FindGlobalVariables(ConstString(name),
- UINT32_MAX, variable_list);
- }
- return 0;
+ if (target)
+ target->GetImages().FindGlobalVariables(ConstString(name), UINT32_MAX,
+ variable_list);
+ return variable_list.GetSize() - old_size;
}
bool DoExecute(Args &command, CommandReturnObject &result) override {
const bool include_symbols = false;
const bool include_inlines = true;
- const bool append = false;
switch (m_match_type) {
case AddressResolver::Exact:
if (context.module_sp) {
eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions(m_func_name, nullptr,
eFunctionNameTypeAuto, include_symbols,
- include_inlines, append, func_list);
+ include_inlines, func_list);
}
break;
context.module_sp->FindSymbolsMatchingRegExAndType(
m_regex, eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions(m_regex, include_symbols,
- include_inlines, append, func_list);
+ include_inlines, func_list);
}
break;
SymbolContextList sc_list;
if (module) {
module->FindFunctions(name, nullptr, eFunctionNameTypeAuto, include_symbols,
- include_inlines, true, sc_list);
+ include_inlines, sc_list);
} else if (exe_ctx.GetTargetPtr()) {
exe_ctx.GetTargetPtr()->GetImages().FindFunctions(
- name, eFunctionNameTypeAuto, include_symbols, include_inlines, false,
- sc_list);
+ name, eFunctionNameTypeAuto, include_symbols, include_inlines, sc_list);
}
// If no functions were found there's nothing to disassemble.
return sc_list.GetSize() - initial_count;
}
-size_t Module::FindGlobalVariables(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- size_t max_matches,
- VariableList &variables) {
+void Module::FindGlobalVariables(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ size_t max_matches, VariableList &variables) {
if (SymbolFile *symbols = GetSymbolFile())
- return symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches,
- variables);
- return 0;
+ symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches, variables);
}
-size_t Module::FindGlobalVariables(const RegularExpression ®ex,
- size_t max_matches,
- VariableList &variables) {
+void Module::FindGlobalVariables(const RegularExpression ®ex,
+ size_t max_matches, VariableList &variables) {
SymbolFile *symbols = GetSymbolFile();
if (symbols)
- return symbols->FindGlobalVariables(regex, max_matches, variables);
- return 0;
+ symbols->FindGlobalVariables(regex, max_matches, variables);
}
-size_t Module::FindCompileUnits(const FileSpec &path, bool append,
- SymbolContextList &sc_list) {
- if (!append)
- sc_list.Clear();
-
- const size_t start_size = sc_list.GetSize();
+void Module::FindCompileUnits(const FileSpec &path,
+ SymbolContextList &sc_list) {
const size_t num_compile_units = GetNumCompileUnits();
SymbolContext sc;
sc.module_sp = shared_from_this();
sc_list.Append(sc);
}
}
- return sc_list.GetSize() - start_size;
}
Module::LookupInfo::LookupInfo(ConstString name,
}
}
-size_t Module::FindFunctions(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- FunctionNameType name_type_mask,
- bool include_symbols, bool include_inlines,
- bool append, SymbolContextList &sc_list) {
- if (!append)
- sc_list.Clear();
-
+void Module::FindFunctions(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ FunctionNameType name_type_mask,
+ bool include_symbols, bool include_inlines,
+ SymbolContextList &sc_list) {
const size_t old_size = sc_list.GetSize();
// Find all the functions (not symbols, but debug information functions...
if (symbols) {
symbols->FindFunctions(lookup_info.GetLookupName(), parent_decl_ctx,
lookup_info.GetNameTypeMask(), include_inlines,
- append, sc_list);
+ sc_list);
// Now check our symbol table for symbols that are code symbols if
// requested
} else {
if (symbols) {
symbols->FindFunctions(name, parent_decl_ctx, name_type_mask,
- include_inlines, append, sc_list);
+ include_inlines, sc_list);
// Now check our symbol table for symbols that are code symbols if
// requested
}
}
}
-
- return sc_list.GetSize() - old_size;
}
-size_t Module::FindFunctions(const RegularExpression ®ex,
- bool include_symbols, bool include_inlines,
- bool append, SymbolContextList &sc_list) {
- if (!append)
- sc_list.Clear();
-
+void Module::FindFunctions(const RegularExpression ®ex, bool include_symbols,
+ bool include_inlines,
+ SymbolContextList &sc_list) {
const size_t start_size = sc_list.GetSize();
if (SymbolFile *symbols = GetSymbolFile()) {
- symbols->FindFunctions(regex, include_inlines, append, sc_list);
+ symbols->FindFunctions(regex, include_inlines, sc_list);
// Now check our symbol table for symbols that are code symbols if
// requested
}
}
}
- return sc_list.GetSize() - start_size;
}
void Module::FindAddressesForLine(const lldb::TargetSP target_sp,
}
}
-size_t Module::FindFunctionSymbols(ConstString name,
+void Module::FindFunctionSymbols(ConstString name,
uint32_t name_type_mask,
SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
"Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
name.AsCString(), name_type_mask);
if (Symtab *symtab = GetSymtab())
- return symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
- return 0;
+ symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
}
-size_t Module::FindSymbolsWithNameAndType(ConstString name,
+void Module::FindSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type,
SymbolContextList &sc_list) {
// No need to protect this call using m_mutex all other method calls are
Timer scoped_timer(
func_cat, "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
name.AsCString(), symbol_type);
- const size_t initial_size = sc_list.GetSize();
if (Symtab *symtab = GetSymtab()) {
std::vector<uint32_t> symbol_indexes;
symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
}
- return sc_list.GetSize() - initial_size;
}
-size_t Module::FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
- SymbolType symbol_type,
- SymbolContextList &sc_list) {
+void Module::FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
+ SymbolType symbol_type,
+ SymbolContextList &sc_list) {
// No need to protect this call using m_mutex all other method calls are
// already thread safe.
func_cat,
"Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
regex.GetText().str().c_str(), symbol_type);
- const size_t initial_size = sc_list.GetSize();
if (Symtab *symtab = GetSymtab()) {
std::vector<uint32_t> symbol_indexes;
symtab->FindAllSymbolsMatchingRexExAndType(
symbol_indexes);
SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
}
- return sc_list.GetSize() - initial_size;
}
void Module::PreloadSymbols() {
return module_sp;
}
-size_t ModuleList::FindFunctions(ConstString name,
- FunctionNameType name_type_mask,
- bool include_symbols, bool include_inlines,
- bool append,
- SymbolContextList &sc_list) const {
- if (!append)
- sc_list.Clear();
-
+void ModuleList::FindFunctions(ConstString name,
+ FunctionNameType name_type_mask,
+ bool include_symbols, bool include_inlines,
+ SymbolContextList &sc_list) const {
const size_t old_size = sc_list.GetSize();
if (name_type_mask & eFunctionNameTypeAuto) {
for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindFunctions(lookup_info.GetLookupName(), nullptr,
lookup_info.GetNameTypeMask(), include_symbols,
- include_inlines, true, sc_list);
+ include_inlines, sc_list);
}
const size_t new_size = sc_list.GetSize();
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols,
- include_inlines, true, sc_list);
+ include_inlines, sc_list);
}
}
- return sc_list.GetSize() - old_size;
}
-size_t ModuleList::FindFunctionSymbols(ConstString name,
- lldb::FunctionNameType name_type_mask,
- SymbolContextList &sc_list) {
+void ModuleList::FindFunctionSymbols(ConstString name,
+ lldb::FunctionNameType name_type_mask,
+ SymbolContextList &sc_list) {
const size_t old_size = sc_list.GetSize();
if (name_type_mask & eFunctionNameTypeAuto) {
(*pos)->FindFunctionSymbols(name, name_type_mask, sc_list);
}
}
-
- return sc_list.GetSize() - old_size;
}
-size_t ModuleList::FindFunctions(const RegularExpression &name,
- bool include_symbols, bool include_inlines,
- bool append, SymbolContextList &sc_list) {
- const size_t old_size = sc_list.GetSize();
-
+void ModuleList::FindFunctions(const RegularExpression &name,
+ bool include_symbols, bool include_inlines,
+ SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) {
- (*pos)->FindFunctions(name, include_symbols, include_inlines, append,
- sc_list);
+ (*pos)->FindFunctions(name, include_symbols, include_inlines, sc_list);
}
-
- return sc_list.GetSize() - old_size;
}
-size_t ModuleList::FindCompileUnits(const FileSpec &path, bool append,
- SymbolContextList &sc_list) const {
- if (!append)
- sc_list.Clear();
-
+void ModuleList::FindCompileUnits(const FileSpec &path,
+ SymbolContextList &sc_list) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) {
- (*pos)->FindCompileUnits(path, true, sc_list);
+ (*pos)->FindCompileUnits(path, sc_list);
}
-
- return sc_list.GetSize();
}
-size_t ModuleList::FindGlobalVariables(ConstString name,
- size_t max_matches,
- VariableList &variable_list) const {
- size_t initial_size = variable_list.GetSize();
+void ModuleList::FindGlobalVariables(ConstString name, size_t max_matches,
+ VariableList &variable_list) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindGlobalVariables(name, nullptr, max_matches, variable_list);
}
- return variable_list.GetSize() - initial_size;
}
-size_t ModuleList::FindGlobalVariables(const RegularExpression ®ex,
- size_t max_matches,
- VariableList &variable_list) const {
- size_t initial_size = variable_list.GetSize();
+void ModuleList::FindGlobalVariables(const RegularExpression ®ex,
+ size_t max_matches,
+ VariableList &variable_list) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindGlobalVariables(regex, max_matches, variable_list);
}
- return variable_list.GetSize() - initial_size;
}
-size_t ModuleList::FindSymbolsWithNameAndType(ConstString name,
- SymbolType symbol_type,
- SymbolContextList &sc_list,
- bool append) const {
+void ModuleList::FindSymbolsWithNameAndType(ConstString name,
+ SymbolType symbol_type,
+ SymbolContextList &sc_list) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
- if (!append)
- sc_list.Clear();
- size_t initial_size = sc_list.GetSize();
-
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
(*pos)->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
- return sc_list.GetSize() - initial_size;
}
-size_t ModuleList::FindSymbolsMatchingRegExAndType(
+void ModuleList::FindSymbolsMatchingRegExAndType(
const RegularExpression ®ex, lldb::SymbolType symbol_type,
- SymbolContextList &sc_list, bool append) const {
+ SymbolContextList &sc_list) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
- if (!append)
- sc_list.Clear();
- size_t initial_size = sc_list.GetSize();
-
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
(*pos)->FindSymbolsMatchingRegExAndType(regex, symbol_type, sc_list);
- return sc_list.GetSize() - initial_size;
}
-size_t ModuleList::FindModules(const ModuleSpec &module_spec,
- ModuleList &matching_module_list) const {
- size_t existing_matches = matching_module_list.GetSize();
-
+void ModuleList::FindModules(const ModuleSpec &module_spec,
+ ModuleList &matching_module_list) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) {
if (module_sp->MatchesModuleSpec(module_spec))
matching_module_list.Append(module_sp);
}
- return matching_module_list.GetSize() - existing_matches;
}
ModuleSP ModuleList::FindModule(const Module *module_ptr) const {
return false;
}
-size_t ModuleList::FindSharedModules(const ModuleSpec &module_spec,
- ModuleList &matching_module_list) {
- return GetSharedModuleList().FindModules(module_spec, matching_module_list);
+void ModuleList::FindSharedModules(const ModuleSpec &module_spec,
+ ModuleList &matching_module_list) {
+ GetSharedModuleList().FindModules(module_spec, matching_module_list);
}
size_t ModuleList::RemoveOrphanSharedModules(bool mandatory) {
// mutex list.
if (!always_create) {
ModuleList matching_module_list;
- const size_t num_matching_modules =
- shared_module_list.FindModules(module_spec, matching_module_list);
+ shared_module_list.FindModules(module_spec, matching_module_list);
+ const size_t num_matching_modules = matching_module_list.GetSize();
+
if (num_matching_modules > 0) {
for (size_t module_idx = 0; module_idx < num_matching_modules;
++module_idx) {
platform_module_spec.GetSymbolFileSpec() =
located_binary_modulespec.GetSymbolFileSpec();
ModuleList matching_module_list;
- if (shared_module_list.FindModules(platform_module_spec,
- matching_module_list) > 0) {
+ shared_module_list.FindModules(platform_module_spec, matching_module_list);
+ if (!matching_module_list.IsEmpty()) {
module_sp = matching_module_list.GetModuleAtIndex(0);
// If we didn't have a UUID in mind when looking for the object file,
ConstString main_name("main");
bool symbols_okay = false; // Force it to be a debug symbol.
bool inlines_okay = true;
- bool append = false;
- size_t num_matches = executable_ptr->FindFunctions(
- main_name, nullptr, lldb::eFunctionNameTypeBase, inlines_okay,
- symbols_okay, append, sc_list);
+ executable_ptr->FindFunctions(main_name, nullptr,
+ lldb::eFunctionNameTypeBase, inlines_okay,
+ symbols_okay, sc_list);
+ size_t num_matches = sc_list.GetSize();
for (size_t idx = 0; idx < num_matches; idx++) {
SymbolContext sc;
sc_list.GetContextAtIndex(idx, sc);
sc.module_sp->FindFunctions(spec.name, nullptr, spec.mask,
true, // include_symbols
false, // include_inlines
- true, // append
sc_list);
}
sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask,
true, // include_symbols
false, // include_inlines
- true, // append
sc_list);
}
Target &target = m_process->GetTarget();
SymbolContextList list;
- if (!target.GetImages().FindSymbolsWithNameAndType(ConstString(name),
- eSymbolTypeAny, list))
+ target.GetImages().FindSymbolsWithNameAndType(ConstString(name),
+ eSymbolTypeAny, list);
+ if (list.IsEmpty())
return false;
Address address = list[0].symbol->GetAddress();
return thread_plan_sp;
}
-size_t DynamicLoaderDarwin::FindEquivalentSymbols(
+void DynamicLoaderDarwin::FindEquivalentSymbols(
lldb_private::Symbol *original_symbol, lldb_private::ModuleList &images,
lldb_private::SymbolContextList &equivalent_symbols) {
ConstString trampoline_name = original_symbol->GetMangled().GetName(
original_symbol->GetLanguage(), Mangled::ePreferMangled);
if (!trampoline_name)
- return 0;
-
- size_t initial_size = equivalent_symbols.GetSize();
+ return;
static const char *resolver_name_regex = "(_gc|_non_gc|\\$[A-Za-z0-9\\$]+)$";
std::string equivalent_regex_buf("^");
equivalent_regex_buf.append(resolver_name_regex);
RegularExpression equivalent_name_regex(equivalent_regex_buf);
- const bool append = true;
images.FindSymbolsMatchingRegExAndType(equivalent_name_regex, eSymbolTypeCode,
- equivalent_symbols, append);
+ equivalent_symbols);
- return equivalent_symbols.GetSize() - initial_size;
}
lldb::ModuleSP DynamicLoaderDarwin::GetPThreadLibraryModule() {
module_spec.GetFileSpec().GetFilename().SetCString(
"libsystem_pthread.dylib");
ModuleList module_list;
- if (m_process->GetTarget().GetImages().FindModules(module_spec,
- module_list)) {
+ m_process->GetTarget().GetImages().FindModules(module_spec, module_list);
+ if (!module_list.IsEmpty()) {
if (module_list.GetSize() == 1) {
module_sp = module_list.GetModuleAtIndex(0);
if (module_sp)
lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
bool stop_others) override;
- size_t FindEquivalentSymbols(
+ void FindEquivalentSymbols(
lldb_private::Symbol *original_symbol,
lldb_private::ModuleList &module_list,
lldb_private::SymbolContextList &equivalent_symbols) override;
Target &target = m_process->GetTarget();
SymbolContextList list;
- if (!target.GetImages().FindSymbolsWithNameAndType(ConstString(name),
- eSymbolTypeAny, list))
- return false;
+ target.GetImages().FindSymbolsWithNameAndType(ConstString(name),
+ eSymbolTypeAny, list);
+ if (list.IsEmpty())
+ return false;
Address address = list[0].symbol->GetAddress();
addr_t addr = address.GetLoadAddress(&target);
const bool include_symbols = false;
const bool include_inlines = false;
- const bool append = false;
std::string interface_name = interface_decl->getNameAsString();
ms.Flush();
ConstString instance_method_name(ms.GetString());
+ sc_list.Clear();
m_target->GetImages().FindFunctions(
instance_method_name, lldb::eFunctionNameTypeFull, include_symbols,
- include_inlines, append, sc_list);
+ include_inlines, sc_list);
if (sc_list.GetSize())
break;
ms.Flush();
ConstString class_method_name(ms.GetString());
+ sc_list.Clear();
m_target->GetImages().FindFunctions(
class_method_name, lldb::eFunctionNameTypeFull, include_symbols,
- include_inlines, append, sc_list);
+ include_inlines, sc_list);
if (sc_list.GetSize())
break;
m_target->GetImages().FindFunctions(
selector_name, lldb::eFunctionNameTypeSelector, include_symbols,
- include_inlines, append, candidate_sc_list);
+ include_inlines, candidate_sc_list);
for (uint32_t ci = 0, ce = candidate_sc_list.GetSize(); ci != ce; ++ci) {
SymbolContext candidate_sc;
}
const bool include_inlines = false;
- const bool append = false;
-
+ sc_list.Clear();
if (namespace_decl && module_sp) {
const bool include_symbols = false;
module_sp->FindFunctions(name, &namespace_decl, eFunctionNameTypeBase,
- include_symbols, include_inlines, append,
- sc_list);
+ include_symbols, include_inlines, sc_list);
} else if (target && !namespace_decl) {
const bool include_symbols = true;
target->GetImages().FindFunctions(name, eFunctionNameTypeFull,
include_symbols, include_inlines,
- append, sc_list);
+ sc_list);
}
// If we found more than one function, see if we can use the frame's decl
SymbolContextList target_symbols;
Target &target = m_process->GetTarget();
- if (!module_list.FindSymbolsWithNameAndType(name, symbol_type,
- target_symbols))
+ module_list.FindSymbolsWithNameAndType(name, symbol_type, target_symbols);
+ if (target_symbols.IsEmpty())
return LLDB_INVALID_ADDRESS;
SymbolContext sym_ctx;
SymbolContextList scl;
target.GetImages().FindSymbolsMatchingRegExAndType(
- RegularExpression{R"(^)" + func_to_match}, eSymbolTypeAny, scl, true);
+ RegularExpression{R"(^)" + func_to_match}, eSymbolTypeAny, scl);
// Case 1,2 or 3
if (scl.GetSize() >= 1) {
SymbolContextList contexts;
SymbolContext context;
- if ((!modules.FindSymbolsWithNameAndType(ConstString("_NSPrintForDebugger"),
- eSymbolTypeCode, contexts)) &&
- (!modules.FindSymbolsWithNameAndType(ConstString("_CFPrintForDebugger"),
- eSymbolTypeCode, contexts)))
- return nullptr;
+ modules.FindSymbolsWithNameAndType(ConstString("_NSPrintForDebugger"),
+ eSymbolTypeCode, contexts);
+ if (contexts.IsEmpty()) {
+ modules.FindSymbolsWithNameAndType(ConstString("_CFPrintForDebugger"),
+ eSymbolTypeCode, contexts);
+ if (contexts.IsEmpty())
+ return nullptr;
+ }
contexts.GetContextAtIndex(0, context);
SymbolContextList sc_list;
- return target.GetImages().FindSymbolsWithNameAndType(
- s_method_signature, eSymbolTypeCode, sc_list) ||
- target.GetImages().FindSymbolsWithNameAndType(
- s_arclite_method_signature, eSymbolTypeCode, sc_list);
+ target.GetImages().FindSymbolsWithNameAndType(s_method_signature,
+ eSymbolTypeCode, sc_list);
+ if (sc_list.IsEmpty())
+ target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature,
+ eSymbolTypeCode, sc_list);
+ return !sc_list.IsEmpty();
}
lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() {
std::function<lldb::addr_t(ConstString)> get_symbol =
[this](ConstString sym) -> lldb::addr_t {
SymbolContextList sc_list;
- if (GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType(
- sym, lldb::eSymbolTypeData, sc_list) == 1) {
+ GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType(
+ sym, lldb::eSymbolTypeData, sc_list);
+ if (sc_list.GetSize() == 1) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
if (sc.symbol)
const ModuleList &modules = m_process->GetTarget().GetImages();
SymbolContextList sc_list;
- const size_t matching_symbols =
- modules.FindSymbolsWithNameAndType(name, eSymbolTypeObjCClass, sc_list);
+ modules.FindSymbolsWithNameAndType(name, eSymbolTypeObjCClass, sc_list);
+ const size_t matching_symbols = sc_list.GetSize();
if (matching_symbols) {
SymbolContext sc;
if (module_sp) {
SymbolContextList contexts;
SymbolContext context;
- if (module_sp->FindSymbolsWithNameAndType(ConstString("start"),
- eSymbolTypeCode, contexts)) {
+ module_sp->FindSymbolsWithNameAndType(ConstString("start"),
+ eSymbolTypeCode, contexts);
+ if (contexts.GetSize()) {
if (contexts.GetContextAtIndex(0, context))
m_entry_point_address = context.symbol->GetAddress();
}
const char *dl_open_name = nullptr;
Target &target = process->GetTarget();
for (auto name: dl_open_names) {
- if (target.GetImages().FindFunctionSymbols(ConstString(name),
- eFunctionNameTypeFull,
- matching_symbols)) {
+ target.GetImages().FindFunctionSymbols(
+ ConstString(name), eFunctionNameTypeFull, matching_symbols);
+ if (matching_symbols.GetSize()) {
dl_open_name = name;
break;
}
if (thread == nullptr)
return false;
- const bool append = true;
const bool include_symbols = true;
const bool include_inlines = false;
SymbolContextList sc_list;
- const uint32_t count = process->GetTarget().GetImages().FindFunctions(
+ process->GetTarget().GetImages().FindFunctions(
ConstString("mmap"), eFunctionNameTypeFull, include_symbols,
- include_inlines, append, sc_list);
+ include_inlines, sc_list);
+ const uint32_t count = sc_list.GetSize();
if (count > 0) {
SymbolContext sc;
if (sc_list.GetContextAtIndex(0, sc)) {
if (thread == nullptr)
return false;
- const bool append = true;
const bool include_symbols = true;
const bool include_inlines = false;
SymbolContextList sc_list;
- const uint32_t count = process->GetTarget().GetImages().FindFunctions(
+ process->GetTarget().GetImages().FindFunctions(
ConstString("munmap"), eFunctionNameTypeFull, include_symbols,
- include_inlines, append, sc_list);
+ include_inlines, sc_list);
+ const uint32_t count = sc_list.GetSize();
if (count > 0) {
SymbolContext sc;
if (sc_list.GetContextAtIndex(0, sc)) {
addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
lldb_private::SymbolContextList sc_list;
- if (process->GetTarget().GetImages().FindSymbolsWithNameAndType(
- ConstString(symbol_name), eSymbolTypeAny, sc_list)) {
+ process->GetTarget().GetImages().FindSymbolsWithNameAndType(
+ ConstString(symbol_name), eSymbolTypeAny, sc_list);
+ if (!sc_list.IsEmpty()) {
const size_t num_scs = sc_list.GetSize();
for (size_t sc_idx = 0;
sc_idx < num_scs &&
return sc_list.GetSize() - old_size;
}
-uint32_t SymbolFileBreakpad::FindFunctions(
+void SymbolFileBreakpad::FindFunctions(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
- FunctionNameType name_type_mask, bool include_inlines, bool append,
+ FunctionNameType name_type_mask, bool include_inlines,
SymbolContextList &sc_list) {
// TODO
- if (!append)
- sc_list.Clear();
- return sc_list.GetSize();
}
-uint32_t SymbolFileBreakpad::FindFunctions(const RegularExpression ®ex,
- bool include_inlines, bool append,
- SymbolContextList &sc_list) {
+void SymbolFileBreakpad::FindFunctions(const RegularExpression ®ex,
+ bool include_inlines,
+ SymbolContextList &sc_list) {
// TODO
- if (!append)
- sc_list.Clear();
- return sc_list.GetSize();
}
void SymbolFileBreakpad::FindTypes(
size_t ParseBlocksRecursive(Function &func) override { return 0; }
- uint32_t FindGlobalVariables(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- uint32_t max_matches,
- VariableList &variables) override {
- return 0;
- }
+ void FindGlobalVariables(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ uint32_t max_matches,
+ VariableList &variables) override {}
size_t ParseVariablesForContext(const SymbolContext &sc) override {
return 0;
void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
TypeList &type_list) override {}
- uint32_t FindFunctions(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- lldb::FunctionNameType name_type_mask,
- bool include_inlines, bool append,
- SymbolContextList &sc_list) override;
+ void FindFunctions(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask,
+ bool include_inlines, SymbolContextList &sc_list) override;
- uint32_t FindFunctions(const RegularExpression ®ex, bool include_inlines,
- bool append, SymbolContextList &sc_list) override;
+ void FindFunctions(const RegularExpression ®ex, bool include_inlines,
+ SymbolContextList &sc_list) override;
void FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
return false;
}
-uint32_t SymbolFileDWARF::FindGlobalVariables(
+void SymbolFileDWARF::FindGlobalVariables(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
max_matches);
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
- return 0;
+ return;
DWARFDebugInfo *info = DebugInfo();
- if (info == nullptr)
- return 0;
+ if (!info)
+ return;
// Remember how many variables are in the list before we search.
const uint32_t original_size = variables.GetSize();
name.GetCString(), static_cast<const void *>(parent_decl_ctx),
max_matches, num_matches);
}
- return num_matches;
}
-uint32_t SymbolFileDWARF::FindGlobalVariables(const RegularExpression ®ex,
- uint32_t max_matches,
- VariableList &variables) {
+void SymbolFileDWARF::FindGlobalVariables(const RegularExpression ®ex,
+ uint32_t max_matches,
+ VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
}
DWARFDebugInfo *info = DebugInfo();
- if (info == nullptr)
- return 0;
+ if (!info)
+ return;
// Remember how many variables are in the list before we search.
const uint32_t original_size = variables.GetSize();
m_index->ReportInvalidDIERef(die_ref, regex.GetText());
}
}
-
- // Return the number of variable that were appended to the list
- return variables.GetSize() - original_size;
}
bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
return false;
}
-uint32_t SymbolFileDWARF::FindFunctions(
- ConstString name, const CompilerDeclContext *parent_decl_ctx,
- FunctionNameType name_type_mask, bool include_inlines, bool append,
- SymbolContextList &sc_list) {
+void SymbolFileDWARF::FindFunctions(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ FunctionNameType name_type_mask,
+ bool include_inlines,
+ SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
if (log) {
GetObjectFile()->GetModule()->LogMessage(
log,
- "SymbolFileDWARF::FindFunctions (name=\"%s\", "
- "name_type_mask=0x%x, append=%u, sc_list)",
- name.GetCString(), name_type_mask, append);
+ "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, sc_list)",
+ name.GetCString(), name_type_mask);
}
- // If we aren't appending the results to this list, then clear the list
- if (!append)
- sc_list.Clear();
-
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
- return 0;
+ return;
// If name is empty then we won't find anything.
if (name.IsEmpty())
- return 0;
+ return;
// Remember how many sc_list are in the list before we search in case we are
// appending the results to a variable list.
GetObjectFile()->GetModule()->LogMessage(
log,
"SymbolFileDWARF::FindFunctions (name=\"%s\", "
- "name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => "
- "%u",
- name.GetCString(), name_type_mask, include_inlines, append,
+ "name_type_mask=0x%x, include_inlines=%d, sc_list) => %u",
+ name.GetCString(), name_type_mask, include_inlines,
num_matches);
}
- return num_matches;
}
-uint32_t SymbolFileDWARF::FindFunctions(const RegularExpression ®ex,
- bool include_inlines, bool append,
- SymbolContextList &sc_list) {
+void SymbolFileDWARF::FindFunctions(const RegularExpression ®ex,
+ bool include_inlines,
+ SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (regex = '%s')",
if (log) {
GetObjectFile()->GetModule()->LogMessage(
- log,
- "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)",
- regex.GetText().str().c_str(), append);
+ log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
+ regex.GetText().str().c_str());
}
- // If we aren't appending the results to this list, then clear the list
- if (!append)
- sc_list.Clear();
-
DWARFDebugInfo *info = DebugInfo();
if (!info)
- return 0;
-
- // Remember how many sc_list are in the list before we search in case we are
- // appending the results to a variable list.
- uint32_t original_size = sc_list.GetSize();
+ return;
DIEArray offsets;
m_index->GetFunctions(regex, offsets);
if (resolved_dies.insert(die.GetDIE()).second)
ResolveFunction(die, include_inlines, sc_list);
}
-
- // Return the number of variable that were appended to the list
- return sc_list.GetSize() - original_size;
}
void SymbolFileDWARF::GetMangledNamesForFunction(
lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContextList &sc_list) override;
- uint32_t
+ void
FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
lldb_private::VariableList &variables) override;
- uint32_t FindGlobalVariables(const lldb_private::RegularExpression ®ex,
- uint32_t max_matches,
- lldb_private::VariableList &variables) override;
+ void FindGlobalVariables(const lldb_private::RegularExpression ®ex,
+ uint32_t max_matches,
+ lldb_private::VariableList &variables) override;
- uint32_t
- FindFunctions(lldb_private::ConstString name,
- const lldb_private::CompilerDeclContext *parent_decl_ctx,
- lldb::FunctionNameType name_type_mask, bool include_inlines,
- bool append, lldb_private::SymbolContextList &sc_list) override;
-
- uint32_t FindFunctions(const lldb_private::RegularExpression ®ex,
- bool include_inlines, bool append,
- lldb_private::SymbolContextList &sc_list) override;
+ void FindFunctions(lldb_private::ConstString name,
+ const lldb_private::CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask,
+ bool include_inlines,
+ lldb_private::SymbolContextList &sc_list) override;
+
+ void FindFunctions(const lldb_private::RegularExpression ®ex,
+ bool include_inlines,
+ lldb_private::SymbolContextList &sc_list) override;
void GetMangledNamesForFunction(
const std::string &scope_qualified_name,
return sc_list.GetSize() - initial;
}
-uint32_t SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
+void SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
const std::vector<uint32_t>
&indexes, // Indexes into the symbol table that match "name"
uint32_t max_matches, VariableList &variables) {
- const uint32_t original_size = variables.GetSize();
const size_t match_count = indexes.size();
for (size_t i = 0; i < match_count; ++i) {
uint32_t oso_idx;
if (comp_unit_info) {
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
if (oso_dwarf) {
- if (oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches,
- variables))
- if (variables.GetSize() > max_matches)
- break;
+ oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches,
+ variables);
+ if (variables.GetSize() > max_matches)
+ break;
}
}
}
- return variables.GetSize() - original_size;
}
-uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables(
+void SymbolFileDWARFDebugMap::FindGlobalVariables(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-
- // Remember how many variables are in the list before we search.
- const uint32_t original_size = variables.GetSize();
-
uint32_t total_matches = 0;
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
- const uint32_t oso_matches = oso_dwarf->FindGlobalVariables(
- name, parent_decl_ctx, max_matches, variables);
+ const uint32_t old_size = variables.GetSize();
+ oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches,
+ variables);
+ const uint32_t oso_matches = variables.GetSize() - old_size;
if (oso_matches > 0) {
total_matches += oso_matches;
return false;
});
-
- // Return the number of variable that were appended to the list
- return variables.GetSize() - original_size;
}
-uint32_t
-SymbolFileDWARFDebugMap::FindGlobalVariables(const RegularExpression ®ex,
- uint32_t max_matches,
- VariableList &variables) {
+void SymbolFileDWARFDebugMap::FindGlobalVariables(
+ const RegularExpression ®ex, uint32_t max_matches,
+ VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
- // Remember how many variables are in the list before we search.
- const uint32_t original_size = variables.GetSize();
-
uint32_t total_matches = 0;
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
- const uint32_t oso_matches =
- oso_dwarf->FindGlobalVariables(regex, max_matches, variables);
+ const uint32_t old_size = variables.GetSize();
+ oso_dwarf->FindGlobalVariables(regex, max_matches, variables);
+
+ const uint32_t oso_matches = variables.GetSize() - old_size;
if (oso_matches > 0) {
total_matches += oso_matches;
return false;
});
-
- // Return the number of variable that were appended to the list
- return variables.GetSize() - original_size;
}
int SymbolFileDWARFDebugMap::SymbolContainsSymbolWithIndex(
}
}
-uint32_t SymbolFileDWARFDebugMap::FindFunctions(
+void SymbolFileDWARFDebugMap::FindFunctions(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
- FunctionNameType name_type_mask, bool include_inlines, bool append,
+ FunctionNameType name_type_mask, bool include_inlines,
SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
"SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
name.GetCString());
- uint32_t initial_size = 0;
- if (append)
- initial_size = sc_list.GetSize();
- else
- sc_list.Clear();
-
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
uint32_t sc_idx = sc_list.GetSize();
- if (oso_dwarf->FindFunctions(name, parent_decl_ctx, name_type_mask,
- include_inlines, true, sc_list)) {
+ oso_dwarf->FindFunctions(name, parent_decl_ctx, name_type_mask,
+ include_inlines, sc_list);
+ if (!sc_list.IsEmpty()) {
RemoveFunctionsWithModuleNotEqualTo(m_objfile_sp->GetModule(), sc_list,
sc_idx);
}
return false;
});
-
- return sc_list.GetSize() - initial_size;
}
-uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression ®ex,
- bool include_inlines,
- bool append,
- SymbolContextList &sc_list) {
+void SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression ®ex,
+ bool include_inlines,
+ SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat,
"SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')",
regex.GetText().str().c_str());
- uint32_t initial_size = 0;
- if (append)
- initial_size = sc_list.GetSize();
- else
- sc_list.Clear();
-
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
uint32_t sc_idx = sc_list.GetSize();
- if (oso_dwarf->FindFunctions(regex, include_inlines, true, sc_list)) {
+ oso_dwarf->FindFunctions(regex, include_inlines, sc_list);
+ if (!sc_list.IsEmpty()) {
RemoveFunctionsWithModuleNotEqualTo(m_objfile_sp->GetModule(), sc_list,
sc_idx);
}
return false;
});
-
- return sc_list.GetSize() - initial_size;
}
void SymbolFileDWARFDebugMap::GetTypes(SymbolContextScope *sc_scope,
bool check_inlines,
lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContextList &sc_list) override;
- uint32_t
+ void
FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
lldb_private::VariableList &variables) override;
- uint32_t FindGlobalVariables(const lldb_private::RegularExpression ®ex,
- uint32_t max_matches,
- lldb_private::VariableList &variables) override;
- uint32_t
- FindFunctions(lldb_private::ConstString name,
- const lldb_private::CompilerDeclContext *parent_decl_ctx,
- lldb::FunctionNameType name_type_mask, bool include_inlines,
- bool append, lldb_private::SymbolContextList &sc_list) override;
- uint32_t FindFunctions(const lldb_private::RegularExpression ®ex,
- bool include_inlines, bool append,
- lldb_private::SymbolContextList &sc_list) override;
+ void FindGlobalVariables(const lldb_private::RegularExpression ®ex,
+ uint32_t max_matches,
+ lldb_private::VariableList &variables) override;
+ void FindFunctions(lldb_private::ConstString name,
+ const lldb_private::CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask,
+ bool include_inlines,
+ lldb_private::SymbolContextList &sc_list) override;
+ void FindFunctions(const lldb_private::RegularExpression ®ex,
+ bool include_inlines,
+ lldb_private::SymbolContextList &sc_list) override;
void
FindTypes(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
static int SymbolContainsSymbolWithID(lldb::user_id_t *symbol_idx_ptr,
const CompileUnitInfo *comp_unit_info);
- uint32_t PrivateFindGlobalVariables(
+ void PrivateFindGlobalVariables(
lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
const std::vector<uint32_t> &name_symbol_indexes, uint32_t max_matches,
void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
-uint32_t SymbolFileNativePDB::FindGlobalVariables(
+void SymbolFileNativePDB::FindGlobalVariables(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
continue;
}
}
- return variables.GetSize();
}
-uint32_t SymbolFileNativePDB::FindFunctions(
+void SymbolFileNativePDB::FindFunctions(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
- FunctionNameType name_type_mask, bool include_inlines, bool append,
+ FunctionNameType name_type_mask, bool include_inlines,
SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
// For now we only support lookup by method name.
if (!(name_type_mask & eFunctionNameTypeMethod))
- return 0;
+ return;
using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
sc_list.Append(sc);
}
-
- return sc_list.GetSize();
}
-uint32_t SymbolFileNativePDB::FindFunctions(const RegularExpression ®ex,
- bool include_inlines, bool append,
- SymbolContextList &sc_list) {
- return 0;
-}
+void SymbolFileNativePDB::FindFunctions(const RegularExpression ®ex,
+ bool include_inlines,
+ SymbolContextList &sc_list) {}
void SymbolFileNativePDB::FindTypes(
ConstString name, const CompilerDeclContext *parent_decl_ctx,
size_t ParseBlocksRecursive(Function &func) override;
- uint32_t FindGlobalVariables(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- uint32_t max_matches,
- VariableList &variables) override;
+ void FindGlobalVariables(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ uint32_t max_matches,
+ VariableList &variables) override;
size_t ParseVariablesForContext(const SymbolContext &sc) override;
void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
TypeList &type_list) override;
- uint32_t FindFunctions(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- lldb::FunctionNameType name_type_mask,
- bool include_inlines, bool append,
- SymbolContextList &sc_list) override;
+ void FindFunctions(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask,
+ bool include_inlines, SymbolContextList &sc_list) override;
- uint32_t FindFunctions(const RegularExpression ®ex, bool include_inlines,
- bool append, SymbolContextList &sc_list) override;
+ void FindFunctions(const RegularExpression ®ex, bool include_inlines,
+ SymbolContextList &sc_list) override;
void FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
return num_added;
}
-uint32_t SymbolFilePDB::FindGlobalVariables(
+void SymbolFilePDB::FindGlobalVariables(
lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, lldb_private::VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
- return 0;
+ return;
if (name.IsEmpty())
- return 0;
+ return;
auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
if (!results)
- return 0;
+ return;
uint32_t matches = 0;
size_t old_size = variables.GetSize();
ParseVariables(sc, *pdb_data, &variables);
matches = variables.GetSize() - old_size;
}
-
- return matches;
}
-uint32_t
-SymbolFilePDB::FindGlobalVariables(const lldb_private::RegularExpression ®ex,
- uint32_t max_matches,
- lldb_private::VariableList &variables) {
+void SymbolFilePDB::FindGlobalVariables(
+ const lldb_private::RegularExpression ®ex, uint32_t max_matches,
+ lldb_private::VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (!regex.IsValid())
- return 0;
+ return;
auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
if (!results)
- return 0;
+ return;
uint32_t matches = 0;
size_t old_size = variables.GetSize();
ParseVariables(sc, *pdb_data, &variables);
matches = variables.GetSize() - old_size;
}
-
- return matches;
}
bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
m_func_base_names.SizeToFit();
}
-uint32_t SymbolFilePDB::FindFunctions(
+void SymbolFilePDB::FindFunctions(
lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
- FunctionNameType name_type_mask, bool include_inlines, bool append,
+ FunctionNameType name_type_mask, bool include_inlines,
lldb_private::SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
- if (!append)
- sc_list.Clear();
lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
if (name_type_mask == eFunctionNameTypeNone)
- return 0;
+ return;
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
- return 0;
+ return;
if (name.IsEmpty())
- return 0;
+ return;
- auto old_size = sc_list.GetSize();
if (name_type_mask & eFunctionNameTypeFull ||
name_type_mask & eFunctionNameTypeBase ||
name_type_mask & eFunctionNameTypeMethod) {
ResolveFn(m_func_base_names);
ResolveFn(m_func_method_names);
}
- if (name_type_mask & eFunctionNameTypeBase) {
+ if (name_type_mask & eFunctionNameTypeBase)
ResolveFn(m_func_base_names);
- }
- if (name_type_mask & eFunctionNameTypeMethod) {
+ if (name_type_mask & eFunctionNameTypeMethod)
ResolveFn(m_func_method_names);
- }
}
- return sc_list.GetSize() - old_size;
}
-uint32_t
-SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression ®ex,
- bool include_inlines, bool append,
- lldb_private::SymbolContextList &sc_list) {
+void SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression ®ex,
+ bool include_inlines,
+ lldb_private::SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
- if (!append)
- sc_list.Clear();
if (!regex.IsValid())
- return 0;
+ return;
auto old_size = sc_list.GetSize();
CacheFunctionNames();
};
ResolveFn(m_func_full_names);
ResolveFn(m_func_base_names);
-
- return sc_list.GetSize() - old_size;
}
void SymbolFilePDB::GetMangledNamesForFunction(
lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContextList &sc_list) override;
- uint32_t
+ void
FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
lldb_private::VariableList &variables) override;
- uint32_t FindGlobalVariables(const lldb_private::RegularExpression ®ex,
- uint32_t max_matches,
- lldb_private::VariableList &variables) override;
+ void FindGlobalVariables(const lldb_private::RegularExpression ®ex,
+ uint32_t max_matches,
+ lldb_private::VariableList &variables) override;
- uint32_t
- FindFunctions(lldb_private::ConstString name,
- const lldb_private::CompilerDeclContext *parent_decl_ctx,
- lldb::FunctionNameType name_type_mask, bool include_inlines,
- bool append, lldb_private::SymbolContextList &sc_list) override;
-
- uint32_t FindFunctions(const lldb_private::RegularExpression ®ex,
- bool include_inlines, bool append,
- lldb_private::SymbolContextList &sc_list) override;
+ void FindFunctions(lldb_private::ConstString name,
+ const lldb_private::CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask,
+ bool include_inlines,
+ lldb_private::SymbolContextList &sc_list) override;
+
+ void FindFunctions(const lldb_private::RegularExpression ®ex,
+ bool include_inlines,
+ lldb_private::SymbolContextList &sc_list) override;
void GetMangledNamesForFunction(
const std::string &scope_qualified_name,
static ConstString introspection_dispatch_queue_info_version(
"__introspection_dispatch_queue_info_version");
SymbolContextList sc_list;
- if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
- introspection_dispatch_queue_info_version, eSymbolTypeData, sc_list) >
- 0) {
+ m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
+ introspection_dispatch_queue_info_version, eSymbolTypeData, sc_list);
+ if (!sc_list.IsEmpty()) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
AddressRange addr_range;
static ConstString introspection_dispatch_queue_info_data_offset(
"__introspection_dispatch_queue_info_data_offset");
- if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
- introspection_dispatch_queue_info_data_offset, eSymbolTypeData,
- sc_list) > 0) {
+ m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
+ introspection_dispatch_queue_info_data_offset, eSymbolTypeData, sc_list);
+ if (!sc_list.IsEmpty()) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
AddressRange addr_range;
static ConstString introspection_dispatch_item_info_version(
"__introspection_dispatch_item_info_version");
- if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
- introspection_dispatch_item_info_version, eSymbolTypeData, sc_list) >
- 0) {
+ m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
+ introspection_dispatch_item_info_version, eSymbolTypeData, sc_list);
+ if (!sc_list.IsEmpty()) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
AddressRange addr_range;
static ConstString introspection_dispatch_item_info_data_offset(
"__introspection_dispatch_item_info_data_offset");
- if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
- introspection_dispatch_item_info_data_offset, eSymbolTypeData,
- sc_list) > 0) {
+ m_process->GetTarget().GetImages().FindSymbolsWithNameAndType(
+ introspection_dispatch_item_info_data_offset, eSymbolTypeData, sc_list);
+ if (!sc_list.IsEmpty()) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
AddressRange addr_range;
auto resolve_lazy_callee = [&]() -> Function * {
ConstString callee_name{lazy_callee.symbol_name};
SymbolContextList sc_list;
- size_t num_matches =
- images.FindFunctionSymbols(callee_name, eFunctionNameTypeAuto, sc_list);
+ images.FindFunctionSymbols(callee_name, eFunctionNameTypeAuto, sc_list);
+ size_t num_matches = sc_list.GetSize();
if (num_matches == 0 || !sc_list[0].symbol) {
LLDB_LOG(log, "CallEdge: Found no symbols for {0}, cannot resolve it",
callee_name);
return 0;
}
-uint32_t
-SymbolFile::FindGlobalVariables(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- uint32_t max_matches, VariableList &variables) {
- return 0;
-}
-
-uint32_t SymbolFile::FindGlobalVariables(const RegularExpression ®ex,
- uint32_t max_matches,
- VariableList &variables) {
- return 0;
-}
-
-uint32_t SymbolFile::FindFunctions(ConstString name,
- const CompilerDeclContext *parent_decl_ctx,
- 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 ®ex,
- bool include_inlines, bool append,
- SymbolContextList &sc_list) {
- if (!append)
- sc_list.Clear();
- return 0;
-}
+void SymbolFile::FindGlobalVariables(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ uint32_t max_matches,
+ VariableList &variables) {}
+
+void SymbolFile::FindGlobalVariables(const RegularExpression ®ex,
+ uint32_t max_matches,
+ VariableList &variables) {}
+
+void SymbolFile::FindFunctions(ConstString name,
+ const CompilerDeclContext *parent_decl_ctx,
+ lldb::FunctionNameType name_type_mask,
+ bool include_inlines,
+ SymbolContextList &sc_list) {}
+
+void SymbolFile::FindFunctions(const RegularExpression ®ex,
+ bool include_inlines,
+ SymbolContextList &sc_list) {}
void SymbolFile::GetMangledNamesForFunction(
const std::string &scope_qualified_name,
return nullptr;
}
-size_t
+void
Symtab::FindAllSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type,
std::vector<uint32_t> &symbol_indexes) {
// the symbols and match the symbol_type if any was given.
AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_indexes);
}
- return symbol_indexes.size();
}
-size_t Symtab::FindAllSymbolsWithNameAndType(
+void Symtab::FindAllSymbolsWithNameAndType(
ConstString name, SymbolType symbol_type, Debug symbol_debug_type,
Visibility symbol_visibility, std::vector<uint32_t> &symbol_indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_debug_type,
symbol_visibility, symbol_indexes);
}
- return symbol_indexes.size();
}
-size_t Symtab::FindAllSymbolsMatchingRexExAndType(
+void Symtab::FindAllSymbolsMatchingRexExAndType(
const RegularExpression ®ex, SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &symbol_indexes) {
AppendSymbolIndexesMatchingRegExAndType(regex, symbol_type, symbol_debug_type,
symbol_visibility, symbol_indexes);
- return symbol_indexes.size();
}
Symbol *Symtab::FindFirstSymbolWithNameAndType(ConstString name,
}
}
-size_t Symtab::FindFunctionSymbols(ConstString name,
- uint32_t name_type_mask,
- SymbolContextList &sc_list) {
- size_t count = 0;
+void Symtab::FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
+ SymbolContextList &sc_list) {
std::vector<uint32_t> symbol_indexes;
// eFunctionNameTypeAuto should be pre-resolved by a call to
symbol_indexes.erase(
std::unique(symbol_indexes.begin(), symbol_indexes.end()),
symbol_indexes.end());
- count = symbol_indexes.size();
SymbolIndicesToSymbolContextList(symbol_indexes, sc_list);
}
-
- return count;
}
const Symbol *Symtab::GetParent(Symbol *child_symbol) const {
if (GetBreakpointsConsultPlatformAvoidList()) {
ModuleList matchingModules;
ModuleSpec module_spec(module_file_spec);
- size_t num_modules = GetImages().FindModules(module_spec, matchingModules);
+ GetImages().FindModules(module_spec, matchingModules);
+ size_t num_modules = matchingModules.GetSize();
- // If there is more than one module for this file spec, only return true if
- // ALL the modules are on the
- // black list.
+ // If there is more than one module for this file spec, only
+ // return true if ALL the modules are on the black list.
if (num_modules > 0) {
for (size_t i = 0; i < num_modules; i++) {
if (!ModuleIsExcludedForUnconstrainedSearches(
module_spec_copy.GetUUID().Clear();
ModuleList found_modules;
- size_t num_found =
- m_images.FindModules(module_spec_copy, found_modules);
- if (num_found == 1) {
+ m_images.FindModules(module_spec_copy, found_modules);
+ if (found_modules.GetSize() == 1)
old_module_sp = found_modules.GetModuleAtIndex(0);
- }
}
}
} else if (Regex) {
RegularExpression RE(Name);
assert(RE.IsValid());
- Symfile.FindFunctions(RE, true, false, List);
+ List.Clear();
+ Symfile.FindFunctions(RE, true, List);
} else {
Expected<CompilerDeclContext> ContextOr = getDeclContext(Symfile);
if (!ContextOr)
CompilerDeclContext *ContextPtr =
ContextOr->IsValid() ? &*ContextOr : nullptr;
+ List.Clear();
Symfile.FindFunctions(ConstString(Name), ContextPtr, getFunctionNameFlags(),
- true, false, List);
+ true, List);
}
outs() << formatv("Found {0} functions:\n", List.GetSize());
StreamString Stream;
auto Count = [M](const char *Name, FunctionNameType Type) -> int {
SymbolContextList SymList;
- return M->FindFunctionSymbols(ConstString(Name), Type, SymList);
+ M->FindFunctionSymbols(ConstString(Name), Type, SymList);
+ return SymList.GetSize();
};
// Unmangled
ASSERT_TRUE(bool(module_sp));
SymbolContextList sc_list;
- EXPECT_EQ(1u, module_sp->FindFunctionSymbols(ConstString("boom"),
- eFunctionNameTypeFull, sc_list));
+ module_sp->FindFunctionSymbols(ConstString("boom"), eFunctionNameTypeFull,
+ sc_list);
+ EXPECT_EQ(1u, sc_list.GetSize());
EXPECT_STREQ(GetDummyRemotePath().GetCString(),
module_sp->GetPlatformFileSpec().GetCString());
EXPECT_STREQ(module_uuid, module_sp->GetUUID().GetAsString().c_str());
projects / platform / upstream / llvm.git / commitdiff