[llvm-nm][NFC] remove global variable " std::vector<NMSymbol> SymbolList"

[DiggerLin]

Summary

according to Jame's comment in the patch https://reviews.llvm.org/D112735
I created a NFC patch to remove global variable " std::vector<NMSymbol> SymbolList"

[jhenderson]

I think you may be doing too much in this patch. I think you should start with a patch that literally just changes from a global SymbolList to a local one that's passed down the stack as required. You can then make other changes on top of that to continue the refactoring we discussed.

[DiggerLin]

In D120687#3350476, @jhenderson wrote:

I think you may be doing too much in this patch. I think you should start with a patch that literally just changes from a global SymbolList to a local one that's passed down the stack as required. You can then make other changes on top of that to continue the refactoring we discussed.

Any criterion on how to create a NFC patch?  It is difficult for me the control the size of the NFC patch, I already did three refactor patches on the llvm-nm.cpp before I can reach your comment on the patch https://reviews.llvm.org/D112735 , I always feel sad when you tell me that I need to split a patches into two patches , it is time consume  for me to split the patches after I post a patch.  I need to  change the code, compile and test the separate patches.  And I also have my team work on my hand.

[jhenderson]

In D120687#3351246, @DiggerLin wrote:

In D120687#3350476, @jhenderson wrote:

I think you may be doing too much in this patch. I think you should start with a patch that literally just changes from a global SymbolList to a local one that's passed down the stack as required. You can then make other changes on top of that to continue the refactoring we discussed.

Any criterion on how to create a NFC patch?  It is difficult for me the control the size of the NFC patch, I already did three refactor patches on the llvm-nm.cpp before I can reach your comment on the patch https://reviews.llvm.org/D112735 , I always feel sad when you tell me that I need to split a patches into two patches , it is time consume  for me to split the patches after I post a patch.  I need to  change the code, compile and test the separate patches.

In general, you should try to keep patches to a minimum size - prefer lots of individual patches over one larger patch to achieve a goal - you'll rarely, if ever find people complaining about you splitting something up too much! This is because it is much harder to review larger changes versus smaller changes, especially if the review is either busy or is not all that familiar with the area. I'm sorry you feel sad about being asked to do these things - it isn't my intention to upset you. However, small, incremental changes are a good developer habit to get into, whether working in open source, on proprietary code, or on personal projects. This is because it is easier to ensure it is correct when done incrementally. There are a number of good books out there that discuss things like this topic. I'm afraid I'm not good at recommending this sort of thing though. It's also worth reading through LLVM's guidelines on creating and reviewing patches (e.g. https://llvm.org/docs/DeveloperPolicy.html and https://llvm.org/docs/CodeReview.html).

In this particular context, you have at least two different items in this patch: the changes to the symbol list population, and the ObjMemBufs stuff. They don't seem to be intertwined with each other such that you couldn't do one without the other. As such, in the ideal world, you should do them separately.

And I also have my team work on my hand.

Please remember that reviewers also usually have their own work to do. Reviews are done to help ensure a thriving community where people help each other out. I myself often review things that nobody else ever gets around to, but am pushing the amount of time I can spend on reviews as it is. Keeping things simple for reviewers is important. If you don't, people simply won't review your code and you'll never get it landed.

[DiggerLin]

address comment

[jhenderson]

LGTM, with one nit.

llvm/tools/llvm-nm/llvm-nm.cpp

2432

Nit: I'd delete this blank line.

[DiggerLin]

In D120687#3351412, @jhenderson wrote:

In D120687#3351246, @DiggerLin wrote:

In D120687#3350476, @jhenderson wrote:

I think you may be doing too much in this patch. I think you should start with a patch that literally just changes from a global SymbolList to a local one that's passed down the stack as required. You can then make other changes on top of that to continue the refactoring we discussed.

Any criterion on how to create a NFC patch?  It is difficult for me the control the size of the NFC patch, I already did three refactor patches on the llvm-nm.cpp before I can reach your comment on the patch https://reviews.llvm.org/D112735 , I always feel sad when you tell me that I need to split a patches into two patches , it is time consume  for me to split the patches after I post a patch.  I need to  change the code, compile and test the separate patches.

