[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 ↗

(On Diff #216686)

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

218 ↗

(On Diff #216686)

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

255 ↗

(On Diff #216686)

"<=" -> "="

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 ↗

(On Diff #216686)

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 ↗

(On Diff #216686)

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 ↗

(On Diff #216686)

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 ↗

(On Diff #216983)

character '^' may be slightly better/faster.

268 ↗

(On Diff #216983)

character ']'

[MaskRay]

llvm/docs/CommandGuide/llvm-objcopy.rst

147

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

147

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

1

Move the file-level comment before RUN:

3

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.

21

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

25

Full stop.

26

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.

73

Probably add a section named z to enhance the test.

llvm/tools/llvm-objcopy/CopyConfig.h

115

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

119

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

3

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"

21

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.

26

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 :)

73

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

119

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

148

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

162

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

llvm/docs/CommandGuide/llvm-strip.rst

110

Same comments as llvm-objcopy document.

llvm/lib/Support/GlobPattern.cpp

118–120

Nit: "* -> '*' ?

llvm/unittests/Support/GlobPatternTest.cpp

26

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

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

llvm/docs/CommandGuide/llvm-objcopy.rst

 .. option:: --version, -V
 
  Display the version of the :program:`llvm-objcopy` executable.
 
 .. option:: @<FILE>
 
  Read command-line options and commands from response file `<FILE>`.
 
+.. 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:: --version, -V
 
  Display the version of the :program:`llvm-strip` executable.
 
 .. option:: @<FILE>
 
  Read command-line options and commands from response file `<FILE>`.
 
+.. 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/GlobPattern.h

 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include <vector>
 
 // This class represents a glob pattern. Supported metacharacters
-// are "*", "?", "[<chars>]" and "[^<chars>]".
+// are "*", "?", "\", "[<chars>]", "[^<chars>]", and "[!<chars>]".
 namespace llvm {
 class BitVector;
 template <typename T> class ArrayRef;
 
 class GlobPattern {
 public:
   static Expected<GlobPattern> create(StringRef Pat);
   bool match(StringRef S) const;

llvm/lib/Support/GlobPattern.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Errc.h"
 
 using namespace llvm;
 
 static bool hasWildcard(StringRef S) {
-  return S.find_first_of("?*[") != StringRef::npos;
+  return S.find_first_of("?*[\\") != StringRef::npos;
 }
 
 // Expands character ranges and returns a bitmap.
 // For example, "a-cf-hz" is expanded to "abcfghz".
 static Expected<BitVector> expand(StringRef S, StringRef Original) {
   BitVector BV(256, false);
 
   // Expand X-Y.
static Expected<BitVector> expand(StringRef S, StringRef Original) {
   }
 
   for (char C : S)
     BV[(uint8_t)C] = true;
   return BV;
 }
 
 // This is a scanner for the glob pattern.
-// A glob pattern token is one of "*", "?", "[<chars>]", "[^<chars>]"
-// (which is a negative form of "[<chars>]"), or a non-meta character.
+// A glob pattern token is one of "*", "?", "\", "[<chars>]", "[^<chars>]"
+// (which is a negative form of "[<chars>]"), "[!<chars>]" (which is
+// equivalent to "[^<chars>]"), or a non-meta character.
 // This function returns the first token in S.
 static Expected<BitVector> scan(StringRef &S, StringRef Original) {
   switch (S[0]) {
   case '*':
     S = S.substr(1);
     // '*' is represented by an empty bitvector.
     // All other bitvectors are 256-bit long.
     return BitVector();
   case '?':
     S = S.substr(1);
     return BitVector(256, true);
   case '[': {
-    size_t End = S.find(']', 1);
+    // ']' is allowed as the first character of a character class. '[]' is
+    // invalid. So, just skip the first character.
+    size_t End = S.find(']', 2);
     if (End == StringRef::npos)
       return make_error<StringError>("invalid glob pattern: " + Original,
                                      errc::invalid_argument);
 
     StringRef Chars = S.substr(1, End - 1);
     S = S.substr(End + 1);
-    if (Chars.startswith("^")) {
+    if (Chars.startswith("^") || Chars.startswith("!")) {
       Expected<BitVector> BV = expand(Chars.substr(1), Original);
       if (!BV)
         return BV.takeError();
       return BV->flip();
     }
     return expand(Chars, Original);
   }
+  case '\\':
+    // Eat this character and fall through below to treat it like a non-meta
+    // character.
+    S = S.substr(1);
+    LLVM_FALLTHROUGH;
   default:
     BitVector BV(256, false);
     BV[(uint8_t)S[0]] = true;
     S = S.substr(1);
     return BV;
   }
 }
 
 Expected<GlobPattern> GlobPattern::create(StringRef S) {
   GlobPattern Pat;
 
   // S doesn't contain any metacharacter,
   // so the regular string comparison should work.
   if (!hasWildcard(S)) {
     Pat.Exact = S;
     return Pat;
   }
 
-  // S is something like "foo*". We can use startswith().
-  if (S.endswith("*") && !hasWildcard(S.drop_back())) {
+  // S is something like "foo*", and the "* is not escaped. We can use
+  // startswith().
+  if (S.endswith("*") && !S.endswith("\\*") && !hasWildcard(S.drop_back())) {
     Pat.Prefix = S.drop_back();
     return Pat;
   }
 
   // S is something like "*foo". We can use endswith().
   if (S.startswith("*") && !hasWildcard(S.drop_front())) {
     Pat.Suffix = S.drop_front();
     return Pat;

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,B3,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,B3,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,B3,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,B3,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,B3,FOO
+
+## An invalid glob expression is interpreted as a literal instead.
+# RUN: llvm-objcopy --remove-section='][]' %t.special.o %t.class.3.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=WARN
+# RUN: llvm-readobj --sections %t.class.3.o \
+# RUN:   | FileCheck %s --implicit-check-not=Name: --check-prefixes=CHECK,DOT,GLOB,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:   '][]'
+    Type:   SHT_PROGBITS
+  - Name:   .foo
+    Type:   SHT_PROGBITS
+
+# WARN: warning: invalid glob pattern: ][]
+
+# CHECK: LoadName:
+# CHECK:     Name: (0)
+# DOT:       Name: .
+# GLOB:      Name: *
+# QUESTION:  Name: ?
+# LB:        Name: [
+# RB:        Name: ]
+# B3:        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

 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/Regex.h"
 // Necessary for llvm::DebugCompressionType::None
 #include "llvm/Target/TargetOptions.h"
 #include <vector>
 
 namespace llvm {
 namespace objcopy {
 

 };
 
 enum class DiscardType {
   None,   // Default
   All,    // --discard-all (-x)
   Locals, // --discard-locals (-X)
 };
 
-class NameOrRegex {
+enum class MatchStyle {
+  Literal,  // Default for symbols.
+  Wildcard, // Default for sections, or enabled with --wildcard (-w).
+  Regex,    // Enabled with --regex.
+};
+
+class NameOrPattern {
   StringRef Name;
   // Regex is shared between multiple CopyConfig instances.
   std::shared_ptr<Regex> R;
+  std::shared_ptr<GlobPattern> G;
+  bool IsPositiveMatch = true;
+
+  NameOrPattern(StringRef N) : Name(N) {}
+  NameOrPattern(std::shared_ptr<Regex> R) : R(R) {}
+  NameOrPattern(std::shared_ptr<GlobPattern> G, bool IsPositiveMatch)
+      : G(G), IsPositiveMatch(IsPositiveMatch) {}
 
 public:
-  NameOrRegex(StringRef Pattern, bool IsRegex);
-  bool operator==(StringRef S) const { return R ? R->match(S) : Name == S; }
+  // ErrorCallback is used to handle recoverable errors. An Error returned
+  // by the callback aborts the parsing and is then returned by this function.
+  static Expected<NameOrPattern>
+  create(StringRef Pattern, MatchStyle MS,
+         std::function<Error(Error)> ErrorCallback);
+
+  bool isPositiveMatch() const { return IsPositiveMatch; }
+  bool operator==(StringRef S) const {
+    return R ? return R->match(S) : G ? return G->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<NameOrPattern> PosMatchers;
+  std::vector<NameOrPattern> NegMatchers;
 
 public:
-  void addMatcher(NameOrRegex Matcher) {
-    Matchers.push_back(std::move(Matcher));
+  Error addMatcher(Expected<NameOrPattern> Matcher) {
+    if (!Matcher)
+      return Matcher.takeError();
+    if (Matcher->isPositiveMatch())
+      PosMatchers.push_back(std::move(*Matcher));
+    else
+      NegMatchers.push_back(std::move(*Matcher));
+    return Error::success();
+  }
+  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(); }
 };
 
 // Configuration for copying/stripping a single file.
 struct CopyConfig {
   // Format-specific options to be initialized lazily when needed.
   Optional<elf::ELFCopyConfig> ELF;
 
   // Main input/output options

 // will contain one or more CopyConfigs.
 struct DriverConfig {
   SmallVector<CopyConfig, 1> CopyConfigs;
   BumpPtrAllocator Alloc;
 };
 
 // ParseObjcopyOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseObjcopyOptions will print the help messege and
-// exit.
-Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr);
+// exit. ErrorCallback is used to handle recoverable errors. An Error returned
+// by the callback aborts the parsing and is then returned by this function.
+Expected<DriverConfig>
+parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
+                    std::function<Error(Error)> ErrorCallback);
 
 // ParseStripOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseStripOptions will print the help messege and
 // exit. ErrorCallback is used to handle recoverable errors. An Error returned
 // by the callback aborts the parsing and is then returned by this function.
 Expected<DriverConfig>
 parseStripOptions(ArrayRef<const char *> ArgsArr,
                   std::function<Error(Error)> ErrorCallback);
 
 } // namespace objcopy
 } // namespace llvm
 
 #endif

llvm/tools/llvm-objcopy/CopyConfig.cpp

 //===- CopyConfig.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 "CopyConfig.h"
+#include "llvm-objcopy.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
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,
+                                std::function<Error(Error)> ErrorCallback) {
   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});
+      if (Error E = Symbols.addMatcher(NameOrPattern::create(
+              Saver.save(TrimmedLine), MS, ErrorCallback)))
+        return E;
   }
 
   return Error::success();
 }
 
-NameOrRegex::NameOrRegex(StringRef Pattern, bool IsRegex) {
-  if (!IsRegex) {
-    Name = Pattern;
-    return;
+Expected<NameOrPattern>
+NameOrPattern::create(StringRef Pattern, MatchStyle MS,
+                      std::function<Error(Error)> ErrorCallback) {
+  switch (MS) {
+  case MatchStyle::Literal:
+    return NameOrPattern(Pattern);
+  case MatchStyle::Wildcard: {
+    SmallVector<char, 32> Data;
+    bool IsPositiveMatch = true;
+    if (Pattern[0] == '!') {
+      IsPositiveMatch = false;
+      Pattern = Pattern.drop_front();
+    }
+    Expected<GlobPattern> GlobOrErr = GlobPattern::create(Pattern);
+
+    // If we couldn't create it as a glob, report the error, but try again with
+    // a literal if the error reporting is non-fatal.
+    if (!GlobOrErr) {
+      if (Error E = ErrorCallback(GlobOrErr.takeError()))
+        return std::move(E);
+      return create(Pattern, MatchStyle::Literal, ErrorCallback);
     }
 
+    return NameOrPattern(std::make_shared<GlobPattern>(*GlobOrErr),
+                         IsPositiveMatch);
+  }
+  case MatchStyle::Regex: {
     SmallVector<char, 32> Data;
-  R = std::make_shared<Regex>(
-      ("^" + Pattern.ltrim('^').rtrim('$') + "$").toStringRef(Data));
+    return NameOrPattern(std::make_shared<Regex>(
+        ("^" + Pattern.ltrim('^').rtrim('$') + "$").toStringRef(Data)));
+  }
+  }
 }
 
 static Error addSymbolsToRenameFromFile(StringMap<StringRef> &SymbolsToRename,
                                         BumpPtrAllocator &Alloc,
                                         StringRef Filename) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
static void printHelp(const opt::OptTable &OptTable, raw_ostream &OS,
   // The CommandLine library has a cl::extrahelp class to support this,
   // but libOption does not have that yet.
   OS << "\nPass @FILE as argument to read options from FILE.\n";
 }
 
 // ParseObjcopyOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseObjcopyOptions will print the help messege and
 // exit.
-Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
+Expected<DriverConfig>
+parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
+                    std::function<Error(Error)> ErrorCallback) {
   DriverConfig DC;
   ObjcopyOptTable T;
   unsigned MissingArgumentIndex, MissingArgumentCount;
   llvm::opt::InputArgList InputArgs =
       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 
   if (InputArgs.size() == 0) {
     printHelp(T, errs(), "llvm-objcopy");
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});
+    if (Error E = Config.ToRemove.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
-    Config.KeepSection.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E = Config.KeepSection.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_only_section))
-    Config.OnlySection.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E = Config.OnlySection.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
+      return std::move(E);
   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});
+    if (Error E = Config.SymbolsToLocalize.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToLocalize, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle,
+                                     ErrorCallback))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbol))
-    Config.SymbolsToKeepGlobal.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E = Config.SymbolsToKeepGlobal.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToKeepGlobal, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle,
+                                     ErrorCallback))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbol))
-    Config.SymbolsToGlobalize.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E = Config.SymbolsToGlobalize.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToGlobalize, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle,
+                                     ErrorCallback))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbol))
-    Config.SymbolsToWeaken.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E = Config.SymbolsToWeaken.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToWeaken, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle,
+                                     ErrorCallback))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbol))
-    Config.SymbolsToRemove.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E = Config.SymbolsToRemove.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToRemove, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle,
+                                     ErrorCallback))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbol))
-    Config.UnneededSymbolsToRemove.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E =
+            Config.UnneededSymbolsToRemove.addMatcher(NameOrPattern::create(
+                Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbols))
     if (Error E = addSymbolsFromFile(Config.UnneededSymbolsToRemove, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+                                     Arg->getValue(), SymbolMatchStyle,
+                                     ErrorCallback))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbol))
-    Config.SymbolsToKeep.addMatcher({Arg->getValue(), UseRegex});
+    if (Error E = Config.SymbolsToKeep.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbols))
-    if (Error E = addSymbolsFromFile(Config.SymbolsToKeep, DC.Alloc,
-                                     Arg->getValue(), UseRegex))
+    if (Error E =
+            addSymbolsFromFile(Config.SymbolsToKeep, DC.Alloc, Arg->getValue(),
+                               SymbolMatchStyle, ErrorCallback))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_add_symbol))
     Config.SymbolsToAdd.push_back(Arg->getValue());
 
   Config.AllowBrokenLinks = InputArgs.hasArg(OBJCOPY_allow_broken_links);
 
   Config.DeterministicArchives = InputArgs.hasFlag(
       OBJCOPY_enable_deterministic_archives,
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});
+    if (Error E = Config.KeepSection.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
+      return std::move(E);
 
   for (auto Arg : InputArgs.filtered(STRIP_remove_section))
-    Config.ToRemove.addMatcher({Arg->getValue(), UseRegexp});
+    if (Error E = Config.ToRemove.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
+      return std::move(E);
 
   for (auto Arg : InputArgs.filtered(STRIP_strip_symbol))
-    Config.SymbolsToRemove.addMatcher({Arg->getValue(), UseRegexp});
+    if (Error E = Config.SymbolsToRemove.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
 
   for (auto Arg : InputArgs.filtered(STRIP_keep_symbol))
-    Config.SymbolsToKeep.addMatcher({Arg->getValue(), UseRegexp});
+    if (Error E = Config.SymbolsToKeep.addMatcher(NameOrPattern::create(
+            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
+      return std::move(E);
 
   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/tools/llvm-objcopy/llvm-objcopy.cpp

cl::ExpandResponseFiles(Saver,
                               ? cl::TokenizeWindowsCommandLine
                               : cl::TokenizeGNUCommandLine,
                           NewArgv);
 
   auto Args = makeArrayRef(NewArgv).drop_front();
 
   Expected<DriverConfig> DriverConfig =
       IsStrip ? parseStripOptions(Args, reportWarning)
-              : parseObjcopyOptions(Args);
+              : parseObjcopyOptions(Args, reportWarning);
   if (!DriverConfig) {
     logAllUnhandledErrors(DriverConfig.takeError(),
                           WithColor::error(errs(), ToolName));
     return 1;
   }
   for (CopyConfig &CopyConfig : DriverConfig->CopyConfigs) {
     if (Error E = executeObjcopy(CopyConfig)) {
       logAllUnhandledErrors(std::move(E), WithColor::error(errs(), ToolName));
       return 1;
     }
   }
 
   return 0;
 }

llvm/unittests/Support/GlobPatternTest.cpp

 //===- llvm/unittest/Support/GlobPatternTest.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/Support/GlobPattern.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 namespace {
 
 class GlobPatternTest : public ::testing::Test {};
 
-TEST_F(GlobPatternTest, Basics) {
+TEST_F(GlobPatternTest, Empty) {
   Expected<GlobPattern> Pat1 = GlobPattern::create("");
   EXPECT_TRUE((bool)Pat1);
   EXPECT_TRUE(Pat1->match(""));
   EXPECT_FALSE(Pat1->match("a"));
+}
+
+TEST_F(GlobPatternTest, Glob) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("ab*c*def");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("abcdef"));
+  EXPECT_TRUE(Pat1->match("abxcxdef"));
+  EXPECT_FALSE(Pat1->match(""));
+  EXPECT_FALSE(Pat1->match("xabcdef"));
+  EXPECT_FALSE(Pat1->match("abcdefx"));
+}
+
+TEST_F(GlobPatternTest, Wildcard) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("a??c");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("axxc"));
+  EXPECT_FALSE(Pat1->match("axxx"));
+  EXPECT_FALSE(Pat1->match(""));
+}
+
+TEST_F(GlobPatternTest, Escape) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("\\*");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("*"));
+  EXPECT_FALSE(Pat1->match("\\*"));
+  EXPECT_FALSE(Pat1->match("a"));
+
+  Expected<GlobPattern> Pat2 = GlobPattern::create("a?\\?c");
+  EXPECT_TRUE((bool)Pat2);
+  EXPECT_TRUE(Pat2->match("ax?c"));
+  EXPECT_FALSE(Pat2->match("axxc"));
+  EXPECT_FALSE(Pat2->match(""));
+}
+
+TEST_F(GlobPatternTest, BasicCharacterClass) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("[abc-fy-z]");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("a"));
+  EXPECT_TRUE(Pat1->match("b"));
+  EXPECT_TRUE(Pat1->match("c"));
+  EXPECT_TRUE(Pat1->match("d"));
+  EXPECT_TRUE(Pat1->match("e"));
+  EXPECT_TRUE(Pat1->match("f"));
+  EXPECT_TRUE(Pat1->match("y"));
+  EXPECT_TRUE(Pat1->match("z"));
+  EXPECT_FALSE(Pat1->match("g"));
+  EXPECT_FALSE(Pat1->match(""));
+}
+
+TEST_F(GlobPatternTest, NegatedCharacterClass) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("[^abc-fy-z]");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("g"));
+  EXPECT_FALSE(Pat1->match("a"));
+  EXPECT_FALSE(Pat1->match("b"));
+  EXPECT_FALSE(Pat1->match("c"));
+  EXPECT_FALSE(Pat1->match("d"));
+  EXPECT_FALSE(Pat1->match("e"));
+  EXPECT_FALSE(Pat1->match("f"));
+  EXPECT_FALSE(Pat1->match("y"));
+  EXPECT_FALSE(Pat1->match("z"));
+  EXPECT_FALSE(Pat1->match(""));
 
