Remove append parameter to FindGlobalVariables

[tromey]

Summary

As discussed in https://bugs.llvm.org/show_bug.cgi?id=37317,
FindGlobalVariables does not properly handle the case where
append=false. As this doesn't seem to be used in the tree, this patch
removes the parameter entirely.

[aprantl]

I couldn't find any additional uses of FindGlobalVariables in swift-lldb either.

[tromey]

I don't have commit access, so could someone please land this for me?

[labath]

Thanks for the patch. I've clang-formatted it and committed in r333639.

include/lldb/Core/Module.h

public:
   ///
   /// @param[in] name
   ///     The name of the global or static variable we are looking
   ///     for.
   ///
   /// @param[in] parent_decl_ctx
   ///     If valid, a decl context that results must exist within
   ///
-  /// @param[in] append
-  ///     If \b true, any matches will be appended to \a
-  ///     variable_list, else matches replace the contents of
-  ///     \a variable_list.
-  ///
   /// @param[in] max_matches
   ///     Allow the number of matches to be limited to \a
   ///     max_matches. Specify UINT32_MAX to get all possible matches.
   ///
   /// @param[in] variable_list
-  ///     A list of variables that gets the matches appended to (if
-  ///     \a append it \b true), or replace (if \a append is \b false).
+  ///     A list of variables that gets the matches appended to.
   ///
   /// @return
   ///     The number of matches added to \a variable_list.
   //------------------------------------------------------------------
   size_t FindGlobalVariables(const ConstString &name,
                              const CompilerDeclContext *parent_decl_ctx,
-                             bool append, size_t max_matches,
+                             size_t max_matches,
                              VariableList &variable_list);
 
   //------------------------------------------------------------------
   /// Find global and static variables by regular expression.
   ///
   /// @param[in] regex
   ///     A regular expression to use when matching the name.
   ///
-  /// @param[in] append
-  ///     If \b true, any matches will be appended to \a
-  ///     variable_list, else matches replace the contents of
-  ///     \a variable_list.
-  ///
   /// @param[in] max_matches
   ///     Allow the number of matches to be limited to \a
   ///     max_matches. Specify UINT32_MAX to get all possible matches.
   ///
   /// @param[in] variable_list
-  ///     A list of variables that gets the matches appended to (if
-  ///     \a append it \b true), or replace (if \a append is \b false).
+  ///     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 &regex, bool append,
+  size_t FindGlobalVariables(const RegularExpression &regex,
                              size_t max_matches, VariableList &variable_list);
 
   //------------------------------------------------------------------
   /// Find types by name.
   ///
   /// Type lookups in modules go through the SymbolVendor (which will use one
   /// or more SymbolFile subclasses). The SymbolFile needs to be able to
   /// lookup types by basename and not the fully qualified typename. This

include/lldb/Core/ModuleList.h

public:
 
   //------------------------------------------------------------------
   /// Find global and static variables by name.
   ///
   /// @param[in] name
   ///     The name of the global or static variable we are looking
   ///     for.
   ///
-  /// @param[in] append
-  ///     If \b true, any matches will be appended to \a
-  ///     variable_list, else matches replace the contents of
-  ///     \a variable_list.
-  ///
   /// @param[in] max_matches
   ///     Allow the number of matches to be limited to \a
   ///     max_matches. Specify UINT32_MAX to get all possible matches.
   ///
   /// @param[in] variable_list
-  ///     A list of variables that gets the matches appended to (if
-  ///     \a append it \b true), or replace (if \a append is \b false).
+  ///     A list of variables that gets the matches appended to.
   ///
   /// @return
   ///     The number of matches added to \a variable_list.
   //------------------------------------------------------------------
