[ifs] Add --exclude flag

[abrachet]

Summary

Use to remove certain symbols which match the glob pattern. Can be used with --strip-undefined

[haowei]

llvm/tools/llvm-ifs/llvm-ifs.cpp

298

I think it is better to put this back into the IFSHandler.cpp. That file is part of the InterfaceStub library so it can be used by other tools in the future.

[abrachet]

• Add --exclude too
• Move implementation into lib/InterfaceStub

[abrachet]

Rebase

[haowei]

The implementation of the filtering feature LGTM. My concerns is that do we need both 2 flags are needed at the same time. I am not very familiar with the __asan symbols use case so I will ask @mcgrathr and @phosek to comment on this.

[mcgrathr]

Usually when you have these kinds of things they're called include and exclude.
I don't think we have any known use cases for include, just for exclude so it would be sufficient to start with just that feature.

[abrachet]

• Remove --preserve
• Make tests more readable by starting and ending with Symbols: and ... respectively, instead of using CHECK-NOT

[haowei]

LGTM.

Please correct the comments of the test file.
Please wait for @mcgrathr 's approval before you land the change.

llvm/test/tools/llvm-ifs/exclude.test

2

--preserve is already removed from this patch

llvm/include/llvm/InterfaceStub/IFSHandler.h

 
 #ifndef LLVM_INTERFACESTUB_IFSHANDLER_H
 #define LLVM_INTERFACESTUB_IFSHANDLER_H
 
 #include "IFSStub.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include <memory>
+#include <string>
+#include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 class Error;
 class StringRef;
 
 namespace ifs {

 
 /// Validate the target platform inforation in the text stub.
 Error validateIFSTarget(IFSStub &Stub, bool ParseTriple);
 
 /// Strips target platform information from the text stub.
 void stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
                     bool StripEndianness, bool StripBitWidth);
 
-/// Strips symbols from IFS symbol table that are undefined.
-void stripIFSUndefinedSymbols(IFSStub &Stub);
+Error filterIFSSyms(IFSStub &Stub, bool StripUndefined,
+                    const std::vector<std::string> &Exclude = {});
 
 /// Parse llvm triple string into a IFSTarget struct.
 IFSTarget parseTriple(StringRef TripleStr);
 
 } // end namespace ifs
 } // end namespace llvm
 
 #endif // LLVM_INTERFACESTUB_IFSHANDLER_H

llvm/lib/InterfaceStub/IFSHandler.cpp

 //===- IFSHandler.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===-----------------------------------------------------------------------===/
 
 #include "llvm/InterfaceStub/IFSHandler.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/YAMLTraits.h"