-  Expected<GlobPattern> Pat2 = GlobPattern::create("ab*c*def");
+  Expected<GlobPattern> Pat2 = GlobPattern::create("[!abc-fy-z]");
   EXPECT_TRUE((bool)Pat2);
-  EXPECT_TRUE(Pat2->match("abcdef"));
-  EXPECT_TRUE(Pat2->match("abxcxdef"));
+  EXPECT_TRUE(Pat2->match("g"));
+  EXPECT_FALSE(Pat2->match("a"));
+  EXPECT_FALSE(Pat2->match("b"));
+  EXPECT_FALSE(Pat2->match("c"));
+  EXPECT_FALSE(Pat2->match("d"));
+  EXPECT_FALSE(Pat2->match("e"));
+  EXPECT_FALSE(Pat2->match("f"));
+  EXPECT_FALSE(Pat2->match("y"));
+  EXPECT_FALSE(Pat2->match("z"));
   EXPECT_FALSE(Pat2->match(""));
-  EXPECT_FALSE(Pat2->match("xabcdef"));
-  EXPECT_FALSE(Pat2->match("abcdefx"));
+}
+
+TEST_F(GlobPatternTest, BracketFrontOfCharacterClass) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("[]a]x");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("]x"));
+  EXPECT_TRUE(Pat1->match("ax"));
+  EXPECT_FALSE(Pat1->match("a]x"));
+  EXPECT_FALSE(Pat1->match(""));
+}
 