In general, you should try to keep patches to a minimum size - prefer lots of individual patches over one larger patch to achieve a goal - you'll rarely, if ever find people complaining about you splitting something up too much! This is because it is much harder to review larger changes versus smaller changes, especially if the review is either busy or is not all that familiar with the area. I'm sorry you feel sad about being asked to do these things - it isn't my intention to upset you. However, small, incremental changes are a good developer habit to get into, whether working in open source, on proprietary code, or on personal projects. This is because it is easier to ensure it is correct when done incrementally. There are a number of good books out there that discuss things like this topic. I'm afraid I'm not good at recommending this sort of thing though. It's also worth reading through LLVM's guidelines on creating and reviewing patches (e.g. https://llvm.org/docs/DeveloperPolicy.html and https://llvm.org/docs/CodeReview.html).

In this particular context, you have at least two different items in this patch: the changes to the symbol list population, and the ObjMemBufs stuff. They don't seem to be intertwined with each other such that you couldn't do one without the other. As such, in the ideal world, you should do them separately.

And I also have my team work on my hand.

Please remember that reviewers also usually have their own work to do. Reviews are done to help ensure a thriving community where people help each other out. I myself often review things that nobody else ever gets around to, but am pushing the amount of time I can spend on reviews as it is. Keeping things simple for reviewers is important. If you don't, people simply won't review your code and you'll never get it landed.

Thanks a lot of for your time and professional review comment.

llvm/tools/llvm-nm/llvm-nm.cpp

static char isSymbolList64Bit(SymbolicFile &Obj) {
   if (TapiFile *Tapi = dyn_cast<TapiFile>(&Obj))
     return Tapi->is64Bit();
   if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
     return MachO->is64Bit();
   return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
 }
 
 static StringRef CurrentFilename;
-static std::vector<NMSymbol> SymbolList;
 
 static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I);
 
 // darwinPrintSymbol() is used to print a symbol from a Mach-O file when the
 // the OutputFormat is darwin or we are printing Mach-O symbols in hex.  For
 // the darwin format it produces the same output as darwin's nm(1) -m output
 // and when printing Mach-O symbols in hex it produces the same output as
 // darwin's nm(1) -x format.
if (OutputFormat == posix && !ArchiveName.empty())
     S << ArchiveName << "[" << CurrentFilename << "]: ";
   else {
     if (!ArchiveName.empty())
       S << ArchiveName << ":";
     S << CurrentFilename << ": ";
   }
 }
 
