[support][llvm-objcopy] Add support for shell wildcards

[rupprecht]

Summary

GNU objcopy accepts the --wildcard flag to allow wildcard matching on symbol-related flags. (Note: it's implicitly true for section flags).

The basic syntax is to allow *, ?, \, and [] which work similarly to how they work in a shell. Additionally, starting a wildcard with ! causes that wildcard to prevent it from matching a flag.

Update GlobPattern in libSupport to handle a few more cases. It does not fully match the fnmatch used by GNU objcopy since named character classes (e.g. [[:digit:]]) are not supported, but this should support most existing use cases (mostly just * is what's used anyway).

[jhenderson]

I've not fully reviewed this yet, and won't get around to it until next week, but I wanted to highlight your own comment from D57517 where you said the following:

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.

We added --regex instead of --wildcard precisely to address the specific use-case @evgeny777 had. I'm not opposed to adding --wildcard, if there are actual users of it who don't want to try to migrate to --regex, but I do wonder about the additional complexity this is introducing, and how likely it is to get the rules wrong, e.g. to do with escaping etc.

llvm/lib/Support/Regex.cpp

214

Why is BracketDepth signed? It can't ever be negative.

218

Looks to me like the comments aren't lined up correctly with their case statements.

255

"<=" -> "="

You assert BracketDepth is not negative elsewhere.

[MaskRay]

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.

I have the same question.

llvm/lib/Support/Regex.cpp

214

BracketDepth should just be a boolean. There is no nested depth. With the current implementation, the pattern [[]* does not match the string [a, while in fnmatch(3) (used by GNU objcopy), it matches.

Windows does not have fnmatch(3). If there were a similar function, Unicode might be its weakness...

To correctly parse brackets used in glob, I think the bracket parsing code should detect [:, [. or [= (
collation-related bracket symbols), and skip all characters until the ending symbol is found.

[rupprecht]

(Will get to the code comments later, just wanted to justify the patch)

In D66613#1642461, @jhenderson wrote:

I've not fully reviewed this yet, and won't get around to it until next week, but I wanted to highlight your own comment from D57517 where you said the following:

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.

We added --regex instead of --wildcard precisely to address the specific use-case @evgeny777 had. I'm not opposed to adding --wildcard, if there are actual users of it who don't want to try to migrate to --regex

IMO --regex is nicer for interactive uses, but when using objcopy in a build script that may be used by different toolchains, with either GNU objcopy or llvm-objcopy, a common denominator is needed. Apparently clang+kernel people need it for some versions of the kernel, and we've had some internal users need this too. (For now, they use llvm-objcopy w/ --regex, but it would be a problem if someone using GNU objcopy in their toolchain needs to depend on their package). I also think it will generally help with the long tail of users that want to try it out.

but I do wonder about the additional complexity this is introducing, and how likely it is to get the rules wrong, e.g. to do with escaping etc.

My concern as well. Please review diligently, I won't take comments about regex bugs personally :)

[nickdesaulniers]

In D66613#1642461, @jhenderson wrote:

! In D66613#1642709, @MaskRay wrote:

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.

I have the same question.

Android/ChromeOS/Google is looking into using llvm substitutes for binutils for their Linux kernels. This feature is needed for us to substitute GNU strip for llvm-strip and GNU objcopy for llvm-objcopy. The upstream Linux kernel has removed the use of these for architectures we ship, but the Long Term Support (LTS) kernels that we will be shipping for the foreseeable future still do. Backporting the removal of these flags in a way that doesn't also backport features (which is against LTS policy) is likely to be tricky, as it would also cause the LTS branches to start to diverge, making future backports to those source files less likely to apply cleanly. I'm not confident we could get those patches accepted upstream. We could always carry them out of tree in Android/ChromeOS/Google, but I'd rather not.

All that not supporting this feature does is delay the use of llvm-objcopy/llvm-strip in a few major Linux distributions for their kernels for a few years.

[rupprecht]

• Split out separate methods for parsing brackets instead of allowing arbitrary nesting.

[rupprecht]

Here are a couple other places using it in the wild:

https://git.ruby-lang.org/ruby.git/tree/template/Makefile.in#n295
https://chromium.googlesource.com/native_client/pnacl-subzero/+/master/pydir/szbuild.py#441
https://github.com/NetBSD/src/blob/trunk/share/mk/bsd.sys.mk#L352

llvm/lib/Support/Regex.cpp

214

Thanks, I missed that edge case.

I've removed the BracketDepth var entirely. I originally did have it as a boolean but it didn't handle the "nested" case of "[[:alpha:]]" (it's not arbitrarily nested, but it is still kind of nested...). It isn't necessary by changing this test case to handle eating all characters until a matching ].

218

Fixed -- this indentation level is forced by clang-format, but it looks better after the case statement rather than before it.

[MaskRay]

I just realized that you can remove the glob (I'd call it glob, not wildcard) change from this patch, and just use lib/Support/Regex.cpp:GlobPattern.

GlobPattern is currently used by lld to do version script/dynamic list matching. In version scripts/dynamic lists, [: and [= are syntax error (ld.bfd), and I don't think anyone using [.. But to make it fully fnmatch(pat, str, 0) capable (in case someone uses character classes like [[:digit:]]), you can add these enhancement to a separate change.

llvm/lib/Support/Regex.cpp

247

character '^' may be slightly better/faster.

268

character ']'

[MaskRay]

llvm/docs/CommandGuide/llvm-objcopy.rst

134

On by default for section-related flags.

This is another thing I'm not sure if we want to do.

I'd like users to specify -w to get wildcard semantics for section options. I checked the ruby/nacl/netbsd links and they all appear to use -w

[alexander-shaposhnikov]

khm, I don't insist, but personally I would split out the changes in lib/Support and the corresponding unit tests into a separate patch

[evgeny777]

I wonder if you can use GlobPattern (llvm/Support/GlobPattern.h) or extend this class. One of the reasons we use it in lld is because of much better performance (see D26241),
This may not be the case for llvm-objcopy, but still using original pattern matcher looks nicer than translating to regexps.

[rupprecht]

• Use GlobPattern instead of Regex
• Log a warning if the glob expression is invalid

[rupprecht]

In D66613#1659632, @alexshap wrote:

khm, I don't insist, but personally I would split out the changes in lib/Support and the corresponding unit tests into a separate patch

Ack; I'll submit them separately, but I'm leaving them together in the patch for now, e.g. to show how the added glob support is needed by llvm-objcopy tests.

In D66613#1643926, @MaskRay wrote:

I just realized that you can remove the glob (I'd call it glob, not wildcard) change from this patch, and just use lib/Support/Regex.cpp:GlobPattern.

GlobPattern is currently used by lld to do version script/dynamic list matching. In version scripts/dynamic lists, [: and [= are syntax error (ld.bfd), and I don't think anyone using [.. But to make it fully fnmatch(pat, str, 0) capable (in case someone uses character classes like [[:digit:]]), you can add these enhancement to a separate change.

In D66613#1703550, @evgeny777 wrote:

I wonder if you can use GlobPattern (llvm/Support/GlobPattern.h) or extend this class. One of the reasons we use it in lld is because of much better performance (see D26241),
This may not be the case for llvm-objcopy, but still using original pattern matcher looks nicer than translating to regexps.

OK, removed the regex transformation and using glob instead.

I decided to leave out character classes for now, so the changes to glob are actually pretty minimal. lld tests are still passing w/ these glob changes. I hope the test coverage is sufficient there.

llvm/docs/CommandGuide/llvm-objcopy.rst

134

Those were just easy-to-find examples of wildcard usage. There are others using wildcards w/o -w, e.g.

https://chromium.googlesource.com/chromiumos/platform/ec/+/refs/heads/master/Makefile.rules#66

cmd_ec_elf_to_flat ?= $(OBJCOPY) --set-section-flags .roshared=share -R .dram* \
				-O binary $< $@
cmd_ec_elf_to_flat_dram ?= $(OBJCOPY) -j .dram* -O binary $< $@

Older kernel versions: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/drivers/firmware/efi/libstub/Makefile?h=linux-4.4.y#n57

STUBCOPY_FLAGS-y		:= -R .debug* -R *ksymtab* -R *kcrctab*

[MaskRay]

llvm/test/tools/llvm-objcopy/ELF/wildcard-syntax.test

2

Move the file-level comment before RUN:

4

The name is wildcard-syntax.test (good). Both wildcard and glob are referred to in this test. Personally I think wildcard is a subset of glob and glob is a better name here - glob is a POSIX specified concept and the function fnmatch that objcopy uses accepts glob, not just wildcard.

Unify the naming here.

22

What does --remove-section='.???' --remove-section='!.f*' --remove-section='.???' do?

26

Full stop.

27

If llvm-objcopy called setlocale, RE Bracket Expression (also used by glob) would be non-portable (behaviors of locales other than the POSIX locale are unspecified).

Just for fun, glibc>=2.27 make w and v have the same collating order and a w test may fail in the Swedish locale (if regex matching is used): https://sourceware.org/bugzilla/show_bug.cgi?id=23393 (Comment #41 said this is basically a wontfix)

In any case, llvm-objcopy does not call setlocale, w not used in the test, nor do we use regex, so we are good.

74

Probably add a section named z to enhance the test.

llvm/tools/llvm-objcopy/CopyConfig.h

109

If ErrorCallback is not stored, consider llvm::function_ref.

113

Remove some return

[rupprecht]

• Remove returns that don't compile
• std::function -> llvm::function_ref
• Update docs
• Fix punctuation
• Clarify wildcard vs glob
• Use better check prefixes
• Change letters to avoid any locale issues

[rupprecht]

llvm/test/tools/llvm-objcopy/ELF/wildcard-syntax.test

4

Done; I've kept it as "wildcard" when talking about the flag name, and also once to mention "shell wildcard" which it's commonly referred to as, but generally I've updated to "glob syntax"

22

Flag ordering doesn't matter, the algorithm (which GNU objcopy seems to do as well) is to apply the flag if any positive matcher matches and no negative matcher matches. Your example is equivalent to what is written here.

I added some test cases that show this, and I updated the command guide docs.

27

Not going to pretend I totally understand locales, but I'll just use [q-s] (to match the r in bar) to avoid v or w anyway :)

74

I'm not sure it would add that much, but I added it anyway.

The point of this test is that []xyz] is interpreted as "a single character which is one of something in ]xyz" (which matches the ] section), as opposed to "an empty character matcher followed by the literal xyz]".

I added this as a test comment. Also added a section named xyz] to show that it is not removed.

llvm/tools/llvm-objcopy/CopyConfig.h

113

I was wondering how this even compiled, then realized it doesn't :(

[MaskRay]

If you have extra bandwidth, I hope you can raise the issues for projects that use glob in objcopy --*-section but does not pass -w. This patch LG.

[rupprecht]

Turns out treating \ breaks linker scripts on Windows due to path names :(

glob support added in r375051 and immediately reverted in r375052 after a fast buildbot.

[rupprecht]

Planning to reland as-is after D69074

[jhenderson]

Post-commit comments since I've been away and spotted a few relatively minor things. I'll post directly on the commit for the llvm-objcopy side, if I see anything there.

llvm/docs/CommandGuide/llvm-objcopy.rst

135

--regex -> :option:'--regex' (with back-ticks instead of apostrophes).

149

'!' -> `!` for consistency? Not sure.

llvm/docs/CommandGuide/llvm-strip.rst

109

Same comments as llvm-objcopy document.

llvm/lib/Support/GlobPattern.cpp

118 ↗

(On Diff #225474)

Nit: "* -> '*' ?

llvm/unittests/Support/GlobPatternTest.cpp

26 ↗

(On Diff #225474)

This and similar cases should at least be ASSERT_TRUE instead of EXPECT_TRUE. If for some reason a failure is hit, the following lines will attempt to dereference an Expected in a failing state and crash the test rather than simply fail it.

Better however would be to use ASSERT_THAT_EXPECTED(Pat1, Succeeded()); (double-check exact usage, but it's something like that).

124 ↗

(On Diff #225474)

Similar to above, you can use ASSERT_THAT_EXPECTED(Pat2, Failed()); to avoid weird behaviour.

llvm/docs/CommandGuide/llvm-objcopy.rst

 
  Remove from the output all local or undefined symbols that are not required by
  relocations.
 
 .. option:: --version, -V
 
   Display the version of this program.
 
+.. option:: --wildcard, -w
+
+  Allow wildcard syntax for symbol-related flags. On by default for
+  section-related flags. Incompatible with --regex.
+
+  Wildcard syntax allows the following special symbols:
+
+  ====================== ========================= ==================
+   Character              Meaning                   Equivalent
+  ====================== ========================= ==================
+  ``*``                  Any number of characters  ``.*``
+  ``?``                  Any single character      ``.``
+  ``\``                  Escape the next character ``\``
+  ``[a-z]``              Character class           ``[a-z]``
+  ``[!a-z]``, ``[^a-z]`` Negated character class   ``[^a-z]``
+  ====================== ========================= ==================
+
+  Additionally, starting a wildcard with '!' will prevent a match, even if
+  another flag matches. For example ``-w -N '*' -N '!x'`` will strip all symbols
+  except for ``x``.
+
 COFF-SPECIFIC OPTIONS
 ---------------------
 
 The following options are implemented only for COFF objects. If used with other
 objects, :program:`llvm-objcopy` will either emit an error or silently ignore
 them.
 
 .. option:: --only-keep-debug

llvm/docs/CommandGuide/llvm-strip.rst

 .. option:: --strip-unneeded
 
  Remove all local or undefined symbols that are not required by relocations.
 
 .. option:: --version, -V
 
   Display the version of this program.
 
+.. option:: --wildcard, -w
+
+  Allow wildcard syntax for symbol-related flags. On by default for
+  section-related flags. Incompatible with --regex.
+
+  Wildcard syntax allows the following special symbols:
+
+  ====================== ========================= ==================
+   Character              Meaning                   Equivalent
+  ====================== ========================= ==================
+  ``*``                  Any number of characters  ``.*``
+  ``?``                  Any single character      ``.``
+  ``\``                  Escape the next character ``\``
+  ``[a-z]``              Character class           ``[a-z]``
+  ``[!a-z]``, ``[^a-z]`` Negated character class   ``[^a-z]``
+  ====================== ========================= ==================
+
+  Additionally, starting a wildcard with '!' will prevent a match, even if
+  another flag matches. For example ``-w -N '*' -N '!x'`` will strip all symbols
+  except for ``x``.
+
 COFF-SPECIFIC OPTIONS
 ---------------------
 
 The following options are implemented only for COFF objects. If used with other
 objects, :program:`llvm-strip` will either emit an error or silently ignore
 them.
 
 .. option:: --only-keep-debug

llvm/include/llvm/Support/Regex.h

public:
 
     /// If this function returns true, ^Str$ is an extended regular
     /// expression that matches Str and only Str.
     static bool isLiteralERE(StringRef Str);
 
     /// Turn String into a regex by escaping its special characters.
     static std::string escape(StringRef String);
 
+    /// Turn a shell wildcard string into a regular expression by escaping
+    /// non-wildcard special characters and converting wildcard notation to its
+    /// equivalent regular expression notation.
+    static std::string fromShellWildcard(StringRef Wildcard);
+
   private:
     struct llvm_regex *preg;
     int error;
   };
 }
 
 #endif // LLVM_SUPPORT_REGEX_H

llvm/lib/Support/Regex.cpp

std::string Regex::escape(StringRef String) {
   for (unsigned i = 0, e = String.size(); i != e; ++i) {
     if (strchr(RegexMetachars, String[i]))
       RegexStr += '\\';
     RegexStr += String[i];
   }
 
   return RegexStr;
 }
+
+std::string Regex::fromShellWildcard(StringRef Wildcard) {
+  std::string RegexStr;
+
+  int BracketDepth = 0;
+  for (unsigned I = 0, E = Wildcard.size(); I < E; ++I) {
+    assert(BracketDepth >= 0 && "Unexpected negative bracket depth");
+    switch (Wildcard[I]) {
+      // * matches any number of characters.
+    case '*':
+      RegexStr += BracketDepth > 0 ? "*" : ".*";
+      break;
+
+      // ? matches any single character.
+    case '?':
+      RegexStr += BracketDepth > 0 ? "?" : ".";
+      break;
+
+      // [] are treated normally, but the first character can be ! instead of ^
+      // to negate a character class.
+    case '[':
+      ++BracketDepth;
+      RegexStr += "[";
+      if (I + 1 < E && (Wildcard[I + 1] == '!' || Wildcard[I + 1] == '^')) {
+        ++I;
+        RegexStr += "^";
+      }
+      if (I + 1 < E && Wildcard[I + 1] == ']') {
+        ++I;
+        RegexStr += "]";
+      }
+      break;
+    case ']':
+      if (BracketDepth > 0)
+        --BracketDepth;
+      RegexStr += "]";
+      break;
+    case '\\':
+      RegexStr += "\\";
+      if (I + 1 < E) {
+        ++I;
+        RegexStr += Wildcard[I];
+      }
+      break;
+    default:
+      if (BracketDepth <= 0 && strchr(RegexMetachars, Wildcard[I]))
+        RegexStr += "\\";
+      RegexStr += Wildcard[I];
+    }
+  }
+
+  return RegexStr;
+}

llvm/test/tools/llvm-objcopy/ELF/wildcard-flags.test

+# RUN: yaml2obj %s > %t.o
+
+## This test checks basic functionality of shell wildcard matching, as well as
+## verifying all the relevant flags in llvm-objcopy and llvm-strip are
+## configured correctly.
+## For more detailed syntax tests, see wildcard-syntax.test.
+
+## Check that --regex and --wildcard cannot be used together.
+# RUN: not llvm-objcopy --regex --wildcard %t.o %t.err.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=ERR
+# RUN: not llvm-strip --regex --wildcard %t.o -o %t.err.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=ERR
+
+# ERR: error: --regex and --wildcard are incompatible
+
+## Check that section removal flags default to wildcard matches.
+
+## --keep-section:
+# RUN: llvm-objcopy --strip-all --keep-section='.f*' %t.o %t.ksec.1.o
+# RUN: llvm-readobj --sections %t.ksec.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,SEC,FOO-SEC
+# RUN: llvm-strip --strip-all --keep-section='.f*' %t.o -o %t.ksec.2.o
+# RUN: cmp %t.ksec.1.o %t.ksec.2.o
+
+## --only-section:
+# RUN: llvm-objcopy --strip-all --only-section='.f*' %t.o %t.osec.1.o
+# RUN: llvm-readobj --sections %t.osec.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,SEC,FOO-SEC
+
+## --remove-section
+# RUN: llvm-objcopy --strip-debug --remove-section='.s??tab' %t.o %t.rsec.1.o
+# RUN: llvm-readobj --sections %t.rsec.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,SEC,FOO-SEC,BAR-SEC
+# RUN: llvm-strip --strip-debug --remove-section='.s??tab' %t.o -o %t.rsec.2.o
+# RUN: cmp %t.rsec.1.o %t.rsec.2.o
+
+## Check that symbol removal options default to literal matches. Adding -w
+## enables wildcard support for these options.
+
+## --globalize-symbol:
+# RUN: llvm-objcopy --globalize-symbol='*' %t.o %t.globsym.1.o
+# RUN: llvm-readobj --symbols %t.globsym.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,LOCAL,FOO-SYM,BAR-SYM
+
+# RUN: llvm-objcopy -w --globalize-symbol='*' %t.o %t.globsym.2.o
+# RUN: llvm-readobj --symbols %t.globsym.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,GLOBAL,FOO-SYM,BAR-SYM
+
+## --keep-symbol:
+# RUN: llvm-objcopy --discard-all --keep-symbol='f*' %t.o %t.ksym.1.o
+# RUN: llvm-readobj --symbols %t.ksym.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK
+# RUN: llvm-strip --discard-all --keep-symbol='f*' %t.o -o %t.ksym.2.o
+# RUN: cmp %t.ksym.1.o %t.ksym.2.o
+
+# RUN: llvm-objcopy --discard-all -w --keep-symbol='f*' %t.o %t.ksym.3.o
+# RUN: llvm-readobj --symbols %t.ksym.3.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,FOO-SYM
+# RUN: llvm-strip --discard-all -w --keep-symbol='f*' %t.o -o %t.ksym.4.o
+# RUN: cmp %t.ksym.3.o %t.ksym.4.o
+
+## --localize-symbol:
+## Note: Use %t.globsym.2.o instead of %t.o since those symbols are global.
+# RUN: llvm-objcopy --localize-symbol='*' %t.globsym.2.o %t.localsym.1.o
+# RUN: llvm-readobj --symbols %t.localsym.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,GLOBAL,FOO-SYM,BAR-SYM
+
+# RUN: llvm-objcopy -w --localize-symbol='*' %t.globsym.2.o %t.localsym.2.o
+# RUN: llvm-readobj --symbols %t.localsym.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,LOCAL,FOO-SYM,BAR-SYM
+
+## --strip-symbol:
+# RUN: llvm-objcopy --strip-symbol='f*' %t.o %t.stripsym.1.o
+# RUN: llvm-readobj --symbols %t.stripsym.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,FOO-SYM,BAR-SYM
+# RUN: llvm-strip --strip-symbol='f*' %t.o -o %t.stripsym.2.o
+# RUN: cmp %t.stripsym.1.o %t.stripsym.2.o
+
+# RUN: llvm-objcopy -w --strip-symbol='f*' %t.o %t.stripsym.3.o
+# RUN: llvm-readobj --symbols %t.stripsym.3.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,BAR-SYM
+# RUN: llvm-strip -w --strip-symbol='f*' %t.o -o %t.stripsym.4.o
+# RUN: cmp %t.stripsym.3.o %t.stripsym.4.o
+
+## --strip-unneeded-symbol:
+# RUN: llvm-objcopy --strip-unneeded-symbol='f*' %t.o %t.stripunsym.1.o
+# RUN: llvm-readobj --symbols %t.stripunsym.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,FOO-SYM,BAR-SYM
+
+# RUN: llvm-objcopy -w --strip-unneeded-symbol='f*' %t.o %t.stripunsym.2.o
+# RUN: llvm-readobj --symbols %t.stripunsym.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,BAR-SYM
+
+## --weaken-symbol:
+## Note: Use %t.globsym.2.o instead of %t.o since those symbols are global.
+# RUN: llvm-objcopy --weaken-symbol='*' %t.globsym.2.o %t.weaksym.1.o
+# RUN: llvm-readobj --symbols %t.weaksym.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,GLOBAL,FOO-SYM,BAR-SYM
+
+# RUN: llvm-objcopy -w --weaken-symbol='*' %t.globsym.2.o %t.weaksym.2.o
+# RUN: llvm-readobj --symbols %t.weaksym.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,WEAK,FOO-SYM,BAR-SYM
+
+## --keep-global-symbol:
+## Note: Use %t.globsym.2.o instead of %t.o since those symbols are global.
+# RUN: llvm-objcopy --keep-global-symbol='*' %t.globsym.2.o %t.keepgsym.1.o
+# RUN: llvm-readobj --symbols %t.keepgsym.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,LOCAL,FOO-SYM,BAR-SYM
+
+# RUN: llvm-objcopy -w --keep-global-symbol='*' %t.globsym.2.o %t.keepgsym.2.o
+# RUN: llvm-readobj --symbols %t.keepgsym.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: \
+# RUN:       --check-prefixes=CHECK,GLOBAL,FOO-SYM,BAR-SYM
+
+## Check that -w is accepted as an alias for --wildcard.
+# RUN: llvm-objcopy --wildcard --keep-global-symbol='*' %t.globsym.2.o %t.keepgsym.3.o
+# RUN: cmp %t.keepgsym.2.o %t.keepgsym.3.o
+
+# CHECK:   LoadName:
+# CHECK:   Name: (0)
+
+# FOO-SEC: Name: .foo
+
+# FOO-SYM: Name: foo
+# GLOBAL:  Binding: Global
+# WEAK:    Binding: Weak
+# LOCAL:   Binding: Local
+
+# BAR-SEC: Name: .bar
+# BAR-SYM: Name: bar
+# GLOBAL:  Binding: Global
+# WEAK:    Binding: Weak
+# LOCAL:   Binding: Local
+
+# SEC:     Name: .shstrtab
+
+!ELF
+FileHeader:
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  Machine:   EM_X86_64
+Sections:
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+  - Name:    .bar
+    Type:    SHT_PROGBITS
+Symbols:
+  - Name:    foo
+    Type:    STT_FUNC
+    Section: .foo
+  - Name:    bar
+    Type:    STT_FUNC
+    Section: .foo

llvm/test/tools/llvm-objcopy/ELF/wildcard-syntax.test

+# RUN: yaml2obj --docnum=1 %s > %t.o
+
+## This test checks that llvm-objcopy accepts wildcard syntax correctly.
+
+## * matches all characters.
+# RUN: llvm-objcopy --remove-section='.f*' %t.o %t.glob.o
+# RUN: llvm-readobj --sections %t.glob.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,BAR
+
+## Wildcard matches are full matches. ("*a" does not match ".bar")
+# RUN: llvm-objcopy --remove-section='*a' %t.o %t.full.o
+# RUN: llvm-readobj --sections %t.full.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,FOO,BAR
+
+## ? matches one character.
+# RUN: llvm-objcopy --remove-section='.b?r' %t.o %t.question.o
+# RUN: llvm-readobj --sections %t.question.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,FOO
+
+## ! (as a leading character) prevents matches (not dependent on ordering).
+# RUN: llvm-objcopy --remove-section='.???' --remove-section='!.f*' %t.o %t.negmatch.o
+# RUN: llvm-readobj --sections %t.negmatch.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,FOO
+
+## [a-z] matches a range of characters
+# RUN: llvm-objcopy --remove-section='.[a-c][a-a][q-z]' %t.o %t.range.o
+# RUN: llvm-readobj --sections %t.range.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,FOO
+
+## [^a-z] or [!a-z] match a negated range of characters.
+# RUN: llvm-objcopy --remove-section='.[^x]oo' %t.o %t.negrange.1.o
+# RUN: llvm-readobj --sections %t.negrange.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,BAR
+# RUN: llvm-objcopy --remove-section='.[!x]oo' %t.o %t.negrange.2.o
+# RUN: llvm-readobj --sections %t.negrange.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,BAR
+
+--- !ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+Sections:
+  - Name:   .foo
+    Type:   SHT_PROGBITS
+  - Name:   .bar
+    Type:   SHT_PROGBITS
+
+## Use a separate test file with special characters for the following tests.
+# RUN: yaml2obj --docnum=2 %s > %t.special.o
+
+## \ escapes wildcard characters.
+# RUN: llvm-objcopy --remove-section='\*' %t.special.o %t.escape.1.o
+# RUN: llvm-readobj --sections %t.escape.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,DOT,QUESTION,LB,RB,FOO
+# RUN: llvm-objcopy --remove-section='\?' %t.special.o %t.escape.2.o
+# RUN: llvm-readobj --sections %t.escape.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,DOT,GLOB,LB,RB,FOO
+
+## Special characters are not treated like regular expression characters.
+# RUN: llvm-objcopy --remove-section='.' %t.special.o %t.dot.o
+# RUN: llvm-readobj --sections %t.dot.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,GLOB,QUESTION,LB,RB,FOO
+
+## Special characters in character classes are treated literally.
+## [*] should not get expanded to [.*], which would match both '.' and '*'
+# RUN: llvm-objcopy --remove-section='[*]' %t.special.o %t.class.1.o
+# RUN: llvm-readobj --sections %t.class.1.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,DOT,QUESTION,LB,RB,FOO
+
+## ] doesn't close the character class as a first character.
+# RUN: llvm-objcopy --remove-section='[]xyz]' %t.special.o %t.class.2.o
+# RUN: llvm-readobj --sections %t.class.2.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,DOT,GLOB,QUESTION,LB,FOO
+
+## Named classes like [:lower:] work.
+# RUN: llvm-objcopy --remove-section='.f[[:lower:]]o' %t.special.o %t.class.3.o
+# RUN: llvm-readobj --sections %t.class.3.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,DOT,GLOB,QUESTION,LB,RB
+
+## Characters in brackets don't get escaped until the brackets are balanced.
+## This matches either [:lower:] or a literal '*'. The '*' does not get expanded
+## to '.*' which would also match '.'.
+# RUN: llvm-objcopy --remove-section='[[:lower:]*]' %t.special.o %t.class.4.o
+# RUN: llvm-readobj --sections %t.class.4.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,DOT,QUESTION,LB,RB,FOO
+
+--- !ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+Sections:
+  - Name:   .
+    Type:   SHT_PROGBITS
+  - Name:   '*'
+    Type:   SHT_PROGBITS
+  - Name:   '?'
+    Type:   SHT_PROGBITS
+  - Name:   '['
+    Type:   SHT_PROGBITS
+  - Name:   ']'
+    Type:   SHT_PROGBITS
+  - Name:   .foo
+    Type:   SHT_PROGBITS
+
+# CHECK: LoadName:
+# CHECK:     Name: (0)
+# DOT:       Name: .
+# GLOB:      Name: *
+# QUESTION:  Name: ?
+# LB:        Name: [
+# RB:        Name: ]
+# FOO:       Name: .foo
+# BAR:       Name: .bar
+# CHECK:     Name: .symtab
+# CHECK:     Name: .strtab
+# CHECK:     Name: .shstrtab

llvm/tools/llvm-objcopy/CommonOpts.td

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>,
         HelpText<"Alias for --version">;
+
+def wildcard
+    : Flag<["--"], "wildcard">,
+      HelpText<"Allow wildcard syntax for symbol-related flags. Incompatible "
+               "with --regex. Allows using '*' to match any number of "
+               "characters, '?' to match any single character, '\' to escape "
+               "special characters, and '[]' to define character classes. "
+               "Wildcards beginning with '!' will prevent a match, for example "
+               "\"-N '*' -N '!x'\" will strip all symbols except for \"x\".">;
+def w : Flag<["-"], "w">, Alias<wildcard>, HelpText<"Alias for --wildcard">;

llvm/tools/llvm-objcopy/CopyConfig.h

 };
 
 enum class DiscardType {
   None,   // Default
   All,    // --discard-all (-x)
   Locals, // --discard-locals (-X)
 };
 
+enum class MatchStyle {
+  Literal,  // Default for symbols.
+  Wildcard, // Default for sections, or enabled with --wildcard (-w).
+  Regex,    // Enabled with --regex.
+};
+
 class NameOrRegex {
   StringRef Name;
   // Regex is shared between multiple CopyConfig instances.
   std::shared_ptr<Regex> R;
+  bool IsPositiveMatch = true;
 
 public:
-  NameOrRegex(StringRef Pattern, bool IsRegex);
+  NameOrRegex(StringRef Pattern, MatchStyle MS);
+  bool isPositiveMatch() const { return IsPositiveMatch; }
   bool operator==(StringRef S) const { return R ? R->match(S) : Name == S; }
   bool operator!=(StringRef S) const { return !operator==(S); }
 };
 
 // Matcher that checks symbol or section names against the command line flags
 // provided for that option.
 class NameMatcher {
-  std::vector<NameOrRegex> Matchers;
+  std::vector<NameOrRegex> PosMatchers;
+  std::vector<NameOrRegex> NegMatchers;
 
 public:
   void addMatcher(NameOrRegex Matcher) {
-    Matchers.push_back(std::move(Matcher));
+    if (Matcher.isPositiveMatch())
+      PosMatchers.push_back(std::move(Matcher));
+    else
+      NegMatchers.push_back(std::move(Matcher));
+  }
+  bool matches(StringRef S) const {
+    return is_contained(PosMatchers, S) && !is_contained(NegMatchers, S);
   }
-  bool matches(StringRef S) const { return is_contained(Matchers, S); }
-  bool empty() const { return Matchers.empty(); }
+  bool empty() const { return PosMatchers.empty() && NegMatchers.empty(); }
 };
 
 struct NewSymbolInfo {
   StringRef SymbolName;
   StringRef SectionName;
   uint64_t Value = 0;
   uint8_t Type = ELF::STT_NOTYPE;
   uint8_t Bind = ELF::STB_GLOBAL;

llvm/tools/llvm-objcopy/CopyConfig.cpp

else
     // This should never happen because `TargetName` is valid (it certainly
     // exists in the TargetMap).
     llvm_unreachable("unknown target prefix");
 
   return {TargetInfo{Format, MI}};
 }
 
 static Error addSymbolsFromFile(NameMatcher &Symbols, BumpPtrAllocator &Alloc,
-                                StringRef Filename, bool UseRegex) {
+                                StringRef Filename, MatchStyle MS) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
   if (!BufOrErr)
     return createFileError(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.addMatcher({Saver.save(TrimmedLine), UseRegex});
+      Symbols.addMatcher({Saver.save(TrimmedLine), MS});
   }
 
   return Error::success();
 }
 
-NameOrRegex::NameOrRegex(StringRef Pattern, bool IsRegex) {
-  if (!IsRegex) {
+NameOrRegex::NameOrRegex(StringRef Pattern, MatchStyle MS) {
+  switch (MS) {
+  case MatchStyle::Literal:
     Name = Pattern;
-    return;
+    break;
+  case MatchStyle::Wildcard: {
+    SmallVector<char, 32> Data;
+    if (Pattern[0] == '!') {
+      IsPositiveMatch = false;
+      Pattern = Pattern.drop_front();
     }
-
+    R = std::make_shared<Regex>("^" + Regex::fromShellWildcard(Pattern) + "$");
+    break;
+  }
+  case MatchStyle::Regex: {
     SmallVector<char, 32> Data;
     R = std::make_shared<Regex>(
         ("^" + Pattern.ltrim('^').rtrim('$') + "$").toStringRef(Data));
+    break;
+  }
+  }
 }
 
 static Error addSymbolsToRenameFromFile(StringMap<StringRef> &SymbolsToRename,
                                         BumpPtrAllocator &Alloc,
                                         StringRef Filename) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   Config.OutputFilename = Positional[Positional.size() == 1 ? 0 : 1];
   if (InputArgs.hasArg(OBJCOPY_target) &&
       (InputArgs.hasArg(OBJCOPY_input_target) ||
        InputArgs.hasArg(OBJCOPY_output_target)))
     return createStringError(
         errc::invalid_argument,
         "--target cannot be used with --input-target or --output-target");
 
-  bool UseRegex = InputArgs.hasArg(OBJCOPY_regex);
+  if (InputArgs.hasArg(OBJCOPY_regex) && InputArgs.hasArg(OBJCOPY_wildcard))
+    return createStringError(errc::invalid_argument,
+                             "--regex and --wildcard are incompatible");
+
+  MatchStyle SectionMatchStyle = InputArgs.hasArg(OBJCOPY_regex)
+                                     ? MatchStyle::Regex
+                                     : MatchStyle::Wildcard;
+  MatchStyle SymbolMatchStyle = InputArgs.hasArg(OBJCOPY_regex)
+                                    ? MatchStyle::Regex
+                                    : InputArgs.hasArg(OBJCOPY_wildcard)
+                                          ? MatchStyle::Wildcard
+                                          : MatchStyle::Literal;
   StringRef InputFormat, OutputFormat;
   if (InputArgs.hasArg(OBJCOPY_target)) {
     InputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
     OutputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
   } else {
     InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
     OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
   }
if (Config.SetSectionFlags.count(SR.NewName))
       return createStringError(
           errc::invalid_argument,
           "--set-section-flags=%s conflicts with --rename-section=%s=%s",
           SR.NewName.str().c_str(), SR.OriginalName.str().c_str(),
           SR.NewName.str().c_str());
   }
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
-    Config.ToRemove.addMatcher({Arg->getValue(), UseRegex});
+    Config.ToRemove.addMatcher({Arg->getValue(), SectionMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
-    Config.KeepSection.addMatcher({Arg->getValue(), UseRegex});
+    Config.KeepSection.addMatcher({Arg->getValue(), SectionMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_only_section))
-    Config.OnlySection.addMatcher({Arg->getValue(), UseRegex});
+    Config.OnlySection.addMatcher({Arg->getValue(), SectionMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_add_section)) {
     StringRef ArgValue(Arg->getValue());
     if (!ArgValue.contains('='))
       return createStringError(errc::invalid_argument,
                                "bad format for --add-section: missing '='");
     if (ArgValue.split("=").second.empty())
       return createStringError(
           errc::invalid_argument,
Config.DiscardMode =
             : 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);
   if (Config.DiscardMode == DiscardType::All)
     Config.StripDebug = true;
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
-    Config.SymbolsToLocalize.addMatcher({Arg->getValue(), UseRegex});
+    Config.SymbolsToLocalize.addMatcher({Arg->getValue(), SymbolMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToLocalize, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbol))
-    Config.SymbolsToKeepGlobal.addMatcher({Arg->getValue(), UseRegex});
+    Config.SymbolsToKeepGlobal.addMatcher({Arg->getValue(), SymbolMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToKeepGlobal, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbol))
-    Config.SymbolsToGlobalize.addMatcher({Arg->getValue(), UseRegex});
+    Config.SymbolsToGlobalize.addMatcher({Arg->getValue(), SymbolMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToGlobalize, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbol))
-    Config.SymbolsToWeaken.addMatcher({Arg->getValue(), UseRegex});
+    Config.SymbolsToWeaken.addMatcher({Arg->getValue(), SymbolMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToWeaken, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbol))
-    Config.SymbolsToRemove.addMatcher({Arg->getValue(), UseRegex});
+    Config.SymbolsToRemove.addMatcher({Arg->getValue(), SymbolMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToRemove, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbol))
-    Config.UnneededSymbolsToRemove.addMatcher({Arg->getValue(), UseRegex});
+    Config.UnneededSymbolsToRemove.addMatcher(
+        {Arg->getValue(), SymbolMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbols))
     if (Error E = addSymbolsFromFile(Config.UnneededSymbolsToRemove, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbol))
-    Config.SymbolsToKeep.addMatcher({Arg->getValue(), UseRegex});
+    Config.SymbolsToKeep.addMatcher({Arg->getValue(), SymbolMatchStyle});
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToKeep, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_add_symbol)) {
     Expected<NewSymbolInfo> NSI = parseNewSymbolInfo(Arg->getValue());
     if (!NSI)
       return NSI.takeError();
     Config.SymbolsToAdd.push_back(*NSI);
   }
 
if (Positional.empty())
     return createStringError(errc::invalid_argument, "no input file specified");
 
   if (Positional.size() > 1 && InputArgs.hasArg(STRIP_output))
     return createStringError(
         errc::invalid_argument,
         "multiple input files cannot be used in combination with -o");
 
   CopyConfig Config;
-  bool UseRegexp = InputArgs.hasArg(STRIP_regex);
+
+  if (InputArgs.hasArg(STRIP_regex) && InputArgs.hasArg(STRIP_wildcard))
+    return createStringError(errc::invalid_argument,
+                             "--regex and --wildcard are incompatible");
+  MatchStyle SectionMatchStyle =
+      InputArgs.hasArg(STRIP_regex) ? MatchStyle::Regex : MatchStyle::Wildcard;
+  MatchStyle SymbolMatchStyle = InputArgs.hasArg(STRIP_regex)
+                                    ? MatchStyle::Regex
+                                    : InputArgs.hasArg(STRIP_wildcard)
+                                          ? MatchStyle::Wildcard
+                                          : MatchStyle::Literal;
   Config.AllowBrokenLinks = InputArgs.hasArg(STRIP_allow_broken_links);
   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.StripSections = InputArgs.hasArg(STRIP_strip_sections);
   Config.StripUnneeded = InputArgs.hasArg(STRIP_strip_unneeded);
   if (auto Arg = InputArgs.getLastArg(STRIP_strip_all, STRIP_no_strip_all))
     Config.StripAll = Arg->getOption().getID() == STRIP_strip_all;
   Config.StripAllGNU = InputArgs.hasArg(STRIP_strip_all_gnu);
   Config.OnlyKeepDebug = InputArgs.hasArg(STRIP_only_keep_debug);
   Config.KeepFileSymbols = InputArgs.hasArg(STRIP_keep_file_symbols);
 
   for (auto Arg : InputArgs.filtered(STRIP_keep_section))
-    Config.KeepSection.addMatcher({Arg->getValue(), UseRegexp});
+    Config.KeepSection.addMatcher({Arg->getValue(), SectionMatchStyle});
 
   for (auto Arg : InputArgs.filtered(STRIP_remove_section))
-    Config.ToRemove.addMatcher({Arg->getValue(), UseRegexp});
+    Config.ToRemove.addMatcher({Arg->getValue(), SectionMatchStyle});
 
   for (auto Arg : InputArgs.filtered(STRIP_strip_symbol))
-    Config.SymbolsToRemove.addMatcher({Arg->getValue(), UseRegexp});
+    Config.SymbolsToRemove.addMatcher({Arg->getValue(), SymbolMatchStyle});
 
   for (auto Arg : InputArgs.filtered(STRIP_keep_symbol))
-    Config.SymbolsToKeep.addMatcher({Arg->getValue(), UseRegexp});
+    Config.SymbolsToKeep.addMatcher({Arg->getValue(), SymbolMatchStyle});
 
   if (!InputArgs.hasArg(STRIP_no_strip_all) && !Config.StripDebug &&
       !Config.StripUnneeded && Config.DiscardMode == DiscardType::None &&
       !Config.StripAllGNU && Config.SymbolsToRemove.empty())
     Config.StripAll = true;
 
   if (Config.DiscardMode == DiscardType::All)
     Config.StripDebug = true;

llvm/unittests/Support/RegexTest.cpp

TEST_F(RegexTest, IsLiteralERE) {
   EXPECT_FALSE(Regex::isLiteralERE("abc{1,2}"));
 }
 
 TEST_F(RegexTest, Escape) {
   EXPECT_EQ("a\\[bc\\]", Regex::escape("a[bc]"));
   EXPECT_EQ("abc\\{1\\\\,2\\}", Regex::escape("abc{1\\,2}"));
 }
 
+TEST_F(RegexTest, ShellWildcard) {
+  // Globs are converted to '.*'.
+  EXPECT_EQ("a.*b", Regex::fromShellWildcard("a*b"));
+
+  // Single-character wildcard converted to '.'.
+  EXPECT_EQ("a.b", Regex::fromShellWildcard("a?b"));
+
+  // Character classes and negations.
+  EXPECT_EQ("a[x-y]b", Regex::fromShellWildcard("a[x-y]b"));
+  EXPECT_EQ("a[^x-y]b", Regex::fromShellWildcard("a[^x-y]b"));
+  EXPECT_EQ("a[^x-y]b", Regex::fromShellWildcard("a[!x-y]b"));
+
+  // Don't convert wildcard characters inside character classes.
+  EXPECT_EQ("a[*]b", Regex::fromShellWildcard("a[*]b"));
+  EXPECT_EQ("a[x-y*]b", Regex::fromShellWildcard("a[x-y*]b"));
+  EXPECT_EQ("a[^x-y?]b", Regex::fromShellWildcard("a[^x-y?]b"));
+  EXPECT_EQ("a[{}]b", Regex::fromShellWildcard("a[{}]b"));
+  EXPECT_EQ("a[]]b", Regex::fromShellWildcard("a[]]b"));
+  EXPECT_EQ("a[]*]b", Regex::fromShellWildcard("a[]*]b"));
+  EXPECT_EQ("a[^]*]b", Regex::fromShellWildcard("a[^]*]b"));
+
+  // Escapes passed through, and take the next character verbatim.
+  EXPECT_EQ("a\\b", Regex::fromShellWildcard("a\\b"));
+  EXPECT_EQ("a\\*\\?", Regex::fromShellWildcard("a\\*\\?"));
+  EXPECT_EQ("a\\*.*", Regex::fromShellWildcard("a\\**"));
+
+  // Check against underflow for bracket depth.
+  EXPECT_EQ("].*", Regex::fromShellWildcard("]*"));
+  EXPECT_EQ("]\\$", Regex::fromShellWildcard("]$"));
+
+  // Other regular expression characters should be escaped.
+  EXPECT_EQ("\\^x1\\(\\)\\|\\+\\.\\{\\}\\$",
+            Regex::fromShellWildcard("^x1()|+.{}$"));
+}
+
 TEST_F(RegexTest, IsValid) {
   std::string Error;
   EXPECT_FALSE(Regex("(foo").isValid(Error));
   EXPECT_EQ("parentheses not balanced", Error);
   EXPECT_FALSE(Regex("a[b-").isValid(Error));
   EXPECT_EQ("invalid character range", Error);
 }