-  Expected<GlobPattern> Pat3 = GlobPattern::create("a??c");
-  EXPECT_TRUE((bool)Pat3);
-  EXPECT_TRUE(Pat3->match("axxc"));
-  EXPECT_FALSE(Pat3->match("axxx"));
-  EXPECT_FALSE(Pat3->match(""));
-
-  Expected<GlobPattern> Pat4 = GlobPattern::create("[abc-fy-z]");
-  EXPECT_TRUE((bool)Pat4);
-  EXPECT_TRUE(Pat4->match("a"));
-  EXPECT_TRUE(Pat4->match("b"));
-  EXPECT_TRUE(Pat4->match("c"));
-  EXPECT_TRUE(Pat4->match("d"));
-  EXPECT_TRUE(Pat4->match("e"));
-  EXPECT_TRUE(Pat4->match("f"));
-  EXPECT_TRUE(Pat4->match("y"));
-  EXPECT_TRUE(Pat4->match("z"));
-  EXPECT_FALSE(Pat4->match("g"));
-  EXPECT_FALSE(Pat4->match(""));
-
-  Expected<GlobPattern> Pat5 = GlobPattern::create("[^abc-fy-z]");
-  EXPECT_TRUE((bool)Pat5);
-  EXPECT_TRUE(Pat5->match("g"));
-  EXPECT_FALSE(Pat5->match("a"));
-  EXPECT_FALSE(Pat5->match("b"));
-  EXPECT_FALSE(Pat5->match("c"));
-  EXPECT_FALSE(Pat5->match("d"));
-  EXPECT_FALSE(Pat5->match("e"));
-  EXPECT_FALSE(Pat5->match("f"));
-  EXPECT_FALSE(Pat5->match("y"));
-  EXPECT_FALSE(Pat5->match("z"));
-  EXPECT_FALSE(Pat5->match(""));
+TEST_F(GlobPatternTest, SpecialCharsInCharacterClass) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("[*?^]");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("*"));
+  EXPECT_TRUE(Pat1->match("?"));
+  EXPECT_TRUE(Pat1->match("^"));
+  EXPECT_FALSE(Pat1->match("*?^"));
+  EXPECT_FALSE(Pat1->match(""));
 }
 
 TEST_F(GlobPatternTest, Invalid) {
   Expected<GlobPattern> Pat1 = GlobPattern::create("[");
   EXPECT_FALSE((bool)Pat1);
   handleAllErrors(Pat1.takeError(), [&](ErrorInfoBase &EIB) {});
+
+  Expected<GlobPattern> Pat2 = GlobPattern::create("[]");
+  EXPECT_FALSE((bool)Pat2);
+  handleAllErrors(Pat2.takeError(), [&](ErrorInfoBase &EIB) {});
 }
 
 TEST_F(GlobPatternTest, ExtSym) {
   Expected<GlobPattern> Pat1 = GlobPattern::create("a*\xFF");
   EXPECT_TRUE((bool)Pat1);
   EXPECT_TRUE(Pat1->match("axxx\xFF"));
   Expected<GlobPattern> Pat2 = GlobPattern::create("[\xFF-\xFF]");
   EXPECT_TRUE((bool)Pat2);
   EXPECT_TRUE(Pat2->match("\xFF"));
 }
 }