[llvm-objcopy] Allow using regex in name comparison

[evgeny777]

Summary

This patch implements GNU objcopy -w option, but uses regex instead of glob

[rupprecht]

In general, I think regex is probably a better choice than wildcards, but I'd be wary of pretending to be GNU compatible with -w when it's a different format. Maybe -r would be better, or maybe we don't even need a short arg for this. If we're going to implement it as -w, I think it would be better to actually be wildcards.
i.e. if someone drops llvm-objcopy into their toolchain and somewhere they use -w -G foo*, that means it now only matches things like fooooooo but not foobar (and additionally will now match fo too!)... but it may be a error that takes a while to be exposed. (In general, people assume tools work just fine, and don't always feel the need to write tests).

If we use a different flag, the error will be obvious: it will be "-w is not a valid flag" and exit 1.

Also a question, for others as well: is this a feature we actually want to carry forward? Are there any users of this feature/is it useful? This isn't something I've come across as actually being used, though I'm happy to review it if is.

tools/llvm-objcopy/CopyConfig.h

100 ↗

(On Diff #184512)

Technically, the section flags among these always accept wildcards. -w only affects symbol name matching. I'm fine with this though.

[evgeny777]

Are there any users of this feature/is it useful?

One of such users is myself. I'm using it to strip specific classes (with all methods and data) from relocatable objects and then execute those object files on memory tight embedded platform using OrcJIT. This is pretty specific use case though.

[jhenderson]

In D57517#1380163, @evgeny777 wrote:

Are there any users of this feature/is it useful?

One of such users is myself. I'm using it to strip specific classes (with all methods and data) from relocatable objects and then execute those object files on memory tight embedded platform using OrcJIT. This is pretty specific use case though.

Still sounds like a reasonable use-case anyway. I could see it being useful for library providers too, who want to hide some things in the external interface, though I don't know of any concrete examples.

If we choose to support this (and I'm happy to +1 it), then I think it should only be a long-form switch, with no short-form equivalent. That's because there's a much higher chance of something being added to GNU objcopy in the future with a short alias that causes a clash than for a long-form version.

[evgeny777]

Removed -w

[rupprecht]

In D57517#1380215, @jhenderson wrote:

In D57517#1380163, @evgeny777 wrote:

Are there any users of this feature/is it useful?

One of such users is myself. I'm using it to strip specific classes (with all methods and data) from relocatable objects and then execute those object files on memory tight embedded platform using OrcJIT. This is pretty specific use case though.

Still sounds like a reasonable use-case anyway. I could see it being useful for library providers too, who want to hide some things in the external interface, though I don't know of any concrete examples.

If we choose to support this (and I'm happy to +1 it), then I think it should only be a long-form switch, with no short-form equivalent. That's because there's a much higher chance of something being added to GNU objcopy in the future with a short alias that causes a clash than for a long-form version.

OK, thanks -- just wanted to double check it's useful, and sounds like it is. I'm on board too :)

test/tools/llvm-objcopy/ELF/globalize.test

7 ↗

(On Diff #184726)

nit: please use --regex instead of -regex in these test cases

8 ↗

(On Diff #184726)

In cases where this should be identical to the output of another another command, you can use cmp instead of another readobj | FileCheck, e.g. cmp %t2 %t3

tools/llvm-objcopy/CopyConfig.h

52 ↗

(On Diff #184726)

Can you add a test that just demonstrates regex matching itself?

64 ↗

(On Diff #184726)

It looks like this does regex matching anywhere within the string. I think it might be less error prone if we make it a full string regex match, e.g. special.* -- currently matches not-special. I think we should force the user to write .*special.* if that's what they want.

Python has a similar distinction, re.match vs re.search. I don't think llvm's regex has anything similar builtin, so you may need to manually wrap the expression in ^$.

101 ↗

(On Diff #184726)

It might be worth using StringSaver or something for this, so they can all be StringRef and avoid templating NameOrRegex. I'll take a look since I introduced that nonsense here.

[alexander-shaposhnikov]

tools/llvm-objcopy/CopyConfig.h

53 ↗

(On Diff #184726)

tbh I have mixed feelings regarding this,

1. so basically string comparison is just a particular case of regex - maybe we can simply use Regex and don't need this class ?
2. khm, where is CopyConfig copied ?

[alexander-shaposhnikov]

tools/llvm-objcopy/CopyConfig.h

53 ↗

(On Diff #184726)

although my second thought is that probably it might make sense to have these two cases separate (performance, simplicity of the most popular use case).
However, maybe we can get rid of shared_ptr here ? (movable but non-copyable classes work just fine with the standard containers) i.e. use optional or (probably even better) - Regex has a default "empty" state (i.e. default constructed Regex is in this state), maybe we can just add a method "empty" (or safe bool conversion operator) to Regex

[evgeny777]

tools/llvm-objcopy/CopyConfig.h

53 ↗

(On Diff #184726)

llvm-strip may use multiple CopyConfig instances which differ only in input/output file names.

for (const char *Filename : Positional) {
   Config.InputFilename = Filename;
   Config.OutputFilename = Filename;
   DC.CopyConfigs.push_back(Config);
 }

[alexander-shaposhnikov]

tools/llvm-objcopy/CopyConfig.h

53 ↗

(On Diff #184726)

oh, i see, this is kind of unfortunate, but i see what you are saying.

[evgeny777]

Addressed. I temporarily merged it with D57617

[evgeny777]

Rebased

[jhenderson]

LGTM, with nit fix.

tools/llvm-objcopy/CopyConfig.h

54 ↗

(On Diff #185250)

Nit: mumltiple -> multiple

llvm/trunk/test/tools/llvm-objcopy/ELF/globalize.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objcopy --globalize-symbol Global \
 # RUN:   --globalize-symbol Local \
 # RUN:   --globalize-symbol Weak \
 # RUN:   --globalize-symbol WeakUndef %t %t2
 # RUN: llvm-readobj --symbols %t2 | FileCheck %s
+# RUN: llvm-objcopy --regex --globalize-symbol '.*' %t %t3
+# RUN: cmp %t2 %t3
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-objcopy/ELF/keep-global-symbols.test

 
 # RUN: echo Global2 > %t-globals1.txt
 # RUN: echo "  Global3  " > %t-globals2.txt
 # RUN: echo "Global4 # Global5" >> %t-globals2.txt
 # RUN: echo "  Global5 Global6  " >> %t-globals2.txt
 # RUN: echo "Unknown" >> %t-globals2.txt
 # RUN: echo "   " >> %t-globals2.txt
 # RUN: echo "# File with no symbols" > %t-globals3.txt
+# RUN: echo "^Global[0-9]+([[:space:]]Global6)*$" > %t-globals-regexp.txt
 
 # RUN: llvm-objcopy \
 # RUN:   -G Global1 \
 # RUN:   --keep-global-symbol Global2 \
 # RUN:   --keep-global-symbols %t-globals1.txt \
 # RUN:   --keep-global-symbols %t-globals2.txt \
 # RUN:   -G Local1 \
 # RUN:   --globalize-symbol Local2 \
 # RUN:   -G Weak1 \
 # RUN:   --globalize-symbol Weak2 \
 # RUN:   %t.o %t.2.o
 # RUN: llvm-readobj --elf-output-style=GNU --symbols %t.2.o | FileCheck %s
 
+# RUN: llvm-objcopy  --regex --keep-global-symbols %t-globals-regexp.txt %t.o %t.3.o
+# RUN: llvm-readobj --elf-output-style=GNU --symbols %t.3.o | FileCheck %s --check-prefix=REGEXP
+
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:          .text

 # CHECK-NEXT:      6: {{.*}}  GLOBAL {{.*}} Global1
 # CHECK-NEXT:      7: {{.*}}  GLOBAL {{.*}} Global2
 # CHECK-NEXT:      8: {{.*}}  GLOBAL {{.*}} Global3
 # CHECK-NEXT:      9: {{.*}}  GLOBAL {{.*}} Global4
 # CHECK-NEXT:     10: {{.*}}  GLOBAL {{.*}} Global5 Global6
 # CHECK-NEXT:     11: {{.*}}  GLOBAL {{.*}} UND Global7
 # CHECK-NEXT:     12: {{.*}}  WEAK   {{.*}} Weak1
 # CHECK-NEXT:     13: {{.*}}  GLOBAL {{.*}} Weak2
+
+# REGEXP:           6: {{.*}}  GLOBAL {{.*}} Global1
+# REGEXP-NEXT:      7: {{.*}}  GLOBAL {{.*}} Global2
+# REGEXP-NEXT:      8: {{.*}}  GLOBAL {{.*}} Global3
+# REGEXP-NEXT:      9: {{.*}}  GLOBAL {{.*}} Global4
+# REGEXP-NEXT:     10: {{.*}}  GLOBAL {{.*}} Global5
+# REGEXP-NEXT:     11: {{.*}}  GLOBAL {{.*}} Global6
+# REGEXP-NEXT:     12: {{.*}}  GLOBAL {{.*}} Global5 Global6
+# REGEXP-NEXT:     13: {{.*}}  GLOBAL {{.*}} UND Global7

llvm/trunk/test/tools/llvm-objcopy/ELF/keep-many.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objcopy --strip-non-alloc --keep-section=.test --keep-section=.test3 %t %t2
+# RUN: llvm-objcopy --strip-non-alloc --regex --keep-section='^.test[0-9]+$' %t %t3
 # RUN: llvm-readobj --file-headers --sections %t2 | FileCheck %s
+# RUN: llvm-readobj --file-headers --sections %t3 | FileCheck %s --check-prefix=REGEX
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:            .test
     Type:            SHT_PROGBITS
     Flags:           [ ]
   - Name:            .test2
     Type:            SHT_PROGBITS
     Flags:           [ ]
   - Name:            .test3
     Type:            SHT_PROGBITS
     Flags:           [ ]
 
 
 # CHECK: SectionHeaderCount: 4
 
 # CHECK:     Name: .test
 # CHECK:     Name: .test3
 # CHECK:     Name: .shstrtab
+
+# REGEX: SectionHeaderCount: 4
+# REGEX:     Name: .test2
+# REGEX:     Name: .test3
+# REGEX:     Name: .shstrtab

llvm/trunk/test/tools/llvm-objcopy/ELF/keep-only-section.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objcopy --keep-section=.test2 --only-section=.test %t %t2
 # RUN: llvm-objcopy -j .test --keep-section=.test2 %t %t3
 # RUN: llvm-readobj --file-headers --sections %t2 | FileCheck %s
 # RUN: diff %t2 %t3
+# RUN: llvm-objcopy --regex --keep-section='^.test$'  --only-section='^.test[2-3]+$' %t %t4
+# RUN: llvm-readobj --file-headers --sections %t4 | FileCheck %s --check-prefix=REGEX
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:            .test
     Type:            SHT_PROGBITS
   - Name:            .test2
     Type:            SHT_PROGBITS
   - Name:            .test3
     Type:            SHT_PROGBITS
 
 # CHECK: SectionHeaderCount: 6
 
 # CHECK:     Name: .test
 # CHECK:     Name: .test2
 # CHECK:     Name: .symtab
 # CHECK:     Name: .strtab
 # CHECK:     Name: .shstrtab
+
+# REGEX: SectionHeaderCount: 7
+
+# REGEX:     Name: .test
+# REGEX:     Name: .test2
+# REGEX:     Name: .test3
+# REGEX:     Name: .symtab
+# REGEX:     Name: .strtab
+# REGEX:     Name: .shstrtab

llvm/trunk/test/tools/llvm-objcopy/ELF/keep-symbol.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objcopy --discard-all -K foo --keep-symbol bar %t %t2
 # RUN: llvm-objcopy -K foo -N foo -N bar --keep-symbol bar -N baz %t %t3
+# RUN: llvm-objcopy --discard-all --regex -K '^ba.*' %t %t4
 # RUN: llvm-readobj --symbols %t2 | FileCheck %s
 # RUN: llvm-readobj --symbols %t3 | FileCheck %s
+# RUN: llvm-readobj --symbols %t4 | FileCheck %s --check-prefix=REGEX
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:

 #CHECK-NEXT:    Value: 0x1008
 #CHECK-NEXT:    Size: 8
 #CHECK-NEXT:    Binding: Local
 #CHECK-NEXT:    Type: Function
 #CHECK-NEXT:    Other: 0
 #CHECK-NEXT:    Section: .text
 #CHECK-NEXT:  }
 #CHECK-NEXT:]
+
+#REGEX: Symbols [
+#REGEX-NOT: foo
+#REGEX: Name: bar
+#REGEX: Name: baz
+#REGEX: ]

llvm/trunk/test/tools/llvm-objcopy/ELF/localize.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objcopy \
 # RUN:     --localize-symbol Global \
 # RUN:     -L GlobalUndef \
 # RUN:     -L Local \
 # RUN:     -L Weak \
 # RUN:     -L GlobalCommon \
 # RUN:     %t %t2
 # RUN: llvm-readobj --symbols %t2 | FileCheck %s
+# RUN: llvm-objcopy --regex -L '.*' %t %t3
+# RUN: cmp %t2 %t3
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-objcopy/ELF/regex.test

+# RUN: yaml2obj %s > %t
+
+# No symbol matches, because pattern is implicitly enveloped in '^$'
+# RUN: llvm-objcopy --discard-all --regex -K 'ba' %t %t2
+# RUN: llvm-readobj --symbols %t2 | FileCheck %s --check-prefix=REGEX1
+
+# Symbol 'bar' matches
+# RUN: llvm-objcopy --discard-all --regex -K 'ba.*' %t %t3
+# RUN: llvm-readobj --symbols %t3 | FileCheck %s --check-prefix=REGEX2
+
+# All symbols match
+# RUN: llvm-objcopy --discard-all --regex -K '.*ba.*' %t %t4
+# RUN: llvm-readobj --symbols %t4 | FileCheck %s --check-prefix=REGEX3
+
+# All symbols match
+# RUN: llvm-objcopy --discard-all --regex -K '^([a-z]+)*ba.*$' %t %t5
+# RUN: cmp %t4 %t5
+ 
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000000010
+    Size:            64
+Symbols:
+  Local:
+    - Name:     foobaz
+      Type:     STT_FUNC
+      Section:  .text
+      Value:    0x1000
+      Size:     8
+    - Name:     bar
+      Type:     STT_FUNC
+      Section:  .text
+      Value:    0x1008
+      Size:     8
+    - Name:     rebar
+      Type:     STT_FUNC
+      Section:  .text
+      Value:    0x1010
+      Size:     8
+
+#REGEX1-NOT: foobaz
+#REGEX1-NOT: bar
+#REGEX1-NOT: rebar
+
+#REGEX2-NOT: foobaz
+#REGEX2: bar
+#REGEX2-NOT: rebar
+
+#REGEX3: foobaz
+#REGEX3: bar
+#REGEX3: rebar

llvm/trunk/test/tools/llvm-objcopy/ELF/remove-section.test

 # RUN: yaml2obj %s > %t
 # RUN: cp %t %t1
 
 # RUN: llvm-objcopy -R .test2 %t %t2
 # RUN: llvm-readobj --file-headers --sections %t2 | FileCheck %s
 
 # Verify that the first run of llvm-objcopy
 # has not modified the input binary.
 # RUN: cmp %t %t1
 
 # RUN: llvm-objcopy --remove-section=.test2 %t1 %t3
 # RUN: cmp %t2 %t3
 
+# RUN: llvm-objcopy --regex --remove-section='.test[0-9]+' %t %t4
+# RUN: llvm-readobj --file-headers --sections %t4 | FileCheck %s --check-prefix=REGEX
+
+
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:            .test1

 # CHECK:     Offset:
 # CHECK:     Size:
 # CHECK:     Link: 0
 # CHECK:     Info: 0
 # CHECK:     AddressAlignment: 1
 # CHECK:     EntrySize: 0
 # CHECK:   }
 # CHECK: ]
+
+# REGEX: SectionHeaderCount: 4
+# REGEX: Sections [
+# REGEX-NOT: test  

llvm/trunk/test/tools/llvm-objcopy/ELF/strip-symbol.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objcopy --strip-symbol baz -N bar %t %t2
 # RUN: llvm-readobj --symbols --sections %t2 | FileCheck %s
 # RUN: llvm-strip --strip-symbol baz -N bar %t -o %t3
-# RUN: llvm-readobj --symbols --sections %t3 | FileCheck %s
+# RUN: cmp %t2 %t3
+# RUN: llvm-strip --regex --strip-symbol '^b.*' -N bar %t -o %t4
+# RUN: cmp %t3 %t4
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-objcopy/ELF/weaken.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objcopy --weaken-symbol Global -W Local -W Weak %t %t2
 # RUN: llvm-readobj --symbols %t2 | FileCheck %s
+# RUN: llvm-objcopy --regex --weaken-symbol '.*' %t %t3
+# RUN: cmp %t2 %t3
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:

llvm/trunk/tools/llvm-objcopy/CopyConfig.h

 #define LLVM_TOOLS_LLVM_OBJCOPY_COPY_CONFIG_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/Regex.h"
 // Necessary for llvm::DebugCompressionType::None
 #include "llvm/Target/TargetOptions.h"
 #include <vector>
 
 namespace llvm {
 namespace objcopy {
 
 // This type keeps track of the machine info for various architectures. This

 };
 
 enum class DiscardType {
   None,   // Default
   All,    // --discard-all (-x)
   Locals, // --discard-locals (-X)
 };
 
+class NameOrRegex {
+  StringRef Name;
+  // Regex is shared between multiple CopyConfig instances.
+  std::shared_ptr<Regex> R;
+
+public:
+  NameOrRegex(StringRef Pattern, bool IsRegex);
+  bool operator==(StringRef S) const { return R ? R->match(S) : Name == S; }
+  bool operator!=(StringRef S) const { return !operator==(S); }
+};
+
 // Configuration for copying/stripping a single file.
 struct CopyConfig {
   // Main input/output options
   StringRef InputFilename;
   StringRef InputFormat;
   StringRef OutputFilename;
   StringRef OutputFormat;
 
struct CopyConfig {
   Optional<StringRef> BuildIdLinkOutput;
   StringRef SplitDWO;
   StringRef SymbolsPrefix;
   DiscardType DiscardMode = DiscardType::None;
 
   // Repeated options
   std::vector<StringRef> AddSection;
   std::vector<StringRef> DumpSection;
-  std::vector<StringRef> KeepSection;
-  std::vector<StringRef> OnlySection;
-  std::vector<StringRef> SymbolsToGlobalize;
-  std::vector<StringRef> SymbolsToKeep;
-  std::vector<StringRef> SymbolsToLocalize;
-  std::vector<StringRef> SymbolsToRemove;
-  std::vector<StringRef> SymbolsToWeaken;
-  std::vector<StringRef> ToRemove;
-  std::vector<StringRef> SymbolsToKeepGlobal;
+  std::vector<NameOrRegex> KeepSection;
+  std::vector<NameOrRegex> OnlySection;
+  std::vector<NameOrRegex> SymbolsToGlobalize;
+  std::vector<NameOrRegex> SymbolsToKeep;
+  std::vector<NameOrRegex> SymbolsToLocalize;
+  std::vector<NameOrRegex> SymbolsToRemove;
+  std::vector<NameOrRegex> SymbolsToWeaken;
+  std::vector<NameOrRegex> ToRemove;
+  std::vector<NameOrRegex> SymbolsToKeepGlobal;
 
   // Map options
   StringMap<SectionRename> SectionsToRename;
   StringMap<SectionFlagsUpdate> SetSectionFlags;
   StringMap<StringRef> SymbolsToRename;
 
   // Boolean options
   bool DeterministicArchives = true;

llvm/trunk/tools/llvm-objcopy/CopyConfig.cpp

 
 static const MachineInfo &getOutputFormatMachineInfo(StringRef Format) {
   auto Iter = OutputFormatMap.find(Format);
   if (Iter == std::end(OutputFormatMap))
     error("Invalid output format: '" + Format + "'");
   return Iter->getValue();
 }
 
-static void addGlobalSymbolsFromFile(std::vector<StringRef> &Symbols,
+static void addGlobalSymbolsFromFile(std::vector<NameOrRegex> &Symbols,
                                      BumpPtrAllocator &Alloc,
-                                     StringRef Filename) {
+                                     StringRef Filename, bool UseRegex) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
   if (!BufOrErr)
     reportError(Filename, BufOrErr.getError());
 
   BufOrErr.get()->getBuffer().split(Lines, '\n');
   for (StringRef Line : Lines) {
     // Ignore everything after '#', trim whitespace, and only add the symbol if
     // it's not empty.
     auto TrimmedLine = Line.split('#').first.trim();
     if (!TrimmedLine.empty())
-      Symbols.push_back(Saver.save(TrimmedLine));
+      Symbols.emplace_back(Saver.save(TrimmedLine), UseRegex);
   }
 }
 
+NameOrRegex::NameOrRegex(StringRef Pattern, bool IsRegex) {
+  if (!IsRegex) {
+    Name = Pattern;
+    return;
+  }
+
+  SmallVector<char, 32> Data;
+  R = std::make_shared<Regex>(
+      ("^" + Pattern.ltrim('^').rtrim('$') + "$").toStringRef(Data));
+}
+
 // ParseObjcopyOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseObjcopyOptions will print the help messege and
 // exit.
 DriverConfig parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   DriverConfig DC;
   ObjcopyOptTable T;
   unsigned MissingArgumentIndex, MissingArgumentCount;
   llvm::opt::InputArgList InputArgs =
DriverConfig parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   CopyConfig Config;
   Config.InputFilename = Positional[0];
   Config.OutputFilename = Positional[Positional.size() == 1 ? 0 : 1];
   if (InputArgs.hasArg(OBJCOPY_target) &&
       (InputArgs.hasArg(OBJCOPY_input_target) ||
        InputArgs.hasArg(OBJCOPY_output_target)))
     error("--target cannot be used with --input-target or --output-target");
 
+  bool UseRegex = InputArgs.hasArg(OBJCOPY_regex);
   if (InputArgs.hasArg(OBJCOPY_target)) {
     Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
     Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
   } else {
     Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
     Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
   }
   if (Config.InputFormat == "binary") {
if (Config.SetSectionFlags.count(SR.OriginalName))
             SR.NewName);
     if (Config.SetSectionFlags.count(SR.NewName))
       error("--set-section-flags=" + SR.NewName +
             " conflicts with --rename-section=" + SR.OriginalName + "=" +
             SR.NewName);
   }
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
-    Config.ToRemove.push_back(Arg->getValue());
+    Config.ToRemove.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
-    Config.KeepSection.push_back(Arg->getValue());
+    Config.KeepSection.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_only_section))
-    Config.OnlySection.push_back(Arg->getValue());
+    Config.OnlySection.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_add_section))
     Config.AddSection.push_back(Arg->getValue());
   for (auto Arg : InputArgs.filtered(OBJCOPY_dump_section))
     Config.DumpSection.push_back(Arg->getValue());
   Config.StripAll = InputArgs.hasArg(OBJCOPY_strip_all);
   Config.StripAllGNU = InputArgs.hasArg(OBJCOPY_strip_all_gnu);
   Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug);
   Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo);
   Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections);
   Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc);
   Config.StripUnneeded = InputArgs.hasArg(OBJCOPY_strip_unneeded);
   Config.ExtractDWO = InputArgs.hasArg(OBJCOPY_extract_dwo);
   Config.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden);
   Config.Weaken = InputArgs.hasArg(OBJCOPY_weaken);
   if (InputArgs.hasArg(OBJCOPY_discard_all, OBJCOPY_discard_locals))
     Config.DiscardMode =
         InputArgs.hasFlag(OBJCOPY_discard_all, OBJCOPY_discard_locals)
             ? DiscardType::All
             : DiscardType::Locals;
   Config.OnlyKeepDebug = InputArgs.hasArg(OBJCOPY_only_keep_debug);
   Config.KeepFileSymbols = InputArgs.hasArg(OBJCOPY_keep_file_symbols);
   Config.DecompressDebugSections =
       InputArgs.hasArg(OBJCOPY_decompress_debug_sections);
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
-    Config.SymbolsToLocalize.push_back(Arg->getValue());
+    Config.SymbolsToLocalize.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbol))
-    Config.SymbolsToKeepGlobal.push_back(Arg->getValue());
+    Config.SymbolsToKeepGlobal.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbols))
     addGlobalSymbolsFromFile(Config.SymbolsToKeepGlobal, DC.Alloc,
-                             Arg->getValue());
+                             Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbol))
-    Config.SymbolsToGlobalize.push_back(Arg->getValue());
+    Config.SymbolsToGlobalize.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbol))
-    Config.SymbolsToWeaken.push_back(Arg->getValue());
+    Config.SymbolsToWeaken.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbol))
-    Config.SymbolsToRemove.push_back(Arg->getValue());
+    Config.SymbolsToRemove.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbol))
-    Config.SymbolsToKeep.push_back(Arg->getValue());
+    Config.SymbolsToKeep.emplace_back(Arg->getValue(), UseRegex);
 
   Config.DeterministicArchives = InputArgs.hasFlag(
       OBJCOPY_enable_deterministic_archives,
       OBJCOPY_disable_deterministic_archives, /*default=*/true);
 
   Config.PreserveDates = InputArgs.hasArg(OBJCOPY_preserve_dates);
 
   if (Config.DecompressDebugSections &&
DriverConfig parseStripOptions(ArrayRef<const char *> ArgsArr) {
 
   if (Positional.empty())
     error("No input file specified");
 
   if (Positional.size() > 1 && InputArgs.hasArg(STRIP_output))
     error("Multiple input files cannot be used in combination with -o");
 
   CopyConfig Config;
+  bool UseRegexp = InputArgs.hasArg(STRIP_regex);
   Config.StripDebug = InputArgs.hasArg(STRIP_strip_debug);
 
   if (InputArgs.hasArg(STRIP_discard_all, STRIP_discard_locals))
     Config.DiscardMode =
         InputArgs.hasFlag(STRIP_discard_all, STRIP_discard_locals)
             ? DiscardType::All
             : DiscardType::Locals;
   Config.StripUnneeded = InputArgs.hasArg(STRIP_strip_unneeded);
   Config.StripAll = InputArgs.hasArg(STRIP_strip_all);
   Config.StripAllGNU = InputArgs.hasArg(STRIP_strip_all_gnu);
   Config.KeepFileSymbols = InputArgs.hasArg(STRIP_keep_file_symbols);
 
   for (auto Arg : InputArgs.filtered(STRIP_keep_section))
-    Config.KeepSection.push_back(Arg->getValue());
+    Config.KeepSection.emplace_back(Arg->getValue(), UseRegexp);
 
   for (auto Arg : InputArgs.filtered(STRIP_remove_section))
-    Config.ToRemove.push_back(Arg->getValue());
+    Config.ToRemove.emplace_back(Arg->getValue(), UseRegexp);
 
   for (auto Arg : InputArgs.filtered(STRIP_strip_symbol))
-    Config.SymbolsToRemove.push_back(Arg->getValue());
+    Config.SymbolsToRemove.emplace_back(Arg->getValue(), UseRegexp);
 
   for (auto Arg : InputArgs.filtered(STRIP_keep_symbol))
-    Config.SymbolsToKeep.push_back(Arg->getValue());
+    Config.SymbolsToKeep.emplace_back(Arg->getValue(), UseRegexp);
 
   if (!Config.StripDebug && !Config.StripUnneeded &&
       Config.DiscardMode == DiscardType::None && !Config.StripAllGNU && Config.SymbolsToRemove.empty())
     Config.StripAll = true;
 
   Config.DeterministicArchives =
       InputArgs.hasFlag(STRIP_enable_deterministic_archives,
                         STRIP_disable_deterministic_archives, /*default=*/true);

llvm/trunk/tools/llvm-objcopy/ObjcopyOpts.td

 defm build_id_link_input
     : Eq<"build-id-link-input", "Hard-link the input to <dir>/xx/xxx<suffix> "
                                 "name derived from hex build ID">,
       MetaVarName<"suffix">;
 defm build_id_link_output
     : Eq<"build-id-link-output", "Hard-link the output to <dir>/xx/xxx<suffix> "
                                  "name derived from hex build ID">,
       MetaVarName<"suffix">;
+
+def regex
+    : Flag<["-", "--"], "regex">,
+      HelpText<"Permit regular expressions in name comparison">;

llvm/trunk/tools/llvm-objcopy/StripOpts.td

def discard_locals : Flag<["-", "--"], "discard-locals">,
                               "symbols starting with .L)">;
 def X : Flag<["-"], "X">, Alias<discard_locals>;
 
 def discard_all
     : Flag<["-", "--"], "discard-all">,
       HelpText<"Remove all local symbols except file and section symbols">;
 def x : Flag<["-"], "x">, Alias<discard_all>;
 
+def regex
+    : Flag<["-", "--"], "regex">,
+      HelpText<"Permit regular expressions in name comparison">;
+
 def version : Flag<["-", "--"], "version">,
               HelpText<"Print the version and exit.">;
 def V : Flag<["-"], "V">, Alias<version>;