-  size_t FindGlobalVariables(const ConstString &name, bool append,
+  size_t FindGlobalVariables(const ConstString &name,
                              size_t max_matches,
                              VariableList &variable_list) const;
 
   //------------------------------------------------------------------
   /// Find global and static variables by regular expression.
   ///
   /// @param[in] regex
   ///     A regular expression to use when matching the name.
   ///
-  /// @param[in] append
-  ///     If \b true, any matches will be appended to \a
-  ///     variable_list, else matches replace the contents of
-  ///     \a variable_list.
-  ///
   /// @param[in] max_matches
   ///     Allow the number of matches to be limited to \a
   ///     max_matches. Specify UINT32_MAX to get all possible matches.
   ///
   /// @param[in] variable_list
-  ///     A list of variables that gets the matches appended to (if
-  ///     \a append it \b true), or replace (if \a append is \b false).
+  ///     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 &regex, bool append,
+  size_t FindGlobalVariables(const RegularExpression &regex,
                              size_t max_matches,
                              VariableList &variable_list) const;
 
   //------------------------------------------------------------------
   /// Finds the first module whose file specification matches \a file_spec.
   ///
   /// @param[in] file_spec_ptr
   ///     A file specification object to match against the Module's

include/lldb/Symbol/SymbolFile.h

virtual uint32_t ResolveSymbolContext(const Address &so_addr,
                                         uint32_t resolve_scope,
                                         SymbolContext &sc) = 0;
   virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
                                         uint32_t line, bool check_inlines,
                                         uint32_t resolve_scope,
                                         SymbolContextList &sc_list);
   virtual uint32_t
   FindGlobalVariables(const ConstString &name,
-                      const CompilerDeclContext *parent_decl_ctx, bool append,
+                      const CompilerDeclContext *parent_decl_ctx,
                       uint32_t max_matches, VariableList &variables);
   virtual uint32_t FindGlobalVariables(const RegularExpression &regex,
-                                       bool append, uint32_t max_matches,
+                                       uint32_t max_matches,
                                        VariableList &variables);
   virtual uint32_t FindFunctions(const ConstString &name,
                                  const CompilerDeclContext *parent_decl_ctx,
                                  uint32_t name_type_mask, bool include_inlines,
                                  bool append, SymbolContextList &sc_list);
   virtual uint32_t FindFunctions(const RegularExpression &regex,
                                  bool include_inlines, bool append,
                                  SymbolContextList &sc_list);

include/lldb/Symbol/SymbolVendor.h