-static void sortSymbolList() {
+static void sortSymbolList(std::vector<NMSymbol> &SymbolList) {
   if (NoSort)
     return;
 
   if (ReverseSort)
     llvm::sort(SymbolList, std::greater<>());
   else
     llvm::sort(SymbolList);
 }
 
-static void printExportSymbolList() {
+static void printExportSymbolList(const std::vector<NMSymbol> &SymbolList) {
   for (const NMSymbol &Sym : SymbolList) {
     outs() << Sym.Name;
     if (!Sym.Visibility.empty())
       outs() << ' ' << Sym.Visibility;
     outs() << '\n';
   }
 }
 
-static void printSymbolList(SymbolicFile &Obj, bool printName,
+static void printSymbolList(SymbolicFile &Obj,
+                            std::vector<NMSymbol> &SymbolList, bool printName,
                             StringRef ArchiveName, StringRef ArchitectureName) {
   if (!PrintFileName) {
     if ((OutputFormat == bsd || OutputFormat == posix ||
          OutputFormat == just_symbols) &&
         MultipleFiles && printName) {
       outs() << '\n' << CurrentFilename << ":\n";
     } else if (OutputFormat == sysv) {
       outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n";
static unsigned getNsectInMachO(MachOObjectFile &Obj, BasicSymbolRef Sym) {
   if (Obj.is64Bit()) {
     MachO::nlist_64 STE = Obj.getSymbol64TableEntry(Symb);
     return (STE.n_type & MachO::N_TYPE) == MachO::N_SECT ? STE.n_sect : 0;
   }
   MachO::nlist STE = Obj.getSymbolTableEntry(Symb);
   return (STE.n_type & MachO::N_TYPE) == MachO::N_SECT ? STE.n_sect : 0;
 }
 
-static void dumpSymbolsFromDLInfoMachO(MachOObjectFile &MachO) {
+static void dumpSymbolsFromDLInfoMachO(MachOObjectFile &MachO,
+                                       std::vector<NMSymbol> &SymbolList) {
   size_t I = SymbolList.size();
   std::string ExportsNameBuffer;
   raw_string_ostream EOS(ExportsNameBuffer);
   std::string BindsNameBuffer;
   raw_string_ostream BOS(BindsNameBuffer);
   std::string LazysNameBuffer;
   raw_string_ostream LOS(LazysNameBuffer);
   std::string WeaksNameBuffer;
static bool shouldDump(SymbolicFile &Obj) {
   if (!isa<XCOFFObjectFile>(Obj) && !isa<ELFObjectFileBase>(Obj) &&
       !isa<IRObjectFile>(Obj))
     return true;
 
   return isSymbolList64Bit(Obj) ? BitMode != BitModeTy::Bit32
                                 : BitMode != BitModeTy::Bit64;
 }
 
-static void getXCOFFExports(XCOFFObjectFile *XCOFFObj, StringRef ArchiveName) {
+static void getXCOFFExports(XCOFFObjectFile *XCOFFObj,
+                            std::vector<NMSymbol> &SymbolList,
+                            StringRef ArchiveName) {
   // Skip Shared object file.
   if (XCOFFObj->getFlags() & XCOFF::F_SHROBJ)
     return;
 
   for (SymbolRef Sym : XCOFFObj->symbols()) {
     // There is no visibility in old 32 bit XCOFF object file interpret.
     bool HasVisibilityAttr =
         XCOFFObj->is64Bit() || (XCOFFObj->auxiliaryHeader32() &&

 static Expected<SymbolicFile::basic_symbol_iterator_range>
 getDynamicSyms(SymbolicFile &Obj) {
   const auto *E = dyn_cast<ELFObjectFileBase>(&Obj);
   if (!E)
     return createError("File format has no dynamic symbol table");
   return E->getDynamicSymbolIterators();
 }
 
-// Returns false if an error is encounted or true otherwise.
-static bool getSymbolNamesFromObject(SymbolicFile &Obj) {
+// Returns false if there is error found or true otherwise.
+static bool getSymbolNamesFromObject(SymbolicFile &Obj,
+                                     std::vector<NMSymbol> &SymbolList) {
   auto Symbols = Obj.symbols();
   std::vector<VersionEntry> SymbolVersions;
 
   if (DynamicSyms) {
     Expected<SymbolicFile::basic_symbol_iterator_range> SymbolsOrErr =
         getDynamicSyms(Obj);
     if (!SymbolsOrErr) {
       error(SymbolsOrErr.takeError(), Obj.getFileName());
static bool getSymbolNamesFromObject(SymbolicFile &Obj,
 
   // If this is a Mach-O file where the nlist symbol table is out of sync
   // with the dyld export trie then look through exports and fake up symbols
   // for the ones that are missing (also done with the -add-dyldinfo flag).
   // This is needed if strip(1) -T is run on a binary containing swift
   // language symbols for example.  The option -only-dyldinfo will fake up
   // all symbols from the dyld export trie as well as the bind info.
   if (MachO && !NoDyldInfo)
-    dumpSymbolsFromDLInfoMachO(*MachO);
+    dumpSymbolsFromDLInfoMachO(*MachO, SymbolList);
+
   return true;
 }
 
 static void printObjectLabel(bool PrintArchiveName, StringRef ArchiveName,
                              StringRef ArchitectureName,
                              StringRef ObjectFileName) {
   outs() << "\n";
   if (ArchiveName.empty() || !PrintArchiveName)
Expected<SymbolicFile::basic_symbol_iterator_range> DynamicSymsOrErr =
         getDynamicSyms(Obj);
     if (!DynamicSymsOrErr)
       return DynamicSymsOrErr.takeError();
     return !DynamicSymsOrErr->empty();
   }
   return !Obj.symbols().empty();
 }
 
-static void dumpSymbolNamesFromObject(SymbolicFile &Obj, bool PrintSymbolObject,
-                                      bool PrintObjectLabel,
-                                      StringRef ArchiveName = {},
-                                      StringRef ArchitectureName = {},
-                                      StringRef ObjectName = {},
-                                      bool PrintArchiveName = true) {
+static void dumpSymbolNamesFromObject(
+    SymbolicFile &Obj, std::vector<NMSymbol> &SymbolList,
+    bool PrintSymbolObject, bool PrintObjectLabel, StringRef ArchiveName = {},
+    StringRef ArchitectureName = {}, StringRef ObjectName = {},
   if (!shouldDump(Obj))
     return;
 
   if (ExportSymbols && Obj.isXCOFF()) {
     XCOFFObjectFile *XCOFFObj = cast<XCOFFObjectFile>(&Obj);
-    getXCOFFExports(XCOFFObj, ArchiveName);
+    getXCOFFExports(XCOFFObj, SymbolList, ArchiveName);
     return;
   }
 
   if (PrintObjectLabel && !ExportSymbols)
     printObjectLabel(PrintArchiveName, ArchiveName, ArchitectureName,
                      ObjectName.empty() ? Obj.getFileName() : ObjectName);
-  if (!getSymbolNamesFromObject(Obj) || ExportSymbols)
+  if (!getSymbolNamesFromObject(Obj, SymbolList) || ExportSymbols)
     return;
   CurrentFilename = Obj.getFileName();
 
   // If there is an error in hasSymbols(), the error should be encountered in
   // function getSymbolNamesFromObject first.
   if (!cantFail(hasSymbols(Obj)) && SymbolList.empty() && !Quiet) {
     writeFileName(errs(), ArchiveName, ArchitectureName);
     errs() << "no symbols\n";
   }
 
-  sortSymbolList();
-  printSymbolList(Obj, PrintSymbolObject, ArchiveName, ArchitectureName);
+  sortSymbolList(SymbolList);
+  printSymbolList(Obj, SymbolList, PrintSymbolObject, ArchiveName,
+                  ArchitectureName);
 }
 
 // checkMachOAndArchFlags() checks to see if the SymbolicFile is a Mach-O file
 // and if it is and there is a list of architecture flags is specified then
 // check to make sure this Mach-O file is one of those architectures or all
 // architectures was specificed.  If not then an error is generated and this
 // routine returns false.  Else it returns true.
 static bool checkMachOAndArchFlags(SymbolicFile *O, std::string &Filename) {
for (; I != E; ++I) {
       }
       StringRef SymName = I->getName();
       outs() << SymName << " in " << FileNameOrErr.get() << "\n";
     }
     outs() << "\n";
   }
 }
 
-static void dumpArchive(Archive *A, std::string &Filename,
-                        LLVMContext *ContextPtr) {
+static void dumpArchive(Archive *A, std::vector<NMSymbol> &SymbolList,
+                        std::string &Filename, LLVMContext *ContextPtr) {
   if (ArchiveMap)
     dumpArchiveMap(A, Filename);
 
   Error Err = Error::success();
   for (auto &C : A->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(ContextPtr);
     if (!ChildOrErr) {
       if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
         error(std::move(E), Filename, C);
       continue;
     }
     if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
       if (!MachOPrintSizeWarning && PrintSize && isa<MachOObjectFile>(O)) {
         WithColor::warning(errs(), ToolName)
             << "sizes with -print-size for Mach-O files are always zero.\n";
         MachOPrintSizeWarning = true;
       }
       if (!checkMachOAndArchFlags(O, Filename))
         return;
-      dumpSymbolNamesFromObject(*O, /*PrintSymbolObject=*/false, !PrintFileName,
-                                Filename,
+      dumpSymbolNamesFromObject(*O, SymbolList, /*PrintSymbolObject=*/false,
+                                !PrintFileName, Filename,
                                 /*ArchitectureName=*/{}, O->getFileName(),
                                 /*PrintArchiveName=*/false);
     }
   }
   if (Err)
     error(std::move(Err), A->getFileName());
 }
 
-static void dumpMachOUniversalBinaryMatchArchFlags(MachOUniversalBinary *UB,
-                                                   std::string &Filename,
-                                                   LLVMContext *ContextPtr) {
+static void dumpMachOUniversalBinaryMatchArchFlags(
+    MachOUniversalBinary *UB, std::vector<NMSymbol> &SymbolList,
+    std::string &Filename, LLVMContext *ContextPtr) {
   // Look for a slice in the universal binary that matches each ArchFlag.
   bool ArchFound;
   for (unsigned i = 0; i < ArchFlags.size(); ++i) {
     ArchFound = false;
     for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
                                                E = UB->end_objects();
          I != E; ++I) {
       if (ArchFlags[i] == I->getArchFlagName()) {
         ArchFound = true;
         Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
         std::string ArchiveName;
         std::string ArchitectureName;
         ArchiveName.clear();
         ArchitectureName.clear();
         if (ObjOrErr) {
           ObjectFile &Obj = *ObjOrErr.get();
           if (ArchFlags.size() > 1)
             ArchitectureName = I->getArchFlagName();
-          dumpSymbolNamesFromObject(Obj, /*PrintSymbolObject=*/false,
+          dumpSymbolNamesFromObject(Obj, SymbolList,
+                                    /*PrintSymbolObject=*/false,
                                     (ArchFlags.size() > 1) && !PrintFileName,
                                     ArchiveName, ArchitectureName);
         } else if (auto E =
                        isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
           error(std::move(E), Filename,
                 ArchFlags.size() > 1 ? StringRef(I->getArchFlagName())
                                      : StringRef());
           continue;
for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
                                            : StringRef());
               }
               continue;
             }
             if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
               ArchiveName = std::string(A->getFileName());
               if (ArchFlags.size() > 1)
                 ArchitectureName = I->getArchFlagName();
-              dumpSymbolNamesFromObject(*O, /*PrintSymbolObject=*/false,
-                                        !PrintFileName, ArchiveName,
-                                        ArchitectureName);
+              dumpSymbolNamesFromObject(
+                  *O, SymbolList, /*PrintSymbolObject=*/false, !PrintFileName,
+                  ArchiveName, ArchitectureName);
             }
           }
           if (Err)
             error(std::move(Err), A->getFileName());
         } else {
           consumeError(AOrErr.takeError());
           error(Filename + " for architecture " +
                     StringRef(I->getArchFlagName()) +
                     " is not a Mach-O file or an archive file",
                 "Mach-O universal file");
         }
       }
     }
     if (!ArchFound) {
       error(ArchFlags[i],
             "file: " + Filename + " does not contain architecture");
       return;
     }
   }
 }
 
 // Returns true If the binary contains a slice that matches the host
 // architecture, or false otherwise.
 static bool dumpMachOUniversalBinaryMatchHost(MachOUniversalBinary *UB,
+                                              std::vector<NMSymbol> &SymbolList,
                                               std::string &Filename,
                                               LLVMContext *ContextPtr) {
   Triple HostTriple = MachOObjectFile::getHostArch();
   StringRef HostArchName = HostTriple.getArchName();
   for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
                                              E = UB->end_objects();
        I != E; ++I) {
     if (HostArchName == I->getArchFlagName()) {
       Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
       std::string ArchiveName;
       if (ObjOrErr) {
         ObjectFile &Obj = *ObjOrErr.get();
-        dumpSymbolNamesFromObject(Obj, /*PrintSymbolObject=*/false,
+        dumpSymbolNamesFromObject(Obj, SymbolList, /*PrintSymbolObject=*/false,
                                   /*PrintObjectLabel=*/false);
       } else if (auto E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError()))
         error(std::move(E), Filename);
       else if (Expected<std::unique_ptr<Archive>> AOrErr = I->getAsArchive()) {
         std::unique_ptr<Archive> &A = *AOrErr;
         Error Err = Error::success();
         for (auto &C : A->children(Err)) {
           Expected<std::unique_ptr<Binary>> ChildOrErr =
               C.getAsBinary(ContextPtr);
           if (!ChildOrErr) {
             if (auto E =
                     isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
               error(std::move(E), Filename, C);
             continue;
           }
           if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
             ArchiveName = std::string(A->getFileName());
-            dumpSymbolNamesFromObject(*O, /*PrintSymbolObject=*/false,
+            dumpSymbolNamesFromObject(*O, SymbolList,
+                                      /*PrintSymbolObject=*/false,
                                       !PrintFileName, ArchiveName);
           }
         }
         if (Err)
           error(std::move(Err), A->getFileName());
       } else {
         consumeError(AOrErr.takeError());
         error(Filename + " for architecture " +
                   StringRef(I->getArchFlagName()) +
                   " is not a Mach-O file or an archive file",
               "Mach-O universal file");
       }
       return true;
     }
   }
   return false;
 }
 
 static void dumpMachOUniversalBinaryArchAll(MachOUniversalBinary *UB,
+                                            std::vector<NMSymbol> &SymbolList,
                                             std::string &Filename,
                                             LLVMContext *ContextPtr) {
   bool moreThanOneArch = UB->getNumberOfObjects() > 1;
   for (const MachOUniversalBinary::ObjectForArch &O : UB->objects()) {
     Expected<std::unique_ptr<ObjectFile>> ObjOrErr = O.getAsObjectFile();
     std::string ArchiveName;
     std::string ArchitectureName;
     ArchiveName.clear();
     ArchitectureName.clear();
     if (ObjOrErr) {
       ObjectFile &Obj = *ObjOrErr.get();
       if (isa<MachOObjectFile>(Obj) && moreThanOneArch)
         ArchitectureName = O.getArchFlagName();
-      dumpSymbolNamesFromObject(Obj, /*PrintSymbolObject=*/false,
+      dumpSymbolNamesFromObject(Obj, SymbolList, /*PrintSymbolObject=*/false,
                                 !PrintFileName, ArchiveName, ArchitectureName);
     } else if (auto E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
       error(std::move(E), Filename,
             moreThanOneArch ? StringRef(O.getArchFlagName()) : StringRef());
       continue;
     } else if (Expected<std::unique_ptr<Archive>> AOrErr = O.getAsArchive()) {
       std::unique_ptr<Archive> &A = *AOrErr;
       Error Err = Error::success();
       for (auto &C : A->children(Err)) {
         Expected<std::unique_ptr<Binary>> ChildOrErr =
             C.getAsBinary(ContextPtr);
         if (!ChildOrErr) {
           if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
             error(std::move(E), Filename, C,
                   moreThanOneArch ? StringRef(ArchitectureName) : StringRef());
           continue;
         }
         if (SymbolicFile *F = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
           ArchiveName = std::string(A->getFileName());
           if (isa<MachOObjectFile>(F) && moreThanOneArch)
             ArchitectureName = O.getArchFlagName();
-          dumpSymbolNamesFromObject(*F, /*PrintSymbolObject=*/false,
+          dumpSymbolNamesFromObject(*F, SymbolList, /*PrintSymbolObject=*/false,
                                     !PrintFileName, ArchiveName,
                                     ArchitectureName);
         }
       }
       if (Err)
         error(std::move(Err), A->getFileName());
     } else {
       consumeError(AOrErr.takeError());
       error(Filename + " for architecture " + StringRef(O.getArchFlagName()) +
                 " is not a Mach-O file or an archive file",
             "Mach-O universal file");
     }
   }
 }
 
 static void dumpMachOUniversalBinary(MachOUniversalBinary *UB,
+                                     std::vector<NMSymbol> &SymbolList,
                                      std::string &Filename,
                                      LLVMContext *ContextPtr) {
   // If we have a list of architecture flags specified dump only those.
   if (!ArchAll && !ArchFlags.empty()) {
-    dumpMachOUniversalBinaryMatchArchFlags(UB, Filename, ContextPtr);
+    dumpMachOUniversalBinaryMatchArchFlags(UB, SymbolList, Filename,
+                                           ContextPtr);
     return;
   }
 
   // No architecture flags were specified so if this contains a slice that
   // matches the host architecture dump only that.
-  if (!ArchAll && dumpMachOUniversalBinaryMatchHost(UB, Filename, ContextPtr))
+  if (!ArchAll &&
+      dumpMachOUniversalBinaryMatchHost(UB, SymbolList, Filename, ContextPtr))
     return;
 
   // Either all architectures have been specified or none have been specified
   // and this does not contain the host architecture so dump all the slices.
-  dumpMachOUniversalBinaryArchAll(UB, Filename, ContextPtr);
+  dumpMachOUniversalBinaryArchAll(UB, SymbolList, Filename, ContextPtr);
 }
 
-static void dumpTapiUniversal(TapiUniversal *TU, std::string &Filename) {
+static void dumpTapiUniversal(TapiUniversal *TU,
+                              std::vector<NMSymbol> &SymbolList,
+                              std::string &Filename) {
   for (const TapiUniversal::ObjectForArch &I : TU->objects()) {
     StringRef ArchName = I.getArchFlagName();
     const bool ShowArch =
         ArchFlags.empty() || llvm::is_contained(ArchFlags, ArchName);
     if (!ShowArch)
       continue;
     if (!AddInlinedInfo && !I.isTopLevelLib())
       continue;
     if (auto ObjOrErr = I.getAsObjectFile())
-      dumpSymbolNamesFromObject(*ObjOrErr.get(), /*PrintSymbolObject=*/false,
-                                /*PrintObjectLabel=*/true,
-                                /*ArchiveName=*/{}, ArchName,
-                                I.getInstallName());
+      dumpSymbolNamesFromObject(
+          *ObjOrErr.get(), SymbolList, /*PrintSymbolObject=*/false,
+          /*ArchiveName=*/{}, ArchName, I.getInstallName());
     else if (Error E = isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
       error(std::move(E), Filename, ArchName);
     }
   }
 }
 
-static void dumpSymbolicFile(SymbolicFile *O, std::string &Filename) {
+static void dumpSymbolicFile(SymbolicFile *O, std::vector<NMSymbol> &SymbolList,
+                             std::string &Filename) {
   if (!MachOPrintSizeWarning && PrintSize && isa<MachOObjectFile>(O)) {
     WithColor::warning(errs(), ToolName)
         << "sizes with --print-size for Mach-O files are always zero.\n";
     MachOPrintSizeWarning = true;
   }
   if (!checkMachOAndArchFlags(O, Filename))
     return;
-  dumpSymbolNamesFromObject(*O, /*PrintSymbolObject=*/true,
+  dumpSymbolNamesFromObject(*O, SymbolList, /*PrintSymbolObject=*/true,
                             /*PrintObjectLabel=*/false);
 }
 
-static void dumpSymbolNamesFromFile(std::string &Filename) {
+static void dumpSymbolNamesFromFile(std::string &Filename,
+                                    std::vector<NMSymbol> *SymbolList) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (error(BufferOrErr.getError(), Filename))
     return;
 
   LLVMContext Context;
   LLVMContext *ContextPtr = NoLLVMBitcode ? nullptr : &Context;
   Expected<std::unique_ptr<Binary>> BinaryOrErr =
       createBinary(BufferOrErr.get()->getMemBufferRef(), ContextPtr);
   if (!BinaryOrErr) {
     error(BinaryOrErr.takeError(), Filename);
     return;
   }
   Binary &Bin = *BinaryOrErr.get();
   if (Archive *A = dyn_cast<Archive>(&Bin))
-    dumpArchive(A, Filename, ContextPtr);
+    dumpArchive(A, *SymbolList, Filename, ContextPtr);
   else if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin))
-    dumpMachOUniversalBinary(UB, Filename, ContextPtr);
+    dumpMachOUniversalBinary(UB, *SymbolList, Filename, ContextPtr);
   else if (TapiUniversal *TU = dyn_cast<TapiUniversal>(&Bin))
-    dumpTapiUniversal(TU, Filename);
+    dumpTapiUniversal(TU, *SymbolList, Filename);
   else if (SymbolicFile *O = dyn_cast<SymbolicFile>(&Bin))
-    dumpSymbolicFile(O, Filename);
+    dumpSymbolicFile(O, *SymbolList, Filename);
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   BumpPtrAllocator A;
   StringSaver Saver(A);
   NmOptTable Tbl;
   ToolName = argv[0];
int main(int argc, char **argv) {
   if (InputFilenames.empty())
     InputFilenames.push_back("a.out");
   if (InputFilenames.size() > 1)
     MultipleFiles = true;
 
   if (NoDyldInfo && (AddDyldInfo || DyldInfoOnly))
     error("--no-dyldinfo can't be used with --add-dyldinfo or --dyldinfo-only");
 
-  llvm::for_each(InputFilenames, dumpSymbolNamesFromFile);
+  std::vector<NMSymbol> SymbolList;
+
+  llvm::for_each(InputFilenames, std::bind(dumpSymbolNamesFromFile,
+                                           std::placeholders::_1, &SymbolList));
 
   if (ExportSymbols) {
     // Delete symbols which should not be printed from SymolList.
     SymbolList.erase(
         std::remove_if(SymbolList.begin(), SymbolList.end(),
                        [](const NMSymbol &s) { return !s.shouldPrint(); }),
         SymbolList.end());
-    sortSymbolList();
+    sortSymbolList(SymbolList);
     SymbolList.erase(std::unique(SymbolList.begin(), SymbolList.end()),
                      SymbolList.end());
-    printExportSymbolList();
+    printExportSymbolList(SymbolList);
   }
 
   if (HadError)
     return 1;
 }