+#include <functional>
 
 using namespace llvm;
 using namespace llvm::ifs;
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
 
 namespace llvm {
 namespace yaml {
void ifs::stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
   if (StripTriple) {
     Stub.Target.Triple.reset();
   }
   if (!Stub.Target.Arch && !Stub.Target.BitWidth && !Stub.Target.Endianness) {
     Stub.Target.ObjectFormat.reset();
   }
 }
 
-void ifs::stripIFSUndefinedSymbols(IFSStub &Stub) {
-  for (auto Iter = Stub.Symbols.begin(); Iter != Stub.Symbols.end();) {
-    if (Iter->Undefined) {
-      Iter = Stub.Symbols.erase(Iter);
-    } else {
-      Iter++;
-    }
+Error ifs::filterIFSSyms(IFSStub &Stub, bool StripUndefined,
+                         const std::vector<std::string> &Exclude) {
+  std::function<bool(const IFSSymbol &)> Filter = [](const IFSSymbol &) {
+    return false;
+  };
+
+  if (StripUndefined) {
+    Filter = [Filter](const IFSSymbol &Sym) {
+      return Sym.Undefined || Filter(Sym);
+    };
+
+  for (StringRef Glob : Exclude) {
+    Expected<llvm::GlobPattern> PatternOrErr = llvm::GlobPattern::create(Glob);
+    if (!PatternOrErr)
+      return PatternOrErr.takeError();
+    Filter = [Pattern = *PatternOrErr, Filter](const IFSSymbol &Sym) {
+      return Pattern.match(Sym.Name) || Filter(Sym);
+    };
   }
+
+  llvm::erase_if(Stub.Symbols, Filter);
+
+  return Error::success();
 }

llvm/test/tools/llvm-ifs/exclude.test

+## Test --exclude flag
+
+# RUN: llvm-ifs --input-format=IFS --output-ifs=- --exclude='exclude*' %s | FileCheck %s
+
+# RUN: llvm-ifs --input-format=IFS --output-ifs=- --exclude='exclude*' \
+# RUN: --strip-undefined %s | FileCheck %s --check-prefix=BOTH
+
+# RUN: not llvm-ifs --input-format=IFS --output-ifs=- --exclude='[' %s 2>&1 | \
+# RUN: FileCheck %s --check-prefix=BAD-GLOB
+
+# BAD-GLOB: error: invalid glob pattern: [
+
+--- !ifs-v1
+SoName: somelib.so
+IfsVersion: 3.0
+Symbols:
+  - { Name: dont_exclude, Type: Func, Undefined: true }
+  - { Name: exclude_1, Type: Func }
+  - { Name: exclude_2, Type: Func, Undefined: true }
+  - { Name: no_match_not_undef, Type: Func }
+...
+
+# CHECK:      Symbols:
+# CHECK-NEXT:   - { Name: dont_exclude, Type: Func, Undefined: true }
+# CHECK-NEXT:   - { Name: no_match_not_undef, Type: Func }
+# CHECK-NEXT: ...
+
+# BOTH:       Symbols:
+# BOTH-NEXT:    - { Name: no_match_not_undef, Type: Func }
+# BOTH-NEXT:  ...

llvm/tools/llvm-ifs/llvm-ifs.cpp

cl::opt<bool> StripIFSTarget(
     cl::cat(IfsCategory));
 cl::opt<bool>
     StripUndefined("strip-undefined",
                    cl::desc("Strip undefined symbols from IFS output"),
                    cl::cat(IfsCategory));
 cl::opt<bool> StripNeededLibs("strip-needed",
                               cl::desc("Strip needed libs from output"),
                               cl::cat(IfsCategory));
+cl::list<std::string>
+    ExcludeSyms("exclude",
+                cl::desc("Remove symbols which match the pattern. Can be "
+                         "specified multiple times"),
+                cl::cat(IfsCategory));
 
 cl::opt<std::string>
     SoName("soname",
            cl::desc("Manually set the DT_SONAME entry of any emitted files"),
            cl::value_desc("name"), cl::cat(IfsCategory));
 cl::opt<std::string> OutputFilePath("output",
                                     cl::desc("Output file **DEPRECATED**"),
                                     cl::cat(IfsCategory));
static Error writeIFS(StringRef FilePath, IFSStub &Stub) {
   raw_fd_ostream Out(FilePath, SysErr);
   if (SysErr)
     return createStringError(SysErr, "Couldn't open `%s` for writing",
                              FilePath.data());
   Out << IFSStr;
   return Error::success();
 }
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
   cl::HideUnrelatedOptions({&IfsCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv);
 
   if (InputFilePaths.empty())
     InputFilePaths.push_back("-");
 
   // If input files are more than one, they can only be IFS files.
case FileFormat::IFS: {
               "Triple hint does not match the actual bit width", HintEC));
 
         stripIFSTarget(Stub, true, false, false, false);
         Stub.Target.Triple = OptTargetTripleHint.getValue();
       } else {
         stripIFSTarget(Stub, StripIFSTarget, StripIFSArch,
                        StripIFSEndiannessWidth, StripIFSBitWidth);
       }
-      if (StripUndefined)
-        stripIFSUndefinedSymbols(Stub);
+      if (Error E = filterIFSSyms(Stub, StripUndefined, ExcludeSyms))
+        fatalError(std::move(E));
       Error IFSWriteError = writeIFS(OutputFilePath.getValue(), Stub);
       if (IFSWriteError)
         fatalError(std::move(IFSWriteError));
       break;
     }
     case FileFormat::ELF: {
       Error TargetError = validateIFSTarget(Stub, true);
       if (TargetError)
if (OutputIFSFilePath.getNumOccurrences() == 1) {
               "Triple hint does not match the actual bit width", HintEC));
 
         stripIFSTarget(Stub, true, false, false, false);
         Stub.Target.Triple = OptTargetTripleHint.getValue();
       } else {
         stripIFSTarget(Stub, StripIFSTarget, StripIFSArch,
                        StripIFSEndiannessWidth, StripIFSBitWidth);
       }
-      if (StripUndefined)
-        stripIFSUndefinedSymbols(Stub);
+      if (Error E = filterIFSSyms(Stub, StripUndefined, ExcludeSyms))
+        fatalError(std::move(E));
       Error IFSWriteError = writeIFS(OutputIFSFilePath.getValue(), Stub);
       if (IFSWriteError)
         fatalError(std::move(IFSWriteError));
     }
     if (OutputTBDFilePath.getNumOccurrences() == 1) {
       std::error_code SysErr;
       raw_fd_ostream Out(OutputTBDFilePath, SysErr);
       if (SysErr) {