public:
 
   virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
                                         uint32_t line, bool check_inlines,
                                         uint32_t resolve_scope,
                                         SymbolContextList &sc_list);
 
   virtual size_t FindGlobalVariables(const ConstString &name,
                                      const CompilerDeclContext *parent_decl_ctx,
-                                     bool append, size_t max_matches,
+                                     size_t max_matches,
                                      VariableList &variables);
 
   virtual size_t FindGlobalVariables(const RegularExpression &regex,
-                                     bool append, size_t max_matches,
+                                     size_t max_matches,
                                      VariableList &variables);
 
   virtual size_t FindFunctions(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t name_type_mask, bool include_inlines,
                                bool append, SymbolContextList &sc_list);
 
   virtual size_t FindFunctions(const RegularExpression &regex,

source/API/SBModule.cpp

 
 SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
                                           uint32_t max_matches) {
   SBValueList sb_value_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {
     VariableList variable_list;
     const uint32_t match_count = module_sp->FindGlobalVariables(
-        ConstString(name), NULL, false, max_matches, variable_list);
+        ConstString(name), NULL, max_matches, variable_list);
 
     if (match_count > 0) {
       for (uint32_t i = 0; i < match_count; ++i) {
         lldb::ValueObjectSP valobj_sp;
         TargetSP target_sp(target.GetSP());
         valobj_sp = ValueObjectVariable::Create(
             target_sp.get(), variable_list.GetVariableAtIndex(i));
         if (valobj_sp)

source/API/SBTarget.cpp

 
 SBValueList SBTarget::FindGlobalVariables(const char *name,
                                           uint32_t max_matches) {
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());
   if (name && target_sp) {
     VariableList variable_list;
-    const bool append = true;
     const uint32_t match_count = target_sp->GetImages().FindGlobalVariables(
-        ConstString(name), append, max_matches, variable_list);
+        ConstString(name), max_matches, variable_list);
 
     if (match_count > 0) {
       ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
       if (exe_scope == NULL)
         exe_scope = target_sp.get();
       for (uint32_t i = 0; i < match_count; ++i) {
         lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create(
             exe_scope, variable_list.GetVariableAtIndex(i)));
SBValueList SBTarget::FindGlobalVariables(const char *name,
                                           uint32_t max_matches,
                                           MatchType matchtype) {
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());
   if (name && target_sp) {
     llvm::StringRef name_ref(name);
     VariableList variable_list;
-    const bool append = true;
 
     std::string regexstr;
     uint32_t match_count;
     switch (matchtype) {
     case eMatchTypeNormal:
       match_count = target_sp->GetImages().FindGlobalVariables(
-          ConstString(name), append, max_matches, variable_list);
+          ConstString(name), max_matches, variable_list);
       break;
     case eMatchTypeRegex:
       match_count = target_sp->GetImages().FindGlobalVariables(
-          RegularExpression(name_ref), append, max_matches, variable_list);
+          RegularExpression(name_ref), max_matches, variable_list);
       break;
     case eMatchTypeStartsWith:
       regexstr = llvm::Regex::escape(name) + ".*";
       match_count = target_sp->GetImages().FindGlobalVariables(
-          RegularExpression(regexstr), append, max_matches, variable_list);
+          RegularExpression(regexstr), max_matches, variable_list);
       break;
     }
 
     if (match_count > 0) {
       ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
       if (exe_scope == NULL)
         exe_scope = target_sp.get();
       for (uint32_t i = 0; i < match_count; ++i) {

source/Commands/CommandObjectTarget.cpp

void DumpValueObject(Stream &s, VariableSP &var_sp, ValueObjectSP &valobj_sp,
 
     valobj_sp->Dump(s, options);
   }
 
   static size_t GetVariableCallback(void *baton, const char *name,
                                     VariableList &variable_list) {
     Target *target = static_cast<Target *>(baton);
     if (target) {
-      return target->GetImages().FindGlobalVariables(ConstString(name), true,
+      return target->GetImages().FindGlobalVariables(ConstString(name),
                                                      UINT32_MAX, variable_list);
     }
     return 0;
   }
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
if (argc > 0) {
           if (!regex.IsValid()) {
             result.GetErrorStream().Printf(
                 "error: invalid regular expression: '%s'\n", arg);
             result.SetStatus(eReturnStatusFailed);
             return false;
           }
           use_var_name = true;
           matches = target->GetImages().FindGlobalVariables(
-              regex, true, UINT32_MAX, variable_list);
+              regex, UINT32_MAX, variable_list);
         } else {
           Status error(Variable::GetValuesForVariableExpressionPath(
               arg, m_exe_ctx.GetBestExecutionContextScope(),
               GetVariableCallback, target, variable_list, valobj_list));
           matches = variable_list.GetSize();
         }
 
         if (matches == 0) {
if (argc > 0) {
                   DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp,
                                          s);
               } else if (sc.module_sp) {
                 // Get all global variables for this module
                 lldb_private::RegularExpression all_globals_regex(
                     llvm::StringRef(
                         ".")); // Any global with at least one character
                 VariableList variable_list;
-                sc.module_sp->FindGlobalVariables(all_globals_regex, append,
+                sc.module_sp->FindGlobalVariables(all_globals_regex,
                                                   UINT32_MAX, variable_list);
                 DumpGlobalVariableList(m_exe_ctx, sc, variable_list, s);
               }
             }
           }
         }
       }
     }

source/Commands/CommandObjectWatchpoint.cpp

corresponding to the byte size of the data type.");
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   static size_t GetVariableCallback(void *baton, const char *name,
                                     VariableList &variable_list) {
     Target *target = static_cast<Target *>(baton);
     if (target) {
-      return target->GetImages().FindGlobalVariables(ConstString(name), true,
+      return target->GetImages().FindGlobalVariables(ConstString(name),
                                                      UINT32_MAX, variable_list);
     }
     return 0;
   }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
     StackFrame *frame = m_exe_ctx.GetFramePtr();

source/Core/Module.cpp

if (symbols)
     symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope,
                                   sc_list);
 
   return sc_list.GetSize() - initial_count;
 }
 
 size_t Module::FindGlobalVariables(const ConstString &name,
                                    const CompilerDeclContext *parent_decl_ctx,
-                                   bool append, size_t max_matches,
+                                   size_t max_matches,
                                    VariableList &variables) {
   SymbolVendor *symbols = GetSymbolVendor();
   if (symbols)
-    return symbols->FindGlobalVariables(name, parent_decl_ctx, append,
+    return symbols->FindGlobalVariables(name, parent_decl_ctx,
                                         max_matches, variables);
   return 0;
 }
 
-size_t Module::FindGlobalVariables(const RegularExpression &regex, bool append,
+size_t Module::FindGlobalVariables(const RegularExpression &regex,
                                    size_t max_matches,
                                    VariableList &variables) {
   SymbolVendor *symbols = GetSymbolVendor();
   if (symbols)
-    return symbols->FindGlobalVariables(regex, append, max_matches, variables);
+    return symbols->FindGlobalVariables(regex, max_matches, variables);
   return 0;
 }
 
 size_t Module::FindCompileUnits(const FileSpec &path, bool append,
                                 SymbolContextList &sc_list) {
   if (!append)
     sc_list.Clear();
 

source/Core/ModuleList.cpp

size_t ModuleList::FindCompileUnits(const FileSpec &path, bool append,
   collection::const_iterator pos, end = m_modules.end();
   for (pos = m_modules.begin(); pos != end; ++pos) {
     (*pos)->FindCompileUnits(path, true, sc_list);
   }
 
   return sc_list.GetSize();
 }
 
-size_t ModuleList::FindGlobalVariables(const ConstString &name, bool append,
+size_t ModuleList::FindGlobalVariables(const ConstString &name,
                                        size_t max_matches,
                                        VariableList &variable_list) const {
   size_t initial_size = variable_list.GetSize();
   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, append, max_matches,
+    (*pos)->FindGlobalVariables(name, nullptr, max_matches,
                                 variable_list);
   }
   return variable_list.GetSize() - initial_size;
 }
 
 size_t ModuleList::FindGlobalVariables(const RegularExpression &regex,
-                                       bool append, size_t max_matches,
+                                       size_t max_matches,
                                        VariableList &variable_list) const {
   size_t initial_size = variable_list.GetSize();
   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, append, max_matches, variable_list);
+    (*pos)->FindGlobalVariables(regex, max_matches, variable_list);
   }
   return variable_list.GetSize() - initial_size;
 }
 
 size_t ModuleList::FindSymbolsWithNameAndType(const ConstString &name,
                                               SymbolType symbol_type,
                                               SymbolContextList &sc_list,
                                               bool append) const {

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 }
 
 lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
     Target &target, ModuleSP &module, const ConstString &name,
     CompilerDeclContext *namespace_decl, TypeFromUser *type) {
   VariableList vars;
 
   if (module && namespace_decl)
-    module->FindGlobalVariables(name, namespace_decl, true, -1, vars);
+    module->FindGlobalVariables(name, namespace_decl, -1, vars);
   else
-    target.GetImages().FindGlobalVariables(name, true, -1, vars);
+    target.GetImages().FindGlobalVariables(name, -1, vars);
 
   if (vars.GetSize()) {
     if (type) {
       for (size_t i = 0; i < vars.GetSize(); ++i) {
         VariableSP var_sp = vars.GetVariableAtIndex(i);
 
         if (ClangASTContext::AreTypesSame(
                 *type, var_sp->GetType()->GetFullCompilerType()))

source/Plugins/ExpressionParser/Go/GoUserExpression.cpp

private:
   Status m_error;
   llvm::StringRef m_package;
   std::vector<std::unique_ptr<GoASTStmt>> m_statements;
 };
 
 VariableSP FindGlobalVariable(TargetSP target, llvm::Twine name) {
   ConstString fullname(name.str());
   VariableList variable_list;
-  const bool append = true;
   if (!target) {
     return nullptr;
   }
   const uint32_t match_count = target->GetImages().FindGlobalVariables(
-      fullname, append, 1, variable_list);
+      fullname, 1, variable_list);
   if (match_count == 1) {
     return variable_list.GetVariableAtIndex(0);
   }
   return nullptr;
 }
 
 CompilerType LookupType(TargetSP target, ConstString name) {
   if (!target)

source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

static void GetSymbolDeclarationFromAddress(ProcessSP process_sp, addr_t addr,
   ConstString sym_name = symbol->GetMangled().GetName(
       lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
 
   ModuleSP module = symbol->CalculateSymbolContextModule();
   if (!module)
     return;
 
   VariableList var_list;
-  module->FindGlobalVariables(sym_name, nullptr, true, 1U, var_list);
+  module->FindGlobalVariables(sym_name, nullptr, 1U, var_list);
   if (var_list.GetSize() < 1)
     return;
 
   VariableSP var = var_list.GetVariableAtIndex(0);
   decl = var->GetDeclaration();
 }
 
 addr_t ThreadSanitizerRuntime::GetFirstNonInternalFramePc(

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

void RenderScriptRuntime::FindStructTypeName(Element &elem,
   else
     elem.type_name = Element::GetFallbackStructName(); // Default type name if
                                                        // we don't succeed
 
   // Find all the global variables from the script rs modules
   VariableList var_list;
   for (auto module_sp : m_rsmodules)
     module_sp->m_module->FindGlobalVariables(
-        RegularExpression(llvm::StringRef(".")), true, UINT32_MAX, var_list);
+        RegularExpression(llvm::StringRef(".")), UINT32_MAX, var_list);
 
   // Iterate over all the global variables looking for one with a matching type
   // to the Element. We make the assumption a match exists since there needs to
   // be a global variable to reflect the struct type back into java host code.
   for (uint32_t i = 0; i < var_list.GetSize(); ++i) {
     const VariableSP var_sp(var_list.GetVariableAtIndex(i));
     if (!var_sp)
       continue;
void RSModuleDescriptor::Dump(Stream &strm) const {
   }
 
   strm.SetIndentLevel(indent);
 }
 
 void RSGlobalDescriptor::Dump(Stream &strm) const {
   strm.Indent(m_name.AsCString());
   VariableList var_list;
-  m_module->m_module->FindGlobalVariables(m_name, nullptr, true, 1U, var_list);
+  m_module->m_module->FindGlobalVariables(m_name, nullptr, 1U, var_list);
   if (var_list.GetSize() == 1) {
     auto var = var_list.GetVariableAtIndex(0);
     auto type = var->GetType();
     if (type) {
       strm.Printf(" - ");
       type->DumpTypeName(&strm);
     } else {
       strm.Printf(" - Unknown Type");

source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

log->Printf("OperatingSystemGo::CreateThread (tid = 0x%" PRIx64
                 ", context = 0x%" PRIx64 ") not implemented",
                 tid, context);
 
   return ThreadSP();
 }
 
 ValueObjectSP OperatingSystemGo::FindGlobal(TargetSP target, const char *name) {
   VariableList variable_list;
-  const bool append = true;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
 
   if (log) {
     log->Printf(
         "exe: %s",
         target->GetExecutableModule()->GetSpecificationDescription().c_str());
     log->Printf("modules: %zu", target->GetImages().GetSize());
   }
 
   uint32_t match_count = target->GetImages().FindGlobalVariables(
-      ConstString(name), append, 1, variable_list);
+      ConstString(name), 1, variable_list);
   if (match_count > 0) {
     ExecutionContextScope *exe_scope = target->GetProcessSP().get();
     if (exe_scope == NULL)
       exe_scope = target.get();
     return ValueObjectVariable::Create(exe_scope,
                                        variable_list.GetVariableAtIndex(0));
   }
   return ValueObjectSP();

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
                        bool check_inlines, uint32_t resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
 
   uint32_t
   FindGlobalVariables(const lldb_private::ConstString &name,
                       const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                      bool append, uint32_t max_matches,
+                      uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
-                               bool append, uint32_t max_matches,
+                               uint32_t max_matches,
                                lldb_private::VariableList &variables) override;
 
   uint32_t
   FindFunctions(const lldb_private::ConstString &name,
                 const lldb_private::CompilerDeclContext *parent_decl_ctx,
                 uint32_t name_type_mask, bool include_inlines, bool append,
                 lldb_private::SymbolContextList &sc_list) override;
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (log)
     GetObjectFile()->GetModule()->LogMessage(
         log, "Valid namespace does not match symbol file");
 
   return false;
 }
 
 uint32_t SymbolFileDWARF::FindGlobalVariables(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
-    bool append, uint32_t max_matches, VariableList &variables) {
+    uint32_t max_matches, VariableList &variables) {
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log)
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
-             "parent_decl_ctx=%p, append=%u, max_matches=%u, variables)",
-        name.GetCString(), static_cast<const void *>(parent_decl_ctx), append,
+             "parent_decl_ctx=%p, max_matches=%u, variables)",
+        name.GetCString(), static_cast<const void *>(parent_decl_ctx),
         max_matches);
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   DWARFDebugInfo *info = DebugInfo();
   if (info == NULL)
     return 0;
 
-  // If we aren't appending the results to this list, then clear the list
-  if (!append)
-    variables.Clear();
-
-  // Remember how many variables are in the list before we search in case we
-  // are appending the results to a variable list.
+  // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   DIEArray die_offsets;
 
   if (m_using_apple_tables) {
     if (m_apple_names_ap.get()) {
       const char *name_cstr = name.GetCString();
       llvm::StringRef basename;
if (num_die_matches) {
     }
   }
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = variables.GetSize() - original_size;
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
-             "parent_decl_ctx=%p, append=%u, max_matches=%u, variables) => %u",
-        name.GetCString(), static_cast<const void *>(parent_decl_ctx), append,
+             "parent_decl_ctx=%p, max_matches=%u, variables) => %u",
+        name.GetCString(), static_cast<const void *>(parent_decl_ctx),
         max_matches, num_matches);
   }
   return num_matches;
 }
 
 uint32_t SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
-                                              bool append, uint32_t max_matches,
+                                              uint32_t max_matches,
                                               VariableList &variables) {
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
-        log, "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, "
+        log, "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", "
              "max_matches=%u, variables)",
-        regex.GetText().str().c_str(), append, max_matches);
+        regex.GetText().str().c_str(), max_matches);
   }
 
   DWARFDebugInfo *info = DebugInfo();
   if (info == NULL)
     return 0;
 
-  // If we aren't appending the results to this list, then clear the list
-  if (!append)
-    variables.Clear();
-
-  // Remember how many variables are in the list before we search in case we
-  // are appending the results to a variable list.
+  // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   DIEArray die_offsets;
 
   if (m_using_apple_tables) {
     if (m_apple_names_ap.get()) {
       DWARFMappedHash::DIEInfoArray hash_data_array;
       if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex(regex,

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb_private::SymbolContext &sc) override;
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
                        bool check_inlines, uint32_t resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
   uint32_t
   FindGlobalVariables(const lldb_private::ConstString &name,
                       const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                      bool append, uint32_t max_matches,
+                      uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
   uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
-                               bool append, uint32_t max_matches,
+                               uint32_t max_matches,
                                lldb_private::VariableList &variables) override;
   uint32_t
   FindFunctions(const lldb_private::ConstString &name,
                 const lldb_private::CompilerDeclContext *parent_decl_ctx,
                 uint32_t name_type_mask, bool include_inlines, bool append,
                 lldb_private::SymbolContextList &sc_list) override;
   uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
                          bool include_inlines, bool append,

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

uint32_t SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
   const size_t match_count = indexes.size();
   for (size_t i = 0; i < match_count; ++i) {
     uint32_t oso_idx;
     CompileUnitInfo *comp_unit_info =
         GetCompileUnitInfoForSymbolWithIndex(indexes[i], &oso_idx);
     if (comp_unit_info) {
       SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
       if (oso_dwarf) {
-        if (oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, true,
+        if (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(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
-    bool append, uint32_t max_matches, VariableList &variables) {
+    uint32_t max_matches, VariableList &variables) {
 
-  // If we aren't appending the results to this list, then clear the list
-  if (!append)
-    variables.Clear();
-
-  // Remember how many variables are in the list before we search in case we
-  // are appending the results to a variable list.
+  // 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, true, max_matches, variables);
+        name, parent_decl_ctx, max_matches, variables);
     if (oso_matches > 0) {
       total_matches += oso_matches;
 
       // Are we getting all matches?
       if (max_matches == UINT32_MAX)
         return false; // Yep, continue getting everything
 
       // If we have found enough matches, lets get out
uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables(
   });
 
   // Return the number of variable that were appended to the list
   return variables.GetSize() - original_size;
 }
 
 uint32_t
 SymbolFileDWARFDebugMap::FindGlobalVariables(const RegularExpression &regex,
-                                             bool append, uint32_t max_matches,
+                                             uint32_t max_matches,
                                              VariableList &variables) {
-  // If we aren't appending the results to this list, then clear the list
-  if (!append)
-    variables.Clear();
-
-  // Remember how many variables are in the list before we search in case we
-  // are appending the results to a variable list.
+  // 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, true, max_matches, variables);
+        oso_dwarf->FindGlobalVariables(regex, max_matches, variables);
     if (oso_matches > 0) {
       total_matches += oso_matches;
 
       // Are we getting all matches?
       if (max_matches == UINT32_MAX)
         return false; // Yep, continue getting everything
 
       // If we have found enough matches, lets get out

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
                        bool check_inlines, uint32_t resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
 
   uint32_t
   FindGlobalVariables(const lldb_private::ConstString &name,
                       const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                      bool append, uint32_t max_matches,
+                      uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
-                               bool append, uint32_t max_matches,
+                               uint32_t max_matches,
                                lldb_private::VariableList &variables) override;
 
   uint32_t
   FindFunctions(const lldb_private::ConstString &name,
                 const lldb_private::CompilerDeclContext *parent_decl_ctx,
                 uint32_t name_type_mask, bool include_inlines, bool append,
                 lldb_private::SymbolContextList &sc_list) override;
 

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

while (auto compiland = compilands->getNext()) {
       }
     }
   }
   return sc_list.GetSize() - old_size;
 }
 
 uint32_t SymbolFilePDB::FindGlobalVariables(
     const lldb_private::ConstString &name,
-    const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append,
+    const lldb_private::CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, lldb_private::VariableList &variables) {
   return uint32_t();
 }
 
 uint32_t
 SymbolFilePDB::FindGlobalVariables(const lldb_private::RegularExpression &regex,
-                                   bool append, uint32_t max_matches,
+                                   uint32_t max_matches,
                                    lldb_private::VariableList &variables) {
   return uint32_t();
 }
 
 bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
                                     bool include_inlines,
                                     lldb_private::SymbolContextList &sc_list) {
   lldb_private::SymbolContext sc;

source/Symbol/SymbolFile.cpp

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

source/Symbol/SymbolVendor.cpp

if (m_sym_file_ap.get())
       return m_sym_file_ap->ResolveSymbolContext(file_spec, line, check_inlines,
                                                  resolve_scope, sc_list);
   }
   return 0;
 }
 
 size_t SymbolVendor::FindGlobalVariables(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
-    bool append, size_t max_matches, VariableList &variables) {
+    size_t max_matches, VariableList &variables) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      return m_sym_file_ap->FindGlobalVariables(name, parent_decl_ctx, append,
+      return m_sym_file_ap->FindGlobalVariables(name, parent_decl_ctx,
                                                 max_matches, variables);
   }
   return 0;
 }
 
 size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex,
-                                         bool append, size_t max_matches,
+                                         size_t max_matches,
                                          VariableList &variables) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      return m_sym_file_ap->FindGlobalVariables(regex, append, max_matches,
+      return m_sym_file_ap->FindGlobalVariables(regex, max_matches,
                                                 variables);
   }
   return 0;
 }
 
 size_t SymbolVendor::FindFunctions(const ConstString &name,
                                    const CompilerDeclContext *parent_decl_ctx,
                                    uint32_t name_type_mask,

tools/lldb-test/lldb-test.cpp

int opts::breakpoint::evaluateBreakpoints(Debugger &Dbg) {
   return HadErrors;
 }
 
 Expected<CompilerDeclContext>
 opts::symbols::getDeclContext(SymbolVendor &Vendor) {
   if (Context.empty())
     return CompilerDeclContext();
   VariableList List;
-  Vendor.FindGlobalVariables(ConstString(Context), nullptr, false, UINT32_MAX,
+  Vendor.FindGlobalVariables(ConstString(Context), nullptr, UINT32_MAX,
                              List);
   if (List.Empty()) {
     return make_error<StringError>("Context search didn't find a match.",
                                    inconvertibleErrorCode());
   }
   if (List.GetSize() > 1) {
     return make_error<StringError>("Context search found multiple matches.",
                                    inconvertibleErrorCode());

 }
 
 Error opts::symbols::findVariables(lldb_private::Module &Module) {
   SymbolVendor &Vendor = *Module.GetSymbolVendor();
   VariableList List;
   if (Regex) {
     RegularExpression RE(Name);
     assert(RE.IsValid());
-    Vendor.FindGlobalVariables(RE, false, UINT32_MAX, List);
+    Vendor.FindGlobalVariables(RE, UINT32_MAX, List);
   } else {
     Expected<CompilerDeclContext> ContextOr = getDeclContext(Vendor);
     if (!ContextOr)
       return ContextOr.takeError();
     CompilerDeclContext *ContextPtr =
         ContextOr->IsValid() ? &*ContextOr : nullptr;
 
-    Vendor.FindGlobalVariables(ConstString(Name), ContextPtr, false, UINT32_MAX,
-                               List);
+    Vendor.FindGlobalVariables(ConstString(Name), ContextPtr, UINT32_MAX, List);
   }
   outs() << formatv("Found {0} variables:\n", List.GetSize());
   StreamString Stream;
   List.Dump(&Stream, false);
   outs() << Stream.GetData() << "\n";
   return Error::success();
 }